Update vendored dependencies.

go.mod

@@ -3,9 +3,9 @@ module salsa.debian.org/mdosch/go-sendxmpp
 go 1.13
 
 require (
-	github.com/gabriel-vasile/mimetype v1.3.1
+	github.com/gabriel-vasile/mimetype v1.4.0
 	github.com/mattn/go-xmpp v0.0.0-20210723025538-3871461df959
 	github.com/pborman/getopt/v2 v2.1.0
-	golang.org/x/net v0.0.0-20211005001312-d4b1ae081e3b // indirect
+	golang.org/x/net v0.0.0-20211020060615-d418f374d309 // indirect
 	salsa.debian.org/mdosch/xmppsrv v0.1.0
 )

go.sum

@@ -1,12 +1,12 @@
-github.com/gabriel-vasile/mimetype v1.3.1 h1:qevA6c2MtE1RorlScnixeG0VA1H4xrXyhyX3oWBynNQ=
-github.com/gabriel-vasile/mimetype v1.3.1/go.mod h1:fA8fi6KUiG7MgQQ+mEWotXoEOvmxRtOJlERCzSmRvr8=
+github.com/gabriel-vasile/mimetype v1.4.0 h1:Cn9dkdYsMIu56tGho+fqzh7XmvY2YyGU0FnbhiOsEro=
+github.com/gabriel-vasile/mimetype v1.4.0/go.mod h1:fA8fi6KUiG7MgQQ+mEWotXoEOvmxRtOJlERCzSmRvr8=
 github.com/mattn/go-xmpp v0.0.0-20210723025538-3871461df959 h1:heUerLk4jOhweir4OqSGDUZueo9dRRtBcglPB44XRYY=
 github.com/mattn/go-xmpp v0.0.0-20210723025538-3871461df959/go.mod h1:Cs5mF0OsrRRmhkyOod//ldNPOwJsrBvJ+1WRspv0xoc=
 github.com/pborman/getopt/v2 v2.1.0 h1:eNfR+r+dWLdWmV8g5OlpyrTYHkhVNxHBdN2cCrJmOEA=
 github.com/pborman/getopt/v2 v2.1.0/go.mod h1:4NtW75ny4eBw9fO1bhtNdYTlZKYX5/tBLtsOpwKIKd0=
 golang.org/x/net v0.0.0-20210505024714-0287a6fb4125/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20211005001312-d4b1ae081e3b h1:SXy8Ld8oKlcogOvUAh0J5Pm5RKzgYBMMxLxt6n5XW50=
-golang.org/x/net v0.0.0-20211005001312-d4b1ae081e3b/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20211020060615-d418f374d309 h1:A0lJIi+hcTR6aajJH4YqKWwohY4aW9RO7oRMcdv+HKI=
+golang.org/x/net v0.0.0-20211020060615-d418f374d309/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=

vendor/github.com/gabriel-vasile/mimetype/internal/magic/image.go

@@ -43,7 +43,7 @@ var (
 )
 
 func jpeg2k(sig []byte) Detector {
-	return func(raw []byte, limit uint32) bool {
+	return func(raw []byte, _ uint32) bool {
 		if len(raw) < 24 {
 			return false
 		}
@@ -57,14 +57,14 @@ func jpeg2k(sig []byte) Detector {
 }
 
 // Webp matches a WebP file.
-func Webp(raw []byte, limit uint32) bool {
+func Webp(raw []byte, _ uint32) bool {
 	return len(raw) > 12 &&
 		bytes.Equal(raw[0:4], []byte("RIFF")) &&
 		bytes.Equal(raw[8:12], []byte{0x57, 0x45, 0x42, 0x50})
 }
 
 // Dwg matches a CAD drawing file.
-func Dwg(raw []byte, limit uint32) bool {
+func Dwg(raw []byte, _ uint32) bool {
 	if len(raw) < 6 || raw[0] != 0x41 || raw[1] != 0x43 {
 		return false
 	}
@@ -94,3 +94,9 @@ func Dwg(raw []byte, limit uint32) bool {
 
 	return false
 }
+
+// Jxl matches JPEG XL image file.
+func Jxl(raw []byte, _ uint32) bool {
+	return bytes.HasPrefix(raw, []byte{0xFF, 0x0A}) ||
+		bytes.HasPrefix(raw, []byte("\x00\x00\x00\x0cJXL\x20\x0d\x0a\x87\x0a"))
+}

vendor/github.com/gabriel-vasile/mimetype/internal/magic/ms_office.go

@@ -224,6 +224,15 @@ func Msg(raw []byte, limit uint32) bool {
 	})
 }
 
+// Msi matches a Microsoft Windows Installer file.
+// http://fileformats.archiveteam.org/wiki/Microsoft_Compound_File
+func Msi(raw []byte, limit uint32) bool {
+	return matchOleClsid(raw, []byte{
+		0x84, 0x10, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46,
+	})
+}
+
 // Helper to match by a specific CLSID of a compound file.
 //
 // http://fileformats.archiveteam.org/wiki/Microsoft_Compound_File

vendor/github.com/gabriel-vasile/mimetype/internal/magic/signature.go

@@ -6,13 +6,15 @@ import (
 	"fmt"
 )
 
-type Detector func(raw []byte, limit uint32) bool
-type xmlSig struct {
-	// the local name of the root tag
-	localName []byte
-	// the namespace of the XML document
-	xmlns []byte
-}
+type (
+	Detector func(raw []byte, limit uint32) bool
+	xmlSig   struct {
+		// the local name of the root tag
+		localName []byte
+		// the namespace of the XML document
+		xmlns []byte
+	}
+)
 
 // prefix creates a Detector which returns true if any of the provided signatures
 // is the prefix of the raw input.

vendor/github.com/gabriel-vasile/mimetype/internal/magic/text.go

@@ -1,6 +1,7 @@
 package magic
 
 import (
+	"bufio"
 	"bytes"
 
 	"github.com/gabriel-vasile/mimetype/internal/charset"
@@ -131,7 +132,16 @@ func Text(raw []byte, limit uint32) bool {
 	if cset := charset.FromBOM(raw); cset != "" {
 		return true
 	}
-	return isText(raw)
+	// Binary data bytes as defined here: https://mimesniff.spec.whatwg.org/#binary-data-byte
+	for _, b := range raw {
+		if b <= 0x08 ||
+			b == 0x0B ||
+			0x0E <= b && b <= 0x1A ||
+			0x1C <= b && b <= 0x1F {
+			return false
+		}
+	}
+	return true
 }
 
 // Php matches a PHP: Hypertext Preprocessor file.
@@ -142,27 +152,33 @@ func Php(raw []byte, limit uint32) bool {
 	return phpScriptF(raw, limit)
 }
 
-// Json matches a JavaScript Object Notation file.
-func Json(raw []byte, limit uint32) bool {
+// JSON matches a JavaScript Object Notation file.
+func JSON(raw []byte, limit uint32) bool {
+	raw = trimLWS(raw)
+	if len(raw) == 0 || (raw[0] != '[' && raw[0] != '{') {
+		return false
+	}
 	parsed, err := json.Scan(raw)
+	// If the full file content was provided, check there is no error.
 	if len(raw) < int(limit) {
 		return err == nil
 	}
 
-	return parsed == len(raw)
+	// If a section of the file was provided, check if all of it was parsed.
+	return parsed == len(raw) && len(raw) > 0
 }
 
-// GeoJson matches a RFC 7946 GeoJSON file.
+// GeoJSON matches a RFC 7946 GeoJSON file.
 //
-// GeoJson detection implies searching for key:value pairs like: `"type": "Feature"`
+// GeoJSON detection implies searching for key:value pairs like: `"type": "Feature"`
 // in the input.
 // BUG(gabriel-vasile): The "type" key should be searched for in the root object.
-func GeoJson(raw []byte, limit uint32) bool {
+func GeoJSON(raw []byte, limit uint32) bool {
 	raw = trimLWS(raw)
 	if len(raw) == 0 {
 		return false
 	}
-	// GeoJSON is always a JSON object, not a JSON array.
+	// GeoJSON is always a JSON object, not a JSON array or any other JSON value.
 	if raw[0] != '{' {
 		return false
 	}
@@ -190,7 +206,7 @@ func GeoJson(raw []byte, limit uint32) bool {
 	// Skip any whitespace after the colon.
 	raw = trimLWS(raw[1:])
 
-	geoJsonTypes := [][]byte{
+	geoJSONTypes := [][]byte{
 		[]byte(`"Feature"`),
 		[]byte(`"FeatureCollection"`),
 		[]byte(`"Point"`),
@@ -201,7 +217,7 @@ func GeoJson(raw []byte, limit uint32) bool {
 		[]byte(`"MultiPolygon"`),
 		[]byte(`"GeometryCollection"`),
 	}
-	for _, t := range geoJsonTypes {
+	for _, t := range geoJSONTypes {
 		if bytes.HasPrefix(raw, t) {
 			return true
 		}
@@ -210,59 +226,68 @@ func GeoJson(raw []byte, limit uint32) bool {
 	return false
 }
 
-// NdJson matches a Newline delimited JSON file.
-func NdJson(raw []byte, limit uint32) bool {
-	// Separator with carriage return and new line `\r\n`.
-	srn := []byte{0x0D, 0x0A}
+// NdJSON matches a Newline delimited JSON file.
+func NdJSON(raw []byte, limit uint32) bool {
+	lCount := 0
+	sc := bufio.NewScanner(dropLastLine(raw, limit))
+	for sc.Scan() {
+		l := sc.Bytes()
+		// Empty lines are allowed in NDJSON.
+		if l = trimRWS(trimLWS(l)); len(l) == 0 {
+			continue
+		}
+		_, err := json.Scan(l)
+		if err != nil {
+			return false
+		}
+		lCount++
+	}
+
+	return lCount > 1
+}
 
-	// Separator with only new line `\n`.
-	sn := []byte{0x0A}
+// Har matches a HAR Spec file.
+// Spec: http://www.softwareishard.com/blog/har-12-spec/
+func HAR(raw []byte, limit uint32) bool {
+	s := []byte(`"log"`)
+	si, sl := bytes.Index(raw, s), len(s)
 
-	// Total bytes scanned.
-	parsed := 0
+	if si == -1 {
+		return false
+	}
 
-	// Split by `srn`.
-	for rni, insrn := range bytes.Split(raw, srn) {
-		// Separator byte count should be added only after the first split.
-		if rni != 0 {
-			// Add two as `\r\n` is used for split.
-			parsed += 2
-		}
-		// Split again by `sn`.
-		for ni, insn := range bytes.Split(insrn, sn) {
-			// Separator byte count should be added only after the first split.
-			if ni != 0 {
-				// Add one as `\n` is used for split.
-				parsed++
-			}
-			// Empty line is valid.
-			if len(insn) == 0 {
-				continue
-			}
-			p, err := json.Scan(insn)
-			parsed += p
-			if parsed < int(limit) && err != nil {
-				return false
-			}
+	// If the "log" string is the suffix of the input,
+	// there is no need to search for the value of the key.
+	if si+sl == len(raw) {
+		return false
+	}
+	// Skip the "log" part.
+	raw = raw[si+sl:]
+	// Skip any whitespace before the colon.
+	raw = trimLWS(raw)
+	// Check for colon.
+	if len(raw) == 0 || raw[0] != ':' {
+		return false
+	}
+	// Skip any whitespace after the colon.
+	raw = trimLWS(raw[1:])
+
+	harJsonTypes := [][]byte{
+		[]byte(`"version"`),
+		[]byte(`"creator"`),
+		[]byte(`"entries"`),
+	}
+	for _, t := range harJsonTypes {
+		si := bytes.Index(raw, t)
+		if si > -1 {
+			return true
 		}
 	}
 
-	// Empty inputs should not pass as valid NDJSON with 0 lines.
-	return parsed > 2 && parsed == len(raw)
+	return false
 }
 
 // Svg matches a SVG file.
 func Svg(raw []byte, limit uint32) bool {
 	return bytes.Contains(raw, []byte("<svg"))
 }
-
-// isText considers any file containing null bytes as a binary file.
-// There is plenty room for disagreement regarding what should be considered a
-// text file. This approach is used by diff, cat, and other linux utilities.
-func isText(raw []byte) bool {
-	l := 8000
-	if len(raw) > l {
-		raw = raw[:l]
-	}
-	return bytes.IndexByte(raw, 0) == -1
-}

vendor/github.com/gabriel-vasile/mimetype/internal/magic/text_csv.go

@@ -8,16 +8,16 @@ import (
 
 // Csv matches a comma-separated values file.
 func Csv(raw []byte, limit uint32) bool {
-	return sv(raw, ',')
+	return sv(raw, ',', limit)
 }
 
 // Tsv matches a tab-separated values file.
 func Tsv(raw []byte, limit uint32) bool {
-	return sv(raw, '\t')
+	return sv(raw, '\t', limit)
 }
 
-func sv(in []byte, comma rune) bool {
-	r := csv.NewReader(butLastLineReader(in, len(in)))
+func sv(in []byte, comma rune, limit uint32) bool {
+	r := csv.NewReader(dropLastLine(in, limit))
 	r.Comma = comma
 	r.TrimLeadingSpace = true
 	r.LazyQuotes = true
@@ -27,20 +27,25 @@ func sv(in []byte, comma rune) bool {
 	return err == nil && r.FieldsPerRecord > 1 && len(lines) > 1
 }
 
-// butLastLineReader returns a reader to the provided byte slice.
-// The reader is guaranteed to reach EOF before it reads `cutAt` bytes.
-// Bytes after the last newline are dropped from the input.
-func butLastLineReader(in []byte, cutAt int) io.Reader {
-	if len(in) >= cutAt {
+// dropLastLine drops the last incomplete line from b.
+//
+// mimetype limits itself to ReadLimit bytes when performing a detection.
+// This means, for file formats like CSV for NDJSON, the last line of the input
+// can be an incomplete line.
+func dropLastLine(b []byte, cutAt uint32) io.Reader {
+	if cutAt == 0 {
+		return bytes.NewReader(b)
+	}
+	if uint32(len(b)) >= cutAt {
 		for i := cutAt - 1; i > 0; i-- {
-			if in[i] == '\n' {
-				return bytes.NewReader(in[:i])
+			if b[i] == '\n' {
+				return bytes.NewReader(b[:i])
 			}
 		}
 
-		// no newline was found between the 0 index and cutAt
-		return bytes.NewReader(in[:cutAt])
+		// No newline was found between the 0 index and cutAt.
+		return bytes.NewReader(b[:cutAt])
 	}
 
-	return bytes.NewReader(in)
+	return bytes.NewReader(b)
 }

vendor/github.com/gabriel-vasile/mimetype/internal/magic/video.go

@@ -41,21 +41,36 @@ func isMatroskaFileTypeMatched(in []byte, flType string) bool {
 // isFileTypeNamePresent accepts the matroska input data stream and searches
 // for the given file type in the stream. Return whether a match is found.
 // The logic of search is: find first instance of \x42\x82 and then
-// search for given string after one byte of above instance.
+// search for given string after n bytes of above instance.
 func isFileTypeNamePresent(in []byte, flType string) bool {
 	ind, maxInd, lenIn := 0, 4096, len(in)
 	if lenIn < maxInd { // restricting length to 4096
 		maxInd = lenIn
 	}
 	ind = bytes.Index(in[:maxInd], []byte("\x42\x82"))
-	if ind > 0 && lenIn > ind+3 {
+	if ind > 0 && lenIn > ind+2 {
+		ind += 2
+
 		// filetype name will be present exactly
-		// one byte after the match of the two bytes "\x42\x82"
-		return bytes.HasPrefix(in[ind+3:], []byte(flType))
+		// n bytes after the match of the two bytes "\x42\x82"
+		n := vintWidth(int(in[ind]))
+		if lenIn > ind+n {
+			return bytes.HasPrefix(in[ind+n:], []byte(flType))
+		}
 	}
 	return false
 }
 
+// vintWidth parses the variable-integer width in matroska containers
+func vintWidth(v int) int {
+	mask, max, num := 128, 8, 1
+	for num < max && v&mask == 0 {
+		mask = mask >> 1
+		num++
+	}
+	return num
+}
+
 // Mpeg matches a Moving Picture Experts Group file.
 func Mpeg(raw []byte, limit uint32) bool {
 	return len(raw) > 3 && bytes.HasPrefix(raw, []byte{0x00, 0x00, 0x01}) &&

vendor/github.com/gabriel-vasile/mimetype/mime.go

@@ -56,6 +56,7 @@ func (m *MIME) Is(expectedMIME string) bool {
 	if expectedMIME == found {
 		return true
 	}
+
 	for _, alias := range m.aliases {
 		if alias == expectedMIME {
 			return true
@@ -151,3 +152,36 @@ func (m *MIME) cloneHierarchy(ps map[string]string) *MIME {
 
 	return ret
 }
+
+func (m *MIME) lookup(mime string) *MIME {
+	for _, n := range append(m.aliases, m.mime) {
+		if n == mime {
+			return m
+		}
+	}
+
+	for _, c := range m.children {
+		if m := c.lookup(mime); m != nil {
+			return m
+		}
+	}
+	return nil
+}
+
+// Extend adds detection for a sub-format. The detector is a function
+// returning true when the raw input file satisfies a signature.
+// The sub-format will be detected if all the detectors in the parent chain return true.
+// The extension should include the leading dot, as in ".html".
+func (m *MIME) Extend(detector func(raw []byte, limit uint32) bool, mime, extension string, aliases ...string) {
+	c := &MIME{
+		mime:      mime,
+		extension: extension,
+		detector:  detector,
+		parent:    m,
+		aliases:   aliases,
+	}
+
+	mu.Lock()
+	m.children = append([]*MIME{c}, m.children...)
+	mu.Unlock()
+}

vendor/github.com/gabriel-vasile/mimetype/mimetype.go

@@ -1,4 +1,8 @@
 // Package mimetype uses magic number signatures to detect the MIME type of a file.
+//
+// File formats are stored in a hierarchy with application/octet-stream at its root.
+// For example, the hierarchy for HTML format is application/octet-stream ->
+// text/plain -> text/html.
 package mimetype
 
 import (
@@ -6,6 +10,7 @@ import (
 	"io/ioutil"
 	"mime"
 	"os"
+	"sync/atomic"
 )
 
 // readLimit is the maximum number of bytes from the input used when detecting.
@@ -16,12 +21,14 @@ var readLimit uint32 = 3072
 // The result is always a valid MIME type, with application/octet-stream
 // returned when identification failed.
 func Detect(in []byte) *MIME {
-	rootMu.RLock()
-	defer rootMu.RUnlock()
-	if readLimit > 0 && len(in) > int(readLimit) {
-		in = in[:readLimit]
+	// Using atomic because readLimit can be written at the same time in other goroutine.
+	l := atomic.LoadUint32(&readLimit)
+	if l > 0 && len(in) > int(l) {
+		in = in[:l]
 	}
-	return root.match(in, readLimit)
+	mu.RLock()
+	defer mu.RUnlock()
+	return root.match(in, l)
 }
 
 // DetectReader returns the MIME type of the provided reader.
@@ -34,29 +41,31 @@ func Detect(in []byte) *MIME {
 // io.ReadSeeker you previously read from, it should be rewinded before detection:
 //  reader.Seek(0, io.SeekStart)
 func DetectReader(r io.Reader) (*MIME, error) {
-	rootMu.RLock()
-	defer rootMu.RUnlock()
 	var in []byte
 	var err error
 
-	if readLimit == 0 {
+	// Using atomic because readLimit can be written at the same time in other goroutine.
+	l := atomic.LoadUint32(&readLimit)
+	if l == 0 {
 		in, err = ioutil.ReadAll(r)
 		if err != nil {
-			return root, err
+			return errMIME, err
 		}
 	} else {
+		n := 0
+		in = make([]byte, l)
 		// io.UnexpectedEOF means len(r) < len(in). It is not an error in this case,
 		// it just means the input file is smaller than the allocated bytes slice.
-		n := 0
-		in = make([]byte, readLimit)
 		n, err = io.ReadFull(r, in)
 		if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF {
-			return root, err
+			return errMIME, err
 		}
 		in = in[:n]
 	}
 
-	return root.match(in, readLimit), nil
+	mu.RLock()
+	defer mu.RUnlock()
+	return root.match(in, l), nil
 }
 
 // DetectFile returns the MIME type of the provided file.
@@ -67,7 +76,7 @@ func DetectReader(r io.Reader) (*MIME, error) {
 func DetectFile(path string) (*MIME, error) {
 	f, err := os.Open(path)
 	if err != nil {
-		return root, err
+		return errMIME, err
 	}
 	defer f.Close()
 
@@ -95,24 +104,20 @@ func EqualsAny(s string, mimes ...string) bool {
 // their magical numbers towards the end of the file: docx, pptx, xlsx, etc.
 // A limit of 0 means the whole input file will be used.
 func SetLimit(limit uint32) {
-	rootMu.Lock()
-	readLimit = limit
-	rootMu.Unlock()
+	// Using atomic because readLimit can be read at the same time in other goroutine.
+	atomic.StoreUint32(&readLimit, limit)
 }
 
-// Extend adds detection for other file formats. The detector is a function
-// returning true when the raw input file satisfies a  signature.
-// The extension should include the leading dot, as in ".html".
+// Extend adds detection for other file formats.
+// It is equivalent to calling Extend() on the root mime type "application/octet-stream".
 func Extend(detector func(raw []byte, limit uint32) bool, mime, extension string, aliases ...string) {
-	m := &MIME{
-		mime:      mime,
-		extension: extension,
-		detector:  detector,
-		parent:    root,
-		aliases:   aliases,
-	}
+	root.Extend(detector, mime, extension, aliases...)
+}
 
-	rootMu.Lock()
-	root.children = append([]*MIME{m}, root.children...)
-	rootMu.Unlock()
+// Lookup finds a MIME object by its string representation.
+// The representation can be the main mime type, or any of its aliases.
+func Lookup(mime string) *MIME {
+	mu.RLock()
+	defer mu.RUnlock()
+	return root.lookup(mime)
 }

vendor/github.com/gabriel-vasile/mimetype/supported_mimes.md

@@ -1,4 +1,4 @@
-## 162 Supported MIME types
+## 165 Supported MIME types
 This file is automatically generated when running tests. Do not edit manually.
 
 Extension | MIME type | Aliases
@@ -26,6 +26,7 @@ Extension | MIME type | Aliases
 **.pdf** | application/pdf | application/x-pdf
 **.fdf** | application/vnd.fdf | -
 **n/a** | application/x-ole-storage | -
+**.msi** | application/x-ms-installer | application/x-windows-installer, application/x-msi
 **.aaf** | application/octet-stream | -
 **.msg** | application/vnd.ms-outlook | -
 **.xls** | application/vnd.ms-excel | application/msexcel
@@ -40,6 +41,7 @@ Extension | MIME type | Aliases
 **.ogv** | video/ogg | -
 **.png** | image/png | -
 **.jpg** | image/jpeg | -
+**.jxl** | image/jxl | -
 **.jp2** | image/jp2 | -
 **.jpf** | image/jpx | -
 **.jpm** | image/jpm | video/jpm
@@ -106,7 +108,7 @@ Extension | MIME type | Aliases
 **.mobi** | application/x-mobipocket-ebook | -
 **.lit** | application/x-ms-reader | -
 **.bpg** | image/bpg | -
-**.sqlite** | application/x-sqlite3 | -
+**.sqlite** | application/vnd.sqlite3 | application/x-sqlite3
 **.dwg** | image/vnd.dwg | image/x-dwg, application/acad, application/x-acad, application/autocad_dwg, application/dwg, application/x-dwg, application/x-autocad, drawing/dwg
 **.nes** | application/vnd.nintendo.snes.rom | -
 **.lnk** | application/x-ms-shortcut | -
@@ -157,6 +159,7 @@ Extension | MIME type | Aliases
 **.py** | application/x-python | -
 **.json** | application/json | -
 **.geojson** | application/geo+json | -
+**.har** | application/json | -
 **.ndjson** | application/x-ndjson | -
 **.rtf** | text/rtf | -
 **.tcl** | text/x-tcl | application/x-tcl

vendor/github.com/gabriel-vasile/mimetype/tree.go

@@ -12,25 +12,30 @@ import (
 // and allows for more precise results once the base type of file has been
 // identified.
 //
-// root is a matcher which passes for any slice of bytes.
-// When a matcher passes the check, the children magic
+// root is a detector which passes for any slice of bytes.
+// When a detector passes the check, the children detectors
 // are tried in order to find a more accurate MIME type.
 var root = newMIME("application/octet-stream", "",
 	func([]byte, uint32) bool { return true },
-	xpm, sevenZ, zip, pdf, fdf, ole, ps, psd, p7s, ogg, png, jpg, jp2, jpx, jpm, gif, webp,
-	exe, elf, ar, tar, xar, bz2, fits, tiff, bmp, ico, mp3, flac, midi, ape,
-	musePack, amr, wav, aiff, au, mpeg, quickTime, mqv, mp4, webM, threeGP,
-	threeG2, avi, flv, mkv, asf, aac, voc, aMp4, m4a, m3u, m4v, rmvb,
-	gzip, class, swf, crx, ttf, woff, woff2, otf, eot, wasm,
-	shx, dbf, dcm, rar, djvu, mobi, lit, bpg, sqlite3, dwg, nes, lnk, macho, qcp,
-	icns, heic, heicSeq, heif, heifSeq, hdr, mrc, mdb, accdb, zstd, cab,
-	rpm, xz, lzip, torrent, cpio, tzif, xcf, pat, gbr, glb,
+	xpm, sevenZ, zip, pdf, fdf, ole, ps, psd, p7s, ogg, png, jpg, jxl, jp2, jpx,
+	jpm, gif, webp, exe, elf, ar, tar, xar, bz2, fits, tiff, bmp, ico, mp3, flac,
+	midi, ape, musePack, amr, wav, aiff, au, mpeg, quickTime, mqv, mp4, webM,
+	threeGP, threeG2, avi, flv, mkv, asf, aac, voc, aMp4, m4a, m3u, m4v, rmvb,
+	gzip, class, swf, crx, ttf, woff, woff2, otf, eot, wasm, shx, dbf, dcm, rar,
+	djvu, mobi, lit, bpg, sqlite3, dwg, nes, lnk, macho, qcp, icns, heic,
+	heicSeq, heif, heifSeq, hdr, mrc, mdb, accdb, zstd, cab, rpm, xz, lzip,
+	torrent, cpio, tzif, xcf, pat, gbr, glb,
 	// Keep text last because it is the slowest check
 	text,
 )
 
-// rootMu guards the root tree and the readLimit used when creating the detection buffer.
-var rootMu sync.RWMutex
+// errMIME is returned from Detect functions when err is not nil.
+// Detect could return root for erroneous cases, but it needs to lock mu in order to do so.
+// errMIME is same as root but it does not require locking.
+var errMIME = newMIME("application/octet-stream", "", func([]byte, uint32) bool { return false })
+
+// mu guards access to the root MIME tree. Access to root must be synchonized with this lock.
+var mu = &sync.RWMutex{}
 
 // The list of nodes appended to the root node.
 var (
@@ -53,9 +58,11 @@ var (
 	pptx = newMIME("application/vnd.openxmlformats-officedocument.presentationml.presentation", ".pptx", magic.Pptx)
 	epub = newMIME("application/epub+zip", ".epub", magic.Epub)
 	jar  = newMIME("application/jar", ".jar", magic.Jar)
-	ole  = newMIME("application/x-ole-storage", "", magic.Ole, aaf, msg, xls, pub, ppt, doc)
-	aaf  = newMIME("application/octet-stream", ".aaf", magic.Aaf)
-	doc  = newMIME("application/msword", ".doc", magic.Doc).
+	ole  = newMIME("application/x-ole-storage", "", magic.Ole, msi, aaf, msg, xls, pub, ppt, doc)
+	msi  = newMIME("application/x-ms-installer", ".msi", magic.Msi).
+		alias("application/x-windows-installer", "application/x-msi")
+	aaf = newMIME("application/octet-stream", ".aaf", magic.Aaf)
+	doc = newMIME("application/msword", ".doc", magic.Doc).
 		alias("application/vnd.ms-word")
 	ppt = newMIME("application/vnd.ms-powerpoint", ".ppt", magic.Ppt).
 		alias("application/mspowerpoint")
@@ -69,13 +76,14 @@ var (
 		alias("application/x-ogg")
 	oggAudio = newMIME("audio/ogg", ".oga", magic.OggAudio)
 	oggVideo = newMIME("video/ogg", ".ogv", magic.OggVideo)
-	text     = newMIME("text/plain", ".txt", magic.Text, html, svg, xml, php, js, lua, perl, python, json, ndJson, rtf, tcl, csv, tsv, vCard, iCalendar, warc)
+	text     = newMIME("text/plain", ".txt", magic.Text, html, svg, xml, php, js, lua, perl, python, json, ndJSON, rtf, tcl, csv, tsv, vCard, iCalendar, warc)
 	xml      = newMIME("text/xml", ".xml", magic.Xml, rss, atom, x3d, kml, xliff, collada, gml, gpx, tcx, amf, threemf, xfdf, owl2)
-	json     = newMIME("application/json", ".json", magic.Json, geoJson)
+	json     = newMIME("application/json", ".json", magic.JSON, geoJSON, har)
+	har      = newMIME("application/json", ".har", magic.HAR)
 	csv      = newMIME("text/csv", ".csv", magic.Csv)
 	tsv      = newMIME("text/tab-separated-values", ".tsv", magic.Tsv)
-	geoJson  = newMIME("application/geo+json", ".geojson", magic.GeoJson)
-	ndJson   = newMIME("application/x-ndjson", ".ndjson", magic.NdJson)
+	geoJSON  = newMIME("application/geo+json", ".geojson", magic.GeoJSON)
+	ndJSON   = newMIME("application/x-ndjson", ".ndjson", magic.NdJSON)
 	html     = newMIME("text/html", ".html", magic.Html)
 	php      = newMIME("text/x-php", ".php", magic.Php)
 	rtf      = newMIME("text/rtf", ".rtf", magic.Rtf)
@@ -104,6 +112,7 @@ var (
 	threemf = newMIME("application/vnd.ms-package.3dmanufacturing-3dmodel+xml", ".3mf", magic.Threemf)
 	png     = newMIME("image/png", ".png", magic.Png)
 	jpg     = newMIME("image/jpeg", ".jpg", magic.Jpg)
+	jxl     = newMIME("image/jxl", ".jxl", magic.Jxl)
 	jp2     = newMIME("image/jp2", ".jp2", magic.Jp2)
 	jpx     = newMIME("image/jpx", ".jpf", magic.Jpx)
 	jpm     = newMIME("image/jpm", ".jpm", magic.Jpm).
@@ -212,8 +221,9 @@ var (
 	djvu    = newMIME("image/vnd.djvu", ".djvu", magic.DjVu)
 	mobi    = newMIME("application/x-mobipocket-ebook", ".mobi", magic.Mobi)
 	lit     = newMIME("application/x-ms-reader", ".lit", magic.Lit)
-	sqlite3 = newMIME("application/x-sqlite3", ".sqlite", magic.Sqlite)
-	dwg     = newMIME("image/vnd.dwg", ".dwg", magic.Dwg).
+	sqlite3 = newMIME("application/vnd.sqlite3", ".sqlite", magic.Sqlite).
+		alias("application/x-sqlite3")
+	dwg = newMIME("image/vnd.dwg", ".dwg", magic.Dwg).
 		alias("image/x-dwg", "application/acad", "application/x-acad",
 			"application/autocad_dwg", "application/dwg", "application/x-dwg",
 			"application/x-autocad", "drawing/dwg")

vendor/modules.txt

@@ -1,4 +1,4 @@
-# github.com/gabriel-vasile/mimetype v1.3.1
+# github.com/gabriel-vasile/mimetype v1.4.0
 github.com/gabriel-vasile/mimetype
 github.com/gabriel-vasile/mimetype/internal/charset
 github.com/gabriel-vasile/mimetype/internal/json
@@ -7,7 +7,7 @@ github.com/gabriel-vasile/mimetype/internal/magic
 github.com/mattn/go-xmpp
 # github.com/pborman/getopt/v2 v2.1.0
 github.com/pborman/getopt/v2
-# golang.org/x/net v0.0.0-20211005001312-d4b1ae081e3b
+# golang.org/x/net v0.0.0-20211020060615-d418f374d309
 golang.org/x/net/html
 golang.org/x/net/html/atom
 # salsa.debian.org/mdosch/xmppsrv v0.1.0