SuperSeriousBusiness
/
GoToSocial
mirror of https://github.com/superseriousbusiness/gotosocial
1
1
Fork 0
Code Issues Projects Releases Wiki Activity

[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>
This commit is contained in:
dependabot[bot] 2024-10-21 11:39:43 +02:00 committed by GitHub
parent ea1bf5f8a3
commit f301ec65f1
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
8 changed files with 414 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
go.mod
View File

@ -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

8
go.sum generated
View File

@ -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.20.37/go.mod h1:L1VYef/jwKw6Wwyk5A+T0mBjjn3mMPgmjjA688RNsxU=
github.com/tdewolff/parse/v2 v2.7.15 h1:hysDXtdGZIRF5UZXwpfn3ZWRbm+ru4l53/ajBRGpCTw=
github.com/tdewolff/parse/v2 v2.7.15/go.mod h1:3FbJWZp3XT9OWVN3Hmfp0p/a08v4h8J9W1aghka0soA=
github.com/tdewolff/minify/v2 v2.21.0 h1:nAPP1UVx0aK1xsQh/JiG3xyEnnqWw+agPstn+V6Pkto=
github.com/tdewolff/minify/v2 v2.21.0/go.mod h1:hGcthJ6Vj51NG+9QRIfN/DpWj5loHnY3bfhThzWWq08=
github.com/tdewolff/parse/v2 v2.7.17 h1:uC10p6DaQQORDy72eaIyD+AvAkaIUOouQ0nWp4uD0D0=
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=

6
vendor/github.com/tdewolff/minify/v2/html/html.go generated vendored
View File

@ -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()
}
}

4
vendor/github.com/tdewolff/minify/v2/html/table.go generated vendored
View File

@ -74,7 +74,7 @@ var tagMap = map[Hash]traits{
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 @@ var tagMap = map[Hash]traits{
Th: blockTag,
Thead: blockTag,
Time: normalTag,
Title: normalTag,
Title: blockTag,
Tr: blockTag,
Track: normalTag,
U: normalTag,

317
vendor/github.com/tdewolff/parse/v2/binary.go generated vendored
View File

@ -2,12 +2,15 @@ package parse
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

83
vendor/github.com/tdewolff/parse/v2/binary_unix.go generated vendored Normal file
View File

@ -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
}

2
vendor/github.com/tdewolff/parse/v2/html/lex.go generated vendored
View File

@ -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)

4
vendor/modules.txt vendored
View File

@ -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