diff --git a/go.mod b/go.mod
index a652fed654..371728ba06 100644
--- a/go.mod
+++ b/go.mod
@@ -6,7 +6,7 @@ require (
 	github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.2.1
 	github.com/CortexFoundation/inference v1.0.2-0.20230307032835-9197d586a4e8
 	github.com/CortexFoundation/statik v0.0.0-20210315012922-8bb8a7b5dc66
-	github.com/CortexFoundation/torrentfs v1.0.59-0.20240127141413-4bf19d565523
+	github.com/CortexFoundation/torrentfs v1.0.59-0.20240129113837-7f5c3c53b617
 	github.com/VictoriaMetrics/fastcache v1.12.2
 	github.com/arsham/figurine v1.3.0
 	github.com/aws/aws-sdk-go-v2 v1.24.1
@@ -205,7 +205,7 @@ require (
 	github.com/prometheus/procfs v0.12.0 // indirect
 	github.com/rakyll/statik v0.1.7 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
-	github.com/rivo/uniseg v0.4.5 // indirect
+	github.com/rivo/uniseg v0.4.6 // indirect
 	github.com/rogpeppe/go-internal v1.12.0 // indirect
 	github.com/rs/dnscache v0.0.0-20230804202142-fc85eb664529 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
@@ -222,7 +222,7 @@ require (
 	github.com/xrash/smetrics v0.0.0-20231213231151-1d8dd44e695e // indirect
 	github.com/xujiajun/mmap-go v1.0.1 // indirect
 	github.com/xujiajun/utils v0.0.0-20220904132955-5f7c5b914235 // indirect
-	github.com/yusufpapurcu/wmi v1.2.3 // indirect
+	github.com/yusufpapurcu/wmi v1.2.4 // indirect
 	github.com/zeebo/xxh3 v1.0.3-0.20230502181907-3808c706a06a // indirect
 	go.etcd.io/bbolt v1.3.8 // indirect
 	go.opencensus.io v0.24.0 // indirect
@@ -233,7 +233,7 @@ require (
 	golang.org/x/net v0.20.0 // indirect
 	golang.org/x/term v0.16.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
-	modernc.org/libc v1.40.7 // indirect
+	modernc.org/libc v1.40.8 // indirect
 	modernc.org/mathutil v1.6.0 // indirect
 	modernc.org/memory v1.7.2 // indirect
 	modernc.org/sqlite v1.28.0 // indirect
diff --git a/go.sum b/go.sum
index 1851327c45..b4bdd74d25 100644
--- a/go.sum
+++ b/go.sum
@@ -68,8 +68,8 @@ github.com/CortexFoundation/statik v0.0.0-20210315012922-8bb8a7b5dc66/go.mod h1:
 github.com/CortexFoundation/torrentfs v1.0.13-0.20200623060705-ce027f43f2f8/go.mod h1:Ma+tGhPPvz4CEZHaqEJQMOEGOfHeQBiAoNd1zyc/w3Q=
 github.com/CortexFoundation/torrentfs v1.0.14-0.20200703071639-3fcabcabf274/go.mod h1:qnb3YlIJmuetVBtC6Lsejr0Xru+1DNmDCdTqnwy7lhk=
 github.com/CortexFoundation/torrentfs v1.0.20-0.20200810031954-d36d26f82fcc/go.mod h1:N5BsicP5ynjXIi/Npl/SRzlJ630n1PJV2sRj0Z0t2HA=
-github.com/CortexFoundation/torrentfs v1.0.59-0.20240127141413-4bf19d565523 h1:3Y3KgtEbSp5faqd7x85i6egyWnvZCoE+yft7qUVaZxQ=
-github.com/CortexFoundation/torrentfs v1.0.59-0.20240127141413-4bf19d565523/go.mod h1:mIgOgma2+ZsDyew1fhZWHOcXJF5bvA5cy1KrzRLi+cA=
+github.com/CortexFoundation/torrentfs v1.0.59-0.20240129113837-7f5c3c53b617 h1:ulwe8PP2Mv3krzOWna0kDJLeV87yYCfZHvB5kZfogXk=
+github.com/CortexFoundation/torrentfs v1.0.59-0.20240129113837-7f5c3c53b617/go.mod h1:ViWum/jqxa+88uU5QKt7IvHDY8uRICP5c1AEGB+VG4s=
 github.com/CortexFoundation/wormhole v0.0.2-0.20231221155549-5c938553b5fc h1:LkbBJvvbfraAg/joFxPZtDvmdrjuTqPfbGhdnrEq7GM=
 github.com/CortexFoundation/wormhole v0.0.2-0.20231221155549-5c938553b5fc/go.mod h1:ipzmPabDgzYKUbXkGVe2gTkBEp+MsDx6pXGiuYzmP6s=
 github.com/DATA-DOG/go-sqlmock v1.3.3/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
@@ -1096,8 +1096,8 @@ github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qq
 github.com/retailnext/hllpp v1.0.1-0.20180308014038-101a6d2f8b52/go.mod h1:RDpi1RftBQPUCDRw6SmxeaREsAaRKnOclghuzp/WRzc=
 github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.5 h1:I1LlsYBcfG4ggKsNaL6bi8pL7Z8SizVPVBrh3Y8F/BA=
-github.com/rivo/uniseg v0.4.5/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rivo/uniseg v0.4.6 h1:Sovz9sDSwbOz9tgUy8JpT+KgCkPYJEN/oYzlJiYTNLg=
+github.com/rivo/uniseg v0.4.6/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rjeczalik/notify v0.9.2/go.mod h1:aErll2f0sUX9PXZnVNyeiObbmTlk5jnMoCa4QEjJeqM=
 github.com/robertkrimen/godocdown v0.0.0-20130622164427-0bfa04905481/go.mod h1:C9WhFzY47SzYBIvzFqSvHIR6ROgDo4TtdTuRaOMjF/s=
 github.com/robertkrimen/otto v0.0.0-20191219234010-c382bd3c16ff/go.mod h1:xvqspoSXJTIpemEonrMDFq6XzwHYYgToXWj5eRX1OtY=
@@ -1285,8 +1285,8 @@ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-github.com/yusufpapurcu/wmi v1.2.3 h1:E1ctvB7uKFMOJw3fdOW32DwGE9I7t++CRUEMKvFoFiw=
-github.com/yusufpapurcu/wmi v1.2.3/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
+github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
+github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
 github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
 github.com/zeebo/xxh3 v1.0.3-0.20230502181907-3808c706a06a h1:wNpehQr1+k+Z6H5RvqnCPVH9Dg/d1/ZbWucPQ+FLva4=
@@ -1784,8 +1784,8 @@ honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWh
 honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
-modernc.org/libc v1.40.7 h1:oeLS0G067ZqUu+v143Dqad0btMfKmNS7SuOsnkq0Ysg=
-modernc.org/libc v1.40.7/go.mod h1:YAXkAZ8ktnkCKaN9sw/UDeUVkGYJ/YquGO4FTi5nmHE=
+modernc.org/libc v1.40.8 h1:ZHN83BZzEytp4ctJMC2lxGTU3l8jo+2kGW7AUatIDZw=
+modernc.org/libc v1.40.8/go.mod h1:YAXkAZ8ktnkCKaN9sw/UDeUVkGYJ/YquGO4FTi5nmHE=
 modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4=
 modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo=
 modernc.org/memory v1.7.2 h1:Klh90S215mmH8c9gO98QxQFsY+W451E8AnzjoE2ee1E=
diff --git a/vendor/github.com/rivo/uniseg/README.md b/vendor/github.com/rivo/uniseg/README.md
index 250b2a1f57..a8191b8154 100644
--- a/vendor/github.com/rivo/uniseg/README.md
+++ b/vendor/github.com/rivo/uniseg/README.md
@@ -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
diff --git a/vendor/github.com/rivo/uniseg/grapheme.go b/vendor/github.com/rivo/uniseg/grapheme.go
index 0086fc1b20..a0bcc554bb 100644
--- a/vendor/github.com/rivo/uniseg/grapheme.go
+++ b/vendor/github.com/rivo/uniseg/grapheme.go
@@ -222,7 +222,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
 		}
@@ -284,7 +284,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
 		}
diff --git a/vendor/github.com/rivo/uniseg/graphemerules.go b/vendor/github.com/rivo/uniseg/graphemerules.go
index bb4a42073c..5d399d29c8 100644
--- a/vendor/github.com/rivo/uniseg/graphemerules.go
+++ b/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.
@@ -37,58 +38,95 @@ const (
 //  6. Assume grAny and grBoundary.
 //
 // Unicode version 15.0.0.
-var grTransitions = map[[2]int][3]int{
+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.
diff --git a/vendor/github.com/rivo/uniseg/line.go b/vendor/github.com/rivo/uniseg/line.go
index e46be37a29..7a46318d93 100644
--- a/vendor/github.com/rivo/uniseg/line.go
+++ b/vendor/github.com/rivo/uniseg/line.go
@@ -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)
+	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)
+	property, _ := propertyLineBreak(r)
 	return property == prBK || property == prCR || property == prLF || property == prNL
 }
diff --git a/vendor/github.com/rivo/uniseg/linerules.go b/vendor/github.com/rivo/uniseg/linerules.go
index acde9a1118..7708ae0fbe 100644
--- a/vendor/github.com/rivo/uniseg/linerules.go
+++ b/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 15.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
 		}
diff --git a/vendor/github.com/rivo/uniseg/properties.go b/vendor/github.com/rivo/uniseg/properties.go
index bc3c7bcf34..6290e6810f 100644
--- a/vendor/github.com/rivo/uniseg/properties.go
+++ b/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)
+}
diff --git a/vendor/github.com/rivo/uniseg/sentencerules.go b/vendor/github.com/rivo/uniseg/sentencerules.go
index 58c04794e8..0b29c7bdb8 100644
--- a/vendor/github.com/rivo/uniseg/sentencerules.go
+++ b/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
diff --git a/vendor/github.com/rivo/uniseg/step.go b/vendor/github.com/rivo/uniseg/step.go
index 6eca4b5dc7..2959b69096 100644
--- a/vendor/github.com/rivo/uniseg/step.go
+++ b/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
 		}
@@ -179,7 +179,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)
 	}
 
diff --git a/vendor/github.com/rivo/uniseg/width.go b/vendor/github.com/rivo/uniseg/width.go
index 96ee16e760..975a9f1343 100644
--- a/vendor/github.com/rivo/uniseg/width.go
+++ b/vendor/github.com/rivo/uniseg/width.go
@@ -38,7 +38,7 @@ func runeWidth(r rune, graphemeProperty int) int {
 		return 4
 	}
 
-	switch property(eastAsianWidth, r) {
+	switch propertyEastAsianWidth(r) {
 	case prW, prF:
 		return 2
 	case prA:
diff --git a/vendor/github.com/rivo/uniseg/wordrules.go b/vendor/github.com/rivo/uniseg/wordrules.go
index 2b62e12228..57a8c68311 100644
--- a/vendor/github.com/rivo/uniseg/wordrules.go
+++ b/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 15.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}:     {wbKatakana, 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
diff --git a/vendor/github.com/yusufpapurcu/wmi/wmi.go b/vendor/github.com/yusufpapurcu/wmi/wmi.go
index 26c3581c97..03f386ed59 100644
--- a/vendor/github.com/yusufpapurcu/wmi/wmi.go
+++ b/vendor/github.com/yusufpapurcu/wmi/wmi.go
@@ -456,6 +456,18 @@ func (c *Client) loadEntity(dst interface{}, src *ole.IDispatch) (errFieldMismat
 					Reason:     "not a Float32",
 				}
 			}
+		case float64:
+			switch f.Kind() {
+			case reflect.Float32, reflect.Float64:
+				f.SetFloat(val)
+			default:
+				return &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     "not a Float64",
+				}
+			}
+		
 		default:
 			if f.Kind() == reflect.Slice {
 				switch f.Type().Elem().Kind() {
diff --git a/vendor/modernc.org/libc/libc.go b/vendor/modernc.org/libc/libc.go
index 9d1b6e2914..4680259392 100644
--- a/vendor/modernc.org/libc/libc.go
+++ b/vendor/modernc.org/libc/libc.go
@@ -957,6 +957,18 @@ func Xabs(t *TLS, j int32) int32 {
 	return -j
 }
 
+// long abs(long j);
+func Xlabs(t *TLS, j long) long {
+	if __ccgo_strace {
+		trc("t=%v j=%v, (%v:)", t, j, origin(2))
+	}
+	if j >= 0 {
+		return j
+	}
+
+	return -j
+}
+
 func Xllabs(tls *TLS, a int64) int64 {
 	if __ccgo_strace {
 		trc("tls=%v a=%v, (%v:)", tls, a, origin(2))
@@ -2319,3 +2331,78 @@ func Xffs(tls *TLS, i int32) (r int32) {
 
 	return int32(mbits.TrailingZeros32(uint32(i))) + 1
 }
+
+var _toint5 = Float32FromInt32(1) / Float32FromFloat32(1.1920928955078125e-07)
+
+func X__builtin_rintf(tls *TLS, x float32) (r float32) {
+	return Xrintf(tls, x)
+}
+
+func Xrintf(tls *TLS, x float32) (r float32) {
+	if __ccgo_strace {
+		trc("tls=%v x=%v, (%v:)", tls, x, origin(2))
+		defer func() { trc("-> %v", r) }()
+	}
+	bp := tls.Alloc(16)
+	defer tls.Free(16)
+	var e, s int32
+	var y float32
+	var v1 float32
+	var _ /* u at bp+0 */ struct {
+		Fi [0]uint32
+		Ff float32
+	}
+	_, _, _, _ = e, s, y, v1
+	*(*struct {
+		Fi [0]uint32
+		Ff float32
+	})(unsafe.Pointer(bp)) = struct {
+		Fi [0]uint32
+		Ff float32
+	}{}
+	*(*float32)(unsafe.Pointer(bp)) = x
+	e = int32(*(*uint32)(unsafe.Pointer(bp)) >> int32(23) & uint32(0xff))
+	s = int32(*(*uint32)(unsafe.Pointer(bp)) >> int32(31))
+	if e >= Int32FromInt32(0x7f)+Int32FromInt32(23) {
+		return x
+	}
+	if s != 0 {
+		y = x - _toint5 + _toint5
+	} else {
+		y = x + _toint5 - _toint5
+	}
+	if y == Float32FromInt32(0) {
+		if s != 0 {
+			v1 = -Float32FromFloat32(0)
+		} else {
+			v1 = Float32FromFloat32(0)
+		}
+		return v1
+	}
+	return y
+}
+
+func X__builtin_lrintf(tls *TLS, x float32) (r int64) {
+	return Xlrintf(tls, x)
+}
+
+
+func Xlrintf(tls *TLS, x float32) (r int64) {
+	if __ccgo_strace {
+		trc("tls=%v x=%v, (%v:)", tls, x, origin(2))
+		defer func() { trc("-> %v", r) }()
+	}
+	return int64(Xrintf(tls, x))
+}
+
+func X__builtin_lrint(tls *TLS, x float64) (r int64) {
+	return Xlrint(tls, x)
+}
+
+func Xlrint(tls *TLS, x float64) (r int64) {
+	if __ccgo_strace {
+		trc("tls=%v x=%v, (%v:)", tls, x, origin(2))
+		defer func() { trc("-> %v", r) }()
+	}
+	return int64(Xrint(tls, x))
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index ea148cabfd..349c6c4a27 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -58,7 +58,7 @@ github.com/CortexFoundation/robot/backend
 # github.com/CortexFoundation/statik v0.0.0-20210315012922-8bb8a7b5dc66
 ## explicit; go 1.16
 github.com/CortexFoundation/statik
-# github.com/CortexFoundation/torrentfs v1.0.59-0.20240127141413-4bf19d565523
+# github.com/CortexFoundation/torrentfs v1.0.59-0.20240129113837-7f5c3c53b617
 ## explicit; go 1.21
 github.com/CortexFoundation/torrentfs
 github.com/CortexFoundation/torrentfs/backend
@@ -928,7 +928,7 @@ github.com/rakyll/statik/fs
 # github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec
 ## explicit; go 1.12
 github.com/remyoudompheng/bigfft
-# github.com/rivo/uniseg v0.4.5
+# github.com/rivo/uniseg v0.4.6
 ## explicit; go 1.18
 github.com/rivo/uniseg
 # github.com/rogpeppe/go-internal v1.12.0
@@ -1024,7 +1024,7 @@ github.com/xujiajun/mmap-go
 ## explicit; go 1.13
 github.com/xujiajun/utils/filesystem
 github.com/xujiajun/utils/strconv2
-# github.com/yusufpapurcu/wmi v1.2.3
+# github.com/yusufpapurcu/wmi v1.2.4
 ## explicit; go 1.16
 github.com/yusufpapurcu/wmi
 # github.com/zeebo/xxh3 v1.0.3-0.20230502181907-3808c706a06a
@@ -1236,7 +1236,7 @@ gopkg.in/urfave/cli.v1
 # gopkg.in/yaml.v3 v3.0.1
 ## explicit
 gopkg.in/yaml.v3
-# modernc.org/libc v1.40.7
+# modernc.org/libc v1.40.8
 ## explicit; go 1.20
 modernc.org/libc
 modernc.org/libc/errno