SVI Обновление вендоринга

Makefile

@@ -12,14 +12,14 @@ dev.run:
 	clear
 	rm -rf ./bin_dev
 	mkdir -p ./bin_dev
-	cp -rf ./static ./bin_dev
+	cp -rf ./web ./bin_dev
 	go fmt ./...
 	go build -race -o ./bin_dev/gostore_dev ./cmd/gostore/main.go
 	./dev.sh
 mod:
 	clear
 	go get -u ./...
-	go mod tidy -compat=1.21
+	go mod tidy -compat=1.22.0
 	go mod vendor
 	go fmt ./...
 test.run:

go.mod

@@ -1,6 +1,6 @@
 module git.p78su.freemyip.com/svi/gostore
 
-go 1.21.1
+go 1.22.0
 
 require (
 	github.com/gofiber/fiber/v2 v2.52.0
@@ -9,20 +9,20 @@ require (
 )
 
 require (
-	github.com/andybalholm/brotli v1.0.6 // indirect
+	github.com/andybalholm/brotli v1.1.0 // indirect
 	github.com/gofiber/template v1.8.2 // indirect
 	github.com/gofiber/utils v1.1.0 // indirect
 	github.com/golang/snappy v0.0.4 // indirect
-	github.com/google/uuid v1.5.0 // indirect
-	github.com/klauspost/compress v1.17.4 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/klauspost/compress v1.17.6 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.15 // indirect
 	github.com/philhofer/fwd v1.1.2 // indirect
-	github.com/rivo/uniseg v0.4.4 // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/tinylib/msgp v1.1.9 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
-	github.com/valyala/fasthttp v1.51.0 // indirect
+	github.com/valyala/fasthttp v1.52.0 // indirect
 	github.com/valyala/tcplisten v1.0.0 // indirect
-	golang.org/x/sys v0.16.0 // indirect
+	golang.org/x/sys v0.17.0 // indirect
 )

go.sum

@@ -1,5 +1,5 @@
-github.com/andybalholm/brotli v1.0.6 h1:Yf9fFpf49Zrxb9NlQaluyE92/+X7UVHlhMNJN2sxfOI=
-github.com/andybalholm/brotli v1.0.6/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
+github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M=
+github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
@@ -15,12 +15,12 @@ github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5y
 github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=
-github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
-github.com/klauspost/compress v1.17.4 h1:Ej5ixsIri7BrIjBkRZLTo6ghwrEtHFk7ijlczPW4fZ4=
-github.com/klauspost/compress v1.17.4/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM=
+github.com/klauspost/compress v1.17.6 h1:60eq2E/jlfwQXtvZEeBUYADs+BwKBWURIY+Gj2eRGjI=
+github.com/klauspost/compress v1.17.6/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
@@ -38,8 +38,8 @@ github.com/philhofer/fwd v1.1.2/go.mod h1:qkPdfjR2SIEbspLqpe1tO4n5yICnr2DY7mqEx2
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
-github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/syndtr/goleveldb v1.0.0 h1:fBdIW9lB4Iz0n9khmH8w27SJ3QEJ7+IgjPEwGSZiFdE=
@@ -48,22 +48,22 @@ github.com/tinylib/msgp v1.1.9 h1:SHf3yoO2sGA0veCJeCBYLHuttAVFHGm2RHgNodW7wQU=
 github.com/tinylib/msgp v1.1.9/go.mod h1:BCXGB54lDD8qUEPmiG0cQQUANC4IUQyB2ItS2UDlO/k=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
-github.com/valyala/fasthttp v1.51.0 h1:8b30A5JlZ6C7AS81RsWjYMQmrZG6feChmgAolCl1SqA=
-github.com/valyala/fasthttp v1.51.0/go.mod h1:oI2XroL+lI7vdXyYoQk03bXBThfFl2cVdIA3Xl7cH8g=
+github.com/valyala/fasthttp v1.52.0 h1:wqBQpxH71XW0e2g+Og4dzQM8pk34aFYlA1Ga8db7gU0=
+github.com/valyala/fasthttp v1.52.0/go.mod h1:hf5C4QnVMkNXMspnsUlfM3WitlgYflyhHYoKol/szxQ=
 github.com/valyala/tcplisten v1.0.0 h1:rBHj/Xf+E1tRGZyWIWwJDiRY0zc1Js+CV5DqwacVSA8=
 github.com/valyala/tcplisten v1.0.0/go.mod h1:T0xQ8SeCZGxckz9qRXTfG43PvQ/mcWh7FwZEA7Ioqkc=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=
-golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
+golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
-golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
-golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=

make.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+import sys
+import os
+import subprocess
+
+build = "go build -o ./bin/gostore ./cmd/gostore/main.go"
+build_dev = "go build -o " +\
+    "./bin_dev/gostore_dev ./cmd/gostore/main.go"
+
+
+def help() -> None:
+    """Выводит справку по использованию"""
+    s = """
+
+СПРАВКА
+
+    ./make.py
+    ./make.py --help
+        Выводит справку по использованию
+
+    ./make.py build
+        Сборка проекта
+
+    ./make.py dev.run
+        Отладка проекта
+
+    ./make.py mod
+        Обновление модулей/вендринга
+
+    ./make.py test.run
+        Тестирование
+
+    ./make.py lint
+        Запуск линтеров
+    """
+    print(s)
+
+
+class TBuild:
+    """Класс для сборки проекта"""
+
+    def __init__(self):
+        pass
+
+    def run(self) -> None:
+        print("Сборка проекта")
+        os.system("go fmt ./...")
+        t = TTest()
+        t.run()
+        linter = TLint()
+        linter.run()
+        os.system(build)
+        os.system("strip -s ./bin/notify_service")
+        os.system("upx -f ./bin/notify_service")
+
+
+class TDev:
+    """Класс для отладки проекта"""
+
+    def __init__(self):
+        pass
+
+    def run(self) -> None:
+        print("Сборка отладки проекта")
+        print('Установка перменных окружения')
+        os.unsetenv("STAGE")
+        os.environ['STAGE'] = "local"
+
+        print('Зачистка путей')
+        os.system('rm -frd ./bin_dev')
+        os.system('mkdir -p ./bin_dev/web')
+        os.system('cp -r ./web ./bin_dev')
+        os.system("go fmt ./...")
+        os.system(build_dev)
+
+        os.chdir('./bin_dev')
+        os.system('./fedor_dev')
+
+
+class TMod:
+    """Класс для обновления модулей"""
+
+    def __init__(self):
+        pass
+
+    def run(self) -> None:
+        print("Обновление модулей (режим совместимости с Go 1.22)")
+        os.system("go get -u ./...")
+        os.system("go mod tidy -compat=1.22.0")
+        os.system("go mod vendor")
+        os.system("go fmt ./...")
+
+
+class TTest:
+    """Класс для тестирования"""
+
+    def __init__(self):
+        pass
+
+    def run(self) -> None:
+        print("Тестирование...")
+        lst_cmd = ['go', 'test', '-shuffle=on', '-vet=all',
+                   '-race', '-timeout', '30s', '-coverprofile',
+                   'cover.out', './...']
+        _result = subprocess.run(
+            lst_cmd, stdout=subprocess.PIPE)
+        result = _result.stdout.decode('utf-8')
+        lst_cmd = ['go', 'tool', 'cover', '-func=cover.out']
+        _result_cover = subprocess.run(
+            lst_cmd, stdout=subprocess.PIPE)
+        result_cover = _result_cover.stdout.decode('utf-8')
+        result += result_cover
+        out = ''
+        out += self.cover_packet(result)
+        out += self.cover_func(result)
+        out += self.control_fail(result)
+        result = result.replace('\t', '  ')
+        result = result.replace('  ', ' ')
+        result = result.replace('  ', ' ')
+        out = out.replace("\t", " ")
+        out = out.replace("  ", " ")
+        print(f'==========[ OUT ]==========\n{result}\n')
+        total = self.cover_total(result_cover)
+        if total < '85.0%':
+            out += f'Слишком низкое прокрытие тестами({total})\n'
+        print(f'==========[ ANALIZE ]==========\n{out}\n')
+        if out != '':
+            print('==========[ FINAL FAIL ]==========\n')
+            print(f'Покрытие примерно: {total}')
+            sys.exit(100)
+
+        print('==========[ FINAL OK ]==========\n')
+        print(f'Покрытие тестами: {total}')
+
+    def cover_total(self, result_cover: str) -> str:
+        """Проверяет, достаточный уровень покрытия тестами
+        """
+        lst_cover = result_cover.split('\n')
+        cover_total = lst_cover[-2]
+        lst_cover = cover_total.split('\t')
+        total = lst_cover[-1]
+        return total
+
+    def control_fail(self, result: str) -> str:
+        """Проверяет, что тест провален
+        """
+        lst_str = result.split('\n')
+        out = ''
+        for _str in lst_str:
+            if 'FAIL' in _str:
+                if _str == 'FAIL':
+                    continue
+                out += 'TTest.control_fail(): тест провален'
+                out += '\n'+_str+'\n\n'
+        return out
+
+    def cover_func(self, result: str) -> str:
+        """Проверяет, что функция покрыта тестами
+        """
+        lst_str = result.split('\n')
+        out = ''
+        for _str in lst_str:
+            if ('%' in _str) and\
+                (_str.find('cover') == -1) and\
+                    (_str.find('\t%v') == -1):
+                substr1 = _str.split('\t')[-1]
+                _s = substr1[:-1]
+                if len(_s) > 2 and float(_s) < 40.0:
+                    out += 'TTest.cover_func(): функция плохо покрыта тестами'
+                    out += '\n'+_str+'\n\n'
+        return out
+
+    def cover_packet(self, result: str) -> str:
+        """Проверяет, что пакет покрыт тестами
+        """
+        lst_str = result.split('\n')
+        out = ''
+        for _str in lst_str:
+            if '?' in _str:
+                out += 'TTest.cover_packet(): пакет не покрыт тестами'
+                out += '\n'+_str+'\n'
+        return out
+
+
+class TLint:
+    """Класс для запуска динтеров"""
+
+    def __init__(self):
+        pass
+
+    def run(self) -> None:
+        print("Проверка кода")
+        os.system("go fmt ./...")
+        os.system("golangci-lint run ./...")
+        os.system("gocyclo -over 12 ./cmd/")
+        os.system("gocyclo -over 12 ./internal/")
+        os.system("gocyclo -over 12 ./pkg/")
+        os.system("gosec ./...")
+
+
+if __name__ == '__main__':
+    os.system("clear")
+    args = sys.argv
+    if len(args) < 2:
+        help()
+        sys.exit(1)
+    cmd = args[1]
+    if cmd == "help":
+        help()
+        sys.exit(2)
+    elif cmd == "build":
+        b = TBuild()
+        b.run()
+    elif cmd == "mod":
+        m = TMod()
+        m.run()
+    elif cmd == "test.run":
+        t = TTest()
+        t.run()
+    elif cmd == "lint":
+        linter = TLint()
+        linter.run()
+    elif cmd == "dev.run":
+        d = TDev()
+        d.run()
+    elif cmd == "":
+        help()
+        sys.exit(3)
+    sys.exit(0)

vendor/github.com/andybalholm/brotli/README.md

@@ -2,6 +2,13 @@ This package is a brotli compressor and decompressor implemented in Go.
 It was translated from the reference implementation (https://github.com/google/brotli)
 with the `c2go` tool at https://github.com/andybalholm/c2go.
 
+I have been working on new compression algorithms (not translated from C)
+in the matchfinder package.
+You can use them with the NewWriterV2 function.
+Currently they give better results than the old implementation
+(at least for compressing my test file, Newton’s *Opticks*) 
+on levels 2 to 6.
+
 I am using it in production with https://github.com/andybalholm/redwood.
 
 API documentation is found at https://pkg.go.dev/github.com/andybalholm/brotli?tab=doc.

vendor/github.com/andybalholm/brotli/bitwriter.go

@@ -0,0 +1,56 @@
+package brotli
+
+/* Copyright 2010 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+/* Write bits into a byte array. */
+
+type bitWriter struct {
+	dst []byte
+
+	// Data waiting to be written is the low nbits of bits.
+	bits  uint64
+	nbits uint
+}
+
+func (w *bitWriter) writeBits(nb uint, b uint64) {
+	w.bits |= b << w.nbits
+	w.nbits += nb
+	if w.nbits >= 32 {
+		bits := w.bits
+		w.bits >>= 32
+		w.nbits -= 32
+		w.dst = append(w.dst,
+			byte(bits),
+			byte(bits>>8),
+			byte(bits>>16),
+			byte(bits>>24),
+		)
+	}
+}
+
+func (w *bitWriter) writeSingleBit(bit bool) {
+	if bit {
+		w.writeBits(1, 1)
+	} else {
+		w.writeBits(1, 0)
+	}
+}
+
+func (w *bitWriter) jumpToByteBoundary() {
+	dst := w.dst
+	for w.nbits != 0 {
+		dst = append(dst, byte(w.bits))
+		w.bits >>= 8
+		if w.nbits > 8 { // Avoid underflow
+			w.nbits -= 8
+		} else {
+			w.nbits = 0
+		}
+	}
+	w.bits = 0
+	w.dst = dst
+}

vendor/github.com/andybalholm/brotli/brotli_bit_stream.go

@@ -7,12 +7,18 @@ import (
 
 const maxHuffmanTreeSize = (2*numCommandSymbols + 1)
 
-/* The maximum size of Huffman dictionary for distances assuming that
-   NPOSTFIX = 0 and NDIRECT = 0. */
+/*
+The maximum size of Huffman dictionary for distances assuming that
+
+	NPOSTFIX = 0 and NDIRECT = 0.
+*/
 const maxSimpleDistanceAlphabetSize = 140
 
-/* Represents the range of values belonging to a prefix code:
-   [offset, offset + 2^nbits) */
+/*
+Represents the range of values belonging to a prefix code:
+
+	[offset, offset + 2^nbits)
+*/
 type prefixCodeRange struct {
 	offset uint32
 	nbits  uint32
@@ -96,9 +102,12 @@ func nextBlockTypeCode(calculator *blockTypeCodeCalculator, type_ byte) uint {
 	return type_code
 }
 
-/* |nibblesbits| represents the 2 bits to encode MNIBBLES (0-3)
-   REQUIRES: length > 0
-   REQUIRES: length <= (1 << 24) */
+/*
+|nibblesbits| represents the 2 bits to encode MNIBBLES (0-3)
+
+	REQUIRES: length > 0
+	REQUIRES: length <= (1 << 24)
+*/
 func encodeMlen(length uint, bits *uint64, numbits *uint, nibblesbits *uint64) {
 	var lg uint
 	if length == 1 {
@@ -132,8 +141,11 @@ func storeCommandExtra(cmd *command, storage_ix *uint, storage []byte) {
 	writeBits(uint(insnumextra+getCopyExtra(copycode)), bits, storage_ix, storage)
 }
 
-/* Data structure that stores almost everything that is needed to encode each
-   block switch command. */
+/*
+Data structure that stores almost everything that is needed to encode each
+
+	block switch command.
+*/
 type blockSplitCode struct {
 	type_code_calculator blockTypeCodeCalculator
 	type_depths          [maxBlockTypeSymbols]byte
@@ -154,9 +166,12 @@ func storeVarLenUint8(n uint, storage_ix *uint, storage []byte) {
 	}
 }
 
-/* Stores the compressed meta-block header.
-   REQUIRES: length > 0
-   REQUIRES: length <= (1 << 24) */
+/*
+Stores the compressed meta-block header.
+
+	REQUIRES: length > 0
+	REQUIRES: length <= (1 << 24)
+*/
 func storeCompressedMetaBlockHeader(is_final_block bool, length uint, storage_ix *uint, storage []byte) {
 	var lenbits uint64
 	var nlenbits uint
@@ -186,9 +201,12 @@ func storeCompressedMetaBlockHeader(is_final_block bool, length uint, storage_ix
 	}
 }
 
-/* Stores the uncompressed meta-block header.
-   REQUIRES: length > 0
-   REQUIRES: length <= (1 << 24) */
+/*
+Stores the uncompressed meta-block header.
+
+	REQUIRES: length > 0
+	REQUIRES: length <= (1 << 24)
+*/
 func storeUncompressedMetaBlockHeader(length uint, storage_ix *uint, storage []byte) {
 	var lenbits uint64
 	var nlenbits uint
@@ -312,8 +330,11 @@ func storeSimpleHuffmanTree(depths []byte, symbols []uint, num_symbols uint, max
 	}
 }
 
-/* num = alphabet size
-   depths = symbol depths */
+/*
+num = alphabet size
+
+	depths = symbol depths
+*/
 func storeHuffmanTree(depths []byte, num uint, tree []huffmanTree, storage_ix *uint, storage []byte) {
 	var huffman_tree [numCommandSymbols]byte
 	var huffman_tree_extra_bits [numCommandSymbols]byte
@@ -367,8 +388,11 @@ func storeHuffmanTree(depths []byte, num uint, tree []huffmanTree, storage_ix *u
 	storeHuffmanTreeToBitMask(huffman_tree_size, huffman_tree[:], huffman_tree_extra_bits[:], code_length_bitdepth[:], code_length_bitdepth_symbols[:], storage_ix, storage)
 }
 
-/* Builds a Huffman tree from histogram[0:length] into depth[0:length] and
-   bits[0:length] and stores the encoded tree to the bit stream. */
+/*
+Builds a Huffman tree from histogram[0:length] into depth[0:length] and
+
+	bits[0:length] and stores the encoded tree to the bit stream.
+*/
 func buildAndStoreHuffmanTree(histogram []uint32, histogram_length uint, alphabet_size uint, tree []huffmanTree, depth []byte, bits []uint16, storage_ix *uint, storage []byte) {
 	var count uint = 0
 	var s4 = [4]uint{0}
@@ -623,6 +647,203 @@ func buildAndStoreHuffmanTreeFast(histogram []uint32, histogram_total uint, max_
 	}
 }
 
+func buildAndStoreHuffmanTreeFastBW(histogram []uint32, histogram_total uint, max_bits uint, depth []byte, bits []uint16, bw *bitWriter) {
+	var count uint = 0
+	var symbols = [4]uint{0}
+	var length uint = 0
+	var total uint = histogram_total
+	for total != 0 {
+		if histogram[length] != 0 {
+			if count < 4 {
+				symbols[count] = length
+			}
+
+			count++
+			total -= uint(histogram[length])
+		}
+
+		length++
+	}
+
+	if count <= 1 {
+		bw.writeBits(4, 1)
+		bw.writeBits(max_bits, uint64(symbols[0]))
+		depth[symbols[0]] = 0
+		bits[symbols[0]] = 0
+		return
+	}
+
+	for i := 0; i < int(length); i++ {
+		depth[i] = 0
+	}
+	{
+		var max_tree_size uint = 2*length + 1
+		tree, _ := huffmanTreePool.Get().(*[]huffmanTree)
+		if tree == nil || cap(*tree) < int(max_tree_size) {
+			tmp := make([]huffmanTree, max_tree_size)
+			tree = &tmp
+		} else {
+			*tree = (*tree)[:max_tree_size]
+		}
+		var count_limit uint32
+		for count_limit = 1; ; count_limit *= 2 {
+			var node int = 0
+			var l uint
+			for l = length; l != 0; {
+				l--
+				if histogram[l] != 0 {
+					if histogram[l] >= count_limit {
+						initHuffmanTree(&(*tree)[node:][0], histogram[l], -1, int16(l))
+					} else {
+						initHuffmanTree(&(*tree)[node:][0], count_limit, -1, int16(l))
+					}
+
+					node++
+				}
+			}
+			{
+				var n int = node
+				/* Points to the next leaf node. */ /* Points to the next non-leaf node. */
+				var sentinel huffmanTree
+				var i int = 0
+				var j int = n + 1
+				var k int
+
+				sortHuffmanTreeItems(*tree, uint(n), huffmanTreeComparator(sortHuffmanTree1))
+
+				/* The nodes are:
+				   [0, n): the sorted leaf nodes that we start with.
+				   [n]: we add a sentinel here.
+				   [n + 1, 2n): new parent nodes are added here, starting from
+				                (n+1). These are naturally in ascending order.
+				   [2n]: we add a sentinel at the end as well.
+				   There will be (2n+1) elements at the end. */
+				initHuffmanTree(&sentinel, math.MaxUint32, -1, -1)
+
+				(*tree)[node] = sentinel
+				node++
+				(*tree)[node] = sentinel
+				node++
+
+				for k = n - 1; k > 0; k-- {
+					var left int
+					var right int
+					if (*tree)[i].total_count_ <= (*tree)[j].total_count_ {
+						left = i
+						i++
+					} else {
+						left = j
+						j++
+					}
+
+					if (*tree)[i].total_count_ <= (*tree)[j].total_count_ {
+						right = i
+						i++
+					} else {
+						right = j
+						j++
+					}
+
+					/* The sentinel node becomes the parent node. */
+					(*tree)[node-1].total_count_ = (*tree)[left].total_count_ + (*tree)[right].total_count_
+
+					(*tree)[node-1].index_left_ = int16(left)
+					(*tree)[node-1].index_right_or_value_ = int16(right)
+
+					/* Add back the last sentinel node. */
+					(*tree)[node] = sentinel
+					node++
+				}
+
+				if setDepth(2*n-1, *tree, depth, 14) {
+					/* We need to pack the Huffman tree in 14 bits. If this was not
+					   successful, add fake entities to the lowest values and retry. */
+					break
+				}
+			}
+		}
+
+		huffmanTreePool.Put(tree)
+	}
+
+	convertBitDepthsToSymbols(depth, length, bits)
+	if count <= 4 {
+		var i uint
+
+		/* value of 1 indicates a simple Huffman code */
+		bw.writeBits(2, 1)
+
+		bw.writeBits(2, uint64(count)-1) /* NSYM - 1 */
+
+		/* Sort */
+		for i = 0; i < count; i++ {
+			var j uint
+			for j = i + 1; j < count; j++ {
+				if depth[symbols[j]] < depth[symbols[i]] {
+					var tmp uint = symbols[j]
+					symbols[j] = symbols[i]
+					symbols[i] = tmp
+				}
+			}
+		}
+
+		if count == 2 {
+			bw.writeBits(max_bits, uint64(symbols[0]))
+			bw.writeBits(max_bits, uint64(symbols[1]))
+		} else if count == 3 {
+			bw.writeBits(max_bits, uint64(symbols[0]))
+			bw.writeBits(max_bits, uint64(symbols[1]))
+			bw.writeBits(max_bits, uint64(symbols[2]))
+		} else {
+			bw.writeBits(max_bits, uint64(symbols[0]))
+			bw.writeBits(max_bits, uint64(symbols[1]))
+			bw.writeBits(max_bits, uint64(symbols[2]))
+			bw.writeBits(max_bits, uint64(symbols[3]))
+
+			/* tree-select */
+			bw.writeSingleBit(depth[symbols[0]] == 1)
+		}
+	} else {
+		var previous_value byte = 8
+		var i uint
+
+		/* Complex Huffman Tree */
+		storeStaticCodeLengthCodeBW(bw)
+
+		/* Actual RLE coding. */
+		for i = 0; i < length; {
+			var value byte = depth[i]
+			var reps uint = 1
+			var k uint
+			for k = i + 1; k < length && depth[k] == value; k++ {
+				reps++
+			}
+
+			i += reps
+			if value == 0 {
+				bw.writeBits(uint(kZeroRepsDepth[reps]), kZeroRepsBits[reps])
+			} else {
+				if previous_value != value {
+					bw.writeBits(uint(kCodeLengthDepth[value]), uint64(kCodeLengthBits[value]))
+					reps--
+				}
+
+				if reps < 3 {
+					for reps != 0 {
+						reps--
+						bw.writeBits(uint(kCodeLengthDepth[value]), uint64(kCodeLengthBits[value]))
+					}
+				} else {
+					reps -= 3
+					bw.writeBits(uint(kNonZeroRepsDepth[reps]), kNonZeroRepsBits[reps])
+				}
+
+				previous_value = value
+			}
+		}
+	}
+}
+
 func indexOf(v []byte, v_size uint, value byte) uint {
 	var i uint = 0
 	for ; i < v_size; i++ {
@@ -674,12 +895,15 @@ func moveToFrontTransform(v_in []uint32, v_size uint, v_out []uint32) {
 	}
 }
 
-/* Finds runs of zeros in v[0..in_size) and replaces them with a prefix code of
-   the run length plus extra bits (lower 9 bits is the prefix code and the rest
-   are the extra bits). Non-zero values in v[] are shifted by
-   *max_length_prefix. Will not create prefix codes bigger than the initial
-   value of *max_run_length_prefix. The prefix code of run length L is simply
-   Log2Floor(L) and the number of extra bits is the same as the prefix code. */
+/*
+Finds runs of zeros in v[0..in_size) and replaces them with a prefix code of
+
+	the run length plus extra bits (lower 9 bits is the prefix code and the rest
+	are the extra bits). Non-zero values in v[] are shifted by
+	*max_length_prefix. Will not create prefix codes bigger than the initial
+	value of *max_run_length_prefix. The prefix code of run length L is simply
+	Log2Floor(L) and the number of extra bits is the same as the prefix code.
+*/
 func runLengthCodeZeros(in_size uint, v []uint32, out_size *uint, max_run_length_prefix *uint32) {
 	var max_reps uint32 = 0
 	var i uint
@@ -799,8 +1023,11 @@ func storeBlockSwitch(code *blockSplitCode, block_len uint32, block_type byte, i
 	writeBits(uint(len_nextra), uint64(len_extra), storage_ix, storage)
 }
 
-/* Builds a BlockSplitCode data structure from the block split given by the
-   vector of block types and block lengths and stores it to the bit stream. */
+/*
+Builds a BlockSplitCode data structure from the block split given by the
+
+	vector of block types and block lengths and stores it to the bit stream.
+*/
 func buildAndStoreBlockSplitCode(types []byte, lengths []uint32, num_blocks uint, num_types uint, tree []huffmanTree, code *blockSplitCode, storage_ix *uint, storage []byte) {
 	var type_histo [maxBlockTypeSymbols]uint32
 	var length_histo [numBlockLenSymbols]uint32
@@ -919,14 +1146,20 @@ func cleanupBlockEncoder(self *blockEncoder) {
 	blockEncoderPool.Put(self)
 }
 
-/* Creates entropy codes of block lengths and block types and stores them
-   to the bit stream. */
+/*
+Creates entropy codes of block lengths and block types and stores them
+
+	to the bit stream.
+*/
 func buildAndStoreBlockSwitchEntropyCodes(self *blockEncoder, tree []huffmanTree, storage_ix *uint, storage []byte) {
 	buildAndStoreBlockSplitCode(self.block_types_, self.block_lengths_, self.num_blocks_, self.num_block_types_, tree, &self.block_split_code_, storage_ix, storage)
 }
 
-/* Stores the next symbol with the entropy code of the current block type.
-   Updates the block type and block length at block boundaries. */
+/*
+Stores the next symbol with the entropy code of the current block type.
+
+	Updates the block type and block length at block boundaries.
+*/
 func storeSymbol(self *blockEncoder, symbol uint, storage_ix *uint, storage []byte) {
 	if self.block_len_ == 0 {
 		self.block_ix_++
@@ -945,9 +1178,12 @@ func storeSymbol(self *blockEncoder, symbol uint, storage_ix *uint, storage []by
 	}
 }
 
-/* Stores the next symbol with the entropy code of the current block type and
-   context value.
-   Updates the block type and block length at block boundaries. */
+/*
+Stores the next symbol with the entropy code of the current block type and
+
+	context value.
+	Updates the block type and block length at block boundaries.
+*/
 func storeSymbolWithContext(self *blockEncoder, symbol uint, context uint, context_map []uint32, storage_ix *uint, storage []byte, context_bits uint) {
 	if self.block_len_ == 0 {
 		self.block_ix_++
@@ -1268,8 +1504,11 @@ func storeMetaBlockFast(input []byte, start_pos uint, length uint, mask uint, is
 	}
 }
 
-/* This is for storing uncompressed blocks (simple raw storage of
-   bytes-as-bytes). */
+/*
+This is for storing uncompressed blocks (simple raw storage of
+
+	bytes-as-bytes).
+*/
 func storeUncompressedMetaBlock(is_final_block bool, input []byte, position uint, mask uint, len uint, storage_ix *uint, storage []byte) {
 	var masked_pos uint = position & mask
 	storeUncompressedMetaBlockHeader(uint(len), storage_ix, storage)

vendor/github.com/andybalholm/brotli/compress_fragment_two_pass.go

@@ -39,8 +39,11 @@ func isMatch1(p1 []byte, p2 []byte, length uint) bool {
 	return p1[4] == p2[4] && p1[5] == p2[5]
 }
 
-/* Builds a command and distance prefix code (each 64 symbols) into "depth" and
-   "bits" based on "histogram" and stores it into the bit stream. */
+/*
+Builds a command and distance prefix code (each 64 symbols) into "depth" and
+
+	"bits" based on "histogram" and stores it into the bit stream.
+*/
 func buildAndStoreCommandPrefixCode(histogram []uint32, depth []byte, bits []uint16, storage_ix *uint, storage []byte) {
 	var tree [129]huffmanTree
 	var cmd_depth = [numCommandSymbols]byte{0}
@@ -216,6 +219,25 @@ func storeMetaBlockHeader(len uint, is_uncompressed bool, storage_ix *uint, stor
 	writeSingleBit(is_uncompressed, storage_ix, storage)
 }
 
+func storeMetaBlockHeaderBW(len uint, is_uncompressed bool, bw *bitWriter) {
+	var nibbles uint = 6
+
+	/* ISLAST */
+	bw.writeBits(1, 0)
+
+	if len <= 1<<16 {
+		nibbles = 4
+	} else if len <= 1<<20 {
+		nibbles = 5
+	}
+
+	bw.writeBits(2, uint64(nibbles)-4)
+	bw.writeBits(nibbles*4, uint64(len)-1)
+
+	/* ISUNCOMPRESSED */
+	bw.writeSingleBit(is_uncompressed)
+}
+
 func createCommands(input []byte, block_size uint, input_size uint, base_ip_ptr []byte, table []int, table_bits uint, min_match uint, literals *[]byte, commands *[]uint32) {
 	var ip int = 0
 	var shift uint = 64 - table_bits
@@ -710,19 +732,22 @@ func compressFragmentTwoPassImpl(input []byte, input_size uint, is_last bool, co
 	}
 }
 
-/* Compresses "input" string to the "*storage" buffer as one or more complete
-   meta-blocks, and updates the "*storage_ix" bit position.
+/*
+Compresses "input" string to the "*storage" buffer as one or more complete
 
-   If "is_last" is 1, emits an additional empty last meta-block.
+	meta-blocks, and updates the "*storage_ix" bit position.
 
-   REQUIRES: "input_size" is greater than zero, or "is_last" is 1.
-   REQUIRES: "input_size" is less or equal to maximal metablock size (1 << 24).
-   REQUIRES: "command_buf" and "literal_buf" point to at least
-              kCompressFragmentTwoPassBlockSize long arrays.
-   REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero.
-   REQUIRES: "table_size" is a power of two
-   OUTPUT: maximal copy distance <= |input_size|
-   OUTPUT: maximal copy distance <= BROTLI_MAX_BACKWARD_LIMIT(18) */
+	If "is_last" is 1, emits an additional empty last meta-block.
+
+	REQUIRES: "input_size" is greater than zero, or "is_last" is 1.
+	REQUIRES: "input_size" is less or equal to maximal metablock size (1 << 24).
+	REQUIRES: "command_buf" and "literal_buf" point to at least
+	           kCompressFragmentTwoPassBlockSize long arrays.
+	REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero.
+	REQUIRES: "table_size" is a power of two
+	OUTPUT: maximal copy distance <= |input_size|
+	OUTPUT: maximal copy distance <= BROTLI_MAX_BACKWARD_LIMIT(18)
+*/
 func compressFragmentTwoPass(input []byte, input_size uint, is_last bool, command_buf []uint32, literal_buf []byte, table []int, table_size uint, storage_ix *uint, storage []byte) {
 	var initial_storage_ix uint = *storage_ix
 	var table_bits uint = uint(log2FloorNonZero(table_size))

vendor/github.com/andybalholm/brotli/encoder.go

@@ -0,0 +1,168 @@
+package brotli
+
+import "github.com/andybalholm/brotli/matchfinder"
+
+// An Encoder implements the matchfinder.Encoder interface, writing in Brotli format.
+type Encoder struct {
+	wroteHeader bool
+	bw          bitWriter
+	distCache   []distanceCode
+}
+
+func (e *Encoder) Reset() {
+	e.wroteHeader = false
+	e.bw = bitWriter{}
+}
+
+func (e *Encoder) Encode(dst []byte, src []byte, matches []matchfinder.Match, lastBlock bool) []byte {
+	e.bw.dst = dst
+	if !e.wroteHeader {
+		e.bw.writeBits(4, 15)
+		e.wroteHeader = true
+	}
+
+	var literalHisto [256]uint32
+	var commandHisto [704]uint32
+	var distanceHisto [64]uint32
+	literalCount := 0
+	commandCount := 0
+	distanceCount := 0
+
+	if len(e.distCache) < len(matches) {
+		e.distCache = make([]distanceCode, len(matches))
+	}
+
+	// first pass: build the histograms
+	pos := 0
+
+	// d is the ring buffer of the last 4 distances.
+	d := [4]int{-10, -10, -10, -10}
+	for i, m := range matches {
+		if m.Unmatched > 0 {
+			for _, c := range src[pos : pos+m.Unmatched] {
+				literalHisto[c]++
+			}
+			literalCount += m.Unmatched
+		}
+
+		insertCode := getInsertLengthCode(uint(m.Unmatched))
+		copyCode := getCopyLengthCode(uint(m.Length))
+		if m.Length == 0 {
+			// If the stream ends with unmatched bytes, we need a dummy copy length.
+			copyCode = 2
+		}
+		command := combineLengthCodes(insertCode, copyCode, false)
+		commandHisto[command]++
+		commandCount++
+
+		if command >= 128 && m.Length != 0 {
+			var distCode distanceCode
+			switch m.Distance {
+			case d[3]:
+				distCode.code = 0
+			case d[2]:
+				distCode.code = 1
+			case d[1]:
+				distCode.code = 2
+			case d[0]:
+				distCode.code = 3
+			case d[3] - 1:
+				distCode.code = 4
+			case d[3] + 1:
+				distCode.code = 5
+			case d[3] - 2:
+				distCode.code = 6
+			case d[3] + 2:
+				distCode.code = 7
+			case d[3] - 3:
+				distCode.code = 8
+			case d[3] + 3:
+				distCode.code = 9
+
+				// In my testing, codes 10–15 actually reduced the compression ratio.
+
+			default:
+				distCode = getDistanceCode(m.Distance)
+			}
+			e.distCache[i] = distCode
+			distanceHisto[distCode.code]++
+			distanceCount++
+			if distCode.code != 0 {
+				d[0], d[1], d[2], d[3] = d[1], d[2], d[3], m.Distance
+			}
+		}
+
+		pos += m.Unmatched + m.Length
+	}
+
+	storeMetaBlockHeaderBW(uint(len(src)), false, &e.bw)
+	e.bw.writeBits(13, 0)
+
+	var literalDepths [256]byte
+	var literalBits [256]uint16
+	buildAndStoreHuffmanTreeFastBW(literalHisto[:], uint(literalCount), 8, literalDepths[:], literalBits[:], &e.bw)
+
+	var commandDepths [704]byte
+	var commandBits [704]uint16
+	buildAndStoreHuffmanTreeFastBW(commandHisto[:], uint(commandCount), 10, commandDepths[:], commandBits[:], &e.bw)
+
+	var distanceDepths [64]byte
+	var distanceBits [64]uint16
+	buildAndStoreHuffmanTreeFastBW(distanceHisto[:], uint(distanceCount), 6, distanceDepths[:], distanceBits[:], &e.bw)
+
+	pos = 0
+	for i, m := range matches {
+		insertCode := getInsertLengthCode(uint(m.Unmatched))
+		copyCode := getCopyLengthCode(uint(m.Length))
+		if m.Length == 0 {
+			// If the stream ends with unmatched bytes, we need a dummy copy length.
+			copyCode = 2
+		}
+		command := combineLengthCodes(insertCode, copyCode, false)
+		e.bw.writeBits(uint(commandDepths[command]), uint64(commandBits[command]))
+		if kInsExtra[insertCode] > 0 {
+			e.bw.writeBits(uint(kInsExtra[insertCode]), uint64(m.Unmatched)-uint64(kInsBase[insertCode]))
+		}
+		if kCopyExtra[copyCode] > 0 {
+			e.bw.writeBits(uint(kCopyExtra[copyCode]), uint64(m.Length)-uint64(kCopyBase[copyCode]))
+		}
+
+		if m.Unmatched > 0 {
+			for _, c := range src[pos : pos+m.Unmatched] {
+				e.bw.writeBits(uint(literalDepths[c]), uint64(literalBits[c]))
+			}
+		}
+
+		if command >= 128 && m.Length != 0 {
+			distCode := e.distCache[i]
+			e.bw.writeBits(uint(distanceDepths[distCode.code]), uint64(distanceBits[distCode.code]))
+			if distCode.nExtra > 0 {
+				e.bw.writeBits(distCode.nExtra, distCode.extraBits)
+			}
+		}
+
+		pos += m.Unmatched + m.Length
+	}
+
+	if lastBlock {
+		e.bw.writeBits(2, 3) // islast + isempty
+		e.bw.jumpToByteBoundary()
+	}
+	return e.bw.dst
+}
+
+type distanceCode struct {
+	code      int
+	nExtra    uint
+	extraBits uint64
+}
+
+func getDistanceCode(distance int) distanceCode {
+	d := distance + 3
+	nbits := log2FloorNonZero(uint(d)) - 1
+	prefix := (d >> nbits) & 1
+	offset := (2 + prefix) << nbits
+	distcode := int(2*(nbits-1)) + prefix + 16
+	extra := d - offset
+	return distanceCode{distcode, uint(nbits), uint64(extra)}
+}

vendor/github.com/andybalholm/brotli/entropy_encode_static.go

@@ -782,6 +782,11 @@ func storeStaticCodeLengthCode(storage_ix *uint, storage []byte) {
 	writeBits(40, 0x0000FF55555554, storage_ix, storage)
 }
 
+func storeStaticCodeLengthCodeBW(bw *bitWriter) {
+	bw.writeBits(32, 0x55555554)
+	bw.writeBits(8, 0xFF)
+}
+
 var kZeroRepsBits = [numCommandSymbols]uint64{
 	0x00000000,
 	0x00000000,

vendor/github.com/andybalholm/brotli/http.go

@@ -20,7 +20,7 @@ func HTTPCompressor(w http.ResponseWriter, r *http.Request) io.WriteCloser {
 	switch encoding {
 	case "br":
 		w.Header().Set("Content-Encoding", "br")
-		return NewWriter(w)
+		return NewWriterV2(w, DefaultCompression)
 	case "gzip":
 		w.Header().Set("Content-Encoding", "gzip")
 		return gzip.NewWriter(w)

vendor/github.com/andybalholm/brotli/matchfinder/emitter.go

@@ -0,0 +1,45 @@
+package matchfinder
+
+// An absoluteMatch is like a Match, but it stores indexes into the byte
+// stream instead of lengths.
+type absoluteMatch struct {
+	// Start is the index of the first byte.
+	Start int
+
+	// End is the index of the byte after the last byte
+	// (so that End - Start = Length).
+	End int
+
+	// Match is the index of the previous data that matches
+	// (Start - Match = Distance).
+	Match int
+}
+
+// A matchEmitter manages the output of matches for a MatchFinder.
+type matchEmitter struct {
+	// Dst is the destination slice that Matches are added to.
+	Dst []Match
+
+	// NextEmit is the index of the next byte to emit.
+	NextEmit int
+}
+
+func (e *matchEmitter) emit(m absoluteMatch) {
+	e.Dst = append(e.Dst, Match{
+		Unmatched: m.Start - e.NextEmit,
+		Length:    m.End - m.Start,
+		Distance:  m.Start - m.Match,
+	})
+	e.NextEmit = m.End
+}
+
+// trim shortens m if it extends past maxEnd. Then if the length is at least
+// minLength, the match is emitted.
+func (e *matchEmitter) trim(m absoluteMatch, maxEnd int, minLength int) {
+	if m.End > maxEnd {
+		m.End = maxEnd
+	}
+	if m.End-m.Start >= minLength {
+		e.emit(m)
+	}
+}

vendor/github.com/andybalholm/brotli/matchfinder/m0.go

@@ -0,0 +1,169 @@
+package matchfinder
+
+import (
+	"encoding/binary"
+)
+
+// M0 is an implementation of the MatchFinder interface based
+// on the algorithm used by snappy, but modified to be more like the algorithm
+// used by compression level 0 of the brotli reference implementation.
+//
+// It has a maximum block size of 65536 bytes.
+type M0 struct {
+	// Lazy turns on "lazy matching," for higher compression but less speed.
+	Lazy bool
+
+	MaxDistance int
+	MaxLength   int
+}
+
+func (M0) Reset() {}
+
+const (
+	m0HashLen = 5
+
+	m0TableBits = 14
+	m0TableSize = 1 << m0TableBits
+	m0Shift     = 32 - m0TableBits
+	// m0TableMask is redundant, but helps the compiler eliminate bounds
+	// checks.
+	m0TableMask = m0TableSize - 1
+)
+
+func (m M0) hash(data uint64) uint64 {
+	hash := (data << (64 - 8*m0HashLen)) * hashMul64
+	return hash >> (64 - m0TableBits)
+}
+
+// FindMatches looks for matches in src, appends them to dst, and returns dst.
+// src must not be longer than 65536 bytes.
+func (m M0) FindMatches(dst []Match, src []byte) []Match {
+	const inputMargin = 16 - 1
+	const minNonLiteralBlockSize = 1 + 1 + inputMargin
+
+	if len(src) < minNonLiteralBlockSize {
+		dst = append(dst, Match{
+			Unmatched: len(src),
+		})
+		return dst
+	}
+	if len(src) > 65536 {
+		panic("block too long")
+	}
+
+	var table [m0TableSize]uint16
+
+	// sLimit is when to stop looking for offset/length copies. The inputMargin
+	// lets us use a fast path for emitLiteral in the main loop, while we are
+	// looking for copies.
+	sLimit := len(src) - inputMargin
+
+	// nextEmit is where in src the next emitLiteral should start from.
+	nextEmit := 0
+
+	// The encoded form must start with a literal, as there are no previous
+	// bytes to copy, so we start looking for hash matches at s == 1.
+	s := 1
+	nextHash := m.hash(binary.LittleEndian.Uint64(src[s:]))
+
+	for {
+		// Copied from the C++ snappy implementation:
+		//
+		// Heuristic match skipping: If 32 bytes are scanned with no matches
+		// found, start looking only at every other byte. If 32 more bytes are
+		// scanned (or skipped), look at every third byte, etc.. When a match
+		// is found, immediately go back to looking at every byte. This is a
+		// small loss (~5% performance, ~0.1% density) for compressible data
+		// due to more bookkeeping, but for non-compressible data (such as
+		// JPEG) it's a huge win since the compressor quickly "realizes" the
+		// data is incompressible and doesn't bother looking for matches
+		// everywhere.
+		//
+		// The "skip" variable keeps track of how many bytes there are since
+		// the last match; dividing it by 32 (ie. right-shifting by five) gives
+		// the number of bytes to move ahead for each iteration.
+		skip := 32
+
+		nextS := s
+		candidate := 0
+		for {
+			s = nextS
+			bytesBetweenHashLookups := skip >> 5
+			nextS = s + bytesBetweenHashLookups
+			skip += bytesBetweenHashLookups
+			if nextS > sLimit {
+				goto emitRemainder
+			}
+			candidate = int(table[nextHash&m0TableMask])
+			table[nextHash&m0TableMask] = uint16(s)
+			nextHash = m.hash(binary.LittleEndian.Uint64(src[nextS:]))
+			if m.MaxDistance != 0 && s-candidate > m.MaxDistance {
+				continue
+			}
+			if binary.LittleEndian.Uint32(src[s:]) == binary.LittleEndian.Uint32(src[candidate:]) {
+				break
+			}
+		}
+
+		// Invariant: we have a 4-byte match at s.
+		base := s
+		s = extendMatch(src, candidate+4, s+4)
+
+		origBase := base
+		if m.Lazy && base+1 < sLimit {
+			newBase := base + 1
+			h := m.hash(binary.LittleEndian.Uint64(src[newBase:]))
+			newCandidate := int(table[h&m0TableMask])
+			table[h&m0TableMask] = uint16(newBase)
+			okDistance := true
+			if m.MaxDistance != 0 && newBase-newCandidate > m.MaxDistance {
+				okDistance = false
+			}
+			if okDistance && binary.LittleEndian.Uint32(src[newBase:]) == binary.LittleEndian.Uint32(src[newCandidate:]) {
+				newS := extendMatch(src, newCandidate+4, newBase+4)
+				if newS-newBase > s-base+1 {
+					s = newS
+					base = newBase
+					candidate = newCandidate
+				}
+			}
+		}
+
+		if m.MaxLength != 0 && s-base > m.MaxLength {
+			s = base + m.MaxLength
+		}
+		dst = append(dst, Match{
+			Unmatched: base - nextEmit,
+			Length:    s - base,
+			Distance:  base - candidate,
+		})
+		nextEmit = s
+		if s >= sLimit {
+			goto emitRemainder
+		}
+
+		if m.Lazy {
+			// If lazy matching is enabled, we update the hash table for
+			// every byte in the match.
+			for i := origBase + 2; i < s-1; i++ {
+				x := binary.LittleEndian.Uint64(src[i:])
+				table[m.hash(x)&m0TableMask] = uint16(i)
+			}
+		}
+
+		// We could immediately start working at s now, but to improve
+		// compression we first update the hash table at s-1 and at s.
+		x := binary.LittleEndian.Uint64(src[s-1:])
+		prevHash := m.hash(x >> 0)
+		table[prevHash&m0TableMask] = uint16(s - 1)
+		nextHash = m.hash(x >> 8)
+	}
+
+emitRemainder:
+	if nextEmit < len(src) {
+		dst = append(dst, Match{
+			Unmatched: len(src) - nextEmit,
+		})
+	}
+	return dst
+}

vendor/github.com/andybalholm/brotli/matchfinder/m4.go

@@ -0,0 +1,297 @@
+package matchfinder
+
+import (
+	"encoding/binary"
+	"math/bits"
+	"runtime"
+)
+
+// M4 is an implementation of the MatchFinder
+// interface that uses a hash table to find matches,
+// optional match chains,
+// and the advanced parsing technique from
+// https://fastcompression.blogspot.com/2011/12/advanced-parsing-strategies.html.
+type M4 struct {
+	// MaxDistance is the maximum distance (in bytes) to look back for
+	// a match. The default is 65535.
+	MaxDistance int
+
+	// MinLength is the length of the shortest match to return.
+	// The default is 4.
+	MinLength int
+
+	// HashLen is the number of bytes to use to calculate the hashes.
+	// The maximum is 8 and the default is 6.
+	HashLen int
+
+	// TableBits is the number of bits in the hash table indexes.
+	// The default is 17 (128K entries).
+	TableBits int
+
+	// ChainLength is how many entries to search on the "match chain" of older
+	// locations with the same hash as the current location.
+	ChainLength int
+
+	// DistanceBitCost is used when comparing two matches to see
+	// which is better. The comparison is primarily based on the length
+	// of the matches, but it can also take the distance into account,
+	// in terms of the number of bits needed to represent the distance.
+	// One byte of length is given a score of 256, so 32 (256/8) would
+	// be a reasonable first guess for the value of one bit.
+	// (The default is 0, which bases the comparison solely on length.)
+	DistanceBitCost int
+
+	table []uint32
+	chain []uint16
+
+	history []byte
+}
+
+func (q *M4) Reset() {
+	for i := range q.table {
+		q.table[i] = 0
+	}
+	q.history = q.history[:0]
+	q.chain = q.chain[:0]
+}
+
+func (q *M4) score(m absoluteMatch) int {
+	return (m.End-m.Start)*256 + bits.LeadingZeros32(uint32(m.Start-m.Match))*q.DistanceBitCost
+}
+
+func (q *M4) FindMatches(dst []Match, src []byte) []Match {
+	if q.MaxDistance == 0 {
+		q.MaxDistance = 65535
+	}
+	if q.MinLength == 0 {
+		q.MinLength = 4
+	}
+	if q.HashLen == 0 {
+		q.HashLen = 6
+	}
+	if q.TableBits == 0 {
+		q.TableBits = 17
+	}
+	if len(q.table) < 1<<q.TableBits {
+		q.table = make([]uint32, 1<<q.TableBits)
+	}
+
+	e := matchEmitter{Dst: dst}
+
+	if len(q.history) > q.MaxDistance*2 {
+		// Trim down the history buffer.
+		delta := len(q.history) - q.MaxDistance
+		copy(q.history, q.history[delta:])
+		q.history = q.history[:q.MaxDistance]
+		if q.ChainLength > 0 {
+			q.chain = q.chain[:q.MaxDistance]
+		}
+
+		for i, v := range q.table {
+			newV := int(v) - delta
+			if newV < 0 {
+				newV = 0
+			}
+			q.table[i] = uint32(newV)
+		}
+	}
+
+	// Append src to the history buffer.
+	e.NextEmit = len(q.history)
+	q.history = append(q.history, src...)
+	if q.ChainLength > 0 {
+		q.chain = append(q.chain, make([]uint16, len(src))...)
+	}
+	src = q.history
+
+	// matches stores the matches that have been found but not emitted,
+	// in reverse order. (matches[0] is the most recent one.)
+	var matches [3]absoluteMatch
+	for i := e.NextEmit; i < len(src)-7; i++ {
+		if matches[0] != (absoluteMatch{}) && i >= matches[0].End {
+			// We have found some matches, and we're far enough along that we probably
+			// won't find overlapping matches, so we might as well emit them.
+			if matches[1] != (absoluteMatch{}) {
+				e.trim(matches[1], matches[0].Start, q.MinLength)
+			}
+			e.emit(matches[0])
+			matches = [3]absoluteMatch{}
+		}
+
+		// Calculate and store the hash.
+		h := ((binary.LittleEndian.Uint64(src[i:]) & (1<<(8*q.HashLen) - 1)) * hashMul64) >> (64 - q.TableBits)
+		candidate := int(q.table[h])
+		q.table[h] = uint32(i)
+		if q.ChainLength > 0 && candidate != 0 {
+			delta := i - candidate
+			if delta < 1<<16 {
+				q.chain[i] = uint16(delta)
+			}
+		}
+
+		if i < matches[0].End && i != matches[0].End+2-q.HashLen {
+			continue
+		}
+		if candidate == 0 || i-candidate > q.MaxDistance {
+			continue
+		}
+
+		// Look for a match.
+		var currentMatch absoluteMatch
+
+		if i-candidate != matches[0].Start-matches[0].Match {
+			if binary.LittleEndian.Uint32(src[candidate:]) == binary.LittleEndian.Uint32(src[i:]) {
+				m := extendMatch2(src, i, candidate, e.NextEmit)
+				if m.End-m.Start > q.MinLength {
+					currentMatch = m
+				}
+			}
+		}
+
+		for j := 0; j < q.ChainLength; j++ {
+			delta := q.chain[candidate]
+			if delta == 0 {
+				break
+			}
+			candidate -= int(delta)
+			if candidate <= 0 || i-candidate > q.MaxDistance {
+				break
+			}
+			if i-candidate != matches[0].Start-matches[0].Match {
+				if binary.LittleEndian.Uint32(src[candidate:]) == binary.LittleEndian.Uint32(src[i:]) {
+					m := extendMatch2(src, i, candidate, e.NextEmit)
+					if m.End-m.Start > q.MinLength && q.score(m) > q.score(currentMatch) {
+						currentMatch = m
+					}
+				}
+			}
+		}
+
+		if currentMatch.End-currentMatch.Start < q.MinLength {
+			continue
+		}
+
+		overlapPenalty := 0
+		if matches[0] != (absoluteMatch{}) {
+			overlapPenalty = 275
+			if currentMatch.Start <= matches[1].End {
+				// This match would completely replace the previous match,
+				// so there is no penalty for overlap.
+				overlapPenalty = 0
+			}
+		}
+
+		if q.score(currentMatch) <= q.score(matches[0])+overlapPenalty {
+			continue
+		}
+
+		matches = [3]absoluteMatch{
+			currentMatch,
+			matches[0],
+			matches[1],
+		}
+
+		if matches[2] == (absoluteMatch{}) {
+			continue
+		}
+
+		// We have three matches, so it's time to emit one and/or eliminate one.
+		switch {
+		case matches[0].Start < matches[2].End:
+			// The first and third matches overlap; discard the one in between.
+			matches = [3]absoluteMatch{
+				matches[0],
+				matches[2],
+				absoluteMatch{},
+			}
+
+		case matches[0].Start < matches[2].End+q.MinLength:
+			// The first and third matches don't overlap, but there's no room for
+			// another match between them. Emit the first match and discard the second.
+			e.emit(matches[2])
+			matches = [3]absoluteMatch{
+				matches[0],
+				absoluteMatch{},
+				absoluteMatch{},
+			}
+
+		default:
+			// Emit the first match, shortening it if necessary to avoid overlap with the second.
+			e.trim(matches[2], matches[1].Start, q.MinLength)
+			matches[2] = absoluteMatch{}
+		}
+	}
+
+	// We've found all the matches now; emit the remaining ones.
+	if matches[1] != (absoluteMatch{}) {
+		e.trim(matches[1], matches[0].Start, q.MinLength)
+	}
+	if matches[0] != (absoluteMatch{}) {
+		e.emit(matches[0])
+	}
+
+	dst = e.Dst
+	if e.NextEmit < len(src) {
+		dst = append(dst, Match{
+			Unmatched: len(src) - e.NextEmit,
+		})
+	}
+
+	return dst
+}
+
+const hashMul64 = 0x1E35A7BD1E35A7BD
+
+// extendMatch returns the largest k such that k <= len(src) and that
+// src[i:i+k-j] and src[j:k] have the same contents.
+//
+// It assumes that:
+//
+//	0 <= i && i < j && j <= len(src)
+func extendMatch(src []byte, i, j int) int {
+	switch runtime.GOARCH {
+	case "amd64":
+		// As long as we are 8 or more bytes before the end of src, we can load and
+		// compare 8 bytes at a time. If those 8 bytes are equal, repeat.
+		for j+8 < len(src) {
+			iBytes := binary.LittleEndian.Uint64(src[i:])
+			jBytes := binary.LittleEndian.Uint64(src[j:])
+			if iBytes != jBytes {
+				// If those 8 bytes were not equal, XOR the two 8 byte values, and return
+				// the index of the first byte that differs. The BSF instruction finds the
+				// least significant 1 bit, the amd64 architecture is little-endian, and
+				// the shift by 3 converts a bit index to a byte index.
+				return j + bits.TrailingZeros64(iBytes^jBytes)>>3
+			}
+			i, j = i+8, j+8
+		}
+	case "386":
+		// On a 32-bit CPU, we do it 4 bytes at a time.
+		for j+4 < len(src) {
+			iBytes := binary.LittleEndian.Uint32(src[i:])
+			jBytes := binary.LittleEndian.Uint32(src[j:])
+			if iBytes != jBytes {
+				return j + bits.TrailingZeros32(iBytes^jBytes)>>3
+			}
+			i, j = i+4, j+4
+		}
+	}
+	for ; j < len(src) && src[i] == src[j]; i, j = i+1, j+1 {
+	}
+	return j
+}
+
+// Given a 4-byte match at src[start] and src[candidate], extendMatch2 extends it
+// upward as far as possible, and downward no farther than to min.
+func extendMatch2(src []byte, start, candidate, min int) absoluteMatch {
+	end := extendMatch(src, candidate+4, start+4)
+	for start > min && candidate > 0 && src[start-1] == src[candidate-1] {
+		start--
+		candidate--
+	}
+	return absoluteMatch{
+		Start: start,
+		End:   end,
+		Match: candidate,
+	}
+}

vendor/github.com/andybalholm/brotli/matchfinder/matchfinder.go

@@ -0,0 +1,103 @@
+// The matchfinder package defines reusable components for data compression.
+//
+// Many compression libraries have two main parts:
+//   - Something that looks for repeated sequences of bytes
+//   - An encoder for the compressed data format (often an entropy coder)
+//
+// Although these are logically two separate steps, the implementations are
+// usually closely tied together. You can't use flate's matcher with snappy's
+// encoder, for example. This package defines interfaces and an intermediate
+// representation to allow mixing and matching compression components.
+package matchfinder
+
+import "io"
+
+// A Match is the basic unit of LZ77 compression.
+type Match struct {
+	Unmatched int // the number of unmatched bytes since the previous match
+	Length    int // the number of bytes in the matched string; it may be 0 at the end of the input
+	Distance  int // how far back in the stream to copy from
+}
+
+// A MatchFinder performs the LZ77 stage of compression, looking for matches.
+type MatchFinder interface {
+	// FindMatches looks for matches in src, appends them to dst, and returns dst.
+	FindMatches(dst []Match, src []byte) []Match
+
+	// Reset clears any internal state, preparing the MatchFinder to be used with
+	// a new stream.
+	Reset()
+}
+
+// An Encoder encodes the data in its final format.
+type Encoder interface {
+	// Encode appends the encoded format of src to dst, using the match
+	// information from matches.
+	Encode(dst []byte, src []byte, matches []Match, lastBlock bool) []byte
+
+	// Reset clears any internal state, preparing the Encoder to be used with
+	// a new stream.
+	Reset()
+}
+
+// A Writer uses MatchFinder and Encoder to write compressed data to Dest.
+type Writer struct {
+	Dest        io.Writer
+	MatchFinder MatchFinder
+	Encoder     Encoder
+
+	// BlockSize is the number of bytes to compress at a time. If it is zero,
+	// each Write operation will be treated as one block.
+	BlockSize int
+
+	err     error
+	inBuf   []byte
+	outBuf  []byte
+	matches []Match
+}
+
+func (w *Writer) Write(p []byte) (n int, err error) {
+	if w.err != nil {
+		return 0, w.err
+	}
+
+	if w.BlockSize == 0 {
+		return w.writeBlock(p, false)
+	}
+
+	w.inBuf = append(w.inBuf, p...)
+	var pos int
+	for pos = 0; pos+w.BlockSize <= len(w.inBuf) && w.err == nil; pos += w.BlockSize {
+		w.writeBlock(w.inBuf[pos:pos+w.BlockSize], false)
+	}
+	if pos > 0 {
+		n := copy(w.inBuf, w.inBuf[pos:])
+		w.inBuf = w.inBuf[:n]
+	}
+
+	return len(p), w.err
+}
+
+func (w *Writer) writeBlock(p []byte, lastBlock bool) (n int, err error) {
+	w.outBuf = w.outBuf[:0]
+	w.matches = w.MatchFinder.FindMatches(w.matches[:0], p)
+	w.outBuf = w.Encoder.Encode(w.outBuf, p, w.matches, lastBlock)
+	_, w.err = w.Dest.Write(w.outBuf)
+	return len(p), w.err
+}
+
+func (w *Writer) Close() error {
+	w.writeBlock(w.inBuf, true)
+	w.inBuf = w.inBuf[:0]
+	return w.err
+}
+
+func (w *Writer) Reset(newDest io.Writer) {
+	w.MatchFinder.Reset()
+	w.Encoder.Reset()
+	w.err = nil
+	w.inBuf = w.inBuf[:0]
+	w.outBuf = w.outBuf[:0]
+	w.matches = w.matches[:0]
+	w.Dest = newDest
+}

vendor/github.com/andybalholm/brotli/matchfinder/textencoder.go

@@ -0,0 +1,53 @@
+package matchfinder
+
+import "fmt"
+
+// A TextEncoder is an Encoder that produces a human-readable representation of
+// the LZ77 compression. Matches are replaced with <Length,Distance> symbols.
+type TextEncoder struct{}
+
+func (t TextEncoder) Reset() {}
+
+func (t TextEncoder) Encode(dst []byte, src []byte, matches []Match, lastBlock bool) []byte {
+	pos := 0
+	for _, m := range matches {
+		if m.Unmatched > 0 {
+			dst = append(dst, src[pos:pos+m.Unmatched]...)
+			pos += m.Unmatched
+		}
+		if m.Length > 0 {
+			dst = append(dst, []byte(fmt.Sprintf("<%d,%d>", m.Length, m.Distance))...)
+			pos += m.Length
+		}
+	}
+	if pos < len(src) {
+		dst = append(dst, src[pos:]...)
+	}
+	return dst
+}
+
+// A NoMatchFinder implements MatchFinder, but doesn't find any matches.
+// It can be used to implement the equivalent of the standard library flate package's
+// HuffmanOnly setting.
+type NoMatchFinder struct{}
+
+func (n NoMatchFinder) Reset() {}
+
+func (n NoMatchFinder) FindMatches(dst []Match, src []byte) []Match {
+	return append(dst, Match{
+		Unmatched: len(src),
+	})
+}
+
+// AutoReset wraps a MatchFinder that can return references to data in previous
+// blocks, and calls Reset before each block. It is useful for (e.g.) using a
+// snappy Encoder with a MatchFinder designed for flate. (Snappy doesn't
+// support references between blocks.)
+type AutoReset struct {
+	MatchFinder
+}
+
+func (a AutoReset) FindMatches(dst []Match, src []byte) []Match {
+	a.Reset()
+	return a.MatchFinder.FindMatches(dst, src)
+}

vendor/github.com/andybalholm/brotli/writer.go

@@ -3,6 +3,8 @@ package brotli
 import (
 	"errors"
 	"io"
+
+	"github.com/andybalholm/brotli/matchfinder"
 )
 
 const (
@@ -117,3 +119,44 @@ type nopCloser struct {
 }
 
 func (nopCloser) Close() error { return nil }
+
+// NewWriterV2 is like NewWriterLevel, but it uses the new implementation
+// based on the matchfinder package. It currently supports up to level 7;
+// if a higher level is specified, level 7 will be used.
+func NewWriterV2(dst io.Writer, level int) *matchfinder.Writer {
+	var mf matchfinder.MatchFinder
+	if level < 2 {
+		mf = matchfinder.M0{Lazy: level == 1}
+	} else {
+		hashLen := 6
+		if level >= 6 {
+			hashLen = 5
+		}
+		chainLen := 64
+		switch level {
+		case 2:
+			chainLen = 0
+		case 3:
+			chainLen = 1
+		case 4:
+			chainLen = 2
+		case 5:
+			chainLen = 4
+		case 6:
+			chainLen = 8
+		}
+		mf = &matchfinder.M4{
+			MaxDistance:     1 << 20,
+			ChainLength:     chainLen,
+			HashLen:         hashLen,
+			DistanceBitCost: 57,
+		}
+	}
+
+	return &matchfinder.Writer{
+		Dest:        dst,
+		MatchFinder: mf,
+		Encoder:     &Encoder{},
+		BlockSize:   1 << 16,
+	}
+}

vendor/github.com/google/uuid/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [1.6.0](https://github.com/google/uuid/compare/v1.5.0...v1.6.0) (2024-01-16)
+
+
+### Features
+
+* add Max UUID constant ([#149](https://github.com/google/uuid/issues/149)) ([c58770e](https://github.com/google/uuid/commit/c58770eb495f55fe2ced6284f93c5158a62e53e3))
+
+
+### Bug Fixes
+
+* fix typo in version 7 uuid documentation ([#153](https://github.com/google/uuid/issues/153)) ([016b199](https://github.com/google/uuid/commit/016b199544692f745ffc8867b914129ecb47ef06))
+* Monotonicity in UUIDv7 ([#150](https://github.com/google/uuid/issues/150)) ([a2b2b32](https://github.com/google/uuid/commit/a2b2b32373ff0b1a312b7fdf6d38a977099698a6))
+
 ## [1.5.0](https://github.com/google/uuid/compare/v1.4.0...v1.5.0) (2023-12-12)
 
 

vendor/github.com/google/uuid/hash.go

@@ -17,6 +17,12 @@ var (
 	NameSpaceOID  = Must(Parse("6ba7b812-9dad-11d1-80b4-00c04fd430c8"))
 	NameSpaceX500 = Must(Parse("6ba7b814-9dad-11d1-80b4-00c04fd430c8"))
 	Nil           UUID // empty UUID, all zeros
+
+	// The Max UUID is special form of UUID that is specified to have all 128 bits set to 1.
+	Max = UUID{
+		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+	}
 )
 
 // NewHash returns a new UUID derived from the hash of space concatenated with

vendor/github.com/google/uuid/version7.go

@@ -44,7 +44,7 @@ func NewV7FromReader(r io.Reader) (UUID, error) {
 
 // makeV7 fill 48 bits time (uuid[0] - uuid[5]), set version b0111 (uuid[6])
 // uuid[8] already has the right version number (Variant is 10)
-// see function  NewV7 and NewV7FromReader
+// see function NewV7 and NewV7FromReader
 func makeV7(uuid []byte) {
 	/*
 		 0                   1                   2                   3
@@ -52,7 +52,7 @@ func makeV7(uuid []byte) {
 		+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 		|                           unix_ts_ms                          |
 		+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-		|          unix_ts_ms           |  ver  |       rand_a          |
+		|          unix_ts_ms           |  ver  |  rand_a (12 bit seq)  |
 		+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 		|var|                        rand_b                             |
 		+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ -61,7 +61,7 @@ func makeV7(uuid []byte) {
 	*/
 	_ = uuid[15] // bounds check
 
-	t := timeNow().UnixMilli()
+	t, s := getV7Time()
 
 	uuid[0] = byte(t >> 40)
 	uuid[1] = byte(t >> 32)
@@ -70,6 +70,35 @@ func makeV7(uuid []byte) {
 	uuid[4] = byte(t >> 8)
 	uuid[5] = byte(t)
 
-	uuid[6] = 0x70 | (uuid[6] & 0x0F)
-	// uuid[8] has already has right version
+	uuid[6] = 0x70 | (0x0F & byte(s>>8))
+	uuid[7] = byte(s)
+}
+
+// lastV7time is the last time we returned stored as:
+//
+//	52 bits of time in milliseconds since epoch
+//	12 bits of (fractional nanoseconds) >> 8
+var lastV7time int64
+
+const nanoPerMilli = 1000000
+
+// getV7Time returns the time in milliseconds and nanoseconds / 256.
+// The returned (milli << 12 + seq) is guarenteed to be greater than
+// (milli << 12 + seq) returned by any previous call to getV7Time.
+func getV7Time() (milli, seq int64) {
+	timeMu.Lock()
+	defer timeMu.Unlock()
+
+	nano := timeNow().UnixNano()
+	milli = nano / nanoPerMilli
+	// Sequence number is between 0 and 3906 (nanoPerMilli>>8)
+	seq = (nano - milli*nanoPerMilli) >> 8
+	now := milli<<12 + seq
+	if now <= lastV7time {
+		now = lastV7time + 1
+		milli = now >> 12
+		seq = now & 0xfff
+	}
+	lastV7time = now
+	return milli, seq
 }

vendor/github.com/klauspost/compress/flate/deflate.go

@@ -212,7 +212,7 @@ func (d *compressor) writeBlockSkip(tok *tokens, index int, eof bool) error {
 // Should only be used after a start/reset.
 func (d *compressor) fillWindow(b []byte) {
 	// Do not fill window if we are in store-only or huffman mode.
-	if d.level <= 0 {
+	if d.level <= 0 && d.level > -MinCustomWindowSize {
 		return
 	}
 	if d.fast != nil {

vendor/github.com/rivo/uniseg/README.md

@@ -3,7 +3,7 @@
 [![Go Reference](https://pkg.go.dev/badge/github.com/rivo/uniseg.svg)](https://pkg.go.dev/github.com/rivo/uniseg)
 [![Go Report](https://img.shields.io/badge/go%20report-A%2B-brightgreen.svg)](https://goreportcard.com/report/github.com/rivo/uniseg)
 
-This Go package implements Unicode Text Segmentation according to [Unicode Standard Annex #29](https://unicode.org/reports/tr29/), Unicode Line Breaking according to [Unicode Standard Annex #14](https://unicode.org/reports/tr14/) (Unicode version 14.0.0), and monospace font string width calculation similar to [wcwidth](https://man7.org/linux/man-pages/man3/wcwidth.3.html).
+This Go package implements Unicode Text Segmentation according to [Unicode Standard Annex #29](https://unicode.org/reports/tr29/), Unicode Line Breaking according to [Unicode Standard Annex #14](https://unicode.org/reports/tr14/) (Unicode version 15.0.0), and monospace font string width calculation similar to [wcwidth](https://man7.org/linux/man-pages/man3/wcwidth.3.html).
 
 ## Background
 
@@ -73,7 +73,7 @@ for gr.Next() {
 
 ### Using the [`Step`](https://pkg.go.dev/github.com/rivo/uniseg#Step) or [`StepString`](https://pkg.go.dev/github.com/rivo/uniseg#StepString) Function
 
-This is orders of magnitude faster than the `Graphemes` class, but it requires the handling of states and boundaries:
+This avoids allocating a new `Graphemes` object but it requires the handling of states and boundaries:
 
 ```go
 str := "🇩🇪🏳️‍🌈"
@@ -88,29 +88,7 @@ for len(str) > 0 {
 
 ### Advanced Examples
 
-Breaking into grapheme clusters and evaluating line breaks:
-
-```go
-str := "First line.\nSecond line."
-state := -1
-var (
-	c          string
-	boundaries int
-)
-for len(str) > 0 {
-	c, str, boundaries, state = uniseg.StepString(str, state)
-	fmt.Print(c)
-	if boundaries&uniseg.MaskLine == uniseg.LineCanBreak {
-		fmt.Print("|")
-	} else if boundaries&uniseg.MaskLine == uniseg.LineMustBreak {
-		fmt.Print("‖")
-	}
-}
-// First |line.
-// ‖Second |line.‖
-```
-
-If you're only interested in word segmentation, use [`FirstWord`](https://pkg.go.dev/github.com/rivo/uniseg#FirstWord) or [`FirstWordInString`](https://pkg.go.dev/github.com/rivo/uniseg#FirstWordInString):
+The [`Graphemes`](https://pkg.go.dev/github.com/rivo/uniseg#Graphemes) class offers the most convenient way to access all functionality of this package. But in some cases, it may be better to use the specialized functions directly. For example, if you're only interested in word segmentation, use [`FirstWord`](https://pkg.go.dev/github.com/rivo/uniseg#FirstWord) or [`FirstWordInString`](https://pkg.go.dev/github.com/rivo/uniseg#FirstWordInString):
 
 ```go
 str := "Hello, world!"
@@ -133,6 +111,8 @@ Similarly, use
 - [`FirstSentence`](https://pkg.go.dev/github.com/rivo/uniseg#FirstSentence) or [`FirstSentenceInString`](https://pkg.go.dev/github.com/rivo/uniseg#FirstSentenceInString) for sentence segmentation only, and
 - [`FirstLineSegment`](https://pkg.go.dev/github.com/rivo/uniseg#FirstLineSegment) or [`FirstLineSegmentInString`](https://pkg.go.dev/github.com/rivo/uniseg#FirstLineSegmentInString) for line breaking / word wrapping (although using [`Step`](https://pkg.go.dev/github.com/rivo/uniseg#Step) or [`StepString`](https://pkg.go.dev/github.com/rivo/uniseg#StepString) is preferred as it will observe grapheme cluster boundaries).
 
+If you're only interested in the width of characters, use [`FirstGraphemeCluster`](https://pkg.go.dev/github.com/rivo/uniseg#FirstGraphemeCluster) or [`FirstGraphemeClusterInString`](https://pkg.go.dev/github.com/rivo/uniseg#FirstGraphemeClusterInString). It is much faster than using [`Step`](https://pkg.go.dev/github.com/rivo/uniseg#Step), [`StepString`](https://pkg.go.dev/github.com/rivo/uniseg#StepString), or the [`Graphemes`](https://pkg.go.dev/github.com/rivo/uniseg#Graphemes) class because it does not include the logic for word / sentence / line boundaries.
+
 Finally, if you need to reverse a string while preserving grapheme clusters, use [`ReverseString`](https://pkg.go.dev/github.com/rivo/uniseg#ReverseString):
 
 ```go

vendor/github.com/rivo/uniseg/eastasianwidth.go

@@ -1,13 +1,13 @@
-package uniseg
-
 // Code generated via go generate from gen_properties.go. DO NOT EDIT.
 
+package uniseg
+
 // eastAsianWidth are taken from
-// https://www.unicode.org/Public/14.0.0/ucd/EastAsianWidth.txt
+// https://www.unicode.org/Public/15.0.0/ucd/EastAsianWidth.txt
 // and
-// https://unicode.org/Public/14.0.0/ucd/emoji/emoji-data.txt
+// https://unicode.org/Public/15.0.0/ucd/emoji/emoji-data.txt
 // ("Extended_Pictographic" only)
-// on September 10, 2022. See https://www.unicode.org/license.html for the Unicode
+// on September 5, 2023. See https://www.unicode.org/license.html for the Unicode
 // license agreement.
 var eastAsianWidth = [][3]int{
 	{0x0000, 0x001F, prN},     // Cc    [32] <control-0000>..<control-001F>
@@ -504,6 +504,7 @@ var eastAsianWidth = [][3]int{
 	{0x0CE2, 0x0CE3, prN},     // Mn     [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL
 	{0x0CE6, 0x0CEF, prN},     // Nd    [10] KANNADA DIGIT ZERO..KANNADA DIGIT NINE
 	{0x0CF1, 0x0CF2, prN},     // Lo     [2] KANNADA SIGN JIHVAMULIYA..KANNADA SIGN UPADHMANIYA
+	{0x0CF3, 0x0CF3, prN},     // Mc         KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT
 	{0x0D00, 0x0D01, prN},     // Mn     [2] MALAYALAM SIGN COMBINING ANUSVARA ABOVE..MALAYALAM SIGN CANDRABINDU
 	{0x0D02, 0x0D03, prN},     // Mc     [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA
 	{0x0D04, 0x0D0C, prN},     // Lo     [9] MALAYALAM LETTER VEDIC ANUSVARA..MALAYALAM LETTER VOCALIC L
@@ -565,7 +566,7 @@ var eastAsianWidth = [][3]int{
 	{0x0EBD, 0x0EBD, prN},     // Lo         LAO SEMIVOWEL SIGN NYO
 	{0x0EC0, 0x0EC4, prN},     // Lo     [5] LAO VOWEL SIGN E..LAO VOWEL SIGN AI
 	{0x0EC6, 0x0EC6, prN},     // Lm         LAO KO LA
-	{0x0EC8, 0x0ECD, prN},     // Mn     [6] LAO TONE MAI EK..LAO NIGGAHITA
+	{0x0EC8, 0x0ECE, prN},     // Mn     [7] LAO TONE MAI EK..LAO YAMAKKAN
 	{0x0ED0, 0x0ED9, prN},     // Nd    [10] LAO DIGIT ZERO..LAO DIGIT NINE
 	{0x0EDC, 0x0EDF, prN},     // Lo     [4] LAO HO NO..LAO LETTER KHMU NYO
 	{0x0F00, 0x0F00, prN},     // Lo         TIBETAN SYLLABLE OM
@@ -1916,6 +1917,7 @@ var eastAsianWidth = [][3]int{
 	{0x10EAB, 0x10EAC, prN},   // Mn     [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK
 	{0x10EAD, 0x10EAD, prN},   // Pd         YEZIDI HYPHENATION MARK
 	{0x10EB0, 0x10EB1, prN},   // Lo     [2] YEZIDI LETTER LAM WITH DOT ABOVE..YEZIDI LETTER YOT WITH CIRCUMFLEX ABOVE
+	{0x10EFD, 0x10EFF, prN},   // Mn     [3] ARABIC SMALL LOW WORD SAKTA..ARABIC SMALL LOW WORD MADDA
 	{0x10F00, 0x10F1C, prN},   // Lo    [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL
 	{0x10F1D, 0x10F26, prN},   // No    [10] OLD SOGDIAN NUMBER ONE..OLD SOGDIAN FRACTION ONE HALF
 	{0x10F27, 0x10F27, prN},   // Lo         OLD SOGDIAN LIGATURE AYIN-DALETH
@@ -1998,6 +2000,8 @@ var eastAsianWidth = [][3]int{
 	{0x11236, 0x11237, prN},   // Mn     [2] KHOJKI SIGN NUKTA..KHOJKI SIGN SHADDA
 	{0x11238, 0x1123D, prN},   // Po     [6] KHOJKI DANDA..KHOJKI ABBREVIATION SIGN
 	{0x1123E, 0x1123E, prN},   // Mn         KHOJKI SIGN SUKUN
+	{0x1123F, 0x11240, prN},   // Lo     [2] KHOJKI LETTER QA..KHOJKI LETTER SHORT I
+	{0x11241, 0x11241, prN},   // Mn         KHOJKI VOWEL SIGN VOCALIC R
 	{0x11280, 0x11286, prN},   // Lo     [7] MULTANI LETTER A..MULTANI LETTER GA
 	{0x11288, 0x11288, prN},   // Lo         MULTANI LETTER GHA
 	{0x1128A, 0x1128D, prN},   // Lo     [4] MULTANI LETTER CA..MULTANI LETTER JJA
@@ -2160,6 +2164,7 @@ var eastAsianWidth = [][3]int{
 	{0x11A9E, 0x11AA2, prN},   // Po     [5] SOYOMBO HEAD MARK WITH MOON AND SUN AND TRIPLE FLAME..SOYOMBO TERMINAL MARK-2
 	{0x11AB0, 0x11ABF, prN},   // Lo    [16] CANADIAN SYLLABICS NATTILIK HI..CANADIAN SYLLABICS SPA
 	{0x11AC0, 0x11AF8, prN},   // Lo    [57] PAU CIN HAU LETTER PA..PAU CIN HAU GLOTTAL STOP FINAL
+	{0x11B00, 0x11B09, prN},   // Po    [10] DEVANAGARI HEAD MARK..DEVANAGARI SIGN MINDU
 	{0x11C00, 0x11C08, prN},   // Lo     [9] BHAIKSUKI LETTER A..BHAIKSUKI LETTER VOCALIC L
 	{0x11C0A, 0x11C2E, prN},   // Lo    [37] BHAIKSUKI LETTER E..BHAIKSUKI LETTER HA
 	{0x11C2F, 0x11C2F, prN},   // Mc         BHAIKSUKI VOWEL SIGN AA
@@ -2205,6 +2210,19 @@ var eastAsianWidth = [][3]int{
 	{0x11EF3, 0x11EF4, prN},   // Mn     [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U
 	{0x11EF5, 0x11EF6, prN},   // Mc     [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O
 	{0x11EF7, 0x11EF8, prN},   // Po     [2] MAKASAR PASSIMBANG..MAKASAR END OF SECTION
+	{0x11F00, 0x11F01, prN},   // Mn     [2] KAWI SIGN CANDRABINDU..KAWI SIGN ANUSVARA
+	{0x11F02, 0x11F02, prN},   // Lo         KAWI SIGN REPHA
+	{0x11F03, 0x11F03, prN},   // Mc         KAWI SIGN VISARGA
+	{0x11F04, 0x11F10, prN},   // Lo    [13] KAWI LETTER A..KAWI LETTER O
+	{0x11F12, 0x11F33, prN},   // Lo    [34] KAWI LETTER KA..KAWI LETTER JNYA
+	{0x11F34, 0x11F35, prN},   // Mc     [2] KAWI VOWEL SIGN AA..KAWI VOWEL SIGN ALTERNATE AA
+	{0x11F36, 0x11F3A, prN},   // Mn     [5] KAWI VOWEL SIGN I..KAWI VOWEL SIGN VOCALIC R
+	{0x11F3E, 0x11F3F, prN},   // Mc     [2] KAWI VOWEL SIGN E..KAWI VOWEL SIGN AI
+	{0x11F40, 0x11F40, prN},   // Mn         KAWI VOWEL SIGN EU
+	{0x11F41, 0x11F41, prN},   // Mc         KAWI SIGN KILLER
+	{0x11F42, 0x11F42, prN},   // Mn         KAWI CONJOINER
+	{0x11F43, 0x11F4F, prN},   // Po    [13] KAWI DANDA..KAWI PUNCTUATION CLOSING SPIRAL
+	{0x11F50, 0x11F59, prN},   // Nd    [10] KAWI DIGIT ZERO..KAWI DIGIT NINE
 	{0x11FB0, 0x11FB0, prN},   // Lo         LISU LETTER YHA
 	{0x11FC0, 0x11FD4, prN},   // No    [21] TAMIL FRACTION ONE THREE-HUNDRED-AND-TWENTIETH..TAMIL FRACTION DOWNSCALING FACTOR KIIZH
 	{0x11FD5, 0x11FDC, prN},   // So     [8] TAMIL SIGN NEL..TAMIL SIGN MUKKURUNI
@@ -2217,8 +2235,11 @@ var eastAsianWidth = [][3]int{
 	{0x12480, 0x12543, prN},   // Lo   [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU
 	{0x12F90, 0x12FF0, prN},   // Lo    [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114
 	{0x12FF1, 0x12FF2, prN},   // Po     [2] CYPRO-MINOAN SIGN CM301..CYPRO-MINOAN SIGN CM302
-	{0x13000, 0x1342E, prN},   // Lo  [1071] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH AA032
-	{0x13430, 0x13438, prN},   // Cf     [9] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH END SEGMENT
+	{0x13000, 0x1342F, prN},   // Lo  [1072] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH V011D
+	{0x13430, 0x1343F, prN},   // Cf    [16] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH END WALLED ENCLOSURE
+	{0x13440, 0x13440, prN},   // Mn         EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY
+	{0x13441, 0x13446, prN},   // Lo     [6] EGYPTIAN HIEROGLYPH FULL BLANK..EGYPTIAN HIEROGLYPH WIDE LOST SIGN
+	{0x13447, 0x13455, prN},   // Mn    [15] EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP START..EGYPTIAN HIEROGLYPH MODIFIER DAMAGED
 	{0x14400, 0x14646, prN},   // Lo   [583] ANATOLIAN HIEROGLYPH A001..ANATOLIAN HIEROGLYPH A530
 	{0x16800, 0x16A38, prN},   // Lo   [569] BAMUM LETTER PHASE-A NGKUE MFON..BAMUM LETTER PHASE-F VUEQ
 	{0x16A40, 0x16A5E, prN},   // Lo    [31] MRO LETTER TA..MRO LETTER TEK
@@ -2263,7 +2284,9 @@ var eastAsianWidth = [][3]int{
 	{0x1AFFD, 0x1AFFE, prW},   // Lm     [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8
 	{0x1B000, 0x1B0FF, prW},   // Lo   [256] KATAKANA LETTER ARCHAIC E..HENTAIGANA LETTER RE-2
 	{0x1B100, 0x1B122, prW},   // Lo    [35] HENTAIGANA LETTER RE-3..KATAKANA LETTER ARCHAIC WU
+	{0x1B132, 0x1B132, prW},   // Lo         HIRAGANA LETTER SMALL KO
 	{0x1B150, 0x1B152, prW},   // Lo     [3] HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO
+	{0x1B155, 0x1B155, prW},   // Lo         KATAKANA LETTER SMALL KO
 	{0x1B164, 0x1B167, prW},   // Lo     [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N
 	{0x1B170, 0x1B2FB, prW},   // Lo   [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB
 	{0x1BC00, 0x1BC6A, prN},   // Lo   [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M
@@ -2294,6 +2317,7 @@ var eastAsianWidth = [][3]int{
 	{0x1D200, 0x1D241, prN},   // So    [66] GREEK VOCAL NOTATION SYMBOL-1..GREEK INSTRUMENTAL NOTATION SYMBOL-54
 	{0x1D242, 0x1D244, prN},   // Mn     [3] COMBINING GREEK MUSICAL TRISEME..COMBINING GREEK MUSICAL PENTASEME
 	{0x1D245, 0x1D245, prN},   // So         GREEK MUSICAL LEIMMA
+	{0x1D2C0, 0x1D2D3, prN},   // No    [20] KAKTOVIK NUMERAL ZERO..KAKTOVIK NUMERAL NINETEEN
 	{0x1D2E0, 0x1D2F3, prN},   // No    [20] MAYAN NUMERAL ZERO..MAYAN NUMERAL NINETEEN
 	{0x1D300, 0x1D356, prN},   // So    [87] MONOGRAM FOR EARTH..TETRAGRAM FOR FOSTERING
 	{0x1D360, 0x1D378, prN},   // No    [25] COUNTING ROD UNIT DIGIT ONE..TALLY MARK FIVE
@@ -2353,11 +2377,14 @@ var eastAsianWidth = [][3]int{
 	{0x1DF00, 0x1DF09, prN},   // Ll    [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK
 	{0x1DF0A, 0x1DF0A, prN},   // Lo         LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK
 	{0x1DF0B, 0x1DF1E, prN},   // Ll    [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL
+	{0x1DF25, 0x1DF2A, prN},   // Ll     [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK
 	{0x1E000, 0x1E006, prN},   // Mn     [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE
 	{0x1E008, 0x1E018, prN},   // Mn    [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU
 	{0x1E01B, 0x1E021, prN},   // Mn     [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI
 	{0x1E023, 0x1E024, prN},   // Mn     [2] COMBINING GLAGOLITIC LETTER YU..COMBINING GLAGOLITIC LETTER SMALL YUS
 	{0x1E026, 0x1E02A, prN},   // Mn     [5] COMBINING GLAGOLITIC LETTER YO..COMBINING GLAGOLITIC LETTER FITA
+	{0x1E030, 0x1E06D, prN},   // Lm    [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE
+	{0x1E08F, 0x1E08F, prN},   // Mn         COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
 	{0x1E100, 0x1E12C, prN},   // Lo    [45] NYIAKENG PUACHUE HMONG LETTER MA..NYIAKENG PUACHUE HMONG LETTER W
 	{0x1E130, 0x1E136, prN},   // Mn     [7] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG TONE-D
 	{0x1E137, 0x1E13D, prN},   // Lm     [7] NYIAKENG PUACHUE HMONG SIGN FOR PERSON..NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER
@@ -2370,6 +2397,10 @@ var eastAsianWidth = [][3]int{
 	{0x1E2EC, 0x1E2EF, prN},   // Mn     [4] WANCHO TONE TUP..WANCHO TONE KOINI
 	{0x1E2F0, 0x1E2F9, prN},   // Nd    [10] WANCHO DIGIT ZERO..WANCHO DIGIT NINE
 	{0x1E2FF, 0x1E2FF, prN},   // Sc         WANCHO NGUN SIGN
+	{0x1E4D0, 0x1E4EA, prN},   // Lo    [27] NAG MUNDARI LETTER O..NAG MUNDARI LETTER ELL
+	{0x1E4EB, 0x1E4EB, prN},   // Lm         NAG MUNDARI SIGN OJOD
+	{0x1E4EC, 0x1E4EF, prN},   // Mn     [4] NAG MUNDARI SIGN MUHOR..NAG MUNDARI SIGN SUTUH
+	{0x1E4F0, 0x1E4F9, prN},   // Nd    [10] NAG MUNDARI DIGIT ZERO..NAG MUNDARI DIGIT NINE
 	{0x1E7E0, 0x1E7E6, prN},   // Lo     [7] ETHIOPIC SYLLABLE HHYA..ETHIOPIC SYLLABLE HHYO
 	{0x1E7E8, 0x1E7EB, prN},   // Lo     [4] ETHIOPIC SYLLABLE GURAGE HHWA..ETHIOPIC SYLLABLE HHWE
 	{0x1E7ED, 0x1E7EE, prN},   // Lo     [2] ETHIOPIC SYLLABLE GURAGE MWI..ETHIOPIC SYLLABLE GURAGE MWEE
@@ -2498,13 +2529,14 @@ var eastAsianWidth = [][3]int{
 	{0x1F6D0, 0x1F6D2, prW},   // So     [3] PLACE OF WORSHIP..SHOPPING TROLLEY
 	{0x1F6D3, 0x1F6D4, prN},   // So     [2] STUPA..PAGODA
 	{0x1F6D5, 0x1F6D7, prW},   // So     [3] HINDU TEMPLE..ELEVATOR
-	{0x1F6DD, 0x1F6DF, prW},   // So     [3] PLAYGROUND SLIDE..RING BUOY
+	{0x1F6DC, 0x1F6DF, prW},   // So     [4] WIRELESS..RING BUOY
 	{0x1F6E0, 0x1F6EA, prN},   // So    [11] HAMMER AND WRENCH..NORTHEAST-POINTING AIRPLANE
 	{0x1F6EB, 0x1F6EC, prW},   // So     [2] AIRPLANE DEPARTURE..AIRPLANE ARRIVING
 	{0x1F6F0, 0x1F6F3, prN},   // So     [4] SATELLITE..PASSENGER SHIP
 	{0x1F6F4, 0x1F6FC, prW},   // So     [9] SCOOTER..ROLLER SKATE
-	{0x1F700, 0x1F773, prN},   // So   [116] ALCHEMICAL SYMBOL FOR QUINTESSENCE..ALCHEMICAL SYMBOL FOR HALF OUNCE
-	{0x1F780, 0x1F7D8, prN},   // So    [89] BLACK LEFT-POINTING ISOSCELES RIGHT TRIANGLE..NEGATIVE CIRCLED SQUARE
+	{0x1F700, 0x1F776, prN},   // So   [119] ALCHEMICAL SYMBOL FOR QUINTESSENCE..LUNAR ECLIPSE
+	{0x1F77B, 0x1F77F, prN},   // So     [5] HAUMEA..ORCUS
+	{0x1F780, 0x1F7D9, prN},   // So    [90] BLACK LEFT-POINTING ISOSCELES RIGHT TRIANGLE..NINE POINTED WHITE STAR
 	{0x1F7E0, 0x1F7EB, prW},   // So    [12] LARGE ORANGE CIRCLE..LARGE BROWN SQUARE
 	{0x1F7F0, 0x1F7F0, prW},   // So         HEAVY EQUALS SIGN
 	{0x1F800, 0x1F80B, prN},   // So    [12] LEFTWARDS ARROW WITH SMALL TRIANGLE ARROWHEAD..DOWNWARDS ARROW WITH LARGE TRIANGLE ARROWHEAD
@@ -2521,22 +2553,20 @@ var eastAsianWidth = [][3]int{
 	{0x1F947, 0x1F9FF, prW},   // So   [185] FIRST PLACE MEDAL..NAZAR AMULET
 	{0x1FA00, 0x1FA53, prN},   // So    [84] NEUTRAL CHESS KING..BLACK CHESS KNIGHT-BISHOP
 	{0x1FA60, 0x1FA6D, prN},   // So    [14] XIANGQI RED GENERAL..XIANGQI BLACK SOLDIER
-	{0x1FA70, 0x1FA74, prW},   // So     [5] BALLET SHOES..THONG SANDAL
-	{0x1FA78, 0x1FA7C, prW},   // So     [5] DROP OF BLOOD..CRUTCH
-	{0x1FA80, 0x1FA86, prW},   // So     [7] YO-YO..NESTING DOLLS
-	{0x1FA90, 0x1FAAC, prW},   // So    [29] RINGED PLANET..HAMSA
-	{0x1FAB0, 0x1FABA, prW},   // So    [11] FLY..NEST WITH EGGS
-	{0x1FAC0, 0x1FAC5, prW},   // So     [6] ANATOMICAL HEART..PERSON WITH CROWN
-	{0x1FAD0, 0x1FAD9, prW},   // So    [10] BLUEBERRIES..JAR
-	{0x1FAE0, 0x1FAE7, prW},   // So     [8] MELTING FACE..BUBBLES
-	{0x1FAF0, 0x1FAF6, prW},   // So     [7] HAND WITH INDEX FINGER AND THUMB CROSSED..HEART HANDS
+	{0x1FA70, 0x1FA7C, prW},   // So    [13] BALLET SHOES..CRUTCH
+	{0x1FA80, 0x1FA88, prW},   // So     [9] YO-YO..FLUTE
+	{0x1FA90, 0x1FABD, prW},   // So    [46] RINGED PLANET..WING
+	{0x1FABF, 0x1FAC5, prW},   // So     [7] GOOSE..PERSON WITH CROWN
+	{0x1FACE, 0x1FADB, prW},   // So    [14] MOOSE..PEA POD
+	{0x1FAE0, 0x1FAE8, prW},   // So     [9] MELTING FACE..SHAKING FACE
+	{0x1FAF0, 0x1FAF8, prW},   // So     [9] HAND WITH INDEX FINGER AND THUMB CROSSED..RIGHTWARDS PUSHING HAND
 	{0x1FB00, 0x1FB92, prN},   // So   [147] BLOCK SEXTANT-1..UPPER HALF INVERSE MEDIUM SHADE AND LOWER HALF BLOCK
 	{0x1FB94, 0x1FBCA, prN},   // So    [55] LEFT HALF INVERSE MEDIUM SHADE AND RIGHT HALF BLOCK..WHITE UP-POINTING CHEVRON
 	{0x1FBF0, 0x1FBF9, prN},   // Nd    [10] SEGMENTED DIGIT ZERO..SEGMENTED DIGIT NINE
 	{0x20000, 0x2A6DF, prW},   // Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF
 	{0x2A6E0, 0x2A6FF, prW},   // Cn    [32] <reserved-2A6E0>..<reserved-2A6FF>
-	{0x2A700, 0x2B738, prW},   // Lo  [4153] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B738
-	{0x2B739, 0x2B73F, prW},   // Cn     [7] <reserved-2B739>..<reserved-2B73F>
+	{0x2A700, 0x2B739, prW},   // Lo  [4154] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B739
+	{0x2B73A, 0x2B73F, prW},   // Cn     [6] <reserved-2B73A>..<reserved-2B73F>
 	{0x2B740, 0x2B81D, prW},   // Lo   [222] CJK UNIFIED IDEOGRAPH-2B740..CJK UNIFIED IDEOGRAPH-2B81D
 	{0x2B81E, 0x2B81F, prW},   // Cn     [2] <reserved-2B81E>..<reserved-2B81F>
 	{0x2B820, 0x2CEA1, prW},   // Lo  [5762] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEA1
@@ -2547,7 +2577,9 @@ var eastAsianWidth = [][3]int{
 	{0x2FA1E, 0x2FA1F, prW},   // Cn     [2] <reserved-2FA1E>..<reserved-2FA1F>
 	{0x2FA20, 0x2FFFD, prW},   // Cn  [1502] <reserved-2FA20>..<reserved-2FFFD>
 	{0x30000, 0x3134A, prW},   // Lo  [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A
-	{0x3134B, 0x3FFFD, prW},   // Cn [60595] <reserved-3134B>..<reserved-3FFFD>
+	{0x3134B, 0x3134F, prW},   // Cn     [5] <reserved-3134B>..<reserved-3134F>
+	{0x31350, 0x323AF, prW},   // Lo  [4192] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-323AF
+	{0x323B0, 0x3FFFD, prW},   // Cn [56398] <reserved-323B0>..<reserved-3FFFD>
 	{0xE0001, 0xE0001, prN},   // Cf         LANGUAGE TAG
 	{0xE0020, 0xE007F, prN},   // Cf    [96] TAG SPACE..CANCEL TAG
 	{0xE0100, 0xE01EF, prA},   // Mn   [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256

vendor/github.com/rivo/uniseg/emojipresentation.go

@@ -1,13 +1,13 @@
-package uniseg
-
 // Code generated via go generate from gen_properties.go. DO NOT EDIT.
 
+package uniseg
+
 // emojiPresentation are taken from
 //
 // and
-// https://unicode.org/Public/14.0.0/ucd/emoji/emoji-data.txt
+// https://unicode.org/Public/15.0.0/ucd/emoji/emoji-data.txt
 // ("Extended_Pictographic" only)
-// on September 10, 2022. See https://www.unicode.org/license.html for the Unicode
+// on September 5, 2023. See https://www.unicode.org/license.html for the Unicode
 // license agreement.
 var emojiPresentation = [][3]int{
 	{0x231A, 0x231B, prEmojiPresentation},   // E0.6   [2] (⌚..⌛)    watch..hourglass done
@@ -211,6 +211,7 @@ var emojiPresentation = [][3]int{
 	{0x1F6D1, 0x1F6D2, prEmojiPresentation}, // E3.0   [2] (🛑..🛒)    stop sign..shopping cart
 	{0x1F6D5, 0x1F6D5, prEmojiPresentation}, // E12.0  [1] (🛕)       hindu temple
 	{0x1F6D6, 0x1F6D7, prEmojiPresentation}, // E13.0  [2] (🛖..🛗)    hut..elevator
+	{0x1F6DC, 0x1F6DC, prEmojiPresentation}, // E15.0  [1] (🛜)       wireless
 	{0x1F6DD, 0x1F6DF, prEmojiPresentation}, // E14.0  [3] (🛝..🛟)    playground slide..ring buoy
 	{0x1F6EB, 0x1F6EC, prEmojiPresentation}, // E1.0   [2] (🛫..🛬)    airplane departure..airplane arrival
 	{0x1F6F4, 0x1F6F6, prEmojiPresentation}, // E3.0   [3] (🛴..🛶)    kick scooter..canoe
@@ -267,19 +268,28 @@ var emojiPresentation = [][3]int{
 	{0x1F9E7, 0x1F9FF, prEmojiPresentation}, // E11.0 [25] (🧧..🧿)    red envelope..nazar amulet
 	{0x1FA70, 0x1FA73, prEmojiPresentation}, // E12.0  [4] (🩰..🩳)    ballet shoes..shorts
 	{0x1FA74, 0x1FA74, prEmojiPresentation}, // E13.0  [1] (🩴)       thong sandal
+	{0x1FA75, 0x1FA77, prEmojiPresentation}, // E15.0  [3] (🩵..🩷)    light blue heart..pink heart
 	{0x1FA78, 0x1FA7A, prEmojiPresentation}, // E12.0  [3] (🩸..🩺)    drop of blood..stethoscope
 	{0x1FA7B, 0x1FA7C, prEmojiPresentation}, // E14.0  [2] (🩻..🩼)    x-ray..crutch
 	{0x1FA80, 0x1FA82, prEmojiPresentation}, // E12.0  [3] (🪀..🪂)    yo-yo..parachute
 	{0x1FA83, 0x1FA86, prEmojiPresentation}, // E13.0  [4] (🪃..🪆)    boomerang..nesting dolls
+	{0x1FA87, 0x1FA88, prEmojiPresentation}, // E15.0  [2] (🪇..🪈)    maracas..flute
 	{0x1FA90, 0x1FA95, prEmojiPresentation}, // E12.0  [6] (🪐..🪕)    ringed planet..banjo
 	{0x1FA96, 0x1FAA8, prEmojiPresentation}, // E13.0 [19] (🪖..🪨)    military helmet..rock
 	{0x1FAA9, 0x1FAAC, prEmojiPresentation}, // E14.0  [4] (🪩..🪬)    mirror ball..hamsa
+	{0x1FAAD, 0x1FAAF, prEmojiPresentation}, // E15.0  [3] (🪭..🪯)    folding hand fan..khanda
 	{0x1FAB0, 0x1FAB6, prEmojiPresentation}, // E13.0  [7] (🪰..🪶)    fly..feather
 	{0x1FAB7, 0x1FABA, prEmojiPresentation}, // E14.0  [4] (🪷..🪺)    lotus..nest with eggs
+	{0x1FABB, 0x1FABD, prEmojiPresentation}, // E15.0  [3] (🪻..🪽)    hyacinth..wing
+	{0x1FABF, 0x1FABF, prEmojiPresentation}, // E15.0  [1] (🪿)       goose
 	{0x1FAC0, 0x1FAC2, prEmojiPresentation}, // E13.0  [3] (🫀..🫂)    anatomical heart..people hugging
 	{0x1FAC3, 0x1FAC5, prEmojiPresentation}, // E14.0  [3] (🫃..🫅)    pregnant man..person with crown
+	{0x1FACE, 0x1FACF, prEmojiPresentation}, // E15.0  [2] (🫎..🫏)    moose..donkey
 	{0x1FAD0, 0x1FAD6, prEmojiPresentation}, // E13.0  [7] (🫐..🫖)    blueberries..teapot
 	{0x1FAD7, 0x1FAD9, prEmojiPresentation}, // E14.0  [3] (🫗..🫙)    pouring liquid..jar
+	{0x1FADA, 0x1FADB, prEmojiPresentation}, // E15.0  [2] (🫚..🫛)    ginger root..pea pod
 	{0x1FAE0, 0x1FAE7, prEmojiPresentation}, // E14.0  [8] (🫠..🫧)    melting face..bubbles
+	{0x1FAE8, 0x1FAE8, prEmojiPresentation}, // E15.0  [1] (🫨)       shaking face
 	{0x1FAF0, 0x1FAF6, prEmojiPresentation}, // E14.0  [7] (🫰..🫶)    hand with index finger and thumb crossed..heart hands
+	{0x1FAF7, 0x1FAF8, prEmojiPresentation}, // E15.0  [2] (🫷..🫸)    leftwards pushing hand..rightwards pushing hand
 }

vendor/github.com/rivo/uniseg/gen_breaktest.go

@@ -32,7 +32,7 @@ import (
 // We want to test against a specific version rather than the latest. When the
 // package is upgraded to a new version, change these to generate new tests.
 const (
-	testCaseURL = `https://www.unicode.org/Public/14.0.0/ucd/auxiliary/%s.txt`
+	testCaseURL = `https://www.unicode.org/Public/15.0.0/ucd/auxiliary/%s.txt`
 )
 
 func main() {
@@ -76,9 +76,9 @@ func parse(url string) ([]byte, error) {
 
 	buf := new(bytes.Buffer)
 	buf.Grow(120 << 10)
-	buf.WriteString(`package uniseg
+	buf.WriteString(`// Code generated via go generate from gen_breaktest.go. DO NOT EDIT.
 
-// Code generated via go generate from gen_breaktest.go. DO NOT EDIT.
+package uniseg
 
 // ` + os.Args[3] + ` are Grapheme testcases taken from
 // ` + url + `
@@ -136,7 +136,9 @@ var (
 //
 // E.g. for the input b="÷ 0020 × 0308 ÷ 1F1E6 ÷"
 // it will append
-//     "\u0020\u0308\U0001F1E6"
+//
+//	"\u0020\u0308\U0001F1E6"
+//
 // and "[][]rune{{0x0020,0x0308},{0x1F1E6},}"
 // to orig and exp respectively.
 //

vendor/github.com/rivo/uniseg/gen_properties.go

@@ -41,8 +41,8 @@ import (
 // We want to test against a specific version rather than the latest. When the
 // package is upgraded to a new version, change these to generate new tests.
 const (
-	propertyURL = `https://www.unicode.org/Public/14.0.0/ucd/%s.txt`
-	emojiURL    = `https://unicode.org/Public/14.0.0/ucd/emoji/emoji-data.txt`
+	propertyURL = `https://www.unicode.org/Public/15.0.0/ucd/%s.txt`
+	emojiURL    = `https://unicode.org/Public/15.0.0/ucd/emoji/emoji-data.txt`
 )
 
 // The regular expression for a line containing a code point range property.
@@ -178,6 +178,11 @@ func parse(propertyURL, emojiProperty string, includeGeneralCategory bool) (stri
 		}
 	}
 
+	// Avoid overflow during binary search.
+	if len(properties) >= 1<<31 {
+		return "", errors.New("too many properties")
+	}
+
 	// Sort properties.
 	sort.Slice(properties, func(i, j int) bool {
 		left, _ := strconv.ParseUint(properties[i][0], 16, 64)
@@ -200,9 +205,9 @@ func parse(propertyURL, emojiProperty string, includeGeneralCategory bool) (stri
 // ` + emojiURL + `
 // ("Extended_Pictographic" only)`
 	}
-	buf.WriteString(`package uniseg
+	buf.WriteString(`// Code generated via go generate from gen_properties.go. DO NOT EDIT.
 
-// Code generated via go generate from gen_properties.go. DO NOT EDIT.
+package uniseg
 
 // ` + os.Args[3] + ` are taken from
 // ` + propertyURL + emojiComment + `

vendor/github.com/rivo/uniseg/grapheme.go

@@ -13,9 +13,10 @@ import "unicode/utf8"
 // well as boundary information and character width is available via the various
 // methods (see examples below).
 //
-// Using this class to iterate over a string is convenient but it is much slower
-// than using this package's [Step] or [StepString] functions or any of the
-// other specialized functions starting with "First".
+// This class basically wraps the [StepString] parser and provides a convenient
+// interface to it. If you are only interested in some parts of this package's
+// functionality, using the specialized functions starting with "First" is
+// almost always faster.
 type Graphemes struct {
 	// The original string.
 	original string
@@ -222,7 +223,7 @@ func FirstGraphemeCluster(b []byte, state int) (cluster, rest []byte, width, new
 	if len(b) <= length { // If we're already past the end, there is nothing else to parse.
 		var prop int
 		if state < 0 {
-			prop = property(graphemeCodePoints, r)
+			prop = propertyGraphemes(r)
 		} else {
 			prop = state >> shiftGraphemePropState
 		}
@@ -252,16 +253,14 @@ func FirstGraphemeCluster(b []byte, state int) (cluster, rest []byte, width, new
 			return b[:length], b[length:], width, state | (prop << shiftGraphemePropState)
 		}
 
-		if r == vs16 {
-			width = 2
-		} else if firstProp != prExtendedPictographic && firstProp != prRegionalIndicator && firstProp != prL {
-			width += runeWidth(r, prop)
-		} else if firstProp == prExtendedPictographic {
+		if firstProp == prExtendedPictographic {
 			if r == vs15 {
 				width = 1
-			} else {
+			} else if r == vs16 {
 				width = 2
 			}
+		} else if firstProp != prRegionalIndicator && firstProp != prL {
+			width += runeWidth(r, prop)
 		}
 
 		length += l
@@ -284,7 +283,7 @@ func FirstGraphemeClusterInString(str string, state int) (cluster, rest string,
 	if len(str) <= length { // If we're already past the end, there is nothing else to parse.
 		var prop int
 		if state < 0 {
-			prop = property(graphemeCodePoints, r)
+			prop = propertyGraphemes(r)
 		} else {
 			prop = state >> shiftGraphemePropState
 		}
@@ -314,16 +313,14 @@ func FirstGraphemeClusterInString(str string, state int) (cluster, rest string,
 			return str[:length], str[length:], width, state | (prop << shiftGraphemePropState)
 		}
 
-		if r == vs16 {
-			width = 2
-		} else if firstProp != prExtendedPictographic && firstProp != prRegionalIndicator && firstProp != prL {
-			width += runeWidth(r, prop)
-		} else if firstProp == prExtendedPictographic {
+		if firstProp == prExtendedPictographic {
 			if r == vs15 {
 				width = 1
-			} else {
+			} else if r == vs16 {
 				width = 2
 			}
+		} else if firstProp != prRegionalIndicator && firstProp != prL {
+			width += runeWidth(r, prop)
 		}
 
 		length += l

vendor/github.com/rivo/uniseg/graphemeproperties.go

@@ -1,13 +1,13 @@
-package uniseg
-
 // Code generated via go generate from gen_properties.go. DO NOT EDIT.
 
+package uniseg
+
 // graphemeCodePoints are taken from
-// https://www.unicode.org/Public/14.0.0/ucd/auxiliary/GraphemeBreakProperty.txt
+// https://www.unicode.org/Public/15.0.0/ucd/auxiliary/GraphemeBreakProperty.txt
 // and
-// https://unicode.org/Public/14.0.0/ucd/emoji/emoji-data.txt
+// https://unicode.org/Public/15.0.0/ucd/emoji/emoji-data.txt
 // ("Extended_Pictographic" only)
-// on September 10, 2022. See https://www.unicode.org/license.html for the Unicode
+// on September 5, 2023. See https://www.unicode.org/license.html for the Unicode
 // license agreement.
 var graphemeCodePoints = [][3]int{
 	{0x0000, 0x0009, prControl},                // Cc  [10] <control-0000>..<control-0009>
@@ -143,6 +143,7 @@ var graphemeCodePoints = [][3]int{
 	{0x0CCC, 0x0CCD, prExtend},                 // Mn   [2] KANNADA VOWEL SIGN AU..KANNADA SIGN VIRAMA
 	{0x0CD5, 0x0CD6, prExtend},                 // Mc   [2] KANNADA LENGTH MARK..KANNADA AI LENGTH MARK
 	{0x0CE2, 0x0CE3, prExtend},                 // Mn   [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL
+	{0x0CF3, 0x0CF3, prSpacingMark},            // Mc       KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT
 	{0x0D00, 0x0D01, prExtend},                 // Mn   [2] MALAYALAM SIGN COMBINING ANUSVARA ABOVE..MALAYALAM SIGN CANDRABINDU
 	{0x0D02, 0x0D03, prSpacingMark},            // Mc   [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA
 	{0x0D3B, 0x0D3C, prExtend},                 // Mn   [2] MALAYALAM SIGN VERTICAL BAR VIRAMA..MALAYALAM SIGN CIRCULAR VIRAMA
@@ -172,7 +173,7 @@ var graphemeCodePoints = [][3]int{
 	{0x0EB1, 0x0EB1, prExtend},                 // Mn       LAO VOWEL SIGN MAI KAN
 	{0x0EB3, 0x0EB3, prSpacingMark},            // Lo       LAO VOWEL SIGN AM
 	{0x0EB4, 0x0EBC, prExtend},                 // Mn   [9] LAO VOWEL SIGN I..LAO SEMIVOWEL SIGN LO
-	{0x0EC8, 0x0ECD, prExtend},                 // Mn   [6] LAO TONE MAI EK..LAO NIGGAHITA
+	{0x0EC8, 0x0ECE, prExtend},                 // Mn   [7] LAO TONE MAI EK..LAO YAMAKKAN
 	{0x0F18, 0x0F19, prExtend},                 // Mn   [2] TIBETAN ASTROLOGICAL SIGN -KHYUD PA..TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS
 	{0x0F35, 0x0F35, prExtend},                 // Mn       TIBETAN MARK NGAS BZUNG NYI ZLA
 	{0x0F37, 0x0F37, prExtend},                 // Mn       TIBETAN MARK NGAS BZUNG SGOR RTAGS
@@ -1336,6 +1337,7 @@ var graphemeCodePoints = [][3]int{
 	{0x10AE5, 0x10AE6, prExtend},               // Mn   [2] MANICHAEAN ABBREVIATION MARK ABOVE..MANICHAEAN ABBREVIATION MARK BELOW
 	{0x10D24, 0x10D27, prExtend},               // Mn   [4] HANIFI ROHINGYA SIGN HARBAHAY..HANIFI ROHINGYA SIGN TASSI
 	{0x10EAB, 0x10EAC, prExtend},               // Mn   [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK
+	{0x10EFD, 0x10EFF, prExtend},               // Mn   [3] ARABIC SMALL LOW WORD SAKTA..ARABIC SMALL LOW WORD MADDA
 	{0x10F46, 0x10F50, prExtend},               // Mn  [11] SOGDIAN COMBINING DOT BELOW..SOGDIAN COMBINING STROKE BELOW
 	{0x10F82, 0x10F85, prExtend},               // Mn   [4] OLD UYGHUR COMBINING DOT ABOVE..OLD UYGHUR COMBINING TWO DOTS BELOW
 	{0x11000, 0x11000, prSpacingMark},          // Mc       BRAHMI SIGN CANDRABINDU
@@ -1375,6 +1377,7 @@ var graphemeCodePoints = [][3]int{
 	{0x11235, 0x11235, prSpacingMark},          // Mc       KHOJKI SIGN VIRAMA
 	{0x11236, 0x11237, prExtend},               // Mn   [2] KHOJKI SIGN NUKTA..KHOJKI SIGN SHADDA
 	{0x1123E, 0x1123E, prExtend},               // Mn       KHOJKI SIGN SUKUN
+	{0x11241, 0x11241, prExtend},               // Mn       KHOJKI VOWEL SIGN VOCALIC R
 	{0x112DF, 0x112DF, prExtend},               // Mn       KHUDAWADI SIGN ANUSVARA
 	{0x112E0, 0x112E2, prSpacingMark},          // Mc   [3] KHUDAWADI VOWEL SIGN AA..KHUDAWADI VOWEL SIGN II
 	{0x112E3, 0x112EA, prExtend},               // Mn   [8] KHUDAWADI VOWEL SIGN U..KHUDAWADI SIGN VIRAMA
@@ -1494,7 +1497,18 @@ var graphemeCodePoints = [][3]int{
 	{0x11D97, 0x11D97, prExtend},               // Mn       GUNJALA GONDI VIRAMA
 	{0x11EF3, 0x11EF4, prExtend},               // Mn   [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U
 	{0x11EF5, 0x11EF6, prSpacingMark},          // Mc   [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O
-	{0x13430, 0x13438, prControl},              // Cf   [9] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH END SEGMENT
+	{0x11F00, 0x11F01, prExtend},               // Mn   [2] KAWI SIGN CANDRABINDU..KAWI SIGN ANUSVARA
+	{0x11F02, 0x11F02, prPrepend},              // Lo       KAWI SIGN REPHA
+	{0x11F03, 0x11F03, prSpacingMark},          // Mc       KAWI SIGN VISARGA
+	{0x11F34, 0x11F35, prSpacingMark},          // Mc   [2] KAWI VOWEL SIGN AA..KAWI VOWEL SIGN ALTERNATE AA
+	{0x11F36, 0x11F3A, prExtend},               // Mn   [5] KAWI VOWEL SIGN I..KAWI VOWEL SIGN VOCALIC R
+	{0x11F3E, 0x11F3F, prSpacingMark},          // Mc   [2] KAWI VOWEL SIGN E..KAWI VOWEL SIGN AI
+	{0x11F40, 0x11F40, prExtend},               // Mn       KAWI VOWEL SIGN EU
+	{0x11F41, 0x11F41, prSpacingMark},          // Mc       KAWI SIGN KILLER
+	{0x11F42, 0x11F42, prExtend},               // Mn       KAWI CONJOINER
+	{0x13430, 0x1343F, prControl},              // Cf  [16] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH END WALLED ENCLOSURE
+	{0x13440, 0x13440, prExtend},               // Mn       EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY
+	{0x13447, 0x13455, prExtend},               // Mn  [15] EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP START..EGYPTIAN HIEROGLYPH MODIFIER DAMAGED
 	{0x16AF0, 0x16AF4, prExtend},               // Mn   [5] BASSA VAH COMBINING HIGH TONE..BASSA VAH COMBINING HIGH-LOW TONE
 	{0x16B30, 0x16B36, prExtend},               // Mn   [7] PAHAWH HMONG MARK CIM TUB..PAHAWH HMONG MARK CIM TAUM
 	{0x16F4F, 0x16F4F, prExtend},               // Mn       MIAO SIGN CONSONANT MODIFIER BAR
@@ -1527,9 +1541,11 @@ var graphemeCodePoints = [][3]int{
 	{0x1E01B, 0x1E021, prExtend},               // Mn   [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI
 	{0x1E023, 0x1E024, prExtend},               // Mn   [2] COMBINING GLAGOLITIC LETTER YU..COMBINING GLAGOLITIC LETTER SMALL YUS
 	{0x1E026, 0x1E02A, prExtend},               // Mn   [5] COMBINING GLAGOLITIC LETTER YO..COMBINING GLAGOLITIC LETTER FITA
+	{0x1E08F, 0x1E08F, prExtend},               // Mn       COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
 	{0x1E130, 0x1E136, prExtend},               // Mn   [7] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG TONE-D
 	{0x1E2AE, 0x1E2AE, prExtend},               // Mn       TOTO SIGN RISING TONE
 	{0x1E2EC, 0x1E2EF, prExtend},               // Mn   [4] WANCHO TONE TUP..WANCHO TONE KOINI
+	{0x1E4EC, 0x1E4EF, prExtend},               // Mn   [4] NAG MUNDARI SIGN MUHOR..NAG MUNDARI SIGN SUTUH
 	{0x1E8D0, 0x1E8D6, prExtend},               // Mn   [7] MENDE KIKAKUI COMBINING NUMBER TEENS..MENDE KIKAKUI COMBINING NUMBER MILLIONS
 	{0x1E944, 0x1E94A, prExtend},               // Mn   [7] ADLAM ALIF LENGTHENER..ADLAM NUKTA
 	{0x1F000, 0x1F003, prExtendedPictographic}, // E0.0   [4] (🀀..🀃)    MAHJONG TILE EAST WIND..MAHJONG TILE NORTH WIND
@@ -1780,7 +1796,8 @@ var graphemeCodePoints = [][3]int{
 	{0x1F6D3, 0x1F6D4, prExtendedPictographic}, // E0.0   [2] (🛓..🛔)    STUPA..PAGODA
 	{0x1F6D5, 0x1F6D5, prExtendedPictographic}, // E12.0  [1] (🛕)       hindu temple
 	{0x1F6D6, 0x1F6D7, prExtendedPictographic}, // E13.0  [2] (🛖..🛗)    hut..elevator
-	{0x1F6D8, 0x1F6DC, prExtendedPictographic}, // E0.0   [5] (🛘..🛜)    <reserved-1F6D8>..<reserved-1F6DC>
+	{0x1F6D8, 0x1F6DB, prExtendedPictographic}, // E0.0   [4] (🛘..🛛)    <reserved-1F6D8>..<reserved-1F6DB>
+	{0x1F6DC, 0x1F6DC, prExtendedPictographic}, // E15.0  [1] (🛜)       wireless
 	{0x1F6DD, 0x1F6DF, prExtendedPictographic}, // E14.0  [3] (🛝..🛟)    playground slide..ring buoy
 	{0x1F6E0, 0x1F6E5, prExtendedPictographic}, // E0.7   [6] (🛠️..🛥️)    hammer and wrench..motor boat
 	{0x1F6E6, 0x1F6E8, prExtendedPictographic}, // E0.0   [3] (🛦..🛨)    UP-POINTING MILITARY AIRPLANE..UP-POINTING SMALL AIRPLANE
@@ -1797,7 +1814,7 @@ var graphemeCodePoints = [][3]int{
 	{0x1F6FA, 0x1F6FA, prExtendedPictographic}, // E12.0  [1] (🛺)       auto rickshaw
 	{0x1F6FB, 0x1F6FC, prExtendedPictographic}, // E13.0  [2] (🛻..🛼)    pickup truck..roller skate
 	{0x1F6FD, 0x1F6FF, prExtendedPictographic}, // E0.0   [3] (🛽..🛿)    <reserved-1F6FD>..<reserved-1F6FF>
-	{0x1F774, 0x1F77F, prExtendedPictographic}, // E0.0  [12] (🝴..🝿)    <reserved-1F774>..<reserved-1F77F>
+	{0x1F774, 0x1F77F, prExtendedPictographic}, // E0.0  [12] (🝴..🝿)    LOT OF FORTUNE..ORCUS
 	{0x1F7D5, 0x1F7DF, prExtendedPictographic}, // E0.0  [11] (🟕..🟟)    CIRCLED TRIANGLE..<reserved-1F7DF>
 	{0x1F7E0, 0x1F7EB, prExtendedPictographic}, // E12.0 [12] (🟠..🟫)    orange circle..brown square
 	{0x1F7EC, 0x1F7EF, prExtendedPictographic}, // E0.0   [4] (🟬..🟯)    <reserved-1F7EC>..<reserved-1F7EF>
@@ -1856,30 +1873,37 @@ var graphemeCodePoints = [][3]int{
 	{0x1FA00, 0x1FA6F, prExtendedPictographic}, // E0.0 [112] (🨀..🩯)    NEUTRAL CHESS KING..<reserved-1FA6F>
 	{0x1FA70, 0x1FA73, prExtendedPictographic}, // E12.0  [4] (🩰..🩳)    ballet shoes..shorts
 	{0x1FA74, 0x1FA74, prExtendedPictographic}, // E13.0  [1] (🩴)       thong sandal
-	{0x1FA75, 0x1FA77, prExtendedPictographic}, // E0.0   [3] (🩵..🩷)    <reserved-1FA75>..<reserved-1FA77>
+	{0x1FA75, 0x1FA77, prExtendedPictographic}, // E15.0  [3] (🩵..🩷)    light blue heart..pink heart
 	{0x1FA78, 0x1FA7A, prExtendedPictographic}, // E12.0  [3] (🩸..🩺)    drop of blood..stethoscope
 	{0x1FA7B, 0x1FA7C, prExtendedPictographic}, // E14.0  [2] (🩻..🩼)    x-ray..crutch
 	{0x1FA7D, 0x1FA7F, prExtendedPictographic}, // E0.0   [3] (🩽..🩿)    <reserved-1FA7D>..<reserved-1FA7F>
 	{0x1FA80, 0x1FA82, prExtendedPictographic}, // E12.0  [3] (🪀..🪂)    yo-yo..parachute
 	{0x1FA83, 0x1FA86, prExtendedPictographic}, // E13.0  [4] (🪃..🪆)    boomerang..nesting dolls
-	{0x1FA87, 0x1FA8F, prExtendedPictographic}, // E0.0   [9] (🪇..🪏)    <reserved-1FA87>..<reserved-1FA8F>
+	{0x1FA87, 0x1FA88, prExtendedPictographic}, // E15.0  [2] (🪇..🪈)    maracas..flute
+	{0x1FA89, 0x1FA8F, prExtendedPictographic}, // E0.0   [7] (🪉..🪏)    <reserved-1FA89>..<reserved-1FA8F>
 	{0x1FA90, 0x1FA95, prExtendedPictographic}, // E12.0  [6] (🪐..🪕)    ringed planet..banjo
 	{0x1FA96, 0x1FAA8, prExtendedPictographic}, // E13.0 [19] (🪖..🪨)    military helmet..rock
 	{0x1FAA9, 0x1FAAC, prExtendedPictographic}, // E14.0  [4] (🪩..🪬)    mirror ball..hamsa
-	{0x1FAAD, 0x1FAAF, prExtendedPictographic}, // E0.0   [3] (🪭..🪯)    <reserved-1FAAD>..<reserved-1FAAF>
+	{0x1FAAD, 0x1FAAF, prExtendedPictographic}, // E15.0  [3] (🪭..🪯)    folding hand fan..khanda
 	{0x1FAB0, 0x1FAB6, prExtendedPictographic}, // E13.0  [7] (🪰..🪶)    fly..feather
 	{0x1FAB7, 0x1FABA, prExtendedPictographic}, // E14.0  [4] (🪷..🪺)    lotus..nest with eggs
-	{0x1FABB, 0x1FABF, prExtendedPictographic}, // E0.0   [5] (🪻..🪿)    <reserved-1FABB>..<reserved-1FABF>
+	{0x1FABB, 0x1FABD, prExtendedPictographic}, // E15.0  [3] (🪻..🪽)    hyacinth..wing
+	{0x1FABE, 0x1FABE, prExtendedPictographic}, // E0.0   [1] (🪾)       <reserved-1FABE>
+	{0x1FABF, 0x1FABF, prExtendedPictographic}, // E15.0  [1] (🪿)       goose
 	{0x1FAC0, 0x1FAC2, prExtendedPictographic}, // E13.0  [3] (🫀..🫂)    anatomical heart..people hugging
 	{0x1FAC3, 0x1FAC5, prExtendedPictographic}, // E14.0  [3] (🫃..🫅)    pregnant man..person with crown
-	{0x1FAC6, 0x1FACF, prExtendedPictographic}, // E0.0  [10] (🫆..🫏)    <reserved-1FAC6>..<reserved-1FACF>
+	{0x1FAC6, 0x1FACD, prExtendedPictographic}, // E0.0   [8] (🫆..🫍)    <reserved-1FAC6>..<reserved-1FACD>
+	{0x1FACE, 0x1FACF, prExtendedPictographic}, // E15.0  [2] (🫎..🫏)    moose..donkey
 	{0x1FAD0, 0x1FAD6, prExtendedPictographic}, // E13.0  [7] (🫐..🫖)    blueberries..teapot
 	{0x1FAD7, 0x1FAD9, prExtendedPictographic}, // E14.0  [3] (🫗..🫙)    pouring liquid..jar
-	{0x1FADA, 0x1FADF, prExtendedPictographic}, // E0.0   [6] (🫚..🫟)    <reserved-1FADA>..<reserved-1FADF>
+	{0x1FADA, 0x1FADB, prExtendedPictographic}, // E15.0  [2] (🫚..🫛)    ginger root..pea pod
+	{0x1FADC, 0x1FADF, prExtendedPictographic}, // E0.0   [4] (🫜..🫟)    <reserved-1FADC>..<reserved-1FADF>
 	{0x1FAE0, 0x1FAE7, prExtendedPictographic}, // E14.0  [8] (🫠..🫧)    melting face..bubbles
-	{0x1FAE8, 0x1FAEF, prExtendedPictographic}, // E0.0   [8] (🫨..🫯)    <reserved-1FAE8>..<reserved-1FAEF>
+	{0x1FAE8, 0x1FAE8, prExtendedPictographic}, // E15.0  [1] (🫨)       shaking face
+	{0x1FAE9, 0x1FAEF, prExtendedPictographic}, // E0.0   [7] (🫩..🫯)    <reserved-1FAE9>..<reserved-1FAEF>
 	{0x1FAF0, 0x1FAF6, prExtendedPictographic}, // E14.0  [7] (🫰..🫶)    hand with index finger and thumb crossed..heart hands
-	{0x1FAF7, 0x1FAFF, prExtendedPictographic}, // E0.0   [9] (🫷..🫿)    <reserved-1FAF7>..<reserved-1FAFF>
+	{0x1FAF7, 0x1FAF8, prExtendedPictographic}, // E15.0  [2] (🫷..🫸)    leftwards pushing hand..rightwards pushing hand
+	{0x1FAF9, 0x1FAFF, prExtendedPictographic}, // E0.0   [7] (🫹..🫿)    <reserved-1FAF9>..<reserved-1FAFF>
 	{0x1FC00, 0x1FFFD, prExtendedPictographic}, // E0.0[1022] (🰀..🿽)    <reserved-1FC00>..<reserved-1FFFD>
 	{0xE0000, 0xE0000, prControl},              // Cn       <reserved-E0000>
 	{0xE0001, 0xE0001, prControl},              // Cf       LANGUAGE TAG

vendor/github.com/rivo/uniseg/graphemerules.go

@@ -21,11 +21,12 @@ const (
 	grBoundary
 )
 
-// The grapheme cluster parser's state transitions. Maps (state, property) to
-// (new state, breaking instruction, rule number). The breaking instruction
-// always refers to the boundary between the last and next code point.
+// grTransitions implements the grapheme cluster parser's state transitions.
+// Maps state and property to a new state, a breaking instruction, and rule
+// number. The breaking instruction always refers to the boundary between the
+// last and next code point. Returns negative values if no transition is found.
 //
-// This map is queried as follows:
+// This function is used as follows:
 //
 //  1. Find specific state + specific property. Stop if found.
 //  2. Find specific state + any property.
@@ -36,59 +37,96 @@ const (
 //     are equal. Stop.
 //  6. Assume grAny and grBoundary.
 //
-// Unicode version 14.0.0.
-var grTransitions = map[[2]int][3]int{
+// Unicode version 15.0.0.
+func grTransitions(state, prop int) (newState int, newProp int, boundary int) {
+	// It turns out that using a big switch statement is much faster than using
+	// a map.
+
+	switch uint64(state) | uint64(prop)<<32 {
 	// GB5
-	{grAny, prCR}:      {grCR, grBoundary, 50},
-	{grAny, prLF}:      {grControlLF, grBoundary, 50},
-	{grAny, prControl}: {grControlLF, grBoundary, 50},
+	case grAny | prCR<<32:
+		return grCR, grBoundary, 50
+	case grAny | prLF<<32:
+		return grControlLF, grBoundary, 50
+	case grAny | prControl<<32:
+		return grControlLF, grBoundary, 50
 
 	// GB4
-	{grCR, prAny}:        {grAny, grBoundary, 40},
-	{grControlLF, prAny}: {grAny, grBoundary, 40},
-
-	// GB3.
-	{grCR, prLF}: {grControlLF, grNoBoundary, 30},
-
-	// GB6.
-	{grAny, prL}: {grL, grBoundary, 9990},
-	{grL, prL}:   {grL, grNoBoundary, 60},
-	{grL, prV}:   {grLVV, grNoBoundary, 60},
-	{grL, prLV}:  {grLVV, grNoBoundary, 60},
-	{grL, prLVT}: {grLVTT, grNoBoundary, 60},
-
-	// GB7.
-	{grAny, prLV}: {grLVV, grBoundary, 9990},
-	{grAny, prV}:  {grLVV, grBoundary, 9990},
-	{grLVV, prV}:  {grLVV, grNoBoundary, 70},
-	{grLVV, prT}:  {grLVTT, grNoBoundary, 70},
-
-	// GB8.
-	{grAny, prLVT}: {grLVTT, grBoundary, 9990},
-	{grAny, prT}:   {grLVTT, grBoundary, 9990},
-	{grLVTT, prT}:  {grLVTT, grNoBoundary, 80},
-
-	// GB9.
-	{grAny, prExtend}: {grAny, grNoBoundary, 90},
-	{grAny, prZWJ}:    {grAny, grNoBoundary, 90},
-
-	// GB9a.
-	{grAny, prSpacingMark}: {grAny, grNoBoundary, 91},
-
-	// GB9b.
-	{grAny, prPrepend}: {grPrepend, grBoundary, 9990},
-	{grPrepend, prAny}: {grAny, grNoBoundary, 92},
-
-	// GB11.
-	{grAny, prExtendedPictographic}:                     {grExtendedPictographic, grBoundary, 9990},
-	{grExtendedPictographic, prExtend}:                  {grExtendedPictographic, grNoBoundary, 110},
-	{grExtendedPictographic, prZWJ}:                     {grExtendedPictographicZWJ, grNoBoundary, 110},
-	{grExtendedPictographicZWJ, prExtendedPictographic}: {grExtendedPictographic, grNoBoundary, 110},
-
-	// GB12 / GB13.
-	{grAny, prRegionalIndicator}:    {grRIOdd, grBoundary, 9990},
-	{grRIOdd, prRegionalIndicator}:  {grRIEven, grNoBoundary, 120},
-	{grRIEven, prRegionalIndicator}: {grRIOdd, grBoundary, 120},
+	case grCR | prAny<<32:
+		return grAny, grBoundary, 40
+	case grControlLF | prAny<<32:
+		return grAny, grBoundary, 40
+
+	// GB3
+	case grCR | prLF<<32:
+		return grControlLF, grNoBoundary, 30
+
+	// GB6
+	case grAny | prL<<32:
+		return grL, grBoundary, 9990
+	case grL | prL<<32:
+		return grL, grNoBoundary, 60
+	case grL | prV<<32:
+		return grLVV, grNoBoundary, 60
+	case grL | prLV<<32:
+		return grLVV, grNoBoundary, 60
+	case grL | prLVT<<32:
+		return grLVTT, grNoBoundary, 60
+
+	// GB7
+	case grAny | prLV<<32:
+		return grLVV, grBoundary, 9990
+	case grAny | prV<<32:
+		return grLVV, grBoundary, 9990
+	case grLVV | prV<<32:
+		return grLVV, grNoBoundary, 70
+	case grLVV | prT<<32:
+		return grLVTT, grNoBoundary, 70
+
+	// GB8
+	case grAny | prLVT<<32:
+		return grLVTT, grBoundary, 9990
+	case grAny | prT<<32:
+		return grLVTT, grBoundary, 9990
+	case grLVTT | prT<<32:
+		return grLVTT, grNoBoundary, 80
+
+	// GB9
+	case grAny | prExtend<<32:
+		return grAny, grNoBoundary, 90
+	case grAny | prZWJ<<32:
+		return grAny, grNoBoundary, 90
+
+	// GB9a
+	case grAny | prSpacingMark<<32:
+		return grAny, grNoBoundary, 91
+
+	// GB9b
+	case grAny | prPrepend<<32:
+		return grPrepend, grBoundary, 9990
+	case grPrepend | prAny<<32:
+		return grAny, grNoBoundary, 92
+
+	// GB11
+	case grAny | prExtendedPictographic<<32:
+		return grExtendedPictographic, grBoundary, 9990
+	case grExtendedPictographic | prExtend<<32:
+		return grExtendedPictographic, grNoBoundary, 110
+	case grExtendedPictographic | prZWJ<<32:
+		return grExtendedPictographicZWJ, grNoBoundary, 110
+	case grExtendedPictographicZWJ | prExtendedPictographic<<32:
+		return grExtendedPictographic, grNoBoundary, 110
+
+	// GB12 / GB13
+	case grAny | prRegionalIndicator<<32:
+		return grRIOdd, grBoundary, 9990
+	case grRIOdd | prRegionalIndicator<<32:
+		return grRIEven, grNoBoundary, 120
+	case grRIEven | prRegionalIndicator<<32:
+		return grRIOdd, grBoundary, 120
+	default:
+		return -1, -1, -1
+	}
 }
 
 // transitionGraphemeState determines the new state of the grapheme cluster
@@ -97,40 +135,40 @@ var grTransitions = map[[2]int][3]int{
 // table) and whether a cluster boundary was detected.
 func transitionGraphemeState(state int, r rune) (newState, prop int, boundary bool) {
 	// Determine the property of the next character.
-	prop = property(graphemeCodePoints, r)
+	prop = propertyGraphemes(r)
 
 	// Find the applicable transition.
-	transition, ok := grTransitions[[2]int{state, prop}]
-	if ok {
+	nextState, nextProp, _ := grTransitions(state, prop)
+	if nextState >= 0 {
 		// We have a specific transition. We'll use it.
-		return transition[0], prop, transition[1] == grBoundary
+		return nextState, prop, nextProp == grBoundary
 	}
 
 	// No specific transition found. Try the less specific ones.
-	transAnyProp, okAnyProp := grTransitions[[2]int{state, prAny}]
-	transAnyState, okAnyState := grTransitions[[2]int{grAny, prop}]
-	if okAnyProp && okAnyState {
+	anyPropState, anyPropProp, anyPropRule := grTransitions(state, prAny)
+	anyStateState, anyStateProp, anyStateRule := grTransitions(grAny, prop)
+	if anyPropState >= 0 && anyStateState >= 0 {
 		// Both apply. We'll use a mix (see comments for grTransitions).
-		newState = transAnyState[0]
-		boundary = transAnyState[1] == grBoundary
-		if transAnyProp[2] < transAnyState[2] {
-			boundary = transAnyProp[1] == grBoundary
+		newState = anyStateState
+		boundary = anyStateProp == grBoundary
+		if anyPropRule < anyStateRule {
+			boundary = anyPropProp == grBoundary
 		}
 		return
 	}
 
-	if okAnyProp {
+	if anyPropState >= 0 {
 		// We only have a specific state.
-		return transAnyProp[0], prop, transAnyProp[1] == grBoundary
+		return anyPropState, prop, anyPropProp == grBoundary
 		// This branch will probably never be reached because okAnyState will
 		// always be true given the current transition map. But we keep it here
 		// for future modifications to the transition map where this may not be
 		// true anymore.
 	}
 
-	if okAnyState {
+	if anyStateState >= 0 {
 		// We only have a specific property.
-		return transAnyState[0], prop, transAnyState[1] == grBoundary
+		return anyStateState, prop, anyStateProp == grBoundary
 	}
 
 	// No known transition. GB999: Any ÷ Any.

vendor/github.com/rivo/uniseg/line.go

@@ -80,7 +80,7 @@ func FirstLineSegment(b []byte, state int) (segment, rest []byte, mustBreak bool
 	}
 }
 
-// FirstLineSegmentInString is like FirstLineSegment() but its input and outputs
+// FirstLineSegmentInString is like [FirstLineSegment] but its input and outputs
 // are strings.
 func FirstLineSegmentInString(str string, state int) (segment, rest string, mustBreak bool, newState int) {
 	// An empty byte slice returns nothing.
@@ -122,13 +122,13 @@ func FirstLineSegmentInString(str string, state int) (segment, rest string, must
 // [UAX #14]: https://www.unicode.org/reports/tr14/#Algorithm
 func HasTrailingLineBreak(b []byte) bool {
 	r, _ := utf8.DecodeLastRune(b)
-	property, _ := propertyWithGenCat(lineBreakCodePoints, r)
-	return property == lbBK || property == lbCR || property == lbLF || property == lbNL
+	property, _ := propertyLineBreak(r)
+	return property == prBK || property == prCR || property == prLF || property == prNL
 }
 
 // HasTrailingLineBreakInString is like [HasTrailingLineBreak] but for a string.
 func HasTrailingLineBreakInString(str string) bool {
 	r, _ := utf8.DecodeLastRuneInString(str)
-	property, _ := propertyWithGenCat(lineBreakCodePoints, r)
-	return property == lbBK || property == lbCR || property == lbLF || property == lbNL
+	property, _ := propertyLineBreak(r)
+	return property == prBK || property == prCR || property == prLF || property == prNL
 }

vendor/github.com/rivo/uniseg/lineproperties.go

@@ -1,13 +1,13 @@
-package uniseg
-
 // Code generated via go generate from gen_properties.go. DO NOT EDIT.
 
+package uniseg
+
 // lineBreakCodePoints are taken from
-// https://www.unicode.org/Public/14.0.0/ucd/LineBreak.txt
+// https://www.unicode.org/Public/15.0.0/ucd/LineBreak.txt
 // and
-// https://unicode.org/Public/14.0.0/ucd/emoji/emoji-data.txt
+// https://unicode.org/Public/15.0.0/ucd/emoji/emoji-data.txt
 // ("Extended_Pictographic" only)
-// on September 10, 2022. See https://www.unicode.org/license.html for the Unicode
+// on September 5, 2023. See https://www.unicode.org/license.html for the Unicode
 // license agreement.
 var lineBreakCodePoints = [][4]int{
 	{0x0000, 0x0008, prCM, gcCc},     //     [9] <control-0000>..<control-0008>
@@ -439,6 +439,7 @@ var lineBreakCodePoints = [][4]int{
 	{0x0CE2, 0x0CE3, prCM, gcMn},     //     [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL
 	{0x0CE6, 0x0CEF, prNU, gcNd},     //    [10] KANNADA DIGIT ZERO..KANNADA DIGIT NINE
 	{0x0CF1, 0x0CF2, prAL, gcLo},     //     [2] KANNADA SIGN JIHVAMULIYA..KANNADA SIGN UPADHMANIYA
+	{0x0CF3, 0x0CF3, prCM, gcMc},     //         KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT
 	{0x0D00, 0x0D01, prCM, gcMn},     //     [2] MALAYALAM SIGN COMBINING ANUSVARA ABOVE..MALAYALAM SIGN CANDRABINDU
 	{0x0D02, 0x0D03, prCM, gcMc},     //     [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA
 	{0x0D04, 0x0D0C, prAL, gcLo},     //     [9] MALAYALAM LETTER VEDIC ANUSVARA..MALAYALAM LETTER VOCALIC L
@@ -500,7 +501,7 @@ var lineBreakCodePoints = [][4]int{
 	{0x0EBD, 0x0EBD, prSA, gcLo},     //         LAO SEMIVOWEL SIGN NYO
 	{0x0EC0, 0x0EC4, prSA, gcLo},     //     [5] LAO VOWEL SIGN E..LAO VOWEL SIGN AI
 	{0x0EC6, 0x0EC6, prSA, gcLm},     //         LAO KO LA
-	{0x0EC8, 0x0ECD, prSA, gcMn},     //     [6] LAO TONE MAI EK..LAO NIGGAHITA
+	{0x0EC8, 0x0ECE, prSA, gcMn},     //     [7] LAO TONE MAI EK..LAO YAMAKKAN
 	{0x0ED0, 0x0ED9, prNU, gcNd},     //    [10] LAO DIGIT ZERO..LAO DIGIT NINE
 	{0x0EDC, 0x0EDF, prSA, gcLo},     //     [4] LAO HO NO..LAO LETTER KHMU NYO
 	{0x0F00, 0x0F00, prAL, gcLo},     //         TIBETAN SYLLABLE OM
@@ -813,7 +814,11 @@ var lineBreakCodePoints = [][4]int{
 	{0x1D79, 0x1D7F, prAL, gcLl},     //     [7] LATIN SMALL LETTER INSULAR G..LATIN SMALL LETTER UPSILON WITH STROKE
 	{0x1D80, 0x1D9A, prAL, gcLl},     //    [27] LATIN SMALL LETTER B WITH PALATAL HOOK..LATIN SMALL LETTER EZH WITH RETROFLEX HOOK
 	{0x1D9B, 0x1DBF, prAL, gcLm},     //    [37] MODIFIER LETTER SMALL TURNED ALPHA..MODIFIER LETTER SMALL THETA
-	{0x1DC0, 0x1DFF, prCM, gcMn},     //    [64] COMBINING DOTTED GRAVE ACCENT..COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW
+	{0x1DC0, 0x1DCC, prCM, gcMn},     //    [13] COMBINING DOTTED GRAVE ACCENT..COMBINING MACRON-BREVE
+	{0x1DCD, 0x1DCD, prGL, gcMn},     //         COMBINING DOUBLE CIRCUMFLEX ABOVE
+	{0x1DCE, 0x1DFB, prCM, gcMn},     //    [46] COMBINING OGONEK ABOVE..COMBINING DELETION MARK
+	{0x1DFC, 0x1DFC, prGL, gcMn},     //         COMBINING DOUBLE INVERTED BREVE BELOW
+	{0x1DFD, 0x1DFF, prCM, gcMn},     //     [3] COMBINING ALMOST EQUAL TO BELOW..COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW
 	{0x1E00, 0x1EFF, prAL, gcLC},     //   [256] LATIN CAPITAL LETTER A WITH RING BELOW..LATIN SMALL LETTER Y WITH LOOP
 	{0x1F00, 0x1F15, prAL, gcLC},     //    [22] GREEK SMALL LETTER ALPHA WITH PSILI..GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA
 	{0x1F18, 0x1F1D, prAL, gcLu},     //     [6] GREEK CAPITAL LETTER EPSILON WITH PSILI..GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA
@@ -889,7 +894,7 @@ var lineBreakCodePoints = [][4]int{
 	{0x2054, 0x2054, prAL, gcPc},     //         INVERTED UNDERTIE
 	{0x2055, 0x2055, prAL, gcPo},     //         FLOWER PUNCTUATION MARK
 	{0x2056, 0x2056, prBA, gcPo},     //         THREE DOT PUNCTUATION
-	{0x2057, 0x2057, prAL, gcPo},     //         QUADRUPLE PRIME
+	{0x2057, 0x2057, prPO, gcPo},     //         QUADRUPLE PRIME
 	{0x2058, 0x205B, prBA, gcPo},     //     [4] FOUR DOT PUNCTUATION..FOUR DOT MARK
 	{0x205C, 0x205C, prAL, gcPo},     //         DOTTED CROSS
 	{0x205D, 0x205E, prBA, gcPo},     //     [2] TRICOLON..VERTICAL FOUR DOTS
@@ -2751,6 +2756,7 @@ var lineBreakCodePoints = [][4]int{
 	{0x10EAB, 0x10EAC, prCM, gcMn},   //     [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK
 	{0x10EAD, 0x10EAD, prBA, gcPd},   //         YEZIDI HYPHENATION MARK
 	{0x10EB0, 0x10EB1, prAL, gcLo},   //     [2] YEZIDI LETTER LAM WITH DOT ABOVE..YEZIDI LETTER YOT WITH CIRCUMFLEX ABOVE
+	{0x10EFD, 0x10EFF, prCM, gcMn},   //     [3] ARABIC SMALL LOW WORD SAKTA..ARABIC SMALL LOW WORD MADDA
 	{0x10F00, 0x10F1C, prAL, gcLo},   //    [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL
 	{0x10F1D, 0x10F26, prAL, gcNo},   //    [10] OLD SOGDIAN NUMBER ONE..OLD SOGDIAN FRACTION ONE HALF
 	{0x10F27, 0x10F27, prAL, gcLo},   //         OLD SOGDIAN LIGATURE AYIN-DALETH
@@ -2840,6 +2846,8 @@ var lineBreakCodePoints = [][4]int{
 	{0x1123B, 0x1123C, prBA, gcPo},   //     [2] KHOJKI SECTION MARK..KHOJKI DOUBLE SECTION MARK
 	{0x1123D, 0x1123D, prAL, gcPo},   //         KHOJKI ABBREVIATION SIGN
 	{0x1123E, 0x1123E, prCM, gcMn},   //         KHOJKI SIGN SUKUN
+	{0x1123F, 0x11240, prAL, gcLo},   //     [2] KHOJKI LETTER QA..KHOJKI LETTER SHORT I
+	{0x11241, 0x11241, prCM, gcMn},   //         KHOJKI VOWEL SIGN VOCALIC R
 	{0x11280, 0x11286, prAL, gcLo},   //     [7] MULTANI LETTER A..MULTANI LETTER GA
 	{0x11288, 0x11288, prAL, gcLo},   //         MULTANI LETTER GHA
 	{0x1128A, 0x1128D, prAL, gcLo},   //     [4] MULTANI LETTER CA..MULTANI LETTER JJA
@@ -3013,6 +3021,7 @@ var lineBreakCodePoints = [][4]int{
 	{0x11AA1, 0x11AA2, prBA, gcPo},   //     [2] SOYOMBO TERMINAL MARK-1..SOYOMBO TERMINAL MARK-2
 	{0x11AB0, 0x11ABF, prAL, gcLo},   //    [16] CANADIAN SYLLABICS NATTILIK HI..CANADIAN SYLLABICS SPA
 	{0x11AC0, 0x11AF8, prAL, gcLo},   //    [57] PAU CIN HAU LETTER PA..PAU CIN HAU GLOTTAL STOP FINAL
+	{0x11B00, 0x11B09, prBB, gcPo},   //    [10] DEVANAGARI HEAD MARK..DEVANAGARI SIGN MINDU
 	{0x11C00, 0x11C08, prAL, gcLo},   //     [9] BHAIKSUKI LETTER A..BHAIKSUKI LETTER VOCALIC L
 	{0x11C0A, 0x11C2E, prAL, gcLo},   //    [37] BHAIKSUKI LETTER E..BHAIKSUKI LETTER HA
 	{0x11C2F, 0x11C2F, prCM, gcMc},   //         BHAIKSUKI VOWEL SIGN AA
@@ -3059,6 +3068,20 @@ var lineBreakCodePoints = [][4]int{
 	{0x11EF3, 0x11EF4, prCM, gcMn},   //     [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U
 	{0x11EF5, 0x11EF6, prCM, gcMc},   //     [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O
 	{0x11EF7, 0x11EF8, prAL, gcPo},   //     [2] MAKASAR PASSIMBANG..MAKASAR END OF SECTION
+	{0x11F00, 0x11F01, prCM, gcMn},   //     [2] KAWI SIGN CANDRABINDU..KAWI SIGN ANUSVARA
+	{0x11F02, 0x11F02, prAL, gcLo},   //         KAWI SIGN REPHA
+	{0x11F03, 0x11F03, prCM, gcMc},   //         KAWI SIGN VISARGA
+	{0x11F04, 0x11F10, prAL, gcLo},   //    [13] KAWI LETTER A..KAWI LETTER O
+	{0x11F12, 0x11F33, prAL, gcLo},   //    [34] KAWI LETTER KA..KAWI LETTER JNYA
+	{0x11F34, 0x11F35, prCM, gcMc},   //     [2] KAWI VOWEL SIGN AA..KAWI VOWEL SIGN ALTERNATE AA
+	{0x11F36, 0x11F3A, prCM, gcMn},   //     [5] KAWI VOWEL SIGN I..KAWI VOWEL SIGN VOCALIC R
+	{0x11F3E, 0x11F3F, prCM, gcMc},   //     [2] KAWI VOWEL SIGN E..KAWI VOWEL SIGN AI
+	{0x11F40, 0x11F40, prCM, gcMn},   //         KAWI VOWEL SIGN EU
+	{0x11F41, 0x11F41, prCM, gcMc},   //         KAWI SIGN KILLER
+	{0x11F42, 0x11F42, prCM, gcMn},   //         KAWI CONJOINER
+	{0x11F43, 0x11F44, prBA, gcPo},   //     [2] KAWI DANDA..KAWI DOUBLE DANDA
+	{0x11F45, 0x11F4F, prID, gcPo},   //    [11] KAWI PUNCTUATION SECTION MARKER..KAWI PUNCTUATION CLOSING SPIRAL
+	{0x11F50, 0x11F59, prNU, gcNd},   //    [10] KAWI DIGIT ZERO..KAWI DIGIT NINE
 	{0x11FB0, 0x11FB0, prAL, gcLo},   //         LISU LETTER YHA
 	{0x11FC0, 0x11FD4, prAL, gcNo},   //    [21] TAMIL FRACTION ONE THREE-HUNDRED-AND-TWENTIETH..TAMIL FRACTION DOWNSCALING FACTOR KIIZH
 	{0x11FD5, 0x11FDC, prAL, gcSo},   //     [8] TAMIL SIGN NEL..TAMIL SIGN MUKKURUNI
@@ -3084,10 +3107,18 @@ var lineBreakCodePoints = [][4]int{
 	{0x1328A, 0x13378, prAL, gcLo},   //   [239] EGYPTIAN HIEROGLYPH O037..EGYPTIAN HIEROGLYPH V011
 	{0x13379, 0x13379, prOP, gcLo},   //         EGYPTIAN HIEROGLYPH V011A
 	{0x1337A, 0x1337B, prCL, gcLo},   //     [2] EGYPTIAN HIEROGLYPH V011B..EGYPTIAN HIEROGLYPH V011C
-	{0x1337C, 0x1342E, prAL, gcLo},   //   [179] EGYPTIAN HIEROGLYPH V012..EGYPTIAN HIEROGLYPH AA032
+	{0x1337C, 0x1342F, prAL, gcLo},   //   [180] EGYPTIAN HIEROGLYPH V012..EGYPTIAN HIEROGLYPH V011D
 	{0x13430, 0x13436, prGL, gcCf},   //     [7] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH OVERLAY MIDDLE
 	{0x13437, 0x13437, prOP, gcCf},   //         EGYPTIAN HIEROGLYPH BEGIN SEGMENT
 	{0x13438, 0x13438, prCL, gcCf},   //         EGYPTIAN HIEROGLYPH END SEGMENT
+	{0x13439, 0x1343B, prGL, gcCf},   //     [3] EGYPTIAN HIEROGLYPH INSERT AT MIDDLE..EGYPTIAN HIEROGLYPH INSERT AT BOTTOM
+	{0x1343C, 0x1343C, prOP, gcCf},   //         EGYPTIAN HIEROGLYPH BEGIN ENCLOSURE
+	{0x1343D, 0x1343D, prCL, gcCf},   //         EGYPTIAN HIEROGLYPH END ENCLOSURE
+	{0x1343E, 0x1343E, prOP, gcCf},   //         EGYPTIAN HIEROGLYPH BEGIN WALLED ENCLOSURE
+	{0x1343F, 0x1343F, prCL, gcCf},   //         EGYPTIAN HIEROGLYPH END WALLED ENCLOSURE
+	{0x13440, 0x13440, prCM, gcMn},   //         EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY
+	{0x13441, 0x13446, prAL, gcLo},   //     [6] EGYPTIAN HIEROGLYPH FULL BLANK..EGYPTIAN HIEROGLYPH WIDE LOST SIGN
+	{0x13447, 0x13455, prCM, gcMn},   //    [15] EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP START..EGYPTIAN HIEROGLYPH MODIFIER DAMAGED
 	{0x14400, 0x145CD, prAL, gcLo},   //   [462] ANATOLIAN HIEROGLYPH A001..ANATOLIAN HIEROGLYPH A409
 	{0x145CE, 0x145CE, prOP, gcLo},   //         ANATOLIAN HIEROGLYPH A410 BEGIN LOGOGRAM MARK
 	{0x145CF, 0x145CF, prCL, gcLo},   //         ANATOLIAN HIEROGLYPH A410A END LOGOGRAM MARK
@@ -3137,7 +3168,9 @@ var lineBreakCodePoints = [][4]int{
 	{0x1AFFD, 0x1AFFE, prAL, gcLm},   //     [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8
 	{0x1B000, 0x1B0FF, prID, gcLo},   //   [256] KATAKANA LETTER ARCHAIC E..HENTAIGANA LETTER RE-2
 	{0x1B100, 0x1B122, prID, gcLo},   //    [35] HENTAIGANA LETTER RE-3..KATAKANA LETTER ARCHAIC WU
+	{0x1B132, 0x1B132, prCJ, gcLo},   //         HIRAGANA LETTER SMALL KO
 	{0x1B150, 0x1B152, prCJ, gcLo},   //     [3] HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO
+	{0x1B155, 0x1B155, prCJ, gcLo},   //         KATAKANA LETTER SMALL KO
 	{0x1B164, 0x1B167, prCJ, gcLo},   //     [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N
 	{0x1B170, 0x1B2FB, prID, gcLo},   //   [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB
 	{0x1BC00, 0x1BC6A, prAL, gcLo},   //   [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M
@@ -3168,6 +3201,7 @@ var lineBreakCodePoints = [][4]int{
 	{0x1D200, 0x1D241, prAL, gcSo},   //    [66] GREEK VOCAL NOTATION SYMBOL-1..GREEK INSTRUMENTAL NOTATION SYMBOL-54
 	{0x1D242, 0x1D244, prCM, gcMn},   //     [3] COMBINING GREEK MUSICAL TRISEME..COMBINING GREEK MUSICAL PENTASEME
 	{0x1D245, 0x1D245, prAL, gcSo},   //         GREEK MUSICAL LEIMMA
+	{0x1D2C0, 0x1D2D3, prAL, gcNo},   //    [20] KAKTOVIK NUMERAL ZERO..KAKTOVIK NUMERAL NINETEEN
 	{0x1D2E0, 0x1D2F3, prAL, gcNo},   //    [20] MAYAN NUMERAL ZERO..MAYAN NUMERAL NINETEEN
 	{0x1D300, 0x1D356, prAL, gcSo},   //    [87] MONOGRAM FOR EARTH..TETRAGRAM FOR FOSTERING
 	{0x1D360, 0x1D378, prAL, gcNo},   //    [25] COUNTING ROD UNIT DIGIT ONE..TALLY MARK FIVE
@@ -3228,11 +3262,14 @@ var lineBreakCodePoints = [][4]int{
 	{0x1DF00, 0x1DF09, prAL, gcLl},   //    [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK
 	{0x1DF0A, 0x1DF0A, prAL, gcLo},   //         LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK
 	{0x1DF0B, 0x1DF1E, prAL, gcLl},   //    [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL
+	{0x1DF25, 0x1DF2A, prAL, gcLl},   //     [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK
 	{0x1E000, 0x1E006, prCM, gcMn},   //     [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE
 	{0x1E008, 0x1E018, prCM, gcMn},   //    [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU
 	{0x1E01B, 0x1E021, prCM, gcMn},   //     [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI
 	{0x1E023, 0x1E024, prCM, gcMn},   //     [2] COMBINING GLAGOLITIC LETTER YU..COMBINING GLAGOLITIC LETTER SMALL YUS
 	{0x1E026, 0x1E02A, prCM, gcMn},   //     [5] COMBINING GLAGOLITIC LETTER YO..COMBINING GLAGOLITIC LETTER FITA
+	{0x1E030, 0x1E06D, prAL, gcLm},   //    [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE
+	{0x1E08F, 0x1E08F, prCM, gcMn},   //         COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
 	{0x1E100, 0x1E12C, prAL, gcLo},   //    [45] NYIAKENG PUACHUE HMONG LETTER MA..NYIAKENG PUACHUE HMONG LETTER W
 	{0x1E130, 0x1E136, prCM, gcMn},   //     [7] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG TONE-D
 	{0x1E137, 0x1E13D, prAL, gcLm},   //     [7] NYIAKENG PUACHUE HMONG SIGN FOR PERSON..NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER
@@ -3245,6 +3282,10 @@ var lineBreakCodePoints = [][4]int{
 	{0x1E2EC, 0x1E2EF, prCM, gcMn},   //     [4] WANCHO TONE TUP..WANCHO TONE KOINI
 	{0x1E2F0, 0x1E2F9, prNU, gcNd},   //    [10] WANCHO DIGIT ZERO..WANCHO DIGIT NINE
 	{0x1E2FF, 0x1E2FF, prPR, gcSc},   //         WANCHO NGUN SIGN
+	{0x1E4D0, 0x1E4EA, prAL, gcLo},   //    [27] NAG MUNDARI LETTER O..NAG MUNDARI LETTER ELL
+	{0x1E4EB, 0x1E4EB, prAL, gcLm},   //         NAG MUNDARI SIGN OJOD
+	{0x1E4EC, 0x1E4EF, prCM, gcMn},   //     [4] NAG MUNDARI SIGN MUHOR..NAG MUNDARI SIGN SUTUH
+	{0x1E4F0, 0x1E4F9, prNU, gcNd},   //    [10] NAG MUNDARI DIGIT ZERO..NAG MUNDARI DIGIT NINE
 	{0x1E7E0, 0x1E7E6, prAL, gcLo},   //     [7] ETHIOPIC SYLLABLE HHYA..ETHIOPIC SYLLABLE HHYO
 	{0x1E7E8, 0x1E7EB, prAL, gcLo},   //     [4] ETHIOPIC SYLLABLE GURAGE HHWA..ETHIOPIC SYLLABLE HHWE
 	{0x1E7ED, 0x1E7EE, prAL, gcLo},   //     [2] ETHIOPIC SYLLABLE GURAGE MWI..ETHIOPIC SYLLABLE GURAGE MWEE
@@ -3412,16 +3453,18 @@ var lineBreakCodePoints = [][4]int{
 	{0x1F6C1, 0x1F6CB, prID, gcSo},   //    [11] BATHTUB..COUCH AND LAMP
 	{0x1F6CC, 0x1F6CC, prEB, gcSo},   //         SLEEPING ACCOMMODATION
 	{0x1F6CD, 0x1F6D7, prID, gcSo},   //    [11] SHOPPING BAGS..ELEVATOR
-	{0x1F6D8, 0x1F6DC, prID, gcCn},   //     [5] <reserved-1F6D8>..<reserved-1F6DC>
-	{0x1F6DD, 0x1F6EC, prID, gcSo},   //    [16] PLAYGROUND SLIDE..AIRPLANE ARRIVING
+	{0x1F6D8, 0x1F6DB, prID, gcCn},   //     [4] <reserved-1F6D8>..<reserved-1F6DB>
+	{0x1F6DC, 0x1F6EC, prID, gcSo},   //    [17] WIRELESS..AIRPLANE ARRIVING
 	{0x1F6ED, 0x1F6EF, prID, gcCn},   //     [3] <reserved-1F6ED>..<reserved-1F6EF>
 	{0x1F6F0, 0x1F6FC, prID, gcSo},   //    [13] SATELLITE..ROLLER SKATE
 	{0x1F6FD, 0x1F6FF, prID, gcCn},   //     [3] <reserved-1F6FD>..<reserved-1F6FF>
 	{0x1F700, 0x1F773, prAL, gcSo},   //   [116] ALCHEMICAL SYMBOL FOR QUINTESSENCE..ALCHEMICAL SYMBOL FOR HALF OUNCE
-	{0x1F774, 0x1F77F, prID, gcCn},   //    [12] <reserved-1F774>..<reserved-1F77F>
+	{0x1F774, 0x1F776, prID, gcSo},   //     [3] LOT OF FORTUNE..LUNAR ECLIPSE
+	{0x1F777, 0x1F77A, prID, gcCn},   //     [4] <reserved-1F777>..<reserved-1F77A>
+	{0x1F77B, 0x1F77F, prID, gcSo},   //     [5] HAUMEA..ORCUS
 	{0x1F780, 0x1F7D4, prAL, gcSo},   //    [85] BLACK LEFT-POINTING ISOSCELES RIGHT TRIANGLE..HEAVY TWELVE POINTED PINWHEEL STAR
-	{0x1F7D5, 0x1F7D8, prID, gcSo},   //     [4] CIRCLED TRIANGLE..NEGATIVE CIRCLED SQUARE
-	{0x1F7D9, 0x1F7DF, prID, gcCn},   //     [7] <reserved-1F7D9>..<reserved-1F7DF>
+	{0x1F7D5, 0x1F7D9, prID, gcSo},   //     [5] CIRCLED TRIANGLE..NINE POINTED WHITE STAR
+	{0x1F7DA, 0x1F7DF, prID, gcCn},   //     [6] <reserved-1F7DA>..<reserved-1F7DF>
 	{0x1F7E0, 0x1F7EB, prID, gcSo},   //    [12] LARGE ORANGE CIRCLE..LARGE BROWN SQUARE
 	{0x1F7EC, 0x1F7EF, prID, gcCn},   //     [4] <reserved-1F7EC>..<reserved-1F7EF>
 	{0x1F7F0, 0x1F7F0, prID, gcSo},   //         HEAVY EQUALS SIGN
@@ -3467,33 +3510,29 @@ var lineBreakCodePoints = [][4]int{
 	{0x1FA54, 0x1FA5F, prID, gcCn},   //    [12] <reserved-1FA54>..<reserved-1FA5F>
 	{0x1FA60, 0x1FA6D, prID, gcSo},   //    [14] XIANGQI RED GENERAL..XIANGQI BLACK SOLDIER
 	{0x1FA6E, 0x1FA6F, prID, gcCn},   //     [2] <reserved-1FA6E>..<reserved-1FA6F>
-	{0x1FA70, 0x1FA74, prID, gcSo},   //     [5] BALLET SHOES..THONG SANDAL
-	{0x1FA75, 0x1FA77, prID, gcCn},   //     [3] <reserved-1FA75>..<reserved-1FA77>
-	{0x1FA78, 0x1FA7C, prID, gcSo},   //     [5] DROP OF BLOOD..CRUTCH
+	{0x1FA70, 0x1FA7C, prID, gcSo},   //    [13] BALLET SHOES..CRUTCH
 	{0x1FA7D, 0x1FA7F, prID, gcCn},   //     [3] <reserved-1FA7D>..<reserved-1FA7F>
-	{0x1FA80, 0x1FA86, prID, gcSo},   //     [7] YO-YO..NESTING DOLLS
-	{0x1FA87, 0x1FA8F, prID, gcCn},   //     [9] <reserved-1FA87>..<reserved-1FA8F>
-	{0x1FA90, 0x1FAAC, prID, gcSo},   //    [29] RINGED PLANET..HAMSA
-	{0x1FAAD, 0x1FAAF, prID, gcCn},   //     [3] <reserved-1FAAD>..<reserved-1FAAF>
-	{0x1FAB0, 0x1FABA, prID, gcSo},   //    [11] FLY..NEST WITH EGGS
-	{0x1FABB, 0x1FABF, prID, gcCn},   //     [5] <reserved-1FABB>..<reserved-1FABF>
-	{0x1FAC0, 0x1FAC2, prID, gcSo},   //     [3] ANATOMICAL HEART..PEOPLE HUGGING
+	{0x1FA80, 0x1FA88, prID, gcSo},   //     [9] YO-YO..FLUTE
+	{0x1FA89, 0x1FA8F, prID, gcCn},   //     [7] <reserved-1FA89>..<reserved-1FA8F>
+	{0x1FA90, 0x1FABD, prID, gcSo},   //    [46] RINGED PLANET..WING
+	{0x1FABE, 0x1FABE, prID, gcCn},   //         <reserved-1FABE>
+	{0x1FABF, 0x1FAC2, prID, gcSo},   //     [4] GOOSE..PEOPLE HUGGING
 	{0x1FAC3, 0x1FAC5, prEB, gcSo},   //     [3] PREGNANT MAN..PERSON WITH CROWN
-	{0x1FAC6, 0x1FACF, prID, gcCn},   //    [10] <reserved-1FAC6>..<reserved-1FACF>
-	{0x1FAD0, 0x1FAD9, prID, gcSo},   //    [10] BLUEBERRIES..JAR
-	{0x1FADA, 0x1FADF, prID, gcCn},   //     [6] <reserved-1FADA>..<reserved-1FADF>
-	{0x1FAE0, 0x1FAE7, prID, gcSo},   //     [8] MELTING FACE..BUBBLES
-	{0x1FAE8, 0x1FAEF, prID, gcCn},   //     [8] <reserved-1FAE8>..<reserved-1FAEF>
-	{0x1FAF0, 0x1FAF6, prEB, gcSo},   //     [7] HAND WITH INDEX FINGER AND THUMB CROSSED..HEART HANDS
-	{0x1FAF7, 0x1FAFF, prID, gcCn},   //     [9] <reserved-1FAF7>..<reserved-1FAFF>
+	{0x1FAC6, 0x1FACD, prID, gcCn},   //     [8] <reserved-1FAC6>..<reserved-1FACD>
+	{0x1FACE, 0x1FADB, prID, gcSo},   //    [14] MOOSE..PEA POD
+	{0x1FADC, 0x1FADF, prID, gcCn},   //     [4] <reserved-1FADC>..<reserved-1FADF>
+	{0x1FAE0, 0x1FAE8, prID, gcSo},   //     [9] MELTING FACE..SHAKING FACE
+	{0x1FAE9, 0x1FAEF, prID, gcCn},   //     [7] <reserved-1FAE9>..<reserved-1FAEF>
+	{0x1FAF0, 0x1FAF8, prEB, gcSo},   //     [9] HAND WITH INDEX FINGER AND THUMB CROSSED..RIGHTWARDS PUSHING HAND
+	{0x1FAF9, 0x1FAFF, prID, gcCn},   //     [7] <reserved-1FAF9>..<reserved-1FAFF>
 	{0x1FB00, 0x1FB92, prAL, gcSo},   //   [147] BLOCK SEXTANT-1..UPPER HALF INVERSE MEDIUM SHADE AND LOWER HALF BLOCK
 	{0x1FB94, 0x1FBCA, prAL, gcSo},   //    [55] LEFT HALF INVERSE MEDIUM SHADE AND RIGHT HALF BLOCK..WHITE UP-POINTING CHEVRON
 	{0x1FBF0, 0x1FBF9, prNU, gcNd},   //    [10] SEGMENTED DIGIT ZERO..SEGMENTED DIGIT NINE
 	{0x1FC00, 0x1FFFD, prID, gcCn},   //  [1022] <reserved-1FC00>..<reserved-1FFFD>
 	{0x20000, 0x2A6DF, prID, gcLo},   // [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF
 	{0x2A6E0, 0x2A6FF, prID, gcCn},   //    [32] <reserved-2A6E0>..<reserved-2A6FF>
-	{0x2A700, 0x2B738, prID, gcLo},   //  [4153] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B738
-	{0x2B739, 0x2B73F, prID, gcCn},   //     [7] <reserved-2B739>..<reserved-2B73F>
+	{0x2A700, 0x2B739, prID, gcLo},   //  [4154] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B739
+	{0x2B73A, 0x2B73F, prID, gcCn},   //     [6] <reserved-2B73A>..<reserved-2B73F>
 	{0x2B740, 0x2B81D, prID, gcLo},   //   [222] CJK UNIFIED IDEOGRAPH-2B740..CJK UNIFIED IDEOGRAPH-2B81D
 	{0x2B81E, 0x2B81F, prID, gcCn},   //     [2] <reserved-2B81E>..<reserved-2B81F>
 	{0x2B820, 0x2CEA1, prID, gcLo},   //  [5762] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEA1
@@ -3504,7 +3543,9 @@ var lineBreakCodePoints = [][4]int{
 	{0x2FA1E, 0x2FA1F, prID, gcCn},   //     [2] <reserved-2FA1E>..<reserved-2FA1F>
 	{0x2FA20, 0x2FFFD, prID, gcCn},   //  [1502] <reserved-2FA20>..<reserved-2FFFD>
 	{0x30000, 0x3134A, prID, gcLo},   //  [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A
-	{0x3134B, 0x3FFFD, prID, gcCn},   // [60595] <reserved-3134B>..<reserved-3FFFD>
+	{0x3134B, 0x3134F, prID, gcCn},   //     [5] <reserved-3134B>..<reserved-3134F>
+	{0x31350, 0x323AF, prID, gcLo},   //  [4192] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-323AF
+	{0x323B0, 0x3FFFD, prID, gcCn},   // [56398] <reserved-323B0>..<reserved-3FFFD>
 	{0xE0001, 0xE0001, prCM, gcCf},   //         LANGUAGE TAG
 	{0xE0020, 0xE007F, prCM, gcCf},   //    [96] TAG SPACE..CANCEL TAG
 	{0xE0100, 0xE01EF, prCM, gcMn},   //   [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256

vendor/github.com/rivo/uniseg/linerules.go

@@ -64,222 +64,381 @@ const (
 	LineMustBreak        // You must break the line here.
 )
 
-// The line break parser's state transitions. It's anologous to grTransitions,
-// see comments there for details. Unicode version 14.0.0.
-var lbTransitions = map[[2]int][3]int{
+// lbTransitions implements the line break parser's state transitions. It's
+// anologous to [grTransitions], see comments there for details.
+//
+// Unicode version 15.0.0.
+func lbTransitions(state, prop int) (newState, lineBreak, rule int) {
+	switch uint64(state) | uint64(prop)<<32 {
 	// LB4.
-	{lbAny, prBK}: {lbBK, LineCanBreak, 310},
-	{lbBK, prAny}: {lbAny, LineMustBreak, 40},
+	case lbBK | prAny<<32:
+		return lbAny, LineMustBreak, 40
 
 	// LB5.
-	{lbAny, prCR}: {lbCR, LineCanBreak, 310},
-	{lbAny, prLF}: {lbLF, LineCanBreak, 310},
-	{lbAny, prNL}: {lbNL, LineCanBreak, 310},
-	{lbCR, prLF}:  {lbLF, LineDontBreak, 50},
-	{lbCR, prAny}: {lbAny, LineMustBreak, 50},
-	{lbLF, prAny}: {lbAny, LineMustBreak, 50},
-	{lbNL, prAny}: {lbAny, LineMustBreak, 50},
+	case lbCR | prLF<<32:
+		return lbLF, LineDontBreak, 50
+	case lbCR | prAny<<32:
+		return lbAny, LineMustBreak, 50
+	case lbLF | prAny<<32:
+		return lbAny, LineMustBreak, 50
+	case lbNL | prAny<<32:
+		return lbAny, LineMustBreak, 50
 
 	// LB6.
-	{lbAny, prBK}: {lbBK, LineDontBreak, 60},
-	{lbAny, prCR}: {lbCR, LineDontBreak, 60},
-	{lbAny, prLF}: {lbLF, LineDontBreak, 60},
-	{lbAny, prNL}: {lbNL, LineDontBreak, 60},
+	case lbAny | prBK<<32:
+		return lbBK, LineDontBreak, 60
+	case lbAny | prCR<<32:
+		return lbCR, LineDontBreak, 60
+	case lbAny | prLF<<32:
+		return lbLF, LineDontBreak, 60
+	case lbAny | prNL<<32:
+		return lbNL, LineDontBreak, 60
 
 	// LB7.
-	{lbAny, prSP}: {lbSP, LineDontBreak, 70},
-	{lbAny, prZW}: {lbZW, LineDontBreak, 70},
+	case lbAny | prSP<<32:
+		return lbSP, LineDontBreak, 70
+	case lbAny | prZW<<32:
+		return lbZW, LineDontBreak, 70
 
 	// LB8.
-	{lbZW, prSP}:  {lbZW, LineDontBreak, 70},
-	{lbZW, prAny}: {lbAny, LineCanBreak, 80},
+	case lbZW | prSP<<32:
+		return lbZW, LineDontBreak, 70
+	case lbZW | prAny<<32:
+		return lbAny, LineCanBreak, 80
 
 	// LB11.
-	{lbAny, prWJ}: {lbWJ, LineDontBreak, 110},
-	{lbWJ, prAny}: {lbAny, LineDontBreak, 110},
+	case lbAny | prWJ<<32:
+		return lbWJ, LineDontBreak, 110
+	case lbWJ | prAny<<32:
+		return lbAny, LineDontBreak, 110
 
 	// LB12.
-	{lbAny, prGL}: {lbGL, LineCanBreak, 310},
-	{lbGL, prAny}: {lbAny, LineDontBreak, 120},
+	case lbAny | prGL<<32:
+		return lbGL, LineCanBreak, 310
+	case lbGL | prAny<<32:
+		return lbAny, LineDontBreak, 120
 
 	// LB13 (simple transitions).
-	{lbAny, prCL}: {lbCL, LineCanBreak, 310},
-	{lbAny, prCP}: {lbCP, LineCanBreak, 310},
-	{lbAny, prEX}: {lbEX, LineDontBreak, 130},
-	{lbAny, prIS}: {lbIS, LineCanBreak, 310},
-	{lbAny, prSY}: {lbSY, LineCanBreak, 310},
+	case lbAny | prCL<<32:
+		return lbCL, LineCanBreak, 310
+	case lbAny | prCP<<32:
+		return lbCP, LineCanBreak, 310
+	case lbAny | prEX<<32:
+		return lbEX, LineDontBreak, 130
+	case lbAny | prIS<<32:
+		return lbIS, LineCanBreak, 310
+	case lbAny | prSY<<32:
+		return lbSY, LineCanBreak, 310
 
 	// LB14.
-	{lbAny, prOP}: {lbOP, LineCanBreak, 310},
-	{lbOP, prSP}:  {lbOP, LineDontBreak, 70},
-	{lbOP, prAny}: {lbAny, LineDontBreak, 140},
+	case lbAny | prOP<<32:
+		return lbOP, LineCanBreak, 310
+	case lbOP | prSP<<32:
+		return lbOP, LineDontBreak, 70
+	case lbOP | prAny<<32:
+		return lbAny, LineDontBreak, 140
 
 	// LB15.
-	{lbQU, prSP}:   {lbQUSP, LineDontBreak, 70},
-	{lbQU, prOP}:   {lbOP, LineDontBreak, 150},
-	{lbQUSP, prOP}: {lbOP, LineDontBreak, 150},
+	case lbQU | prSP<<32:
+		return lbQUSP, LineDontBreak, 70
+	case lbQU | prOP<<32:
+		return lbOP, LineDontBreak, 150
+	case lbQUSP | prOP<<32:
+		return lbOP, LineDontBreak, 150
 
 	// LB16.
-	{lbCL, prSP}:     {lbCLCPSP, LineDontBreak, 70},
-	{lbNUCL, prSP}:   {lbCLCPSP, LineDontBreak, 70},
-	{lbCP, prSP}:     {lbCLCPSP, LineDontBreak, 70},
-	{lbNUCP, prSP}:   {lbCLCPSP, LineDontBreak, 70},
-	{lbCL, prNS}:     {lbNS, LineDontBreak, 160},
-	{lbNUCL, prNS}:   {lbNS, LineDontBreak, 160},
-	{lbCP, prNS}:     {lbNS, LineDontBreak, 160},
-	{lbNUCP, prNS}:   {lbNS, LineDontBreak, 160},
-	{lbCLCPSP, prNS}: {lbNS, LineDontBreak, 160},
+	case lbCL | prSP<<32:
+		return lbCLCPSP, LineDontBreak, 70
+	case lbNUCL | prSP<<32:
+		return lbCLCPSP, LineDontBreak, 70
+	case lbCP | prSP<<32:
+		return lbCLCPSP, LineDontBreak, 70
+	case lbNUCP | prSP<<32:
+		return lbCLCPSP, LineDontBreak, 70
+	case lbCL | prNS<<32:
+		return lbNS, LineDontBreak, 160
+	case lbNUCL | prNS<<32:
+		return lbNS, LineDontBreak, 160
+	case lbCP | prNS<<32:
+		return lbNS, LineDontBreak, 160
+	case lbNUCP | prNS<<32:
+		return lbNS, LineDontBreak, 160
+	case lbCLCPSP | prNS<<32:
+		return lbNS, LineDontBreak, 160
 
 	// LB17.
-	{lbAny, prB2}:  {lbB2, LineCanBreak, 310},
-	{lbB2, prSP}:   {lbB2SP, LineDontBreak, 70},
-	{lbB2, prB2}:   {lbB2, LineDontBreak, 170},
-	{lbB2SP, prB2}: {lbB2, LineDontBreak, 170},
+	case lbAny | prB2<<32:
+		return lbB2, LineCanBreak, 310
+	case lbB2 | prSP<<32:
+		return lbB2SP, LineDontBreak, 70
+	case lbB2 | prB2<<32:
+		return lbB2, LineDontBreak, 170
+	case lbB2SP | prB2<<32:
+		return lbB2, LineDontBreak, 170
 
 	// LB18.
-	{lbSP, prAny}:     {lbAny, LineCanBreak, 180},
-	{lbQUSP, prAny}:   {lbAny, LineCanBreak, 180},
-	{lbCLCPSP, prAny}: {lbAny, LineCanBreak, 180},
-	{lbB2SP, prAny}:   {lbAny, LineCanBreak, 180},
+	case lbSP | prAny<<32:
+		return lbAny, LineCanBreak, 180
+	case lbQUSP | prAny<<32:
+		return lbAny, LineCanBreak, 180
+	case lbCLCPSP | prAny<<32:
+		return lbAny, LineCanBreak, 180
+	case lbB2SP | prAny<<32:
+		return lbAny, LineCanBreak, 180
 
 	// LB19.
-	{lbAny, prQU}: {lbQU, LineDontBreak, 190},
-	{lbQU, prAny}: {lbAny, LineDontBreak, 190},
+	case lbAny | prQU<<32:
+		return lbQU, LineDontBreak, 190
+	case lbQU | prAny<<32:
+		return lbAny, LineDontBreak, 190
 
 	// LB20.
-	{lbAny, prCB}: {lbCB, LineCanBreak, 200},
-	{lbCB, prAny}: {lbAny, LineCanBreak, 200},
+	case lbAny | prCB<<32:
+		return lbCB, LineCanBreak, 200
+	case lbCB | prAny<<32:
+		return lbAny, LineCanBreak, 200
 
 	// LB21.
-	{lbAny, prBA}: {lbBA, LineDontBreak, 210},
-	{lbAny, prHY}: {lbHY, LineDontBreak, 210},
-	{lbAny, prNS}: {lbNS, LineDontBreak, 210},
-	{lbAny, prBB}: {lbBB, LineCanBreak, 310},
-	{lbBB, prAny}: {lbAny, LineDontBreak, 210},
+	case lbAny | prBA<<32:
+		return lbBA, LineDontBreak, 210
+	case lbAny | prHY<<32:
+		return lbHY, LineDontBreak, 210
+	case lbAny | prNS<<32:
+		return lbNS, LineDontBreak, 210
+	case lbAny | prBB<<32:
+		return lbBB, LineCanBreak, 310
+	case lbBB | prAny<<32:
+		return lbAny, LineDontBreak, 210
 
 	// LB21a.
-	{lbAny, prHL}:    {lbHL, LineCanBreak, 310},
-	{lbHL, prHY}:     {lbLB21a, LineDontBreak, 210},
-	{lbHL, prBA}:     {lbLB21a, LineDontBreak, 210},
-	{lbLB21a, prAny}: {lbAny, LineDontBreak, 211},
+	case lbAny | prHL<<32:
+		return lbHL, LineCanBreak, 310
+	case lbHL | prHY<<32:
+		return lbLB21a, LineDontBreak, 210
+	case lbHL | prBA<<32:
+		return lbLB21a, LineDontBreak, 210
+	case lbLB21a | prAny<<32:
+		return lbAny, LineDontBreak, 211
 
 	// LB21b.
-	{lbSY, prHL}:   {lbHL, LineDontBreak, 212},
-	{lbNUSY, prHL}: {lbHL, LineDontBreak, 212},
+	case lbSY | prHL<<32:
+		return lbHL, LineDontBreak, 212
+	case lbNUSY | prHL<<32:
+		return lbHL, LineDontBreak, 212
 
 	// LB22.
-	{lbAny, prIN}: {lbAny, LineDontBreak, 220},
+	case lbAny | prIN<<32:
+		return lbAny, LineDontBreak, 220
 
 	// LB23.
-	{lbAny, prAL}:  {lbAL, LineCanBreak, 310},
-	{lbAny, prNU}:  {lbNU, LineCanBreak, 310},
-	{lbAL, prNU}:   {lbNU, LineDontBreak, 230},
-	{lbHL, prNU}:   {lbNU, LineDontBreak, 230},
-	{lbNU, prAL}:   {lbAL, LineDontBreak, 230},
-	{lbNU, prHL}:   {lbHL, LineDontBreak, 230},
-	{lbNUNU, prAL}: {lbAL, LineDontBreak, 230},
-	{lbNUNU, prHL}: {lbHL, LineDontBreak, 230},
+	case lbAny | prAL<<32:
+		return lbAL, LineCanBreak, 310
+	case lbAny | prNU<<32:
+		return lbNU, LineCanBreak, 310
+	case lbAL | prNU<<32:
+		return lbNU, LineDontBreak, 230
+	case lbHL | prNU<<32:
+		return lbNU, LineDontBreak, 230
+	case lbNU | prAL<<32:
+		return lbAL, LineDontBreak, 230
+	case lbNU | prHL<<32:
+		return lbHL, LineDontBreak, 230
+	case lbNUNU | prAL<<32:
+		return lbAL, LineDontBreak, 230
+	case lbNUNU | prHL<<32:
+		return lbHL, LineDontBreak, 230
 
 	// LB23a.
-	{lbAny, prPR}:  {lbPR, LineCanBreak, 310},
-	{lbAny, prID}:  {lbIDEM, LineCanBreak, 310},
-	{lbAny, prEB}:  {lbEB, LineCanBreak, 310},
-	{lbAny, prEM}:  {lbIDEM, LineCanBreak, 310},
-	{lbPR, prID}:   {lbIDEM, LineDontBreak, 231},
-	{lbPR, prEB}:   {lbEB, LineDontBreak, 231},
-	{lbPR, prEM}:   {lbIDEM, LineDontBreak, 231},
-	{lbIDEM, prPO}: {lbPO, LineDontBreak, 231},
-	{lbEB, prPO}:   {lbPO, LineDontBreak, 231},
+	case lbAny | prPR<<32:
+		return lbPR, LineCanBreak, 310
+	case lbAny | prID<<32:
+		return lbIDEM, LineCanBreak, 310
+	case lbAny | prEB<<32:
+		return lbEB, LineCanBreak, 310
+	case lbAny | prEM<<32:
+		return lbIDEM, LineCanBreak, 310
+	case lbPR | prID<<32:
+		return lbIDEM, LineDontBreak, 231
+	case lbPR | prEB<<32:
+		return lbEB, LineDontBreak, 231
+	case lbPR | prEM<<32:
+		return lbIDEM, LineDontBreak, 231
+	case lbIDEM | prPO<<32:
+		return lbPO, LineDontBreak, 231
+	case lbEB | prPO<<32:
+		return lbPO, LineDontBreak, 231
 
 	// LB24.
-	{lbAny, prPO}: {lbPO, LineCanBreak, 310},
-	{lbPR, prAL}:  {lbAL, LineDontBreak, 240},
-	{lbPR, prHL}:  {lbHL, LineDontBreak, 240},
-	{lbPO, prAL}:  {lbAL, LineDontBreak, 240},
-	{lbPO, prHL}:  {lbHL, LineDontBreak, 240},
-	{lbAL, prPR}:  {lbPR, LineDontBreak, 240},
-	{lbAL, prPO}:  {lbPO, LineDontBreak, 240},
-	{lbHL, prPR}:  {lbPR, LineDontBreak, 240},
-	{lbHL, prPO}:  {lbPO, LineDontBreak, 240},
+	case lbAny | prPO<<32:
+		return lbPO, LineCanBreak, 310
+	case lbPR | prAL<<32:
+		return lbAL, LineDontBreak, 240
+	case lbPR | prHL<<32:
+		return lbHL, LineDontBreak, 240
+	case lbPO | prAL<<32:
+		return lbAL, LineDontBreak, 240
+	case lbPO | prHL<<32:
+		return lbHL, LineDontBreak, 240
+	case lbAL | prPR<<32:
+		return lbPR, LineDontBreak, 240
+	case lbAL | prPO<<32:
+		return lbPO, LineDontBreak, 240
+	case lbHL | prPR<<32:
+		return lbPR, LineDontBreak, 240
+	case lbHL | prPO<<32:
+		return lbPO, LineDontBreak, 240
 
 	// LB25 (simple transitions).
-	{lbPR, prNU}:   {lbNU, LineDontBreak, 250},
-	{lbPO, prNU}:   {lbNU, LineDontBreak, 250},
-	{lbOP, prNU}:   {lbNU, LineDontBreak, 250},
-	{lbHY, prNU}:   {lbNU, LineDontBreak, 250},
-	{lbNU, prNU}:   {lbNUNU, LineDontBreak, 250},
-	{lbNU, prSY}:   {lbNUSY, LineDontBreak, 250},
-	{lbNU, prIS}:   {lbNUIS, LineDontBreak, 250},
-	{lbNUNU, prNU}: {lbNUNU, LineDontBreak, 250},
-	{lbNUNU, prSY}: {lbNUSY, LineDontBreak, 250},
-	{lbNUNU, prIS}: {lbNUIS, LineDontBreak, 250},
-	{lbNUSY, prNU}: {lbNUNU, LineDontBreak, 250},
-	{lbNUSY, prSY}: {lbNUSY, LineDontBreak, 250},
-	{lbNUSY, prIS}: {lbNUIS, LineDontBreak, 250},
-	{lbNUIS, prNU}: {lbNUNU, LineDontBreak, 250},
-	{lbNUIS, prSY}: {lbNUSY, LineDontBreak, 250},
-	{lbNUIS, prIS}: {lbNUIS, LineDontBreak, 250},
-	{lbNU, prCL}:   {lbNUCL, LineDontBreak, 250},
-	{lbNU, prCP}:   {lbNUCP, LineDontBreak, 250},
-	{lbNUNU, prCL}: {lbNUCL, LineDontBreak, 250},
-	{lbNUNU, prCP}: {lbNUCP, LineDontBreak, 250},
-	{lbNUSY, prCL}: {lbNUCL, LineDontBreak, 250},
-	{lbNUSY, prCP}: {lbNUCP, LineDontBreak, 250},
-	{lbNUIS, prCL}: {lbNUCL, LineDontBreak, 250},
-	{lbNUIS, prCP}: {lbNUCP, LineDontBreak, 250},
-	{lbNU, prPO}:   {lbPO, LineDontBreak, 250},
-	{lbNUNU, prPO}: {lbPO, LineDontBreak, 250},
-	{lbNUSY, prPO}: {lbPO, LineDontBreak, 250},
-	{lbNUIS, prPO}: {lbPO, LineDontBreak, 250},
-	{lbNUCL, prPO}: {lbPO, LineDontBreak, 250},
-	{lbNUCP, prPO}: {lbPO, LineDontBreak, 250},
-	{lbNU, prPR}:   {lbPR, LineDontBreak, 250},
-	{lbNUNU, prPR}: {lbPR, LineDontBreak, 250},
-	{lbNUSY, prPR}: {lbPR, LineDontBreak, 250},
-	{lbNUIS, prPR}: {lbPR, LineDontBreak, 250},
-	{lbNUCL, prPR}: {lbPR, LineDontBreak, 250},
-	{lbNUCP, prPR}: {lbPR, LineDontBreak, 250},
+	case lbPR | prNU<<32:
+		return lbNU, LineDontBreak, 250
+	case lbPO | prNU<<32:
+		return lbNU, LineDontBreak, 250
+	case lbOP | prNU<<32:
+		return lbNU, LineDontBreak, 250
+	case lbHY | prNU<<32:
+		return lbNU, LineDontBreak, 250
+	case lbNU | prNU<<32:
+		return lbNUNU, LineDontBreak, 250
+	case lbNU | prSY<<32:
+		return lbNUSY, LineDontBreak, 250
+	case lbNU | prIS<<32:
+		return lbNUIS, LineDontBreak, 250
+	case lbNUNU | prNU<<32:
+		return lbNUNU, LineDontBreak, 250
+	case lbNUNU | prSY<<32:
+		return lbNUSY, LineDontBreak, 250
+	case lbNUNU | prIS<<32:
+		return lbNUIS, LineDontBreak, 250
+	case lbNUSY | prNU<<32:
+		return lbNUNU, LineDontBreak, 250
+	case lbNUSY | prSY<<32:
+		return lbNUSY, LineDontBreak, 250
+	case lbNUSY | prIS<<32:
+		return lbNUIS, LineDontBreak, 250
+	case lbNUIS | prNU<<32:
+		return lbNUNU, LineDontBreak, 250
+	case lbNUIS | prSY<<32:
+		return lbNUSY, LineDontBreak, 250
+	case lbNUIS | prIS<<32:
+		return lbNUIS, LineDontBreak, 250
+	case lbNU | prCL<<32:
+		return lbNUCL, LineDontBreak, 250
+	case lbNU | prCP<<32:
+		return lbNUCP, LineDontBreak, 250
+	case lbNUNU | prCL<<32:
+		return lbNUCL, LineDontBreak, 250
+	case lbNUNU | prCP<<32:
+		return lbNUCP, LineDontBreak, 250
+	case lbNUSY | prCL<<32:
+		return lbNUCL, LineDontBreak, 250
+	case lbNUSY | prCP<<32:
+		return lbNUCP, LineDontBreak, 250
+	case lbNUIS | prCL<<32:
+		return lbNUCL, LineDontBreak, 250
+	case lbNUIS | prCP<<32:
+		return lbNUCP, LineDontBreak, 250
+	case lbNU | prPO<<32:
+		return lbPO, LineDontBreak, 250
+	case lbNUNU | prPO<<32:
+		return lbPO, LineDontBreak, 250
+	case lbNUSY | prPO<<32:
+		return lbPO, LineDontBreak, 250
+	case lbNUIS | prPO<<32:
+		return lbPO, LineDontBreak, 250
+	case lbNUCL | prPO<<32:
+		return lbPO, LineDontBreak, 250
+	case lbNUCP | prPO<<32:
+		return lbPO, LineDontBreak, 250
+	case lbNU | prPR<<32:
+		return lbPR, LineDontBreak, 250
+	case lbNUNU | prPR<<32:
+		return lbPR, LineDontBreak, 250
+	case lbNUSY | prPR<<32:
+		return lbPR, LineDontBreak, 250
+	case lbNUIS | prPR<<32:
+		return lbPR, LineDontBreak, 250
+	case lbNUCL | prPR<<32:
+		return lbPR, LineDontBreak, 250
+	case lbNUCP | prPR<<32:
+		return lbPR, LineDontBreak, 250
 
 	// LB26.
-	{lbAny, prJL}: {lbJL, LineCanBreak, 310},
-	{lbAny, prJV}: {lbJV, LineCanBreak, 310},
-	{lbAny, prJT}: {lbJT, LineCanBreak, 310},
-	{lbAny, prH2}: {lbH2, LineCanBreak, 310},
-	{lbAny, prH3}: {lbH3, LineCanBreak, 310},
-	{lbJL, prJL}:  {lbJL, LineDontBreak, 260},
-	{lbJL, prJV}:  {lbJV, LineDontBreak, 260},
-	{lbJL, prH2}:  {lbH2, LineDontBreak, 260},
-	{lbJL, prH3}:  {lbH3, LineDontBreak, 260},
-	{lbJV, prJV}:  {lbJV, LineDontBreak, 260},
-	{lbJV, prJT}:  {lbJT, LineDontBreak, 260},
-	{lbH2, prJV}:  {lbJV, LineDontBreak, 260},
-	{lbH2, prJT}:  {lbJT, LineDontBreak, 260},
-	{lbJT, prJT}:  {lbJT, LineDontBreak, 260},
-	{lbH3, prJT}:  {lbJT, LineDontBreak, 260},
+	case lbAny | prJL<<32:
+		return lbJL, LineCanBreak, 310
+	case lbAny | prJV<<32:
+		return lbJV, LineCanBreak, 310
+	case lbAny | prJT<<32:
+		return lbJT, LineCanBreak, 310
+	case lbAny | prH2<<32:
+		return lbH2, LineCanBreak, 310
+	case lbAny | prH3<<32:
+		return lbH3, LineCanBreak, 310
+	case lbJL | prJL<<32:
+		return lbJL, LineDontBreak, 260
+	case lbJL | prJV<<32:
+		return lbJV, LineDontBreak, 260
+	case lbJL | prH2<<32:
+		return lbH2, LineDontBreak, 260
+	case lbJL | prH3<<32:
+		return lbH3, LineDontBreak, 260
+	case lbJV | prJV<<32:
+		return lbJV, LineDontBreak, 260
+	case lbJV | prJT<<32:
+		return lbJT, LineDontBreak, 260
+	case lbH2 | prJV<<32:
+		return lbJV, LineDontBreak, 260
+	case lbH2 | prJT<<32:
+		return lbJT, LineDontBreak, 260
+	case lbJT | prJT<<32:
+		return lbJT, LineDontBreak, 260
+	case lbH3 | prJT<<32:
+		return lbJT, LineDontBreak, 260
 
 	// LB27.
-	{lbJL, prPO}: {lbPO, LineDontBreak, 270},
-	{lbJV, prPO}: {lbPO, LineDontBreak, 270},
-	{lbJT, prPO}: {lbPO, LineDontBreak, 270},
-	{lbH2, prPO}: {lbPO, LineDontBreak, 270},
-	{lbH3, prPO}: {lbPO, LineDontBreak, 270},
-	{lbPR, prJL}: {lbJL, LineDontBreak, 270},
-	{lbPR, prJV}: {lbJV, LineDontBreak, 270},
-	{lbPR, prJT}: {lbJT, LineDontBreak, 270},
-	{lbPR, prH2}: {lbH2, LineDontBreak, 270},
-	{lbPR, prH3}: {lbH3, LineDontBreak, 270},
+	case lbJL | prPO<<32:
+		return lbPO, LineDontBreak, 270
+	case lbJV | prPO<<32:
+		return lbPO, LineDontBreak, 270
+	case lbJT | prPO<<32:
+		return lbPO, LineDontBreak, 270
+	case lbH2 | prPO<<32:
+		return lbPO, LineDontBreak, 270
+	case lbH3 | prPO<<32:
+		return lbPO, LineDontBreak, 270
+	case lbPR | prJL<<32:
+		return lbJL, LineDontBreak, 270
+	case lbPR | prJV<<32:
+		return lbJV, LineDontBreak, 270
+	case lbPR | prJT<<32:
+		return lbJT, LineDontBreak, 270
+	case lbPR | prH2<<32:
+		return lbH2, LineDontBreak, 270
+	case lbPR | prH3<<32:
+		return lbH3, LineDontBreak, 270
 
 	// LB28.
-	{lbAL, prAL}: {lbAL, LineDontBreak, 280},
-	{lbAL, prHL}: {lbHL, LineDontBreak, 280},
-	{lbHL, prAL}: {lbAL, LineDontBreak, 280},
-	{lbHL, prHL}: {lbHL, LineDontBreak, 280},
+	case lbAL | prAL<<32:
+		return lbAL, LineDontBreak, 280
+	case lbAL | prHL<<32:
+		return lbHL, LineDontBreak, 280
+	case lbHL | prAL<<32:
+		return lbAL, LineDontBreak, 280
+	case lbHL | prHL<<32:
+		return lbHL, LineDontBreak, 280
 
 	// LB29.
-	{lbIS, prAL}:   {lbAL, LineDontBreak, 290},
-	{lbIS, prHL}:   {lbHL, LineDontBreak, 290},
-	{lbNUIS, prAL}: {lbAL, LineDontBreak, 290},
-	{lbNUIS, prHL}: {lbHL, LineDontBreak, 290},
+	case lbIS | prAL<<32:
+		return lbAL, LineDontBreak, 290
+	case lbIS | prHL<<32:
+		return lbHL, LineDontBreak, 290
+	case lbNUIS | prAL<<32:
+		return lbAL, LineDontBreak, 290
+	case lbNUIS | prHL<<32:
+		return lbHL, LineDontBreak, 290
+
+	default:
+		return -1, -1, -1
+	}
 }
 
 // transitionLineBreakState determines the new state of the line break parser
@@ -290,7 +449,7 @@ var lbTransitions = map[[2]int][3]int{
 // further lookups.
 func transitionLineBreakState(state int, r rune, b []byte, str string) (newState int, lineBreak int) {
 	// Determine the property of the next character.
-	nextProperty, generalCategory := propertyWithGenCat(lineBreakCodePoints, r)
+	nextProperty, generalCategory := propertyLineBreak(r)
 
 	// Prepare.
 	var forceNoBreak, isCPeaFWH bool
@@ -306,7 +465,7 @@ func transitionLineBreakState(state int, r rune, b []byte, str string) (newState
 	defer func() {
 		// Transition into LB30.
 		if newState == lbCP || newState == lbNUCP {
-			ea := property(eastAsianWidth, r)
+			ea := propertyEastAsianWidth(r)
 			if ea != prF && ea != prW && ea != prH {
 				newState |= lbCPeaFWHBit
 			}
@@ -352,30 +511,27 @@ func transitionLineBreakState(state int, r rune, b []byte, str string) (newState
 
 	// Find the applicable transition in the table.
 	var rule int
-	transition, ok := lbTransitions[[2]int{state, nextProperty}]
-	if ok {
-		// We have a specific transition. We'll use it.
-		newState, lineBreak, rule = transition[0], transition[1], transition[2]
-	} else {
+	newState, lineBreak, rule = lbTransitions(state, nextProperty)
+	if newState < 0 {
 		// No specific transition found. Try the less specific ones.
-		transAnyProp, okAnyProp := lbTransitions[[2]int{state, prAny}]
-		transAnyState, okAnyState := lbTransitions[[2]int{lbAny, nextProperty}]
-		if okAnyProp && okAnyState {
+		anyPropProp, anyPropLineBreak, anyPropRule := lbTransitions(state, prAny)
+		anyStateProp, anyStateLineBreak, anyStateRule := lbTransitions(lbAny, nextProperty)
+		if anyPropProp >= 0 && anyStateProp >= 0 {
 			// Both apply. We'll use a mix (see comments for grTransitions).
-			newState, lineBreak, rule = transAnyState[0], transAnyState[1], transAnyState[2]
-			if transAnyProp[2] < transAnyState[2] {
-				lineBreak, rule = transAnyProp[1], transAnyProp[2]
+			newState, lineBreak, rule = anyStateProp, anyStateLineBreak, anyStateRule
+			if anyPropRule < anyStateRule {
+				lineBreak, rule = anyPropLineBreak, anyPropRule
 			}
-		} else if okAnyProp {
+		} else if anyPropProp >= 0 {
 			// We only have a specific state.
-			newState, lineBreak, rule = transAnyProp[0], transAnyProp[1], transAnyProp[2]
+			newState, lineBreak, rule = anyPropProp, anyPropLineBreak, anyPropRule
 			// This branch will probably never be reached because okAnyState will
 			// always be true given the current transition map. But we keep it here
 			// for future modifications to the transition map where this may not be
 			// true anymore.
-		} else if okAnyState {
+		} else if anyStateProp >= 0 {
 			// We only have a specific property.
-			newState, lineBreak, rule = transAnyState[0], transAnyState[1], transAnyState[2]
+			newState, lineBreak, rule = anyStateProp, anyStateLineBreak, anyStateRule
 		} else {
 			// No known transition. LB31: ALL ÷ ALL.
 			newState, lineBreak, rule = lbAny, LineCanBreak, 310
@@ -414,7 +570,7 @@ func transitionLineBreakState(state int, r rune, b []byte, str string) (newState
 			r, _ = utf8.DecodeRuneInString(str)
 		}
 		if r != utf8.RuneError {
-			pr, _ := propertyWithGenCat(lineBreakCodePoints, r)
+			pr, _ := propertyLineBreak(r)
 			if pr == prNU {
 				return lbNU, LineDontBreak
 			}
@@ -424,7 +580,7 @@ func transitionLineBreakState(state int, r rune, b []byte, str string) (newState
 	// LB30 (part one).
 	if rule > 300 {
 		if (state == lbAL || state == lbHL || state == lbNU || state == lbNUNU) && nextProperty == prOP {
-			ea := property(eastAsianWidth, r)
+			ea := propertyEastAsianWidth(r)
 			if ea != prF && ea != prW && ea != prH {
 				return lbOP, LineDontBreak
 			}
@@ -460,7 +616,7 @@ func transitionLineBreakState(state int, r rune, b []byte, str string) (newState
 				return prAny, LineDontBreak
 			}
 		}
-		graphemeProperty := property(graphemeCodePoints, r)
+		graphemeProperty := propertyGraphemes(r)
 		if graphemeProperty == prExtendedPictographic && generalCategory == gcCn {
 			return lbExtPicCn, LineCanBreak
 		}

vendor/github.com/rivo/uniseg/properties.go

@@ -160,9 +160,49 @@ func property(dictionary [][3]int, r rune) int {
 	return propertySearch(dictionary, r)[2]
 }
 
-// propertyWithGenCat returns the Unicode property value and General Category
-// (see constants above) of the given code point.
-func propertyWithGenCat(dictionary [][4]int, r rune) (property, generalCategory int) {
-	entry := propertySearch(dictionary, r)
+// propertyLineBreak returns the Unicode property value and General Category
+// (see constants above) of the given code point, as listed in the line break
+// code points table, while fast tracking ASCII digits and letters.
+func propertyLineBreak(r rune) (property, generalCategory int) {
+	if r >= 'a' && r <= 'z' {
+		return prAL, gcLl
+	}
+	if r >= 'A' && r <= 'Z' {
+		return prAL, gcLu
+	}
+	if r >= '0' && r <= '9' {
+		return prNU, gcNd
+	}
+	entry := propertySearch(lineBreakCodePoints, r)
 	return entry[2], entry[3]
 }
+
+// propertyGraphemes returns the Unicode grapheme cluster property value of the
+// given code point while fast tracking ASCII characters.
+func propertyGraphemes(r rune) int {
+	if r >= 0x20 && r <= 0x7e {
+		return prAny
+	}
+	if r == 0x0a {
+		return prLF
+	}
+	if r == 0x0d {
+		return prCR
+	}
+	if r >= 0 && r <= 0x1f || r == 0x7f {
+		return prControl
+	}
+	return property(graphemeCodePoints, r)
+}
+
+// propertyEastAsianWidth returns the Unicode East Asian Width property value of
+// the given code point while fast tracking ASCII characters.
+func propertyEastAsianWidth(r rune) int {
+	if r >= 0x20 && r <= 0x7e {
+		return prNa
+	}
+	if r >= 0 && r <= 0x1f || r == 0x7f {
+		return prN
+	}
+	return property(eastAsianWidth, r)
+}

vendor/github.com/rivo/uniseg/sentenceproperties.go

@@ -1,13 +1,13 @@
-package uniseg
-
 // Code generated via go generate from gen_properties.go. DO NOT EDIT.
 
+package uniseg
+
 // sentenceBreakCodePoints are taken from
-// https://www.unicode.org/Public/14.0.0/ucd/auxiliary/SentenceBreakProperty.txt
+// https://www.unicode.org/Public/15.0.0/ucd/auxiliary/SentenceBreakProperty.txt
 // and
-// https://unicode.org/Public/14.0.0/ucd/emoji/emoji-data.txt
+// https://unicode.org/Public/15.0.0/ucd/emoji/emoji-data.txt
 // ("Extended_Pictographic" only)
-// on September 10, 2022. See https://www.unicode.org/license.html for the Unicode
+// on September 5, 2023. See https://www.unicode.org/license.html for the Unicode
 // license agreement.
 var sentenceBreakCodePoints = [][3]int{
 	{0x0009, 0x0009, prSp},        // Cc       <control-0009>
@@ -843,6 +843,7 @@ var sentenceBreakCodePoints = [][3]int{
 	{0x0CE2, 0x0CE3, prExtend},    // Mn   [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL
 	{0x0CE6, 0x0CEF, prNumeric},   // Nd  [10] KANNADA DIGIT ZERO..KANNADA DIGIT NINE
 	{0x0CF1, 0x0CF2, prOLetter},   // Lo   [2] KANNADA SIGN JIHVAMULIYA..KANNADA SIGN UPADHMANIYA
+	{0x0CF3, 0x0CF3, prExtend},    // Mc       KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT
 	{0x0D00, 0x0D01, prExtend},    // Mn   [2] MALAYALAM SIGN COMBINING ANUSVARA ABOVE..MALAYALAM SIGN CANDRABINDU
 	{0x0D02, 0x0D03, prExtend},    // Mc   [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA
 	{0x0D04, 0x0D0C, prOLetter},   // Lo   [9] MALAYALAM LETTER VEDIC ANUSVARA..MALAYALAM LETTER VOCALIC L
@@ -896,7 +897,7 @@ var sentenceBreakCodePoints = [][3]int{
 	{0x0EBD, 0x0EBD, prOLetter},   // Lo       LAO SEMIVOWEL SIGN NYO
 	{0x0EC0, 0x0EC4, prOLetter},   // Lo   [5] LAO VOWEL SIGN E..LAO VOWEL SIGN AI
 	{0x0EC6, 0x0EC6, prOLetter},   // Lm       LAO KO LA
-	{0x0EC8, 0x0ECD, prExtend},    // Mn   [6] LAO TONE MAI EK..LAO NIGGAHITA
+	{0x0EC8, 0x0ECE, prExtend},    // Mn   [7] LAO TONE MAI EK..LAO YAMAKKAN
 	{0x0ED0, 0x0ED9, prNumeric},   // Nd  [10] LAO DIGIT ZERO..LAO DIGIT NINE
 	{0x0EDC, 0x0EDF, prOLetter},   // Lo   [4] LAO HO NO..LAO LETTER KHMU NYO
 	{0x0F00, 0x0F00, prOLetter},   // Lo       TIBETAN SYLLABLE OM
@@ -958,7 +959,7 @@ var sentenceBreakCodePoints = [][3]int{
 	{0x10C7, 0x10C7, prUpper},     // L&       GEORGIAN CAPITAL LETTER YN
 	{0x10CD, 0x10CD, prUpper},     // L&       GEORGIAN CAPITAL LETTER AEN
 	{0x10D0, 0x10FA, prOLetter},   // L&  [43] GEORGIAN LETTER AN..GEORGIAN LETTER AIN
-	{0x10FC, 0x10FC, prOLetter},   // Lm       MODIFIER LETTER GEORGIAN NAR
+	{0x10FC, 0x10FC, prLower},     // Lm       MODIFIER LETTER GEORGIAN NAR
 	{0x10FD, 0x10FF, prOLetter},   // L&   [3] GEORGIAN LETTER AEN..GEORGIAN LETTER LABIAL SIGN
 	{0x1100, 0x1248, prOLetter},   // Lo [329] HANGUL CHOSEONG KIYEOK..ETHIOPIC SYLLABLE QWA
 	{0x124A, 0x124D, prOLetter},   // Lo   [4] ETHIOPIC SYLLABLE QWI..ETHIOPIC SYLLABLE QWE
@@ -2034,7 +2035,7 @@ var sentenceBreakCodePoints = [][3]int{
 	{0xA7D7, 0xA7D7, prLower},     // L&       LATIN SMALL LETTER MIDDLE SCOTS S
 	{0xA7D8, 0xA7D8, prUpper},     // L&       LATIN CAPITAL LETTER SIGMOID S
 	{0xA7D9, 0xA7D9, prLower},     // L&       LATIN SMALL LETTER SIGMOID S
-	{0xA7F2, 0xA7F4, prOLetter},   // Lm   [3] MODIFIER LETTER CAPITAL C..MODIFIER LETTER CAPITAL Q
+	{0xA7F2, 0xA7F4, prLower},     // Lm   [3] MODIFIER LETTER CAPITAL C..MODIFIER LETTER CAPITAL Q
 	{0xA7F5, 0xA7F5, prUpper},     // L&       LATIN CAPITAL LETTER REVERSED HALF H
 	{0xA7F6, 0xA7F6, prLower},     // L&       LATIN SMALL LETTER REVERSED HALF H
 	{0xA7F7, 0xA7F7, prOLetter},   // Lo       LATIN EPIGRAPHIC LETTER SIDEWAYS I
@@ -2140,7 +2141,7 @@ var sentenceBreakCodePoints = [][3]int{
 	{0xAB30, 0xAB5A, prLower},     // L&  [43] LATIN SMALL LETTER BARRED ALPHA..LATIN SMALL LETTER Y WITH SHORT RIGHT LEG
 	{0xAB5C, 0xAB5F, prLower},     // Lm   [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK
 	{0xAB60, 0xAB68, prLower},     // L&   [9] LATIN SMALL LETTER SAKHA YAT..LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE
-	{0xAB69, 0xAB69, prOLetter},   // Lm       MODIFIER LETTER SMALL TURNED W
+	{0xAB69, 0xAB69, prLower},     // Lm       MODIFIER LETTER SMALL TURNED W
 	{0xAB70, 0xABBF, prLower},     // L&  [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA
 	{0xABC0, 0xABE2, prOLetter},   // Lo  [35] MEETEI MAYEK LETTER KOK..MEETEI MAYEK LETTER I LONSUM
 	{0xABE3, 0xABE4, prExtend},    // Mc   [2] MEETEI MAYEK VOWEL SIGN ONAP..MEETEI MAYEK VOWEL SIGN INAP
@@ -2334,6 +2335,7 @@ var sentenceBreakCodePoints = [][3]int{
 	{0x10E80, 0x10EA9, prOLetter}, // Lo  [42] YEZIDI LETTER ELIF..YEZIDI LETTER ET
 	{0x10EAB, 0x10EAC, prExtend},  // Mn   [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK
 	{0x10EB0, 0x10EB1, prOLetter}, // Lo   [2] YEZIDI LETTER LAM WITH DOT ABOVE..YEZIDI LETTER YOT WITH CIRCUMFLEX ABOVE
+	{0x10EFD, 0x10EFF, prExtend},  // Mn   [3] ARABIC SMALL LOW WORD SAKTA..ARABIC SMALL LOW WORD MADDA
 	{0x10F00, 0x10F1C, prOLetter}, // Lo  [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL
 	{0x10F27, 0x10F27, prOLetter}, // Lo       OLD SOGDIAN LIGATURE AYIN-DALETH
 	{0x10F30, 0x10F45, prOLetter}, // Lo  [22] SOGDIAN LETTER ALEPH..SOGDIAN INDEPENDENT SHIN
@@ -2408,6 +2410,8 @@ var sentenceBreakCodePoints = [][3]int{
 	{0x11238, 0x11239, prSTerm},   // Po   [2] KHOJKI DANDA..KHOJKI DOUBLE DANDA
 	{0x1123B, 0x1123C, prSTerm},   // Po   [2] KHOJKI SECTION MARK..KHOJKI DOUBLE SECTION MARK
 	{0x1123E, 0x1123E, prExtend},  // Mn       KHOJKI SIGN SUKUN
+	{0x1123F, 0x11240, prOLetter}, // Lo   [2] KHOJKI LETTER QA..KHOJKI LETTER SHORT I
+	{0x11241, 0x11241, prExtend},  // Mn       KHOJKI VOWEL SIGN VOCALIC R
 	{0x11280, 0x11286, prOLetter}, // Lo   [7] MULTANI LETTER A..MULTANI LETTER GA
 	{0x11288, 0x11288, prOLetter}, // Lo       MULTANI LETTER GHA
 	{0x1128A, 0x1128D, prOLetter}, // Lo   [4] MULTANI LETTER CA..MULTANI LETTER JJA
@@ -2603,13 +2607,29 @@ var sentenceBreakCodePoints = [][3]int{
 	{0x11EF3, 0x11EF4, prExtend},  // Mn   [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U
 	{0x11EF5, 0x11EF6, prExtend},  // Mc   [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O
 	{0x11EF7, 0x11EF8, prSTerm},   // Po   [2] MAKASAR PASSIMBANG..MAKASAR END OF SECTION
+	{0x11F00, 0x11F01, prExtend},  // Mn   [2] KAWI SIGN CANDRABINDU..KAWI SIGN ANUSVARA
+	{0x11F02, 0x11F02, prOLetter}, // Lo       KAWI SIGN REPHA
+	{0x11F03, 0x11F03, prExtend},  // Mc       KAWI SIGN VISARGA
+	{0x11F04, 0x11F10, prOLetter}, // Lo  [13] KAWI LETTER A..KAWI LETTER O
+	{0x11F12, 0x11F33, prOLetter}, // Lo  [34] KAWI LETTER KA..KAWI LETTER JNYA
+	{0x11F34, 0x11F35, prExtend},  // Mc   [2] KAWI VOWEL SIGN AA..KAWI VOWEL SIGN ALTERNATE AA
+	{0x11F36, 0x11F3A, prExtend},  // Mn   [5] KAWI VOWEL SIGN I..KAWI VOWEL SIGN VOCALIC R
+	{0x11F3E, 0x11F3F, prExtend},  // Mc   [2] KAWI VOWEL SIGN E..KAWI VOWEL SIGN AI
+	{0x11F40, 0x11F40, prExtend},  // Mn       KAWI VOWEL SIGN EU
+	{0x11F41, 0x11F41, prExtend},  // Mc       KAWI SIGN KILLER
+	{0x11F42, 0x11F42, prExtend},  // Mn       KAWI CONJOINER
+	{0x11F43, 0x11F44, prSTerm},   // Po   [2] KAWI DANDA..KAWI DOUBLE DANDA
+	{0x11F50, 0x11F59, prNumeric}, // Nd  [10] KAWI DIGIT ZERO..KAWI DIGIT NINE
 	{0x11FB0, 0x11FB0, prOLetter}, // Lo       LISU LETTER YHA
 	{0x12000, 0x12399, prOLetter}, // Lo [922] CUNEIFORM SIGN A..CUNEIFORM SIGN U U
 	{0x12400, 0x1246E, prOLetter}, // Nl [111] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM
 	{0x12480, 0x12543, prOLetter}, // Lo [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU
 	{0x12F90, 0x12FF0, prOLetter}, // Lo  [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114
-	{0x13000, 0x1342E, prOLetter}, // Lo [1071] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH AA032
-	{0x13430, 0x13438, prFormat},  // Cf   [9] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH END SEGMENT
+	{0x13000, 0x1342F, prOLetter}, // Lo [1072] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH V011D
+	{0x13430, 0x1343F, prFormat},  // Cf  [16] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH END WALLED ENCLOSURE
+	{0x13440, 0x13440, prExtend},  // Mn       EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY
+	{0x13441, 0x13446, prOLetter}, // Lo   [6] EGYPTIAN HIEROGLYPH FULL BLANK..EGYPTIAN HIEROGLYPH WIDE LOST SIGN
+	{0x13447, 0x13455, prExtend},  // Mn  [15] EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP START..EGYPTIAN HIEROGLYPH MODIFIER DAMAGED
 	{0x14400, 0x14646, prOLetter}, // Lo [583] ANATOLIAN HIEROGLYPH A001..ANATOLIAN HIEROGLYPH A530
 	{0x16800, 0x16A38, prOLetter}, // Lo [569] BAMUM LETTER PHASE-A NGKUE MFON..BAMUM LETTER PHASE-F VUEQ
 	{0x16A40, 0x16A5E, prOLetter}, // Lo  [31] MRO LETTER TA..MRO LETTER TEK
@@ -2648,7 +2668,9 @@ var sentenceBreakCodePoints = [][3]int{
 	{0x1AFF5, 0x1AFFB, prOLetter}, // Lm   [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5
 	{0x1AFFD, 0x1AFFE, prOLetter}, // Lm   [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8
 	{0x1B000, 0x1B122, prOLetter}, // Lo [291] KATAKANA LETTER ARCHAIC E..KATAKANA LETTER ARCHAIC WU
+	{0x1B132, 0x1B132, prOLetter}, // Lo       HIRAGANA LETTER SMALL KO
 	{0x1B150, 0x1B152, prOLetter}, // Lo   [3] HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO
+	{0x1B155, 0x1B155, prOLetter}, // Lo       KATAKANA LETTER SMALL KO
 	{0x1B164, 0x1B167, prOLetter}, // Lo   [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N
 	{0x1B170, 0x1B2FB, prOLetter}, // Lo [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB
 	{0x1BC00, 0x1BC6A, prOLetter}, // Lo [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M
@@ -2738,11 +2760,14 @@ var sentenceBreakCodePoints = [][3]int{
 	{0x1DF00, 0x1DF09, prLower},   // L&  [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK
 	{0x1DF0A, 0x1DF0A, prOLetter}, // Lo       LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK
 	{0x1DF0B, 0x1DF1E, prLower},   // L&  [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL
+	{0x1DF25, 0x1DF2A, prLower},   // L&   [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK
 	{0x1E000, 0x1E006, prExtend},  // Mn   [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE
 	{0x1E008, 0x1E018, prExtend},  // Mn  [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU
 	{0x1E01B, 0x1E021, prExtend},  // Mn   [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI
 	{0x1E023, 0x1E024, prExtend},  // Mn   [2] COMBINING GLAGOLITIC LETTER YU..COMBINING GLAGOLITIC LETTER SMALL YUS
 	{0x1E026, 0x1E02A, prExtend},  // Mn   [5] COMBINING GLAGOLITIC LETTER YO..COMBINING GLAGOLITIC LETTER FITA
+	{0x1E030, 0x1E06D, prLower},   // Lm  [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE
+	{0x1E08F, 0x1E08F, prExtend},  // Mn       COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
 	{0x1E100, 0x1E12C, prOLetter}, // Lo  [45] NYIAKENG PUACHUE HMONG LETTER MA..NYIAKENG PUACHUE HMONG LETTER W
 	{0x1E130, 0x1E136, prExtend},  // Mn   [7] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG TONE-D
 	{0x1E137, 0x1E13D, prOLetter}, // Lm   [7] NYIAKENG PUACHUE HMONG SIGN FOR PERSON..NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER
@@ -2753,6 +2778,10 @@ var sentenceBreakCodePoints = [][3]int{
 	{0x1E2C0, 0x1E2EB, prOLetter}, // Lo  [44] WANCHO LETTER AA..WANCHO LETTER YIH
 	{0x1E2EC, 0x1E2EF, prExtend},  // Mn   [4] WANCHO TONE TUP..WANCHO TONE KOINI
 	{0x1E2F0, 0x1E2F9, prNumeric}, // Nd  [10] WANCHO DIGIT ZERO..WANCHO DIGIT NINE
+	{0x1E4D0, 0x1E4EA, prOLetter}, // Lo  [27] NAG MUNDARI LETTER O..NAG MUNDARI LETTER ELL
+	{0x1E4EB, 0x1E4EB, prOLetter}, // Lm       NAG MUNDARI SIGN OJOD
+	{0x1E4EC, 0x1E4EF, prExtend},  // Mn   [4] NAG MUNDARI SIGN MUHOR..NAG MUNDARI SIGN SUTUH
+	{0x1E4F0, 0x1E4F9, prNumeric}, // Nd  [10] NAG MUNDARI DIGIT ZERO..NAG MUNDARI DIGIT NINE
 	{0x1E7E0, 0x1E7E6, prOLetter}, // Lo   [7] ETHIOPIC SYLLABLE HHYA..ETHIOPIC SYLLABLE HHYO
 	{0x1E7E8, 0x1E7EB, prOLetter}, // Lo   [4] ETHIOPIC SYLLABLE GURAGE HHWA..ETHIOPIC SYLLABLE HHWE
 	{0x1E7ED, 0x1E7EE, prOLetter}, // Lo   [2] ETHIOPIC SYLLABLE GURAGE MWI..ETHIOPIC SYLLABLE GURAGE MWEE
@@ -2803,12 +2832,13 @@ var sentenceBreakCodePoints = [][3]int{
 	{0x1F676, 0x1F678, prClose},   // So   [3] SANS-SERIF HEAVY DOUBLE TURNED COMMA QUOTATION MARK ORNAMENT..SANS-SERIF HEAVY LOW DOUBLE COMMA QUOTATION MARK ORNAMENT
 	{0x1FBF0, 0x1FBF9, prNumeric}, // Nd  [10] SEGMENTED DIGIT ZERO..SEGMENTED DIGIT NINE
 	{0x20000, 0x2A6DF, prOLetter}, // Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF
-	{0x2A700, 0x2B738, prOLetter}, // Lo [4153] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B738
+	{0x2A700, 0x2B739, prOLetter}, // Lo [4154] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B739
 	{0x2B740, 0x2B81D, prOLetter}, // Lo [222] CJK UNIFIED IDEOGRAPH-2B740..CJK UNIFIED IDEOGRAPH-2B81D
 	{0x2B820, 0x2CEA1, prOLetter}, // Lo [5762] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEA1
 	{0x2CEB0, 0x2EBE0, prOLetter}, // Lo [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0
 	{0x2F800, 0x2FA1D, prOLetter}, // Lo [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D
 	{0x30000, 0x3134A, prOLetter}, // Lo [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A
+	{0x31350, 0x323AF, prOLetter}, // Lo [4192] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-323AF
 	{0xE0001, 0xE0001, prFormat},  // Cf       LANGUAGE TAG
 	{0xE0020, 0xE007F, prExtend},  // Cf  [96] TAG SPACE..CANCEL TAG
 	{0xE0100, 0xE01EF, prExtend},  // Mn [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256

vendor/github.com/rivo/uniseg/sentencerules.go

@@ -18,104 +18,178 @@ const (
 	sbSB8aSp
 )
 
-// The sentence break parser's breaking instructions.
-const (
-	sbDontBreak = iota
-	sbBreak
-)
-
-// The sentence break parser's state transitions. It's anologous to
-// grTransitions, see comments there for details. Unicode version 14.0.0.
-var sbTransitions = map[[2]int][3]int{
+// sbTransitions implements the sentence break parser's state transitions. It's
+// anologous to [grTransitions], see comments there for details.
+//
+// Unicode version 15.0.0.
+func sbTransitions(state, prop int) (newState int, sentenceBreak bool, rule int) {
+	switch uint64(state) | uint64(prop)<<32 {
 	// SB3.
-	{sbAny, prCR}: {sbCR, sbDontBreak, 9990},
-	{sbCR, prLF}:  {sbParaSep, sbDontBreak, 30},
+	case sbAny | prCR<<32:
+		return sbCR, false, 9990
+	case sbCR | prLF<<32:
+		return sbParaSep, false, 30
 
 	// SB4.
-	{sbAny, prSep}:     {sbParaSep, sbDontBreak, 9990},
-	{sbAny, prLF}:      {sbParaSep, sbDontBreak, 9990},
-	{sbParaSep, prAny}: {sbAny, sbBreak, 40},
-	{sbCR, prAny}:      {sbAny, sbBreak, 40},
+	case sbAny | prSep<<32:
+		return sbParaSep, false, 9990
+	case sbAny | prLF<<32:
+		return sbParaSep, false, 9990
+	case sbParaSep | prAny<<32:
+		return sbAny, true, 40
+	case sbCR | prAny<<32:
+		return sbAny, true, 40
 
 	// SB6.
-	{sbAny, prATerm}:     {sbATerm, sbDontBreak, 9990},
-	{sbATerm, prNumeric}: {sbAny, sbDontBreak, 60},
-	{sbSB7, prNumeric}:   {sbAny, sbDontBreak, 60}, // Because ATerm also appears in SB7.
+	case sbAny | prATerm<<32:
+		return sbATerm, false, 9990
+	case sbATerm | prNumeric<<32:
+		return sbAny, false, 60
+	case sbSB7 | prNumeric<<32:
+		return sbAny, false, 60 // Because ATerm also appears in SB7.
 
 	// SB7.
-	{sbAny, prUpper}:   {sbUpper, sbDontBreak, 9990},
-	{sbAny, prLower}:   {sbLower, sbDontBreak, 9990},
-	{sbUpper, prATerm}: {sbSB7, sbDontBreak, 70},
-	{sbLower, prATerm}: {sbSB7, sbDontBreak, 70},
-	{sbSB7, prUpper}:   {sbUpper, sbDontBreak, 70},
+	case sbAny | prUpper<<32:
+		return sbUpper, false, 9990
+	case sbAny | prLower<<32:
+		return sbLower, false, 9990
+	case sbUpper | prATerm<<32:
+		return sbSB7, false, 70
+	case sbLower | prATerm<<32:
+		return sbSB7, false, 70
+	case sbSB7 | prUpper<<32:
+		return sbUpper, false, 70
 
 	// SB8a.
-	{sbAny, prSTerm}:           {sbSTerm, sbDontBreak, 9990},
-	{sbATerm, prSContinue}:     {sbAny, sbDontBreak, 81},
-	{sbATerm, prATerm}:         {sbATerm, sbDontBreak, 81},
-	{sbATerm, prSTerm}:         {sbSTerm, sbDontBreak, 81},
-	{sbSB7, prSContinue}:       {sbAny, sbDontBreak, 81},
-	{sbSB7, prATerm}:           {sbATerm, sbDontBreak, 81},
-	{sbSB7, prSTerm}:           {sbSTerm, sbDontBreak, 81},
-	{sbSB8Close, prSContinue}:  {sbAny, sbDontBreak, 81},
-	{sbSB8Close, prATerm}:      {sbATerm, sbDontBreak, 81},
-	{sbSB8Close, prSTerm}:      {sbSTerm, sbDontBreak, 81},
-	{sbSB8Sp, prSContinue}:     {sbAny, sbDontBreak, 81},
-	{sbSB8Sp, prATerm}:         {sbATerm, sbDontBreak, 81},
-	{sbSB8Sp, prSTerm}:         {sbSTerm, sbDontBreak, 81},
-	{sbSTerm, prSContinue}:     {sbAny, sbDontBreak, 81},
-	{sbSTerm, prATerm}:         {sbATerm, sbDontBreak, 81},
-	{sbSTerm, prSTerm}:         {sbSTerm, sbDontBreak, 81},
-	{sbSB8aClose, prSContinue}: {sbAny, sbDontBreak, 81},
-	{sbSB8aClose, prATerm}:     {sbATerm, sbDontBreak, 81},
-	{sbSB8aClose, prSTerm}:     {sbSTerm, sbDontBreak, 81},
-	{sbSB8aSp, prSContinue}:    {sbAny, sbDontBreak, 81},
-	{sbSB8aSp, prATerm}:        {sbATerm, sbDontBreak, 81},
-	{sbSB8aSp, prSTerm}:        {sbSTerm, sbDontBreak, 81},
+	case sbAny | prSTerm<<32:
+		return sbSTerm, false, 9990
+	case sbATerm | prSContinue<<32:
+		return sbAny, false, 81
+	case sbATerm | prATerm<<32:
+		return sbATerm, false, 81
+	case sbATerm | prSTerm<<32:
+		return sbSTerm, false, 81
+	case sbSB7 | prSContinue<<32:
+		return sbAny, false, 81
+	case sbSB7 | prATerm<<32:
+		return sbATerm, false, 81
+	case sbSB7 | prSTerm<<32:
+		return sbSTerm, false, 81
+	case sbSB8Close | prSContinue<<32:
+		return sbAny, false, 81
+	case sbSB8Close | prATerm<<32:
+		return sbATerm, false, 81
+	case sbSB8Close | prSTerm<<32:
+		return sbSTerm, false, 81
+	case sbSB8Sp | prSContinue<<32:
+		return sbAny, false, 81
+	case sbSB8Sp | prATerm<<32:
+		return sbATerm, false, 81
+	case sbSB8Sp | prSTerm<<32:
+		return sbSTerm, false, 81
+	case sbSTerm | prSContinue<<32:
+		return sbAny, false, 81
+	case sbSTerm | prATerm<<32:
+		return sbATerm, false, 81
+	case sbSTerm | prSTerm<<32:
+		return sbSTerm, false, 81
+	case sbSB8aClose | prSContinue<<32:
+		return sbAny, false, 81
+	case sbSB8aClose | prATerm<<32:
+		return sbATerm, false, 81
+	case sbSB8aClose | prSTerm<<32:
+		return sbSTerm, false, 81
+	case sbSB8aSp | prSContinue<<32:
+		return sbAny, false, 81
+	case sbSB8aSp | prATerm<<32:
+		return sbATerm, false, 81
+	case sbSB8aSp | prSTerm<<32:
+		return sbSTerm, false, 81
 
 	// SB9.
-	{sbATerm, prClose}:     {sbSB8Close, sbDontBreak, 90},
-	{sbSB7, prClose}:       {sbSB8Close, sbDontBreak, 90},
-	{sbSB8Close, prClose}:  {sbSB8Close, sbDontBreak, 90},
-	{sbATerm, prSp}:        {sbSB8Sp, sbDontBreak, 90},
-	{sbSB7, prSp}:          {sbSB8Sp, sbDontBreak, 90},
-	{sbSB8Close, prSp}:     {sbSB8Sp, sbDontBreak, 90},
-	{sbSTerm, prClose}:     {sbSB8aClose, sbDontBreak, 90},
-	{sbSB8aClose, prClose}: {sbSB8aClose, sbDontBreak, 90},
-	{sbSTerm, prSp}:        {sbSB8aSp, sbDontBreak, 90},
-	{sbSB8aClose, prSp}:    {sbSB8aSp, sbDontBreak, 90},
-	{sbATerm, prSep}:       {sbParaSep, sbDontBreak, 90},
-	{sbATerm, prCR}:        {sbParaSep, sbDontBreak, 90},
-	{sbATerm, prLF}:        {sbParaSep, sbDontBreak, 90},
-	{sbSB7, prSep}:         {sbParaSep, sbDontBreak, 90},
-	{sbSB7, prCR}:          {sbParaSep, sbDontBreak, 90},
-	{sbSB7, prLF}:          {sbParaSep, sbDontBreak, 90},
-	{sbSB8Close, prSep}:    {sbParaSep, sbDontBreak, 90},
-	{sbSB8Close, prCR}:     {sbParaSep, sbDontBreak, 90},
-	{sbSB8Close, prLF}:     {sbParaSep, sbDontBreak, 90},
-	{sbSTerm, prSep}:       {sbParaSep, sbDontBreak, 90},
-	{sbSTerm, prCR}:        {sbParaSep, sbDontBreak, 90},
-	{sbSTerm, prLF}:        {sbParaSep, sbDontBreak, 90},
-	{sbSB8aClose, prSep}:   {sbParaSep, sbDontBreak, 90},
-	{sbSB8aClose, prCR}:    {sbParaSep, sbDontBreak, 90},
-	{sbSB8aClose, prLF}:    {sbParaSep, sbDontBreak, 90},
+	case sbATerm | prClose<<32:
+		return sbSB8Close, false, 90
+	case sbSB7 | prClose<<32:
+		return sbSB8Close, false, 90
+	case sbSB8Close | prClose<<32:
+		return sbSB8Close, false, 90
+	case sbATerm | prSp<<32:
+		return sbSB8Sp, false, 90
+	case sbSB7 | prSp<<32:
+		return sbSB8Sp, false, 90
+	case sbSB8Close | prSp<<32:
+		return sbSB8Sp, false, 90
+	case sbSTerm | prClose<<32:
+		return sbSB8aClose, false, 90
+	case sbSB8aClose | prClose<<32:
+		return sbSB8aClose, false, 90
+	case sbSTerm | prSp<<32:
+		return sbSB8aSp, false, 90
+	case sbSB8aClose | prSp<<32:
+		return sbSB8aSp, false, 90
+	case sbATerm | prSep<<32:
+		return sbParaSep, false, 90
+	case sbATerm | prCR<<32:
+		return sbParaSep, false, 90
+	case sbATerm | prLF<<32:
+		return sbParaSep, false, 90
+	case sbSB7 | prSep<<32:
+		return sbParaSep, false, 90
+	case sbSB7 | prCR<<32:
+		return sbParaSep, false, 90
+	case sbSB7 | prLF<<32:
+		return sbParaSep, false, 90
+	case sbSB8Close | prSep<<32:
+		return sbParaSep, false, 90
+	case sbSB8Close | prCR<<32:
+		return sbParaSep, false, 90
+	case sbSB8Close | prLF<<32:
+		return sbParaSep, false, 90
+	case sbSTerm | prSep<<32:
+		return sbParaSep, false, 90
+	case sbSTerm | prCR<<32:
+		return sbParaSep, false, 90
+	case sbSTerm | prLF<<32:
+		return sbParaSep, false, 90
+	case sbSB8aClose | prSep<<32:
+		return sbParaSep, false, 90
+	case sbSB8aClose | prCR<<32:
+		return sbParaSep, false, 90
+	case sbSB8aClose | prLF<<32:
+		return sbParaSep, false, 90
 
 	// SB10.
-	{sbSB8Sp, prSp}:  {sbSB8Sp, sbDontBreak, 100},
-	{sbSB8aSp, prSp}: {sbSB8aSp, sbDontBreak, 100},
-	{sbSB8Sp, prSep}: {sbParaSep, sbDontBreak, 100},
-	{sbSB8Sp, prCR}:  {sbParaSep, sbDontBreak, 100},
-	{sbSB8Sp, prLF}:  {sbParaSep, sbDontBreak, 100},
+	case sbSB8Sp | prSp<<32:
+		return sbSB8Sp, false, 100
+	case sbSB8aSp | prSp<<32:
+		return sbSB8aSp, false, 100
+	case sbSB8Sp | prSep<<32:
+		return sbParaSep, false, 100
+	case sbSB8Sp | prCR<<32:
+		return sbParaSep, false, 100
+	case sbSB8Sp | prLF<<32:
+		return sbParaSep, false, 100
 
 	// SB11.
-	{sbATerm, prAny}:     {sbAny, sbBreak, 110},
-	{sbSB7, prAny}:       {sbAny, sbBreak, 110},
-	{sbSB8Close, prAny}:  {sbAny, sbBreak, 110},
-	{sbSB8Sp, prAny}:     {sbAny, sbBreak, 110},
-	{sbSTerm, prAny}:     {sbAny, sbBreak, 110},
-	{sbSB8aClose, prAny}: {sbAny, sbBreak, 110},
-	{sbSB8aSp, prAny}:    {sbAny, sbBreak, 110},
+	case sbATerm | prAny<<32:
+		return sbAny, true, 110
+	case sbSB7 | prAny<<32:
+		return sbAny, true, 110
+	case sbSB8Close | prAny<<32:
+		return sbAny, true, 110
+	case sbSB8Sp | prAny<<32:
+		return sbAny, true, 110
+	case sbSTerm | prAny<<32:
+		return sbAny, true, 110
+	case sbSB8aClose | prAny<<32:
+		return sbAny, true, 110
+	case sbSB8aSp | prAny<<32:
+		return sbAny, true, 110
 	// We'll always break after ParaSep due to SB4.
+
+	default:
+		return -1, false, -1
+	}
 }
 
 // transitionSentenceBreakState determines the new state of the sentence break
@@ -141,30 +215,27 @@ func transitionSentenceBreakState(state int, r rune, b []byte, str string) (newS
 
 	// Find the applicable transition in the table.
 	var rule int
-	transition, ok := sbTransitions[[2]int{state, nextProperty}]
-	if ok {
-		// We have a specific transition. We'll use it.
-		newState, sentenceBreak, rule = transition[0], transition[1] == sbBreak, transition[2]
-	} else {
+	newState, sentenceBreak, rule = sbTransitions(state, nextProperty)
+	if newState < 0 {
 		// No specific transition found. Try the less specific ones.
-		transAnyProp, okAnyProp := sbTransitions[[2]int{state, prAny}]
-		transAnyState, okAnyState := sbTransitions[[2]int{sbAny, nextProperty}]
-		if okAnyProp && okAnyState {
+		anyPropState, anyPropProp, anyPropRule := sbTransitions(state, prAny)
+		anyStateState, anyStateProp, anyStateRule := sbTransitions(sbAny, nextProperty)
+		if anyPropState >= 0 && anyStateState >= 0 {
 			// Both apply. We'll use a mix (see comments for grTransitions).
-			newState, sentenceBreak, rule = transAnyState[0], transAnyState[1] == sbBreak, transAnyState[2]
-			if transAnyProp[2] < transAnyState[2] {
-				sentenceBreak, rule = transAnyProp[1] == sbBreak, transAnyProp[2]
+			newState, sentenceBreak, rule = anyStateState, anyStateProp, anyStateRule
+			if anyPropRule < anyStateRule {
+				sentenceBreak, rule = anyPropProp, anyPropRule
 			}
-		} else if okAnyProp {
+		} else if anyPropState >= 0 {
 			// We only have a specific state.
-			newState, sentenceBreak, rule = transAnyProp[0], transAnyProp[1] == sbBreak, transAnyProp[2]
+			newState, sentenceBreak, rule = anyPropState, anyPropProp, anyPropRule
 			// This branch will probably never be reached because okAnyState will
 			// always be true given the current transition map. But we keep it here
 			// for future modifications to the transition map where this may not be
 			// true anymore.
-		} else if okAnyState {
+		} else if anyStateState >= 0 {
 			// We only have a specific property.
-			newState, sentenceBreak, rule = transAnyState[0], transAnyState[1] == sbBreak, transAnyState[2]
+			newState, sentenceBreak, rule = anyStateState, anyStateProp, anyStateRule
 		} else {
 			// No known transition. SB999: Any × Any.
 			newState, sentenceBreak, rule = sbAny, false, 9990

vendor/github.com/rivo/uniseg/step.go

@@ -100,7 +100,7 @@ func Step(b []byte, state int) (cluster, rest []byte, boundaries int, newState i
 	if len(b) <= length { // If we're already past the end, there is nothing else to parse.
 		var prop int
 		if state < 0 {
-			prop = property(graphemeCodePoints, r)
+			prop = propertyGraphemes(r)
 		} else {
 			prop = state >> shiftPropState
 		}
@@ -150,16 +150,14 @@ func Step(b []byte, state int) (cluster, rest []byte, boundaries int, newState i
 			return b[:length], b[length:], boundary, graphemeState | (wordState << shiftWordState) | (sentenceState << shiftSentenceState) | (lineState << shiftLineState) | (prop << shiftPropState)
 		}
 
-		if r == vs16 {
-			width = 2
-		} else if firstProp != prExtendedPictographic && firstProp != prRegionalIndicator && firstProp != prL {
-			width += runeWidth(r, prop)
-		} else if firstProp == prExtendedPictographic {
+		if firstProp == prExtendedPictographic {
 			if r == vs15 {
 				width = 1
-			} else {
+			} else if r == vs16 {
 				width = 2
 			}
+		} else if firstProp != prRegionalIndicator && firstProp != prL {
+			width += runeWidth(r, prop)
 		}
 
 		length += l
@@ -179,7 +177,7 @@ func StepString(str string, state int) (cluster, rest string, boundaries int, ne
 	// Extract the first rune.
 	r, length := utf8.DecodeRuneInString(str)
 	if len(str) <= length { // If we're already past the end, there is nothing else to parse.
-		prop := property(graphemeCodePoints, r)
+		prop := propertyGraphemes(r)
 		return str, "", LineMustBreak | (1 << shiftWord) | (1 << shiftSentence) | (runeWidth(r, prop) << ShiftWidth), grAny | (wbAny << shiftWordState) | (sbAny << shiftSentenceState) | (lbAny << shiftLineState)
 	}
 
@@ -226,16 +224,14 @@ func StepString(str string, state int) (cluster, rest string, boundaries int, ne
 			return str[:length], str[length:], boundary, graphemeState | (wordState << shiftWordState) | (sentenceState << shiftSentenceState) | (lineState << shiftLineState) | (prop << shiftPropState)
 		}
 
-		if r == vs16 {
-			width = 2
-		} else if firstProp != prExtendedPictographic && firstProp != prRegionalIndicator && firstProp != prL {
-			width += runeWidth(r, prop)
-		} else if firstProp == prExtendedPictographic {
+		if firstProp == prExtendedPictographic {
 			if r == vs15 {
 				width = 1
-			} else {
+			} else if r == vs16 {
 				width = 2
 			}
+		} else if firstProp != prRegionalIndicator && firstProp != prL {
+			width += runeWidth(r, prop)
 		}
 
 		length += l

vendor/github.com/rivo/uniseg/width.go

@@ -1,5 +1,10 @@
 package uniseg
 
+// EastAsianAmbiguousWidth specifies the monospace width for East Asian
+// characters classified as Ambiguous. The default is 1 but some rare fonts
+// render them with a width of 2.
+var EastAsianAmbiguousWidth = 1
+
 // runeWidth returns the monospace width for the given rune. The provided
 // grapheme property is a value mapped by the [graphemeCodePoints] table.
 //
@@ -33,9 +38,11 @@ func runeWidth(r rune, graphemeProperty int) int {
 		return 4
 	}
 
-	switch property(eastAsianWidth, r) {
+	switch propertyEastAsianWidth(r) {
 	case prW, prF:
 		return 2
+	case prA:
+		return EastAsianAmbiguousWidth
 	}
 
 	return 1

vendor/github.com/rivo/uniseg/wordproperties.go

@@ -1,13 +1,13 @@
-package uniseg
-
 // Code generated via go generate from gen_properties.go. DO NOT EDIT.
 
+package uniseg
+
 // workBreakCodePoints are taken from
-// https://www.unicode.org/Public/14.0.0/ucd/auxiliary/WordBreakProperty.txt
+// https://www.unicode.org/Public/15.0.0/ucd/auxiliary/WordBreakProperty.txt
 // and
-// https://unicode.org/Public/14.0.0/ucd/emoji/emoji-data.txt
+// https://unicode.org/Public/15.0.0/ucd/emoji/emoji-data.txt
 // ("Extended_Pictographic" only)
-// on September 10, 2022. See https://www.unicode.org/license.html for the Unicode
+// on September 5, 2023. See https://www.unicode.org/license.html for the Unicode
 // license agreement.
 var workBreakCodePoints = [][3]int{
 	{0x000A, 0x000A, prLF},                     // Cc       <control-000A>
@@ -318,6 +318,7 @@ var workBreakCodePoints = [][3]int{
 	{0x0CE2, 0x0CE3, prExtend},                 // Mn   [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL
 	{0x0CE6, 0x0CEF, prNumeric},                // Nd  [10] KANNADA DIGIT ZERO..KANNADA DIGIT NINE
 	{0x0CF1, 0x0CF2, prALetter},                // Lo   [2] KANNADA SIGN JIHVAMULIYA..KANNADA SIGN UPADHMANIYA
+	{0x0CF3, 0x0CF3, prExtend},                 // Mc       KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT
 	{0x0D00, 0x0D01, prExtend},                 // Mn   [2] MALAYALAM SIGN COMBINING ANUSVARA ABOVE..MALAYALAM SIGN CANDRABINDU
 	{0x0D02, 0x0D03, prExtend},                 // Mc   [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA
 	{0x0D04, 0x0D0C, prALetter},                // Lo   [9] MALAYALAM LETTER VEDIC ANUSVARA..MALAYALAM LETTER VOCALIC L
@@ -357,7 +358,7 @@ var workBreakCodePoints = [][3]int{
 	{0x0E50, 0x0E59, prNumeric},                // Nd  [10] THAI DIGIT ZERO..THAI DIGIT NINE
 	{0x0EB1, 0x0EB1, prExtend},                 // Mn       LAO VOWEL SIGN MAI KAN
 	{0x0EB4, 0x0EBC, prExtend},                 // Mn   [9] LAO VOWEL SIGN I..LAO SEMIVOWEL SIGN LO
-	{0x0EC8, 0x0ECD, prExtend},                 // Mn   [6] LAO TONE MAI EK..LAO NIGGAHITA
+	{0x0EC8, 0x0ECE, prExtend},                 // Mn   [7] LAO TONE MAI EK..LAO YAMAKKAN
 	{0x0ED0, 0x0ED9, prNumeric},                // Nd  [10] LAO DIGIT ZERO..LAO DIGIT NINE
 	{0x0F00, 0x0F00, prALetter},                // Lo       TIBETAN SYLLABLE OM
 	{0x0F18, 0x0F19, prExtend},                 // Mn   [2] TIBETAN ASTROLOGICAL SIGN -KHYUD PA..TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS
@@ -1093,6 +1094,7 @@ var workBreakCodePoints = [][3]int{
 	{0x10E80, 0x10EA9, prALetter},              // Lo  [42] YEZIDI LETTER ELIF..YEZIDI LETTER ET
 	{0x10EAB, 0x10EAC, prExtend},               // Mn   [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK
 	{0x10EB0, 0x10EB1, prALetter},              // Lo   [2] YEZIDI LETTER LAM WITH DOT ABOVE..YEZIDI LETTER YOT WITH CIRCUMFLEX ABOVE
+	{0x10EFD, 0x10EFF, prExtend},               // Mn   [3] ARABIC SMALL LOW WORD SAKTA..ARABIC SMALL LOW WORD MADDA
 	{0x10F00, 0x10F1C, prALetter},              // Lo  [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL
 	{0x10F27, 0x10F27, prALetter},              // Lo       OLD SOGDIAN LIGATURE AYIN-DALETH
 	{0x10F30, 0x10F45, prALetter},              // Lo  [22] SOGDIAN LETTER ALEPH..SOGDIAN INDEPENDENT SHIN
@@ -1157,6 +1159,8 @@ var workBreakCodePoints = [][3]int{
 	{0x11235, 0x11235, prExtend},               // Mc       KHOJKI SIGN VIRAMA
 	{0x11236, 0x11237, prExtend},               // Mn   [2] KHOJKI SIGN NUKTA..KHOJKI SIGN SHADDA
 	{0x1123E, 0x1123E, prExtend},               // Mn       KHOJKI SIGN SUKUN
+	{0x1123F, 0x11240, prALetter},              // Lo   [2] KHOJKI LETTER QA..KHOJKI LETTER SHORT I
+	{0x11241, 0x11241, prExtend},               // Mn       KHOJKI VOWEL SIGN VOCALIC R
 	{0x11280, 0x11286, prALetter},              // Lo   [7] MULTANI LETTER A..MULTANI LETTER GA
 	{0x11288, 0x11288, prALetter},              // Lo       MULTANI LETTER GHA
 	{0x1128A, 0x1128D, prALetter},              // Lo   [4] MULTANI LETTER CA..MULTANI LETTER JJA
@@ -1337,13 +1341,28 @@ var workBreakCodePoints = [][3]int{
 	{0x11EE0, 0x11EF2, prALetter},              // Lo  [19] MAKASAR LETTER KA..MAKASAR ANGKA
 	{0x11EF3, 0x11EF4, prExtend},               // Mn   [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U
 	{0x11EF5, 0x11EF6, prExtend},               // Mc   [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O
+	{0x11F00, 0x11F01, prExtend},               // Mn   [2] KAWI SIGN CANDRABINDU..KAWI SIGN ANUSVARA
+	{0x11F02, 0x11F02, prALetter},              // Lo       KAWI SIGN REPHA
+	{0x11F03, 0x11F03, prExtend},               // Mc       KAWI SIGN VISARGA
+	{0x11F04, 0x11F10, prALetter},              // Lo  [13] KAWI LETTER A..KAWI LETTER O
+	{0x11F12, 0x11F33, prALetter},              // Lo  [34] KAWI LETTER KA..KAWI LETTER JNYA
+	{0x11F34, 0x11F35, prExtend},               // Mc   [2] KAWI VOWEL SIGN AA..KAWI VOWEL SIGN ALTERNATE AA
+	{0x11F36, 0x11F3A, prExtend},               // Mn   [5] KAWI VOWEL SIGN I..KAWI VOWEL SIGN VOCALIC R
+	{0x11F3E, 0x11F3F, prExtend},               // Mc   [2] KAWI VOWEL SIGN E..KAWI VOWEL SIGN AI
+	{0x11F40, 0x11F40, prExtend},               // Mn       KAWI VOWEL SIGN EU
+	{0x11F41, 0x11F41, prExtend},               // Mc       KAWI SIGN KILLER
+	{0x11F42, 0x11F42, prExtend},               // Mn       KAWI CONJOINER
+	{0x11F50, 0x11F59, prNumeric},              // Nd  [10] KAWI DIGIT ZERO..KAWI DIGIT NINE
 	{0x11FB0, 0x11FB0, prALetter},              // Lo       LISU LETTER YHA
 	{0x12000, 0x12399, prALetter},              // Lo [922] CUNEIFORM SIGN A..CUNEIFORM SIGN U U
 	{0x12400, 0x1246E, prALetter},              // Nl [111] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM
 	{0x12480, 0x12543, prALetter},              // Lo [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU
 	{0x12F90, 0x12FF0, prALetter},              // Lo  [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114
-	{0x13000, 0x1342E, prALetter},              // Lo [1071] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH AA032
-	{0x13430, 0x13438, prFormat},               // Cf   [9] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH END SEGMENT
+	{0x13000, 0x1342F, prALetter},              // Lo [1072] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH V011D
+	{0x13430, 0x1343F, prFormat},               // Cf  [16] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH END WALLED ENCLOSURE
+	{0x13440, 0x13440, prExtend},               // Mn       EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY
+	{0x13441, 0x13446, prALetter},              // Lo   [6] EGYPTIAN HIEROGLYPH FULL BLANK..EGYPTIAN HIEROGLYPH WIDE LOST SIGN
+	{0x13447, 0x13455, prExtend},               // Mn  [15] EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP START..EGYPTIAN HIEROGLYPH MODIFIER DAMAGED
 	{0x14400, 0x14646, prALetter},              // Lo [583] ANATOLIAN HIEROGLYPH A001..ANATOLIAN HIEROGLYPH A530
 	{0x16800, 0x16A38, prALetter},              // Lo [569] BAMUM LETTER PHASE-A NGKUE MFON..BAMUM LETTER PHASE-F VUEQ
 	{0x16A40, 0x16A5E, prALetter},              // Lo  [31] MRO LETTER TA..MRO LETTER TEK
@@ -1374,6 +1393,7 @@ var workBreakCodePoints = [][3]int{
 	{0x1AFFD, 0x1AFFE, prKatakana},             // Lm   [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8
 	{0x1B000, 0x1B000, prKatakana},             // Lo       KATAKANA LETTER ARCHAIC E
 	{0x1B120, 0x1B122, prKatakana},             // Lo   [3] KATAKANA LETTER ARCHAIC YI..KATAKANA LETTER ARCHAIC WU
+	{0x1B155, 0x1B155, prKatakana},             // Lo       KATAKANA LETTER SMALL KO
 	{0x1B164, 0x1B167, prKatakana},             // Lo   [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N
 	{0x1BC00, 0x1BC6A, prALetter},              // Lo [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M
 	{0x1BC70, 0x1BC7C, prALetter},              // Lo  [13] DUPLOYAN AFFIX LEFT HORIZONTAL SECANT..DUPLOYAN AFFIX ATTACHED TANGENT HOOK
@@ -1431,11 +1451,14 @@ var workBreakCodePoints = [][3]int{
 	{0x1DF00, 0x1DF09, prALetter},              // L&  [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK
 	{0x1DF0A, 0x1DF0A, prALetter},              // Lo       LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK
 	{0x1DF0B, 0x1DF1E, prALetter},              // L&  [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL
+	{0x1DF25, 0x1DF2A, prALetter},              // L&   [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK
 	{0x1E000, 0x1E006, prExtend},               // Mn   [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE
 	{0x1E008, 0x1E018, prExtend},               // Mn  [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU
 	{0x1E01B, 0x1E021, prExtend},               // Mn   [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI
 	{0x1E023, 0x1E024, prExtend},               // Mn   [2] COMBINING GLAGOLITIC LETTER YU..COMBINING GLAGOLITIC LETTER SMALL YUS
 	{0x1E026, 0x1E02A, prExtend},               // Mn   [5] COMBINING GLAGOLITIC LETTER YO..COMBINING GLAGOLITIC LETTER FITA
+	{0x1E030, 0x1E06D, prALetter},              // Lm  [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE
+	{0x1E08F, 0x1E08F, prExtend},               // Mn       COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
 	{0x1E100, 0x1E12C, prALetter},              // Lo  [45] NYIAKENG PUACHUE HMONG LETTER MA..NYIAKENG PUACHUE HMONG LETTER W
 	{0x1E130, 0x1E136, prExtend},               // Mn   [7] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG TONE-D
 	{0x1E137, 0x1E13D, prALetter},              // Lm   [7] NYIAKENG PUACHUE HMONG SIGN FOR PERSON..NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER
@@ -1446,6 +1469,10 @@ var workBreakCodePoints = [][3]int{
 	{0x1E2C0, 0x1E2EB, prALetter},              // Lo  [44] WANCHO LETTER AA..WANCHO LETTER YIH
 	{0x1E2EC, 0x1E2EF, prExtend},               // Mn   [4] WANCHO TONE TUP..WANCHO TONE KOINI
 	{0x1E2F0, 0x1E2F9, prNumeric},              // Nd  [10] WANCHO DIGIT ZERO..WANCHO DIGIT NINE
+	{0x1E4D0, 0x1E4EA, prALetter},              // Lo  [27] NAG MUNDARI LETTER O..NAG MUNDARI LETTER ELL
+	{0x1E4EB, 0x1E4EB, prALetter},              // Lm       NAG MUNDARI SIGN OJOD
+	{0x1E4EC, 0x1E4EF, prExtend},               // Mn   [4] NAG MUNDARI SIGN MUHOR..NAG MUNDARI SIGN SUTUH
+	{0x1E4F0, 0x1E4F9, prNumeric},              // Nd  [10] NAG MUNDARI DIGIT ZERO..NAG MUNDARI DIGIT NINE
 	{0x1E7E0, 0x1E7E6, prALetter},              // Lo   [7] ETHIOPIC SYLLABLE HHYA..ETHIOPIC SYLLABLE HHYO
 	{0x1E7E8, 0x1E7EB, prALetter},              // Lo   [4] ETHIOPIC SYLLABLE GURAGE HHWA..ETHIOPIC SYLLABLE HHWE
 	{0x1E7ED, 0x1E7EE, prALetter},              // Lo   [2] ETHIOPIC SYLLABLE GURAGE MWI..ETHIOPIC SYLLABLE GURAGE MWEE
@@ -1740,7 +1767,8 @@ var workBreakCodePoints = [][3]int{
 	{0x1F6D3, 0x1F6D4, prExtendedPictographic}, // E0.0   [2] (🛓..🛔)    STUPA..PAGODA
 	{0x1F6D5, 0x1F6D5, prExtendedPictographic}, // E12.0  [1] (🛕)       hindu temple
 	{0x1F6D6, 0x1F6D7, prExtendedPictographic}, // E13.0  [2] (🛖..🛗)    hut..elevator
-	{0x1F6D8, 0x1F6DC, prExtendedPictographic}, // E0.0   [5] (🛘..🛜)    <reserved-1F6D8>..<reserved-1F6DC>
+	{0x1F6D8, 0x1F6DB, prExtendedPictographic}, // E0.0   [4] (🛘..🛛)    <reserved-1F6D8>..<reserved-1F6DB>
+	{0x1F6DC, 0x1F6DC, prExtendedPictographic}, // E15.0  [1] (🛜)       wireless
 	{0x1F6DD, 0x1F6DF, prExtendedPictographic}, // E14.0  [3] (🛝..🛟)    playground slide..ring buoy
 	{0x1F6E0, 0x1F6E5, prExtendedPictographic}, // E0.7   [6] (🛠️..🛥️)    hammer and wrench..motor boat
 	{0x1F6E6, 0x1F6E8, prExtendedPictographic}, // E0.0   [3] (🛦..🛨)    UP-POINTING MILITARY AIRPLANE..UP-POINTING SMALL AIRPLANE
@@ -1757,7 +1785,7 @@ var workBreakCodePoints = [][3]int{
 	{0x1F6FA, 0x1F6FA, prExtendedPictographic}, // E12.0  [1] (🛺)       auto rickshaw
 	{0x1F6FB, 0x1F6FC, prExtendedPictographic}, // E13.0  [2] (🛻..🛼)    pickup truck..roller skate
 	{0x1F6FD, 0x1F6FF, prExtendedPictographic}, // E0.0   [3] (🛽..🛿)    <reserved-1F6FD>..<reserved-1F6FF>
-	{0x1F774, 0x1F77F, prExtendedPictographic}, // E0.0  [12] (🝴..🝿)    <reserved-1F774>..<reserved-1F77F>
+	{0x1F774, 0x1F77F, prExtendedPictographic}, // E0.0  [12] (🝴..🝿)    LOT OF FORTUNE..ORCUS
 	{0x1F7D5, 0x1F7DF, prExtendedPictographic}, // E0.0  [11] (🟕..🟟)    CIRCLED TRIANGLE..<reserved-1F7DF>
 	{0x1F7E0, 0x1F7EB, prExtendedPictographic}, // E12.0 [12] (🟠..🟫)    orange circle..brown square
 	{0x1F7EC, 0x1F7EF, prExtendedPictographic}, // E0.0   [4] (🟬..🟯)    <reserved-1F7EC>..<reserved-1F7EF>
@@ -1816,30 +1844,37 @@ var workBreakCodePoints = [][3]int{
 	{0x1FA00, 0x1FA6F, prExtendedPictographic}, // E0.0 [112] (🨀..🩯)    NEUTRAL CHESS KING..<reserved-1FA6F>
 	{0x1FA70, 0x1FA73, prExtendedPictographic}, // E12.0  [4] (🩰..🩳)    ballet shoes..shorts
 	{0x1FA74, 0x1FA74, prExtendedPictographic}, // E13.0  [1] (🩴)       thong sandal
-	{0x1FA75, 0x1FA77, prExtendedPictographic}, // E0.0   [3] (🩵..🩷)    <reserved-1FA75>..<reserved-1FA77>
+	{0x1FA75, 0x1FA77, prExtendedPictographic}, // E15.0  [3] (🩵..🩷)    light blue heart..pink heart
 	{0x1FA78, 0x1FA7A, prExtendedPictographic}, // E12.0  [3] (🩸..🩺)    drop of blood..stethoscope
 	{0x1FA7B, 0x1FA7C, prExtendedPictographic}, // E14.0  [2] (🩻..🩼)    x-ray..crutch
 	{0x1FA7D, 0x1FA7F, prExtendedPictographic}, // E0.0   [3] (🩽..🩿)    <reserved-1FA7D>..<reserved-1FA7F>
 	{0x1FA80, 0x1FA82, prExtendedPictographic}, // E12.0  [3] (🪀..🪂)    yo-yo..parachute
 	{0x1FA83, 0x1FA86, prExtendedPictographic}, // E13.0  [4] (🪃..🪆)    boomerang..nesting dolls
-	{0x1FA87, 0x1FA8F, prExtendedPictographic}, // E0.0   [9] (🪇..🪏)    <reserved-1FA87>..<reserved-1FA8F>
+	{0x1FA87, 0x1FA88, prExtendedPictographic}, // E15.0  [2] (🪇..🪈)    maracas..flute
+	{0x1FA89, 0x1FA8F, prExtendedPictographic}, // E0.0   [7] (🪉..🪏)    <reserved-1FA89>..<reserved-1FA8F>
 	{0x1FA90, 0x1FA95, prExtendedPictographic}, // E12.0  [6] (🪐..🪕)    ringed planet..banjo
 	{0x1FA96, 0x1FAA8, prExtendedPictographic}, // E13.0 [19] (🪖..🪨)    military helmet..rock
 	{0x1FAA9, 0x1FAAC, prExtendedPictographic}, // E14.0  [4] (🪩..🪬)    mirror ball..hamsa
-	{0x1FAAD, 0x1FAAF, prExtendedPictographic}, // E0.0   [3] (🪭..🪯)    <reserved-1FAAD>..<reserved-1FAAF>
+	{0x1FAAD, 0x1FAAF, prExtendedPictographic}, // E15.0  [3] (🪭..🪯)    folding hand fan..khanda
 	{0x1FAB0, 0x1FAB6, prExtendedPictographic}, // E13.0  [7] (🪰..🪶)    fly..feather
 	{0x1FAB7, 0x1FABA, prExtendedPictographic}, // E14.0  [4] (🪷..🪺)    lotus..nest with eggs
-	{0x1FABB, 0x1FABF, prExtendedPictographic}, // E0.0   [5] (🪻..🪿)    <reserved-1FABB>..<reserved-1FABF>
+	{0x1FABB, 0x1FABD, prExtendedPictographic}, // E15.0  [3] (🪻..🪽)    hyacinth..wing
+	{0x1FABE, 0x1FABE, prExtendedPictographic}, // E0.0   [1] (🪾)       <reserved-1FABE>
+	{0x1FABF, 0x1FABF, prExtendedPictographic}, // E15.0  [1] (🪿)       goose
 	{0x1FAC0, 0x1FAC2, prExtendedPictographic}, // E13.0  [3] (🫀..🫂)    anatomical heart..people hugging
 	{0x1FAC3, 0x1FAC5, prExtendedPictographic}, // E14.0  [3] (🫃..🫅)    pregnant man..person with crown
-	{0x1FAC6, 0x1FACF, prExtendedPictographic}, // E0.0  [10] (🫆..🫏)    <reserved-1FAC6>..<reserved-1FACF>
+	{0x1FAC6, 0x1FACD, prExtendedPictographic}, // E0.0   [8] (🫆..🫍)    <reserved-1FAC6>..<reserved-1FACD>
+	{0x1FACE, 0x1FACF, prExtendedPictographic}, // E15.0  [2] (🫎..🫏)    moose..donkey
 	{0x1FAD0, 0x1FAD6, prExtendedPictographic}, // E13.0  [7] (🫐..🫖)    blueberries..teapot
 	{0x1FAD7, 0x1FAD9, prExtendedPictographic}, // E14.0  [3] (🫗..🫙)    pouring liquid..jar
-	{0x1FADA, 0x1FADF, prExtendedPictographic}, // E0.0   [6] (🫚..🫟)    <reserved-1FADA>..<reserved-1FADF>
+	{0x1FADA, 0x1FADB, prExtendedPictographic}, // E15.0  [2] (🫚..🫛)    ginger root..pea pod
+	{0x1FADC, 0x1FADF, prExtendedPictographic}, // E0.0   [4] (🫜..🫟)    <reserved-1FADC>..<reserved-1FADF>
 	{0x1FAE0, 0x1FAE7, prExtendedPictographic}, // E14.0  [8] (🫠..🫧)    melting face..bubbles
-	{0x1FAE8, 0x1FAEF, prExtendedPictographic}, // E0.0   [8] (🫨..🫯)    <reserved-1FAE8>..<reserved-1FAEF>
+	{0x1FAE8, 0x1FAE8, prExtendedPictographic}, // E15.0  [1] (🫨)       shaking face
+	{0x1FAE9, 0x1FAEF, prExtendedPictographic}, // E0.0   [7] (🫩..🫯)    <reserved-1FAE9>..<reserved-1FAEF>
 	{0x1FAF0, 0x1FAF6, prExtendedPictographic}, // E14.0  [7] (🫰..🫶)    hand with index finger and thumb crossed..heart hands
-	{0x1FAF7, 0x1FAFF, prExtendedPictographic}, // E0.0   [9] (🫷..🫿)    <reserved-1FAF7>..<reserved-1FAFF>
+	{0x1FAF7, 0x1FAF8, prExtendedPictographic}, // E15.0  [2] (🫷..🫸)    leftwards pushing hand..rightwards pushing hand
+	{0x1FAF9, 0x1FAFF, prExtendedPictographic}, // E0.0   [7] (🫹..🫿)    <reserved-1FAF9>..<reserved-1FAFF>
 	{0x1FBF0, 0x1FBF9, prNumeric},              // Nd  [10] SEGMENTED DIGIT ZERO..SEGMENTED DIGIT NINE
 	{0x1FC00, 0x1FFFD, prExtendedPictographic}, // E0.0[1022] (🰀..🿽)    <reserved-1FC00>..<reserved-1FFFD>
 	{0xE0001, 0xE0001, prFormat},               // Cf       LANGUAGE TAG

vendor/github.com/rivo/uniseg/wordrules.go

@@ -22,82 +22,121 @@ const (
 	wbZWJBit = 16 // This bit is set for any states followed by at least one zero-width joiner (see WB4 and WB3c).
 )
 
-// The word break parser's breaking instructions.
-const (
-	wbDontBreak = iota
-	wbBreak
-)
-
-// The word break parser's state transitions. It's anologous to grTransitions,
-// see comments there for details. Unicode version 14.0.0.
-var wbTransitions = map[[2]int][3]int{
+// wbTransitions implements the word break parser's state transitions. It's
+// anologous to [grTransitions], see comments there for details.
+//
+// Unicode version 15.0.0.
+func wbTransitions(state, prop int) (newState int, wordBreak bool, rule int) {
+	switch uint64(state) | uint64(prop)<<32 {
 	// WB3b.
-	{wbAny, prNewline}: {wbNewline, wbBreak, 32},
-	{wbAny, prCR}:      {wbCR, wbBreak, 32},
-	{wbAny, prLF}:      {wbLF, wbBreak, 32},
+	case wbAny | prNewline<<32:
+		return wbNewline, true, 32
+	case wbAny | prCR<<32:
+		return wbCR, true, 32
+	case wbAny | prLF<<32:
+		return wbLF, true, 32
 
 	// WB3a.
-	{wbNewline, prAny}: {wbAny, wbBreak, 31},
-	{wbCR, prAny}:      {wbAny, wbBreak, 31},
-	{wbLF, prAny}:      {wbAny, wbBreak, 31},
+	case wbNewline | prAny<<32:
+		return wbAny, true, 31
+	case wbCR | prAny<<32:
+		return wbAny, true, 31
+	case wbLF | prAny<<32:
+		return wbAny, true, 31
 
 	// WB3.
-	{wbCR, prLF}: {wbLF, wbDontBreak, 30},
+	case wbCR | prLF<<32:
+		return wbLF, false, 30
 
 	// WB3d.
-	{wbAny, prWSegSpace}:       {wbWSegSpace, wbBreak, 9990},
-	{wbWSegSpace, prWSegSpace}: {wbWSegSpace, wbDontBreak, 34},
+	case wbAny | prWSegSpace<<32:
+		return wbWSegSpace, true, 9990
+	case wbWSegSpace | prWSegSpace<<32:
+		return wbWSegSpace, false, 34
 
 	// WB5.
-	{wbAny, prALetter}:               {wbALetter, wbBreak, 9990},
-	{wbAny, prHebrewLetter}:          {wbHebrewLetter, wbBreak, 9990},
-	{wbALetter, prALetter}:           {wbALetter, wbDontBreak, 50},
-	{wbALetter, prHebrewLetter}:      {wbHebrewLetter, wbDontBreak, 50},
-	{wbHebrewLetter, prALetter}:      {wbALetter, wbDontBreak, 50},
-	{wbHebrewLetter, prHebrewLetter}: {wbHebrewLetter, wbDontBreak, 50},
+	case wbAny | prALetter<<32:
+		return wbALetter, true, 9990
+	case wbAny | prHebrewLetter<<32:
+		return wbHebrewLetter, true, 9990
+	case wbALetter | prALetter<<32:
+		return wbALetter, false, 50
+	case wbALetter | prHebrewLetter<<32:
+		return wbHebrewLetter, false, 50
+	case wbHebrewLetter | prALetter<<32:
+		return wbALetter, false, 50
+	case wbHebrewLetter | prHebrewLetter<<32:
+		return wbHebrewLetter, false, 50
 
 	// WB7. Transitions to wbWB7 handled by transitionWordBreakState().
-	{wbWB7, prALetter}:      {wbALetter, wbDontBreak, 70},
-	{wbWB7, prHebrewLetter}: {wbHebrewLetter, wbDontBreak, 70},
+	case wbWB7 | prALetter<<32:
+		return wbALetter, false, 70
+	case wbWB7 | prHebrewLetter<<32:
+		return wbHebrewLetter, false, 70
 
 	// WB7a.
-	{wbHebrewLetter, prSingleQuote}: {wbAny, wbDontBreak, 71},
+	case wbHebrewLetter | prSingleQuote<<32:
+		return wbAny, false, 71
 
 	// WB7c. Transitions to wbWB7c handled by transitionWordBreakState().
-	{wbWB7c, prHebrewLetter}: {wbHebrewLetter, wbDontBreak, 73},
+	case wbWB7c | prHebrewLetter<<32:
+		return wbHebrewLetter, false, 73
 
 	// WB8.
-	{wbAny, prNumeric}:     {wbNumeric, wbBreak, 9990},
-	{wbNumeric, prNumeric}: {wbNumeric, wbDontBreak, 80},
+	case wbAny | prNumeric<<32:
+		return wbNumeric, true, 9990
+	case wbNumeric | prNumeric<<32:
+		return wbNumeric, false, 80
 
 	// WB9.
-	{wbALetter, prNumeric}:      {wbNumeric, wbDontBreak, 90},
-	{wbHebrewLetter, prNumeric}: {wbNumeric, wbDontBreak, 90},
+	case wbALetter | prNumeric<<32:
+		return wbNumeric, false, 90
+	case wbHebrewLetter | prNumeric<<32:
+		return wbNumeric, false, 90
 
 	// WB10.
-	{wbNumeric, prALetter}:      {wbALetter, wbDontBreak, 100},
-	{wbNumeric, prHebrewLetter}: {wbHebrewLetter, wbDontBreak, 100},
+	case wbNumeric | prALetter<<32:
+		return wbALetter, false, 100
+	case wbNumeric | prHebrewLetter<<32:
+		return wbHebrewLetter, false, 100
 
 	// WB11. Transitions to wbWB11 handled by transitionWordBreakState().
-	{wbWB11, prNumeric}: {wbNumeric, wbDontBreak, 110},
+	case wbWB11 | prNumeric<<32:
+		return wbNumeric, false, 110
 
 	// WB13.
-	{wbAny, prKatakana}:      {wbKatakana, wbBreak, 9990},
-	{wbKatakana, prKatakana}: {wbKatakana, wbDontBreak, 130},
+	case wbAny | prKatakana<<32:
+		return wbKatakana, true, 9990
+	case wbKatakana | prKatakana<<32:
+		return wbKatakana, false, 130
 
 	// WB13a.
-	{wbAny, prExtendNumLet}:          {wbExtendNumLet, wbBreak, 9990},
-	{wbALetter, prExtendNumLet}:      {wbExtendNumLet, wbDontBreak, 131},
-	{wbHebrewLetter, prExtendNumLet}: {wbExtendNumLet, wbDontBreak, 131},
-	{wbNumeric, prExtendNumLet}:      {wbExtendNumLet, wbDontBreak, 131},
-	{wbKatakana, prExtendNumLet}:     {wbExtendNumLet, wbDontBreak, 131},
-	{wbExtendNumLet, prExtendNumLet}: {wbExtendNumLet, wbDontBreak, 131},
+	case wbAny | prExtendNumLet<<32:
+		return wbExtendNumLet, true, 9990
+	case wbALetter | prExtendNumLet<<32:
+		return wbExtendNumLet, false, 131
+	case wbHebrewLetter | prExtendNumLet<<32:
+		return wbExtendNumLet, false, 131
+	case wbNumeric | prExtendNumLet<<32:
+		return wbExtendNumLet, false, 131
+	case wbKatakana | prExtendNumLet<<32:
+		return wbExtendNumLet, false, 131
+	case wbExtendNumLet | prExtendNumLet<<32:
+		return wbExtendNumLet, false, 131
 
 	// WB13b.
-	{wbExtendNumLet, prALetter}:      {wbALetter, wbDontBreak, 132},
-	{wbExtendNumLet, prHebrewLetter}: {wbHebrewLetter, wbDontBreak, 132},
-	{wbExtendNumLet, prNumeric}:      {wbNumeric, wbDontBreak, 132},
-	{wbExtendNumLet, prKatakana}:     {prKatakana, wbDontBreak, 132},
+	case wbExtendNumLet | prALetter<<32:
+		return wbALetter, false, 132
+	case wbExtendNumLet | prHebrewLetter<<32:
+		return wbHebrewLetter, false, 132
+	case wbExtendNumLet | prNumeric<<32:
+		return wbNumeric, false, 132
+	case wbExtendNumLet | prKatakana<<32:
+		return wbKatakana, false, 132
+
+	default:
+		return -1, false, -1
+	}
 }
 
 // transitionWordBreakState determines the new state of the word break parser
@@ -141,30 +180,27 @@ func transitionWordBreakState(state int, r rune, b []byte, str string) (newState
 
 	// Find the applicable transition in the table.
 	var rule int
-	transition, ok := wbTransitions[[2]int{state, nextProperty}]
-	if ok {
-		// We have a specific transition. We'll use it.
-		newState, wordBreak, rule = transition[0], transition[1] == wbBreak, transition[2]
-	} else {
+	newState, wordBreak, rule = wbTransitions(state, nextProperty)
+	if newState < 0 {
 		// No specific transition found. Try the less specific ones.
-		transAnyProp, okAnyProp := wbTransitions[[2]int{state, prAny}]
-		transAnyState, okAnyState := wbTransitions[[2]int{wbAny, nextProperty}]
-		if okAnyProp && okAnyState {
+		anyPropState, anyPropWordBreak, anyPropRule := wbTransitions(state, prAny)
+		anyStateState, anyStateWordBreak, anyStateRule := wbTransitions(wbAny, nextProperty)
+		if anyPropState >= 0 && anyStateState >= 0 {
 			// Both apply. We'll use a mix (see comments for grTransitions).
-			newState, wordBreak, rule = transAnyState[0], transAnyState[1] == wbBreak, transAnyState[2]
-			if transAnyProp[2] < transAnyState[2] {
-				wordBreak, rule = transAnyProp[1] == wbBreak, transAnyProp[2]
+			newState, wordBreak, rule = anyStateState, anyStateWordBreak, anyStateRule
+			if anyPropRule < anyStateRule {
+				wordBreak, rule = anyPropWordBreak, anyPropRule
 			}
-		} else if okAnyProp {
+		} else if anyPropState >= 0 {
 			// We only have a specific state.
-			newState, wordBreak, rule = transAnyProp[0], transAnyProp[1] == wbBreak, transAnyProp[2]
+			newState, wordBreak, rule = anyPropState, anyPropWordBreak, anyPropRule
 			// This branch will probably never be reached because okAnyState will
 			// always be true given the current transition map. But we keep it here
 			// for future modifications to the transition map where this may not be
 			// true anymore.
-		} else if okAnyState {
+		} else if anyStateState >= 0 {
 			// We only have a specific property.
-			newState, wordBreak, rule = transAnyState[0], transAnyState[1] == wbBreak, transAnyState[2]
+			newState, wordBreak, rule = anyStateState, anyStateWordBreak, anyStateRule
 		} else {
 			// No known transition. WB999: Any ÷ Any.
 			newState, wordBreak, rule = wbAny, true, 9990

vendor/github.com/valyala/fasthttp/.gitignore

@@ -6,3 +6,4 @@ tags
 .vscode
 .DS_Store
 vendor/
+testdata/fuzz

vendor/github.com/valyala/fasthttp/.golangci.yml

@@ -21,13 +21,11 @@ linters:
     - gocognit
     - goconst
     - gocyclo
-    - godot
     - goerr113
     - gomnd
     - gosec
     - inamedparam
     - ireturn
-    - lll
     - maintidx
     - nakedret
     - nestif
@@ -36,8 +34,6 @@ linters:
     - nonamedreturns
     - paralleltest
     - perfsprint
-    - revive
-    - stylecheck
     - testableexamples
     - testpackage
     - thelper
@@ -45,8 +41,6 @@ linters:
     - unparam
     - usestdlibvars
     - varnamelen
-    - wastedassign
-    - whitespace
     - wrapcheck
     - wsl
 
@@ -63,8 +57,33 @@ linters:
     - varcheck
 
 linters-settings:
+  revive:
+    # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md
+    rules:
+      - name: use-any
+  lll:
+    line-length: 130
+  stylecheck:
+    checks: [
+      "all",
+      "-ST1000", # at least one file in a package should have a package comment
+    ]
+  gocritic:
+    enabled-checks:
+      - emptyStringTest
+
+issues:
   # Show all issues from a linter.
   max-issues-per-linter: 0
 
   # Show all issues with the same text.
   max-same-issues: 0
+
+  include:
+    - EXC0011 # include issues about comments from `stylecheck`
+
+  exclude-rules:
+    # Exclude some linters from running on tests files.
+    - path: _test\.go
+      linters:
+        - lll

vendor/github.com/valyala/fasthttp/README.md

@@ -600,7 +600,7 @@ This is an **unsafe** way, the result string and `[]byte` buffer share the same
 
 * *Which GO versions are supported by fasthttp?*
 
-  Go 1.15.x. Older versions won't be supported.
+  Go 1.18.x. Older versions won't be supported.
 
 * *Please provide real benchmark data and server information*
 

vendor/github.com/valyala/fasthttp/args.go

@@ -32,7 +32,7 @@ func ReleaseArgs(a *Args) {
 }
 
 var argsPool = &sync.Pool{
-	New: func() interface{} {
+	New: func() any {
 		return &Args{}
 	},
 }
@@ -118,7 +118,7 @@ func (a *Args) QueryString() []byte {
 
 // Sort sorts Args by key and then value using 'f' as comparison function.
 //
-// For example args.Sort(bytes.Compare)
+// For example args.Sort(bytes.Compare).
 func (a *Args) Sort(f func(x, y []byte) int) {
 	sort.SliceStable(a.args, func(i, j int) bool {
 		n := f(a.args[i].key, a.args[j].key)
@@ -229,7 +229,7 @@ func (a *Args) SetBytesKV(key, value []byte) {
 
 // SetNoValue sets only 'key' as argument without the '='.
 //
-// Only key in argument, like key1&key2
+// Only key in argument, like key1&key2.
 func (a *Args) SetNoValue(key string) {
 	a.args = setArg(a.args, key, "", argsNoValue)
 }
@@ -551,7 +551,7 @@ func decodeArgAppend(dst, src []byte) []byte {
 		return append(dst, src...)
 	}
 
-	idx := 0
+	var idx int
 	switch {
 	case idxPercent == -1:
 		idx = idxPlus

vendor/github.com/valyala/fasthttp/brotli.go

@@ -134,17 +134,17 @@ func WriteBrotliLevel(w io.Writer, p []byte, level int) (int, error) {
 
 var (
 	stacklessWriteBrotliOnce sync.Once
-	stacklessWriteBrotliFunc func(ctx interface{}) bool
+	stacklessWriteBrotliFunc func(ctx any) bool
 )
 
-func stacklessWriteBrotli(ctx interface{}) {
+func stacklessWriteBrotli(ctx any) {
 	stacklessWriteBrotliOnce.Do(func() {
 		stacklessWriteBrotliFunc = stackless.NewFunc(nonblockingWriteBrotli)
 	})
 	stacklessWriteBrotliFunc(ctx)
 }
 
-func nonblockingWriteBrotli(ctxv interface{}) {
+func nonblockingWriteBrotli(ctxv any) {
 	ctx := ctxv.(*compressCtx)
 	zw := acquireRealBrotliWriter(ctx.w, ctx.level)
 

vendor/github.com/valyala/fasthttp/bytesconv_table.go

@@ -4,7 +4,8 @@ package fasthttp
 // See bytesconv_table_gen.go for more information about these tables.
 
 const hex2intTable = "\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x00\x01\x02\x03\x04\x05\x06\a\b\t\x10\x10\x10\x10\x10\x10\x10\n\v\f\r\x0e\x0f\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\n\v\f\r\x0e\x0f\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10"
-const toLowerTable = "\x00\x01\x02\x03\x04\x05\x06\a\b\t\n\v\f\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u007f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"
-const toUpperTable = "\x00\x01\x02\x03\x04\x05\x06\a\b\t\n\v\f\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~\u007f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"
+const toLowerTable = "\x00\x01\x02\x03\x04\x05\x06\a\b\t\n\v\f\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"
+const toUpperTable = "\x00\x01\x02\x03\x04\x05\x06\a\b\t\n\v\f\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"
 const quotedArgShouldEscapeTable = "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x01\x01\x01\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x01\x01\x01\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x01\x01\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
 const quotedPathShouldEscapeTable = "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\x01\x00\x01\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x01\x01\x01\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x01\x01\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+const tcharTable = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x01\x01\x01\x01\x01\x00\x00\x01\x01\x00\x01\x01\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\x00\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\x01\x00\x01\x00"

vendor/github.com/valyala/fasthttp/client.go

@@ -185,7 +185,15 @@ type Client struct {
 
 	// Callback for establishing new connections to hosts.
 	//
-	// Default Dial is used if not set.
+	// Default DialTimeout is used if not set.
+	DialTimeout DialFuncWithTimeout
+
+	// Callback for establishing new connections to hosts.
+	//
+	// Note that if Dial is set instead of DialTimeout, Dial will ignore Request timeout.
+	// If you want the tcp dial process to account for request timeouts, use DialTimeout instead.
+	//
+	// If not set, DialTimeout is used.
 	Dial DialFunc
 
 	// Attempt to connect to both ipv4 and ipv6 addresses if set to true.
@@ -218,7 +226,7 @@ type Client struct {
 	// By default connection duration is unlimited.
 	MaxConnDuration time.Duration
 
-	// Maximum number of attempts for idempotent calls
+	// Maximum number of attempts for idempotent calls.
 	//
 	// DefaultMaxIdemponentCallAttempts is used if not set.
 	MaxIdemponentCallAttempts int
@@ -270,7 +278,7 @@ type Client struct {
 	//     * cONTENT-lenGTH -> Content-Length
 	DisableHeaderNamesNormalizing bool
 
-	// Path values are sent as-is without normalization
+	// Path values are sent as-is without normalization.
 	//
 	// Disabled path normalization may be useful for proxying incoming requests
 	// to servers that are expecting paths to be forwarded as-is.
@@ -281,18 +289,18 @@ type Client struct {
 
 	// Maximum duration for waiting for a free connection.
 	//
-	// By default will not waiting, return ErrNoFreeConns immediately
+	// By default will not waiting, return ErrNoFreeConns immediately.
 	MaxConnWaitTimeout time.Duration
 
 	// RetryIf controls whether a retry should be attempted after an error.
 	//
-	// By default will use isIdempotent function
+	// By default will use isIdempotent function.
 	RetryIf RetryIfFunc
 
 	// Connection pool strategy. Can be either LIFO or FIFO (default).
 	ConnPoolStrategy ConnPoolStrategyType
 
-	// StreamResponseBody enables response body streaming
+	// StreamResponseBody enables response body streaming.
 	StreamResponseBody bool
 
 	// ConfigureClient configures the fasthttp.HostClient.
@@ -505,6 +513,7 @@ func (c *Client) Do(req *Request, resp *Response) error {
 				Name:                          c.Name,
 				NoDefaultUserAgentHeader:      c.NoDefaultUserAgentHeader,
 				Dial:                          c.Dial,
+				DialTimeout:                   c.DialTimeout,
 				DialDualStack:                 c.DialDualStack,
 				IsTLS:                         isTLS,
 				TLSConfig:                     c.TLSConfig,
@@ -624,7 +633,22 @@ const DefaultMaxIdemponentCallAttempts = 5
 //   - foobar.com:8080
 type DialFunc func(addr string) (net.Conn, error)
 
-// RetryIfFunc signature of retry if function
+// DialFuncWithTimeout must establish connection to addr.
+// Unlike DialFunc, it also accepts a timeout.
+//
+// There is no need in establishing TLS (SSL) connection for https.
+// The client automatically converts connection to TLS
+// if HostClient.IsTLS is set.
+//
+// TCP address passed to DialFuncWithTimeout always contains host and port.
+// Example TCP addr values:
+//
+//   - foobar.com:80
+//   - foobar.com:443
+//   - foobar.com:8080
+type DialFuncWithTimeout func(addr string, timeout time.Duration) (net.Conn, error)
+
+// RetryIfFunc signature of retry if function.
 //
 // Request argument passed to RetryIfFunc, if there are any request errors.
 type RetryIfFunc func(request *Request) bool
@@ -634,7 +658,7 @@ type RoundTripper interface {
 	RoundTrip(hc *HostClient, req *Request, resp *Response) (retry bool, err error)
 }
 
-// ConnPoolStrategyType define strategy of connection pool enqueue/dequeue
+// ConnPoolStrategyType define strategy of connection pool enqueue/dequeue.
 type ConnPoolStrategyType int
 
 const (
@@ -656,7 +680,7 @@ type HostClient struct {
 	noCopy noCopy
 
 	// Comma-separated list of upstream HTTP server host addresses,
-	// which are passed to Dial in a round-robin manner.
+	// which are passed to Dial or DialTimeout in a round-robin manner.
 	//
 	// Each address may contain port if default dialer is used.
 	// For example,
@@ -673,16 +697,24 @@ type HostClient struct {
 	// User-Agent header to be excluded from the Request.
 	NoDefaultUserAgentHeader bool
 
-	// Callback for establishing new connection to the host.
+	// Callback for establishing new connections to hosts.
 	//
-	// Default Dial is used if not set.
+	// Default DialTimeout is used if not set.
+	DialTimeout DialFuncWithTimeout
+
+	// Callback for establishing new connections to hosts.
+	//
+	// Note that if Dial is set instead of DialTimeout, Dial will ignore Request timeout.
+	// If you want the tcp dial process to account for request timeouts, use DialTimeout instead.
+	//
+	// If not set, DialTimeout is used.
 	Dial DialFunc
 
 	// Attempt to connect to both ipv4 and ipv6 host addresses
 	// if set to true.
 	//
 	// This option is used only if default TCP dialer is used,
-	// i.e. if Dial is blank.
+	// i.e. if Dial and DialTimeout are blank.
 	//
 	// By default client connects only to ipv4 addresses,
 	// since unfortunately ipv6 remains broken in many networks worldwide :)
@@ -714,7 +746,7 @@ type HostClient struct {
 	// after DefaultMaxIdleConnDuration.
 	MaxIdleConnDuration time.Duration
 
-	// Maximum number of attempts for idempotent calls
+	// Maximum number of attempts for idempotent calls.
 	//
 	// DefaultMaxIdemponentCallAttempts is used if not set.
 	MaxIdemponentCallAttempts int
@@ -766,7 +798,7 @@ type HostClient struct {
 	//     * cONTENT-lenGTH -> Content-Length
 	DisableHeaderNamesNormalizing bool
 
-	// Path values are sent as-is without normalization
+	// Path values are sent as-is without normalization.
 	//
 	// Disabled path normalization may be useful for proxying incoming requests
 	// to servers that are expecting paths to be forwarded as-is.
@@ -775,7 +807,7 @@ type HostClient struct {
 	// extra slashes are removed, special characters are encoded.
 	DisablePathNormalizing bool
 
-	// Will not log potentially sensitive content in error logs
+	// Will not log potentially sensitive content in error logs.
 	//
 	// This option is useful for servers that handle sensitive data
 	// in the request/response.
@@ -799,7 +831,7 @@ type HostClient struct {
 	// Connection pool strategy. Can be either LIFO or FIFO (default).
 	ConnPoolStrategy ConnPoolStrategyType
 
-	// StreamResponseBody enables response body streaming
+	// StreamResponseBody enables response body streaming.
 	StreamResponseBody bool
 
 	lastUseTime uint32
@@ -840,7 +872,7 @@ type clientConn struct {
 
 var startTimeUnix = time.Now().Unix()
 
-// LastUseTime returns time the client was last used
+// LastUseTime returns time the client was last used.
 func (c *HostClient) LastUseTime() time.Time {
 	n := atomic.LoadUint32(&c.lastUseTime)
 	return time.Unix(startTimeUnix+int64(n), 0)
@@ -1015,7 +1047,8 @@ var (
 	ErrTooManyRedirects = errors.New("too many redirects detected when doing the request")
 
 	// HostClients are only able to follow redirects to the same protocol.
-	ErrHostClientRedirectToDifferentScheme = errors.New("HostClient can't follow redirects to a different protocol, please use Client instead")
+	ErrHostClientRedirectToDifferentScheme = errors.New("HostClient can't follow redirects to a different protocol," +
+		" please use Client instead")
 )
 
 const defaultMaxRedirectsCount = 16
@@ -1037,7 +1070,9 @@ func doRequestFollowRedirectsBuffer(req *Request, dst []byte, url string, c clie
 	return statusCode, body, err
 }
 
-func doRequestFollowRedirects(req *Request, resp *Response, url string, maxRedirectsCount int, c clientDoer) (statusCode int, body []byte, err error) {
+func doRequestFollowRedirects(
+	req *Request, resp *Response, url string, maxRedirectsCount int, c clientDoer,
+) (statusCode int, body []byte, err error) {
 	redirectsCount := 0
 
 	for {
@@ -1659,7 +1694,7 @@ func (c *HostClient) decConnsCount() {
 	}
 }
 
-// ConnsCount returns connection count of HostClient
+// ConnsCount returns connection count of HostClient.
 func (c *HostClient) ConnsCount() int {
 	c.connsLock.Lock()
 	defer c.connsLock.Unlock()
@@ -1714,7 +1749,7 @@ func (c *HostClient) releaseConn(cc *clientConn) {
 }
 
 func (c *HostClient) acquireWriter(conn net.Conn) *bufio.Writer {
-	var v interface{}
+	var v any
 	if c.clientWriterPool != nil {
 		v = c.clientWriterPool.Get()
 		if v == nil {
@@ -1749,7 +1784,7 @@ func (c *HostClient) releaseWriter(bw *bufio.Writer) {
 }
 
 func (c *HostClient) acquireReader(conn net.Conn) *bufio.Reader {
-	var v interface{}
+	var v any
 	if c.clientReaderPool != nil {
 		v = c.clientReaderPool.Get()
 		if v == nil {
@@ -1790,7 +1825,7 @@ func newClientTLSConfig(c *tls.Config, addr string) *tls.Config {
 		c = c.Clone()
 	}
 
-	if len(c.ServerName) == 0 {
+	if c.ServerName == "" {
 		serverName := tlsServerName(addr)
 		if serverName == "*" {
 			c.InsecureSkipVerify = true
@@ -1827,7 +1862,8 @@ func (c *HostClient) nextAddr() string {
 }
 
 func (c *HostClient) dialHostHard(dialTimeout time.Duration) (conn net.Conn, err error) {
-	// use dialTimeout to control the timeout of each dial. It does not work if dialTimeout is 0 or dial has been set.
+	// use dialTimeout to control the timeout of each dial. It does not work if dialTimeout is 0 or if
+	// c.DialTimeout has not been set and c.Dial has been set.
 	// attempt to dial all the available hosts before giving up.
 
 	c.addrsLock.Lock()
@@ -1839,16 +1875,6 @@ func (c *HostClient) dialHostHard(dialTimeout time.Duration) (conn net.Conn, err
 		n = 1
 	}
 
-	dial := c.Dial
-	if dialTimeout != 0 && dial == nil {
-		dial = func(addr string) (net.Conn, error) {
-			if c.DialDualStack {
-				return DialDualStackTimeout(addr, dialTimeout)
-			}
-			return DialTimeout(addr, dialTimeout)
-		}
-	}
-
 	timeout := c.ReadTimeout + c.WriteTimeout
 	if timeout <= 0 {
 		timeout = DefaultDialTimeout
@@ -1857,7 +1883,7 @@ func (c *HostClient) dialHostHard(dialTimeout time.Duration) (conn net.Conn, err
 	for n > 0 {
 		addr := c.nextAddr()
 		tlsConfig := c.cachedTLSConfig(addr)
-		conn, err = dialAddr(addr, dial, c.DialDualStack, c.IsTLS, tlsConfig, c.WriteTimeout)
+		conn, err = dialAddr(addr, c.Dial, c.DialTimeout, c.DialDualStack, c.IsTLS, tlsConfig, dialTimeout, c.WriteTimeout)
 		if err == nil {
 			return conn, nil
 		}
@@ -1916,22 +1942,17 @@ func tlsClientHandshake(rawConn net.Conn, tlsConfig *tls.Config, deadline time.T
 	return conn, nil
 }
 
-func dialAddr(addr string, dial DialFunc, dialDualStack, isTLS bool, tlsConfig *tls.Config, timeout time.Duration) (net.Conn, error) {
-	deadline := time.Now().Add(timeout)
-	if dial == nil {
-		if dialDualStack {
-			dial = DialDualStack
-		} else {
-			dial = Dial
-		}
-		addr = AddMissingPort(addr, isTLS)
-	}
-	conn, err := dial(addr)
+func dialAddr(
+	addr string, dial DialFunc, dialWithTimeout DialFuncWithTimeout, dialDualStack, isTLS bool,
+	tlsConfig *tls.Config, dialTimeout, writeTimeout time.Duration,
+) (net.Conn, error) {
+	deadline := time.Now().Add(writeTimeout)
+	conn, err := callDialFunc(addr, dial, dialWithTimeout, dialDualStack, isTLS, dialTimeout)
 	if err != nil {
 		return nil, err
 	}
 	if conn == nil {
-		return nil, errors.New("dialling unsuccessful. Please report this bug!")
+		return nil, errors.New("dialling unsuccessful. Please report this bug")
 	}
 
 	// We assume that any conn that has the Handshake() method is a TLS conn already.
@@ -1939,7 +1960,7 @@ func dialAddr(addr string, dial DialFunc, dialDualStack, isTLS bool, tlsConfig *
 	_, isTLSAlready := conn.(interface{ Handshake() error })
 
 	if isTLS && !isTLSAlready {
-		if timeout == 0 {
+		if writeTimeout == 0 {
 			return tls.Client(conn, tlsConfig), nil
 		}
 		return tlsClientHandshake(conn, tlsConfig, deadline)
@@ -1947,6 +1968,28 @@ func dialAddr(addr string, dial DialFunc, dialDualStack, isTLS bool, tlsConfig *
 	return conn, nil
 }
 
+func callDialFunc(
+	addr string, dial DialFunc, dialWithTimeout DialFuncWithTimeout, dialDualStack, isTLS bool, timeout time.Duration,
+) (net.Conn, error) {
+	if dialWithTimeout != nil {
+		return dialWithTimeout(addr, timeout)
+	}
+	if dial != nil {
+		return dial(addr)
+	}
+	addr = AddMissingPort(addr, isTLS)
+	if timeout > 0 {
+		if dialDualStack {
+			return DialDualStackTimeout(addr, timeout)
+		}
+		return DialTimeout(addr, timeout)
+	}
+	if dialDualStack {
+		return DialDualStack(addr)
+	}
+	return Dial(addr)
+}
+
 // AddMissingPort adds a port to a host if it is missing.
 // A literal IPv6 address in hostport must be enclosed in square
 // brackets, as in "[::1]:80", "[::1%lo0]:80".
@@ -1983,7 +2026,7 @@ func AddMissingPort(addr string, isTLS bool) string {
 // These three options are racing against each other and use
 // wantConn to coordinate and agree about the winning outcome.
 //
-// inspired by net/http/transport.go
+// Inspired by net/http/transport.go.
 type wantConn struct {
 	ready chan struct{}
 	mu    sync.Mutex // protects conn, err, close(ready)
@@ -2038,7 +2081,7 @@ func (w *wantConn) cancel(c *HostClient, err error) {
 
 // A wantConnQueue is a queue of wantConns.
 //
-// inspired by net/http/transport.go
+// Inspired by net/http/transport.go.
 type wantConnQueue struct {
 	// This is a queue, not a dequeue.
 	// It is split into two stages - head[headPos:] and tail.
@@ -2591,7 +2634,7 @@ func (c *pipelineConnClient) init() {
 
 func (c *pipelineConnClient) worker() error {
 	tlsConfig := c.cachedTLSConfig()
-	conn, err := dialAddr(c.Addr, c.Dial, c.DialDualStack, c.IsTLS, tlsConfig, c.WriteTimeout)
+	conn, err := dialAddr(c.Addr, c.Dial, nil, c.DialDualStack, c.IsTLS, tlsConfig, 0, c.WriteTimeout)
 	if err != nil {
 		return err
 	}

vendor/github.com/valyala/fasthttp/compress.go

@@ -179,17 +179,17 @@ func WriteGzipLevel(w io.Writer, p []byte, level int) (int, error) {
 
 var (
 	stacklessWriteGzipOnce sync.Once
-	stacklessWriteGzipFunc func(ctx interface{}) bool
+	stacklessWriteGzipFunc func(ctx any) bool
 )
 
-func stacklessWriteGzip(ctx interface{}) {
+func stacklessWriteGzip(ctx any) {
 	stacklessWriteGzipOnce.Do(func() {
 		stacklessWriteGzipFunc = stackless.NewFunc(nonblockingWriteGzip)
 	})
 	stacklessWriteGzipFunc(ctx)
 }
 
-func nonblockingWriteGzip(ctxv interface{}) {
+func nonblockingWriteGzip(ctxv any) {
 	ctx := ctxv.(*compressCtx)
 	zw := acquireRealGzipWriter(ctx.w, ctx.level)
 
@@ -282,17 +282,17 @@ func WriteDeflateLevel(w io.Writer, p []byte, level int) (int, error) {
 
 var (
 	stacklessWriteDeflateOnce sync.Once
-	stacklessWriteDeflateFunc func(ctx interface{}) bool
+	stacklessWriteDeflateFunc func(ctx any) bool
 )
 
-func stacklessWriteDeflate(ctx interface{}) {
+func stacklessWriteDeflate(ctx any) {
 	stacklessWriteDeflateOnce.Do(func() {
 		stacklessWriteDeflateFunc = stackless.NewFunc(nonblockingWriteDeflate)
 	})
 	stacklessWriteDeflateFunc(ctx)
 }
 
-func nonblockingWriteDeflate(ctxv interface{}) {
+func nonblockingWriteDeflate(ctxv any) {
 	ctx := ctxv.(*compressCtx)
 	zw := acquireRealDeflateWriter(ctx.w, ctx.level)
 

vendor/github.com/valyala/fasthttp/cookie.go

@@ -23,16 +23,16 @@ var (
 type CookieSameSite int
 
 const (
-	// CookieSameSiteDisabled removes the SameSite flag
+	// CookieSameSiteDisabled removes the SameSite flag.
 	CookieSameSiteDisabled CookieSameSite = iota
-	// CookieSameSiteDefaultMode sets the SameSite flag
+	// CookieSameSiteDefaultMode sets the SameSite flag.
 	CookieSameSiteDefaultMode
-	// CookieSameSiteLaxMode sets the SameSite flag with the "Lax" parameter
+	// CookieSameSiteLaxMode sets the SameSite flag with the "Lax" parameter.
 	CookieSameSiteLaxMode
-	// CookieSameSiteStrictMode sets the SameSite flag with the "Strict" parameter
+	// CookieSameSiteStrictMode sets the SameSite flag with the "Strict" parameter.
 	CookieSameSiteStrictMode
-	// CookieSameSiteNoneMode sets the SameSite flag with the "None" parameter
-	// see https://tools.ietf.org/html/draft-west-cookie-incrementalism-00
+	// CookieSameSiteNoneMode sets the SameSite flag with the "None" parameter.
+	// See https://tools.ietf.org/html/draft-west-cookie-incrementalism-00
 	CookieSameSiteNoneMode
 )
 
@@ -54,7 +54,7 @@ func ReleaseCookie(c *Cookie) {
 }
 
 var cookiePool = &sync.Pool{
-	New: func() interface{} {
+	New: func() any {
 		return &Cookie{}
 	},
 }
@@ -122,7 +122,7 @@ func (c *Cookie) SameSite() CookieSameSite {
 }
 
 // SetSameSite sets the cookie's SameSite flag to the given value.
-// set value CookieSameSiteNoneMode will set Secure to true also to avoid browser rejection
+// Set value CookieSameSiteNoneMode will set Secure to true also to avoid browser rejection.
 func (c *Cookie) SetSameSite(mode CookieSameSite) {
 	c.sameSite = mode
 	if mode == CookieSameSiteNoneMode {
@@ -172,16 +172,16 @@ func (c *Cookie) MaxAge() int {
 }
 
 // SetMaxAge sets cookie expiration time based on seconds. This takes precedence
-// over any absolute expiry set on the cookie
+// over any absolute expiry set on the cookie.
 //
-// Set max age to 0 to unset
+// Set max age to 0 to unset.
 func (c *Cookie) SetMaxAge(seconds int) {
 	c.maxAge = seconds
 }
 
 // Expire returns cookie expiration time.
 //
-// CookieExpireUnlimited is returned if cookie doesn't expire
+// CookieExpireUnlimited is returned if cookie doesn't expire.
 func (c *Cookie) Expire() time.Time {
 	expire := c.expire
 	if expire.IsZero() {

vendor/github.com/valyala/fasthttp/examples/README.md

@@ -1,4 +0,0 @@
-# Code examples
-
-* [HelloWorld server](helloworldserver)
-* [Static file server](fileserver)

vendor/github.com/valyala/fasthttp/examples/client/Makefile

@@ -1,6 +0,0 @@
-client: clean
-	go get -u github.com/valyala/fasthttp
-	go build
-
-clean:
-	rm -f client

vendor/github.com/valyala/fasthttp/examples/client/README.md

@@ -1,21 +0,0 @@
-# Client Example
-
-The Client is useful when working with multiple hostnames.
-
-See the simplest `sendGetRequest()` for GET and more advanced `sendPostRequest()` for a POST request.
-
-The `sendPostRequest()` also shows:
-* Per-request timeout with `DoTimeout()`
-* Send a body as bytes slice with `SetBodyRaw()`. This is useful if you generated a request body. Otherwise, prefer `SetBody()` which copies it.
-* Parse JSON from response
-* Gracefully show error messages i.e. timeouts as warnings and other errors as a failures with detailed error messages.
-
-## How to build and run
-Start a web server on localhost:8080 then execute:
-
-    make
-    ./client
-
-## Client vs HostClient
-Internally the Client creates a dedicated HostClient for each domain/IP address and cleans unused after period of time.
-So if you have a single heavily loaded API endpoint it's better to use HostClient. See an example in the [examples/host_client](../host_client/)

vendor/github.com/valyala/fasthttp/examples/client/client.go

@@ -1,132 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"reflect"
-	"time"
-
-	"github.com/valyala/fasthttp"
-)
-
-var headerContentTypeJson = []byte("application/json")
-
-var client *fasthttp.Client
-
-type Entity struct {
-	Id   int
-	Name string
-}
-
-func main() {
-	// You may read the timeouts from some config
-	readTimeout, _ := time.ParseDuration("500ms")
-	writeTimeout, _ := time.ParseDuration("500ms")
-	maxIdleConnDuration, _ := time.ParseDuration("1h")
-	client = &fasthttp.Client{
-		ReadTimeout:                   readTimeout,
-		WriteTimeout:                  writeTimeout,
-		MaxIdleConnDuration:           maxIdleConnDuration,
-		NoDefaultUserAgentHeader:      true, // Don't send: User-Agent: fasthttp
-		DisableHeaderNamesNormalizing: true, // If you set the case on your headers correctly you can enable this
-		DisablePathNormalizing:        true,
-		// increase DNS cache time to an hour instead of default minute
-		Dial: (&fasthttp.TCPDialer{
-			Concurrency:      4096,
-			DNSCacheDuration: time.Hour,
-		}).Dial,
-	}
-	sendGetRequest()
-	sendPostRequest()
-}
-
-func sendGetRequest() {
-	req := fasthttp.AcquireRequest()
-	req.SetRequestURI("http://localhost:8080/")
-	req.Header.SetMethod(fasthttp.MethodGet)
-	resp := fasthttp.AcquireResponse()
-	err := client.Do(req, resp)
-	fasthttp.ReleaseRequest(req)
-	if err == nil {
-		fmt.Printf("DEBUG Response: %s\n", resp.Body())
-	} else {
-		fmt.Fprintf(os.Stderr, "ERR Connection error: %v\n", err)
-	}
-	fasthttp.ReleaseResponse(resp)
-}
-
-func sendPostRequest() {
-	// per-request timeout
-	reqTimeout := time.Duration(100) * time.Millisecond
-
-	reqEntity := &Entity{
-		Name: "New entity",
-	}
-	reqEntityBytes, _ := json.Marshal(reqEntity)
-
-	req := fasthttp.AcquireRequest()
-	req.SetRequestURI("http://localhost:8080/")
-	req.Header.SetMethod(fasthttp.MethodPost)
-	req.Header.SetContentTypeBytes(headerContentTypeJson)
-	req.SetBodyRaw(reqEntityBytes)
-
-	resp := fasthttp.AcquireResponse()
-	err := client.DoTimeout(req, resp, reqTimeout)
-	fasthttp.ReleaseRequest(req)
-	defer fasthttp.ReleaseResponse(resp)
-
-	if err != nil {
-		errName, known := httpConnError(err)
-		if known {
-			fmt.Fprintf(os.Stderr, "WARN conn error: %v\n", errName)
-		} else {
-			fmt.Fprintf(os.Stderr, "ERR conn failure: %v %v\n", errName, err)
-		}
-
-		return
-	}
-
-	statusCode := resp.StatusCode()
-	respBody := resp.Body()
-	fmt.Printf("DEBUG Response: %s\n", respBody)
-
-	if statusCode != http.StatusOK {
-		fmt.Fprintf(os.Stderr, "ERR invalid HTTP response code: %d\n", statusCode)
-
-		return
-	}
-
-	respEntity := &Entity{}
-	err = json.Unmarshal(respBody, respEntity)
-	if err == nil || errors.Is(err, io.EOF) {
-		fmt.Printf("DEBUG Parsed Response: %v\n", respEntity)
-	} else {
-		fmt.Fprintf(os.Stderr, "ERR failed to parse response: %v\n", err)
-	}
-}
-
-func httpConnError(err error) (string, bool) {
-	var (
-		errName string
-		known   = true
-	)
-
-	switch {
-	case errors.Is(err, fasthttp.ErrTimeout):
-		errName = "timeout"
-	case errors.Is(err, fasthttp.ErrNoFreeConns):
-		errName = "conn_limit"
-	case errors.Is(err, fasthttp.ErrConnectionClosed):
-		errName = "conn_close"
-	case reflect.TypeOf(err).String() == "*net.OpError":
-		errName = "timeout"
-	default:
-		known = false
-	}
-
-	return errName, known
-}

vendor/github.com/valyala/fasthttp/examples/fileserver/Makefile

@@ -1,7 +0,0 @@
-fileserver: clean
-	go get -u github.com/valyala/fasthttp
-	go get -u github.com/valyala/fasthttp/expvarhandler
-	go build
-
-clean:
-	rm -f fileserver

vendor/github.com/valyala/fasthttp/examples/fileserver/README.md

@@ -1,84 +0,0 @@
-# Static file server example
-
-* Serves files from the given directory.
-* Supports transparent response compression.
-* Supports byte range responses.
-* Generates directory index pages.
-* Supports TLS (aka SSL or HTTPS).
-* Supports virtual hosts.
-* Exports various stats on /stats path.
-
-# How to build
-
-```
-make
-```
-
-# How to run
-
-```
-./fileserver -h
-./fileserver -addr=tcp.addr.to.listen:to -dir=/path/to/directory/to/serve
-```
-
-# fileserver vs nginx performance comparison
-
-Serving default nginx path (`/usr/share/nginx/html` on ubuntu).
-
-* nginx
-
-```
-$ ./wrk -t 4 -c 16 -d 10 http://localhost:80
-Running 10s test @ http://localhost:80
-  4 threads and 16 connections
-  Thread Stats   Avg      Stdev     Max   +/- Stdev
-    Latency   397.76us    1.08ms  20.23ms   95.19%
-    Req/Sec    21.20k     2.49k   31.34k    79.65%
-  850220 requests in 10.10s, 695.65MB read
-Requests/sec:  84182.71
-Transfer/sec:     68.88MB
-```
-
-* fileserver
-
-```
-$ ./wrk -t 4 -c 16 -d 10 http://localhost:8080
-Running 10s test @ http://localhost:8080
-  4 threads and 16 connections
-  Thread Stats   Avg      Stdev     Max   +/- Stdev
-    Latency   447.99us    1.59ms  27.20ms   94.79%
-    Req/Sec    37.13k     3.99k   47.86k    76.00%
-  1478457 requests in 10.02s, 1.03GB read
-Requests/sec: 147597.06
-Transfer/sec:    105.15MB
-```
-
-8 pipelined requests
-
-* nginx
-
-```
-$ ./wrk -s pipeline.lua -t 4 -c 16 -d 10 http://localhost:80 -- 8
-Running 10s test @ http://localhost:80
-  4 threads and 16 connections
-  Thread Stats   Avg      Stdev     Max   +/- Stdev
-    Latency     1.34ms    2.15ms  30.91ms   92.16%
-    Req/Sec    33.54k     7.36k  108.12k    76.81%
-  1339908 requests in 10.10s, 1.07GB read
-Requests/sec: 132705.81
-Transfer/sec:    108.58MB
-```
-
-* fileserver
-
-```
-$ ./wrk -s pipeline.lua -t 4 -c 16 -d 10 http://localhost:8080 -- 8
-Running 10s test @ http://localhost:8080
-  4 threads and 16 connections
-  Thread Stats   Avg      Stdev     Max   +/- Stdev
-    Latency     2.08ms    6.33ms  88.26ms   92.83%
-    Req/Sec   116.54k    14.66k  167.98k    69.00%
-  4642226 requests in 10.03s, 3.23GB read
-Requests/sec: 462769.41
-Transfer/sec:    329.67MB
-```

vendor/github.com/valyala/fasthttp/examples/fileserver/fileserver.go

@@ -1,120 +0,0 @@
-// Example static file server.
-//
-// Serves static files from the given directory.
-// Exports various stats at /stats .
-package main
-
-import (
-	"expvar"
-	"flag"
-	"log"
-
-	"github.com/valyala/fasthttp"
-	"github.com/valyala/fasthttp/expvarhandler"
-)
-
-var (
-	addr               = flag.String("addr", "localhost:8080", "TCP address to listen to")
-	addrTLS            = flag.String("addrTLS", "", "TCP address to listen to TLS (aka SSL or HTTPS) requests. Leave empty for disabling TLS")
-	byteRange          = flag.Bool("byteRange", false, "Enables byte range requests if set to true")
-	certFile           = flag.String("certFile", "./ssl-cert.pem", "Path to TLS certificate file")
-	compress           = flag.Bool("compress", false, "Enables transparent response compression if set to true")
-	dir                = flag.String("dir", "/usr/share/nginx/html", "Directory to serve static files from")
-	generateIndexPages = flag.Bool("generateIndexPages", true, "Whether to generate directory index pages")
-	keyFile            = flag.String("keyFile", "./ssl-cert.key", "Path to TLS key file")
-	vhost              = flag.Bool("vhost", false, "Enables virtual hosting by prepending the requested path with the requested hostname")
-)
-
-func main() {
-	// Parse command-line flags.
-	flag.Parse()
-
-	// Setup FS handler
-	fs := &fasthttp.FS{
-		Root:               *dir,
-		IndexNames:         []string{"index.html"},
-		GenerateIndexPages: *generateIndexPages,
-		Compress:           *compress,
-		AcceptByteRange:    *byteRange,
-	}
-	if *vhost {
-		fs.PathRewrite = fasthttp.NewVHostPathRewriter(0)
-	}
-	fsHandler := fs.NewRequestHandler()
-
-	// Create RequestHandler serving server stats on /stats and files
-	// on other requested paths.
-	// /stats output may be filtered using regexps. For example:
-	//
-	//   * /stats?r=fs will show only stats (expvars) containing 'fs'
-	//     in their names.
-	requestHandler := func(ctx *fasthttp.RequestCtx) {
-		switch string(ctx.Path()) {
-		case "/stats":
-			expvarhandler.ExpvarHandler(ctx)
-		default:
-			fsHandler(ctx)
-			updateFSCounters(ctx)
-		}
-	}
-
-	// Start HTTP server.
-	if len(*addr) > 0 {
-		log.Printf("Starting HTTP server on %q", *addr)
-		go func() {
-			if err := fasthttp.ListenAndServe(*addr, requestHandler); err != nil {
-				log.Fatalf("error in ListenAndServe: %v", err)
-			}
-		}()
-	}
-
-	// Start HTTPS server.
-	if len(*addrTLS) > 0 {
-		log.Printf("Starting HTTPS server on %q", *addrTLS)
-		go func() {
-			if err := fasthttp.ListenAndServeTLS(*addrTLS, *certFile, *keyFile, requestHandler); err != nil {
-				log.Fatalf("error in ListenAndServeTLS: %v", err)
-			}
-		}()
-	}
-
-	log.Printf("Serving files from directory %q", *dir)
-	log.Printf("See stats at http://%s/stats", *addr)
-
-	// Wait forever.
-	select {}
-}
-
-func updateFSCounters(ctx *fasthttp.RequestCtx) {
-	// Increment the number of fsHandler calls.
-	fsCalls.Add(1)
-
-	// Update other stats counters
-	resp := &ctx.Response
-	switch resp.StatusCode() {
-	case fasthttp.StatusOK:
-		fsOKResponses.Add(1)
-		fsResponseBodyBytes.Add(int64(resp.Header.ContentLength()))
-	case fasthttp.StatusNotModified:
-		fsNotModifiedResponses.Add(1)
-	case fasthttp.StatusNotFound:
-		fsNotFoundResponses.Add(1)
-	default:
-		fsOtherResponses.Add(1)
-	}
-}
-
-// Various counters - see https://pkg.go.dev/expvar for details.
-var (
-	// Counter for total number of fs calls
-	fsCalls = expvar.NewInt("fsCalls")
-
-	// Counters for various response status codes
-	fsOKResponses          = expvar.NewInt("fsOKResponses")
-	fsNotModifiedResponses = expvar.NewInt("fsNotModifiedResponses")
-	fsNotFoundResponses    = expvar.NewInt("fsNotFoundResponses")
-	fsOtherResponses       = expvar.NewInt("fsOtherResponses")
-
-	// Total size in bytes for OK response bodies served.
-	fsResponseBodyBytes = expvar.NewInt("fsResponseBodyBytes")
-)

vendor/github.com/valyala/fasthttp/examples/fileserver/ssl-cert-snakeoil.key

@@ -1,28 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQD4IQusAs8PJdnG
-3mURt/AXtgC+ceqLOatJ49JJE1VPTkMAy+oE1f1XvkMrYsHqmDf6GWVzgVXryL4U
-wq2/nJSm56ddhN55nI8oSN3dtywUB8/ShelEN73nlN77PeD9tl6NksPwWaKrqxq0
-FlabRPZSQCfmgZbhDV8Sa8mfCkFU0G0lit6kLGceCKMvmW+9Bz7ebsYmVdmVMxmf
-IJStFD44lWFTdUc65WISKEdW2ELcUefb0zOLw+0PCbXFGJH5x5ktksW8+BBk2Hkg
-GeQRL/qPCccthbScO0VgNj3zJ3ZZL0ObSDAbvNDG85joeNjDNq5DT/BAZ0bOSbEF
-sh+f9BAzAgMBAAECggEBAJWv2cq7Jw6MVwSRxYca38xuD6TUNBopgBvjREixURW2
-sNUaLuMb9Omp7fuOaE2N5rcJ+xnjPGIxh/oeN5MQctz9gwn3zf6vY+15h97pUb4D
-uGvYPRDaT8YVGS+X9NMZ4ZCmqW2lpWzKnCFoGHcy8yZLbcaxBsRdvKzwOYGoPiFb
-K2QuhXZ/1UPmqK9i2DFKtj40X6vBszTNboFxOVpXrPu0FJwLVSDf2hSZ4fMM0DH3
-YqwKcYf5te+hxGKgrqRA3tn0NCWii0in6QIwXMC+kMw1ebg/tZKqyDLMNptAK8J+
-DVw9m5X1seUHS5ehU/g2jrQrtK5WYn7MrFK4lBzlRwECgYEA/d1TeANYECDWRRDk
-B0aaRZs87Rwl/J9PsvbsKvtU/bX+OfSOUjOa9iQBqn0LmU8GqusEET/QVUfocVwV
-Bggf/5qDLxz100Rj0ags/yE/kNr0Bb31kkkKHFMnCT06YasR7qKllwrAlPJvQv9x
-IzBKq+T/Dx08Wep9bCRSFhzRCnsCgYEA+jdeZXTDr/Vz+D2B3nAw1frqYFfGnEVY
-wqmoK3VXMDkGuxsloO2rN+SyiUo3JNiQNPDub/t7175GH5pmKtZOlftePANsUjBj
-wZ1D0rI5Bxu/71ibIUYIRVmXsTEQkh/ozoh3jXCZ9+bLgYiYx7789IUZZSokFQ3D
-FICUT9KJ36kCgYAGoq9Y1rWJjmIrYfqj2guUQC+CfxbbGIrrwZqAsRsSmpwvhZ3m
-tiSZxG0quKQB+NfSxdvQW5ulbwC7Xc3K35F+i9pb8+TVBdeaFkw+yu6vaZmxQLrX
-fQM/pEjD7A7HmMIaO7QaU5SfEAsqdCTP56Y8AftMuNXn/8IRfo2KuGwaWwKBgFpU
-ILzJoVdlad9E/Rw7LjYhZfkv1uBVXIyxyKcfrkEXZSmozDXDdxsvcZCEfVHM6Ipk
-K/+7LuMcqp4AFEAEq8wTOdq6daFaHLkpt/FZK6M4TlruhtpFOPkoNc3e45eM83OT
-6mziKINJC1CQ6m65sQHpBtjxlKMRG8rL/D6wx9s5AoGBAMRlqNPMwglT3hvDmsAt
-9Lf9pdmhERUlHhD8bj8mDaBj2Aqv7f6VRJaYZqP403pKKQexuqcn80mtjkSAPFkN
-Cj7BVt/RXm5uoxDTnfi26RF9F6yNDEJ7UU9+peBr99aazF/fTgW/1GcMkQnum8uV
-c257YgaWmjK9uB0Y2r2VxS0G
------END PRIVATE KEY-----

vendor/github.com/valyala/fasthttp/examples/fileserver/ssl-cert-snakeoil.pem

@@ -1,17 +0,0 @@
------BEGIN CERTIFICATE-----
-MIICujCCAaKgAwIBAgIJAMbXnKZ/cikUMA0GCSqGSIb3DQEBCwUAMBUxEzARBgNV
-BAMTCnVidW50dS5uYW4wHhcNMTUwMjA0MDgwMTM5WhcNMjUwMjAxMDgwMTM5WjAV
-MRMwEQYDVQQDEwp1YnVudHUubmFuMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
-CgKCAQEA+CELrALPDyXZxt5lEbfwF7YAvnHqizmrSePSSRNVT05DAMvqBNX9V75D
-K2LB6pg3+hllc4FV68i+FMKtv5yUpuenXYTeeZyPKEjd3bcsFAfP0oXpRDe955Te
-+z3g/bZejZLD8Fmiq6satBZWm0T2UkAn5oGW4Q1fEmvJnwpBVNBtJYrepCxnHgij
-L5lvvQc+3m7GJlXZlTMZnyCUrRQ+OJVhU3VHOuViEihHVthC3FHn29Mzi8PtDwm1
-xRiR+ceZLZLFvPgQZNh5IBnkES/6jwnHLYW0nDtFYDY98yd2WS9Dm0gwG7zQxvOY
-6HjYwzauQ0/wQGdGzkmxBbIfn/QQMwIDAQABow0wCzAJBgNVHRMEAjAAMA0GCSqG
-SIb3DQEBCwUAA4IBAQBQjKm/4KN/iTgXbLTL3i7zaxYXFLXsnT1tF+ay4VA8aj98
-L3JwRTciZ3A5iy/W4VSCt3eASwOaPWHKqDBB5RTtL73LoAqsWmO3APOGQAbixcQ2
-45GXi05OKeyiYRi1Nvq7Unv9jUkRDHUYVPZVSAjCpsXzPhFkmZoTRxmx5l0ZF7Li
-K91lI5h+eFq0dwZwrmlPambyh1vQUi70VHv8DNToVU29kel7YLbxGbuqETfhrcy6
-X+Mha6RYITkAn5FqsZcKMsc9eYGEF4l3XV+oS7q6xfTxktYJMFTI18J0lQ2Lv/CI
-whdMnYGntDQBE/iFCrJEGNsKGc38796GBOb5j+zd
------END CERTIFICATE-----

vendor/github.com/valyala/fasthttp/examples/helloworldserver/Makefile

@@ -1,6 +0,0 @@
-helloworldserver: clean
-	go get -u github.com/valyala/fasthttp
-	go build
-
-clean:
-	rm -f helloworldserver

vendor/github.com/valyala/fasthttp/examples/helloworldserver/README.md

@@ -1,17 +0,0 @@
-# HelloWorld server example
-
-* Displays various request info.
-* Sets response headers and cookies.
-* Supports transparent compression.
-
-# How to build
-
-```
-make
-```
-
-# How to run
-
-```
-./helloworldserver -addr=tcp.addr.to.listen:to
-```

vendor/github.com/valyala/fasthttp/examples/helloworldserver/helloworldserver.go

@@ -1,55 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"log"
-
-	"github.com/valyala/fasthttp"
-)
-
-var (
-	addr     = flag.String("addr", ":8080", "TCP address to listen to")
-	compress = flag.Bool("compress", false, "Whether to enable transparent response compression")
-)
-
-func main() {
-	flag.Parse()
-
-	h := requestHandler
-	if *compress {
-		h = fasthttp.CompressHandler(h)
-	}
-
-	if err := fasthttp.ListenAndServe(*addr, h); err != nil {
-		log.Fatalf("Error in ListenAndServe: %v", err)
-	}
-}
-
-func requestHandler(ctx *fasthttp.RequestCtx) {
-	fmt.Fprintf(ctx, "Hello, world!\n\n")
-
-	fmt.Fprintf(ctx, "Request method is %q\n", ctx.Method())
-	fmt.Fprintf(ctx, "RequestURI is %q\n", ctx.RequestURI())
-	fmt.Fprintf(ctx, "Requested path is %q\n", ctx.Path())
-	fmt.Fprintf(ctx, "Host is %q\n", ctx.Host())
-	fmt.Fprintf(ctx, "Query string is %q\n", ctx.QueryArgs())
-	fmt.Fprintf(ctx, "User-Agent is %q\n", ctx.UserAgent())
-	fmt.Fprintf(ctx, "Connection has been established at %s\n", ctx.ConnTime())
-	fmt.Fprintf(ctx, "Request has been started at %s\n", ctx.Time())
-	fmt.Fprintf(ctx, "Serial request number for the current connection is %d\n", ctx.ConnRequestNum())
-	fmt.Fprintf(ctx, "Your ip is %q\n\n", ctx.RemoteIP())
-
-	fmt.Fprintf(ctx, "Raw request is:\n---CUT---\n%s\n---CUT---", &ctx.Request)
-
-	ctx.SetContentType("text/plain; charset=utf8")
-
-	// Set arbitrary headers
-	ctx.Response.Header.Set("X-My-Header", "my-header-value")
-
-	// Set cookies
-	var c fasthttp.Cookie
-	c.SetKey("cookie-name")
-	c.SetValue("cookie-value")
-	ctx.Response.Header.SetCookie(&c)
-}

vendor/github.com/valyala/fasthttp/examples/host_client/Makefile

@@ -1,6 +0,0 @@
-host_client: clean
-	go get -u github.com/valyala/fasthttp
-	go build
-
-clean:
-	rm -f host_client

vendor/github.com/valyala/fasthttp/examples/host_client/README.md

@@ -1,13 +0,0 @@
-# Host Client Example
-
-The HostClient is useful when calling an API from a single host.
-The example also shows how to use URI.
-You may create the parsed URI once and reuse it in many requests.
-The URI has a username and password for Basic Auth but you may also set other parts i.e. `SetPath()`, `SetQueryString()`.
-
-# How to build and run
-Start a web server on localhost:8080 then execute:
-
-    make
-    ./host_client
-

vendor/github.com/valyala/fasthttp/examples/host_client/hostclient.go

@@ -1,35 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/valyala/fasthttp"
-)
-
-func main() {
-	// Get URI from a pool
-	url := fasthttp.AcquireURI()
-	url.Parse(nil, []byte("http://localhost:8080/"))
-	url.SetUsername("Aladdin")
-	url.SetPassword("Open Sesame")
-
-	hc := &fasthttp.HostClient{
-		Addr: "localhost:8080", // The host address and port must be set explicitly
-	}
-
-	req := fasthttp.AcquireRequest()
-	req.SetURI(url)          // copy url into request
-	fasthttp.ReleaseURI(url) // now you may release the URI
-
-	req.Header.SetMethod(fasthttp.MethodGet)
-	resp := fasthttp.AcquireResponse()
-	err := hc.Do(req, resp)
-	fasthttp.ReleaseRequest(req)
-	if err == nil {
-		fmt.Printf("Response: %s\n", resp.Body())
-	} else {
-		fmt.Fprintf(os.Stderr, "Connection error: %v\n", err)
-	}
-	fasthttp.ReleaseResponse(resp)
-}

vendor/github.com/valyala/fasthttp/examples/letsencrypt/letsencryptserver.go

@@ -1,41 +0,0 @@
-package main
-
-import (
-	"crypto/tls"
-	"net"
-
-	"github.com/valyala/fasthttp"
-	"golang.org/x/crypto/acme"
-	"golang.org/x/crypto/acme/autocert"
-)
-
-func requestHandler(ctx *fasthttp.RequestCtx) {
-	ctx.SetBodyString("hello from https!")
-}
-
-func main() {
-	m := &autocert.Manager{
-		Prompt:     autocert.AcceptTOS,
-		HostPolicy: autocert.HostWhitelist("example.com"), // Replace with your domain.
-		Cache:      autocert.DirCache("./certs"),
-	}
-
-	cfg := &tls.Config{
-		GetCertificate: m.GetCertificate,
-		NextProtos: []string{
-			"http/1.1", acme.ALPNProto,
-		},
-	}
-
-	// Let's Encrypt tls-alpn-01 only works on port 443.
-	ln, err := net.Listen("tcp4", "0.0.0.0:443") /* #nosec G102 */
-	if err != nil {
-		panic(err)
-	}
-
-	lnTls := tls.NewListener(ln, cfg)
-
-	if err := fasthttp.Serve(lnTls, requestHandler); err != nil {
-		panic(err)
-	}
-}

vendor/github.com/valyala/fasthttp/examples/multidomain/Makefile

@@ -1,6 +0,0 @@
-writer: clean
-	go get -u github.com/valyala/fasthttp
-	go build
-
-clean:
-	rm -f multidomain

vendor/github.com/valyala/fasthttp/examples/multidomain/README.md

@@ -1,15 +0,0 @@
-# Multidomain using SSL certs example
-
-* Prints two messages depending on visited host.
-
-# How to build
-
-```
-make
-```
-
-# How to run
-
-```
-./multidomain
-```

vendor/github.com/valyala/fasthttp/examples/multidomain/multidomain.go

@@ -1,63 +0,0 @@
-package main
-
-import (
-	"fmt"
-
-	"github.com/valyala/fasthttp"
-)
-
-var domains = make(map[string]fasthttp.RequestHandler)
-
-func main() {
-	server := &fasthttp.Server{
-		// You can check the access using openssl command:
-		// $ openssl s_client -connect localhost:8080 << EOF
-		// > GET /
-		// > Host: localhost
-		// > EOF
-		//
-		// $ openssl s_client -connect localhost:8080 << EOF
-		// > GET /
-		// > Host: 127.0.0.1:8080
-		// > EOF
-		//
-		Handler: func(ctx *fasthttp.RequestCtx) {
-			h, ok := domains[string(ctx.Host())]
-			if !ok {
-				ctx.NotFound()
-				return
-			}
-			h(ctx)
-		},
-	}
-
-	// preparing first host
-	cert, priv, err := fasthttp.GenerateTestCertificate("localhost:8080")
-	if err != nil {
-		panic(err)
-	}
-	domains["localhost:8080"] = func(ctx *fasthttp.RequestCtx) {
-		ctx.WriteString("You are accessing to localhost:8080\n")
-	}
-
-	err = server.AppendCertEmbed(cert, priv)
-	if err != nil {
-		panic(err)
-	}
-
-	// preparing second host
-	cert, priv, err = fasthttp.GenerateTestCertificate("127.0.0.1")
-	if err != nil {
-		panic(err)
-	}
-	domains["127.0.0.1:8080"] = func(ctx *fasthttp.RequestCtx) {
-		ctx.WriteString("You are accessing to 127.0.0.1:8080\n")
-	}
-
-	err = server.AppendCertEmbed(cert, priv)
-	if err != nil {
-		panic(err)
-	}
-
-	fmt.Println(server.ListenAndServeTLS(":8080", "", ""))
-}

vendor/github.com/valyala/fasthttp/fasthttputil/inmemory_listener_test.go

@@ -1,273 +0,0 @@
-package fasthttputil
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"sync"
-	"testing"
-	"time"
-)
-
-func TestInmemoryListener(t *testing.T) {
-	ln := NewInmemoryListener()
-
-	ch := make(chan struct{})
-	for i := 0; i < 10; i++ {
-		go func(n int) {
-			conn, err := ln.Dial()
-			if err != nil {
-				t.Errorf("unexpected error: %v", err)
-			}
-			defer conn.Close()
-			req := fmt.Sprintf("request_%d", n)
-			nn, err := conn.Write([]byte(req))
-			if err != nil {
-				t.Errorf("unexpected error: %v", err)
-			}
-			if nn != len(req) {
-				t.Errorf("unexpected number of bytes written: %d. Expecting %d", nn, len(req))
-			}
-			buf := make([]byte, 30)
-			nn, err = conn.Read(buf)
-			if err != nil {
-				t.Errorf("unexpected error: %v", err)
-			}
-			buf = buf[:nn]
-			resp := fmt.Sprintf("response_%d", n)
-			if nn != len(resp) {
-				t.Errorf("unexpected number of bytes read: %d. Expecting %d", nn, len(resp))
-			}
-			if string(buf) != resp {
-				t.Errorf("unexpected response %q. Expecting %q", buf, resp)
-			}
-			ch <- struct{}{}
-		}(i)
-	}
-
-	serverCh := make(chan struct{})
-	go func() {
-		for {
-			conn, err := ln.Accept()
-			if err != nil {
-				close(serverCh)
-				return
-			}
-			defer conn.Close()
-			buf := make([]byte, 30)
-			n, err := conn.Read(buf)
-			if err != nil {
-				t.Errorf("unexpected error: %v", err)
-			}
-			buf = buf[:n]
-			if !bytes.HasPrefix(buf, []byte("request_")) {
-				t.Errorf("unexpected request prefix %q. Expecting %q", buf, "request_")
-			}
-			resp := fmt.Sprintf("response_%s", buf[len("request_"):])
-			n, err = conn.Write([]byte(resp))
-			if err != nil {
-				t.Errorf("unexpected error: %v", err)
-			}
-			if n != len(resp) {
-				t.Errorf("unexpected number of bytes written: %d. Expecting %d", n, len(resp))
-			}
-		}
-	}()
-
-	for i := 0; i < 10; i++ {
-		select {
-		case <-ch:
-		case <-time.After(time.Second):
-			t.Fatalf("timeout")
-		}
-	}
-
-	if err := ln.Close(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	select {
-	case <-serverCh:
-	case <-time.After(time.Second):
-		t.Fatalf("timeout")
-	}
-}
-
-// echoServerHandler implements http.Handler.
-type echoServerHandler struct {
-	t *testing.T
-}
-
-func (s *echoServerHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	w.WriteHeader(200)
-	time.Sleep(time.Millisecond * 100)
-	if _, err := io.Copy(w, r.Body); err != nil {
-		s.t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func testInmemoryListenerHTTP(t *testing.T, f func(t *testing.T, client *http.Client)) {
-	ln := NewInmemoryListener()
-	defer ln.Close()
-
-	client := &http.Client{
-		Transport: &http.Transport{
-			DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
-				return ln.Dial()
-			},
-		},
-		Timeout: time.Second,
-	}
-
-	server := &http.Server{
-		Handler: &echoServerHandler{t},
-	}
-
-	go func() {
-		if err := server.Serve(ln); err != nil && err != http.ErrServerClosed {
-			t.Errorf("unexpected error: %v", err)
-		}
-	}()
-
-	f(t, client)
-
-	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100)
-	defer cancel()
-	server.Shutdown(ctx) //nolint:errcheck
-}
-
-func testInmemoryListenerHTTPSingle(t *testing.T, client *http.Client, content string) {
-	res, err := client.Post("http://...", "text/plain", bytes.NewBufferString(content))
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	defer func() { _ = res.Body.Close() }()
-	b, err := io.ReadAll(res.Body)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	s := string(b)
-	if string(b) != content {
-		t.Fatalf("unexpected response %q, expecting %q", s, content)
-	}
-}
-
-func TestInmemoryListenerHTTPSingle(t *testing.T) {
-	testInmemoryListenerHTTP(t, func(t *testing.T, client *http.Client) {
-		testInmemoryListenerHTTPSingle(t, client, "request")
-	})
-}
-
-func TestInmemoryListenerHTTPSerial(t *testing.T) {
-	testInmemoryListenerHTTP(t, func(t *testing.T, client *http.Client) {
-		for i := 0; i < 10; i++ {
-			testInmemoryListenerHTTPSingle(t, client, fmt.Sprintf("request_%d", i))
-		}
-	})
-}
-
-func TestInmemoryListenerHTTPConcurrent(t *testing.T) {
-	testInmemoryListenerHTTP(t, func(t *testing.T, client *http.Client) {
-		var wg sync.WaitGroup
-		for i := 0; i < 10; i++ {
-			wg.Add(1)
-			go func(i int) {
-				defer wg.Done()
-				testInmemoryListenerHTTPSingle(t, client, fmt.Sprintf("request_%d", i))
-			}(i)
-		}
-		wg.Wait()
-	})
-}
-
-func acceptLoop(ln net.Listener) {
-	for {
-		conn, err := ln.Accept()
-		if err != nil {
-			panic(err)
-		}
-
-		conn.Close()
-	}
-}
-
-func TestInmemoryListenerAddrDefault(t *testing.T) {
-	ln := NewInmemoryListener()
-
-	verifyAddr(t, ln.Addr(), inmemoryAddr(0))
-
-	go func() {
-		c, err := ln.Dial()
-		if err != nil {
-			panic(err)
-		}
-
-		c.Close()
-	}()
-
-	lc, err := ln.Accept()
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	verifyAddr(t, lc.LocalAddr(), inmemoryAddr(0))
-	verifyAddr(t, lc.RemoteAddr(), pipeAddr(0))
-
-	go acceptLoop(ln)
-
-	c, err := ln.Dial()
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	verifyAddr(t, c.LocalAddr(), pipeAddr(0))
-	verifyAddr(t, c.RemoteAddr(), inmemoryAddr(0))
-}
-
-func verifyAddr(t *testing.T, got, expected net.Addr) {
-	if got != expected {
-		t.Fatalf("unexpected addr: %v. Expecting %v", got, expected)
-	}
-}
-
-func TestInmemoryListenerAddrCustom(t *testing.T) {
-	ln := NewInmemoryListener()
-
-	listenerAddr := &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 12345}
-
-	ln.SetLocalAddr(listenerAddr)
-
-	verifyAddr(t, ln.Addr(), listenerAddr)
-
-	go func() {
-		c, err := ln.Dial()
-		if err != nil {
-			panic(err)
-		}
-
-		c.Close()
-	}()
-
-	lc, err := ln.Accept()
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	verifyAddr(t, lc.LocalAddr(), listenerAddr)
-	verifyAddr(t, lc.RemoteAddr(), pipeAddr(0))
-
-	go acceptLoop(ln)
-
-	clientAddr := &net.TCPAddr{IP: net.IPv4(127, 0, 0, 2), Port: 65432}
-
-	c, err := ln.DialWithLocalAddr(clientAddr)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	verifyAddr(t, c.LocalAddr(), clientAddr)
-	verifyAddr(t, c.RemoteAddr(), listenerAddr)
-}

vendor/github.com/valyala/fasthttp/fasthttputil/inmemory_listener_timing_test.go

@@ -1,155 +0,0 @@
-package fasthttputil_test
-
-import (
-	"crypto/tls"
-	"net"
-	"testing"
-
-	"github.com/valyala/fasthttp"
-	"github.com/valyala/fasthttp/fasthttputil"
-)
-
-var (
-	certblock = []byte(`-----BEGIN CERTIFICATE-----
-MIICujCCAaKgAwIBAgIJAMbXnKZ/cikUMA0GCSqGSIb3DQEBCwUAMBUxEzARBgNV
-BAMTCnVidW50dS5uYW4wHhcNMTUwMjA0MDgwMTM5WhcNMjUwMjAxMDgwMTM5WjAV
-MRMwEQYDVQQDEwp1YnVudHUubmFuMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
-CgKCAQEA+CELrALPDyXZxt5lEbfwF7YAvnHqizmrSePSSRNVT05DAMvqBNX9V75D
-K2LB6pg3+hllc4FV68i+FMKtv5yUpuenXYTeeZyPKEjd3bcsFAfP0oXpRDe955Te
-+z3g/bZejZLD8Fmiq6satBZWm0T2UkAn5oGW4Q1fEmvJnwpBVNBtJYrepCxnHgij
-L5lvvQc+3m7GJlXZlTMZnyCUrRQ+OJVhU3VHOuViEihHVthC3FHn29Mzi8PtDwm1
-xRiR+ceZLZLFvPgQZNh5IBnkES/6jwnHLYW0nDtFYDY98yd2WS9Dm0gwG7zQxvOY
-6HjYwzauQ0/wQGdGzkmxBbIfn/QQMwIDAQABow0wCzAJBgNVHRMEAjAAMA0GCSqG
-SIb3DQEBCwUAA4IBAQBQjKm/4KN/iTgXbLTL3i7zaxYXFLXsnT1tF+ay4VA8aj98
-L3JwRTciZ3A5iy/W4VSCt3eASwOaPWHKqDBB5RTtL73LoAqsWmO3APOGQAbixcQ2
-45GXi05OKeyiYRi1Nvq7Unv9jUkRDHUYVPZVSAjCpsXzPhFkmZoTRxmx5l0ZF7Li
-K91lI5h+eFq0dwZwrmlPambyh1vQUi70VHv8DNToVU29kel7YLbxGbuqETfhrcy6
-X+Mha6RYITkAn5FqsZcKMsc9eYGEF4l3XV+oS7q6xfTxktYJMFTI18J0lQ2Lv/CI
-whdMnYGntDQBE/iFCrJEGNsKGc38796GBOb5j+zd
------END CERTIFICATE-----
-`)
-	keyblock = []byte(`-----BEGIN PRIVATE KEY-----
-MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQD4IQusAs8PJdnG
-3mURt/AXtgC+ceqLOatJ49JJE1VPTkMAy+oE1f1XvkMrYsHqmDf6GWVzgVXryL4U
-wq2/nJSm56ddhN55nI8oSN3dtywUB8/ShelEN73nlN77PeD9tl6NksPwWaKrqxq0
-FlabRPZSQCfmgZbhDV8Sa8mfCkFU0G0lit6kLGceCKMvmW+9Bz7ebsYmVdmVMxmf
-IJStFD44lWFTdUc65WISKEdW2ELcUefb0zOLw+0PCbXFGJH5x5ktksW8+BBk2Hkg
-GeQRL/qPCccthbScO0VgNj3zJ3ZZL0ObSDAbvNDG85joeNjDNq5DT/BAZ0bOSbEF
-sh+f9BAzAgMBAAECggEBAJWv2cq7Jw6MVwSRxYca38xuD6TUNBopgBvjREixURW2
-sNUaLuMb9Omp7fuOaE2N5rcJ+xnjPGIxh/oeN5MQctz9gwn3zf6vY+15h97pUb4D
-uGvYPRDaT8YVGS+X9NMZ4ZCmqW2lpWzKnCFoGHcy8yZLbcaxBsRdvKzwOYGoPiFb
-K2QuhXZ/1UPmqK9i2DFKtj40X6vBszTNboFxOVpXrPu0FJwLVSDf2hSZ4fMM0DH3
-YqwKcYf5te+hxGKgrqRA3tn0NCWii0in6QIwXMC+kMw1ebg/tZKqyDLMNptAK8J+
-DVw9m5X1seUHS5ehU/g2jrQrtK5WYn7MrFK4lBzlRwECgYEA/d1TeANYECDWRRDk
-B0aaRZs87Rwl/J9PsvbsKvtU/bX+OfSOUjOa9iQBqn0LmU8GqusEET/QVUfocVwV
-Bggf/5qDLxz100Rj0ags/yE/kNr0Bb31kkkKHFMnCT06YasR7qKllwrAlPJvQv9x
-IzBKq+T/Dx08Wep9bCRSFhzRCnsCgYEA+jdeZXTDr/Vz+D2B3nAw1frqYFfGnEVY
-wqmoK3VXMDkGuxsloO2rN+SyiUo3JNiQNPDub/t7175GH5pmKtZOlftePANsUjBj
-wZ1D0rI5Bxu/71ibIUYIRVmXsTEQkh/ozoh3jXCZ9+bLgYiYx7789IUZZSokFQ3D
-FICUT9KJ36kCgYAGoq9Y1rWJjmIrYfqj2guUQC+CfxbbGIrrwZqAsRsSmpwvhZ3m
-tiSZxG0quKQB+NfSxdvQW5ulbwC7Xc3K35F+i9pb8+TVBdeaFkw+yu6vaZmxQLrX
-fQM/pEjD7A7HmMIaO7QaU5SfEAsqdCTP56Y8AftMuNXn/8IRfo2KuGwaWwKBgFpU
-ILzJoVdlad9E/Rw7LjYhZfkv1uBVXIyxyKcfrkEXZSmozDXDdxsvcZCEfVHM6Ipk
-K/+7LuMcqp4AFEAEq8wTOdq6daFaHLkpt/FZK6M4TlruhtpFOPkoNc3e45eM83OT
-6mziKINJC1CQ6m65sQHpBtjxlKMRG8rL/D6wx9s5AoGBAMRlqNPMwglT3hvDmsAt
-9Lf9pdmhERUlHhD8bj8mDaBj2Aqv7f6VRJaYZqP403pKKQexuqcn80mtjkSAPFkN
-Cj7BVt/RXm5uoxDTnfi26RF9F6yNDEJ7UU9+peBr99aazF/fTgW/1GcMkQnum8uV
-c257YgaWmjK9uB0Y2r2VxS0G
------END PRIVATE KEY-----`)
-)
-
-// BenchmarkPlainStreaming measures end-to-end plaintext streaming performance
-// for fasthttp client and server.
-//
-// It issues http requests over a small number of keep-alive connections.
-func BenchmarkPlainStreaming(b *testing.B) {
-	benchmark(b, streamingHandler, false)
-}
-
-// BenchmarkPlainHandshake measures end-to-end plaintext handshake performance
-// for fasthttp client and server.
-//
-// It re-establishes new connection per each http request.
-func BenchmarkPlainHandshake(b *testing.B) {
-	benchmark(b, handshakeHandler, false)
-}
-
-// BenchmarkTLSStreaming measures end-to-end TLS streaming performance
-// for fasthttp client and server.
-//
-// It issues http requests over a small number of TLS keep-alive connections.
-func BenchmarkTLSStreaming(b *testing.B) {
-	benchmark(b, streamingHandler, true)
-}
-
-func benchmark(b *testing.B, h fasthttp.RequestHandler, isTLS bool) {
-	var serverTLSConfig, clientTLSConfig *tls.Config
-	if isTLS {
-		cert, err := tls.X509KeyPair(certblock, keyblock)
-		if err != nil {
-			b.Fatalf("cannot load TLS certificate: %v", err)
-		}
-		serverTLSConfig = &tls.Config{
-			Certificates:             []tls.Certificate{cert},
-			PreferServerCipherSuites: true,
-		}
-		serverTLSConfig.CurvePreferences = []tls.CurveID{}
-		clientTLSConfig = &tls.Config{
-			InsecureSkipVerify: true,
-		}
-	}
-	ln := fasthttputil.NewInmemoryListener()
-	serverStopCh := make(chan struct{})
-	go func() {
-		serverLn := net.Listener(ln)
-		if serverTLSConfig != nil {
-			serverLn = tls.NewListener(serverLn, serverTLSConfig)
-		}
-		if err := fasthttp.Serve(serverLn, h); err != nil {
-			b.Errorf("unexpected error in server: %v", err)
-		}
-		close(serverStopCh)
-	}()
-	c := &fasthttp.HostClient{
-		Dial: func(addr string) (net.Conn, error) {
-			return ln.Dial()
-		},
-		IsTLS:     isTLS,
-		TLSConfig: clientTLSConfig,
-	}
-
-	b.RunParallel(func(pb *testing.PB) {
-		runRequests(b, pb, c, isTLS)
-	})
-	ln.Close()
-	<-serverStopCh
-}
-
-func streamingHandler(ctx *fasthttp.RequestCtx) {
-	ctx.WriteString("foobar") //nolint:errcheck
-}
-
-func handshakeHandler(ctx *fasthttp.RequestCtx) {
-	streamingHandler(ctx)
-
-	// Explicitly close connection after each response.
-	ctx.SetConnectionClose()
-}
-
-func runRequests(b *testing.B, pb *testing.PB, c *fasthttp.HostClient, isTLS bool) {
-	var req fasthttp.Request
-	if isTLS {
-		req.SetRequestURI("https://foo.bar/baz")
-	} else {
-		req.SetRequestURI("http://foo.bar/baz")
-	}
-	var resp fasthttp.Response
-	for pb.Next() {
-		if err := c.Do(&req, &resp); err != nil {
-			b.Fatalf("unexpected error: %v", err)
-		}
-		if resp.StatusCode() != fasthttp.StatusOK {
-			b.Fatalf("unexpected status code: %d. Expecting %d", resp.StatusCode(), fasthttp.StatusOK)
-		}
-	}
-}

vendor/github.com/valyala/fasthttp/fasthttputil/pipeconns.go

@@ -335,7 +335,7 @@ func releaseByteBuffer(b *byteBuffer) {
 }
 
 var byteBufferPool = &sync.Pool{
-	New: func() interface{} {
+	New: func() any {
 		return &byteBuffer{
 			b: make([]byte, 1024),
 		}

vendor/github.com/valyala/fasthttp/fasthttputil/pipeconns_test.go

@@ -1,407 +0,0 @@
-package fasthttputil
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"net"
-	"testing"
-	"time"
-)
-
-func TestPipeConnsWriteTimeout(t *testing.T) {
-	t.Parallel()
-
-	pc := NewPipeConns()
-	c1 := pc.Conn1()
-
-	deadline := time.Now().Add(time.Millisecond)
-	if err := c1.SetWriteDeadline(deadline); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	data := []byte("foobar")
-	for {
-		_, err := c1.Write(data)
-		if err != nil {
-			if err == ErrTimeout {
-				break
-			}
-			t.Fatalf("unexpected error: %v", err)
-		}
-	}
-
-	for i := 0; i < 10; i++ {
-		_, err := c1.Write(data)
-		if err == nil {
-			t.Fatalf("expecting error")
-		}
-		if err != ErrTimeout {
-			t.Fatalf("unexpected error: %v. Expecting %v", err, ErrTimeout)
-		}
-	}
-
-	// read the written data
-	c2 := pc.Conn2()
-	if err := c2.SetReadDeadline(time.Now().Add(10 * time.Millisecond)); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	for {
-		_, err := c2.Read(data)
-		if err != nil {
-			if err == ErrTimeout {
-				break
-			}
-			t.Fatalf("unexpected error: %v", err)
-		}
-	}
-
-	for i := 0; i < 10; i++ {
-		_, err := c2.Read(data)
-		if err == nil {
-			t.Fatalf("expecting error")
-		}
-		if err != ErrTimeout {
-			t.Fatalf("unexpected error: %v. Expecting %v", err, ErrTimeout)
-		}
-	}
-}
-
-func TestPipeConnsPositiveReadTimeout(t *testing.T) {
-	t.Parallel()
-
-	testPipeConnsReadTimeout(t, time.Millisecond)
-}
-
-func TestPipeConnsNegativeReadTimeout(t *testing.T) {
-	t.Parallel()
-
-	testPipeConnsReadTimeout(t, -time.Second)
-}
-
-var zeroTime time.Time
-
-func testPipeConnsReadTimeout(t *testing.T, timeout time.Duration) {
-	pc := NewPipeConns()
-	c1 := pc.Conn1()
-
-	deadline := time.Now().Add(timeout)
-	if err := c1.SetReadDeadline(deadline); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	var buf [1]byte
-	for i := 0; i < 10; i++ {
-		_, err := c1.Read(buf[:])
-		if err == nil {
-			t.Fatalf("expecting error on iteration %d", i)
-		}
-		if err != ErrTimeout {
-			t.Fatalf("unexpected error on iteration %d: %v. Expecting %v", i, err, ErrTimeout)
-		}
-	}
-
-	// disable deadline and send data from c2 to c1
-	if err := c1.SetReadDeadline(zeroTime); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	data := []byte("foobar")
-	c2 := pc.Conn2()
-	if _, err := c2.Write(data); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	dataBuf := make([]byte, len(data))
-	if _, err := io.ReadFull(c1, dataBuf); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !bytes.Equal(data, dataBuf) {
-		t.Fatalf("unexpected data received: %q. Expecting %q", dataBuf, data)
-	}
-}
-
-func TestPipeConnsCloseWhileReadWriteConcurrent(t *testing.T) {
-	t.Parallel()
-
-	concurrency := 4
-	ch := make(chan struct{}, concurrency)
-	for i := 0; i < concurrency; i++ {
-		go func() {
-			testPipeConnsCloseWhileReadWriteSerial(t)
-			ch <- struct{}{}
-		}()
-	}
-
-	for i := 0; i < concurrency; i++ {
-		select {
-		case <-ch:
-		case <-time.After(5 * time.Second):
-			t.Fatalf("timeout")
-		}
-	}
-}
-
-func TestPipeConnsCloseWhileReadWriteSerial(t *testing.T) {
-	t.Parallel()
-
-	testPipeConnsCloseWhileReadWriteSerial(t)
-}
-
-func testPipeConnsCloseWhileReadWriteSerial(t *testing.T) {
-	for i := 0; i < 10; i++ {
-		testPipeConnsCloseWhileReadWrite(t)
-	}
-}
-
-func testPipeConnsCloseWhileReadWrite(t *testing.T) {
-	pc := NewPipeConns()
-	c1 := pc.Conn1()
-	c2 := pc.Conn2()
-
-	readCh := make(chan error)
-	go func() {
-		var err error
-		if _, err = io.Copy(io.Discard, c1); err != nil {
-			if err != errConnectionClosed {
-				err = fmt.Errorf("unexpected error: %w", err)
-			} else {
-				err = nil
-			}
-		}
-		readCh <- err
-	}()
-
-	writeCh := make(chan error)
-	go func() {
-		var err error
-		for {
-			if _, err = c2.Write([]byte("foobar")); err != nil {
-				if err != errConnectionClosed {
-					err = fmt.Errorf("unexpected error: %w", err)
-				} else {
-					err = nil
-				}
-				break
-			}
-		}
-		writeCh <- err
-	}()
-
-	time.Sleep(10 * time.Millisecond)
-	if err := c1.Close(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if err := c2.Close(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	select {
-	case err := <-readCh:
-		if err != nil {
-			t.Fatalf("unexpected error in reader: %v", err)
-		}
-	case <-time.After(time.Second):
-		t.Fatalf("timeout")
-	}
-	select {
-	case err := <-writeCh:
-		if err != nil {
-			t.Fatalf("unexpected error in writer: %v", err)
-		}
-	case <-time.After(time.Second):
-		t.Fatalf("timeout")
-	}
-}
-
-func TestPipeConnsReadWriteSerial(t *testing.T) {
-	t.Parallel()
-
-	testPipeConnsReadWriteSerial(t)
-}
-
-func TestPipeConnsReadWriteConcurrent(t *testing.T) {
-	t.Parallel()
-
-	testConcurrency(t, 10, testPipeConnsReadWriteSerial)
-}
-
-func testPipeConnsReadWriteSerial(t *testing.T) {
-	pc := NewPipeConns()
-	testPipeConnsReadWrite(t, pc.Conn1(), pc.Conn2())
-
-	pc = NewPipeConns()
-	testPipeConnsReadWrite(t, pc.Conn2(), pc.Conn1())
-}
-
-func testPipeConnsReadWrite(t *testing.T, c1, c2 net.Conn) {
-	defer c1.Close()
-	defer c2.Close()
-
-	var buf [32]byte
-	for i := 0; i < 10; i++ {
-		// The first write
-		s1 := fmt.Sprintf("foo_%d", i)
-		n, err := c1.Write([]byte(s1))
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if n != len(s1) {
-			t.Fatalf("unexpected number of bytes written: %d. Expecting %d", n, len(s1))
-		}
-
-		// The second write
-		s2 := fmt.Sprintf("bar_%d", i)
-		n, err = c1.Write([]byte(s2))
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if n != len(s2) {
-			t.Fatalf("unexpected number of bytes written: %d. Expecting %d", n, len(s2))
-		}
-
-		// Read data written above in two writes
-		s := s1 + s2
-		n, err = c2.Read(buf[:])
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if n != len(s) {
-			t.Fatalf("unexpected number of bytes read: %d. Expecting %d", n, len(s))
-		}
-		if string(buf[:n]) != s {
-			t.Fatalf("unexpected string read: %q. Expecting %q", buf[:n], s)
-		}
-	}
-}
-
-func TestPipeConnsCloseSerial(t *testing.T) {
-	t.Parallel()
-
-	testPipeConnsCloseSerial(t)
-}
-
-func TestPipeConnsCloseConcurrent(t *testing.T) {
-	t.Parallel()
-
-	testConcurrency(t, 10, testPipeConnsCloseSerial)
-}
-
-func testPipeConnsCloseSerial(t *testing.T) {
-	pc := NewPipeConns()
-	testPipeConnsClose(t, pc.Conn1(), pc.Conn2())
-
-	pc = NewPipeConns()
-	testPipeConnsClose(t, pc.Conn2(), pc.Conn1())
-}
-
-func testPipeConnsClose(t *testing.T, c1, c2 net.Conn) {
-	if err := c1.Close(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	var buf [10]byte
-
-	// attempt writing to closed conn
-	for i := 0; i < 10; i++ {
-		n, err := c1.Write(buf[:])
-		if err == nil {
-			t.Fatalf("expecting error")
-		}
-		if n != 0 {
-			t.Fatalf("unexpected number of bytes written: %d. Expecting 0", n)
-		}
-	}
-
-	// attempt reading from closed conn
-	for i := 0; i < 10; i++ {
-		n, err := c2.Read(buf[:])
-		if err == nil {
-			t.Fatalf("expecting error")
-		}
-		if err != io.EOF {
-			t.Fatalf("unexpected error: %v. Expecting %v", err, io.EOF)
-		}
-		if n != 0 {
-			t.Fatalf("unexpected number of bytes read: %d. Expecting 0", n)
-		}
-	}
-
-	if err := c2.Close(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	// attempt closing already closed conns
-	for i := 0; i < 10; i++ {
-		if err := c1.Close(); err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if err := c2.Close(); err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-	}
-}
-
-func testConcurrency(t *testing.T, concurrency int, f func(*testing.T)) {
-	ch := make(chan struct{}, concurrency)
-	for i := 0; i < concurrency; i++ {
-		go func() {
-			f(t)
-			ch <- struct{}{}
-		}()
-	}
-
-	for i := 0; i < concurrency; i++ {
-		select {
-		case <-ch:
-		case <-time.After(time.Second):
-			t.Fatalf("timeout")
-		}
-	}
-}
-
-func TestPipeConnsAddrDefault(t *testing.T) {
-	t.Parallel()
-
-	pc := NewPipeConns()
-	c1 := pc.Conn1()
-
-	if c1.LocalAddr() != pipeAddr(0) {
-		t.Fatalf("unexpected local address: %v", c1.LocalAddr())
-	}
-
-	if c1.RemoteAddr() != pipeAddr(0) {
-		t.Fatalf("unexpected remote address: %v", c1.RemoteAddr())
-	}
-}
-
-func TestPipeConnsAddrCustom(t *testing.T) {
-	t.Parallel()
-
-	pc := NewPipeConns()
-
-	addr1 := &net.TCPAddr{IP: net.IPv4(1, 2, 3, 4), Port: 1234}
-	addr2 := &net.TCPAddr{IP: net.IPv4(5, 6, 7, 8), Port: 5678}
-	addr3 := &net.TCPAddr{IP: net.IPv4(9, 10, 11, 12), Port: 9012}
-	addr4 := &net.TCPAddr{IP: net.IPv4(13, 14, 15, 16), Port: 3456}
-
-	pc.SetAddresses(addr1, addr2, addr3, addr4)
-
-	c1 := pc.Conn1()
-
-	if c1.LocalAddr() != addr1 {
-		t.Fatalf("unexpected local address: %v", c1.LocalAddr())
-	}
-
-	if c1.RemoteAddr() != addr2 {
-		t.Fatalf("unexpected remote address: %v", c1.RemoteAddr())
-	}
-
-	c2 := pc.Conn1()
-
-	if c2.LocalAddr() != addr1 {
-		t.Fatalf("unexpected local address: %v", c2.LocalAddr())
-	}
-
-	if c2.RemoteAddr() != addr2 {
-		t.Fatalf("unexpected remote address: %v", c2.RemoteAddr())
-	}
-}

vendor/github.com/valyala/fasthttp/fs.go

@@ -100,7 +100,7 @@ func ServeFile(ctx *RequestCtx, path string) {
 		rootFSHandler = rootFS.NewRequestHandler()
 	})
 
-	if len(path) == 0 || !filepath.IsAbs(path) {
+	if path == "" || !filepath.IsAbs(path) {
 		// extend relative path to absolute path
 		hasTrailingSlash := len(path) > 0 && (path[len(path)-1] == '/' || path[len(path)-1] == '\\')
 
@@ -429,7 +429,7 @@ func (fs *FS) normalizeRoot(root string) string {
 	// fs.FS uses relative paths, that paths are slash-separated on all systems, even Windows.
 	if fs.FS == nil {
 		// Serve files from the current working directory if Root is empty or if Root is a relative path.
-		if (!fs.AllowEmptyRoot && len(root) == 0) || (len(root) > 0 && !filepath.IsAbs(root)) {
+		if (!fs.AllowEmptyRoot && root == "") || (root != "" && !filepath.IsAbs(root)) {
 			path, err := os.Getwd()
 			if err != nil {
 				path = "."
@@ -452,14 +452,14 @@ func (fs *FS) initRequestHandler() {
 	root := fs.normalizeRoot(fs.Root)
 
 	compressRoot := fs.CompressRoot
-	if len(compressRoot) == 0 {
+	if compressRoot == "" {
 		compressRoot = root
 	} else {
 		compressRoot = fs.normalizeRoot(compressRoot)
 	}
 
 	compressedFileSuffixes := fs.CompressedFileSuffixes
-	if len(compressedFileSuffixes["br"]) == 0 || len(compressedFileSuffixes["gzip"]) == 0 ||
+	if compressedFileSuffixes["br"] == "" || compressedFileSuffixes["gzip"] == "" ||
 		compressedFileSuffixes["br"] == compressedFileSuffixes["gzip"] {
 		// Copy global map
 		compressedFileSuffixes = make(map[string]string, len(FSCompressedFileSuffixes))
@@ -558,7 +558,7 @@ func (ff *fsFile) smallFileReader() (io.Reader, error) {
 	return r, nil
 }
 
-// files bigger than this size are sent with sendfile
+// Files bigger than this size are sent with sendfile.
 const maxSmallFileSize = 2 * 4096
 
 func (ff *fsFile) isBig() bool {
@@ -961,7 +961,9 @@ func (cm *inMemoryCacheManager) cleanCache(pendingFiles []*fsFile) []*fsFile {
 	return pendingFiles
 }
 
-func cleanCacheNolock(cache map[string]*fsFile, pendingFiles, filesToRelease []*fsFile, cacheDuration time.Duration) ([]*fsFile, []*fsFile) {
+func cleanCacheNolock(
+	cache map[string]*fsFile, pendingFiles, filesToRelease []*fsFile, cacheDuration time.Duration,
+) ([]*fsFile, []*fsFile) {
 	t := time.Now()
 	for k, ff := range cache {
 		if t.Sub(ff.t) > cacheDuration {
@@ -1381,7 +1383,9 @@ func (h *fsHandler) compressAndOpenFSFile(filePath string, fileEncoding string)
 	return ff, err
 }
 
-func (h *fsHandler) compressFileNolock(f fs.File, fileInfo fs.FileInfo, filePath, compressedFilePath string, fileEncoding string) (*fsFile, error) {
+func (h *fsHandler) compressFileNolock(
+	f fs.File, fileInfo fs.FileInfo, filePath, compressedFilePath, fileEncoding string,
+) (*fsFile, error) {
 	// Attempt to open compressed file created by another concurrent
 	// goroutine.
 	// It is safe opening such a file, since the file creation
@@ -1432,7 +1436,7 @@ func (h *fsHandler) compressFileNolock(f fs.File, fileInfo fs.FileInfo, filePath
 	return h.newCompressedFSFile(compressedFilePath, fileEncoding)
 }
 
-// newCompressedFSFileCache use memory cache compressed files
+// newCompressedFSFileCache use memory cache compressed files.
 func (h *fsHandler) newCompressedFSFileCache(f fs.File, fileInfo fs.FileInfo, filePath, fileEncoding string) (*fsFile, error) {
 	var (
 		w   = &bytebufferpool.ByteBuffer{}
@@ -1470,7 +1474,7 @@ func (h *fsHandler) newCompressedFSFileCache(f fs.File, fileInfo fs.FileInfo, fi
 
 	ext := fileExtension(fileInfo.Name(), false, h.compressedFileSuffixes[fileEncoding])
 	contentType := mime.TypeByExtension(ext)
-	if len(contentType) == 0 {
+	if contentType == "" {
 		data, err := readFileHeader(f, false, fileEncoding)
 		if err != nil {
 			return nil, fmt.Errorf("cannot read header of the file %q: %w", fileInfo.Name(), err)
@@ -1569,7 +1573,7 @@ func (h *fsHandler) newFSFile(f fs.File, fileInfo fs.FileInfo, compressed bool,
 	// detect content-type
 	ext := fileExtension(fileInfo.Name(), compressed, h.compressedFileSuffixes[fileEncoding])
 	contentType := mime.TypeByExtension(ext)
-	if len(contentType) == 0 {
+	if contentType == "" {
 		data, err := readFileHeader(f, compressed, fileEncoding)
 		if err != nil {
 			return nil, fmt.Errorf("cannot read header of the file %q: %w", fileInfo.Name(), err)

vendor/github.com/valyala/fasthttp/header.go

@@ -344,7 +344,7 @@ func (h *ResponseHeader) SetContentEncodingBytes(contentEncoding []byte) {
 	h.contentEncoding = append(h.contentEncoding[:0], contentEncoding...)
 }
 
-// addVaryBytes add value to the 'Vary' header if it's not included
+// addVaryBytes add value to the 'Vary' header if it's not included.
 func (h *ResponseHeader) addVaryBytes(value []byte) {
 	v := h.peek(strVary)
 	if len(v) == 0 {
@@ -545,6 +545,85 @@ func (h *ResponseHeader) AddTrailerBytes(trailer []byte) error {
 	return err
 }
 
+// validHeaderFieldByte returns true if c is a valid tchar as defined
+// by section 5.6.2 of [RFC9110].
+func validHeaderFieldByte(c byte) bool {
+	return c < 128 && tcharTable[c] == 1
+}
+
+// VisitHeaderParams calls f for each parameter in the given header bytes.
+// It stops processing when f returns false or an invalid parameter is found.
+// Parameter values may be quoted, in which case \ is treated as an escape
+// character, and the value is unquoted before being passed to value.
+// See: https://www.rfc-editor.org/rfc/rfc9110#section-5.6.6
+//
+// f must not retain references to key and/or value after returning.
+// Copy key and/or value contents before returning if you need retaining them.
+func VisitHeaderParams(b []byte, f func(key, value []byte) bool) {
+	for len(b) > 0 {
+		idxSemi := 0
+		for idxSemi < len(b) && b[idxSemi] != ';' {
+			idxSemi++
+		}
+		if idxSemi >= len(b) {
+			return
+		}
+		b = b[idxSemi+1:]
+		for len(b) > 0 && b[0] == ' ' {
+			b = b[1:]
+		}
+
+		n := 0
+		if len(b) == 0 || !validHeaderFieldByte(b[n]) {
+			return
+		}
+		n++
+		for n < len(b) && validHeaderFieldByte(b[n]) {
+			n++
+		}
+
+		if n >= len(b)-1 || b[n] != '=' {
+			return
+		}
+		param := b[:n]
+		n++
+
+		switch {
+		case validHeaderFieldByte(b[n]):
+			m := n
+			n++
+			for n < len(b) && validHeaderFieldByte(b[n]) {
+				n++
+			}
+			if !f(param, b[m:n]) {
+				return
+			}
+		case b[n] == '"':
+			foundEndQuote := false
+			escaping := false
+			n++
+			m := n
+			for ; n < len(b); n++ {
+				if b[n] == '"' && !escaping {
+					foundEndQuote = true
+					break
+				}
+				escaping = (b[n] == '\\' && !escaping)
+			}
+			if !foundEndQuote {
+				return
+			}
+			if !f(param, b[m:n]) {
+				return
+			}
+			n++
+		default:
+			return
+		}
+		b = b[n:]
+	}
+}
+
 // MultipartFormBoundary returns boundary part
 // from 'multipart/form-data; boundary=...' Content-Type.
 func (h *RequestHeader) MultipartFormBoundary() []byte {
@@ -948,7 +1027,7 @@ func (h *RequestHeader) DisableNormalizing() {
 //   - conteNT-tYPE -> Content-Type
 //   - foo-bar-baz -> Foo-Bar-Baz
 //
-// This is enabled by default unless disabled using DisableNormalizing()
+// This is enabled by default unless disabled using DisableNormalizing().
 func (h *RequestHeader) EnableNormalizing() {
 	h.disableNormalizing = false
 }
@@ -980,7 +1059,7 @@ func (h *ResponseHeader) DisableNormalizing() {
 //   - conteNT-tYPE -> Content-Type
 //   - foo-bar-baz -> Foo-Bar-Baz
 //
-// This is enabled by default unless disabled using DisableNormalizing()
+// This is enabled by default unless disabled using DisableNormalizing().
 func (h *ResponseHeader) EnableNormalizing() {
 	h.disableNormalizing = false
 }
@@ -1350,7 +1429,7 @@ func (h *ResponseHeader) setSpecialHeader(key, value []byte) bool {
 	return false
 }
 
-// setNonSpecial directly put into map i.e. not a basic header
+// setNonSpecial directly put into map i.e. not a basic header.
 func (h *ResponseHeader) setNonSpecial(key []byte, value []byte) {
 	h.h = setArgBytes(h.h, key, value, argsHasValue)
 }
@@ -1409,7 +1488,7 @@ func (h *RequestHeader) setSpecialHeader(key, value []byte) bool {
 	return false
 }
 
-// setNonSpecial directly put into map i.e. not a basic header
+// setNonSpecial directly put into map i.e. not a basic header.
 func (h *RequestHeader) setNonSpecial(key []byte, value []byte) {
 	h.h = setArgBytes(h.h, key, value, argsHasValue)
 }
@@ -2791,24 +2870,40 @@ func (h *RequestHeader) parseFirstLine(buf []byte) (int, error) {
 	h.method = append(h.method[:0], b[:n]...)
 	b = b[n+1:]
 
-	protoStr := strHTTP11
 	// parse requestURI
 	n = bytes.LastIndexByte(b, ' ')
-	switch {
-	case n < 0:
-		h.noHTTP11 = true
-		n = len(b)
-		protoStr = strHTTP10
-	case n == 0:
+	if n < 0 {
+		return 0, fmt.Errorf("cannot find whitespace in the first line of request %q", buf)
+	} else if n == 0 {
 		if h.secureErrorLogMessage {
 			return 0, fmt.Errorf("requestURI cannot be empty")
 		}
 		return 0, fmt.Errorf("requestURI cannot be empty in %q", buf)
-	case !bytes.Equal(b[n+1:], strHTTP11):
-		h.noHTTP11 = true
-		protoStr = b[n+1:]
 	}
 
+	protoStr := b[n+1:]
+
+	// Follow RFCs 7230 and 9112 and require that HTTP versions match the following pattern: HTTP/[0-9]\.[0-9]
+	if len(protoStr) != len(strHTTP11) {
+		if h.secureErrorLogMessage {
+			return 0, fmt.Errorf("unsupported HTTP version %q", protoStr)
+		}
+		return 0, fmt.Errorf("unsupported HTTP version %q in %q", protoStr, buf)
+	}
+	if !bytes.HasPrefix(protoStr, strHTTP11[:5]) {
+		if h.secureErrorLogMessage {
+			return 0, fmt.Errorf("unsupported HTTP version %q", protoStr)
+		}
+		return 0, fmt.Errorf("unsupported HTTP version %q in %q", protoStr, buf)
+	}
+	if protoStr[5] < '0' || protoStr[5] > '9' || protoStr[7] < '0' || protoStr[7] > '9' {
+		if h.secureErrorLogMessage {
+			return 0, fmt.Errorf("unsupported HTTP version %q", protoStr)
+		}
+		return 0, fmt.Errorf("unsupported HTTP version %q in %q", protoStr, buf)
+	}
+
+	h.noHTTP11 = !bytes.Equal(protoStr, strHTTP11)
 	h.proto = append(h.proto[:0], protoStr...)
 	h.requestURI = append(h.requestURI[:0], b[:n]...)
 
@@ -2934,6 +3029,8 @@ func (h *ResponseHeader) parseHeaders(buf []byte) (int, error) {
 func (h *RequestHeader) parseHeaders(buf []byte) (int, error) {
 	h.contentLength = -2
 
+	contentLengthSeen := false
+
 	var s headerScanner
 	s.b = buf
 	s.disableNormalizing = h.disableNormalizing
@@ -2969,6 +3066,11 @@ func (h *RequestHeader) parseHeaders(buf []byte) (int, error) {
 					continue
 				}
 				if caseInsensitiveCompare(s.key, strContentLength) {
+					if contentLengthSeen {
+						return 0, fmt.Errorf("duplicate Content-Length header")
+					}
+					contentLengthSeen = true
+
 					if h.contentLength != -1 {
 						var nerr error
 						if h.contentLength, nerr = parseContentLength(s.value); nerr != nil {
@@ -2993,7 +3095,17 @@ func (h *RequestHeader) parseHeaders(buf []byte) (int, error) {
 				}
 			case 't':
 				if caseInsensitiveCompare(s.key, strTransferEncoding) {
-					if !bytes.Equal(s.value, strIdentity) {
+					isIdentity := caseInsensitiveCompare(s.value, strIdentity)
+					isChunked := caseInsensitiveCompare(s.value, strChunked)
+
+					if !isIdentity && !isChunked {
+						if h.secureErrorLogMessage {
+							return 0, fmt.Errorf("unsupported Transfer-Encoding")
+						}
+						return 0, fmt.Errorf("unsupported Transfer-Encoding: %q", s.value)
+					}
+
+					if isChunked {
 						h.contentLength = -1
 						h.h = setArgBytes(h.h, strTransferEncoding, strChunked, argsHasValue)
 					}
@@ -3332,7 +3444,7 @@ func normalizeHeaderKey(b []byte, disableNormalizing bool) {
 	}
 }
 
-// removeNewLines will replace `\r` and `\n` with an empty space
+// removeNewLines will replace `\r` and `\n` with an empty space.
 func removeNewLines(raw []byte) []byte {
 	// check if a `\r` is present and save the position.
 	// if no `\r` is found, check if a `\n` is present.

vendor/github.com/valyala/fasthttp/headers.go

@@ -1,14 +1,14 @@
 package fasthttp
 
-// Headers
+// Headers.
 const (
-	// Authentication
+	// Authentication.
 	HeaderAuthorization      = "Authorization"
 	HeaderProxyAuthenticate  = "Proxy-Authenticate"
 	HeaderProxyAuthorization = "Proxy-Authorization"
 	HeaderWWWAuthenticate    = "WWW-Authenticate"
 
-	// Caching
+	// Caching.
 	HeaderAge           = "Age"
 	HeaderCacheControl  = "Cache-Control"
 	HeaderClearSiteData = "Clear-Site-Data"
@@ -16,7 +16,7 @@ const (
 	HeaderPragma        = "Pragma"
 	HeaderWarning       = "Warning"
 
-	// Client hints
+	// Client hints.
 	HeaderAcceptCH         = "Accept-CH"
 	HeaderAcceptCHLifetime = "Accept-CH-Lifetime"
 	HeaderContentDPR       = "Content-DPR"
@@ -26,7 +26,7 @@ const (
 	HeaderViewportWidth    = "Viewport-Width"
 	HeaderWidth            = "Width"
 
-	// Conditionals
+	// Conditionals.
 	HeaderETag              = "ETag"
 	HeaderIfMatch           = "If-Match"
 	HeaderIfModifiedSince   = "If-Modified-Since"
@@ -35,24 +35,24 @@ const (
 	HeaderLastModified      = "Last-Modified"
 	HeaderVary              = "Vary"
 
-	// Connection management
+	// Connection management.
 	HeaderConnection      = "Connection"
 	HeaderKeepAlive       = "Keep-Alive"
 	HeaderProxyConnection = "Proxy-Connection"
 
-	// Content negotiation
+	// Content negotiation.
 	HeaderAccept         = "Accept"
 	HeaderAcceptCharset  = "Accept-Charset"
 	HeaderAcceptEncoding = "Accept-Encoding"
 	HeaderAcceptLanguage = "Accept-Language"
 
-	// Controls
+	// Controls.
 	HeaderCookie      = "Cookie"
 	HeaderExpect      = "Expect"
 	HeaderMaxForwards = "Max-Forwards"
 	HeaderSetCookie   = "Set-Cookie"
 
-	// CORS
+	// CORS.
 	HeaderAccessControlAllowCredentials = "Access-Control-Allow-Credentials"
 	HeaderAccessControlAllowHeaders     = "Access-Control-Allow-Headers"
 	HeaderAccessControlAllowMethods     = "Access-Control-Allow-Methods"
@@ -65,48 +65,48 @@ const (
 	HeaderTimingAllowOrigin             = "Timing-Allow-Origin"
 	HeaderXPermittedCrossDomainPolicies = "X-Permitted-Cross-Domain-Policies"
 
-	// Do Not Track
+	// Do Not Track.
 	HeaderDNT = "DNT"
 	HeaderTk  = "Tk"
 
-	// Downloads
+	// Downloads.
 	HeaderContentDisposition = "Content-Disposition"
 
-	// Message body information
+	// Message body information.
 	HeaderContentEncoding = "Content-Encoding"
 	HeaderContentLanguage = "Content-Language"
 	HeaderContentLength   = "Content-Length"
 	HeaderContentLocation = "Content-Location"
 	HeaderContentType     = "Content-Type"
 
-	// Proxies
+	// Proxies.
 	HeaderForwarded       = "Forwarded"
 	HeaderVia             = "Via"
 	HeaderXForwardedFor   = "X-Forwarded-For"
 	HeaderXForwardedHost  = "X-Forwarded-Host"
 	HeaderXForwardedProto = "X-Forwarded-Proto"
 
-	// Redirects
+	// Redirects.
 	HeaderLocation = "Location"
 
-	// Request context
+	// Request context.
 	HeaderFrom           = "From"
 	HeaderHost           = "Host"
 	HeaderReferer        = "Referer"
 	HeaderReferrerPolicy = "Referrer-Policy"
 	HeaderUserAgent      = "User-Agent"
 
-	// Response context
+	// Response context.
 	HeaderAllow  = "Allow"
 	HeaderServer = "Server"
 
-	// Range requests
+	// Range requests.
 	HeaderAcceptRanges = "Accept-Ranges"
 	HeaderContentRange = "Content-Range"
 	HeaderIfRange      = "If-Range"
 	HeaderRange        = "Range"
 
-	// Security
+	// Security.
 	HeaderContentSecurityPolicy           = "Content-Security-Policy"
 	HeaderContentSecurityPolicyReportOnly = "Content-Security-Policy-Report-Only"
 	HeaderCrossOriginResourcePolicy       = "Cross-Origin-Resource-Policy"
@@ -122,26 +122,26 @@ const (
 	HeaderXPoweredBy                      = "X-Powered-By"
 	HeaderXXSSProtection                  = "X-XSS-Protection"
 
-	// Server-sent event
+	// Server-sent event.
 	HeaderLastEventID = "Last-Event-ID"
 	HeaderNEL         = "NEL"
 	HeaderPingFrom    = "Ping-From"
 	HeaderPingTo      = "Ping-To"
 	HeaderReportTo    = "Report-To"
 
-	// Transfer coding
+	// Transfer coding.
 	HeaderTE               = "TE"
 	HeaderTrailer          = "Trailer"
 	HeaderTransferEncoding = "Transfer-Encoding"
 
-	// WebSockets
+	// WebSockets.
 	HeaderSecWebSocketAccept     = "Sec-WebSocket-Accept"
 	HeaderSecWebSocketExtensions = "Sec-WebSocket-Extensions" /* #nosec G101 */
 	HeaderSecWebSocketKey        = "Sec-WebSocket-Key"
 	HeaderSecWebSocketProtocol   = "Sec-WebSocket-Protocol"
 	HeaderSecWebSocketVersion    = "Sec-WebSocket-Version"
 
-	// Other
+	// Other.
 	HeaderAcceptPatch         = "Accept-Patch"
 	HeaderAcceptPushPolicy    = "Accept-Push-Policy"
 	HeaderAcceptSignature     = "Accept-Signature"

vendor/github.com/valyala/fasthttp/http.go

@@ -38,7 +38,7 @@ func SetBodySizePoolLimit(reqBodyLimit, respBodyLimit int) {
 type Request struct {
 	noCopy noCopy
 
-	// Request header
+	// Request header.
 	//
 	// Copying Header by value is forbidden. Use pointer to Header instead.
 	Header RequestHeader
@@ -88,7 +88,7 @@ type Request struct {
 type Response struct {
 	noCopy noCopy
 
-	// Response header
+	// Response header.
 	//
 	// Copying Header by value is forbidden. Use pointer to Header instead.
 	Header ResponseHeader
@@ -116,9 +116,9 @@ type Response struct {
 	keepBodyBuffer        bool
 	secureErrorLogMessage bool
 
-	// Remote TCPAddr from concurrently net.Conn
+	// Remote TCPAddr from concurrently net.Conn.
 	raddr net.Addr
-	// Local TCPAddr from concurrently net.Conn
+	// Local TCPAddr from concurrently net.Conn.
 	laddr net.Addr
 }
 
@@ -250,12 +250,12 @@ func (resp *Response) SetBodyStream(bodyStream io.Reader, bodySize int) {
 	resp.Header.SetContentLength(bodySize)
 }
 
-// IsBodyStream returns true if body is set via SetBodyStream*
+// IsBodyStream returns true if body is set via SetBodyStream*.
 func (req *Request) IsBodyStream() bool {
 	return req.bodyStream != nil
 }
 
-// IsBodyStream returns true if body is set via SetBodyStream*
+// IsBodyStream returns true if body is set via SetBodyStream*.
 func (resp *Response) IsBodyStream() bool {
 	return resp.bodyStream != nil
 }
@@ -302,7 +302,7 @@ func (resp *Response) BodyWriter() io.Writer {
 	return &resp.w
 }
 
-// BodyStream returns io.Reader
+// BodyStream returns io.Reader.
 //
 // You must CloseBodyStream or ReleaseRequest after you use it.
 func (req *Request) BodyStream() io.Reader {
@@ -313,7 +313,7 @@ func (req *Request) CloseBodyStream() error {
 	return req.closeBodyStream()
 }
 
-// BodyStream returns io.Reader
+// BodyStream returns io.Reader.
 //
 // You must CloseBodyStream or ReleaseResponse after you use it.
 func (resp *Response) BodyStream() io.Reader {
@@ -894,13 +894,13 @@ func swapResponseBody(a, b *Response) {
 	a.bodyStream, b.bodyStream = b.bodyStream, a.bodyStream
 }
 
-// URI returns request URI
+// URI returns request URI.
 func (req *Request) URI() *URI {
 	req.parseURI() //nolint:errcheck
 	return &req.uri
 }
 
-// SetURI initializes request URI
+// SetURI initializes request URI.
 // Use this method if a single URI may be reused across multiple requests.
 // Otherwise, you can just use SetRequestURI() and it will be parsed as new URI.
 // The URI is copied and can be safely modified later.
@@ -958,7 +958,7 @@ func (req *Request) MultipartForm() (*multipart.Form, error) {
 	}
 
 	req.multipartFormBoundary = string(req.Header.MultipartFormBoundary())
-	if len(req.multipartFormBoundary) == 0 {
+	if req.multipartFormBoundary == "" {
 		return nil, ErrNoMultipartForm
 	}
 
@@ -1014,7 +1014,7 @@ func marshalMultipartForm(f *multipart.Form, boundary string) ([]byte, error) {
 func WriteMultipartForm(w io.Writer, f *multipart.Form, boundary string) error {
 	// Do not care about memory allocations here, since multipart
 	// form processing is slow.
-	if len(boundary) == 0 {
+	if boundary == "" {
 		return errors.New("form boundary cannot be empty")
 	}
 
@@ -1849,7 +1849,7 @@ func (resp *Response) deflateBody(level int) error {
 	return nil
 }
 
-// Bodies with sizes smaller than minCompressLen aren't compressed at all
+// Bodies with sizes smaller than minCompressLen aren't compressed at all.
 const minCompressLen = 200
 
 type writeFlusher interface {
@@ -2104,10 +2104,19 @@ func limitedReaderSize(r io.Reader) int64 {
 
 func writeBodyFixedSize(w *bufio.Writer, r io.Reader, size int64) error {
 	if size > maxSmallFileSize {
-		// w buffer must be empty for triggering
-		// sendfile path in bufio.Writer.ReadFrom.
-		if err := w.Flush(); err != nil {
-			return err
+		earlyFlush := false
+		switch r := r.(type) {
+		case *os.File:
+			earlyFlush = true
+		case *io.LimitedReader:
+			_, earlyFlush = r.R.(*os.File)
+		}
+		if earlyFlush {
+			// w buffer must be empty for triggering
+			// sendfile path in bufio.Writer.ReadFrom.
+			if err := w.Flush(); err != nil {
+				return err
+			}
 		}
 	}
 
@@ -2120,6 +2129,12 @@ func writeBodyFixedSize(w *bufio.Writer, r io.Reader, size int64) error {
 }
 
 func copyZeroAlloc(w io.Writer, r io.Reader) (int64, error) {
+	if wt, ok := r.(io.WriterTo); ok {
+		return wt.WriteTo(w)
+	}
+	if rt, ok := w.(io.ReaderFrom); ok {
+		return rt.ReadFrom(r)
+	}
 	vbuf := copyBufPool.Get()
 	buf := vbuf.([]byte)
 	n, err := io.CopyBuffer(w, r, buf)
@@ -2128,7 +2143,7 @@ func copyZeroAlloc(w io.Writer, r io.Reader) (int64, error) {
 }
 
 var copyBufPool = sync.Pool{
-	New: func() interface{} {
+	New: func() any {
 		return make([]byte, 4096)
 	},
 }
@@ -2351,8 +2366,14 @@ func readCrLf(r *bufio.Reader) error {
 
 // SetTimeout sets timeout for the request.
 //
-// req.SetTimeout(t); c.Do(&req, &resp) is equivalent to
-// c.DoTimeout(&req, &resp, t)
+// The following code:
+//
+//	req.SetTimeout(t)
+//	c.Do(&req, &resp)
+//
+// is equivalent to
+//
+//	c.DoTimeout(&req, &resp, t)
 func (req *Request) SetTimeout(t time.Duration) {
 	req.timeout = t
 }

vendor/github.com/valyala/fasthttp/lbclient.go

@@ -59,12 +59,12 @@ type LBClient struct {
 // The timeout may be overridden via LBClient.Timeout.
 const DefaultLBClientTimeout = time.Second
 
-// DoDeadline calls DoDeadline on the least loaded client
+// DoDeadline calls DoDeadline on the least loaded client.
 func (cc *LBClient) DoDeadline(req *Request, resp *Response, deadline time.Time) error {
 	return cc.get().DoDeadline(req, resp, deadline)
 }
 
-// DoTimeout calculates deadline and calls DoDeadline on the least loaded client
+// DoTimeout calculates deadline and calls DoDeadline on the least loaded client.
 func (cc *LBClient) DoTimeout(req *Request, resp *Response, timeout time.Duration) error {
 	deadline := time.Now().Add(timeout)
 	return cc.get().DoDeadline(req, resp, deadline)
@@ -95,8 +95,8 @@ func (cc *LBClient) init() {
 	}
 }
 
-// AddClient adds a new client to the balanced clients
-// returns the new total number of clients
+// AddClient adds a new client to the balanced clients and
+// returns the new total number of clients.
 func (cc *LBClient) AddClient(c BalancingClient) int {
 	cc.mu.Lock()
 	cc.cs = append(cc.cs, &lbClient{
@@ -107,9 +107,9 @@ func (cc *LBClient) AddClient(c BalancingClient) int {
 	return len(cc.cs)
 }
 
-// RemoveClients removes clients using the provided callback
-// if rc returns true, the passed client will be removed
-// returns the new total number of clients
+// RemoveClients removes clients using the provided callback.
+// If rc returns true, the passed client will be removed.
+// Returns the new total number of clients.
 func (cc *LBClient) RemoveClients(rc func(BalancingClient) bool) int {
 	cc.mu.Lock()
 	n := 0

vendor/github.com/valyala/fasthttp/s2b_new.go

@@ -1,4 +1,4 @@
-//go:build go1.20
+//go:build go1.20 || go1.21
 
 package fasthttp
 

vendor/github.com/valyala/fasthttp/s2b_old.go

@@ -1,4 +1,4 @@
-//go:build !go1.20
+//go:build !go1.20 && !go1.21
 
 package fasthttp
 

vendor/github.com/valyala/fasthttp/server.go

@@ -19,6 +19,7 @@ import (
 
 var errNoCertOrKeyProvided = errors.New("cert or key has not provided")
 
+// ErrAlreadyServing is deprecated.
 // Deprecated: ErrAlreadyServing is never returned from Serve. See issue #633.
 var ErrAlreadyServing = errors.New("Server is already serving connections")
 
@@ -164,20 +165,20 @@ type Server struct {
 	//   * ErrBrokenChunks
 	ErrorHandler func(ctx *RequestCtx, err error)
 
-	// HeaderReceived is called after receiving the header
+	// HeaderReceived is called after receiving the header.
 	//
-	// non zero RequestConfig field values will overwrite the default configs
+	// Non zero RequestConfig field values will overwrite the default configs
 	HeaderReceived func(header *RequestHeader) RequestConfig
 
-	// ContinueHandler is called after receiving the Expect 100 Continue Header
+	// ContinueHandler is called after receiving the Expect 100 Continue Header.
 	//
 	// https://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html#sec8.2.3
 	// https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.1.1
 	// Using ContinueHandler a server can make decisioning on whether or not
-	// to read a potentially large request body based on the headers
+	// to read a potentially large request body based on the headers.
 	//
 	// The default is to automatically read request bodies of Expect 100 Continue requests
-	// like they are normal requests
+	// like they are normal requests.
 	ContinueHandler func(header *RequestHeader) bool
 
 	// Server name for sending in response headers.
@@ -430,6 +431,8 @@ type Server struct {
 	open int32
 	stop int32
 	done chan struct{}
+
+	rejectedRequestsCount uint32
 }
 
 // TimeoutHandler creates RequestHandler, which returns StatusRequestTimeout
@@ -484,18 +487,18 @@ func TimeoutWithCodeHandler(h RequestHandler, timeout time.Duration, msg string,
 	}
 }
 
-// RequestConfig configure the per request deadline and body limits
+// RequestConfig configure the per request deadline and body limits.
 type RequestConfig struct {
 	// ReadTimeout is the maximum duration for reading the entire
 	// request body.
-	// a zero value means that default values will be honored
+	// A zero value means that default values will be honored.
 	ReadTimeout time.Duration
 	// WriteTimeout is the maximum duration before timing out
 	// writes of the response.
-	// a zero value means that default values will be honored
+	// A zero value means that default values will be honored.
 	WriteTimeout time.Duration
 	// Maximum request body size.
-	// a zero value means that default values will be honored
+	// A zero value means that default values will be honored.
 	MaxRequestBodySize int
 }
 
@@ -674,7 +677,7 @@ func (ctx *RequestCtx) Hijacked() bool {
 // All the values are removed from ctx after returning from the top
 // RequestHandler. Additionally, Close method is called on each value
 // implementing io.Closer before removing the value from ctx.
-func (ctx *RequestCtx) SetUserValue(key interface{}, value interface{}) {
+func (ctx *RequestCtx) SetUserValue(key any, value any) {
 	ctx.userValues.Set(key, value)
 }
 
@@ -687,18 +690,18 @@ func (ctx *RequestCtx) SetUserValue(key interface{}, value interface{}) {
 // functions involved in request processing.
 //
 // All the values stored in ctx are deleted after returning from RequestHandler.
-func (ctx *RequestCtx) SetUserValueBytes(key []byte, value interface{}) {
+func (ctx *RequestCtx) SetUserValueBytes(key []byte, value any) {
 	ctx.userValues.SetBytes(key, value)
 }
 
 // UserValue returns the value stored via SetUserValue* under the given key.
-func (ctx *RequestCtx) UserValue(key interface{}) interface{} {
+func (ctx *RequestCtx) UserValue(key any) any {
 	return ctx.userValues.Get(key)
 }
 
 // UserValueBytes returns the value stored via SetUserValue*
 // under the given key.
-func (ctx *RequestCtx) UserValueBytes(key []byte) interface{} {
+func (ctx *RequestCtx) UserValueBytes(key []byte) any {
 	return ctx.userValues.GetBytes(key)
 }
 
@@ -706,7 +709,7 @@ func (ctx *RequestCtx) UserValueBytes(key []byte) interface{} {
 //
 // visitor must not retain references to key and value after returning.
 // Make key and/or value copies if you need storing them after returning.
-func (ctx *RequestCtx) VisitUserValues(visitor func([]byte, interface{})) {
+func (ctx *RequestCtx) VisitUserValues(visitor func([]byte, any)) {
 	for i, n := 0, len(ctx.userValues); i < n; i++ {
 		kv := &ctx.userValues[i]
 		if _, ok := kv.key.(string); ok {
@@ -719,20 +722,20 @@ func (ctx *RequestCtx) VisitUserValues(visitor func([]byte, interface{})) {
 //
 // visitor must not retain references to key and value after returning.
 // Make key and/or value copies if you need storing them after returning.
-func (ctx *RequestCtx) VisitUserValuesAll(visitor func(interface{}, interface{})) {
+func (ctx *RequestCtx) VisitUserValuesAll(visitor func(any, any)) {
 	for i, n := 0, len(ctx.userValues); i < n; i++ {
 		kv := &ctx.userValues[i]
 		visitor(kv.key, kv.value)
 	}
 }
 
-// ResetUserValues allows to reset user values from Request Context
+// ResetUserValues allows to reset user values from Request Context.
 func (ctx *RequestCtx) ResetUserValues() {
 	ctx.userValues.Reset()
 }
 
 // RemoveUserValue removes the given key and the value under it in ctx.
-func (ctx *RequestCtx) RemoveUserValue(key interface{}) {
+func (ctx *RequestCtx) RemoveUserValue(key any) {
 	ctx.userValues.Remove(key)
 }
 
@@ -854,7 +857,7 @@ func (r *firstByteReader) Read(b []byte) (int, error) {
 // Logger is used for logging formatted messages.
 type Logger interface {
 	// Printf must have the same semantics as log.Printf.
-	Printf(format string, args ...interface{})
+	Printf(format string, args ...any)
 }
 
 var ctxLoggerLock sync.Mutex
@@ -864,7 +867,7 @@ type ctxLogger struct {
 	logger Logger
 }
 
-func (cl *ctxLogger) Printf(format string, args ...interface{}) {
+func (cl *ctxLogger) Printf(format string, args ...any) {
 	msg := fmt.Sprintf(format, args...)
 	ctxLoggerLock.Lock()
 	cl.logger.Printf("%.3f %s - %s", time.Since(cl.ctx.ConnTime()).Seconds(), cl.ctx.String(), msg)
@@ -879,7 +882,8 @@ var zeroTCPAddr = &net.TCPAddr{
 //
 // The returned value may be useful for logging.
 func (ctx *RequestCtx) String() string {
-	return fmt.Sprintf("#%016X - %s<->%s - %s %s", ctx.ID(), ctx.LocalAddr(), ctx.RemoteAddr(), ctx.Request.Header.Method(), ctx.URI().FullURI())
+	return fmt.Sprintf("#%016X - %s<->%s - %s %s", ctx.ID(), ctx.LocalAddr(), ctx.RemoteAddr(),
+		ctx.Request.Header.Method(), ctx.URI().FullURI())
 }
 
 // ID returns unique ID of the request.
@@ -1140,7 +1144,10 @@ var (
 		return nil
 	}
 
-	// NetHttpFormValueFunc gives consistent behavior with net/http. POST and PUT body parameters take precedence over URL query string values.
+	// NetHttpFormValueFunc gives consistent behavior with net/http.
+	// POST and PUT body parameters take precedence over URL query string values.
+	//
+	//nolint:stylecheck // backwards compatibility
 	NetHttpFormValueFunc = func(ctx *RequestCtx, key string) []byte {
 		v := ctx.PostArgs().Peek(key)
 		if len(v) > 0 {
@@ -1729,9 +1736,9 @@ func (s *Server) ServeTLSEmbed(ln net.Listener, certData, keyData []byte) error
 // AppendCert appends certificate and keyfile to TLS Configuration.
 //
 // This function allows programmer to handle multiple domains
-// in one server structure. See examples/multidomain
+// in one server structure. See examples/multidomain.
 func (s *Server) AppendCert(certFile, keyFile string) error {
-	if len(certFile) == 0 && len(keyFile) == 0 {
+	if certFile == "" && keyFile == "" {
 		return errNoCertOrKeyProvided
 	}
 
@@ -1780,8 +1787,6 @@ const DefaultConcurrency = 256 * 1024
 func (s *Server) Serve(ln net.Listener) error {
 	var lastOverflowErrorTime time.Time
 	var lastPerIPErrorTime time.Time
-	var c net.Conn
-	var err error
 
 	maxWorkersCount := s.getConcurrency()
 
@@ -1813,7 +1818,8 @@ func (s *Server) Serve(ln net.Listener) error {
 	defer atomic.AddInt32(&s.open, -1)
 
 	for {
-		if c, err = acceptConn(s, ln, &lastPerIPErrorTime); err != nil {
+		c, err := acceptConn(s, ln, &lastPerIPErrorTime)
+		if err != nil {
 			wp.Stop()
 			if err == io.EOF {
 				return nil
@@ -1824,6 +1830,7 @@ func (s *Server) Serve(ln net.Listener) error {
 		atomic.AddInt32(&s.open, 1)
 		if !wp.Serve(c) {
 			atomic.AddInt32(&s.open, -1)
+			atomic.AddUint32(&s.rejectedRequestsCount, 1)
 			s.writeFastError(c, StatusServiceUnavailable,
 				"The connection cannot be served because Server.Concurrency limit exceeded")
 			c.Close()
@@ -1846,12 +1853,12 @@ func (s *Server) Serve(ln net.Listener) error {
 				time.Sleep(s.SleepWhenConcurrencyLimitsExceeded)
 			}
 		}
-		c = nil
 	}
 }
 
 // Shutdown gracefully shuts down the server without interrupting any active connections.
-// Shutdown works by first closing all open listeners and then waiting indefinitely for all connections to return to idle and then shut down.
+// Shutdown works by first closing all open listeners and then waiting indefinitely for all connections
+// to return to idle and then shut down.
 //
 // When Shutdown is called, Serve, ListenAndServe, and ListenAndServeTLS immediately return nil.
 // Make sure the program doesn't exit and waits instead for Shutdown to return.
@@ -1862,12 +1869,14 @@ func (s *Server) Shutdown() error {
 }
 
 // ShutdownWithContext gracefully shuts down the server without interrupting any active connections.
-// ShutdownWithContext works by first closing all open listeners and then waiting for all connections to return to idle or context timeout and then shut down.
+// ShutdownWithContext works by first closing all open listeners and then waiting for all connections to return to idle
+// or context timeout and then shut down.
 //
 // When ShutdownWithContext is called, Serve, ListenAndServe, and ListenAndServeTLS immediately return nil.
 // Make sure the program doesn't exit and waits instead for Shutdown to return.
 //
-// ShutdownWithContext does not close keepalive connections so it's recommended to set ReadTimeout and IdleTimeout to something else than 0.
+// ShutdownWithContext does not close keepalive connections so it's recommended to set ReadTimeout and IdleTimeout
+// to something else than 0.
 func (s *Server) ShutdownWithContext(ctx context.Context) (err error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -2047,14 +2056,14 @@ var errHijacked = errors.New("connection has been hijacked")
 // GetCurrentConcurrency returns a number of currently served
 // connections.
 //
-// This function is intended be used by monitoring systems
+// This function is intended be used by monitoring systems.
 func (s *Server) GetCurrentConcurrency() uint32 {
 	return atomic.LoadUint32(&s.concurrency)
 }
 
 // GetOpenConnectionsCount returns a number of opened connections.
 //
-// This function is intended be used by monitoring systems
+// This function is intended be used by monitoring systems.
 func (s *Server) GetOpenConnectionsCount() int32 {
 	if atomic.LoadInt32(&s.stop) == 0 {
 		// Decrement by one to avoid reporting the extra open value that gets
@@ -2067,6 +2076,13 @@ func (s *Server) GetOpenConnectionsCount() int32 {
 	return atomic.LoadInt32(&s.open)
 }
 
+// GetRejectedConnectionsCount returns a number of rejected connections.
+//
+// This function is intended be used by monitoring systems.
+func (s *Server) GetRejectedConnectionsCount() uint32 {
+	return atomic.LoadUint32(&s.rejectedRequestsCount)
+}
+
 func (s *Server) getConcurrency() int {
 	n := s.Concurrency
 	if n <= 0 {
@@ -2292,7 +2308,6 @@ func (s *Server) serveConn(c net.Conn) (err error) {
 		// 'Expect: 100-continue' request handling.
 		// See https://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html#sec8.2.3 for details.
 		if ctx.Request.MayContinue() {
-
 			// Allow the ability to deny reading the incoming request body
 			if s.ContinueHandler != nil {
 				if continueReadingRequest = s.ContinueHandler(&ctx.Request.Header); !continueReadingRequest {
@@ -2418,7 +2433,7 @@ func (s *Server) serveConn(c net.Conn) (err error) {
 			// This benchmark will send 16 pipelined requests. It is faster to pack as many responses
 			// in a TCP packet and send it back at once than waiting for a flush every request.
 			// In real world circumstances this behaviour could be argued as being wrong.
-			if br == nil || br.Buffered() == 0 || connectionClose {
+			if br == nil || br.Buffered() == 0 || connectionClose || (s.ReduceMemoryUsage && hijackHandler == nil) {
 				err = bw.Flush()
 				if err != nil {
 					break
@@ -2582,7 +2597,7 @@ func acquireByteReader(ctxP **RequestCtx) (*bufio.Reader, error) {
 	c := ctx.c
 	s.releaseCtx(ctx)
 
-	// Make GC happy, so it could garbage collect ctx while we wait for the
+	//nolint:wastedassign // Make GC happy, so it could garbage collect ctx while we wait for the
 	// next request.
 	ctx = nil
 	*ctxP = nil
@@ -2721,7 +2736,7 @@ func (ctx *RequestCtx) Deadline() (deadline time.Time, ok bool) {
 // never be canceled. Successive calls to Done return the same value.
 //
 // Note: Because creating a new channel for every request is just too expensive, so
-// RequestCtx.s.done is only closed when the server is shutting down
+// RequestCtx.s.done is only closed when the server is shutting down.
 func (ctx *RequestCtx) Done() <-chan struct{} {
 	return ctx.s.done
 }
@@ -2734,7 +2749,7 @@ func (ctx *RequestCtx) Done() <-chan struct{} {
 // or DeadlineExceeded if the context's deadline passed.
 //
 // Note: Because creating a new channel for every request is just too expensive, so
-// RequestCtx.s.done is only closed when the server is shutting down
+// RequestCtx.s.done is only closed when the server is shutting down.
 func (ctx *RequestCtx) Err() error {
 	select {
 	case <-ctx.s.done:
@@ -2749,8 +2764,8 @@ func (ctx *RequestCtx) Err() error {
 // the same key returns the same result.
 //
 // This method is present to make RequestCtx implement the context interface.
-// This method is the same as calling ctx.UserValue(key)
-func (ctx *RequestCtx) Value(key interface{}) interface{} {
+// This method is the same as calling ctx.UserValue(key).
+func (ctx *RequestCtx) Value(key any) any {
 	return ctx.UserValue(key)
 }
 
@@ -2877,7 +2892,8 @@ func (s *Server) trackConn(c net.Conn, state ConnState) {
 			s.idleConns = make(map[net.Conn]time.Time)
 		}
 		// Count the connection as Idle after 5 seconds.
-		// Same as net/http.Server: https://github.com/golang/go/blob/85d7bab91d9a3ed1f76842e4328973ea75efef54/src/net/http/server.go#L2834-L2836
+		// Same as net/http.Server:
+		// https://github.com/golang/go/blob/85d7bab91d9a3ed1f76842e4328973ea75efef54/src/net/http/server.go#L2834-L2836
 		s.idleConns[c] = time.Now().Add(time.Second * 5)
 
 	default:

vendor/github.com/valyala/fasthttp/stackless/func.go

@@ -18,7 +18,7 @@ import (
 //
 // The stackless wrapper returns false if the call cannot be processed
 // at the moment due to high load.
-func NewFunc(f func(ctx interface{})) func(ctx interface{}) bool {
+func NewFunc(f func(ctx any)) func(ctx any) bool {
 	if f == nil {
 		// developer sanity-check
 		panic("BUG: f cannot be nil")
@@ -33,7 +33,7 @@ func NewFunc(f func(ctx interface{})) func(ctx interface{}) bool {
 	}
 	var once sync.Once
 
-	return func(ctx interface{}) bool {
+	return func(ctx any) bool {
 		once.Do(onceInit)
 		fw := getFuncWork()
 		fw.ctx = ctx
@@ -50,7 +50,7 @@ func NewFunc(f func(ctx interface{})) func(ctx interface{}) bool {
 	}
 }
 
-func funcWorker(funcWorkCh <-chan *funcWork, f func(ctx interface{})) {
+func funcWorker(funcWorkCh <-chan *funcWork, f func(ctx any)) {
 	for fw := range funcWorkCh {
 		f(fw.ctx)
 		fw.done <- struct{}{}
@@ -75,6 +75,6 @@ func putFuncWork(fw *funcWork) {
 var funcWorkPool sync.Pool
 
 type funcWork struct {
-	ctx  interface{}
+	ctx  any
 	done chan struct{}
 }

vendor/github.com/valyala/fasthttp/stackless/writer.go

@@ -101,17 +101,17 @@ var errHighLoad = errors.New("cannot compress data due to high load")
 
 var (
 	stacklessWriterFuncOnce sync.Once
-	stacklessWriterFuncFunc func(ctx interface{}) bool
+	stacklessWriterFuncFunc func(ctx any) bool
 )
 
-func stacklessWriterFunc(ctx interface{}) bool {
+func stacklessWriterFunc(ctx any) bool {
 	stacklessWriterFuncOnce.Do(func() {
 		stacklessWriterFuncFunc = NewFunc(writerFunc)
 	})
 	return stacklessWriterFuncFunc(ctx)
 }
 
-func writerFunc(ctx interface{}) {
+func writerFunc(ctx any) {
 	w := ctx.(*writer)
 	switch w.op {
 	case opWrite:

vendor/github.com/valyala/fasthttp/streaming.go

@@ -107,7 +107,7 @@ func releaseRequestStream(rs *requestStream) {
 }
 
 var requestStreamPool = sync.Pool{
-	New: func() interface{} {
+	New: func() any {
 		return &requestStream{}
 	},
 }

vendor/github.com/valyala/fasthttp/strings.go

@@ -19,7 +19,6 @@ var (
 	strCRLF                     = []byte("\r\n")
 	strHTTP                     = []byte("http")
 	strHTTPS                    = []byte("https")
-	strHTTP10                   = []byte("HTTP/1.0")
 	strHTTP11                   = []byte("HTTP/1.1")
 	strColon                    = []byte(":")
 	strColonSlashSlash          = []byte("://")

vendor/github.com/valyala/fasthttp/tcpdialer.go

@@ -48,7 +48,7 @@ func Dial(addr string) (net.Conn, error) {
 //     are temporarily unreachable.
 //
 // This dialer is intended for custom code wrapping before passing
-// to Client.Dial or HostClient.Dial.
+// to Client.DialTimeout or HostClient.DialTimeout.
 //
 // For instance, per-host counters and/or limits may be implemented
 // by such wrappers.
@@ -102,7 +102,7 @@ func DialDualStack(addr string) (net.Conn, error) {
 //     are temporarily unreachable.
 //
 // This dialer is intended for custom code wrapping before passing
-// to Client.Dial or HostClient.Dial.
+// to Client.DialTimeout or HostClient.DialTimeout.
 //
 // For instance, per-host counters and/or limits may be implemented
 // by such wrappers.
@@ -151,6 +151,8 @@ type TCPDialer struct {
 	// }
 	Resolver Resolver
 
+	// DisableDNSResolution may be used to disable DNS resolution
+	DisableDNSResolution bool
 	// DNSCacheDuration may be used to override the default DNS cache duration (DefaultDNSCacheDuration)
 	DNSCacheDuration time.Duration
 
@@ -199,7 +201,7 @@ func (d *TCPDialer) Dial(addr string) (net.Conn, error) {
 //     are temporarily unreachable.
 //
 // This dialer is intended for custom code wrapping before passing
-// to Client.Dial or HostClient.Dial.
+// to Client.DialTimeout or HostClient.DialTimeout.
 //
 // For instance, per-host counters and/or limits may be implemented
 // by such wrappers.
@@ -253,7 +255,7 @@ func (d *TCPDialer) DialDualStack(addr string) (net.Conn, error) {
 //     are temporarily unreachable.
 //
 // This dialer is intended for custom code wrapping before passing
-// to Client.Dial or HostClient.Dial.
+// to Client.DialTimeout or HostClient.DialTimeout.
 //
 // For instance, per-host counters and/or limits may be implemented
 // by such wrappers.
@@ -277,23 +279,26 @@ func (d *TCPDialer) dial(addr string, dualStack bool, timeout time.Duration) (ne
 			d.DNSCacheDuration = DefaultDNSCacheDuration
 		}
 
-		go d.tcpAddrsClean()
+		if !d.DisableDNSResolution {
+			go d.tcpAddrsClean()
+		}
 	})
-
 	deadline := time.Now().Add(timeout)
-	addrs, idx, err := d.getTCPAddrs(addr, dualStack, deadline)
-	if err != nil {
-		return nil, err
-	}
 	network := "tcp4"
 	if dualStack {
 		network = "tcp"
 	}
-
+	if d.DisableDNSResolution {
+		return d.tryDial(network, addr, deadline, d.concurrencyCh)
+	}
+	addrs, idx, err := d.getTCPAddrs(addr, dualStack, deadline)
+	if err != nil {
+		return nil, err
+	}
 	var conn net.Conn
 	n := uint32(len(addrs))
 	for n > 0 {
-		conn, err = d.tryDial(network, &addrs[idx%n], deadline, d.concurrencyCh)
+		conn, err = d.tryDial(network, addrs[idx%n].String(), deadline, d.concurrencyCh)
 		if err == nil {
 			return conn, nil
 		}
@@ -306,7 +311,9 @@ func (d *TCPDialer) dial(addr string, dualStack bool, timeout time.Duration) (ne
 	return nil, err
 }
 
-func (d *TCPDialer) tryDial(network string, addr *net.TCPAddr, deadline time.Time, concurrencyCh chan struct{}) (net.Conn, error) {
+func (d *TCPDialer) tryDial(
+	network string, addr string, deadline time.Time, concurrencyCh chan struct{},
+) (net.Conn, error) {
 	timeout := time.Until(deadline)
 	if timeout <= 0 {
 		return nil, ErrDialTimeout
@@ -338,7 +345,7 @@ func (d *TCPDialer) tryDial(network string, addr *net.TCPAddr, deadline time.Tim
 
 	ctx, cancelCtx := context.WithDeadline(context.Background(), deadline)
 	defer cancelCtx()
-	conn, err := dialer.DialContext(ctx, network, addr.String())
+	conn, err := dialer.DialContext(ctx, network, addr)
 	if err != nil && ctx.Err() == context.DeadlineExceeded {
 		return nil, ErrDialTimeout
 	}
@@ -369,13 +376,12 @@ func (d *TCPDialer) tcpAddrsClean() {
 	for {
 		time.Sleep(time.Second)
 		t := time.Now()
-		d.tcpAddrsMap.Range(func(k, v interface{}) bool {
+		d.tcpAddrsMap.Range(func(k, v any) bool {
 			if e, ok := v.(*tcpAddrEntry); ok && t.Sub(e.resolveTime) > expireDuration {
 				d.tcpAddrsMap.Delete(k)
 			}
 			return true
 		})
-
 	}
 }
 

vendor/github.com/valyala/fasthttp/testdata/test.png

@@ -1 +0,0 @@
-

vendor/github.com/valyala/fasthttp/uri.go

@@ -28,7 +28,7 @@ func ReleaseURI(u *URI) {
 }
 
 var uriPool = &sync.Pool{
-	New: func() interface{} {
+	New: func() any {
 		return &URI{}
 	},
 }
@@ -52,7 +52,7 @@ type URI struct {
 	queryArgs       Args
 	parsedQueryArgs bool
 
-	// Path values are sent as-is without normalization
+	// Path values are sent as-is without normalization.
 	//
 	// Disabled path normalization may be useful for proxying incoming requests
 	// to servers that are expecting paths to be forwarded as-is.
@@ -122,7 +122,7 @@ func (u *URI) SetUsernameBytes(username []byte) {
 	u.username = append(u.username[:0], username...)
 }
 
-// Password returns URI password
+// Password returns URI password.
 //
 // The returned bytes are valid until the next URI method call.
 func (u *URI) Password() []byte {
@@ -554,7 +554,7 @@ func unhex(c byte) byte {
 }
 
 // validOptionalPort reports whether port is either an empty string
-// or matches /^:\d*$/
+// or matches /^:\d*$/.
 func validOptionalPort(port []byte) bool {
 	if len(port) == 0 {
 		return true

vendor/github.com/valyala/fasthttp/userdata.go

@@ -5,13 +5,13 @@ import (
 )
 
 type userDataKV struct {
-	key   interface{}
-	value interface{}
+	key   any
+	value any
 }
 
 type userData []userDataKV
 
-func (d *userData) Set(key interface{}, value interface{}) {
+func (d *userData) Set(key any, value any) {
 	if b, ok := key.([]byte); ok {
 		key = string(b)
 	}
@@ -46,11 +46,11 @@ func (d *userData) Set(key interface{}, value interface{}) {
 	*d = args
 }
 
-func (d *userData) SetBytes(key []byte, value interface{}) {
+func (d *userData) SetBytes(key []byte, value any) {
 	d.Set(key, value)
 }
 
-func (d *userData) Get(key interface{}) interface{} {
+func (d *userData) Get(key any) any {
 	if b, ok := key.([]byte); ok {
 		key = b2s(b)
 	}
@@ -65,7 +65,7 @@ func (d *userData) Get(key interface{}) interface{} {
 	return nil
 }
 
-func (d *userData) GetBytes(key []byte) interface{} {
+func (d *userData) GetBytes(key []byte) any {
 	return d.Get(key)
 }
 
@@ -81,7 +81,7 @@ func (d *userData) Reset() {
 	*d = (*d)[:0]
 }
 
-func (d *userData) Remove(key interface{}) {
+func (d *userData) Remove(key any) {
 	if b, ok := key.([]byte); ok {
 		key = b2s(b)
 	}

vendor/github.com/valyala/fasthttp/workerpool.go

@@ -51,7 +51,7 @@ func (wp *workerPool) Start() {
 	}
 	wp.stopCh = make(chan struct{})
 	stopCh := wp.stopCh
-	wp.workerChanPool.New = func() interface{} {
+	wp.workerChanPool.New = func() any {
 		return &workerChan{
 			ch: make(chan net.Conn, workerChanCap),
 		}
@@ -110,9 +110,9 @@ func (wp *workerPool) clean(scratch *[]*workerChan) {
 	n := len(ready)
 
 	// Use binary-search algorithm to find out the index of the least recently worker which can be cleaned up.
-	l, r, mid := 0, n-1, 0
+	l, r := 0, n-1
 	for l <= r {
-		mid = (l + r) / 2
+		mid := (l + r) / 2
 		if criticalTime.After(wp.ready[mid].lastUseTime) {
 			l = mid + 1
 		} else {
@@ -238,7 +238,6 @@ func (wp *workerPool) workerFunc(ch *workerChan) {
 			_ = c.Close()
 			wp.connState(c, StateClosed)
 		}
-		c = nil
 
 		if !wp.release(ch) {
 			break

vendor/golang.org/x/sys/unix/mkerrors.sh

@@ -584,7 +584,7 @@ ccflags="$@"
 		$2 ~ /^KEY_(SPEC|REQKEY_DEFL)_/ ||
 		$2 ~ /^KEYCTL_/ ||
 		$2 ~ /^PERF_/ ||
-		$2 ~ /^SECCOMP_MODE_/ ||
+		$2 ~ /^SECCOMP_/ ||
 		$2 ~ /^SEEK_/ ||
 		$2 ~ /^SCHED_/ ||
 		$2 ~ /^SPLICE_/ ||

vendor/golang.org/x/sys/unix/zerrors_linux.go

@@ -1785,6 +1785,8 @@ const (
 	LANDLOCK_ACCESS_FS_REMOVE_FILE              = 0x20
 	LANDLOCK_ACCESS_FS_TRUNCATE                 = 0x4000
 	LANDLOCK_ACCESS_FS_WRITE_FILE               = 0x2
+	LANDLOCK_ACCESS_NET_BIND_TCP                = 0x1
+	LANDLOCK_ACCESS_NET_CONNECT_TCP             = 0x2
 	LANDLOCK_CREATE_RULESET_VERSION             = 0x1
 	LINUX_REBOOT_CMD_CAD_OFF                    = 0x0
 	LINUX_REBOOT_CMD_CAD_ON                     = 0x89abcdef
@@ -2465,6 +2467,7 @@ const (
 	PR_MCE_KILL_GET                             = 0x22
 	PR_MCE_KILL_LATE                            = 0x0
 	PR_MCE_KILL_SET                             = 0x1
+	PR_MDWE_NO_INHERIT                          = 0x2
 	PR_MDWE_REFUSE_EXEC_GAIN                    = 0x1
 	PR_MPX_DISABLE_MANAGEMENT                   = 0x2c
 	PR_MPX_ENABLE_MANAGEMENT                    = 0x2b
@@ -2669,8 +2672,9 @@ const (
 	RTAX_FEATURES                               = 0xc
 	RTAX_FEATURE_ALLFRAG                        = 0x8
 	RTAX_FEATURE_ECN                            = 0x1
-	RTAX_FEATURE_MASK                           = 0xf
+	RTAX_FEATURE_MASK                           = 0x1f
 	RTAX_FEATURE_SACK                           = 0x2
+	RTAX_FEATURE_TCP_USEC_TS                    = 0x10
 	RTAX_FEATURE_TIMESTAMP                      = 0x4
 	RTAX_HOPLIMIT                               = 0xa
 	RTAX_INITCWND                               = 0xb
@@ -2913,9 +2917,38 @@ const (
 	SCM_RIGHTS                                  = 0x1
 	SCM_TIMESTAMP                               = 0x1d
 	SC_LOG_FLUSH                                = 0x100000
+	SECCOMP_ADDFD_FLAG_SEND                     = 0x2
+	SECCOMP_ADDFD_FLAG_SETFD                    = 0x1
+	SECCOMP_FILTER_FLAG_LOG                     = 0x2
+	SECCOMP_FILTER_FLAG_NEW_LISTENER            = 0x8
+	SECCOMP_FILTER_FLAG_SPEC_ALLOW              = 0x4
+	SECCOMP_FILTER_FLAG_TSYNC                   = 0x1
+	SECCOMP_FILTER_FLAG_TSYNC_ESRCH             = 0x10
+	SECCOMP_FILTER_FLAG_WAIT_KILLABLE_RECV      = 0x20
+	SECCOMP_GET_ACTION_AVAIL                    = 0x2
+	SECCOMP_GET_NOTIF_SIZES                     = 0x3
+	SECCOMP_IOCTL_NOTIF_RECV                    = 0xc0502100
+	SECCOMP_IOCTL_NOTIF_SEND                    = 0xc0182101
+	SECCOMP_IOC_MAGIC                           = '!'
 	SECCOMP_MODE_DISABLED                       = 0x0
 	SECCOMP_MODE_FILTER                         = 0x2
 	SECCOMP_MODE_STRICT                         = 0x1
+	SECCOMP_RET_ACTION                          = 0x7fff0000
+	SECCOMP_RET_ACTION_FULL                     = 0xffff0000
+	SECCOMP_RET_ALLOW                           = 0x7fff0000
+	SECCOMP_RET_DATA                            = 0xffff
+	SECCOMP_RET_ERRNO                           = 0x50000
+	SECCOMP_RET_KILL                            = 0x0
+	SECCOMP_RET_KILL_PROCESS                    = 0x80000000
+	SECCOMP_RET_KILL_THREAD                     = 0x0
+	SECCOMP_RET_LOG                             = 0x7ffc0000
+	SECCOMP_RET_TRACE                           = 0x7ff00000
+	SECCOMP_RET_TRAP                            = 0x30000
+	SECCOMP_RET_USER_NOTIF                      = 0x7fc00000
+	SECCOMP_SET_MODE_FILTER                     = 0x1
+	SECCOMP_SET_MODE_STRICT                     = 0x0
+	SECCOMP_USER_NOTIF_FD_SYNC_WAKE_UP          = 0x1
+	SECCOMP_USER_NOTIF_FLAG_CONTINUE            = 0x1
 	SECRETMEM_MAGIC                             = 0x5345434d
 	SECURITYFS_MAGIC                            = 0x73636673
 	SEEK_CUR                                    = 0x1
@@ -3075,6 +3108,7 @@ const (
 	SOL_TIPC                                    = 0x10f
 	SOL_TLS                                     = 0x11a
 	SOL_UDP                                     = 0x11
+	SOL_VSOCK                                   = 0x11f
 	SOL_X25                                     = 0x106
 	SOL_XDP                                     = 0x11b
 	SOMAXCONN                                   = 0x1000

vendor/golang.org/x/sys/unix/zerrors_linux_386.go

@@ -281,6 +281,9 @@ const (
 	SCM_TIMESTAMPNS                  = 0x23
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
+	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
+	SECCOMP_IOCTL_NOTIF_ID_VALID     = 0x40082102
+	SECCOMP_IOCTL_NOTIF_SET_FLAGS    = 0x40082104
 	SFD_CLOEXEC                      = 0x80000
 	SFD_NONBLOCK                     = 0x800
 	SIOCATMARK                       = 0x8905

vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go

@@ -282,6 +282,9 @@ const (
 	SCM_TIMESTAMPNS                  = 0x23
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
+	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
+	SECCOMP_IOCTL_NOTIF_ID_VALID     = 0x40082102
+	SECCOMP_IOCTL_NOTIF_SET_FLAGS    = 0x40082104
 	SFD_CLOEXEC                      = 0x80000
 	SFD_NONBLOCK                     = 0x800
 	SIOCATMARK                       = 0x8905

vendor/golang.org/x/sys/unix/zerrors_linux_arm.go

@@ -288,6 +288,9 @@ const (
 	SCM_TIMESTAMPNS                  = 0x23
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
+	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
+	SECCOMP_IOCTL_NOTIF_ID_VALID     = 0x40082102
+	SECCOMP_IOCTL_NOTIF_SET_FLAGS    = 0x40082104
 	SFD_CLOEXEC                      = 0x80000
 	SFD_NONBLOCK                     = 0x800
 	SIOCATMARK                       = 0x8905

vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go

@@ -278,6 +278,9 @@ const (
 	SCM_TIMESTAMPNS                  = 0x23
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
+	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
+	SECCOMP_IOCTL_NOTIF_ID_VALID     = 0x40082102
+	SECCOMP_IOCTL_NOTIF_SET_FLAGS    = 0x40082104
 	SFD_CLOEXEC                      = 0x80000
 	SFD_NONBLOCK                     = 0x800
 	SIOCATMARK                       = 0x8905

vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go

@@ -275,6 +275,9 @@ const (
 	SCM_TIMESTAMPNS                  = 0x23
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
+	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
+	SECCOMP_IOCTL_NOTIF_ID_VALID     = 0x40082102
+	SECCOMP_IOCTL_NOTIF_SET_FLAGS    = 0x40082104
 	SFD_CLOEXEC                      = 0x80000
 	SFD_NONBLOCK                     = 0x800
 	SIOCATMARK                       = 0x8905

vendor/golang.org/x/sys/unix/zerrors_linux_mips.go

@@ -281,6 +281,9 @@ const (
 	SCM_TIMESTAMPNS                  = 0x23
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
+	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
+	SECCOMP_IOCTL_NOTIF_ID_VALID     = 0x80082102
+	SECCOMP_IOCTL_NOTIF_SET_FLAGS    = 0x80082104
 	SFD_CLOEXEC                      = 0x80000
 	SFD_NONBLOCK                     = 0x80
 	SIOCATMARK                       = 0x40047307

vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go

@@ -281,6 +281,9 @@ const (
 	SCM_TIMESTAMPNS                  = 0x23
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
+	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
+	SECCOMP_IOCTL_NOTIF_ID_VALID     = 0x80082102
+	SECCOMP_IOCTL_NOTIF_SET_FLAGS    = 0x80082104
 	SFD_CLOEXEC                      = 0x80000
 	SFD_NONBLOCK                     = 0x80
 	SIOCATMARK                       = 0x40047307

vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go

@@ -281,6 +281,9 @@ const (
 	SCM_TIMESTAMPNS                  = 0x23
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
+	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
+	SECCOMP_IOCTL_NOTIF_ID_VALID     = 0x80082102
+	SECCOMP_IOCTL_NOTIF_SET_FLAGS    = 0x80082104
 	SFD_CLOEXEC                      = 0x80000
 	SFD_NONBLOCK                     = 0x80
 	SIOCATMARK                       = 0x40047307

vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go

@@ -281,6 +281,9 @@ const (
 	SCM_TIMESTAMPNS                  = 0x23
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
+	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
+	SECCOMP_IOCTL_NOTIF_ID_VALID     = 0x80082102
+	SECCOMP_IOCTL_NOTIF_SET_FLAGS    = 0x80082104
 	SFD_CLOEXEC                      = 0x80000
 	SFD_NONBLOCK                     = 0x80
 	SIOCATMARK                       = 0x40047307

vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go

@@ -336,6 +336,9 @@ const (
 	SCM_TIMESTAMPNS                  = 0x23
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
+	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
+	SECCOMP_IOCTL_NOTIF_ID_VALID     = 0x80082102
+	SECCOMP_IOCTL_NOTIF_SET_FLAGS    = 0x80082104
 	SFD_CLOEXEC                      = 0x80000
 	SFD_NONBLOCK                     = 0x800
 	SIOCATMARK                       = 0x8905