[chore]: Bump github.com/tdewolff/minify/v2 from 2.20.37 to 2.21.0 (#3468)

Bumps [github.com/tdewolff/minify/v2](https://github.com/tdewolff/minify) from 2.20.37 to 2.21.0.
- [Release notes](https://github.com/tdewolff/minify/releases)
- [Commits](https://github.com/tdewolff/minify/compare/v2.20.37...v2.21.0)

---
updated-dependencies:
- dependency-name: github.com/tdewolff/minify/v2
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

go.mod

@@ -53,7 +53,7 @@ require (
 	github.com/superseriousbusiness/activity v1.9.0-gts
 	github.com/superseriousbusiness/httpsig v1.2.0-SSB
 	github.com/superseriousbusiness/oauth2/v4 v4.3.2-SSB.0.20230227143000-f4900831d6c8
-	github.com/tdewolff/minify/v2 v2.20.37
+	github.com/tdewolff/minify/v2 v2.21.0
 	github.com/technologize/otel-go-contrib v1.1.1
 	github.com/tetratelabs/wazero v1.8.1
 	github.com/tomnomnom/linkheader v0.0.0-20180905144013-02ca5825eb80
@@ -197,7 +197,7 @@ require (
 	github.com/subosito/gotenv v1.6.0 // indirect
 	github.com/superseriousbusiness/go-jpeg-image-structure/v2 v2.0.0-20220321154430-d89a106fdabe // indirect
 	github.com/superseriousbusiness/go-png-image-structure/v2 v2.0.1-SSB // indirect
-	github.com/tdewolff/parse/v2 v2.7.15 // indirect
+	github.com/tdewolff/parse/v2 v2.7.17 // indirect
 	github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc // indirect
 	github.com/toqueteos/webbrowser v1.2.0 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect

go.sum

@@ -539,10 +539,10 @@ github.com/superseriousbusiness/httpsig v1.2.0-SSB h1:BinBGKbf2LSuVT5+MuH0XynHN9
 github.com/superseriousbusiness/httpsig v1.2.0-SSB/go.mod h1:+rxfATjFaDoDIVaJOTSP0gj6UrbicaYPEptvCLC9F28=
 github.com/superseriousbusiness/oauth2/v4 v4.3.2-SSB.0.20230227143000-f4900831d6c8 h1:nTIhuP157oOFcscuoK1kCme1xTeGIzztSw70lX9NrDQ=
 github.com/superseriousbusiness/oauth2/v4 v4.3.2-SSB.0.20230227143000-f4900831d6c8/go.mod h1:uYC/W92oVRJ49Vh1GcvTqpeFqHi+Ovrl2sMllQWRAEo=
-github.com/tdewolff/minify/v2 v2.20.37 h1:Q97cx4STXCh1dlWDlNHZniE8BJ2EBL0+2b0n92BJQhw=
+github.com/tdewolff/minify/v2 v2.21.0 h1:nAPP1UVx0aK1xsQh/JiG3xyEnnqWw+agPstn+V6Pkto=
-github.com/tdewolff/minify/v2 v2.20.37/go.mod h1:L1VYef/jwKw6Wwyk5A+T0mBjjn3mMPgmjjA688RNsxU=
+github.com/tdewolff/minify/v2 v2.21.0/go.mod h1:hGcthJ6Vj51NG+9QRIfN/DpWj5loHnY3bfhThzWWq08=
-github.com/tdewolff/parse/v2 v2.7.15 h1:hysDXtdGZIRF5UZXwpfn3ZWRbm+ru4l53/ajBRGpCTw=
+github.com/tdewolff/parse/v2 v2.7.17 h1:uC10p6DaQQORDy72eaIyD+AvAkaIUOouQ0nWp4uD0D0=
-github.com/tdewolff/parse/v2 v2.7.15/go.mod h1:3FbJWZp3XT9OWVN3Hmfp0p/a08v4h8J9W1aghka0soA=
+github.com/tdewolff/parse/v2 v2.7.17/go.mod h1:3FbJWZp3XT9OWVN3Hmfp0p/a08v4h8J9W1aghka0soA=
 github.com/tdewolff/test v1.0.11-0.20231101010635-f1265d231d52/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE=
 github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739 h1:IkjBCtQOOjIn03u/dMQK9g+Iw9ewps4mCl1nB8Sscbo=
 github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739/go.mod h1:XPuWBzvdUzhCuxWO1ojpXsyzsA5bFoS3tO/Q3kFuTG8=

vendor/github.com/tdewolff/minify/v2/html/html.go

@@ -199,7 +199,7 @@ func (o *Minifier) Minify(m *minify.M, w io.Writer, r io.Reader, _ map[string]st
 						} else if next.TokenType == html.TextToken && !parse.IsAllWhitespace(next.Data) {
 							// stop looking when text encountered
 							break
-						} else if next.TokenType == html.StartTagToken || next.TokenType == html.EndTagToken {
+						} else if next.TokenType == html.StartTagToken || next.TokenType == html.EndTagToken || next.TokenType == html.SvgToken || next.TokenType == html.MathToken {
 							if o.KeepWhitespace {
 								break
 							}
@@ -208,7 +208,7 @@ func (o *Minifier) Minify(m *minify.M, w io.Writer, r io.Reader, _ map[string]st
 								t.Data = t.Data[:len(t.Data)-1]
 								omitSpace = false
 								break
-							} else if next.TokenType == html.StartTagToken {
+							} else if next.TokenType == html.StartTagToken || next.TokenType == html.SvgToken || next.TokenType == html.MathToken {
 								break
 							}
 						}
@@ -309,7 +309,7 @@ func (o *Minifier) Minify(m *minify.M, w io.Writer, r io.Reader, _ map[string]st
 
 				// skip text in select and optgroup tags
 				if t.Hash == Option || t.Hash == Optgroup {
-					if next := tb.Peek(0); next.TokenType == html.TextToken {
+					if next := tb.Peek(0); next.TokenType == html.TextToken && !next.HasTemplate {
 						tb.Shift()
 					}
 				}

vendor/github.com/tdewolff/minify/v2/html/table.go

@@ -74,7 +74,7 @@
 	Input:      objectTag,
 	Ins:        keepPTag,
 	Kbd:        normalTag,
-	Label:      normalTag,
+	Label:      normalTag | keepPTag, // experimentally, keepPTag is needed
 	Legend:     blockTag,
 	Li:         blockTag,
 	Link:       normalTag,
@@ -125,7 +125,7 @@
 	Th:         blockTag,
 	Thead:      blockTag,
 	Time:       normalTag,
-	Title:      normalTag,
+	Title:      blockTag,
 	Tr:         blockTag,
 	Track:      normalTag,
 	U:          normalTag,

vendor/github.com/tdewolff/parse/v2/binary.go

@@ -2,12 +2,15 @@
 
 import (
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"io"
 	"math"
 	"os"
 )
 
+const PageSize = 4096
+
 // BinaryReader is a binary big endian file format reader.
 type BinaryReader struct {
 	Endianness binary.ByteOrder
@@ -330,6 +333,320 @@ func (r *BinaryFileReader) ReadInt64() int64 {
 	return int64(r.ReadUint64())
 }
 
+type IBinaryReader interface {
+	Close() error
+	Len() int
+	Bytes(int, int64) ([]byte, error)
+}
+
+type binaryReaderFile struct {
+	f    *os.File
+	size int64
+}
+
+func newBinaryReaderFile(filename string) (*binaryReaderFile, error) {
+	f, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	fi, err := f.Stat()
+	if err != nil {
+		f.Close()
+		return nil, err
+	}
+	return &binaryReaderFile{f, fi.Size()}, nil
+}
+
+// Close closes the reader.
+func (r *binaryReaderFile) Close() error {
+	return r.f.Close()
+}
+
+// Len returns the length of the underlying memory-mapped file.
+func (r *binaryReaderFile) Len() int {
+	return int(r.size)
+}
+
+func (r *binaryReaderFile) Bytes(n int, off int64) ([]byte, error) {
+	if _, err := r.f.Seek(off, 0); err != nil {
+		return nil, err
+	}
+
+	b := make([]byte, n)
+	m, err := r.f.Read(b)
+	if err != nil {
+		return nil, err
+	} else if m != n {
+		return nil, errors.New("file: could not read all bytes")
+	}
+	return b, nil
+}
+
+type binaryReaderBytes struct {
+	data []byte
+}
+
+func newBinaryReaderBytes(data []byte) (*binaryReaderBytes, error) {
+	return &binaryReaderBytes{data}, nil
+}
+
+// Close closes the reader.
+func (r *binaryReaderBytes) Close() error {
+	return nil
+}
+
+// Len returns the length of the underlying memory-mapped file.
+func (r *binaryReaderBytes) Len() int {
+	return len(r.data)
+}
+
+func (r *binaryReaderBytes) Bytes(n int, off int64) ([]byte, error) {
+	if off < 0 || int64(len(r.data)) < off {
+		return nil, fmt.Errorf("bytes: invalid offset %d", off)
+	}
+	return r.data[off : off+int64(n) : off+int64(n)], nil
+}
+
+type binaryReaderReader struct {
+	r        io.Reader
+	n        int64
+	readerAt bool
+	seeker   bool
+}
+
+func newBinaryReaderReader(r io.Reader, n int64) (*binaryReaderReader, error) {
+	_, readerAt := r.(io.ReaderAt)
+	_, seeker := r.(io.Seeker)
+	return &binaryReaderReader{r, n, readerAt, seeker}, nil
+}
+
+// Close closes the reader.
+func (r *binaryReaderReader) Close() error {
+	if closer, ok := r.r.(io.Closer); ok {
+		return closer.Close()
+	}
+	return nil
+}
+
+// Len returns the length of the underlying memory-mapped file.
+func (r *binaryReaderReader) Len() int {
+	return int(r.n)
+}
+
+func (r *binaryReaderReader) Bytes(n int, off int64) ([]byte, error) {
+	// seeker seems faster than readerAt by 10%
+	if r.seeker {
+		if _, err := r.r.(io.Seeker).Seek(off, 0); err != nil {
+			return nil, err
+		}
+
+		b := make([]byte, n)
+		m, err := r.r.Read(b)
+		if err != nil {
+			return nil, err
+		} else if m != n {
+			return nil, errors.New("file: could not read all bytes")
+		}
+		return b, nil
+	} else if r.readerAt {
+		b := make([]byte, n)
+		m, err := r.r.(io.ReaderAt).ReadAt(b, off)
+		if err != nil {
+			return nil, err
+		} else if m != n {
+			return nil, errors.New("file: could not read all bytes")
+		}
+		return b, nil
+	}
+	return nil, errors.New("io.Seeker and io.ReaderAt not implemented")
+}
+
+type BinaryReader2 struct {
+	f   IBinaryReader
+	pos int64
+	err error
+
+	Endian binary.ByteOrder
+}
+
+func NewBinaryReader2(f IBinaryReader) *BinaryReader2 {
+	return &BinaryReader2{
+		f:      f,
+		Endian: binary.BigEndian,
+	}
+}
+
+func NewBinaryReader2Reader(r io.Reader, n int64) (*BinaryReader2, error) {
+	_, isReaderAt := r.(io.ReaderAt)
+	_, isSeeker := r.(io.Seeker)
+
+	var f IBinaryReader
+	if isReaderAt || isSeeker {
+		var err error
+		f, err = newBinaryReaderReader(r, n)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		b := make([]byte, n)
+		if _, err := io.ReadFull(r, b); err != nil {
+			return nil, err
+		}
+		f, _ = newBinaryReaderBytes(b)
+	}
+	return NewBinaryReader2(f), nil
+}
+
+func NewBinaryReader2Bytes(data []byte) (*BinaryReader2, error) {
+	f, _ := newBinaryReaderBytes(data)
+	return NewBinaryReader2(f), nil
+}
+
+func NewBinaryReader2File(filename string) (*BinaryReader2, error) {
+	f, err := newBinaryReaderFile(filename)
+	if err != nil {
+		return nil, err
+	}
+	return NewBinaryReader2(f), nil
+}
+
+func NewBinaryReader2Mmap(filename string) (*BinaryReader2, error) {
+	f, err := newBinaryReaderMmap(filename)
+	if err != nil {
+		return nil, err
+	}
+	return NewBinaryReader2(f), nil
+}
+
+func (r *BinaryReader2) Err() error {
+	return r.err
+}
+
+func (r *BinaryReader2) Close() error {
+	if err := r.f.Close(); err != nil {
+		return err
+	}
+	return r.err
+}
+
+// InPageCache returns true if the range is already in the page cache (for mmap).
+func (r *BinaryReader2) InPageCache(start, end int64) bool {
+	index := int64(r.Pos()) / PageSize
+	return start/PageSize == index && end/PageSize == index
+}
+
+// Free frees all previously read bytes, you cannot seek from before this position (for reader).
+func (r *BinaryReader2) Free() {
+}
+
+// Pos returns the reader's position.
+func (r *BinaryReader2) Pos() int64 {
+	return r.pos
+}
+
+// Len returns the remaining length of the buffer.
+func (r *BinaryReader2) Len() int {
+	return int(int64(r.f.Len()) - int64(r.pos))
+}
+
+func (r *BinaryReader2) Seek(pos int64) {
+	r.pos = pos
+}
+
+// Read complies with io.Reader.
+func (r *BinaryReader2) Read(b []byte) (int, error) {
+	data, err := r.f.Bytes(len(b), r.pos)
+	if err != nil && err != io.EOF {
+		return 0, err
+	}
+	n := copy(b, data)
+	r.pos += int64(len(b))
+	return n, err
+}
+
+// ReadBytes reads n bytes.
+func (r *BinaryReader2) ReadBytes(n int) []byte {
+	data, err := r.f.Bytes(n, r.pos)
+	if err != nil {
+		r.err = err
+		return nil
+	}
+	r.pos += int64(n)
+	return data
+}
+
+// ReadString reads a string of length n.
+func (r *BinaryReader2) ReadString(n int) string {
+	return string(r.ReadBytes(n))
+}
+
+// ReadByte reads a single byte.
+func (r *BinaryReader2) ReadByte() byte {
+	data := r.ReadBytes(1)
+	if data == nil {
+		return 0
+	}
+	return data[0]
+}
+
+// ReadUint8 reads a uint8.
+func (r *BinaryReader2) ReadUint8() uint8 {
+	return r.ReadByte()
+}
+
+// ReadUint16 reads a uint16.
+func (r *BinaryReader2) ReadUint16() uint16 {
+	data := r.ReadBytes(2)
+	if data == nil {
+		return 0
+	} else if r.Endian == binary.LittleEndian {
+		return uint16(data[1])<<8 | uint16(data[0])
+	}
+	return uint16(data[0])<<8 | uint16(data[1])
+}
+
+// ReadUint32 reads a uint32.
+func (r *BinaryReader2) ReadUint32() uint32 {
+	data := r.ReadBytes(4)
+	if data == nil {
+		return 0
+	} else if r.Endian == binary.LittleEndian {
+		return uint32(data[3])<<24 | uint32(data[2])<<16 | uint32(data[1])<<8 | uint32(data[0])
+	}
+	return uint32(data[0])<<24 | uint32(data[1])<<16 | uint32(data[2])<<8 | uint32(data[3])
+}
+
+// ReadUint64 reads a uint64.
+func (r *BinaryReader2) ReadUint64() uint64 {
+	data := r.ReadBytes(8)
+	if data == nil {
+		return 0
+	} else if r.Endian == binary.LittleEndian {
+		return uint64(data[7])<<56 | uint64(data[6])<<48 | uint64(data[5])<<40 | uint64(data[4])<<32 | uint64(data[3])<<24 | uint64(data[2])<<16 | uint64(data[1])<<8 | uint64(data[0])
+	}
+	return uint64(data[0])<<56 | uint64(data[1])<<48 | uint64(data[2])<<40 | uint64(data[3])<<32 | uint64(data[4])<<24 | uint64(data[5])<<16 | uint64(data[6])<<8 | uint64(data[7])
+}
+
+// ReadInt8 reads a int8.
+func (r *BinaryReader2) ReadInt8() int8 {
+	return int8(r.ReadByte())
+}
+
+// ReadInt16 reads a int16.
+func (r *BinaryReader2) ReadInt16() int16 {
+	return int16(r.ReadUint16())
+}
+
+// ReadInt32 reads a int32.
+func (r *BinaryReader2) ReadInt32() int32 {
+	return int32(r.ReadUint32())
+}
+
+// ReadInt64 reads a int64.
+func (r *BinaryReader2) ReadInt64() int64 {
+	return int64(r.ReadUint64())
+}
+
 // BinaryWriter is a big endian binary file format writer.
 type BinaryWriter struct {
 	buf []byte

vendor/github.com/tdewolff/parse/v2/binary_unix.go

@@ -0,0 +1,83 @@
+//go:build unix
+
+package parse
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+	"syscall"
+)
+
+type binaryReaderMmap struct {
+	data []byte
+}
+
+func newBinaryReaderMmap(filename string) (*binaryReaderMmap, error) {
+	f, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	fi, err := f.Stat()
+	if err != nil {
+		return nil, err
+	}
+
+	size := fi.Size()
+	if size == 0 {
+		// Treat (size == 0) as a special case, avoiding the syscall, since
+		// "man 2 mmap" says "the length... must be greater than 0".
+		//
+		// As we do not call syscall.Mmap, there is no need to call
+		// runtime.SetFinalizer to enforce a balancing syscall.Munmap.
+		return &binaryReaderMmap{
+			data: make([]byte, 0),
+		}, nil
+	} else if size < 0 {
+		return nil, fmt.Errorf("mmap: file %q has negative size", filename)
+	} else if size != int64(int(size)) {
+		return nil, fmt.Errorf("mmap: file %q is too large", filename)
+	}
+
+	data, err := syscall.Mmap(int(f.Fd()), 0, int(size), syscall.PROT_READ, syscall.MAP_SHARED)
+	if err != nil {
+		return nil, err
+	}
+	r := &binaryReaderMmap{data}
+	runtime.SetFinalizer(r, (*binaryReaderMmap).Close)
+	return r, nil
+}
+
+// Close closes the reader.
+func (r *binaryReaderMmap) Close() error {
+	if r.data == nil {
+		return nil
+	} else if len(r.data) == 0 {
+		r.data = nil
+		return nil
+	}
+	data := r.data
+	r.data = nil
+	runtime.SetFinalizer(r, nil)
+	return syscall.Munmap(data)
+}
+
+// Len returns the length of the underlying memory-mapped file.
+func (r *binaryReaderMmap) Len() int {
+	return len(r.data)
+}
+
+func (r *binaryReaderMmap) Bytes(n int, off int64) ([]byte, error) {
+	if r.data == nil {
+		return nil, errors.New("mmap: closed")
+	} else if off < 0 || int64(len(r.data)) < off {
+		return nil, fmt.Errorf("mmap: invalid offset %d", off)
+	} else if int64(len(r.data)-n) < off {
+		return r.data[off:len(r.data):len(r.data)], io.EOF
+	}
+	return r.data[off : off+int64(n) : off+int64(n)], nil
+}

vendor/github.com/tdewolff/parse/v2/html/lex.go

@@ -362,7 +362,7 @@ func (l *Lexer) shiftBogusComment() []byte {
 
 func (l *Lexer) shiftStartTag() (TokenType, []byte) {
 	for {
-		if c := l.r.Peek(0); c == ' ' || c == '>' || c == '/' && l.r.Peek(1) == '>' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == 0 && l.r.Err() != nil {
+		if c := l.r.Peek(0); (c < 'a' || 'z' < c) && (c < 'A' || 'Z' < c) && (c < '0' || '9' < c) && c != '-' {
 			break
 		}
 		l.r.Move(1)

vendor/modules.txt

@@ -832,11 +832,11 @@ github.com/superseriousbusiness/oauth2/v4/generates
 github.com/superseriousbusiness/oauth2/v4/manage
 github.com/superseriousbusiness/oauth2/v4/models
 github.com/superseriousbusiness/oauth2/v4/server
-# github.com/tdewolff/minify/v2 v2.20.37
+# github.com/tdewolff/minify/v2 v2.21.0
 ## explicit; go 1.18
 github.com/tdewolff/minify/v2
 github.com/tdewolff/minify/v2/html
-# github.com/tdewolff/parse/v2 v2.7.15
+# github.com/tdewolff/parse/v2 v2.7.17
 ## explicit; go 1.13
 github.com/tdewolff/parse/v2
 github.com/tdewolff/parse/v2/buffer