/*
The MIT License (MIT)

Copyright © 2025 pacman64

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/

/*
To compile a smaller-sized command-line app, you can use the `go` command as
follows:

go build -ldflags "-s -w" -trimpath si.go
*/

package main

import (
	"bufio"
	"bytes"
	"encoding/base64"
	"errors"
	"io"
	"net"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strings"
)

const info = `
si [options...] [filenames/URIs...]


This app (Show It) shows data using your default web browser by auto-opening
tabs. When reading from stdin, the content-type is auto-detected: data are
then sent right away to the browser via localhost, using a random port among
the available ones.

The localhost connection is available only until all data are transferred:
this means refreshing your browser tab will lose your content, replacing it
with a server-not-found message page.

When given filenames and/or URIs, the browser tabs will point to their paths,
so accidentally reloading them doesn't make their content disappear, unless
those files are actually deleted between reloads.

Dozens of common data-formats are recognized when piped from stdin, such as
  - HTML (web pages)
  - PDF
  - pictures (PNG, JPEG, SVG, WEBP, GIF)
  - audio (AAC, MP3, FLAC, WAV, AU, MIDI)
  - video (MP4, MOV, WEBM, MKV, AVI)
  - JSON
  - generic UTF-8 plain-text

Base64-encoded data URIs are auto-detected and decoded appropriately.

The options are, available both in single and double-dash versions

    -h           show this help message
    -help        show this help message

    -from        declare MIME type, instead of auto-guessing it
    -mime        declare MIME type, instead of auto-guessing it

    -play        autoplay media; useful only for audio/video data
    -autoplay    autoplay media; useful only for audio/video data
`

func main() {
	args := os.Args[1:]
	var cfg config

	for len(args) > 0 {
		if args[0] == `--` {
			args = args[1:]
			break
		}

		if hasAnyPrefix(args[0], `-from=`, `--from=`, `-mime=`, `--mime=`) {
			cfg.From = args[0][strings.IndexByte(args[0], '=')+1:]
			args = args[1:]
			continue
		}

		switch args[0] {
		case `-h`, `--h`, `-help`, `--help`:
			os.Stdout.WriteString(info[1:])
			return

		case `-autoplay`, `--autoplay`, `-play`, `--play`:
			cfg.Autoplay = true
			args = args[1:]

		case `-from`, `--from`, `-mime`, `--mime`:
			if len(args) == 0 {
				os.Stderr.WriteString("missing MIME-type argument\n")
				os.Exit(1)
			}
			cfg.From = args[1]
			args = args[2:]
		}
	}

	nerr := 0

	// show all filenames/URIs given by opening new browser tabs for each
	for _, s := range args {
		s = strings.TrimSpace(s)
		if err := handle(s, cfg); err != nil {
			os.Stderr.WriteString(err.Error())
			os.Stderr.WriteString("\n")
			nerr++
		}
	}

	// serve from stdin only if no filenames were given
	if len(args) == 0 {
		if err := handleInput(os.Stdin, cfg); err != nil {
			os.Stderr.WriteString(err.Error())
			os.Stderr.WriteString("\n")
			nerr++
		}
	}

	// quit in failure if any input clearly failed to show up
	if nerr > 0 {
		os.Exit(1)
	}
}

func hasAnyPrefix(s string, prefixes ...string) bool {
	for _, p := range prefixes {
		if strings.HasPrefix(s, p) {
			return true
		}
	}
	return false
}

// handle shows a filename/URI by operning a new browser tab for it
func handle(s string, cfg config) error {
	// open a new browser window for each URI
	if strings.HasPrefix(s, `https://`) || strings.HasPrefix(s, `http://`) {
		return showURI(s)
	}

	// handle data-URIs
	if strings.HasPrefix(s, `data:`) && strings.Contains(s, `;base64,`) {
		if err := showURI(s); err != nil {
			return err
		}
		return handleInput(strings.NewReader(s), cfg)
	}

	// the browser needs full paths when showing local files
	fpath, err := filepath.Abs(s)
	if err != nil {
		return err
	}

	// open a new browser tab for each full-path filename
	return showURI(`file:///` + fpath)
}

// showURI tries to open the file/url given using the host operating system's
// defaults
func showURI(what string) error {
	const fph = `url.dll,FileProtocolHandler`

	switch runtime.GOOS {
	case `windows`:
		return exec.Command(`rundll32`, fph, what).Run()
	case `darwin`:
		return exec.Command(`open`, what).Run()
	default:
		return exec.Command(`xdg-open`, what).Run()
	}
}

// handleInput specifically handles stdin and data-URIs
func handleInput(r io.Reader, cfg config) error {
	if cfg.From != `` {
		return serveOnce(nil, r, serveConfig{
			ContentType:   cfg.From,
			ContentLength: -1,
			Autoplay:      cfg.Autoplay,
		})
	}

	// before starting the single-request server, try to detect the MIME type
	// by inspecting the first bytes of the stream and matching known filetype
	// starting patterns
	var buf [64]byte
	n, err := r.Read(buf[:])
	if err != nil && err != io.EOF {
		return err
	}
	start := buf[:n]

	// handle data-URI-like inputs
	if bytes.HasPrefix(start, []byte(`data:`)) {
		if bytes.Contains(start, []byte(`;base64,`)) {
			return handleDataURI(start, r, cfg)
		}
	}

	// handle regular data, trying to auto-detect its MIME type using
	// its first few bytes
	mime, ok := detectMIME(start)
	if !ok {
		mime = cfg.From
	}
	if mime == `` {
		mime = `text/plain`
	}

	// remember to precede the partly-used reader with the starting bytes;
	// give a negative/invalid filesize hint, since stream is single-use
	return serveOnce(start, r, serveConfig{
		ContentType:   mime,
		ContentLength: -1,
		Autoplay:      cfg.Autoplay,
	})
}

// handleDataURI handles data-URIs for func handleInput
func handleDataURI(start []byte, r io.Reader, cfg config) error {
	if !bytes.HasPrefix(start, []byte(`data:`)) {
		return errors.New(`invalid data-URI`)
	}

	i := bytes.Index(start, []byte(`;base64,`))
	if i < 0 {
		return errors.New(`invalid data-URI`)
	}

	// force browser to play wave and aiff sounds, instead of
	// showing a useless download-file option
	switch mime := string(start[len(`data:`):i]); mime {
	case `audio/wav`, `audio/wave`, `audio/x-wav`, `audio/aiff`, `audio/x-aiff`:
		before := beforeAudio
		if cfg.Autoplay {
			before = beforeAutoplayAudio
		}

		// surround URI-encoded audio data with a web page only having
		// a media player in it: this is necessary for wave and aiff
		// sounds, since web browsers may insist on a useless download
		// option for those media types
		r = io.MultiReader(
			strings.NewReader(before),
			bytes.NewReader(start),
			r,
			strings.NewReader(afterAudio),
		)

		return serveOnce(nil, r, serveConfig{
			ContentType:   `text/html; charset=UTF-8`,
			ContentLength: -1,
			Autoplay:      cfg.Autoplay,
		})

	case `image/bmp`, `image/x-bmp`:
		// surround URI-encoded bitmap data with a web page only having
		// an image element in it: this is necessary for bitmap pictures,
		// since web browsers may insist on a useless download option for
		// that media type
		r = io.MultiReader(
			strings.NewReader(beforeBitmap),
			bytes.NewReader(start),
			r,
			strings.NewReader(afterBitmap),
		)

		return serveOnce(nil, r, serveConfig{
			ContentType:   `text/html; charset=UTF-8`,
			ContentLength: -1,
			Autoplay:      cfg.Autoplay,
		})

	default:
		start = start[i+len(`;base64,`):]
		r = io.MultiReader(bytes.NewReader(start), r)
		dec := base64.NewDecoder(base64.URLEncoding, r)

		// give a negative/invalid filesize hint, since stream is single-use
		return serveOnce(nil, dec, serveConfig{
			ContentType:   mime,
			ContentLength: -1,
			Autoplay:      cfg.Autoplay,
		})
	}
}

// config is the result of parsing all cmd-line arguments the app was given
type config struct {
	// From is an optional hint for the source data format, and disables
	// type-autodetection when it's non-empty
	From string

	// Autoplay autoplays audio/video data from stdin
	Autoplay bool
}

const (
	fromUsage = `` +
		`declare MIME-type, disabling type-autodetection; ` +
		`use when MIME-type autodetection fails, or to use a ` +
		`charset different from UTF-8`

	mimeUsage     = `alias for option -from`
	playUsage     = `alias for option -autoplay`
	autoplayUsage = `autoplay; useful only when stdin has audio/video data`
)

// serveConfig has all details func serveOnce needs
type serveConfig struct {
	// ContentType is the MIME type of what's being served
	ContentType string

	// ContentLength is the byte-count of what's being served; negative
	// values are ignored
	ContentLength int

	// Autoplay autoplays audio/video data from stdin
	Autoplay bool
}

// makeDotless is similar to filepath.Ext, except its results never start
// with a dot
func makeDotless(s string) string {
	i := strings.LastIndexByte(s, '.')
	if i >= 0 {
		return s[(i + 1):]
	}
	return s
}

// hasPrefixByte is a simpler, single-byte version of bytes.HasPrefix
func hasPrefixByte(b []byte, prefix byte) bool {
	return len(b) > 0 && b[0] == prefix
}

// hasPrefixFold is a case-insensitive bytes.HasPrefix
func hasPrefixFold(s []byte, prefix []byte) bool {
	n := len(prefix)
	return len(s) >= n && bytes.EqualFold(s[:n], prefix)
}

// trimLeadingWhitespace ignores leading space-like symbols: this is useful
// to handle text-based data formats more flexibly
func trimLeadingWhitespace(b []byte) []byte {
	for len(b) > 0 {
		switch b[0] {
		case ' ', '\t', '\n', '\r':
			b = b[1:]
		default:
			return b
		}
	}

	// an empty slice is all that's left, at this point
	return nil
}

const (
	// maxbufsize is the max capacity the HTTP-protocol line-scanners are
	// allowed to reach
	maxbufsize = 128 * 1024

	// beforeAudio starts HTML webpage with just an audio player
	beforeAudio = `<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <link rel="icon" href="data:,">
  <title>wave sound</title>
  <style>
    body { margin: 2rem auto; width: 90vw; }
    audio { margin: auto; width: 100%; }
  </style>
</head>
<body>
  <audio controls autofocus src="`

	// beforeAutoplayAudio starts HTML webpage with just an audio player
	// in autoplay mode
	beforeAutoplayAudio = `<!DOCTYPE html>
	<html>
	<head>
	  <meta charset="UTF-8">
	  <link rel="icon" href="data:,">
	  <title>wave sound</title>
	  <style>
		body { margin: 2rem auto; width: 90vw; }
		audio { margin: auto; width: 100%; }
	  </style>
	</head>
	<body>
	  <audio controls autofocus autoplay src="`

	// afterAudio ends HTML webpage with just an audio player
	afterAudio = "\"></audio>\n</body>\n</html>\n"

	// beforeBitmap starts HTML webpage with just an image
	beforeBitmap = `<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <link rel="icon" href="data:,">
  <title>bitmap image</title>
  <style>
    body { margin: 0.5rem auto; width: 90vw; }
    img { margin: auto; width: 100%; }
  </style>
</head>
<body>
  <img src="`

	// afterBitmap ends HTML webpage with just an image
	afterBitmap = "\"></img>\n</body>\n</html>\n"
)

// serveOnce literally serves a single web request and no more
func serveOnce(start []byte, rest io.Reader, cfg serveConfig) error {
	// pick a random port from the currently-available ones
	srv, err := net.Listen(`tcp`, `127.0.0.1:0`)
	if err != nil {
		return err
	}
	defer srv.Close()

	// open a new browser tab for that localhost port
	err = showURI(`http://` + srv.Addr().String())
	if err != nil {
		return err
	}

	// accept first connection: no need for async as the server quits after
	// its first response
	conn, err := srv.Accept()
	if err != nil {
		return err
	}
	defer conn.Close()

	respond(conn, start, rest, cfg)
	return nil
}

// respond reads/ignores all request headers, and then replies with some
// content given, quitting immediately after
func respond(conn net.Conn, start []byte, rest io.Reader, cfg serveConfig) {
	sc := bufio.NewScanner(conn)
	sc.Buffer(nil, maxbufsize)
	for sc.Scan() && sc.Text() != `` {
		// ignore all request headers
	}

	switch cfg.ContentType {
	case `audio/wav`, `audio/wave`, `audio/x-wav`, `audio/aiff`, `audio/x-aiff`:
		// force browser to play wave and aiff sounds, instead of showing
		// a useless download-file option; encode audio bytes as data-URI
		// in an intermediate buffer

		writePreludeHTTP(conn, `text/html; charset=UTF-8`, -1)
		// emit opening HTML right until <audio controls src="
		if cfg.Autoplay {
			io.WriteString(conn, beforeAutoplayAudio)
		} else {
			io.WriteString(conn, beforeAudio)
		}
		// emit the data-URI
		writeBase64(conn, cfg.ContentType, start, rest)
		// emit closing HTML after data-URI audio
		io.WriteString(conn, afterAudio)
		return

	case `image/bmp`, `image/x-bmp`:
		// force browser to show bitmap pictures, instead of showing a
		// useless download-file option; encode picture bytes as data-URI
		// in an intermediate buffer

		writePreludeHTTP(conn, `text/html; charset=UTF-8`, -1)
		// emit opening HTML right until <img src="
		io.WriteString(conn, beforeBitmap)
		// emit the data-URI
		writeBase64(conn, cfg.ContentType, start, rest)
		// emit closing HTML after data-URI image
		io.WriteString(conn, afterBitmap)
		return

	default:
		writePreludeHTTP(conn, cfg.ContentType, cfg.ContentLength)
		// send the starting bytes used to auto-detect the content-type
		conn.Write(start)
		// send rest of payload at light-speed
		io.Copy(conn, rest)
	}
}

func writePreludeHTTP(conn net.Conn, contentType string, contentLength int) {
	// respond right after the first empty line, which always follows the
	// request's headers
	io.WriteString(conn, "HTTP/1.1 200 OK\r\n")
	io.WriteString(conn, `Content-Type: `)
	io.WriteString(conn, contentType)
	io.WriteString(conn, "\r\n")
	if contentLength > 0 {
		io.WriteString(conn, `Content-Length: `)
		io.WriteString(conn, string(contentLength))
		io.WriteString(conn, "\r\n")
	}

	// prevent download-dialog or auto-download from the browser's part
	io.WriteString(conn, "Content-Disposition: inline\r\n")
	// tell browser this is the last request
	io.WriteString(conn, "Connection: close\r\n")
	// payload starts right after an empty line
	io.WriteString(conn, "\r\n")
}

func writeBase64(conn net.Conn, mimeType string, start []byte, rest io.Reader) {
	// send the data-URI intro
	io.WriteString(conn, `data:`)
	io.WriteString(conn, mimeType)
	io.WriteString(conn, `;base64,`)
	enc := base64.NewEncoder(base64.StdEncoding, conn)
	// base64-encode the starting bytes used to auto-detect the input type
	enc.Write(start)
	// base64-encode the rest of the input
	io.Copy(enc, rest)
	enc.Close()
}

// nameToMIME tries to match a MIME type to a filename, dotted file extension,
// or a dot-less filetype/extension given
func nameToMIME(fname string) (mimeType string, ok bool) {
	// handle dotless file types and filenames alike
	kind, ok := type2mime[makeDotless(fname)]
	return kind, ok
}

// detectMIME guesses the first appropriate MIME type from the first few
// data bytes given: 24 bytes are enough to detect all supported types
func detectMIME(b []byte) (mimeType string, ok bool) {
	t, ok := detectType(b)
	if ok {
		return t, true
	}
	return ``, false
}

// detectType guesses the first appropriate file type for the data given:
// here the type is a a filename extension without the leading dot
func detectType(b []byte) (dotlessExt string, ok bool) {
	// empty data, so there's no way to detect anything
	if len(b) == 0 {
		return ``, false
	}

	// check for plain-text web-document formats case-insensitively
	kind, ok := checkDoc(b)
	if ok {
		return kind, true
	}

	// check data formats which allow any byte at the start
	kind, ok = checkSpecial(b)
	if ok {
		return kind, true
	}

	// check all other supported data formats
	headers := hdrDispatch[b[0]]
	for _, t := range headers {
		if hasPrefixPattern(b[1:], t.Header[1:], cba) {
			return t.Type, true
		}
	}

	// unrecognized data format
	return ``, false
}

// checkDoc tries to guess if the bytes given are the start of HTML, SVG,
// XML, or JSON data
func checkDoc(b []byte) (kind string, ok bool) {
	// ignore leading whitespaces
	b = trimLeadingWhitespace(b)

	// can't detect anything with empty data
	if len(b) == 0 {
		return ``, false
	}

	// handle XHTML documents which don't start with a doctype declaration
	if bytes.Contains(b, doctypeHTML) {
		return html, true
	}

	// handle HTML/SVG/XML documents
	if hasPrefixByte(b, '<') {
		if hasPrefixFold(b, []byte{'<', '?', 'x', 'm', 'l'}) {
			if bytes.Contains(b, []byte{'<', 's', 'v', 'g'}) {
				return svg, true
			}
			return xml, true
		}

		headers := hdrDispatch['<']
		for _, v := range headers {
			if hasPrefixFold(b, v.Header) {
				return v.Type, true
			}
		}
		return ``, false
	}

	// handle JSON with top-level arrays
	if hasPrefixByte(b, '[') {
		// match [", or [[, or [{, ignoring spaces between
		b = trimLeadingWhitespace(b[1:])
		if len(b) > 0 {
			switch b[0] {
			case '"', '[', '{':
				return json, true
			}
		}
		return ``, false
	}

	// handle JSON with top-level objects
	if hasPrefixByte(b, '{') {
		// match {", ignoring spaces between: after {, the only valid syntax
		// which can follow is the opening quote for the expected object-key
		b = trimLeadingWhitespace(b[1:])
		if hasPrefixByte(b, '"') {
			return json, true
		}
		return ``, false
	}

	// checking for a quoted string, any of the JSON keywords, or even a
	// number seems too ambiguous to declare the data valid JSON

	// no web-document format detected
	return ``, false
}

// checkSpecial handles special file-format headers, which should be checked
// before the normal file-type headers, since the first-byte dispatch algo
// doesn't work for these
func checkSpecial(b []byte) (kind string, ok bool) {
	if len(b) >= 8 && bytes.Index(b, []byte{'f', 't', 'y', 'p'}) == 4 {
		for _, t := range specialHeaders {
			if hasPrefixPattern(b[4:], t.Header[4:], cba) {
				return t.Type, true
			}
		}
	}
	return ``, false
}

// hasPrefixPattern works like bytes.HasPrefix, except it allows for a special
// value to signal any byte is allowed on specific spots
func hasPrefixPattern(what []byte, pat []byte, wildcard byte) bool {
	// if the data are shorter than the pattern to match, there's no match
	if len(what) < len(pat) {
		return false
	}

	// use a slice which ensures the pattern length is never exceeded
	what = what[:len(pat)]

	for i, x := range what {
		y := pat[i]
		if x != y && y != wildcard {
			return false
		}
	}
	return true
}

// all the MIME types used/recognized in this package
const (
	aiff    = `audio/aiff`
	au      = `audio/basic`
	avi     = `video/avi`
	avif    = `image/avif`
	bmp     = `image/x-bmp`
	caf     = `audio/x-caf`
	cur     = `image/vnd.microsoft.icon`
	css     = `text/css`
	csv     = `text/csv`
	djvu    = `image/x-djvu`
	elf     = `application/x-elf`
	exe     = `application/vnd.microsoft.portable-executable`
	flac    = `audio/x-flac`
	gif     = `image/gif`
	gz      = `application/gzip`
	heic    = `image/heic`
	htm     = `text/html`
	html    = `text/html`
	ico     = `image/x-icon`
	iso     = `application/octet-stream`
	jpg     = `image/jpeg`
	jpeg    = `image/jpeg`
	js      = `application/javascript`
	json    = `application/json`
	m4a     = `audio/aac`
	m4v     = `video/x-m4v`
	mid     = `audio/midi`
	mov     = `video/quicktime`
	mp4     = `video/mp4`
	mp3     = `audio/mpeg`
	mpg     = `video/mpeg`
	ogg     = `audio/ogg`
	opus    = `audio/opus`
	pdf     = `application/pdf`
	png     = `image/png`
	ps      = `application/postscript`
	psd     = `image/vnd.adobe.photoshop`
	rtf     = `application/rtf`
	sqlite3 = `application/x-sqlite3`
	svg     = `image/svg+xml`
	text    = `text/plain`
	tiff    = `image/tiff`
	tsv     = `text/tsv`
	wasm    = `application/wasm`
	wav     = `audio/x-wav`
	webp    = `image/webp`
	webm    = `video/webm`
	xml     = `application/xml`
	zip     = `application/zip`
	zst     = `application/zstd`
)

// type2mime turns dotless format-names into MIME types
var type2mime = map[string]string{
	`aiff`:    aiff,
	`wav`:     wav,
	`avi`:     avi,
	`jpg`:     jpg,
	`jpeg`:    jpeg,
	`m4a`:     m4a,
	`mp4`:     mp4,
	`m4v`:     m4v,
	`mov`:     mov,
	`png`:     png,
	`avif`:    avif,
	`webp`:    webp,
	`gif`:     gif,
	`tiff`:    tiff,
	`psd`:     psd,
	`flac`:    flac,
	`webm`:    webm,
	`mpg`:     mpg,
	`zip`:     zip,
	`gz`:      gz,
	`zst`:     zst,
	`mp3`:     mp3,
	`opus`:    opus,
	`bmp`:     bmp,
	`mid`:     mid,
	`ogg`:     ogg,
	`html`:    html,
	`htm`:     htm,
	`svg`:     svg,
	`xml`:     xml,
	`rtf`:     rtf,
	`pdf`:     pdf,
	`ps`:      ps,
	`au`:      au,
	`ico`:     ico,
	`cur`:     cur,
	`caf`:     caf,
	`heic`:    heic,
	`sqlite3`: sqlite3,
	`elf`:     elf,
	`exe`:     exe,
	`wasm`:    wasm,
	`iso`:     iso,
	`txt`:     text,
	`css`:     css,
	`csv`:     csv,
	`tsv`:     tsv,
	`js`:      js,
	`json`:    json,
	`geojson`: json,
}

// formatDescriptor ties a file-header pattern to its data-format type
type formatDescriptor struct {
	Header []byte
	Type   string
}

// can be anything: ensure this value differs from all other literal bytes
// in the generic-headers table: failing that, its value could cause subtle
// type-misdetection bugs
const cba = 0xFD // 253, which is > 127, the highest-valued ascii symbol

// dash-streamed m4a format
var m4aDash = []byte{
	cba, cba, cba, cba, 'f', 't', 'y', 'p', 'd', 'a', 's', 'h',
	000, 000, 000, 000, 'i', 's', 'o', '6', 'm', 'p', '4', '1',
}

// format markers with leading wildcards, which should be checked before the
// normal ones: this is to prevent mismatches with the latter types, even
// though you can make probabilistic arguments which suggest these mismatches
// should be very unlikely in practice
var specialHeaders = []formatDescriptor{
	{[]byte{cba, cba, cba, cba, 'f', 't', 'y', 'p', 'M', '4', 'A', ' '}, m4a},
	{[]byte{cba, cba, cba, cba, 'f', 't', 'y', 'p', 'M', '4', 'A', 000}, m4a},
	{[]byte{cba, cba, cba, cba, 'f', 't', 'y', 'p', 'M', 'S', 'N', 'V'}, mp4},
	{[]byte{cba, cba, cba, cba, 'f', 't', 'y', 'p', 'i', 's', 'o', 'm'}, mp4},
	{[]byte{cba, cba, cba, cba, 'f', 't', 'y', 'p', 'm', 'p', '4', '2'}, m4v},
	{[]byte{cba, cba, cba, cba, 'f', 't', 'y', 'p', 'q', 't', ' ', ' '}, mov},
	{[]byte{cba, cba, cba, cba, 'f', 't', 'y', 'p', 'h', 'e', 'i', 'c'}, heic},
	{[]byte{cba, cba, cba, cba, 'f', 't', 'y', 'p', 'a', 'v', 'i', 'f'}, avif},
	{m4aDash, m4a},
}

// sqlite3 database format
var sqlite3db = []byte{
	'S', 'Q', 'L', 'i', 't', 'e', ' ',
	'f', 'o', 'r', 'm', 'a', 't', ' ', '3',
	000,
}

// windows-variant bitmap file-header, which is followed by a byte-counter for
// the 40-byte infoheader which follows that
var winbmp = []byte{
	'B', 'M', cba, cba, cba, cba, cba, cba, cba, cba, cba, cba, cba, cba, 40,
}

// deja-vu document format
var djv = []byte{
	'A', 'T', '&', 'T', 'F', 'O', 'R', 'M', cba, cba, cba, cba, 'D', 'J', 'V',
}

var doctypeHTML = []byte{
	'<', '!', 'D', 'O', 'C', 'T', 'Y', 'P', 'E', ' ', 'h', 't', 'm', 'l',
}

// hdrDispatch groups format-description-groups by their first byte, thus
// shortening total lookups for some data header: notice how the `ftyp` data
// formats aren't handled here, since these can start with any byte, instead
// of the literal value of the any-byte markers they use
var hdrDispatch = [256][]formatDescriptor{
	{
		{[]byte{000, 000, 001, 0xBA}, mpg},
		{[]byte{000, 000, 001, 0xB3}, mpg},
		{[]byte{000, 000, 001, 000}, ico},
		{[]byte{000, 000, 002, 000}, cur},
		{[]byte{000, 'a', 's', 'm'}, wasm},
	}, // 0
	nil, // 1
	nil, // 2
	nil, // 3
	nil, // 4
	nil, // 5
	nil, // 6
	nil, // 7
	nil, // 8
	nil, // 9
	nil, // 10
	nil, // 11
	nil, // 12
	nil, // 13
	nil, // 14
	nil, // 15
	nil, // 16
	nil, // 17
	nil, // 18
	nil, // 19
	nil, // 20
	nil, // 21
	nil, // 22
	nil, // 23
	nil, // 24
	nil, // 25
	{
		{[]byte{0x1A, 0x45, 0xDF, 0xA3}, webm},
	}, // 26
	nil, // 27
	nil, // 28
	nil, // 29
	nil, // 30
	{
		// {[]byte{0x1F, 0x8B, 0x08, 0x08}, gz},
		{[]byte{0x1F, 0x8B, 0x08}, gz},
	}, // 31
	nil, // 32
	nil, // 33 !
	nil, // 34 "
	{
		{[]byte{'#', '!', ' '}, text},
		{[]byte{'#', '!', '/'}, text},
	}, // 35 #
	nil, // 36 $
	{
		{[]byte{'%', 'P', 'D', 'F'}, pdf},
		{[]byte{'%', '!', 'P', 'S'}, ps},
	}, // 37 %
	nil, // 38 &
	nil, // 39 '
	{
		{[]byte{0x28, 0xB5, 0x2F, 0xFD}, zst},
	}, // 40 (
	nil, // 41 )
	nil, // 42 *
	nil, // 43 +
	nil, // 44 ,
	nil, // 45 -
	{
		{[]byte{'.', 's', 'n', 'd'}, au},
	}, // 46 .
	nil, // 47 /
	nil, // 48 0
	nil, // 49 1
	nil, // 50 2
	nil, // 51 3
	nil, // 52 4
	nil, // 53 5
	nil, // 54 6
	nil, // 55 7
	{
		{[]byte{'8', 'B', 'P', 'S'}, psd},
	}, // 56 8
	nil, // 57 9
	nil, // 58 :
	nil, // 59 ;
	{
		// func checkDoc is better for these, since it's case-insensitive
		{doctypeHTML, html},
		{[]byte{'<', 's', 'v', 'g'}, svg},
		{[]byte{'<', 'h', 't', 'm', 'l', '>'}, html},
		{[]byte{'<', 'h', 'e', 'a', 'd', '>'}, html},
		{[]byte{'<', 'b', 'o', 'd', 'y', '>'}, html},
		{[]byte{'<', '?', 'x', 'm', 'l'}, xml},
	}, // 60 <
	nil, // 61 =
	nil, // 62 >
	nil, // 63 ?
	nil, // 64 @
	{
		{djv, djvu},
	}, // 65 A
	{
		{winbmp, bmp},
	}, // 66 B
	nil, // 67 C
	nil, // 68 D
	nil, // 69 E
	{
		{[]byte{'F', 'O', 'R', 'M', cba, cba, cba, cba, 'A', 'I', 'F', 'F'}, aiff},
		{[]byte{'F', 'O', 'R', 'M', cba, cba, cba, cba, 'A', 'I', 'F', 'C'}, aiff},
	}, // 70 F
	{
		{[]byte{'G', 'I', 'F', '8', '7', 'a'}, gif},
		{[]byte{'G', 'I', 'F', '8', '9', 'a'}, gif},
	}, // 71 G
	nil, // 72 H
	{
		{[]byte{'I', 'D', '3', 2}, mp3}, // ID3-format metadata
		{[]byte{'I', 'D', '3', 3}, mp3}, // ID3-format metadata
		{[]byte{'I', 'D', '3', 4}, mp3}, // ID3-format metadata
		{[]byte{'I', 'I', '*', 000}, tiff},
	}, // 73 I
	nil, // 74 J
	nil, // 75 K
	nil, // 76 L
	{
		{[]byte{'M', 'M', 000, '*'}, tiff},
		{[]byte{'M', 'T', 'h', 'd'}, mid},
		{[]byte{'M', 'Z', cba, 000, cba, 000}, exe},
		// {[]byte{'M', 'Z', 0x90, 000, 003, 000}, exe},
		// {[]byte{'M', 'Z', 0x78, 000, 001, 000}, exe},
		// {[]byte{'M', 'Z', 'P', 000, 002, 000}, exe},
	}, // 77 M
	nil, // 78 N
	{
		{[]byte{'O', 'g', 'g', 'S'}, ogg},
	}, // 79 O
	{
		{[]byte{'P', 'K', 003, 004}, zip},
	}, // 80 P
	nil, // 81 Q
	{
		{[]byte{'R', 'I', 'F', 'F', cba, cba, cba, cba, 'W', 'E', 'B', 'P'}, webp},
		{[]byte{'R', 'I', 'F', 'F', cba, cba, cba, cba, 'W', 'A', 'V', 'E'}, wav},
		{[]byte{'R', 'I', 'F', 'F', cba, cba, cba, cba, 'A', 'V', 'I', ' '}, avi},
	}, // 82 R
	{
		{sqlite3db, sqlite3},
	}, // 83 S
	nil, // 84 T
	nil, // 85 U
	nil, // 86 V
	nil, // 87 W
	nil, // 88 X
	nil, // 89 Y
	nil, // 90 Z
	nil, // 91 [
	nil, // 92 \
	nil, // 93 ]
	nil, // 94 ^
	nil, // 95 _
	nil, // 96 `
	nil, // 97 a
	nil, // 98 b
	{
		{[]byte{'c', 'a', 'f', 'f', 000, 001, 000, 000}, caf},
	}, // 99 c
	nil, // 100 d
	nil, // 101 e
	{
		{[]byte{'f', 'L', 'a', 'C'}, flac},
	}, // 102 f
	nil, // 103 g
	nil, // 104 h
	nil, // 105 i
	nil, // 106 j
	nil, // 107 k
	nil, // 108 l
	nil, // 109 m
	nil, // 110 n
	nil, // 111 o
	nil, // 112 p
	nil, // 113 q
	nil, // 114 r
	nil, // 115 s
	nil, // 116 t
	nil, // 117 u
	nil, // 118 v
	nil, // 119 w
	nil, // 120 x
	nil, // 121 y
	nil, // 122 z
	{
		{[]byte{'{', '\\', 'r', 't', 'f'}, rtf},
	}, // 123 {
	nil, // 124 |
	nil, // 125 }
	nil, // 126
	{
		{[]byte{127, 'E', 'L', 'F'}, elf},
	}, // 127
	nil, // 128
	nil, // 129
	nil, // 130
	nil, // 131
	nil, // 132
	nil, // 133
	nil, // 134
	nil, // 135
	nil, // 136
	{
		{[]byte{0x89, 'P', 'N', 'G', 0x0D, 0x0A, 0x1A, 0x0A}, png},
	}, // 137
	nil, // 138
	nil, // 139
	nil, // 140
	nil, // 141
	nil, // 142
	nil, // 143
	nil, // 144
	nil, // 145
	nil, // 146
	nil, // 147
	nil, // 148
	nil, // 149
	nil, // 150
	nil, // 151
	nil, // 152
	nil, // 153
	nil, // 154
	nil, // 155
	nil, // 156
	nil, // 157
	nil, // 158
	nil, // 159
	nil, // 160
	nil, // 161
	nil, // 162
	nil, // 163
	nil, // 164
	nil, // 165
	nil, // 166
	nil, // 167
	nil, // 168
	nil, // 169
	nil, // 170
	nil, // 171
	nil, // 172
	nil, // 173
	nil, // 174
	nil, // 175
	nil, // 176
	nil, // 177
	nil, // 178
	nil, // 179
	nil, // 180
	nil, // 181
	nil, // 182
	nil, // 183
	nil, // 184
	nil, // 185
	nil, // 186
	nil, // 187
	nil, // 188
	nil, // 189
	nil, // 190
	nil, // 191
	nil, // 192
	nil, // 193
	nil, // 194
	nil, // 195
	nil, // 196
	nil, // 197
	nil, // 198
	nil, // 199
	nil, // 200
	nil, // 201
	nil, // 202
	nil, // 203
	nil, // 204
	nil, // 205
	nil, // 206
	nil, // 207
	nil, // 208
	nil, // 209
	nil, // 210
	nil, // 211
	nil, // 212
	nil, // 213
	nil, // 214
	nil, // 215
	nil, // 216
	nil, // 217
	nil, // 218
	nil, // 219
	nil, // 220
	nil, // 221
	nil, // 222
	nil, // 223
	nil, // 224
	nil, // 225
	nil, // 226
	nil, // 227
	nil, // 228
	nil, // 229
	nil, // 230
	nil, // 231
	nil, // 232
	nil, // 233
	nil, // 234
	nil, // 235
	nil, // 236
	nil, // 237
	nil, // 238
	nil, // 239
	nil, // 240
	nil, // 241
	nil, // 242
	nil, // 243
	nil, // 244
	nil, // 245
	nil, // 246
	nil, // 247
	nil, // 248
	nil, // 249
	nil, // 250
	nil, // 251
	nil, // 252
	nil, // 253
	nil, // 254
	{
		{[]byte{0xFF, 0xD8, 0xFF}, jpg},
		{[]byte{0xFF, 0xF3, 0x48, 0xC4, 0x00}, mp3},
		{[]byte{0xFF, 0xFB}, mp3},
	}, // 255
}