From e3107bae9d54f9dee9eed4175ecf02d10ecb55ff Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Mon, 11 Aug 2025 17:52:39 -0400
Subject: [PATCH 01/32] add dockey

---
 dockey/agg.go                | 122 ++++++++++++++++++++++++++++++++
 dockey/agg_test.go           | 113 ++++++++++++++++++++++++++++++
 dockey/dockey.go             | 132 +++++++++++++++++++++++++++++++++++
 dockey/shardkey_pattern.go   | 117 +++++++++++++++++++++++++++++++
 dockey/unit_test.go          | 112 +++++++++++++++++++++++++++++
 internal/verifier/compare.go |   7 +-
 6 files changed, 598 insertions(+), 5 deletions(-)
 create mode 100644 dockey/agg.go
 create mode 100644 dockey/agg_test.go
 create mode 100644 dockey/dockey.go
 create mode 100644 dockey/shardkey_pattern.go
 create mode 100644 dockey/unit_test.go

diff --git a/dockey/agg.go b/dockey/agg.go
new file mode 100644
index 00000000..793c7f07
--- /dev/null
+++ b/dockey/agg.go
@@ -0,0 +1,122 @@
+package dockey
+
+import (
+	"strings"
+
+	"go.mongodb.org/mongo-driver/bson"
+)
+
+func ExtractDocKeyAgg(fieldNames []string) bson.D {
+	return extractDocKeyFromAgg(fieldNames, "$$ROOT")
+}
+
+func extractDocKeyFromAgg(fieldNames []string, rootExpr any) bson.D {
+	var docKeyPieces [][2]any
+
+	for _, name := range fieldNames {
+		var valExpr = extractKeyValueAgg(name, rootExpr)
+
+		docKeyPieces = append(docKeyPieces, [...]any{name, valExpr})
+	}
+
+	return bson.D{
+		{"$arrayToObject", bson.A{docKeyPieces}},
+	}
+}
+
+func existsAgg(fieldName string, baseDocExpr any) bson.D {
+	base, remainder, hasDot := strings.Cut(fieldName, ".")
+
+	fieldExpr := bson.D{
+		{"$getField", bson.D{
+			{"field", fieldName},
+			{"input", baseDocExpr},
+		}},
+	}
+
+	if !hasDot {
+		return bson.D{
+			{"$ne", bson.A{
+				"missing",
+				bson.D{{"$type", fieldExpr}},
+			}},
+		}
+	}
+
+	embDocExpr := bson.D{
+		{"$getField", bson.D{
+			{"field", base},
+			{"input", baseDocExpr},
+		}},
+	}
+
+	return bson.D{
+		{"$cond", bson.D{
+			{"if", bson.D{
+				{"$ne", bson.A{
+					"missing",
+					bson.D{{"$type", fieldExpr}},
+				}},
+			}},
+			{"then", true},
+			{"else", bson.D{
+				{"$cond", bson.D{
+					{"if", bson.D{
+						{"$eq", bson.A{
+							"object",
+							bson.D{{"$type", embDocExpr}},
+						}},
+					}},
+					{"then", extractKeyValueAgg(remainder, embDocExpr)},
+					{"else", false},
+				}},
+			}},
+		}},
+	}
+}
+
+func extractKeyValueAgg(fieldName string, baseDocExpr any) any {
+	base, remainder, hasDot := strings.Cut(fieldName, ".")
+
+	fieldExpr := bson.D{
+		{"$getField", bson.D{
+			{"field", fieldName},
+			{"input", baseDocExpr},
+		}},
+	}
+
+	if !hasDot {
+		return fieldExpr
+	}
+
+	embDocExpr := bson.D{
+		{"$getField", bson.D{
+			{"field", base},
+			{"input", baseDocExpr},
+		}},
+	}
+
+	return bson.D{
+		{"$cond", bson.D{
+			{"if", bson.D{
+				{"$ne", bson.A{
+					"missing",
+					bson.D{{"$type", fieldExpr}},
+				}},
+			}},
+			{"then", fieldExpr},
+			{"else", bson.D{
+				{"$cond", bson.D{
+					{"if", bson.D{
+						{"$eq", bson.A{
+							"object",
+							bson.D{{"$type", embDocExpr}},
+						}},
+					}},
+					{"then", extractKeyValueAgg(remainder, embDocExpr)},
+					{"else", "$$REMOVE"},
+				}},
+			}},
+		}},
+	}
+}
diff --git a/dockey/agg_test.go b/dockey/agg_test.go
new file mode 100644
index 00000000..5b4ef8a3
--- /dev/null
+++ b/dockey/agg_test.go
@@ -0,0 +1,113 @@
+package dockey
+
+import (
+	"os"
+	"testing"
+
+	"github.com/10gen/migration-verifier/internal/logger"
+	"github.com/10gen/migration-verifier/internal/util"
+	"github.com/10gen/migration-verifier/mslices"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+func TestExtractDocKeyAgg(t *testing.T) {
+	ctx := t.Context()
+
+	require := require.New(t)
+
+	cs := os.Getenv("MVTEST_DST")
+	require.NotEmpty(t, cs, "need MVTEST_DST env")
+
+	client, err := mongo.Connect(
+		ctx,
+		options.Client().ApplyURI(cs),
+	)
+	require.NoError(err, "should connect")
+
+	clusterInfo, err := util.GetClusterInfo(
+		ctx,
+		logger.NewDefaultLogger(),
+		client,
+	)
+	require.NoError(err, "should fetch topology")
+	if clusterInfo.Topology != util.TopologySharded {
+		t.Skip("Skipping against unsharded cluster.")
+	}
+
+	db := client.Database(t.Name())
+	defer db.Drop(ctx)
+
+	coll := db.Collection("Stuff")
+	require.NoError(client.Database("admin").RunCommand(
+		ctx,
+		bson.D{
+			{"shardCollection", db.Name() + "." + coll.Name()},
+			{"key", bson.D{
+				{"foo.bar.baz", 1},
+			}},
+		},
+	).Err(),
+	)
+
+	computedDocKeyAgg := extractDocKeyFromAgg(
+		mslices.Of("foo.bar.baz", "_id"),
+		"$$ROOT.fullDocument",
+	)
+
+	ejson, _ := bson.MarshalExtJSON(computedDocKeyAgg, true, false)
+	t.Logf("computed doc key agg: %s", string(ejson))
+
+	for _, curCase := range testCases {
+		changes, err := coll.Watch(
+			ctx,
+			mongo.Pipeline{
+				{
+					{"$addFields", bson.D{
+						{"computedDocKey", computedDocKeyAgg},
+					}},
+				},
+			},
+		)
+		require.NoError(err, "should open change stream")
+
+		_, err = coll.InsertOne(ctx, curCase.doc)
+		require.NoError(err, "should insert doc")
+
+		for changes.Next(ctx) {
+			var event struct {
+				OperationType  string
+				FullDocument   bson.D
+				DocumentKey    bson.D
+				ComputedDocKey bson.D
+			}
+
+			require.NoError(bson.Unmarshal(changes.Current, &event))
+
+			if event.OperationType != "insert" {
+				t.Logf("Ignoring irrelevant-seeing event: %v", changes.Current)
+				continue
+			}
+
+			ejson, _ := bson.MarshalExtJSON(changes.Current, true, false)
+			t.Logf("Event: %s", string(ejson))
+
+			assert.Equal(
+				t,
+				event.DocumentKey,
+				event.ComputedDocKey,
+				"checking computed doc key for %v against server",
+				curCase.doc,
+			)
+
+			break
+		}
+
+		require.NoError(changes.Err(), "change stream should not fail")
+
+		changes.Close(ctx)
+	}
+}
diff --git a/dockey/dockey.go b/dockey/dockey.go
new file mode 100644
index 00000000..2b0d215e
--- /dev/null
+++ b/dockey/dockey.go
@@ -0,0 +1,132 @@
+package dockey
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/pkg/errors"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/x/bsonx/bsoncore"
+)
+
+// DocumentKey represents a document key from the change stream.
+type DocumentKey bson.Raw
+
+// NewDocumentKey returns a document key from a bson.Raw, like you might get
+// from the change stream.
+func NewDocumentKey(raw bson.Raw) DocumentKey {
+	return DocumentKey(raw)
+}
+
+// ExtractDocumentKey takes a shard key pattern and a document and returns its
+// DocumentKey. This is a reimplementation of the same method in the server,
+// so that we can reliably generate document keys even without a change
+// stream.
+func ExtractDocumentKey(pattern Pattern, input bson.Raw) (DocumentKey, error) {
+	builder, err := extractShardKey(pattern, input)
+	if err != nil {
+		return nil, err
+	}
+
+	if !pattern.ContainsID() {
+		id, err := input.LookupErr("_id")
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to get document _id")
+		}
+
+		val := bsoncore.Value{Type: id.Type, Data: id.Value}
+		builder.AppendValue("_id", val)
+	}
+
+	return DocumentKey(builder.Build()), nil
+}
+
+// extractShardKey does the shard-key part of the document key extraction.
+func extractShardKey(pattern Pattern, input bson.Raw) (*bsoncore.DocumentBuilder, error) {
+	db := bsoncore.NewDocumentBuilder()
+
+	if pattern.IsEmpty() {
+		return db, nil
+	}
+
+	// For every element of the shard key pattern:
+	for _, e := range pattern.Elements() {
+		key := e.Key()
+
+		rv, err := extractElementAtDottedPath(key, input)
+
+		switch {
+		case errors.Is(err, bsoncore.ErrElementNotFound),
+			errors.As(err, &bsoncore.InvalidDepthTraversalError{}):
+			// This key doesn't exist, do nothing. The server treats these in some
+			// cases as though an explicit null were present, but when generating
+			// document keys, it always omits the field entirely.
+
+		case err != nil:
+			// Something deeply weird went wrong. Try to grab the ID from the
+			// document so this error is plausibly useful.
+			id := input.Lookup("_id")
+			return nil, errors.Wrapf(err, "failed to lookup path for %s (_id: %#q)", key, id)
+
+		default:
+			// We found the element; add it to the result.
+			val := bsoncore.Value{Type: rv.Type, Data: rv.Value}
+			db.AppendValue(key, val)
+		}
+	}
+
+	// We're done: return the whole document.
+	return db, nil
+}
+
+func extractElementAtDottedPath(path string, input bson.Raw) (bson.RawValue, error) {
+	// First, try to look up the field verbatim. We must do this because field
+	// names can have dots in them: a shard key pattern like {"a.b": 1} will
+	// first match the literal field "a.b", and then the nested lookup for "b"
+	// in the embedded document "a".
+	rv, err := input.LookupErr(path)
+
+	// If it's not there, and it's a dotted path (like a.b.c), try a nested lookup.
+	if errors.Is(err, bsoncore.ErrElementNotFound) && strings.Contains(path, ".") {
+		left, right, ok := strings.Cut(path, ".")
+		if !ok {
+			panic(fmt.Sprintf("Could not cut %#q on dot", path))
+		}
+
+		el, err := input.LookupErr(left)
+		if err != nil {
+			return el, err
+		}
+
+		doc, ok := el.DocumentOK()
+		if !ok {
+			return rv, bsoncore.InvalidDepthTraversalError{
+				Key:  left,
+				Type: el.Type,
+			}
+		}
+
+		return extractElementAtDottedPath(right, doc)
+	}
+
+	return rv, err
+}
+
+func (dk DocumentKey) String() string {
+	return bson.Raw(dk).String()
+}
+
+// Raw provides access to the document key as a bson.Raw value.
+func (dk DocumentKey) Raw() bson.Raw {
+	return bson.Raw(dk)
+}
+
+// Bytes provides access to the underlying bytes of the document key.
+func (dk DocumentKey) Bytes() []byte {
+	return []byte(dk)
+}
+
+// ID returns the _id portion of the document key as a bson.RawValue.
+func (dk DocumentKey) ID() bson.RawValue {
+	return dk.Raw().Lookup("_id")
+}
diff --git a/dockey/shardkey_pattern.go b/dockey/shardkey_pattern.go
new file mode 100644
index 00000000..2b0d4b24
--- /dev/null
+++ b/dockey/shardkey_pattern.go
@@ -0,0 +1,117 @@
+package dockey
+
+import (
+	"fmt"
+
+	"github.com/pkg/errors"
+	"go.mongodb.org/mongo-driver/bson"
+)
+
+// Pattern represents a collection shard key (the thing you'd pass to
+// shardCollection). It's called a "pattern" to distinguish the collection's
+// shard key from a document's shard key. The zero value for Pattern
+// is useful by itself: it behaves as though a collection has no shard key at
+// all.
+type Pattern struct {
+	raw   bson.Raw
+	hasID bool
+}
+
+// EmptyPattern is an empty pattern; it can be used to represent unsharded
+// collections.
+var EmptyPattern Pattern
+
+// NewPattern takes a raw document, like the thing you'd find in
+// config.collections. It validates that the shard key is valid BSON, and
+// returns a Pattern.
+func NewPattern(raw bson.Raw) (Pattern, error) {
+	if len(raw) == 0 {
+		return Pattern{}, nil
+	}
+
+	err := raw.Validate()
+	if err != nil {
+		return Pattern{}, errors.Wrap(err, "failed to validate shard key pattern")
+	}
+
+	_, lookupErr := raw.LookupErr("_id")
+	hasID := lookupErr == nil
+
+	return Pattern{raw, hasID}, nil
+}
+
+// PatternFromMarshalable takes a marshalable object (like a bson.D) and
+// returns a new Pattern. This function panics on any error. It's mostly here
+// because it's convenient to use in tests, where you know you'll have a valid
+// pattern.
+func PatternFromMarshalable(key any) Pattern {
+	raw, err := bson.Marshal(key)
+	if err != nil {
+		panic(err)
+	}
+
+	p, err := NewPattern(raw)
+	if err != nil {
+		panic(err)
+	}
+
+	return p
+}
+
+// ContainsID returns true if the shard key pattern contains the _id field.
+func (p Pattern) ContainsID() bool {
+	return p.hasID
+}
+
+// IsEmpty returns true if this is a zero-value pattern.
+func (p Pattern) IsEmpty() bool {
+	return len(p.raw) == 0
+}
+
+// Elements returns a slice of bson.RawElement values for every element of the
+// shard key. It works like the bson.Raw.Elements method, but does not return
+// an error (because we validate the underlying raw document in the
+// constructor).
+func (p Pattern) Elements() []bson.RawElement {
+	elems, err := p.raw.Elements()
+
+	// We've validated this in the constructor, so if this happens then someone
+	// has done something nasty.
+	if err != nil {
+		panic(
+			fmt.Sprintf("got error calling raw.Elements() on a validated raw: %s", err),
+		)
+	}
+
+	return elems
+}
+
+// String returns a JSON representation of the pattern.
+func (p Pattern) String() string {
+	return p.raw.String()
+}
+
+// MarshalBSON implements the bson.Marshaler interface.
+func (p Pattern) MarshalBSON() ([]byte, error) {
+	// We just need to stash the raw here; we can fill back in hasID when we
+	// unmarshal.
+	return bson.Marshal(p.raw)
+}
+
+// MarshalBSON implements the bson.Unmarshaler interface.
+func (p *Pattern) UnmarshalBSON(data []byte) error {
+	var raw bson.Raw
+	err := bson.Unmarshal(data, &raw)
+	if err != nil {
+		return err
+	}
+
+	dupe, err := NewPattern(raw)
+	if err != nil {
+		return err
+	}
+
+	p.raw = dupe.raw
+	p.hasID = dupe.hasID
+	return nil
+}
diff --git a/dockey/unit_test.go b/dockey/unit_test.go
new file mode 100644
index 00000000..7c9a435b
--- /dev/null
+++ b/dockey/unit_test.go
@@ -0,0 +1,112 @@
+package dockey
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/suite"
+	"go.mongodb.org/mongo-driver/bson"
+)
+
+type UnitTestSuite struct {
+	suite.Suite
+}
+
+func TestUnitTestSuite(t *testing.T) {
+	ts := new(UnitTestSuite)
+	suite.Run(t, ts)
+}
+
+var testCases = []struct {
+	doc    bson.D
+	docKey bson.D
+}{
+	{
+		doc: bson.D{
+			{"foo", bson.D{
+				{"bar", bson.D{{"baz", 1}}},
+				{"bar.baz", 2},
+			}},
+			{"foo.bar", bson.D{{"baz", 3}}},
+			{"foo.bar.baz", 4},
+		},
+		docKey: bson.D{
+			{"foo.bar.baz", int32(4)},
+		},
+	},
+	{
+		doc: bson.D{
+			{"foo", bson.D{
+				{"bar", bson.D{{"baz", 1}}},
+				{"bar.baz", 2},
+			}},
+			{"foo.bar", bson.D{{"baz", 3}}},
+		},
+		docKey: bson.D{
+			{"foo.bar.baz", int32(2)},
+		},
+	},
+	{
+		doc: bson.D{
+			{"foo", bson.D{
+				{"bar", bson.D{{"baz", 1}}},
+			}},
+			{"foo.bar", bson.D{{"baz", 3}}},
+		},
+		docKey: bson.D{
+			{"foo.bar.baz", int32(1)},
+		},
+	},
+	{
+		doc: bson.D{
+			{"foo.bar", bson.D{{"baz", 3}}},
+		},
+		docKey: bson.D{}, // _id only
+	},
+	{
+		doc: bson.D{
+			{"foo", bson.D{{"bar.baz", nil}}},
+		},
+		docKey: bson.D{
+			{"foo.bar.baz", nil},
+		},
+	},
+}
+
+func (s *UnitTestSuite) TestExtractDocumentKey() {
+	patternRaw, err := bson.Marshal(bson.D{
+		{"_id", 1},
+		{"foo.bar.baz", 1},
+	})
+	s.Require().NoError(err)
+
+	pattern, err := NewPattern(patternRaw)
+	s.Require().NoError(err)
+
+	for _, curCase := range testCases {
+		doc, err := bson.Marshal(
+			append(
+				bson.D{{"_id", true}},
+				curCase.doc...,
+			),
+		)
+		s.Require().NoError(err)
+
+		docKeyRaw, err := ExtractDocumentKey(pattern, doc)
+		s.Require().NoError(err)
+
+		var docKey bson.D
+		s.Require().NoError(bson.Unmarshal(docKeyRaw, &docKey))
+
+		s.Assert().Equal(
+			append(
+				bson.D{{"_id", true}},
+				curCase.docKey...,
+			),
+			docKey,
+			"doc key for %v should be %v",
+			curCase.doc,
+			curCase.docKey,
+		)
+	}
+
+}
diff --git a/internal/verifier/compare.go b/internal/verifier/compare.go
index 18b32239..7c9837dd 100644
--- a/internal/verifier/compare.go
+++ b/internal/verifier/compare.go
@@ -631,12 +631,9 @@ func transformPipelineForToHashedIndexKey(
 		slices.Clone(in),
 		bson.D{{"$replaceWith", bson.D{
 			// Single-letter field names minimize the document size.
-			{docKeyInHashedCompare, bson.D(lo.Map(
+			{docKeyInHashedCompare, extractDocKeyAgg(
 				task.QueryFilter.GetDocKeyFields(),
-				func(f string, _ int) bson.E {
-					return bson.E{f, "$$ROOT." + f}
-				},
-			))},
+			)},
 			{"h", bson.D{
 				{"$toHashedIndexKey", bson.D{
 					{"$_internalKeyStringValue", bson.D{

From 0ac82bc5b949ab4169cac5e07884a55768723571 Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Mon, 11 Aug 2025 19:43:10 -0400
Subject: [PATCH 02/32] no base64

---
 dockey/agg.go | 68 ++++++++++++++-------------------------------------
 1 file changed, 19 insertions(+), 49 deletions(-)

diff --git a/dockey/agg.go b/dockey/agg.go
index 793c7f07..325621b7 100644
--- a/dockey/agg.go
+++ b/dockey/agg.go
@@ -1,74 +1,44 @@
 package dockey
 
 import (
+	"strconv"
 	"strings"
 
 	"go.mongodb.org/mongo-driver/bson"
 )
 
+// This function is important enough that we test it directly.
+// NOTE: The document contains base64-encoded names.
 func ExtractDocKeyAgg(fieldNames []string) bson.D {
 	return extractDocKeyFromAgg(fieldNames, "$$ROOT")
 }
 
 func extractDocKeyFromAgg(fieldNames []string, rootExpr any) bson.D {
-	var docKeyPieces [][2]any
+	var docKeyNumKeys bson.D
+	numToKeyLookup := bson.M{}
 
-	for _, name := range fieldNames {
+	for n, name := range fieldNames {
 		var valExpr = extractKeyValueAgg(name, rootExpr)
 
-		docKeyPieces = append(docKeyPieces, [...]any{name, valExpr})
+		nStr := strconv.Itoa(n)
+		docKeyNumKeys = append(docKeyNumKeys, bson.E{nStr, valExpr})
+		numToKeyLookup[nStr] = name
 	}
 
 	return bson.D{
-		{"$arrayToObject", bson.A{docKeyPieces}},
-	}
-}
-
-func existsAgg(fieldName string, baseDocExpr any) bson.D {
-	base, remainder, hasDot := strings.Cut(fieldName, ".")
-
-	fieldExpr := bson.D{
-		{"$getField", bson.D{
-			{"field", fieldName},
-			{"input", baseDocExpr},
-		}},
-	}
-
-	if !hasDot {
-		return bson.D{
-			{"$ne", bson.A{
-				"missing",
-				bson.D{{"$type", fieldExpr}},
-			}},
-		}
-	}
-
-	embDocExpr := bson.D{
-		{"$getField", bson.D{
-			{"field", base},
-			{"input", baseDocExpr},
-		}},
-	}
-
-	return bson.D{
-		{"$cond", bson.D{
-			{"if", bson.D{
-				{"$ne", bson.A{
-					"missing",
-					bson.D{{"$type", fieldExpr}},
+		{"$arrayToObject", bson.D{
+			{"$map", bson.D{
+				{"input", bson.D{
+					{"$objectToArray", docKeyNumKeys},
 				}},
-			}},
-			{"then", true},
-			{"else", bson.D{
-				{"$cond", bson.D{
-					{"if", bson.D{
-						{"$eq", bson.A{
-							"object",
-							bson.D{{"$type", embDocExpr}},
+				{"in", bson.D{
+					{"k", bson.D{
+						{"$getField", bson.D{
+							{"field", "$$this.k"},
+							{"input", numToKeyLookup},
 						}},
 					}},
-					{"then", extractKeyValueAgg(remainder, embDocExpr)},
-					{"else", false},
+					{"v", "$$this.v"},
 				}},
 			}},
 		}},

From 828f072a94b622443ee0bd30346679570eb6ff99 Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Tue, 12 Aug 2025 05:34:30 -0400
Subject: [PATCH 03/32] refactor a bit

---
 dockey/agg.go | 31 ++++++++++++++++++++++++-------
 1 file changed, 24 insertions(+), 7 deletions(-)

diff --git a/dockey/agg.go b/dockey/agg.go
index 325621b7..cb6f64c3 100644
--- a/dockey/agg.go
+++ b/dockey/agg.go
@@ -15,30 +15,47 @@ func ExtractDocKeyAgg(fieldNames []string) bson.D {
 
 func extractDocKeyFromAgg(fieldNames []string, rootExpr any) bson.D {
 	var docKeyNumKeys bson.D
-	numToKeyLookup := bson.M{}
+	numToKeyLookup := map[string]string{}
 
 	for n, name := range fieldNames {
 		var valExpr = extractKeyValueAgg(name, rootExpr)
 
+		// Aggregation forbids direct creation of an object with dotted keys.
+		// So here we create an object with numeric keys, then below we’ll
+		// map the numeric keys back to the real ones.
+
 		nStr := strconv.Itoa(n)
 		docKeyNumKeys = append(docKeyNumKeys, bson.E{nStr, valExpr})
 		numToKeyLookup[nStr] = name
 	}
 
+	// Now convert the numeric keys back to the real ones.
+	return mapObjectKeysAgg(docKeyNumKeys, numToKeyLookup)
+}
+
+// Potentially reusable:
+func mapObjectKeysAgg(expr any, mapping map[string]string) bson.D {
 	return bson.D{
 		{"$arrayToObject", bson.D{
 			{"$map", bson.D{
 				{"input", bson.D{
-					{"$objectToArray", docKeyNumKeys},
+					{"$objectToArray", expr},
 				}},
 				{"in", bson.D{
-					{"k", bson.D{
-						{"$getField", bson.D{
-							{"field", "$$this.k"},
-							{"input", numToKeyLookup},
+					{"$let", bson.D{
+						{"vars", bson.D{
+							{"keyLookup", mapping},
+						}},
+						{"in", bson.D{
+							{"k", bson.D{
+								{"$getField", bson.D{
+									{"field", "$$this.k"},
+									{"input", "$$keyLookup"},
+								}},
+							}},
+							{"v", "$$this.v"},
 						}},
 					}},
-					{"v", "$$this.v"},
 				}},
 			}},
 		}},

From bb0ac8b98beba303a331813035951d15ad58dd7d Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Tue, 12 Aug 2025 09:21:29 -0400
Subject: [PATCH 04/32] fix agg

---
 dockey/agg.go                | 29 +++++++++++++++++++++--------
 dockey/agg_test.go           |  2 +-
 internal/verifier/compare.go |  4 +++-
 3 files changed, 25 insertions(+), 10 deletions(-)

diff --git a/dockey/agg.go b/dockey/agg.go
index cb6f64c3..8e0a3fb8 100644
--- a/dockey/agg.go
+++ b/dockey/agg.go
@@ -7,18 +7,31 @@ import (
 	"go.mongodb.org/mongo-driver/bson"
 )
 
-// This function is important enough that we test it directly.
-// NOTE: The document contains base64-encoded names.
-func ExtractDocKeyAgg(fieldNames []string) bson.D {
-	return extractDocKeyFromAgg(fieldNames, "$$ROOT")
-}
-
-func extractDocKeyFromAgg(fieldNames []string, rootExpr any) bson.D {
+// ExtractDocKeyAgg returns an aggregation expression that extracts the
+// document key from the document to which the `docExpr` refers.
+//
+// For example, if the doc key field names are [`_id`, `lastName`], this
+// function’s returned expression will yield the same document that shows
+// as `documentKey` in the change stream if that document is inserted.
+// Any fields missing in the document will be excluded from the document key.
+//
+// This correctly reproduces the server’s behavior when field names
+// contain dots: it tries the full field name, then pops a “level” off
+// the name & checks a level further in the document (again privileging
+// the full field name’s remainder), and so on. For example, if the field
+// name is `foo.bar.baz`, this will look for these fields in this order
+// (JSON pointer notation):
+//   - `/foo.bar.baz`
+//   - `/foo/bar.baz`
+//   - `/foo/bar/baz`
+//
+// Note that the above DOES NOT include `/foo.bar/baz`.
+func ExtractDocKeyAgg(fieldNames []string, docExpr any) bson.D {
 	var docKeyNumKeys bson.D
 	numToKeyLookup := map[string]string{}
 
 	for n, name := range fieldNames {
-		var valExpr = extractKeyValueAgg(name, rootExpr)
+		var valExpr = extractKeyValueAgg(name, docExpr)
 
 		// Aggregation forbids direct creation of an object with dotted keys.
 		// So here we create an object with numeric keys, then below we’ll
diff --git a/dockey/agg_test.go b/dockey/agg_test.go
index 5b4ef8a3..21ffe35b 100644
--- a/dockey/agg_test.go
+++ b/dockey/agg_test.go
@@ -53,7 +53,7 @@ func TestExtractDocKeyAgg(t *testing.T) {
 	).Err(),
 	)
 
-	computedDocKeyAgg := extractDocKeyFromAgg(
+	computedDocKeyAgg := ExtractDocKeyAgg(
 		mslices.Of("foo.bar.baz", "_id"),
 		"$$ROOT.fullDocument",
 	)
diff --git a/internal/verifier/compare.go b/internal/verifier/compare.go
index 7c9837dd..f85520c5 100644
--- a/internal/verifier/compare.go
+++ b/internal/verifier/compare.go
@@ -8,6 +8,7 @@ import (
 
 	"github.com/10gen/migration-verifier/chanutil"
 	"github.com/10gen/migration-verifier/contextplus"
+	"github.com/10gen/migration-verifier/dockey"
 	"github.com/10gen/migration-verifier/internal/reportutils"
 	"github.com/10gen/migration-verifier/internal/retry"
 	"github.com/10gen/migration-verifier/internal/types"
@@ -631,8 +632,9 @@ func transformPipelineForToHashedIndexKey(
 		slices.Clone(in),
 		bson.D{{"$replaceWith", bson.D{
 			// Single-letter field names minimize the document size.
-			{docKeyInHashedCompare, extractDocKeyAgg(
+			{docKeyInHashedCompare, dockey.ExtractDocKeyAgg(
 				task.QueryFilter.GetDocKeyFields(),
+				"$$ROOT",
 			)},
 			{"h", bson.D{
 				{"$toHashedIndexKey", bson.D{

From b965033b24ee2190d2da137173a26694257e3b63 Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Wed, 13 Aug 2025 13:02:57 -0400
Subject: [PATCH 05/32] bring in mongosync

---
 dockey/agg.go                                 |    2 +
 dockey/agg_test.go                            |   56 +
 dockey/shardkey_pattern.go                    |  117 -
 dockey/unit_test.go                           |  112 -
 dockeys/README.md                             |   22 +
 dockey/dockey.go => dockeys/document_keys.go  |   41 +-
 go.mod                                        |   13 +-
 go.sum                                        |   14 +
 internal/verifier/compare.go                  |   68 +-
 vendor/github.com/golang/snappy/README        |    7 +-
 .../github.com/golang/snappy/encode_arm64.s   |    4 +-
 .../github.com/klauspost/compress/.gitignore  |    7 +
 .../klauspost/compress/.goreleaser.yml        |    4 +
 .../github.com/klauspost/compress/README.md   |  220 +-
 .../github.com/klauspost/compress/SECURITY.md |   25 +
 .../klauspost/compress/fse/compress.go        |   31 +-
 .../klauspost/compress/fse/decompress.go      |    4 +-
 .../klauspost/compress/huff0/bitreader.go     |  130 +-
 .../klauspost/compress/huff0/bitwriter.go     |  133 +-
 .../klauspost/compress/huff0/bytereader.go    |   10 -
 .../klauspost/compress/huff0/compress.go      |  127 +-
 .../klauspost/compress/huff0/decompress.go    |  744 ++-
 .../compress/huff0/decompress_amd64.go        |  226 +
 .../compress/huff0/decompress_amd64.s         |  830 ++++
 .../compress/huff0/decompress_generic.go      |  299 ++
 .../klauspost/compress/huff0/huff0.go         |    2 +
 .../compress/internal/cpuinfo/cpuinfo.go      |   34 +
 .../internal/cpuinfo/cpuinfo_amd64.go         |   11 +
 .../compress/internal/cpuinfo/cpuinfo_amd64.s |   36 +
 .../compress/internal/snapref/encode_other.go |   38 +-
 .../klauspost/compress/zstd/README.md         |  172 +-
 .../klauspost/compress/zstd/bitreader.go      |   12 +-
 .../klauspost/compress/zstd/bitwriter.go      |   98 +-
 .../klauspost/compress/zstd/blockdec.go       |  526 +--
 .../klauspost/compress/zstd/blockenc.go       |  117 +-
 .../klauspost/compress/zstd/bytebuf.go        |   27 +-
 .../klauspost/compress/zstd/bytereader.go     |    6 -
 .../klauspost/compress/zstd/decodeheader.go   |   93 +-
 .../klauspost/compress/zstd/decoder.go        |  685 ++-
 .../compress/zstd/decoder_options.go          |  103 +-
 .../klauspost/compress/zstd/dict.go           |   51 +-
 .../klauspost/compress/zstd/enc_base.go       |   17 +-
 .../klauspost/compress/zstd/enc_best.go       |  264 +-
 .../klauspost/compress/zstd/enc_better.go     |   43 +-
 .../klauspost/compress/zstd/enc_dfast.go      |   35 +-
 .../klauspost/compress/zstd/enc_fast.go       |  176 +-
 .../klauspost/compress/zstd/encoder.go        |  151 +-
 .../compress/zstd/encoder_options.go          |   55 +-
 .../klauspost/compress/zstd/framedec.go       |  342 +-
 .../klauspost/compress/zstd/fse_decoder.go    |  128 +-
 .../compress/zstd/fse_decoder_amd64.go        |   65 +
 .../compress/zstd/fse_decoder_amd64.s         |  126 +
 .../compress/zstd/fse_decoder_generic.go      |   72 +
 .../klauspost/compress/zstd/fse_encoder.go    |   28 +-
 .../klauspost/compress/zstd/hash.go           |    6 -
 .../klauspost/compress/zstd/history.go        |   67 +-
 .../compress/zstd/internal/xxhash/README.md   |   49 +-
 .../compress/zstd/internal/xxhash/xxhash.go   |   47 +-
 .../zstd/internal/xxhash/xxhash_amd64.go      |   12 -
 .../zstd/internal/xxhash/xxhash_amd64.s       |  337 +-
 .../zstd/internal/xxhash/xxhash_arm64.s       |  184 +
 .../zstd/internal/xxhash/xxhash_asm.go        |   16 +
 .../zstd/internal/xxhash/xxhash_other.go      |   23 +-
 .../klauspost/compress/zstd/matchlen_amd64.go |   16 +
 .../klauspost/compress/zstd/matchlen_amd64.s  |   68 +
 .../compress/zstd/matchlen_generic.go         |   33 +
 .../klauspost/compress/zstd/seqdec.go         |  328 +-
 .../klauspost/compress/zstd/seqdec_amd64.go   |  394 ++
 .../klauspost/compress/zstd/seqdec_amd64.s    | 4175 +++++++++++++++++
 .../klauspost/compress/zstd/seqdec_generic.go |  237 +
 .../github.com/klauspost/compress/zstd/zip.go |   69 +-
 .../klauspost/compress/zstd/zstd.go           |   55 +-
 vendor/go.mongodb.org/mongo-driver/v2/LICENSE |  201 +
 .../mongo-driver/v2/bson/array_codec.go       |   42 +
 .../mongo-driver/v2/bson/bsoncodec.go         |  203 +
 .../mongo-driver/v2/bson/byte_slice_codec.go  |   97 +
 .../mongo-driver/v2/bson/codec_cache.go       |  166 +
 .../mongo-driver/v2/bson/cond_addr_codec.go   |   61 +
 .../mongo-driver/v2/bson/copier.go            |  431 ++
 .../mongo-driver/v2/bson/decimal.go           |  339 ++
 .../mongo-driver/v2/bson/decoder.go           |  136 +
 .../v2/bson/default_value_decoders.go         | 1518 ++++++
 .../v2/bson/default_value_encoders.go         |  517 ++
 .../mongo-driver/v2/bson/doc.go               |  155 +
 .../v2/bson/empty_interface_codec.go          |  127 +
 .../mongo-driver/v2/bson/encoder.go           |  130 +
 .../mongo-driver/v2/bson/extjson_parser.go    |  804 ++++
 .../mongo-driver/v2/bson/extjson_reader.go    |  606 +++
 .../mongo-driver/v2/bson/extjson_tables.go    |  223 +
 .../mongo-driver/v2/bson/extjson_wrappers.go  |  489 ++
 .../mongo-driver/v2/bson/extjson_writer.go    |  690 +++
 .../mongo-driver/v2/bson/json_scanner.go      |  533 +++
 .../mongo-driver/v2/bson/map_codec.go         |  292 ++
 .../mongo-driver/v2/bson/marshal.go           |  191 +
 .../mongo-driver/v2/bson/mgoregistry.go       |  209 +
 .../mongo-driver/v2/bson/mode.go              |   82 +
 .../mongo-driver/v2/bson/objectid.go          |  207 +
 .../mongo-driver/v2/bson/pointer_codec.go     |   88 +
 .../mongo-driver/v2/bson/primitive.go         |  379 ++
 .../mongo-driver/v2/bson/primitive_codecs.go  |   89 +
 .../mongo-driver/v2/bson/raw.go               |   93 +
 .../mongo-driver/v2/bson/raw_array.go         |   73 +
 .../mongo-driver/v2/bson/raw_element.go       |   48 +
 .../mongo-driver/v2/bson/raw_value.go         |  306 ++
 .../mongo-driver/v2/bson/reader.go            |   49 +
 .../mongo-driver/v2/bson/registry.go          |  381 ++
 .../mongo-driver/v2/bson/slice_codec.go       |  173 +
 .../mongo-driver/v2/bson/string_codec.go      |  107 +
 .../mongo-driver/v2/bson/struct_codec.go      |  695 +++
 .../mongo-driver/v2/bson/struct_tag_parser.go |  123 +
 .../mongo-driver/v2/bson/time_codec.go        |  109 +
 .../mongo-driver/v2/bson/types.go             |  118 +
 .../mongo-driver/v2/bson/uint_codec.go        |  161 +
 .../mongo-driver/v2/bson/unmarshal.go         |   90 +
 .../mongo-driver/v2/bson/value_reader.go      |  898 ++++
 .../mongo-driver/v2/bson/value_writer.go      |  600 +++
 .../mongo-driver/v2/bson/vector.go            |  268 ++
 .../mongo-driver/v2/bson/writer.go            |   61 +
 .../v2/internal/bsoncoreutil/bsoncoreutil.go  |   40 +
 .../v2/internal/decimal128/decinal128.go      |  117 +
 .../mongo-driver/v2/x/bsonx/bsoncore/array.go |  185 +
 .../v2/x/bsonx/bsoncore/bson_arraybuilder.go  |  198 +
 .../x/bsonx/bsoncore/bson_documentbuilder.go  |  184 +
 .../v2/x/bsonx/bsoncore/bsoncore.go           |  842 ++++
 .../mongo-driver/v2/x/bsonx/bsoncore/doc.go   |   34 +
 .../v2/x/bsonx/bsoncore/document.go           |  411 ++
 .../v2/x/bsonx/bsoncore/element.go            |  166 +
 .../v2/x/bsonx/bsoncore/iterator.go           |  113 +
 .../v2/x/bsonx/bsoncore/tables.go             |  223 +
 .../mongo-driver/v2/x/bsonx/bsoncore/type.go  |   85 +
 .../mongo-driver/v2/x/bsonx/bsoncore/value.go |  986 ++++
 vendor/golang.org/x/crypto/sha3/doc.go        |    4 +
 vendor/golang.org/x/crypto/sha3/hashes.go     |   31 +-
 vendor/golang.org/x/crypto/sha3/sha3.go       |  187 +-
 vendor/golang.org/x/crypto/sha3/shake.go      |   89 +-
 vendor/golang.org/x/crypto/sha3/xor.go        |   40 -
 vendor/golang.org/x/sync/errgroup/errgroup.go |    1 +
 .../golang.org/x/sys/cpu/asm_darwin_x86_gc.s  |   17 +
 vendor/golang.org/x/sys/cpu/cpu.go            |   22 +
 vendor/golang.org/x/sys/cpu/cpu_darwin_x86.go |   61 +
 vendor/golang.org/x/sys/cpu/cpu_gc_x86.go     |    4 +-
 .../x/sys/cpu/{cpu_x86.s => cpu_gc_x86.s}     |    2 +-
 vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go  |    6 -
 .../golang.org/x/sys/cpu/cpu_linux_arm64.go   |    1 -
 .../golang.org/x/sys/cpu/cpu_linux_noinit.go  |    2 +-
 .../golang.org/x/sys/cpu/cpu_linux_riscv64.go |  137 +
 vendor/golang.org/x/sys/cpu/cpu_other_x86.go  |   11 +
 vendor/golang.org/x/sys/cpu/cpu_riscv64.go    |   11 +-
 vendor/golang.org/x/sys/cpu/cpu_x86.go        |   27 +-
 .../x/sys/cpu/syscall_darwin_x86_gc.go        |   98 +
 vendor/golang.org/x/sys/unix/README.md        |    2 +-
 vendor/golang.org/x/sys/unix/auxv.go          |   36 +
 .../golang.org/x/sys/unix/auxv_unsupported.go |   13 +
 vendor/golang.org/x/sys/unix/ioctl_linux.go   |   96 +
 vendor/golang.org/x/sys/unix/mkerrors.sh      |   17 +-
 vendor/golang.org/x/sys/unix/syscall_aix.go   |    2 +-
 .../golang.org/x/sys/unix/syscall_darwin.go   |   37 +
 .../x/sys/unix/syscall_dragonfly.go           |   12 +
 vendor/golang.org/x/sys/unix/syscall_hurd.go  |    1 +
 vendor/golang.org/x/sys/unix/syscall_linux.go |   64 +-
 .../x/sys/unix/syscall_linux_arm64.go         |    2 +
 .../x/sys/unix/syscall_linux_loong64.go       |    2 +
 .../x/sys/unix/syscall_linux_riscv64.go       |    2 +
 .../golang.org/x/sys/unix/syscall_solaris.go  |   87 +
 .../x/sys/unix/syscall_zos_s390x.go           |  104 +-
 .../golang.org/x/sys/unix/vgetrandom_linux.go |   13 +
 .../x/sys/unix/vgetrandom_unsupported.go      |   11 +
 .../x/sys/unix/zerrors_darwin_amd64.go        |    7 +
 .../x/sys/unix/zerrors_darwin_arm64.go        |    7 +
 vendor/golang.org/x/sys/unix/zerrors_linux.go |   64 +-
 .../x/sys/unix/zerrors_linux_386.go           |   28 +
 .../x/sys/unix/zerrors_linux_amd64.go         |   28 +
 .../x/sys/unix/zerrors_linux_arm.go           |   28 +
 .../x/sys/unix/zerrors_linux_arm64.go         |   30 +
 .../x/sys/unix/zerrors_linux_loong64.go       |   28 +
 .../x/sys/unix/zerrors_linux_mips.go          |   28 +
 .../x/sys/unix/zerrors_linux_mips64.go        |   28 +
 .../x/sys/unix/zerrors_linux_mips64le.go      |   28 +
 .../x/sys/unix/zerrors_linux_mipsle.go        |   28 +
 .../x/sys/unix/zerrors_linux_ppc.go           |   28 +
 .../x/sys/unix/zerrors_linux_ppc64.go         |   28 +
 .../x/sys/unix/zerrors_linux_ppc64le.go       |   28 +
 .../x/sys/unix/zerrors_linux_riscv64.go       |   28 +
 .../x/sys/unix/zerrors_linux_s390x.go         |   28 +
 .../x/sys/unix/zerrors_linux_sparc64.go       |   28 +
 .../x/sys/unix/zerrors_zos_s390x.go           |    2 +
 .../x/sys/unix/zsyscall_darwin_amd64.go       |   20 +
 .../x/sys/unix/zsyscall_darwin_amd64.s        |    5 +
 .../x/sys/unix/zsyscall_darwin_arm64.go       |   20 +
 .../x/sys/unix/zsyscall_darwin_arm64.s        |    5 +
 .../golang.org/x/sys/unix/zsyscall_linux.go   |   27 +-
 .../x/sys/unix/zsyscall_solaris_amd64.go      |  114 +
 .../x/sys/unix/zsysnum_linux_386.go           |    4 +
 .../x/sys/unix/zsysnum_linux_amd64.go         |    5 +
 .../x/sys/unix/zsysnum_linux_arm.go           |    4 +
 .../x/sys/unix/zsysnum_linux_arm64.go         |    6 +-
 .../x/sys/unix/zsysnum_linux_loong64.go       |    6 +
 .../x/sys/unix/zsysnum_linux_mips.go          |    4 +
 .../x/sys/unix/zsysnum_linux_mips64.go        |    4 +
 .../x/sys/unix/zsysnum_linux_mips64le.go      |    4 +
 .../x/sys/unix/zsysnum_linux_mipsle.go        |    4 +
 .../x/sys/unix/zsysnum_linux_ppc.go           |    4 +
 .../x/sys/unix/zsysnum_linux_ppc64.go         |    4 +
 .../x/sys/unix/zsysnum_linux_ppc64le.go       |    4 +
 .../x/sys/unix/zsysnum_linux_riscv64.go       |    6 +-
 .../x/sys/unix/zsysnum_linux_s390x.go         |    4 +
 .../x/sys/unix/zsysnum_linux_sparc64.go       |    4 +
 .../x/sys/unix/ztypes_darwin_amd64.go         |   73 +
 .../x/sys/unix/ztypes_darwin_arm64.go         |   73 +
 .../x/sys/unix/ztypes_freebsd_386.go          |    1 +
 .../x/sys/unix/ztypes_freebsd_amd64.go        |    1 +
 .../x/sys/unix/ztypes_freebsd_arm.go          |    1 +
 .../x/sys/unix/ztypes_freebsd_arm64.go        |    1 +
 .../x/sys/unix/ztypes_freebsd_riscv64.go      |    1 +
 vendor/golang.org/x/sys/unix/ztypes_linux.go  |  231 +-
 .../x/sys/unix/ztypes_linux_riscv64.go        |   33 +
 .../golang.org/x/sys/unix/ztypes_zos_s390x.go |    6 +
 vendor/modules.txt                            |   21 +-
 218 files changed, 28976 insertions(+), 3295 deletions(-)
 delete mode 100644 dockey/shardkey_pattern.go
 delete mode 100644 dockey/unit_test.go
 create mode 100644 dockeys/README.md
 rename dockey/dockey.go => dockeys/document_keys.go (71%)
 create mode 100644 vendor/github.com/klauspost/compress/SECURITY.md
 create mode 100644 vendor/github.com/klauspost/compress/huff0/decompress_amd64.go
 create mode 100644 vendor/github.com/klauspost/compress/huff0/decompress_amd64.s
 create mode 100644 vendor/github.com/klauspost/compress/huff0/decompress_generic.go
 create mode 100644 vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo.go
 create mode 100644 vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.go
 create mode 100644 vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.s
 create mode 100644 vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.go
 create mode 100644 vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.s
 create mode 100644 vendor/github.com/klauspost/compress/zstd/fse_decoder_generic.go
 delete mode 100644 vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_amd64.go
 create mode 100644 vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_arm64.s
 create mode 100644 vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_asm.go
 create mode 100644 vendor/github.com/klauspost/compress/zstd/matchlen_amd64.go
 create mode 100644 vendor/github.com/klauspost/compress/zstd/matchlen_amd64.s
 create mode 100644 vendor/github.com/klauspost/compress/zstd/matchlen_generic.go
 create mode 100644 vendor/github.com/klauspost/compress/zstd/seqdec_amd64.go
 create mode 100644 vendor/github.com/klauspost/compress/zstd/seqdec_amd64.s
 create mode 100644 vendor/github.com/klauspost/compress/zstd/seqdec_generic.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/LICENSE
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/array_codec.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/bsoncodec.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/byte_slice_codec.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/codec_cache.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/cond_addr_codec.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/copier.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/decimal.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/decoder.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/default_value_decoders.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/default_value_encoders.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/doc.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/empty_interface_codec.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/encoder.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_parser.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_reader.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_tables.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_wrappers.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_writer.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/json_scanner.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/map_codec.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/marshal.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/mgoregistry.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/mode.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/objectid.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/pointer_codec.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/primitive.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/primitive_codecs.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/raw.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/raw_array.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/raw_element.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/raw_value.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/reader.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/registry.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/slice_codec.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/string_codec.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/struct_codec.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/struct_tag_parser.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/time_codec.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/types.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/uint_codec.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/unmarshal.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/value_reader.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/value_writer.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/vector.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/writer.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/internal/bsoncoreutil/bsoncoreutil.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/internal/decimal128/decinal128.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/array.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bson_arraybuilder.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bson_documentbuilder.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bsoncore.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/doc.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/document.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/element.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/iterator.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/tables.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/type.go
 create mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/value.go
 delete mode 100644 vendor/golang.org/x/crypto/sha3/xor.go
 create mode 100644 vendor/golang.org/x/sys/cpu/asm_darwin_x86_gc.s
 create mode 100644 vendor/golang.org/x/sys/cpu/cpu_darwin_x86.go
 rename vendor/golang.org/x/sys/cpu/{cpu_x86.s => cpu_gc_x86.s} (94%)
 create mode 100644 vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go
 create mode 100644 vendor/golang.org/x/sys/cpu/cpu_other_x86.go
 create mode 100644 vendor/golang.org/x/sys/cpu/syscall_darwin_x86_gc.go
 create mode 100644 vendor/golang.org/x/sys/unix/auxv.go
 create mode 100644 vendor/golang.org/x/sys/unix/auxv_unsupported.go
 create mode 100644 vendor/golang.org/x/sys/unix/vgetrandom_linux.go
 create mode 100644 vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go

diff --git a/dockey/agg.go b/dockey/agg.go
index 8e0a3fb8..dc62fe8e 100644
--- a/dockey/agg.go
+++ b/dockey/agg.go
@@ -1,3 +1,5 @@
+// Package dockey contains logic related to document key determination.
+
 package dockey
 
 import (
diff --git a/dockey/agg_test.go b/dockey/agg_test.go
index 21ffe35b..a95385fc 100644
--- a/dockey/agg_test.go
+++ b/dockey/agg_test.go
@@ -14,6 +14,62 @@ import (
 	"go.mongodb.org/mongo-driver/mongo/options"
 )
 
+var testCases = []struct {
+	doc    bson.D
+	docKey bson.D
+}{
+	{
+		doc: bson.D{
+			{"foo", bson.D{
+				{"bar", bson.D{{"baz", 1}}},
+				{"bar.baz", 2},
+			}},
+			{"foo.bar", bson.D{{"baz", 3}}},
+			{"foo.bar.baz", 4},
+		},
+		docKey: bson.D{
+			{"foo.bar.baz", int32(4)},
+		},
+	},
+	{
+		doc: bson.D{
+			{"foo", bson.D{
+				{"bar", bson.D{{"baz", 1}}},
+				{"bar.baz", 2},
+			}},
+			{"foo.bar", bson.D{{"baz", 3}}},
+		},
+		docKey: bson.D{
+			{"foo.bar.baz", int32(2)},
+		},
+	},
+	{
+		doc: bson.D{
+			{"foo", bson.D{
+				{"bar", bson.D{{"baz", 1}}},
+			}},
+			{"foo.bar", bson.D{{"baz", 3}}},
+		},
+		docKey: bson.D{
+			{"foo.bar.baz", int32(1)},
+		},
+	},
+	{
+		doc: bson.D{
+			{"foo.bar", bson.D{{"baz", 3}}},
+		},
+		docKey: bson.D{}, // _id only
+	},
+	{
+		doc: bson.D{
+			{"foo", bson.D{{"bar.baz", nil}}},
+		},
+		docKey: bson.D{
+			{"foo.bar.baz", nil},
+		},
+	},
+}
+
 func TestExtractDocKeyAgg(t *testing.T) {
 	ctx := t.Context()
 
diff --git a/dockey/shardkey_pattern.go b/dockey/shardkey_pattern.go
deleted file mode 100644
index 2b0d4b24..00000000
--- a/dockey/shardkey_pattern.go
+++ /dev/null
@@ -1,117 +0,0 @@
-package dockey
-
-import (
-	"fmt"
-
-	"github.com/pkg/errors"
-	"go.mongodb.org/mongo-driver/bson"
-)
-
-// Pattern represents a collection shard key (the thing you'd pass to
-// shardCollection). It's called a "pattern" to distinguish the collection's
-// shard key from a document's shard key. The zero value for Pattern
-// is useful by itself: it behaves as though a collection has no shard key at
-// all.
-type Pattern struct {
-	raw   bson.Raw
-	hasID bool
-}
-
-// EmptyPattern is an empty pattern; it can be used to represent unsharded
-// collections.
-var EmptyPattern Pattern
-
-// NewPattern takes a raw document, like the thing you'd find in
-// config.collections. It validates that the shard key is valid BSON, and
-// returns a Pattern.
-func NewPattern(raw bson.Raw) (Pattern, error) {
-	if len(raw) == 0 {
-		return Pattern{}, nil
-	}
-
-	err := raw.Validate()
-	if err != nil {
-		return Pattern{}, errors.Wrap(err, "failed to validate shard key pattern")
-	}
-
-	_, lookupErr := raw.LookupErr("_id")
-	hasID := lookupErr == nil
-
-	return Pattern{raw, hasID}, nil
-}
-
-// PatternFromMarshalable takes a marshalable object (like a bson.D) and
-// returns a new Pattern. This function panics on any error. It's mostly here
-// because it's convenient to use in tests, where you know you'll have a valid
-// pattern.
-func PatternFromMarshalable(key any) Pattern {
-	raw, err := bson.Marshal(key)
-	if err != nil {
-		panic(err)
-	}
-
-	p, err := NewPattern(raw)
-	if err != nil {
-		panic(err)
-	}
-
-	return p
-}
-
-// ContainsID returns true if the shard key pattern contains the _id field.
-func (p Pattern) ContainsID() bool {
-	return p.hasID
-}
-
-// IsEmpty returns true if this is a zero-value pattern.
-func (p Pattern) IsEmpty() bool {
-	return len(p.raw) == 0
-}
-
-// Elements returns a slice of bson.RawElement values for every element of the
-// shard key. It works like the bson.Raw.Elements method, but does not return
-// an error (because we validate the underlying raw document in the
-// constructor).
-func (p Pattern) Elements() []bson.RawElement {
-	elems, err := p.raw.Elements()
-
-	// We've validated this in the constructor, so if this happens then someone
-	// has done something nasty.
-	if err != nil {
-		panic(
-			fmt.Sprintf("got error calling raw.Elements() on a validated raw: %s", err),
-		)
-	}
-
-	return elems
-}
-
-// String returns a JSON representation of the pattern.
-func (p Pattern) String() string {
-	return p.raw.String()
-}
-
-// MarshalBSON implements the bson.Marshaler interface.
-func (p Pattern) MarshalBSON() ([]byte, error) {
-	// We just need to stash the raw here; we can fill back in hasID when we
-	// unmarshal.
-	return bson.Marshal(p.raw)
-}
-
-// MarshalBSON implements the bson.Unmarshaler interface.
-func (p *Pattern) UnmarshalBSON(data []byte) error {
-	var raw bson.Raw
-	err := bson.Unmarshal(data, &raw)
-	if err != nil {
-		return err
-	}
-
-	dupe, err := NewPattern(raw)
-	if err != nil {
-		return err
-	}
-
-	p.raw = dupe.raw
-	p.hasID = dupe.hasID
-	return nil
-}
diff --git a/dockey/unit_test.go b/dockey/unit_test.go
deleted file mode 100644
index 7c9a435b..00000000
--- a/dockey/unit_test.go
+++ /dev/null
@@ -1,112 +0,0 @@
-package dockey
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/suite"
-	"go.mongodb.org/mongo-driver/bson"
-)
-
-type UnitTestSuite struct {
-	suite.Suite
-}
-
-func TestUnitTestSuite(t *testing.T) {
-	ts := new(UnitTestSuite)
-	suite.Run(t, ts)
-}
-
-var testCases = []struct {
-	doc    bson.D
-	docKey bson.D
-}{
-	{
-		doc: bson.D{
-			{"foo", bson.D{
-				{"bar", bson.D{{"baz", 1}}},
-				{"bar.baz", 2},
-			}},
-			{"foo.bar", bson.D{{"baz", 3}}},
-			{"foo.bar.baz", 4},
-		},
-		docKey: bson.D{
-			{"foo.bar.baz", int32(4)},
-		},
-	},
-	{
-		doc: bson.D{
-			{"foo", bson.D{
-				{"bar", bson.D{{"baz", 1}}},
-				{"bar.baz", 2},
-			}},
-			{"foo.bar", bson.D{{"baz", 3}}},
-		},
-		docKey: bson.D{
-			{"foo.bar.baz", int32(2)},
-		},
-	},
-	{
-		doc: bson.D{
-			{"foo", bson.D{
-				{"bar", bson.D{{"baz", 1}}},
-			}},
-			{"foo.bar", bson.D{{"baz", 3}}},
-		},
-		docKey: bson.D{
-			{"foo.bar.baz", int32(1)},
-		},
-	},
-	{
-		doc: bson.D{
-			{"foo.bar", bson.D{{"baz", 3}}},
-		},
-		docKey: bson.D{}, // _id only
-	},
-	{
-		doc: bson.D{
-			{"foo", bson.D{{"bar.baz", nil}}},
-		},
-		docKey: bson.D{
-			{"foo.bar.baz", nil},
-		},
-	},
-}
-
-func (s *UnitTestSuite) TestExtractDocumentKey() {
-	patternRaw, err := bson.Marshal(bson.D{
-		{"_id", 1},
-		{"foo.bar.baz", 1},
-	})
-	s.Require().NoError(err)
-
-	pattern, err := NewPattern(patternRaw)
-	s.Require().NoError(err)
-
-	for _, curCase := range testCases {
-		doc, err := bson.Marshal(
-			append(
-				bson.D{{"_id", true}},
-				curCase.doc...,
-			),
-		)
-		s.Require().NoError(err)
-
-		docKeyRaw, err := ExtractDocumentKey(pattern, doc)
-		s.Require().NoError(err)
-
-		var docKey bson.D
-		s.Require().NoError(bson.Unmarshal(docKeyRaw, &docKey))
-
-		s.Assert().Equal(
-			append(
-				bson.D{{"_id", true}},
-				curCase.docKey...,
-			),
-			docKey,
-			"doc key for %v should be %v",
-			curCase.doc,
-			curCase.docKey,
-		)
-	}
-
-}
diff --git a/dockeys/README.md b/dockeys/README.md
new file mode 100644
index 00000000..49f8d4a1
--- /dev/null
+++ b/dockeys/README.md
@@ -0,0 +1,22 @@
+# The `dockeys` package
+
+This package is responsible for computing document keys from full documents. A _document key_
+uniquely identifies a document: for replica sets, the document key is always just the `_id`, and in
+sharded clusters, it is the `_id` + shard key. The verifier uses document keys to key the maps in
+the aggregator: we need to do this because keying by `_id` is not sufficient, since the same `_id`
+can exist on multiple shards with different shard keys. (This is not merely academic: mongosync
+creates these transient duplicate `_id`s as part of its normal operation.)
+
+The logic in this package duplicates the server's logic for generating document keys. Ideally we
+_wouldn't_ do this, and could rely on the server to generate them for us in all cases, but right now
+there is no way to do that. (The verifier must generate document keys from documents at rest during
+the initial collection scan.)
+
+To generate the document key for a document, pass the shard key pattern and the full document to
+`ExtractDocumentKey`. That function will first iterate through the shard key and extract all of the
+relevant field values from the document, if they are present. If the `_id` is not a part of the
+shard key pattern, it also appends the `_id` field.
+
+**Important:** the tests for this package are in `verifier/dockeys_test`. They use all of the
+verifier's test abstractions, and so it's easier for now to keep them there. (When mongosync and the
+verifier share more test abstractions, it might be useful to move them.)
diff --git a/dockey/dockey.go b/dockeys/document_keys.go
similarity index 71%
rename from dockey/dockey.go
rename to dockeys/document_keys.go
index 2b0d215e..b3dba3d4 100644
--- a/dockey/dockey.go
+++ b/dockeys/document_keys.go
@@ -1,12 +1,16 @@
-package dockey
+// Package dockeys was copied from mongosync@5b99bac58405b and tweaked
+// not to depend on mongosync’s shardkeys package but instead just to take
+// a slice of field names.
+package dockeys
 
 import (
 	"fmt"
+	"slices"
 	"strings"
 
 	"github.com/pkg/errors"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/x/bsonx/bsoncore"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
 )
 
 // DocumentKey represents a document key from the change stream.
@@ -18,41 +22,44 @@ func NewDocumentKey(raw bson.Raw) DocumentKey {
 	return DocumentKey(raw)
 }
 
-// ExtractDocumentKey takes a shard key pattern and a document and returns its
+// ExtractDocumentKey takes a slice of shard key fields and a document and returns its
 // DocumentKey. This is a reimplementation of the same method in the server,
 // so that we can reliably generate document keys even without a change
 // stream.
-func ExtractDocumentKey(pattern Pattern, input bson.Raw) (DocumentKey, error) {
-	builder, err := extractShardKey(pattern, input)
+func ExtractDocumentKey(fields []string, inputBytes []byte) (DocumentKey, error) {
+	input := bson.Raw(inputBytes)
+
+	builder, err := extractShardKey(fields, input)
 	if err != nil {
 		return nil, err
 	}
 
-	if !pattern.ContainsID() {
+	if !slices.Contains(fields, "_id") {
 		id, err := input.LookupErr("_id")
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to get document _id")
 		}
 
-		val := bsoncore.Value{Type: id.Type, Data: id.Value}
+		val := bsoncore.Value{Type: bsoncore.Type(id.Type), Data: id.Value}
 		builder.AppendValue("_id", val)
 	}
 
 	return DocumentKey(builder.Build()), nil
 }
 
-// extractShardKey does the shard-key part of the document key extraction.
-func extractShardKey(pattern Pattern, input bson.Raw) (*bsoncore.DocumentBuilder, error) {
+// extractShardKey does the shard-key part of the document key extraction. This code is a
+// reimplementation of the server's extractElementsBasedOnTemplate function (in
+// dotted_path_support.cpp), which is called from getDocumentKey in op_observer_util.cpp (which is
+// used by the change stream to generate document keys).
+func extractShardKey(fields []string, input bson.Raw) (*bsoncore.DocumentBuilder, error) {
 	db := bsoncore.NewDocumentBuilder()
 
-	if pattern.IsEmpty() {
+	if len(fields) == 0 {
 		return db, nil
 	}
 
 	// For every element of the shard key pattern:
-	for _, e := range pattern.Elements() {
-		key := e.Key()
-
+	for _, key := range fields {
 		rv, err := extractElementAtDottedPath(key, input)
 
 		switch {
@@ -70,7 +77,7 @@ func extractShardKey(pattern Pattern, input bson.Raw) (*bsoncore.DocumentBuilder
 
 		default:
 			// We found the element; add it to the result.
-			val := bsoncore.Value{Type: rv.Type, Data: rv.Value}
+			val := bsoncore.Value{Type: bsoncore.Type(rv.Type), Data: rv.Value}
 			db.AppendValue(key, val)
 		}
 	}
@@ -79,6 +86,8 @@ func extractShardKey(pattern Pattern, input bson.Raw) (*bsoncore.DocumentBuilder
 	return db, nil
 }
 
+// This code is a reimplementation of the server's extractElementAtDottedPath function in
+// dotted_path_support.cpp.
 func extractElementAtDottedPath(path string, input bson.Raw) (bson.RawValue, error) {
 	// First, try to look up the field verbatim. We must do this because field
 	// names can have dots in them: a shard key pattern like {"a.b": 1} will
@@ -102,7 +111,7 @@ func extractElementAtDottedPath(path string, input bson.Raw) (bson.RawValue, err
 		if !ok {
 			return rv, bsoncore.InvalidDepthTraversalError{
 				Key:  left,
-				Type: el.Type,
+				Type: bsoncore.Type(el.Type),
 			}
 		}
 
diff --git a/go.mod b/go.mod
index 7edebef8..0b24d036 100644
--- a/go.mod
+++ b/go.mod
@@ -19,7 +19,7 @@ require (
 	github.com/urfave/cli v1.22.9
 	go.mongodb.org/mongo-driver v1.17.1
 	golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56
-	golang.org/x/sync v0.8.0
+	golang.org/x/sync v0.11.0
 	gopkg.in/natefinch/lumberjack.v2 v2.0.0
 )
 
@@ -32,10 +32,10 @@ require (
 	github.com/go-playground/universal-translator v0.18.0 // indirect
 	github.com/go-playground/validator/v10 v10.10.0 // indirect
 	github.com/goccy/go-json v0.9.7 // indirect
-	github.com/golang/snappy v0.0.4 // indirect
+	github.com/golang/snappy v1.0.0 // indirect
 	github.com/huandu/go-clone v1.6.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/compress v1.13.6 // indirect
+	github.com/klauspost/compress v1.16.7 // indirect
 	github.com/leodido/go-urn v1.2.1 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.19 // indirect
@@ -51,10 +51,11 @@ require (
 	github.com/xdg-go/scram v1.1.2 // indirect
 	github.com/xdg-go/stringprep v1.0.4 // indirect
 	github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
-	golang.org/x/crypto v0.26.0 // indirect
+	go.mongodb.org/mongo-driver/v2 v2.2.3 // indirect
+	golang.org/x/crypto v0.33.0 // indirect
 	golang.org/x/net v0.21.0 // indirect
-	golang.org/x/sys v0.23.0 // indirect
-	golang.org/x/text v0.17.0 // indirect
+	golang.org/x/sys v0.30.0 // indirect
+	golang.org/x/text v0.22.0 // indirect
 	google.golang.org/protobuf v1.28.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
diff --git a/go.sum b/go.sum
index 918591a6..dabb3b87 100644
--- a/go.sum
+++ b/go.sum
@@ -32,6 +32,8 @@ github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5x
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v1.0.0 h1:Oy607GVXHs7RtbggtPBnr2RmDArIsAefDwvrdWvRhGs=
+github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
@@ -48,6 +50,8 @@ github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnr
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/klauspost/compress v1.13.6 h1:P76CopJELS0TiO2mebmnzgWaajssP/EszplttgQxcgc=
 github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
+github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGCFR9I=
+github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
@@ -121,11 +125,15 @@ github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78/go.mod h1:aL8wCCfTfS
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 go.mongodb.org/mongo-driver v1.17.1 h1:Wic5cJIwJgSpBhe3lx3+/RybR5PiYRMpVFgO7cOHyIM=
 go.mongodb.org/mongo-driver v1.17.1/go.mod h1:wwWm/+BuOddhcq3n68LKRmgk2wXzmF6s0SFOa0GINL4=
+go.mongodb.org/mongo-driver/v2 v2.2.3 h1:72uiGYXeSnUEQk37xvV9r067xzFQod4SOeAoOuq3+GM=
+go.mongodb.org/mongo-driver/v2 v2.2.3/go.mod h1:qQkDMhCGWl3FN509DfdPd4GRBLU/41zqF/k8eTRceps=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw=
 golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54=
+golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
+golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
 golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
 golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
@@ -138,6 +146,8 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
 golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
+golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -149,6 +159,8 @@ golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.23.0 h1:YfKFowiIMvtgl1UERQoTPPToxltDeZfbj4H7dVUCwmM=
 golang.org/x/sys v0.23.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -158,6 +170,8 @@ golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
 golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc=
 golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
+golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
diff --git a/internal/verifier/compare.go b/internal/verifier/compare.go
index f85520c5..81081e6f 100644
--- a/internal/verifier/compare.go
+++ b/internal/verifier/compare.go
@@ -9,6 +9,7 @@ import (
 	"github.com/10gen/migration-verifier/chanutil"
 	"github.com/10gen/migration-verifier/contextplus"
 	"github.com/10gen/migration-verifier/dockey"
+	"github.com/10gen/migration-verifier/dockeys"
 	"github.com/10gen/migration-verifier/internal/reportutils"
 	"github.com/10gen/migration-verifier/internal/retry"
 	"github.com/10gen/migration-verifier/internal/types"
@@ -127,16 +128,15 @@ func (verifier *Verifier) compareDocsFromChannels(
 	// b) compares the new doc against its previously-received, cached
 	//    counterpart and records any mismatch.
 	handleNewDoc := func(curDocWithTs docWithTs, isSrc bool) error {
-		docKeyValues := lo.Map(
+		docKeyValues, err := getDocKeyValues(
+			verifier.docCompareMethod,
+			curDocWithTs.doc,
 			mapKeyFieldNames,
-			func(fieldName string, _ int) bson.RawValue {
-				return getDocKeyFieldFromComparison(
-					verifier.docCompareMethod,
-					curDocWithTs.doc,
-					fieldName,
-				)
-			},
 		)
+		if err != nil {
+			return errors.Wrapf(err, "extracting doc key (fields: %v) values from doc %+v", mapKeyFieldNames, curDocWithTs.doc)
+		}
+
 		mapKey := getMapKey(docKeyValues)
 
 		var ourMap, theirMap map[string]docWithTs
@@ -372,6 +372,58 @@ func getDocKeyFieldFromComparison(
 	}
 }
 
+func getDocKeyValues(
+	docCompareMethod DocCompareMethod,
+	doc bson.Raw,
+	fieldNames []string,
+) ([]bson.RawValue, error) {
+	var docKey bson.Raw
+
+	switch docCompareMethod {
+	case DocCompareBinary, DocCompareIgnoreOrder:
+		dk, err := dockeys.ExtractDocumentKey(fieldNames, doc)
+		if err != nil {
+			return nil, errors.Wrapf(err, "extracting doc key (fields: %v) from doc %+v", fieldNames, doc)
+		}
+
+		docKey = bson.Raw(dk.Bytes())
+	case DocCompareToHashedIndexKey:
+		docKeyVal, err := doc.LookupErr(docKeyInHashedCompare)
+		if err != nil {
+			return nil, errors.Wrapf(err, "fetching %#q from doc %v", docKeyInHashedCompare, doc)
+		}
+
+		var isDoc bool
+		docKey, isDoc = docKeyVal.DocumentOK()
+		if !isDoc {
+			return nil, fmt.Errorf(
+				"%#q in doc %v is type %s but should be %s",
+				docKeyInHashedCompare,
+				doc,
+				docKeyVal.Type,
+				bson.TypeEmbeddedDocument,
+			)
+		}
+	}
+
+	var values []bson.RawValue
+	els, err := docKey.Elements()
+	if err != nil {
+		return nil, errors.Wrapf(err, "parsing doc key (%+v) of doc %+v", docKey, doc)
+	}
+
+	for _, el := range els {
+		val, err := el.ValueErr()
+		if err != nil {
+			return nil, errors.Wrapf(err, "parsing doc key element (%+v) of doc %+v", el, doc)
+		}
+
+		values = append(values, val)
+	}
+
+	return values, nil
+}
+
 func simpleTimerReset(t *time.Timer, dur time.Duration) {
 	if !t.Stop() {
 		<-t.C
diff --git a/vendor/github.com/golang/snappy/README b/vendor/github.com/golang/snappy/README
index cea12879..fd191f78 100644
--- a/vendor/github.com/golang/snappy/README
+++ b/vendor/github.com/golang/snappy/README
@@ -1,8 +1,13 @@
 The Snappy compression format in the Go programming language.
 
-To download and install from source:
+To use as a library:
 $ go get github.com/golang/snappy
 
+To use as a binary:
+$ go install github.com/golang/snappy/cmd/snappytool@latest
+$ cat decoded | ~/go/bin/snappytool -e > encoded
+$ cat encoded | ~/go/bin/snappytool -d > decoded
+
 Unless otherwise noted, the Snappy-Go source files are distributed
 under the BSD-style license found in the LICENSE file.
 
diff --git a/vendor/github.com/golang/snappy/encode_arm64.s b/vendor/github.com/golang/snappy/encode_arm64.s
index f8d54adf..f0c876a2 100644
--- a/vendor/github.com/golang/snappy/encode_arm64.s
+++ b/vendor/github.com/golang/snappy/encode_arm64.s
@@ -27,7 +27,7 @@
 // The unusual register allocation of local variables, such as R10 for the
 // source pointer, matches the allocation used at the call site in encodeBlock,
 // which makes it easier to manually inline this function.
-TEXT ·emitLiteral(SB), NOSPLIT, $32-56
+TEXT ·emitLiteral(SB), NOSPLIT, $40-56
 	MOVD dst_base+0(FP), R8
 	MOVD lit_base+24(FP), R10
 	MOVD lit_len+32(FP), R3
@@ -261,7 +261,7 @@ extendMatchEnd:
 // "var table [maxTableSize]uint16" takes up 32768 bytes of stack space. An
 // extra 64 bytes, to call other functions, and an extra 64 bytes, to spill
 // local variables (registers) during calls gives 32768 + 64 + 64 = 32896.
-TEXT ·encodeBlock(SB), 0, $32896-56
+TEXT ·encodeBlock(SB), 0, $32904-56
 	MOVD dst_base+0(FP), R8
 	MOVD src_base+24(FP), R7
 	MOVD src_len+32(FP), R14
diff --git a/vendor/github.com/klauspost/compress/.gitignore b/vendor/github.com/klauspost/compress/.gitignore
index b35f8449..d31b3781 100644
--- a/vendor/github.com/klauspost/compress/.gitignore
+++ b/vendor/github.com/klauspost/compress/.gitignore
@@ -23,3 +23,10 @@ _testmain.go
 *.test
 *.prof
 /s2/cmd/_s2sx/sfx-exe
+
+# Linux perf files
+perf.data
+perf.data.old
+
+# gdb history
+.gdb_history
diff --git a/vendor/github.com/klauspost/compress/.goreleaser.yml b/vendor/github.com/klauspost/compress/.goreleaser.yml
index c9014ce1..7a008a4d 100644
--- a/vendor/github.com/klauspost/compress/.goreleaser.yml
+++ b/vendor/github.com/klauspost/compress/.goreleaser.yml
@@ -3,6 +3,7 @@
 before:
   hooks:
     - ./gen.sh
+    - go install mvdan.cc/garble@v0.9.3
 
 builds:
   -
@@ -31,6 +32,7 @@ builds:
       - mips64le
     goarm:
       - 7
+    gobinary: garble
   -
     id: "s2d"
     binary: s2d
@@ -57,6 +59,7 @@ builds:
       - mips64le
     goarm:
       - 7
+    gobinary: garble
   -
     id: "s2sx"
     binary: s2sx
@@ -84,6 +87,7 @@ builds:
       - mips64le
     goarm:
       - 7
+    gobinary: garble
 
 archives:
   -
diff --git a/vendor/github.com/klauspost/compress/README.md b/vendor/github.com/klauspost/compress/README.md
index 3429879e..4002a16a 100644
--- a/vendor/github.com/klauspost/compress/README.md
+++ b/vendor/github.com/klauspost/compress/README.md
@@ -9,7 +9,6 @@ This package provides various compression algorithms.
 * [huff0](https://github.com/klauspost/compress/tree/master/huff0) and [FSE](https://github.com/klauspost/compress/tree/master/fse) implementations for raw entropy encoding.
 * [gzhttp](https://github.com/klauspost/compress/tree/master/gzhttp) Provides client and server wrappers for handling gzipped requests efficiently.
 * [pgzip](https://github.com/klauspost/pgzip) is a separate package that provides a very fast parallel gzip implementation.
-* [fuzz package](https://github.com/klauspost/compress-fuzz) for fuzz testing all compressors/decompressors here.
 
 [![Go Reference](https://pkg.go.dev/badge/klauspost/compress.svg)](https://pkg.go.dev/github.com/klauspost/compress?tab=subdirectories)
 [![Go](https://github.com/klauspost/compress/actions/workflows/go.yml/badge.svg)](https://github.com/klauspost/compress/actions/workflows/go.yml)
@@ -17,6 +16,199 @@ This package provides various compression algorithms.
 
 # changelog
 
+* June 13, 2023 - [v1.16.6](https://github.com/klauspost/compress/releases/tag/v1.16.6)
+	* zstd: correctly ignore WithEncoderPadding(1) by @ianlancetaylor in https://github.com/klauspost/compress/pull/806
+	* zstd: Add amd64 match length assembly https://github.com/klauspost/compress/pull/824
+	* gzhttp: Handle informational headers by @rtribotte in https://github.com/klauspost/compress/pull/815
+	* s2: Improve Better compression slightly https://github.com/klauspost/compress/pull/663
+
+* Apr 16, 2023 - [v1.16.5](https://github.com/klauspost/compress/releases/tag/v1.16.5)
+	* zstd: readByte needs to use io.ReadFull by @jnoxon in https://github.com/klauspost/compress/pull/802
+	* gzip: Fix WriterTo after initial read https://github.com/klauspost/compress/pull/804
+
+* Apr 5, 2023 - [v1.16.4](https://github.com/klauspost/compress/releases/tag/v1.16.4)
+	* zstd: Improve zstd best efficiency by @greatroar and @klauspost in https://github.com/klauspost/compress/pull/784
+	* zstd: Respect WithAllLitEntropyCompression https://github.com/klauspost/compress/pull/792
+	* zstd: Fix amd64 not always detecting corrupt data https://github.com/klauspost/compress/pull/785
+	* zstd: Various minor improvements by @greatroar in https://github.com/klauspost/compress/pull/788 https://github.com/klauspost/compress/pull/794 https://github.com/klauspost/compress/pull/795
+	* s2: Fix huge block overflow https://github.com/klauspost/compress/pull/779
+	* s2: Allow CustomEncoder fallback https://github.com/klauspost/compress/pull/780
+	* gzhttp: Suppport ResponseWriter Unwrap() in gzhttp handler by @jgimenez in https://github.com/klauspost/compress/pull/799
+
+* Mar 13, 2023 - [v1.16.1](https://github.com/klauspost/compress/releases/tag/v1.16.1)
+	* zstd: Speed up + improve best encoder by @greatroar in https://github.com/klauspost/compress/pull/776
+	* gzhttp: Add optional [BREACH mitigation](https://github.com/klauspost/compress/tree/master/gzhttp#breach-mitigation). https://github.com/klauspost/compress/pull/762 https://github.com/klauspost/compress/pull/768 https://github.com/klauspost/compress/pull/769 https://github.com/klauspost/compress/pull/770 https://github.com/klauspost/compress/pull/767
+	* s2: Add Intel LZ4s converter https://github.com/klauspost/compress/pull/766
+	* zstd: Minor bug fixes https://github.com/klauspost/compress/pull/771 https://github.com/klauspost/compress/pull/772 https://github.com/klauspost/compress/pull/773
+	* huff0: Speed up compress1xDo by @greatroar in https://github.com/klauspost/compress/pull/774
+
+* Feb 26, 2023 - [v1.16.0](https://github.com/klauspost/compress/releases/tag/v1.16.0)
+	* s2: Add [Dictionary](https://github.com/klauspost/compress/tree/master/s2#dictionaries) support.  https://github.com/klauspost/compress/pull/685
+	* s2: Add Compression Size Estimate.  https://github.com/klauspost/compress/pull/752
+	* s2: Add support for custom stream encoder. https://github.com/klauspost/compress/pull/755
+	* s2: Add LZ4 block converter. https://github.com/klauspost/compress/pull/748
+	* s2: Support io.ReaderAt in ReadSeeker. https://github.com/klauspost/compress/pull/747
+	* s2c/s2sx: Use concurrent decoding. https://github.com/klauspost/compress/pull/746
+
+* Jan 21st, 2023 (v1.15.15)
+	* deflate: Improve level 7-9 by @klauspost in https://github.com/klauspost/compress/pull/739
+	* zstd: Add delta encoding support by @greatroar in https://github.com/klauspost/compress/pull/728
+	* zstd: Various speed improvements by @greatroar https://github.com/klauspost/compress/pull/741 https://github.com/klauspost/compress/pull/734 https://github.com/klauspost/compress/pull/736 https://github.com/klauspost/compress/pull/744 https://github.com/klauspost/compress/pull/743 https://github.com/klauspost/compress/pull/745
+	* gzhttp: Add SuffixETag() and DropETag() options to prevent ETag collisions on compressed responses by @willbicks in https://github.com/klauspost/compress/pull/740
+
+* Jan 3rd, 2023 (v1.15.14)
+
+	* flate: Improve speed in big stateless blocks https://github.com/klauspost/compress/pull/718
+	* zstd: Minor speed tweaks by @greatroar in https://github.com/klauspost/compress/pull/716 https://github.com/klauspost/compress/pull/720
+	* export NoGzipResponseWriter for custom ResponseWriter wrappers by @harshavardhana in https://github.com/klauspost/compress/pull/722
+	* s2: Add example for indexing and existing stream https://github.com/klauspost/compress/pull/723
+
+* Dec 11, 2022 (v1.15.13)
+	* zstd: Add [MaxEncodedSize](https://pkg.go.dev/github.com/klauspost/compress@v1.15.13/zstd#Encoder.MaxEncodedSize) to encoder  https://github.com/klauspost/compress/pull/691
+	* zstd: Various tweaks and improvements https://github.com/klauspost/compress/pull/693 https://github.com/klauspost/compress/pull/695 https://github.com/klauspost/compress/pull/696 https://github.com/klauspost/compress/pull/701 https://github.com/klauspost/compress/pull/702 https://github.com/klauspost/compress/pull/703 https://github.com/klauspost/compress/pull/704 https://github.com/klauspost/compress/pull/705 https://github.com/klauspost/compress/pull/706 https://github.com/klauspost/compress/pull/707 https://github.com/klauspost/compress/pull/708
+
+* Oct 26, 2022 (v1.15.12)
+
+	* zstd: Tweak decoder allocs. https://github.com/klauspost/compress/pull/680
+	* gzhttp: Always delete `HeaderNoCompression` https://github.com/klauspost/compress/pull/683
+
+* Sept 26, 2022 (v1.15.11)
+
+	* flate: Improve level 1-3 compression  https://github.com/klauspost/compress/pull/678
+	* zstd: Improve "best" compression by @nightwolfz in https://github.com/klauspost/compress/pull/677
+	* zstd: Fix+reduce decompression allocations https://github.com/klauspost/compress/pull/668
+	* zstd: Fix non-effective noescape tag https://github.com/klauspost/compress/pull/667
+
+* Sept 16, 2022 (v1.15.10)
+
+	* zstd: Add [WithDecodeAllCapLimit](https://pkg.go.dev/github.com/klauspost/compress@v1.15.10/zstd#WithDecodeAllCapLimit) https://github.com/klauspost/compress/pull/649
+	* Add Go 1.19 - deprecate Go 1.16  https://github.com/klauspost/compress/pull/651
+	* flate: Improve level 5+6 compression https://github.com/klauspost/compress/pull/656
+	* zstd: Improve "better" compresssion  https://github.com/klauspost/compress/pull/657
+	* s2: Improve "best" compression https://github.com/klauspost/compress/pull/658
+	* s2: Improve "better" compression. https://github.com/klauspost/compress/pull/635
+	* s2: Slightly faster non-assembly decompression https://github.com/klauspost/compress/pull/646
+	* Use arrays for constant size copies https://github.com/klauspost/compress/pull/659
+
+* July 21, 2022 (v1.15.9)
+
+	* zstd: Fix decoder crash on amd64 (no BMI) on invalid input https://github.com/klauspost/compress/pull/645
+	* zstd: Disable decoder extended memory copies (amd64) due to possible crashes https://github.com/klauspost/compress/pull/644
+	* zstd: Allow single segments up to "max decoded size" by @klauspost in https://github.com/klauspost/compress/pull/643
+
+* July 13, 2022 (v1.15.8)
+
+	* gzip: fix stack exhaustion bug in Reader.Read https://github.com/klauspost/compress/pull/641
+	* s2: Add Index header trim/restore https://github.com/klauspost/compress/pull/638
+	* zstd: Optimize seqdeq amd64 asm by @greatroar in https://github.com/klauspost/compress/pull/636
+	* zstd: Improve decoder memcopy https://github.com/klauspost/compress/pull/637
+	* huff0: Pass a single bitReader pointer to asm by @greatroar in https://github.com/klauspost/compress/pull/634
+	* zstd: Branchless getBits for amd64 w/o BMI2 by @greatroar in https://github.com/klauspost/compress/pull/640
+	* gzhttp: Remove header before writing https://github.com/klauspost/compress/pull/639
+
+* June 29, 2022 (v1.15.7)
+
+	* s2: Fix absolute forward seeks  https://github.com/klauspost/compress/pull/633
+	* zip: Merge upstream  https://github.com/klauspost/compress/pull/631
+	* zip: Re-add zip64 fix https://github.com/klauspost/compress/pull/624
+	* zstd: translate fseDecoder.buildDtable into asm by @WojciechMula in https://github.com/klauspost/compress/pull/598
+	* flate: Faster histograms  https://github.com/klauspost/compress/pull/620
+	* deflate: Use compound hcode  https://github.com/klauspost/compress/pull/622
+
+* June 3, 2022 (v1.15.6)
+	* s2: Improve coding for long, close matches https://github.com/klauspost/compress/pull/613
+	* s2c: Add Snappy/S2 stream recompression https://github.com/klauspost/compress/pull/611
+	* zstd: Always use configured block size https://github.com/klauspost/compress/pull/605
+	* zstd: Fix incorrect hash table placement for dict encoding in default https://github.com/klauspost/compress/pull/606
+	* zstd: Apply default config to ZipDecompressor without options https://github.com/klauspost/compress/pull/608
+	* gzhttp: Exclude more common archive formats https://github.com/klauspost/compress/pull/612
+	* s2: Add ReaderIgnoreCRC https://github.com/klauspost/compress/pull/609
+	* s2: Remove sanity load on index creation https://github.com/klauspost/compress/pull/607
+	* snappy: Use dedicated function for scoring https://github.com/klauspost/compress/pull/614
+	* s2c+s2d: Use official snappy framed extension https://github.com/klauspost/compress/pull/610
+
+* May 25, 2022 (v1.15.5)
+	* s2: Add concurrent stream decompression https://github.com/klauspost/compress/pull/602
+	* s2: Fix final emit oob read crash on amd64 https://github.com/klauspost/compress/pull/601
+	* huff0: asm implementation of Decompress1X by @WojciechMula https://github.com/klauspost/compress/pull/596
+	* zstd: Use 1 less goroutine for stream decoding https://github.com/klauspost/compress/pull/588
+	* zstd: Copy literal in 16 byte blocks when possible https://github.com/klauspost/compress/pull/592
+	* zstd: Speed up when WithDecoderLowmem(false) https://github.com/klauspost/compress/pull/599
+	* zstd: faster next state update in BMI2 version of decode by @WojciechMula in https://github.com/klauspost/compress/pull/593
+	* huff0: Do not check max size when reading table. https://github.com/klauspost/compress/pull/586
+	* flate: Inplace hashing for level 7-9 by @klauspost in https://github.com/klauspost/compress/pull/590
+
+
+* May 11, 2022 (v1.15.4)
+	* huff0: decompress directly into output by @WojciechMula in [#577](https://github.com/klauspost/compress/pull/577)
+	* inflate: Keep dict on stack [#581](https://github.com/klauspost/compress/pull/581)
+	* zstd: Faster decoding memcopy in asm [#583](https://github.com/klauspost/compress/pull/583)
+	* zstd: Fix ignored crc [#580](https://github.com/klauspost/compress/pull/580)
+
+* May 5, 2022 (v1.15.3)
+	* zstd: Allow to ignore checksum checking by @WojciechMula [#572](https://github.com/klauspost/compress/pull/572)
+	* s2: Fix incorrect seek for io.SeekEnd in [#575](https://github.com/klauspost/compress/pull/575)
+
+* Apr 26, 2022 (v1.15.2)
+	* zstd: Add x86-64 assembly for decompression on streams and blocks. Contributed by [@WojciechMula](https://github.com/WojciechMula). Typically 2x faster.  [#528](https://github.com/klauspost/compress/pull/528) [#531](https://github.com/klauspost/compress/pull/531) [#545](https://github.com/klauspost/compress/pull/545) [#537](https://github.com/klauspost/compress/pull/537)
+	* zstd: Add options to ZipDecompressor and fixes [#539](https://github.com/klauspost/compress/pull/539)
+	* s2: Use sorted search for index [#555](https://github.com/klauspost/compress/pull/555)
+	* Minimum version is Go 1.16, added CI test on 1.18.
+
+* Mar 11, 2022 (v1.15.1)
+	* huff0: Add x86 assembly of Decode4X by @WojciechMula in [#512](https://github.com/klauspost/compress/pull/512)
+	* zstd: Reuse zip decoders in [#514](https://github.com/klauspost/compress/pull/514)
+	* zstd: Detect extra block data and report as corrupted in [#520](https://github.com/klauspost/compress/pull/520)
+	* zstd: Handle zero sized frame content size stricter in [#521](https://github.com/klauspost/compress/pull/521)
+	* zstd: Add stricter block size checks in [#523](https://github.com/klauspost/compress/pull/523)
+
+* Mar 3, 2022 (v1.15.0)
+	* zstd: Refactor decoder by @klauspost in [#498](https://github.com/klauspost/compress/pull/498)
+	* zstd: Add stream encoding without goroutines by @klauspost in [#505](https://github.com/klauspost/compress/pull/505)
+	* huff0: Prevent single blocks exceeding 16 bits by @klauspost in[#507](https://github.com/klauspost/compress/pull/507)
+	* flate: Inline literal emission by @klauspost in [#509](https://github.com/klauspost/compress/pull/509)
+	* gzhttp: Add zstd to transport by @klauspost in [#400](https://github.com/klauspost/compress/pull/400)
+	* gzhttp: Make content-type optional by @klauspost in [#510](https://github.com/klauspost/compress/pull/510)
+
+Both compression and decompression now supports "synchronous" stream operations. This means that whenever "concurrency" is set to 1, they will operate without spawning goroutines.
+
+Stream decompression is now faster on asynchronous, since the goroutine allocation much more effectively splits the workload. On typical streams this will typically use 2 cores fully for decompression. When a stream has finished decoding no goroutines will be left over, so decoders can now safely be pooled and still be garbage collected.
+
+While the release has been extensively tested, it is recommended to testing when upgrading.
+
+<details>
+	<summary>See changes to v1.14.x</summary>
+	
+* Feb 22, 2022 (v1.14.4)
+	* flate: Fix rare huffman only (-2) corruption. [#503](https://github.com/klauspost/compress/pull/503)
+	* zip: Update deprecated CreateHeaderRaw to correctly call CreateRaw by @saracen in [#502](https://github.com/klauspost/compress/pull/502)
+	* zip: don't read data descriptor early by @saracen in [#501](https://github.com/klauspost/compress/pull/501)  #501
+	* huff0: Use static decompression buffer up to 30% faster by @klauspost in [#499](https://github.com/klauspost/compress/pull/499) [#500](https://github.com/klauspost/compress/pull/500)
+
+* Feb 17, 2022 (v1.14.3)
+	* flate: Improve fastest levels compression speed ~10% more throughput. [#482](https://github.com/klauspost/compress/pull/482) [#489](https://github.com/klauspost/compress/pull/489) [#490](https://github.com/klauspost/compress/pull/490) [#491](https://github.com/klauspost/compress/pull/491) [#494](https://github.com/klauspost/compress/pull/494)  [#478](https://github.com/klauspost/compress/pull/478)
+	* flate: Faster decompression speed, ~5-10%. [#483](https://github.com/klauspost/compress/pull/483)
+	* s2: Faster compression with Go v1.18 and amd64 microarch level 3+. [#484](https://github.com/klauspost/compress/pull/484) [#486](https://github.com/klauspost/compress/pull/486)
+
+* Jan 25, 2022 (v1.14.2)
+	* zstd: improve header decoder by @dsnet  [#476](https://github.com/klauspost/compress/pull/476)
+	* zstd: Add bigger default blocks  [#469](https://github.com/klauspost/compress/pull/469)
+	* zstd: Remove unused decompression buffer [#470](https://github.com/klauspost/compress/pull/470)
+	* zstd: Fix logically dead code by @ningmingxiao [#472](https://github.com/klauspost/compress/pull/472)
+	* flate: Improve level 7-9 [#471](https://github.com/klauspost/compress/pull/471) [#473](https://github.com/klauspost/compress/pull/473)
+	* zstd: Add noasm tag for xxhash [#475](https://github.com/klauspost/compress/pull/475)
+
+* Jan 11, 2022 (v1.14.1)
+	* s2: Add stream index in [#462](https://github.com/klauspost/compress/pull/462)
+	* flate: Speed and efficiency improvements in [#439](https://github.com/klauspost/compress/pull/439) [#461](https://github.com/klauspost/compress/pull/461) [#455](https://github.com/klauspost/compress/pull/455) [#452](https://github.com/klauspost/compress/pull/452) [#458](https://github.com/klauspost/compress/pull/458)
+	* zstd: Performance improvement in [#420]( https://github.com/klauspost/compress/pull/420) [#456](https://github.com/klauspost/compress/pull/456) [#437](https://github.com/klauspost/compress/pull/437) [#467](https://github.com/klauspost/compress/pull/467) [#468](https://github.com/klauspost/compress/pull/468)
+	* zstd: add arm64 xxhash assembly in [#464](https://github.com/klauspost/compress/pull/464)
+	* Add garbled for binaries for s2 in [#445](https://github.com/klauspost/compress/pull/445)
+</details>
+
+<details>
+	<summary>See changes to v1.13.x</summary>
+	
 * Aug 30, 2021 (v1.13.5)
 	* gz/zlib/flate: Alias stdlib errors [#425](https://github.com/klauspost/compress/pull/425)
 	* s2: Add block support to commandline tools [#413](https://github.com/klauspost/compress/pull/413)
@@ -45,7 +237,12 @@ This package provides various compression algorithms.
 	* Added [gzhttp](https://github.com/klauspost/compress/tree/master/gzhttp#gzip-handler) which allows wrapping HTTP servers and clients with GZIP compressors.
 	* zstd: Detect short invalid signatures [#382](https://github.com/klauspost/compress/pull/382)
 	* zstd: Spawn decoder goroutine only if needed. [#380](https://github.com/klauspost/compress/pull/380)
+</details>
 
+
+<details>
+	<summary>See changes to v1.12.x</summary>
+	
 * May 25, 2021 (v1.12.3)
 	* deflate: Better/faster Huffman encoding [#374](https://github.com/klauspost/compress/pull/374)
 	* deflate: Allocate less for history. [#375](https://github.com/klauspost/compress/pull/375)
@@ -67,9 +264,10 @@ This package provides various compression algorithms.
 	* s2c/s2d/s2sx: Always truncate when writing files [#352](https://github.com/klauspost/compress/pull/352)
 	* zstd: Reduce memory usage further when using [WithLowerEncoderMem](https://pkg.go.dev/github.com/klauspost/compress/zstd#WithLowerEncoderMem) [#346](https://github.com/klauspost/compress/pull/346)
 	* s2: Fix potential problem with amd64 assembly and profilers [#349](https://github.com/klauspost/compress/pull/349)
+</details>
 
 <details>
-	<summary>See changes prior to v1.12.1</summary>
+	<summary>See changes to v1.11.x</summary>
 	
 * Mar 26, 2021 (v1.11.13)
 	* zstd: Big speedup on small dictionary encodes [#344](https://github.com/klauspost/compress/pull/344) [#345](https://github.com/klauspost/compress/pull/345)
@@ -128,7 +326,7 @@ This package provides various compression algorithms.
 </details>
 
 <details>
-	<summary>See changes prior to v1.11.0</summary>
+	<summary>See changes to v1.10.x</summary>
  
 * July 8, 2020 (v1.10.11) 
 	* zstd: Fix extra block when compressing with ReadFrom. [#278](https://github.com/klauspost/compress/pull/278)
@@ -290,11 +488,6 @@ This package provides various compression algorithms.
 
 # deflate usage
 
-* [High Throughput Benchmark](http://blog.klauspost.com/go-gzipdeflate-benchmarks/).
-* [Small Payload/Webserver Benchmarks](http://blog.klauspost.com/gzip-performance-for-go-webservers/).
-* [Linear Time Compression](http://blog.klauspost.com/constant-time-gzipzip-compression/).
-* [Re-balancing Deflate Compression Levels](https://blog.klauspost.com/rebalancing-deflate-compression-levels/)
-
 The packages are drop-in replacements for standard libraries. Simply replace the import path to use them:
 
 | old import         | new import                              | Documentation
@@ -316,6 +509,8 @@ Memory usage is typically 1MB for a Writer. stdlib is in the same range.
 If you expect to have a lot of concurrently allocated Writers consider using 
 the stateless compress described below.
 
+For compression performance, see: [this spreadsheet](https://docs.google.com/spreadsheets/d/1nuNE2nPfuINCZJRMt6wFWhKpToF95I47XjSsc-1rbPQ/edit?usp=sharing).
+
 # Stateless compression
 
 This package offers stateless compression as a special option for gzip/deflate. 
@@ -432,6 +627,15 @@ For more information see my blog post on [Fast Linear Time Compression](http://b
 
 This is implemented on Go 1.7 as "Huffman Only" mode, though not exposed for gzip.
 
+# Other packages
+
+Here are other packages of good quality and pure Go (no cgo wrappers or autoconverted code):
+
+* [github.com/pierrec/lz4](https://github.com/pierrec/lz4) - strong multithreaded LZ4 compression.
+* [github.com/cosnicolaou/pbzip2](https://github.com/cosnicolaou/pbzip2) - multithreaded bzip2 decompression.
+* [github.com/dsnet/compress](https://github.com/dsnet/compress) - brotli decompression, bzip2 writer.
+* [github.com/ronanh/intcomp](https://github.com/ronanh/intcomp) - Integer compression.
+* [github.com/spenczar/fpc](https://github.com/spenczar/fpc) - Float compression.
 
 # license
 
diff --git a/vendor/github.com/klauspost/compress/SECURITY.md b/vendor/github.com/klauspost/compress/SECURITY.md
new file mode 100644
index 00000000..ca6685e2
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/SECURITY.md
@@ -0,0 +1,25 @@
+# Security Policy
+
+## Supported Versions
+
+Security updates are applied only to the latest release.
+
+## Vulnerability Definition
+
+A security vulnerability is a bug that with certain input triggers a crash or an infinite loop. Most calls will have varying execution time and only in rare cases will slow operation be considered a security vulnerability.
+
+Corrupted output generally is not considered a security vulnerability, unless independent operations are able to affect each other. Note that not all functionality is re-entrant and safe to use concurrently.
+
+Out-of-memory crashes only applies if the en/decoder uses an abnormal amount of memory, with appropriate options applied, to limit maximum window size, concurrency, etc. However, if you are in doubt you are welcome to file a security issue.
+
+It is assumed that all callers are trusted, meaning internal data exposed through reflection or inspection of returned data structures is not considered a vulnerability.
+
+Vulnerabilities resulting from compiler/assembler errors should be reported upstream. Depending on the severity this package may or may not implement a workaround.
+
+## Reporting a Vulnerability
+
+If you have discovered a security vulnerability in this project, please report it privately. **Do not disclose it as a public issue.** This gives us time to work with you to fix the issue before public exposure, reducing the chance that the exploit will be used before a patch is released.
+
+Please disclose it at [security advisory](https://github.com/klauspost/compress/security/advisories/new). If possible please provide a minimal reproducer. If the issue only applies to a single platform, it would be helpful to provide access to that.
+
+This project is maintained by a team of volunteers on a reasonable-effort basis. As such, vulnerabilities will be disclosed in a best effort base.
diff --git a/vendor/github.com/klauspost/compress/fse/compress.go b/vendor/github.com/klauspost/compress/fse/compress.go
index 6f341914..dac97e58 100644
--- a/vendor/github.com/klauspost/compress/fse/compress.go
+++ b/vendor/github.com/klauspost/compress/fse/compress.go
@@ -146,54 +146,51 @@ func (s *Scratch) compress(src []byte) error {
 		c1.encodeZero(tt[src[ip-2]])
 		ip -= 2
 	}
+	src = src[:ip]
 
 	// Main compression loop.
 	switch {
 	case !s.zeroBits && s.actualTableLog <= 8:
 		// We can encode 4 symbols without requiring a flush.
 		// We do not need to check if any output is 0 bits.
-		for ip >= 4 {
+		for ; len(src) >= 4; src = src[:len(src)-4] {
 			s.bw.flush32()
-			v3, v2, v1, v0 := src[ip-4], src[ip-3], src[ip-2], src[ip-1]
+			v3, v2, v1, v0 := src[len(src)-4], src[len(src)-3], src[len(src)-2], src[len(src)-1]
 			c2.encode(tt[v0])
 			c1.encode(tt[v1])
 			c2.encode(tt[v2])
 			c1.encode(tt[v3])
-			ip -= 4
 		}
 	case !s.zeroBits:
 		// We do not need to check if any output is 0 bits.
-		for ip >= 4 {
+		for ; len(src) >= 4; src = src[:len(src)-4] {
 			s.bw.flush32()
-			v3, v2, v1, v0 := src[ip-4], src[ip-3], src[ip-2], src[ip-1]
+			v3, v2, v1, v0 := src[len(src)-4], src[len(src)-3], src[len(src)-2], src[len(src)-1]
 			c2.encode(tt[v0])
 			c1.encode(tt[v1])
 			s.bw.flush32()
 			c2.encode(tt[v2])
 			c1.encode(tt[v3])
-			ip -= 4
 		}
 	case s.actualTableLog <= 8:
 		// We can encode 4 symbols without requiring a flush
-		for ip >= 4 {
+		for ; len(src) >= 4; src = src[:len(src)-4] {
 			s.bw.flush32()
-			v3, v2, v1, v0 := src[ip-4], src[ip-3], src[ip-2], src[ip-1]
+			v3, v2, v1, v0 := src[len(src)-4], src[len(src)-3], src[len(src)-2], src[len(src)-1]
 			c2.encodeZero(tt[v0])
 			c1.encodeZero(tt[v1])
 			c2.encodeZero(tt[v2])
 			c1.encodeZero(tt[v3])
-			ip -= 4
 		}
 	default:
-		for ip >= 4 {
+		for ; len(src) >= 4; src = src[:len(src)-4] {
 			s.bw.flush32()
-			v3, v2, v1, v0 := src[ip-4], src[ip-3], src[ip-2], src[ip-1]
+			v3, v2, v1, v0 := src[len(src)-4], src[len(src)-3], src[len(src)-2], src[len(src)-1]
 			c2.encodeZero(tt[v0])
 			c1.encodeZero(tt[v1])
 			s.bw.flush32()
 			c2.encodeZero(tt[v2])
 			c1.encodeZero(tt[v3])
-			ip -= 4
 		}
 	}
 
@@ -459,15 +456,17 @@ func (s *Scratch) countSimple(in []byte) (max int) {
 	for _, v := range in {
 		s.count[v]++
 	}
-	m := uint32(0)
+	m, symlen := uint32(0), s.symbolLen
 	for i, v := range s.count[:] {
+		if v == 0 {
+			continue
+		}
 		if v > m {
 			m = v
 		}
-		if v > 0 {
-			s.symbolLen = uint16(i) + 1
-		}
+		symlen = uint16(i) + 1
 	}
+	s.symbolLen = symlen
 	return int(m)
 }
 
diff --git a/vendor/github.com/klauspost/compress/fse/decompress.go b/vendor/github.com/klauspost/compress/fse/decompress.go
index 926f5f15..cc05d0f7 100644
--- a/vendor/github.com/klauspost/compress/fse/decompress.go
+++ b/vendor/github.com/klauspost/compress/fse/decompress.go
@@ -260,7 +260,9 @@ func (s *Scratch) buildDtable() error {
 // If the buffer is over-read an error is returned.
 func (s *Scratch) decompress() error {
 	br := &s.bits
-	br.init(s.br.unread())
+	if err := br.init(s.br.unread()); err != nil {
+		return err
+	}
 
 	var s1, s2 decoder
 	// Initialize and decode first state and symbol.
diff --git a/vendor/github.com/klauspost/compress/huff0/bitreader.go b/vendor/github.com/klauspost/compress/huff0/bitreader.go
index a4979e88..e36d9742 100644
--- a/vendor/github.com/klauspost/compress/huff0/bitreader.go
+++ b/vendor/github.com/klauspost/compress/huff0/bitreader.go
@@ -8,115 +8,10 @@ package huff0
 import (
 	"encoding/binary"
 	"errors"
+	"fmt"
 	"io"
 )
 
-// bitReader reads a bitstream in reverse.
-// The last set bit indicates the start of the stream and is used
-// for aligning the input.
-type bitReader struct {
-	in       []byte
-	off      uint // next byte to read is at in[off - 1]
-	value    uint64
-	bitsRead uint8
-}
-
-// init initializes and resets the bit reader.
-func (b *bitReader) init(in []byte) error {
-	if len(in) < 1 {
-		return errors.New("corrupt stream: too short")
-	}
-	b.in = in
-	b.off = uint(len(in))
-	// The highest bit of the last byte indicates where to start
-	v := in[len(in)-1]
-	if v == 0 {
-		return errors.New("corrupt stream, did not find end of stream")
-	}
-	b.bitsRead = 64
-	b.value = 0
-	if len(in) >= 8 {
-		b.fillFastStart()
-	} else {
-		b.fill()
-		b.fill()
-	}
-	b.bitsRead += 8 - uint8(highBit32(uint32(v)))
-	return nil
-}
-
-// peekBitsFast requires that at least one bit is requested every time.
-// There are no checks if the buffer is filled.
-func (b *bitReader) peekBitsFast(n uint8) uint16 {
-	const regMask = 64 - 1
-	v := uint16((b.value << (b.bitsRead & regMask)) >> ((regMask + 1 - n) & regMask))
-	return v
-}
-
-// fillFast() will make sure at least 32 bits are available.
-// There must be at least 4 bytes available.
-func (b *bitReader) fillFast() {
-	if b.bitsRead < 32 {
-		return
-	}
-
-	// 2 bounds checks.
-	v := b.in[b.off-4 : b.off]
-	v = v[:4]
-	low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
-	b.value = (b.value << 32) | uint64(low)
-	b.bitsRead -= 32
-	b.off -= 4
-}
-
-func (b *bitReader) advance(n uint8) {
-	b.bitsRead += n
-}
-
-// fillFastStart() assumes the bitreader is empty and there is at least 8 bytes to read.
-func (b *bitReader) fillFastStart() {
-	// Do single re-slice to avoid bounds checks.
-	b.value = binary.LittleEndian.Uint64(b.in[b.off-8:])
-	b.bitsRead = 0
-	b.off -= 8
-}
-
-// fill() will make sure at least 32 bits are available.
-func (b *bitReader) fill() {
-	if b.bitsRead < 32 {
-		return
-	}
-	if b.off > 4 {
-		v := b.in[b.off-4:]
-		v = v[:4]
-		low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
-		b.value = (b.value << 32) | uint64(low)
-		b.bitsRead -= 32
-		b.off -= 4
-		return
-	}
-	for b.off > 0 {
-		b.value = (b.value << 8) | uint64(b.in[b.off-1])
-		b.bitsRead -= 8
-		b.off--
-	}
-}
-
-// finished returns true if all bits have been read from the bit stream.
-func (b *bitReader) finished() bool {
-	return b.off == 0 && b.bitsRead >= 64
-}
-
-// close the bitstream and returns an error if out-of-buffer reads occurred.
-func (b *bitReader) close() error {
-	// Release reference.
-	b.in = nil
-	if b.bitsRead > 64 {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-
 // bitReader reads a bitstream in reverse.
 // The last set bit indicates the start of the stream and is used
 // for aligning the input.
@@ -172,7 +67,6 @@ func (b *bitReaderBytes) fillFast() {
 
 	// 2 bounds checks.
 	v := b.in[b.off-4 : b.off]
-	v = v[:4]
 	low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
 	b.value |= uint64(low) << (b.bitsRead - 32)
 	b.bitsRead -= 32
@@ -193,8 +87,7 @@ func (b *bitReaderBytes) fill() {
 		return
 	}
 	if b.off > 4 {
-		v := b.in[b.off-4:]
-		v = v[:4]
+		v := b.in[b.off-4 : b.off]
 		low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
 		b.value |= uint64(low) << (b.bitsRead - 32)
 		b.bitsRead -= 32
@@ -213,10 +106,17 @@ func (b *bitReaderBytes) finished() bool {
 	return b.off == 0 && b.bitsRead >= 64
 }
 
+func (b *bitReaderBytes) remaining() uint {
+	return b.off*8 + uint(64-b.bitsRead)
+}
+
 // close the bitstream and returns an error if out-of-buffer reads occurred.
 func (b *bitReaderBytes) close() error {
 	// Release reference.
 	b.in = nil
+	if b.remaining() > 0 {
+		return fmt.Errorf("corrupt input: %d bits remain on stream", b.remaining())
+	}
 	if b.bitsRead > 64 {
 		return io.ErrUnexpectedEOF
 	}
@@ -277,7 +177,6 @@ func (b *bitReaderShifted) fillFast() {
 
 	// 2 bounds checks.
 	v := b.in[b.off-4 : b.off]
-	v = v[:4]
 	low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
 	b.value |= uint64(low) << ((b.bitsRead - 32) & 63)
 	b.bitsRead -= 32
@@ -298,8 +197,7 @@ func (b *bitReaderShifted) fill() {
 		return
 	}
 	if b.off > 4 {
-		v := b.in[b.off-4:]
-		v = v[:4]
+		v := b.in[b.off-4 : b.off]
 		low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
 		b.value |= uint64(low) << ((b.bitsRead - 32) & 63)
 		b.bitsRead -= 32
@@ -313,15 +211,17 @@ func (b *bitReaderShifted) fill() {
 	}
 }
 
-// finished returns true if all bits have been read from the bit stream.
-func (b *bitReaderShifted) finished() bool {
-	return b.off == 0 && b.bitsRead >= 64
+func (b *bitReaderShifted) remaining() uint {
+	return b.off*8 + uint(64-b.bitsRead)
 }
 
 // close the bitstream and returns an error if out-of-buffer reads occurred.
 func (b *bitReaderShifted) close() error {
 	// Release reference.
 	b.in = nil
+	if b.remaining() > 0 {
+		return fmt.Errorf("corrupt input: %d bits remain on stream", b.remaining())
+	}
 	if b.bitsRead > 64 {
 		return io.ErrUnexpectedEOF
 	}
diff --git a/vendor/github.com/klauspost/compress/huff0/bitwriter.go b/vendor/github.com/klauspost/compress/huff0/bitwriter.go
index 6bce4e87..b4d7164e 100644
--- a/vendor/github.com/klauspost/compress/huff0/bitwriter.go
+++ b/vendor/github.com/klauspost/compress/huff0/bitwriter.go
@@ -5,8 +5,6 @@
 
 package huff0
 
-import "fmt"
-
 // bitWriter will write bits.
 // First bit will be LSB of the first byte of output.
 type bitWriter struct {
@@ -15,22 +13,6 @@ type bitWriter struct {
 	out          []byte
 }
 
-// bitMask16 is bitmasks. Has extra to avoid bounds check.
-var bitMask16 = [32]uint16{
-	0, 1, 3, 7, 0xF, 0x1F,
-	0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF,
-	0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF, 0xFFFF,
-	0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
-	0xFFFF, 0xFFFF} /* up to 16 bits */
-
-// addBits16NC will add up to 16 bits.
-// It will not check if there is space for them,
-// so the caller must ensure that it has flushed recently.
-func (b *bitWriter) addBits16NC(value uint16, bits uint8) {
-	b.bitContainer |= uint64(value&bitMask16[bits&31]) << (b.nBits & 63)
-	b.nBits += bits
-}
-
 // addBits16Clean will add up to 16 bits. value may not contain more set bits than indicated.
 // It will not check if there is space for them, so the caller must ensure that it has flushed recently.
 func (b *bitWriter) addBits16Clean(value uint16, bits uint8) {
@@ -70,102 +52,20 @@ func (b *bitWriter) encTwoSymbols(ct cTable, av, bv byte) {
 	b.nBits += encA.nBits + encB.nBits
 }
 
-// addBits16ZeroNC will add up to 16 bits.
+// encFourSymbols adds up to 32 bits from four symbols.
 // It will not check if there is space for them,
-// so the caller must ensure that it has flushed recently.
-// This is fastest if bits can be zero.
-func (b *bitWriter) addBits16ZeroNC(value uint16, bits uint8) {
-	if bits == 0 {
-		return
-	}
-	value <<= (16 - bits) & 15
-	value >>= (16 - bits) & 15
-	b.bitContainer |= uint64(value) << (b.nBits & 63)
-	b.nBits += bits
-}
-
-// flush will flush all pending full bytes.
-// There will be at least 56 bits available for writing when this has been called.
-// Using flush32 is faster, but leaves less space for writing.
-func (b *bitWriter) flush() {
-	v := b.nBits >> 3
-	switch v {
-	case 0:
-		return
-	case 1:
-		b.out = append(b.out,
-			byte(b.bitContainer),
-		)
-		b.bitContainer >>= 1 << 3
-	case 2:
-		b.out = append(b.out,
-			byte(b.bitContainer),
-			byte(b.bitContainer>>8),
-		)
-		b.bitContainer >>= 2 << 3
-	case 3:
-		b.out = append(b.out,
-			byte(b.bitContainer),
-			byte(b.bitContainer>>8),
-			byte(b.bitContainer>>16),
-		)
-		b.bitContainer >>= 3 << 3
-	case 4:
-		b.out = append(b.out,
-			byte(b.bitContainer),
-			byte(b.bitContainer>>8),
-			byte(b.bitContainer>>16),
-			byte(b.bitContainer>>24),
-		)
-		b.bitContainer >>= 4 << 3
-	case 5:
-		b.out = append(b.out,
-			byte(b.bitContainer),
-			byte(b.bitContainer>>8),
-			byte(b.bitContainer>>16),
-			byte(b.bitContainer>>24),
-			byte(b.bitContainer>>32),
-		)
-		b.bitContainer >>= 5 << 3
-	case 6:
-		b.out = append(b.out,
-			byte(b.bitContainer),
-			byte(b.bitContainer>>8),
-			byte(b.bitContainer>>16),
-			byte(b.bitContainer>>24),
-			byte(b.bitContainer>>32),
-			byte(b.bitContainer>>40),
-		)
-		b.bitContainer >>= 6 << 3
-	case 7:
-		b.out = append(b.out,
-			byte(b.bitContainer),
-			byte(b.bitContainer>>8),
-			byte(b.bitContainer>>16),
-			byte(b.bitContainer>>24),
-			byte(b.bitContainer>>32),
-			byte(b.bitContainer>>40),
-			byte(b.bitContainer>>48),
-		)
-		b.bitContainer >>= 7 << 3
-	case 8:
-		b.out = append(b.out,
-			byte(b.bitContainer),
-			byte(b.bitContainer>>8),
-			byte(b.bitContainer>>16),
-			byte(b.bitContainer>>24),
-			byte(b.bitContainer>>32),
-			byte(b.bitContainer>>40),
-			byte(b.bitContainer>>48),
-			byte(b.bitContainer>>56),
-		)
-		b.bitContainer = 0
-		b.nBits = 0
-		return
-	default:
-		panic(fmt.Errorf("bits (%d) > 64", b.nBits))
-	}
-	b.nBits &= 7
+// so the caller must ensure that b has been flushed recently.
+func (b *bitWriter) encFourSymbols(encA, encB, encC, encD cTableEntry) {
+	bitsA := encA.nBits
+	bitsB := bitsA + encB.nBits
+	bitsC := bitsB + encC.nBits
+	bitsD := bitsC + encD.nBits
+	combined := uint64(encA.val) |
+		(uint64(encB.val) << (bitsA & 63)) |
+		(uint64(encC.val) << (bitsB & 63)) |
+		(uint64(encD.val) << (bitsC & 63))
+	b.bitContainer |= combined << (b.nBits & 63)
+	b.nBits += bitsD
 }
 
 // flush32 will flush out, so there are at least 32 bits available for writing.
@@ -201,10 +101,3 @@ func (b *bitWriter) close() error {
 	b.flushAlign()
 	return nil
 }
-
-// reset and continue writing by appending to out.
-func (b *bitWriter) reset(out []byte) {
-	b.bitContainer = 0
-	b.nBits = 0
-	b.out = out
-}
diff --git a/vendor/github.com/klauspost/compress/huff0/bytereader.go b/vendor/github.com/klauspost/compress/huff0/bytereader.go
index 50bcdf6e..4dcab8d2 100644
--- a/vendor/github.com/klauspost/compress/huff0/bytereader.go
+++ b/vendor/github.com/klauspost/compress/huff0/bytereader.go
@@ -20,11 +20,6 @@ func (b *byteReader) init(in []byte) {
 	b.off = 0
 }
 
-// advance the stream b n bytes.
-func (b *byteReader) advance(n uint) {
-	b.off += int(n)
-}
-
 // Int32 returns a little endian int32 starting at current offset.
 func (b byteReader) Int32() int32 {
 	v3 := int32(b.b[b.off+3])
@@ -43,11 +38,6 @@ func (b byteReader) Uint32() uint32 {
 	return (v3 << 24) | (v2 << 16) | (v1 << 8) | v0
 }
 
-// unread returns the unread portion of the input.
-func (b byteReader) unread() []byte {
-	return b.b[b.off:]
-}
-
 // remain will return the number of bytes remaining.
 func (b byteReader) remain() int {
 	return len(b.b) - b.off
diff --git a/vendor/github.com/klauspost/compress/huff0/compress.go b/vendor/github.com/klauspost/compress/huff0/compress.go
index 8323dc05..4ee4fa18 100644
--- a/vendor/github.com/klauspost/compress/huff0/compress.go
+++ b/vendor/github.com/klauspost/compress/huff0/compress.go
@@ -2,6 +2,7 @@ package huff0
 
 import (
 	"fmt"
+	"math"
 	"runtime"
 	"sync"
 )
@@ -247,8 +248,7 @@ func (s *Scratch) compress1xDo(dst, src []byte) ([]byte, error) {
 			tmp := src[n : n+4]
 			// tmp should be len 4
 			bw.flush32()
-			bw.encTwoSymbols(cTable, tmp[3], tmp[2])
-			bw.encTwoSymbols(cTable, tmp[1], tmp[0])
+			bw.encFourSymbols(cTable[tmp[3]], cTable[tmp[2]], cTable[tmp[1]], cTable[tmp[0]])
 		}
 	} else {
 		for ; n >= 0; n -= 4 {
@@ -289,6 +289,10 @@ func (s *Scratch) compress4X(src []byte) ([]byte, error) {
 		if err != nil {
 			return nil, err
 		}
+		if len(s.Out)-idx > math.MaxUint16 {
+			// We cannot store the size in the jump table
+			return nil, ErrIncompressible
+		}
 		// Write compressed length as little endian before block.
 		if i < 3 {
 			// Last length is not written.
@@ -332,6 +336,10 @@ func (s *Scratch) compress4Xp(src []byte) ([]byte, error) {
 			return nil, errs[i]
 		}
 		o := s.tmpOut[i]
+		if len(o) > math.MaxUint16 {
+			// We cannot store the size in the jump table
+			return nil, ErrIncompressible
+		}
 		// Write compressed length as little endian before block.
 		if i < 3 {
 			// Last length is not written.
@@ -356,29 +364,29 @@ func (s *Scratch) countSimple(in []byte) (max int, reuse bool) {
 	m := uint32(0)
 	if len(s.prevTable) > 0 {
 		for i, v := range s.count[:] {
+			if v == 0 {
+				continue
+			}
 			if v > m {
 				m = v
 			}
-			if v > 0 {
-				s.symbolLen = uint16(i) + 1
-				if i >= len(s.prevTable) {
-					reuse = false
-				} else {
-					if s.prevTable[i].nBits == 0 {
-						reuse = false
-					}
-				}
+			s.symbolLen = uint16(i) + 1
+			if i >= len(s.prevTable) {
+				reuse = false
+			} else if s.prevTable[i].nBits == 0 {
+				reuse = false
 			}
 		}
 		return int(m), reuse
 	}
 	for i, v := range s.count[:] {
+		if v == 0 {
+			continue
+		}
 		if v > m {
 			m = v
 		}
-		if v > 0 {
-			s.symbolLen = uint16(i) + 1
-		}
+		s.symbolLen = uint16(i) + 1
 	}
 	return int(m), false
 }
@@ -395,6 +403,7 @@ func (s *Scratch) canUseTable(c cTable) bool {
 	return true
 }
 
+//lint:ignore U1000 used for debugging
 func (s *Scratch) validateTable(c cTable) bool {
 	if len(c) < int(s.symbolLen) {
 		return false
@@ -474,34 +483,35 @@ func (s *Scratch) buildCTable() error {
 	// Different from reference implementation.
 	huffNode0 := s.nodes[0 : huffNodesLen+1]
 
-	for huffNode[nonNullRank].count == 0 {
+	for huffNode[nonNullRank].count() == 0 {
 		nonNullRank--
 	}
 
 	lowS := int16(nonNullRank)
 	nodeRoot := nodeNb + lowS - 1
 	lowN := nodeNb
-	huffNode[nodeNb].count = huffNode[lowS].count + huffNode[lowS-1].count
-	huffNode[lowS].parent, huffNode[lowS-1].parent = uint16(nodeNb), uint16(nodeNb)
+	huffNode[nodeNb].setCount(huffNode[lowS].count() + huffNode[lowS-1].count())
+	huffNode[lowS].setParent(nodeNb)
+	huffNode[lowS-1].setParent(nodeNb)
 	nodeNb++
 	lowS -= 2
 	for n := nodeNb; n <= nodeRoot; n++ {
-		huffNode[n].count = 1 << 30
+		huffNode[n].setCount(1 << 30)
 	}
 	// fake entry, strong barrier
-	huffNode0[0].count = 1 << 31
+	huffNode0[0].setCount(1 << 31)
 
 	// create parents
 	for nodeNb <= nodeRoot {
 		var n1, n2 int16
-		if huffNode0[lowS+1].count < huffNode0[lowN+1].count {
+		if huffNode0[lowS+1].count() < huffNode0[lowN+1].count() {
 			n1 = lowS
 			lowS--
 		} else {
 			n1 = lowN
 			lowN++
 		}
-		if huffNode0[lowS+1].count < huffNode0[lowN+1].count {
+		if huffNode0[lowS+1].count() < huffNode0[lowN+1].count() {
 			n2 = lowS
 			lowS--
 		} else {
@@ -509,18 +519,19 @@ func (s *Scratch) buildCTable() error {
 			lowN++
 		}
 
-		huffNode[nodeNb].count = huffNode0[n1+1].count + huffNode0[n2+1].count
-		huffNode0[n1+1].parent, huffNode0[n2+1].parent = uint16(nodeNb), uint16(nodeNb)
+		huffNode[nodeNb].setCount(huffNode0[n1+1].count() + huffNode0[n2+1].count())
+		huffNode0[n1+1].setParent(nodeNb)
+		huffNode0[n2+1].setParent(nodeNb)
 		nodeNb++
 	}
 
 	// distribute weights (unlimited tree height)
-	huffNode[nodeRoot].nbBits = 0
+	huffNode[nodeRoot].setNbBits(0)
 	for n := nodeRoot - 1; n >= startNode; n-- {
-		huffNode[n].nbBits = huffNode[huffNode[n].parent].nbBits + 1
+		huffNode[n].setNbBits(huffNode[huffNode[n].parent()].nbBits() + 1)
 	}
 	for n := uint16(0); n <= nonNullRank; n++ {
-		huffNode[n].nbBits = huffNode[huffNode[n].parent].nbBits + 1
+		huffNode[n].setNbBits(huffNode[huffNode[n].parent()].nbBits() + 1)
 	}
 	s.actualTableLog = s.setMaxHeight(int(nonNullRank))
 	maxNbBits := s.actualTableLog
@@ -532,7 +543,7 @@ func (s *Scratch) buildCTable() error {
 	var nbPerRank [tableLogMax + 1]uint16
 	var valPerRank [16]uint16
 	for _, v := range huffNode[:nonNullRank+1] {
-		nbPerRank[v.nbBits]++
+		nbPerRank[v.nbBits()]++
 	}
 	// determine stating value per rank
 	{
@@ -547,7 +558,7 @@ func (s *Scratch) buildCTable() error {
 
 	// push nbBits per symbol, symbol order
 	for _, v := range huffNode[:nonNullRank+1] {
-		s.cTable[v.symbol].nBits = v.nbBits
+		s.cTable[v.symbol()].nBits = v.nbBits()
 	}
 
 	// assign value within rank, symbol order
@@ -593,12 +604,12 @@ func (s *Scratch) huffSort() {
 		pos := rank[r].current
 		rank[r].current++
 		prev := nodes[(pos-1)&huffNodesMask]
-		for pos > rank[r].base && c > prev.count {
+		for pos > rank[r].base && c > prev.count() {
 			nodes[pos&huffNodesMask] = prev
 			pos--
 			prev = nodes[(pos-1)&huffNodesMask]
 		}
-		nodes[pos&huffNodesMask] = nodeElt{count: c, symbol: byte(n)}
+		nodes[pos&huffNodesMask] = makeNodeElt(c, byte(n))
 	}
 }
 
@@ -607,7 +618,7 @@ func (s *Scratch) setMaxHeight(lastNonNull int) uint8 {
 	huffNode := s.nodes[1 : huffNodesLen+1]
 	//huffNode = huffNode[: huffNodesLen]
 
-	largestBits := huffNode[lastNonNull].nbBits
+	largestBits := huffNode[lastNonNull].nbBits()
 
 	// early exit : no elt > maxNbBits
 	if largestBits <= maxNbBits {
@@ -617,14 +628,14 @@ func (s *Scratch) setMaxHeight(lastNonNull int) uint8 {
 	baseCost := int(1) << (largestBits - maxNbBits)
 	n := uint32(lastNonNull)
 
-	for huffNode[n].nbBits > maxNbBits {
-		totalCost += baseCost - (1 << (largestBits - huffNode[n].nbBits))
-		huffNode[n].nbBits = maxNbBits
+	for huffNode[n].nbBits() > maxNbBits {
+		totalCost += baseCost - (1 << (largestBits - huffNode[n].nbBits()))
+		huffNode[n].setNbBits(maxNbBits)
 		n--
 	}
 	// n stops at huffNode[n].nbBits <= maxNbBits
 
-	for huffNode[n].nbBits == maxNbBits {
+	for huffNode[n].nbBits() == maxNbBits {
 		n--
 	}
 	// n end at index of smallest symbol using < maxNbBits
@@ -645,10 +656,10 @@ func (s *Scratch) setMaxHeight(lastNonNull int) uint8 {
 		{
 			currentNbBits := maxNbBits
 			for pos := int(n); pos >= 0; pos-- {
-				if huffNode[pos].nbBits >= currentNbBits {
+				if huffNode[pos].nbBits() >= currentNbBits {
 					continue
 				}
-				currentNbBits = huffNode[pos].nbBits // < maxNbBits
+				currentNbBits = huffNode[pos].nbBits() // < maxNbBits
 				rankLast[maxNbBits-currentNbBits] = uint32(pos)
 			}
 		}
@@ -665,8 +676,8 @@ func (s *Scratch) setMaxHeight(lastNonNull int) uint8 {
 				if lowPos == noSymbol {
 					break
 				}
-				highTotal := huffNode[highPos].count
-				lowTotal := 2 * huffNode[lowPos].count
+				highTotal := huffNode[highPos].count()
+				lowTotal := 2 * huffNode[lowPos].count()
 				if highTotal <= lowTotal {
 					break
 				}
@@ -682,13 +693,14 @@ func (s *Scratch) setMaxHeight(lastNonNull int) uint8 {
 				// this rank is no longer empty
 				rankLast[nBitsToDecrease-1] = rankLast[nBitsToDecrease]
 			}
-			huffNode[rankLast[nBitsToDecrease]].nbBits++
+			huffNode[rankLast[nBitsToDecrease]].setNbBits(1 +
+				huffNode[rankLast[nBitsToDecrease]].nbBits())
 			if rankLast[nBitsToDecrease] == 0 {
 				/* special case, reached largest symbol */
 				rankLast[nBitsToDecrease] = noSymbol
 			} else {
 				rankLast[nBitsToDecrease]--
-				if huffNode[rankLast[nBitsToDecrease]].nbBits != maxNbBits-nBitsToDecrease {
+				if huffNode[rankLast[nBitsToDecrease]].nbBits() != maxNbBits-nBitsToDecrease {
 					rankLast[nBitsToDecrease] = noSymbol /* this rank is now empty */
 				}
 			}
@@ -696,15 +708,15 @@ func (s *Scratch) setMaxHeight(lastNonNull int) uint8 {
 
 		for totalCost < 0 { /* Sometimes, cost correction overshoot */
 			if rankLast[1] == noSymbol { /* special case : no rank 1 symbol (using maxNbBits-1); let's create one from largest rank 0 (using maxNbBits) */
-				for huffNode[n].nbBits == maxNbBits {
+				for huffNode[n].nbBits() == maxNbBits {
 					n--
 				}
-				huffNode[n+1].nbBits--
+				huffNode[n+1].setNbBits(huffNode[n+1].nbBits() - 1)
 				rankLast[1] = n + 1
 				totalCost++
 				continue
 			}
-			huffNode[rankLast[1]+1].nbBits--
+			huffNode[rankLast[1]+1].setNbBits(huffNode[rankLast[1]+1].nbBits() - 1)
 			rankLast[1]++
 			totalCost++
 		}
@@ -712,9 +724,26 @@ func (s *Scratch) setMaxHeight(lastNonNull int) uint8 {
 	return maxNbBits
 }
 
-type nodeElt struct {
-	count  uint32
-	parent uint16
-	symbol byte
-	nbBits uint8
+// A nodeElt is the fields
+//
+//	count  uint32
+//	parent uint16
+//	symbol byte
+//	nbBits uint8
+//
+// in some order, all squashed into an integer so that the compiler
+// always loads and stores entire nodeElts instead of separate fields.
+type nodeElt uint64
+
+func makeNodeElt(count uint32, symbol byte) nodeElt {
+	return nodeElt(count) | nodeElt(symbol)<<48
 }
+
+func (e *nodeElt) count() uint32  { return uint32(*e) }
+func (e *nodeElt) parent() uint16 { return uint16(*e >> 32) }
+func (e *nodeElt) symbol() byte   { return byte(*e >> 48) }
+func (e *nodeElt) nbBits() uint8  { return uint8(*e >> 56) }
+
+func (e *nodeElt) setCount(c uint32) { *e = (*e)&0xffffffff00000000 | nodeElt(c) }
+func (e *nodeElt) setParent(p int16) { *e = (*e)&0xffff0000ffffffff | nodeElt(uint16(p))<<32 }
+func (e *nodeElt) setNbBits(n uint8) { *e = (*e)&0x00ffffffffffffff | nodeElt(n)<<56 }
diff --git a/vendor/github.com/klauspost/compress/huff0/decompress.go b/vendor/github.com/klauspost/compress/huff0/decompress.go
index 9b7cc8e9..54bd08b2 100644
--- a/vendor/github.com/klauspost/compress/huff0/decompress.go
+++ b/vendor/github.com/klauspost/compress/huff0/decompress.go
@@ -4,13 +4,13 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"sync"
 
 	"github.com/klauspost/compress/fse"
 )
 
 type dTable struct {
 	single []dEntrySingle
-	double []dEntryDouble
 }
 
 // single-symbols decoding
@@ -18,13 +18,6 @@ type dEntrySingle struct {
 	entry uint16
 }
 
-// double-symbols decoding
-type dEntryDouble struct {
-	seq   uint16
-	nBits uint8
-	len   uint8
-}
-
 // Uses special code for all tables that are < 8 bits.
 const use8BitTables = true
 
@@ -34,7 +27,7 @@ const use8BitTables = true
 // If no Scratch is provided a new one is allocated.
 // The returned Scratch can be used for encoding or decoding input using this table.
 func ReadTable(in []byte, s *Scratch) (s2 *Scratch, remain []byte, err error) {
-	s, err = s.prepare(in)
+	s, err = s.prepare(nil)
 	if err != nil {
 		return s, nil, err
 	}
@@ -68,7 +61,7 @@ func ReadTable(in []byte, s *Scratch) (s2 *Scratch, remain []byte, err error) {
 		b, err := fse.Decompress(in[:iSize], s.fse)
 		s.fse.Out = nil
 		if err != nil {
-			return s, nil, err
+			return s, nil, fmt.Errorf("fse decompress returned: %w", err)
 		}
 		if len(b) > 255 {
 			return s, nil, errors.New("corrupt input: output table too large")
@@ -216,6 +209,7 @@ func (s *Scratch) Decoder() *Decoder {
 	return &Decoder{
 		dt:             s.dt,
 		actualTableLog: s.actualTableLog,
+		bufs:           &s.decPool,
 	}
 }
 
@@ -223,103 +217,15 @@ func (s *Scratch) Decoder() *Decoder {
 type Decoder struct {
 	dt             dTable
 	actualTableLog uint8
+	bufs           *sync.Pool
 }
 
-// Decompress1X will decompress a 1X encoded stream.
-// The cap of the output buffer will be the maximum decompressed size.
-// The length of the supplied input must match the end of a block exactly.
-func (d *Decoder) Decompress1X(dst, src []byte) ([]byte, error) {
-	if len(d.dt.single) == 0 {
-		return nil, errors.New("no table loaded")
-	}
-	if use8BitTables && d.actualTableLog <= 8 {
-		return d.decompress1X8Bit(dst, src)
-	}
-	var br bitReaderShifted
-	err := br.init(src)
-	if err != nil {
-		return dst, err
-	}
-	maxDecodedSize := cap(dst)
-	dst = dst[:0]
-
-	// Avoid bounds check by always having full sized table.
-	const tlSize = 1 << tableLogMax
-	const tlMask = tlSize - 1
-	dt := d.dt.single[:tlSize]
-
-	// Use temp table to avoid bound checks/append penalty.
-	var buf [256]byte
-	var off uint8
-
-	for br.off >= 8 {
-		br.fillFast()
-		v := dt[br.peekBitsFast(d.actualTableLog)&tlMask]
-		br.advance(uint8(v.entry))
-		buf[off+0] = uint8(v.entry >> 8)
-
-		v = dt[br.peekBitsFast(d.actualTableLog)&tlMask]
-		br.advance(uint8(v.entry))
-		buf[off+1] = uint8(v.entry >> 8)
-
-		// Refill
-		br.fillFast()
-
-		v = dt[br.peekBitsFast(d.actualTableLog)&tlMask]
-		br.advance(uint8(v.entry))
-		buf[off+2] = uint8(v.entry >> 8)
-
-		v = dt[br.peekBitsFast(d.actualTableLog)&tlMask]
-		br.advance(uint8(v.entry))
-		buf[off+3] = uint8(v.entry >> 8)
-
-		off += 4
-		if off == 0 {
-			if len(dst)+256 > maxDecodedSize {
-				br.close()
-				return nil, ErrMaxDecodedSizeExceeded
-			}
-			dst = append(dst, buf[:]...)
-		}
-	}
-
-	if len(dst)+int(off) > maxDecodedSize {
-		br.close()
-		return nil, ErrMaxDecodedSizeExceeded
-	}
-	dst = append(dst, buf[:off]...)
-
-	// br < 8, so uint8 is fine
-	bitsLeft := uint8(br.off)*8 + 64 - br.bitsRead
-	for bitsLeft > 0 {
-		br.fill()
-		if false && br.bitsRead >= 32 {
-			if br.off >= 4 {
-				v := br.in[br.off-4:]
-				v = v[:4]
-				low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
-				br.value = (br.value << 32) | uint64(low)
-				br.bitsRead -= 32
-				br.off -= 4
-			} else {
-				for br.off > 0 {
-					br.value = (br.value << 8) | uint64(br.in[br.off-1])
-					br.bitsRead -= 8
-					br.off--
-				}
-			}
-		}
-		if len(dst) >= maxDecodedSize {
-			br.close()
-			return nil, ErrMaxDecodedSizeExceeded
-		}
-		v := d.dt.single[br.peekBitsFast(d.actualTableLog)&tlMask]
-		nBits := uint8(v.entry)
-		br.advance(nBits)
-		bitsLeft -= nBits
-		dst = append(dst, uint8(v.entry>>8))
+func (d *Decoder) buffer() *[4][256]byte {
+	buf, ok := d.bufs.Get().(*[4][256]byte)
+	if ok {
+		return buf
 	}
-	return dst, br.close()
+	return &[4][256]byte{}
 }
 
 // decompress1X8Bit will decompress a 1X encoded stream with tablelog <= 8.
@@ -341,12 +247,13 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 	dt := d.dt.single[:256]
 
 	// Use temp table to avoid bound checks/append penalty.
-	var buf [256]byte
+	bufs := d.buffer()
+	buf := &bufs[0]
 	var off uint8
 
 	switch d.actualTableLog {
 	case 8:
-		const shift = 8 - 8
+		const shift = 0
 		for br.off >= 4 {
 			br.fillFast()
 			v := dt[uint8(br.value>>(56+shift))]
@@ -369,6 +276,7 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			if off == 0 {
 				if len(dst)+256 > maxDecodedSize {
 					br.close()
+					d.bufs.Put(bufs)
 					return nil, ErrMaxDecodedSizeExceeded
 				}
 				dst = append(dst, buf[:]...)
@@ -398,6 +306,7 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			if off == 0 {
 				if len(dst)+256 > maxDecodedSize {
 					br.close()
+					d.bufs.Put(bufs)
 					return nil, ErrMaxDecodedSizeExceeded
 				}
 				dst = append(dst, buf[:]...)
@@ -426,6 +335,7 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			off += 4
 			if off == 0 {
 				if len(dst)+256 > maxDecodedSize {
+					d.bufs.Put(bufs)
 					br.close()
 					return nil, ErrMaxDecodedSizeExceeded
 				}
@@ -455,6 +365,7 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			off += 4
 			if off == 0 {
 				if len(dst)+256 > maxDecodedSize {
+					d.bufs.Put(bufs)
 					br.close()
 					return nil, ErrMaxDecodedSizeExceeded
 				}
@@ -484,6 +395,7 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			off += 4
 			if off == 0 {
 				if len(dst)+256 > maxDecodedSize {
+					d.bufs.Put(bufs)
 					br.close()
 					return nil, ErrMaxDecodedSizeExceeded
 				}
@@ -513,6 +425,7 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			off += 4
 			if off == 0 {
 				if len(dst)+256 > maxDecodedSize {
+					d.bufs.Put(bufs)
 					br.close()
 					return nil, ErrMaxDecodedSizeExceeded
 				}
@@ -542,6 +455,7 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			off += 4
 			if off == 0 {
 				if len(dst)+256 > maxDecodedSize {
+					d.bufs.Put(bufs)
 					br.close()
 					return nil, ErrMaxDecodedSizeExceeded
 				}
@@ -571,6 +485,7 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			off += 4
 			if off == 0 {
 				if len(dst)+256 > maxDecodedSize {
+					d.bufs.Put(bufs)
 					br.close()
 					return nil, ErrMaxDecodedSizeExceeded
 				}
@@ -578,10 +493,12 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			}
 		}
 	default:
+		d.bufs.Put(bufs)
 		return nil, fmt.Errorf("invalid tablelog: %d", d.actualTableLog)
 	}
 
 	if len(dst)+int(off) > maxDecodedSize {
+		d.bufs.Put(bufs)
 		br.close()
 		return nil, ErrMaxDecodedSizeExceeded
 	}
@@ -601,6 +518,7 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 		}
 		if len(dst) >= maxDecodedSize {
 			br.close()
+			d.bufs.Put(bufs)
 			return nil, ErrMaxDecodedSizeExceeded
 		}
 		v := dt[br.peekByteFast()>>shift]
@@ -609,6 +527,7 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 		bitsLeft -= int8(nBits)
 		dst = append(dst, uint8(v.entry>>8))
 	}
+	d.bufs.Put(bufs)
 	return dst, br.close()
 }
 
@@ -628,7 +547,8 @@ func (d *Decoder) decompress1X8BitExactly(dst, src []byte) ([]byte, error) {
 	dt := d.dt.single[:256]
 
 	// Use temp table to avoid bound checks/append penalty.
-	var buf [256]byte
+	bufs := d.buffer()
+	buf := &bufs[0]
 	var off uint8
 
 	const shift = 56
@@ -655,6 +575,7 @@ func (d *Decoder) decompress1X8BitExactly(dst, src []byte) ([]byte, error) {
 		off += 4
 		if off == 0 {
 			if len(dst)+256 > maxDecodedSize {
+				d.bufs.Put(bufs)
 				br.close()
 				return nil, ErrMaxDecodedSizeExceeded
 			}
@@ -663,6 +584,7 @@ func (d *Decoder) decompress1X8BitExactly(dst, src []byte) ([]byte, error) {
 	}
 
 	if len(dst)+int(off) > maxDecodedSize {
+		d.bufs.Put(bufs)
 		br.close()
 		return nil, ErrMaxDecodedSizeExceeded
 	}
@@ -679,6 +601,7 @@ func (d *Decoder) decompress1X8BitExactly(dst, src []byte) ([]byte, error) {
 			}
 		}
 		if len(dst) >= maxDecodedSize {
+			d.bufs.Put(bufs)
 			br.close()
 			return nil, ErrMaxDecodedSizeExceeded
 		}
@@ -688,199 +611,10 @@ func (d *Decoder) decompress1X8BitExactly(dst, src []byte) ([]byte, error) {
 		bitsLeft -= int8(nBits)
 		dst = append(dst, uint8(v.entry>>8))
 	}
+	d.bufs.Put(bufs)
 	return dst, br.close()
 }
 
-// Decompress4X will decompress a 4X encoded stream.
-// The length of the supplied input must match the end of a block exactly.
-// The *capacity* of the dst slice must match the destination size of
-// the uncompressed data exactly.
-func (d *Decoder) Decompress4X(dst, src []byte) ([]byte, error) {
-	if len(d.dt.single) == 0 {
-		return nil, errors.New("no table loaded")
-	}
-	if len(src) < 6+(4*1) {
-		return nil, errors.New("input too small")
-	}
-	if use8BitTables && d.actualTableLog <= 8 {
-		return d.decompress4X8bit(dst, src)
-	}
-
-	var br [4]bitReaderShifted
-	start := 6
-	for i := 0; i < 3; i++ {
-		length := int(src[i*2]) | (int(src[i*2+1]) << 8)
-		if start+length >= len(src) {
-			return nil, errors.New("truncated input (or invalid offset)")
-		}
-		err := br[i].init(src[start : start+length])
-		if err != nil {
-			return nil, err
-		}
-		start += length
-	}
-	err := br[3].init(src[start:])
-	if err != nil {
-		return nil, err
-	}
-
-	// destination, offset to match first output
-	dstSize := cap(dst)
-	dst = dst[:dstSize]
-	out := dst
-	dstEvery := (dstSize + 3) / 4
-
-	const tlSize = 1 << tableLogMax
-	const tlMask = tlSize - 1
-	single := d.dt.single[:tlSize]
-
-	// Use temp table to avoid bound checks/append penalty.
-	var buf [256]byte
-	var off uint8
-	var decoded int
-
-	// Decode 2 values from each decoder/loop.
-	const bufoff = 256 / 4
-	for {
-		if br[0].off < 4 || br[1].off < 4 || br[2].off < 4 || br[3].off < 4 {
-			break
-		}
-
-		{
-			const stream = 0
-			const stream2 = 1
-			br[stream].fillFast()
-			br[stream2].fillFast()
-
-			val := br[stream].peekBitsFast(d.actualTableLog)
-			v := single[val&tlMask]
-			br[stream].advance(uint8(v.entry))
-			buf[off+bufoff*stream] = uint8(v.entry >> 8)
-
-			val2 := br[stream2].peekBitsFast(d.actualTableLog)
-			v2 := single[val2&tlMask]
-			br[stream2].advance(uint8(v2.entry))
-			buf[off+bufoff*stream2] = uint8(v2.entry >> 8)
-
-			val = br[stream].peekBitsFast(d.actualTableLog)
-			v = single[val&tlMask]
-			br[stream].advance(uint8(v.entry))
-			buf[off+bufoff*stream+1] = uint8(v.entry >> 8)
-
-			val2 = br[stream2].peekBitsFast(d.actualTableLog)
-			v2 = single[val2&tlMask]
-			br[stream2].advance(uint8(v2.entry))
-			buf[off+bufoff*stream2+1] = uint8(v2.entry >> 8)
-		}
-
-		{
-			const stream = 2
-			const stream2 = 3
-			br[stream].fillFast()
-			br[stream2].fillFast()
-
-			val := br[stream].peekBitsFast(d.actualTableLog)
-			v := single[val&tlMask]
-			br[stream].advance(uint8(v.entry))
-			buf[off+bufoff*stream] = uint8(v.entry >> 8)
-
-			val2 := br[stream2].peekBitsFast(d.actualTableLog)
-			v2 := single[val2&tlMask]
-			br[stream2].advance(uint8(v2.entry))
-			buf[off+bufoff*stream2] = uint8(v2.entry >> 8)
-
-			val = br[stream].peekBitsFast(d.actualTableLog)
-			v = single[val&tlMask]
-			br[stream].advance(uint8(v.entry))
-			buf[off+bufoff*stream+1] = uint8(v.entry >> 8)
-
-			val2 = br[stream2].peekBitsFast(d.actualTableLog)
-			v2 = single[val2&tlMask]
-			br[stream2].advance(uint8(v2.entry))
-			buf[off+bufoff*stream2+1] = uint8(v2.entry >> 8)
-		}
-
-		off += 2
-
-		if off == bufoff {
-			if bufoff > dstEvery {
-				return nil, errors.New("corruption detected: stream overrun 1")
-			}
-			copy(out, buf[:bufoff])
-			copy(out[dstEvery:], buf[bufoff:bufoff*2])
-			copy(out[dstEvery*2:], buf[bufoff*2:bufoff*3])
-			copy(out[dstEvery*3:], buf[bufoff*3:bufoff*4])
-			off = 0
-			out = out[bufoff:]
-			decoded += 256
-			// There must at least be 3 buffers left.
-			if len(out) < dstEvery*3 {
-				return nil, errors.New("corruption detected: stream overrun 2")
-			}
-		}
-	}
-	if off > 0 {
-		ioff := int(off)
-		if len(out) < dstEvery*3+ioff {
-			return nil, errors.New("corruption detected: stream overrun 3")
-		}
-		copy(out, buf[:off])
-		copy(out[dstEvery:dstEvery+ioff], buf[bufoff:bufoff*2])
-		copy(out[dstEvery*2:dstEvery*2+ioff], buf[bufoff*2:bufoff*3])
-		copy(out[dstEvery*3:dstEvery*3+ioff], buf[bufoff*3:bufoff*4])
-		decoded += int(off) * 4
-		out = out[off:]
-	}
-
-	// Decode remaining.
-	for i := range br {
-		offset := dstEvery * i
-		br := &br[i]
-		bitsLeft := br.off*8 + uint(64-br.bitsRead)
-		for bitsLeft > 0 {
-			br.fill()
-			if false && br.bitsRead >= 32 {
-				if br.off >= 4 {
-					v := br.in[br.off-4:]
-					v = v[:4]
-					low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
-					br.value = (br.value << 32) | uint64(low)
-					br.bitsRead -= 32
-					br.off -= 4
-				} else {
-					for br.off > 0 {
-						br.value = (br.value << 8) | uint64(br.in[br.off-1])
-						br.bitsRead -= 8
-						br.off--
-					}
-				}
-			}
-			// end inline...
-			if offset >= len(out) {
-				return nil, errors.New("corruption detected: stream overrun 4")
-			}
-
-			// Read value and increment offset.
-			val := br.peekBitsFast(d.actualTableLog)
-			v := single[val&tlMask].entry
-			nBits := uint8(v)
-			br.advance(nBits)
-			bitsLeft -= uint(nBits)
-			out[offset] = uint8(v >> 8)
-			offset++
-		}
-		decoded += offset - dstEvery*i
-		err = br.close()
-		if err != nil {
-			return nil, err
-		}
-	}
-	if dstSize != decoded {
-		return nil, errors.New("corruption detected: short output block")
-	}
-	return dst, nil
-}
-
 // Decompress4X will decompress a 4X encoded stream.
 // The length of the supplied input must match the end of a block exactly.
 // The *capacity* of the dst slice must match the destination size of
@@ -914,18 +648,18 @@ func (d *Decoder) decompress4X8bit(dst, src []byte) ([]byte, error) {
 	out := dst
 	dstEvery := (dstSize + 3) / 4
 
-	shift := (8 - d.actualTableLog) & 7
+	shift := (56 + (8 - d.actualTableLog)) & 63
 
 	const tlSize = 1 << 8
 	single := d.dt.single[:tlSize]
 
 	// Use temp table to avoid bound checks/append penalty.
-	var buf [256]byte
+	buf := d.buffer()
 	var off uint8
 	var decoded int
 
 	// Decode 4 values from each decoder/loop.
-	const bufoff = 256 / 4
+	const bufoff = 256
 	for {
 		if br[0].off < 4 || br[1].off < 4 || br[2].off < 4 || br[3].off < 4 {
 			break
@@ -935,120 +669,144 @@ func (d *Decoder) decompress4X8bit(dst, src []byte) ([]byte, error) {
 			// Interleave 2 decodes.
 			const stream = 0
 			const stream2 = 1
-			br[stream].fillFast()
-			br[stream2].fillFast()
-
-			v := single[br[stream].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream] = uint8(v >> 8)
-			br[stream].advance(uint8(v))
-
-			v2 := single[br[stream2].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream2] = uint8(v2 >> 8)
-			br[stream2].advance(uint8(v2))
-
-			v = single[br[stream].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream+1] = uint8(v >> 8)
-			br[stream].advance(uint8(v))
-
-			v2 = single[br[stream2].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream2+1] = uint8(v2 >> 8)
-			br[stream2].advance(uint8(v2))
-
-			v = single[br[stream].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream+2] = uint8(v >> 8)
-			br[stream].advance(uint8(v))
-
-			v2 = single[br[stream2].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream2+2] = uint8(v2 >> 8)
-			br[stream2].advance(uint8(v2))
-
-			v = single[br[stream].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream+3] = uint8(v >> 8)
-			br[stream].advance(uint8(v))
-
-			v2 = single[br[stream2].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream2+3] = uint8(v2 >> 8)
-			br[stream2].advance(uint8(v2))
+			br1 := &br[stream]
+			br2 := &br[stream2]
+			br1.fillFast()
+			br2.fillFast()
+
+			v := single[uint8(br1.value>>shift)].entry
+			v2 := single[uint8(br2.value>>shift)].entry
+			br1.bitsRead += uint8(v)
+			br1.value <<= v & 63
+			br2.bitsRead += uint8(v2)
+			br2.value <<= v2 & 63
+			buf[stream][off] = uint8(v >> 8)
+			buf[stream2][off] = uint8(v2 >> 8)
+
+			v = single[uint8(br1.value>>shift)].entry
+			v2 = single[uint8(br2.value>>shift)].entry
+			br1.bitsRead += uint8(v)
+			br1.value <<= v & 63
+			br2.bitsRead += uint8(v2)
+			br2.value <<= v2 & 63
+			buf[stream][off+1] = uint8(v >> 8)
+			buf[stream2][off+1] = uint8(v2 >> 8)
+
+			v = single[uint8(br1.value>>shift)].entry
+			v2 = single[uint8(br2.value>>shift)].entry
+			br1.bitsRead += uint8(v)
+			br1.value <<= v & 63
+			br2.bitsRead += uint8(v2)
+			br2.value <<= v2 & 63
+			buf[stream][off+2] = uint8(v >> 8)
+			buf[stream2][off+2] = uint8(v2 >> 8)
+
+			v = single[uint8(br1.value>>shift)].entry
+			v2 = single[uint8(br2.value>>shift)].entry
+			br1.bitsRead += uint8(v)
+			br1.value <<= v & 63
+			br2.bitsRead += uint8(v2)
+			br2.value <<= v2 & 63
+			buf[stream][off+3] = uint8(v >> 8)
+			buf[stream2][off+3] = uint8(v2 >> 8)
 		}
 
 		{
 			const stream = 2
 			const stream2 = 3
-			br[stream].fillFast()
-			br[stream2].fillFast()
-
-			v := single[br[stream].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream] = uint8(v >> 8)
-			br[stream].advance(uint8(v))
-
-			v2 := single[br[stream2].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream2] = uint8(v2 >> 8)
-			br[stream2].advance(uint8(v2))
-
-			v = single[br[stream].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream+1] = uint8(v >> 8)
-			br[stream].advance(uint8(v))
-
-			v2 = single[br[stream2].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream2+1] = uint8(v2 >> 8)
-			br[stream2].advance(uint8(v2))
-
-			v = single[br[stream].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream+2] = uint8(v >> 8)
-			br[stream].advance(uint8(v))
-
-			v2 = single[br[stream2].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream2+2] = uint8(v2 >> 8)
-			br[stream2].advance(uint8(v2))
-
-			v = single[br[stream].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream+3] = uint8(v >> 8)
-			br[stream].advance(uint8(v))
-
-			v2 = single[br[stream2].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream2+3] = uint8(v2 >> 8)
-			br[stream2].advance(uint8(v2))
+			br1 := &br[stream]
+			br2 := &br[stream2]
+			br1.fillFast()
+			br2.fillFast()
+
+			v := single[uint8(br1.value>>shift)].entry
+			v2 := single[uint8(br2.value>>shift)].entry
+			br1.bitsRead += uint8(v)
+			br1.value <<= v & 63
+			br2.bitsRead += uint8(v2)
+			br2.value <<= v2 & 63
+			buf[stream][off] = uint8(v >> 8)
+			buf[stream2][off] = uint8(v2 >> 8)
+
+			v = single[uint8(br1.value>>shift)].entry
+			v2 = single[uint8(br2.value>>shift)].entry
+			br1.bitsRead += uint8(v)
+			br1.value <<= v & 63
+			br2.bitsRead += uint8(v2)
+			br2.value <<= v2 & 63
+			buf[stream][off+1] = uint8(v >> 8)
+			buf[stream2][off+1] = uint8(v2 >> 8)
+
+			v = single[uint8(br1.value>>shift)].entry
+			v2 = single[uint8(br2.value>>shift)].entry
+			br1.bitsRead += uint8(v)
+			br1.value <<= v & 63
+			br2.bitsRead += uint8(v2)
+			br2.value <<= v2 & 63
+			buf[stream][off+2] = uint8(v >> 8)
+			buf[stream2][off+2] = uint8(v2 >> 8)
+
+			v = single[uint8(br1.value>>shift)].entry
+			v2 = single[uint8(br2.value>>shift)].entry
+			br1.bitsRead += uint8(v)
+			br1.value <<= v & 63
+			br2.bitsRead += uint8(v2)
+			br2.value <<= v2 & 63
+			buf[stream][off+3] = uint8(v >> 8)
+			buf[stream2][off+3] = uint8(v2 >> 8)
 		}
 
 		off += 4
 
-		if off == bufoff {
+		if off == 0 {
 			if bufoff > dstEvery {
+				d.bufs.Put(buf)
 				return nil, errors.New("corruption detected: stream overrun 1")
 			}
-			copy(out, buf[:bufoff])
-			copy(out[dstEvery:], buf[bufoff:bufoff*2])
-			copy(out[dstEvery*2:], buf[bufoff*2:bufoff*3])
-			copy(out[dstEvery*3:], buf[bufoff*3:bufoff*4])
-			off = 0
-			out = out[bufoff:]
-			decoded += 256
 			// There must at least be 3 buffers left.
-			if len(out) < dstEvery*3 {
+			if len(out)-bufoff < dstEvery*3 {
+				d.bufs.Put(buf)
 				return nil, errors.New("corruption detected: stream overrun 2")
 			}
+			//copy(out, buf[0][:])
+			//copy(out[dstEvery:], buf[1][:])
+			//copy(out[dstEvery*2:], buf[2][:])
+			*(*[bufoff]byte)(out) = buf[0]
+			*(*[bufoff]byte)(out[dstEvery:]) = buf[1]
+			*(*[bufoff]byte)(out[dstEvery*2:]) = buf[2]
+			*(*[bufoff]byte)(out[dstEvery*3:]) = buf[3]
+			out = out[bufoff:]
+			decoded += bufoff * 4
 		}
 	}
 	if off > 0 {
 		ioff := int(off)
 		if len(out) < dstEvery*3+ioff {
+			d.bufs.Put(buf)
 			return nil, errors.New("corruption detected: stream overrun 3")
 		}
-		copy(out, buf[:off])
-		copy(out[dstEvery:dstEvery+ioff], buf[bufoff:bufoff*2])
-		copy(out[dstEvery*2:dstEvery*2+ioff], buf[bufoff*2:bufoff*3])
-		copy(out[dstEvery*3:dstEvery*3+ioff], buf[bufoff*3:bufoff*4])
+		copy(out, buf[0][:off])
+		copy(out[dstEvery:], buf[1][:off])
+		copy(out[dstEvery*2:], buf[2][:off])
+		copy(out[dstEvery*3:], buf[3][:off])
 		decoded += int(off) * 4
 		out = out[off:]
 	}
 
 	// Decode remaining.
+	// Decode remaining.
+	remainBytes := dstEvery - (decoded / 4)
 	for i := range br {
 		offset := dstEvery * i
+		endsAt := offset + remainBytes
+		if endsAt > len(out) {
+			endsAt = len(out)
+		}
 		br := &br[i]
-		bitsLeft := int(br.off*8) + int(64-br.bitsRead)
+		bitsLeft := br.remaining()
 		for bitsLeft > 0 {
 			if br.finished() {
+				d.bufs.Put(buf)
 				return nil, io.ErrUnexpectedEOF
 			}
 			if br.bitsRead >= 56 {
@@ -1068,24 +826,31 @@ func (d *Decoder) decompress4X8bit(dst, src []byte) ([]byte, error) {
 				}
 			}
 			// end inline...
-			if offset >= len(out) {
+			if offset >= endsAt {
+				d.bufs.Put(buf)
 				return nil, errors.New("corruption detected: stream overrun 4")
 			}
 
 			// Read value and increment offset.
-			v := single[br.peekByteFast()>>shift].entry
+			v := single[uint8(br.value>>shift)].entry
 			nBits := uint8(v)
 			br.advance(nBits)
-			bitsLeft -= int(nBits)
+			bitsLeft -= uint(nBits)
 			out[offset] = uint8(v >> 8)
 			offset++
 		}
+		if offset != endsAt {
+			d.bufs.Put(buf)
+			return nil, fmt.Errorf("corruption detected: short output block %d, end %d != %d", i, offset, endsAt)
+		}
 		decoded += offset - dstEvery*i
 		err = br.close()
 		if err != nil {
+			d.bufs.Put(buf)
 			return nil, err
 		}
 	}
+	d.bufs.Put(buf)
 	if dstSize != decoded {
 		return nil, errors.New("corruption detected: short output block")
 	}
@@ -1121,18 +886,17 @@ func (d *Decoder) decompress4X8bitExactly(dst, src []byte) ([]byte, error) {
 	out := dst
 	dstEvery := (dstSize + 3) / 4
 
-	const shift = 0
+	const shift = 56
 	const tlSize = 1 << 8
-	const tlMask = tlSize - 1
 	single := d.dt.single[:tlSize]
 
 	// Use temp table to avoid bound checks/append penalty.
-	var buf [256]byte
+	buf := d.buffer()
 	var off uint8
 	var decoded int
 
 	// Decode 4 values from each decoder/loop.
-	const bufoff = 256 / 4
+	const bufoff = 256
 	for {
 		if br[0].off < 4 || br[1].off < 4 || br[2].off < 4 || br[3].off < 4 {
 			break
@@ -1142,98 +906,116 @@ func (d *Decoder) decompress4X8bitExactly(dst, src []byte) ([]byte, error) {
 			// Interleave 2 decodes.
 			const stream = 0
 			const stream2 = 1
-			br[stream].fillFast()
-			br[stream2].fillFast()
-
-			v := single[br[stream].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream] = uint8(v >> 8)
-			br[stream].advance(uint8(v))
-
-			v2 := single[br[stream2].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream2] = uint8(v2 >> 8)
-			br[stream2].advance(uint8(v2))
-
-			v = single[br[stream].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream+1] = uint8(v >> 8)
-			br[stream].advance(uint8(v))
-
-			v2 = single[br[stream2].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream2+1] = uint8(v2 >> 8)
-			br[stream2].advance(uint8(v2))
-
-			v = single[br[stream].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream+2] = uint8(v >> 8)
-			br[stream].advance(uint8(v))
-
-			v2 = single[br[stream2].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream2+2] = uint8(v2 >> 8)
-			br[stream2].advance(uint8(v2))
-
-			v = single[br[stream].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream+3] = uint8(v >> 8)
-			br[stream].advance(uint8(v))
-
-			v2 = single[br[stream2].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream2+3] = uint8(v2 >> 8)
-			br[stream2].advance(uint8(v2))
+			br1 := &br[stream]
+			br2 := &br[stream2]
+			br1.fillFast()
+			br2.fillFast()
+
+			v := single[uint8(br1.value>>shift)].entry
+			v2 := single[uint8(br2.value>>shift)].entry
+			br1.bitsRead += uint8(v)
+			br1.value <<= v & 63
+			br2.bitsRead += uint8(v2)
+			br2.value <<= v2 & 63
+			buf[stream][off] = uint8(v >> 8)
+			buf[stream2][off] = uint8(v2 >> 8)
+
+			v = single[uint8(br1.value>>shift)].entry
+			v2 = single[uint8(br2.value>>shift)].entry
+			br1.bitsRead += uint8(v)
+			br1.value <<= v & 63
+			br2.bitsRead += uint8(v2)
+			br2.value <<= v2 & 63
+			buf[stream][off+1] = uint8(v >> 8)
+			buf[stream2][off+1] = uint8(v2 >> 8)
+
+			v = single[uint8(br1.value>>shift)].entry
+			v2 = single[uint8(br2.value>>shift)].entry
+			br1.bitsRead += uint8(v)
+			br1.value <<= v & 63
+			br2.bitsRead += uint8(v2)
+			br2.value <<= v2 & 63
+			buf[stream][off+2] = uint8(v >> 8)
+			buf[stream2][off+2] = uint8(v2 >> 8)
+
+			v = single[uint8(br1.value>>shift)].entry
+			v2 = single[uint8(br2.value>>shift)].entry
+			br1.bitsRead += uint8(v)
+			br1.value <<= v & 63
+			br2.bitsRead += uint8(v2)
+			br2.value <<= v2 & 63
+			buf[stream][off+3] = uint8(v >> 8)
+			buf[stream2][off+3] = uint8(v2 >> 8)
 		}
 
 		{
 			const stream = 2
 			const stream2 = 3
-			br[stream].fillFast()
-			br[stream2].fillFast()
-
-			v := single[br[stream].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream] = uint8(v >> 8)
-			br[stream].advance(uint8(v))
-
-			v2 := single[br[stream2].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream2] = uint8(v2 >> 8)
-			br[stream2].advance(uint8(v2))
-
-			v = single[br[stream].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream+1] = uint8(v >> 8)
-			br[stream].advance(uint8(v))
-
-			v2 = single[br[stream2].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream2+1] = uint8(v2 >> 8)
-			br[stream2].advance(uint8(v2))
-
-			v = single[br[stream].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream+2] = uint8(v >> 8)
-			br[stream].advance(uint8(v))
-
-			v2 = single[br[stream2].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream2+2] = uint8(v2 >> 8)
-			br[stream2].advance(uint8(v2))
-
-			v = single[br[stream].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream+3] = uint8(v >> 8)
-			br[stream].advance(uint8(v))
-
-			v2 = single[br[stream2].peekByteFast()>>shift].entry
-			buf[off+bufoff*stream2+3] = uint8(v2 >> 8)
-			br[stream2].advance(uint8(v2))
+			br1 := &br[stream]
+			br2 := &br[stream2]
+			br1.fillFast()
+			br2.fillFast()
+
+			v := single[uint8(br1.value>>shift)].entry
+			v2 := single[uint8(br2.value>>shift)].entry
+			br1.bitsRead += uint8(v)
+			br1.value <<= v & 63
+			br2.bitsRead += uint8(v2)
+			br2.value <<= v2 & 63
+			buf[stream][off] = uint8(v >> 8)
+			buf[stream2][off] = uint8(v2 >> 8)
+
+			v = single[uint8(br1.value>>shift)].entry
+			v2 = single[uint8(br2.value>>shift)].entry
+			br1.bitsRead += uint8(v)
+			br1.value <<= v & 63
+			br2.bitsRead += uint8(v2)
+			br2.value <<= v2 & 63
+			buf[stream][off+1] = uint8(v >> 8)
+			buf[stream2][off+1] = uint8(v2 >> 8)
+
+			v = single[uint8(br1.value>>shift)].entry
+			v2 = single[uint8(br2.value>>shift)].entry
+			br1.bitsRead += uint8(v)
+			br1.value <<= v & 63
+			br2.bitsRead += uint8(v2)
+			br2.value <<= v2 & 63
+			buf[stream][off+2] = uint8(v >> 8)
+			buf[stream2][off+2] = uint8(v2 >> 8)
+
+			v = single[uint8(br1.value>>shift)].entry
+			v2 = single[uint8(br2.value>>shift)].entry
+			br1.bitsRead += uint8(v)
+			br1.value <<= v & 63
+			br2.bitsRead += uint8(v2)
+			br2.value <<= v2 & 63
+			buf[stream][off+3] = uint8(v >> 8)
+			buf[stream2][off+3] = uint8(v2 >> 8)
 		}
 
 		off += 4
 
-		if off == bufoff {
+		if off == 0 {
 			if bufoff > dstEvery {
+				d.bufs.Put(buf)
 				return nil, errors.New("corruption detected: stream overrun 1")
 			}
-			copy(out, buf[:bufoff])
-			copy(out[dstEvery:], buf[bufoff:bufoff*2])
-			copy(out[dstEvery*2:], buf[bufoff*2:bufoff*3])
-			copy(out[dstEvery*3:], buf[bufoff*3:bufoff*4])
-			off = 0
-			out = out[bufoff:]
-			decoded += 256
 			// There must at least be 3 buffers left.
-			if len(out) < dstEvery*3 {
+			if len(out)-bufoff < dstEvery*3 {
+				d.bufs.Put(buf)
 				return nil, errors.New("corruption detected: stream overrun 2")
 			}
+
+			//copy(out, buf[0][:])
+			//copy(out[dstEvery:], buf[1][:])
+			//copy(out[dstEvery*2:], buf[2][:])
+			// copy(out[dstEvery*3:], buf[3][:])
+			*(*[bufoff]byte)(out) = buf[0]
+			*(*[bufoff]byte)(out[dstEvery:]) = buf[1]
+			*(*[bufoff]byte)(out[dstEvery*2:]) = buf[2]
+			*(*[bufoff]byte)(out[dstEvery*3:]) = buf[3]
+			out = out[bufoff:]
+			decoded += bufoff * 4
 		}
 	}
 	if off > 0 {
@@ -1241,21 +1023,27 @@ func (d *Decoder) decompress4X8bitExactly(dst, src []byte) ([]byte, error) {
 		if len(out) < dstEvery*3+ioff {
 			return nil, errors.New("corruption detected: stream overrun 3")
 		}
-		copy(out, buf[:off])
-		copy(out[dstEvery:dstEvery+ioff], buf[bufoff:bufoff*2])
-		copy(out[dstEvery*2:dstEvery*2+ioff], buf[bufoff*2:bufoff*3])
-		copy(out[dstEvery*3:dstEvery*3+ioff], buf[bufoff*3:bufoff*4])
+		copy(out, buf[0][:off])
+		copy(out[dstEvery:], buf[1][:off])
+		copy(out[dstEvery*2:], buf[2][:off])
+		copy(out[dstEvery*3:], buf[3][:off])
 		decoded += int(off) * 4
 		out = out[off:]
 	}
 
 	// Decode remaining.
+	remainBytes := dstEvery - (decoded / 4)
 	for i := range br {
 		offset := dstEvery * i
+		endsAt := offset + remainBytes
+		if endsAt > len(out) {
+			endsAt = len(out)
+		}
 		br := &br[i]
-		bitsLeft := int(br.off*8) + int(64-br.bitsRead)
+		bitsLeft := br.remaining()
 		for bitsLeft > 0 {
 			if br.finished() {
+				d.bufs.Put(buf)
 				return nil, io.ErrUnexpectedEOF
 			}
 			if br.bitsRead >= 56 {
@@ -1275,24 +1063,32 @@ func (d *Decoder) decompress4X8bitExactly(dst, src []byte) ([]byte, error) {
 				}
 			}
 			// end inline...
-			if offset >= len(out) {
+			if offset >= endsAt {
+				d.bufs.Put(buf)
 				return nil, errors.New("corruption detected: stream overrun 4")
 			}
 
 			// Read value and increment offset.
-			v := single[br.peekByteFast()>>shift].entry
+			v := single[br.peekByteFast()].entry
 			nBits := uint8(v)
 			br.advance(nBits)
-			bitsLeft -= int(nBits)
+			bitsLeft -= uint(nBits)
 			out[offset] = uint8(v >> 8)
 			offset++
 		}
+		if offset != endsAt {
+			d.bufs.Put(buf)
+			return nil, fmt.Errorf("corruption detected: short output block %d, end %d != %d", i, offset, endsAt)
+		}
+
 		decoded += offset - dstEvery*i
 		err = br.close()
 		if err != nil {
+			d.bufs.Put(buf)
 			return nil, err
 		}
 	}
+	d.bufs.Put(buf)
 	if dstSize != decoded {
 		return nil, errors.New("corruption detected: short output block")
 	}
diff --git a/vendor/github.com/klauspost/compress/huff0/decompress_amd64.go b/vendor/github.com/klauspost/compress/huff0/decompress_amd64.go
new file mode 100644
index 00000000..ba7e8e6b
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/huff0/decompress_amd64.go
@@ -0,0 +1,226 @@
+//go:build amd64 && !appengine && !noasm && gc
+// +build amd64,!appengine,!noasm,gc
+
+// This file contains the specialisation of Decoder.Decompress4X
+// and Decoder.Decompress1X that use an asm implementation of thir main loops.
+package huff0
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/klauspost/compress/internal/cpuinfo"
+)
+
+// decompress4x_main_loop_x86 is an x86 assembler implementation
+// of Decompress4X when tablelog > 8.
+//
+//go:noescape
+func decompress4x_main_loop_amd64(ctx *decompress4xContext)
+
+// decompress4x_8b_loop_x86 is an x86 assembler implementation
+// of Decompress4X when tablelog <= 8 which decodes 4 entries
+// per loop.
+//
+//go:noescape
+func decompress4x_8b_main_loop_amd64(ctx *decompress4xContext)
+
+// fallback8BitSize is the size where using Go version is faster.
+const fallback8BitSize = 800
+
+type decompress4xContext struct {
+	pbr      *[4]bitReaderShifted
+	peekBits uint8
+	out      *byte
+	dstEvery int
+	tbl      *dEntrySingle
+	decoded  int
+	limit    *byte
+}
+
+// Decompress4X will decompress a 4X encoded stream.
+// The length of the supplied input must match the end of a block exactly.
+// The *capacity* of the dst slice must match the destination size of
+// the uncompressed data exactly.
+func (d *Decoder) Decompress4X(dst, src []byte) ([]byte, error) {
+	if len(d.dt.single) == 0 {
+		return nil, errors.New("no table loaded")
+	}
+	if len(src) < 6+(4*1) {
+		return nil, errors.New("input too small")
+	}
+
+	use8BitTables := d.actualTableLog <= 8
+	if cap(dst) < fallback8BitSize && use8BitTables {
+		return d.decompress4X8bit(dst, src)
+	}
+
+	var br [4]bitReaderShifted
+	// Decode "jump table"
+	start := 6
+	for i := 0; i < 3; i++ {
+		length := int(src[i*2]) | (int(src[i*2+1]) << 8)
+		if start+length >= len(src) {
+			return nil, errors.New("truncated input (or invalid offset)")
+		}
+		err := br[i].init(src[start : start+length])
+		if err != nil {
+			return nil, err
+		}
+		start += length
+	}
+	err := br[3].init(src[start:])
+	if err != nil {
+		return nil, err
+	}
+
+	// destination, offset to match first output
+	dstSize := cap(dst)
+	dst = dst[:dstSize]
+	out := dst
+	dstEvery := (dstSize + 3) / 4
+
+	const tlSize = 1 << tableLogMax
+	const tlMask = tlSize - 1
+	single := d.dt.single[:tlSize]
+
+	var decoded int
+
+	if len(out) > 4*4 && !(br[0].off < 4 || br[1].off < 4 || br[2].off < 4 || br[3].off < 4) {
+		ctx := decompress4xContext{
+			pbr:      &br,
+			peekBits: uint8((64 - d.actualTableLog) & 63), // see: bitReaderShifted.peekBitsFast()
+			out:      &out[0],
+			dstEvery: dstEvery,
+			tbl:      &single[0],
+			limit:    &out[dstEvery-4], // Always stop decoding when first buffer gets here to avoid writing OOB on last.
+		}
+		if use8BitTables {
+			decompress4x_8b_main_loop_amd64(&ctx)
+		} else {
+			decompress4x_main_loop_amd64(&ctx)
+		}
+
+		decoded = ctx.decoded
+		out = out[decoded/4:]
+	}
+
+	// Decode remaining.
+	remainBytes := dstEvery - (decoded / 4)
+	for i := range br {
+		offset := dstEvery * i
+		endsAt := offset + remainBytes
+		if endsAt > len(out) {
+			endsAt = len(out)
+		}
+		br := &br[i]
+		bitsLeft := br.remaining()
+		for bitsLeft > 0 {
+			br.fill()
+			if offset >= endsAt {
+				return nil, errors.New("corruption detected: stream overrun 4")
+			}
+
+			// Read value and increment offset.
+			val := br.peekBitsFast(d.actualTableLog)
+			v := single[val&tlMask].entry
+			nBits := uint8(v)
+			br.advance(nBits)
+			bitsLeft -= uint(nBits)
+			out[offset] = uint8(v >> 8)
+			offset++
+		}
+		if offset != endsAt {
+			return nil, fmt.Errorf("corruption detected: short output block %d, end %d != %d", i, offset, endsAt)
+		}
+		decoded += offset - dstEvery*i
+		err = br.close()
+		if err != nil {
+			return nil, err
+		}
+	}
+	if dstSize != decoded {
+		return nil, errors.New("corruption detected: short output block")
+	}
+	return dst, nil
+}
+
+// decompress4x_main_loop_x86 is an x86 assembler implementation
+// of Decompress1X when tablelog > 8.
+//
+//go:noescape
+func decompress1x_main_loop_amd64(ctx *decompress1xContext)
+
+// decompress4x_main_loop_x86 is an x86 with BMI2 assembler implementation
+// of Decompress1X when tablelog > 8.
+//
+//go:noescape
+func decompress1x_main_loop_bmi2(ctx *decompress1xContext)
+
+type decompress1xContext struct {
+	pbr      *bitReaderShifted
+	peekBits uint8
+	out      *byte
+	outCap   int
+	tbl      *dEntrySingle
+	decoded  int
+}
+
+// Error reported by asm implementations
+const error_max_decoded_size_exeeded = -1
+
+// Decompress1X will decompress a 1X encoded stream.
+// The cap of the output buffer will be the maximum decompressed size.
+// The length of the supplied input must match the end of a block exactly.
+func (d *Decoder) Decompress1X(dst, src []byte) ([]byte, error) {
+	if len(d.dt.single) == 0 {
+		return nil, errors.New("no table loaded")
+	}
+	var br bitReaderShifted
+	err := br.init(src)
+	if err != nil {
+		return dst, err
+	}
+	maxDecodedSize := cap(dst)
+	dst = dst[:maxDecodedSize]
+
+	const tlSize = 1 << tableLogMax
+	const tlMask = tlSize - 1
+
+	if maxDecodedSize >= 4 {
+		ctx := decompress1xContext{
+			pbr:      &br,
+			out:      &dst[0],
+			outCap:   maxDecodedSize,
+			peekBits: uint8((64 - d.actualTableLog) & 63), // see: bitReaderShifted.peekBitsFast()
+			tbl:      &d.dt.single[0],
+		}
+
+		if cpuinfo.HasBMI2() {
+			decompress1x_main_loop_bmi2(&ctx)
+		} else {
+			decompress1x_main_loop_amd64(&ctx)
+		}
+		if ctx.decoded == error_max_decoded_size_exeeded {
+			return nil, ErrMaxDecodedSizeExceeded
+		}
+
+		dst = dst[:ctx.decoded]
+	}
+
+	// br < 8, so uint8 is fine
+	bitsLeft := uint8(br.off)*8 + 64 - br.bitsRead
+	for bitsLeft > 0 {
+		br.fill()
+		if len(dst) >= maxDecodedSize {
+			br.close()
+			return nil, ErrMaxDecodedSizeExceeded
+		}
+		v := d.dt.single[br.peekBitsFast(d.actualTableLog)&tlMask]
+		nBits := uint8(v.entry)
+		br.advance(nBits)
+		bitsLeft -= nBits
+		dst = append(dst, uint8(v.entry>>8))
+	}
+	return dst, br.close()
+}
diff --git a/vendor/github.com/klauspost/compress/huff0/decompress_amd64.s b/vendor/github.com/klauspost/compress/huff0/decompress_amd64.s
new file mode 100644
index 00000000..c4c7ab2d
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/huff0/decompress_amd64.s
@@ -0,0 +1,830 @@
+// Code generated by command: go run gen.go -out ../decompress_amd64.s -pkg=huff0. DO NOT EDIT.
+
+//go:build amd64 && !appengine && !noasm && gc
+
+// func decompress4x_main_loop_amd64(ctx *decompress4xContext)
+TEXT ·decompress4x_main_loop_amd64(SB), $0-8
+	// Preload values
+	MOVQ    ctx+0(FP), AX
+	MOVBQZX 8(AX), DI
+	MOVQ    16(AX), BX
+	MOVQ    48(AX), SI
+	MOVQ    24(AX), R8
+	MOVQ    32(AX), R9
+	MOVQ    (AX), R10
+
+	// Main loop
+main_loop:
+	XORL  DX, DX
+	CMPQ  BX, SI
+	SETGE DL
+
+	// br0.fillFast32()
+	MOVQ    32(R10), R11
+	MOVBQZX 40(R10), R12
+	CMPQ    R12, $0x20
+	JBE     skip_fill0
+	MOVQ    24(R10), AX
+	SUBQ    $0x20, R12
+	SUBQ    $0x04, AX
+	MOVQ    (R10), R13
+
+	// b.value |= uint64(low) << (b.bitsRead & 63)
+	MOVL (AX)(R13*1), R13
+	MOVQ R12, CX
+	SHLQ CL, R13
+	MOVQ AX, 24(R10)
+	ORQ  R13, R11
+
+	// exhausted += (br0.off < 4)
+	CMPQ AX, $0x04
+	ADCB $+0, DL
+
+skip_fill0:
+	// val0 := br0.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v0 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br0.advance(uint8(v0.entry)
+	MOVB CH, AL
+	SHLQ CL, R11
+	ADDB CL, R12
+
+	// val1 := br0.peekTopBits(peekBits)
+	MOVQ DI, CX
+	MOVQ R11, R13
+	SHRQ CL, R13
+
+	// v1 := table[val1&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br0.advance(uint8(v1.entry))
+	MOVB CH, AH
+	SHLQ CL, R11
+	ADDB CL, R12
+
+	// these two writes get coalesced
+	// out[id * dstEvery + 0] = uint8(v0.entry >> 8)
+	// out[id * dstEvery + 1] = uint8(v1.entry >> 8)
+	MOVW AX, (BX)
+
+	// update the bitreader structure
+	MOVQ R11, 32(R10)
+	MOVB R12, 40(R10)
+
+	// br1.fillFast32()
+	MOVQ    80(R10), R11
+	MOVBQZX 88(R10), R12
+	CMPQ    R12, $0x20
+	JBE     skip_fill1
+	MOVQ    72(R10), AX
+	SUBQ    $0x20, R12
+	SUBQ    $0x04, AX
+	MOVQ    48(R10), R13
+
+	// b.value |= uint64(low) << (b.bitsRead & 63)
+	MOVL (AX)(R13*1), R13
+	MOVQ R12, CX
+	SHLQ CL, R13
+	MOVQ AX, 72(R10)
+	ORQ  R13, R11
+
+	// exhausted += (br1.off < 4)
+	CMPQ AX, $0x04
+	ADCB $+0, DL
+
+skip_fill1:
+	// val0 := br1.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v0 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br1.advance(uint8(v0.entry)
+	MOVB CH, AL
+	SHLQ CL, R11
+	ADDB CL, R12
+
+	// val1 := br1.peekTopBits(peekBits)
+	MOVQ DI, CX
+	MOVQ R11, R13
+	SHRQ CL, R13
+
+	// v1 := table[val1&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br1.advance(uint8(v1.entry))
+	MOVB CH, AH
+	SHLQ CL, R11
+	ADDB CL, R12
+
+	// these two writes get coalesced
+	// out[id * dstEvery + 0] = uint8(v0.entry >> 8)
+	// out[id * dstEvery + 1] = uint8(v1.entry >> 8)
+	MOVW AX, (BX)(R8*1)
+
+	// update the bitreader structure
+	MOVQ R11, 80(R10)
+	MOVB R12, 88(R10)
+
+	// br2.fillFast32()
+	MOVQ    128(R10), R11
+	MOVBQZX 136(R10), R12
+	CMPQ    R12, $0x20
+	JBE     skip_fill2
+	MOVQ    120(R10), AX
+	SUBQ    $0x20, R12
+	SUBQ    $0x04, AX
+	MOVQ    96(R10), R13
+
+	// b.value |= uint64(low) << (b.bitsRead & 63)
+	MOVL (AX)(R13*1), R13
+	MOVQ R12, CX
+	SHLQ CL, R13
+	MOVQ AX, 120(R10)
+	ORQ  R13, R11
+
+	// exhausted += (br2.off < 4)
+	CMPQ AX, $0x04
+	ADCB $+0, DL
+
+skip_fill2:
+	// val0 := br2.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v0 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br2.advance(uint8(v0.entry)
+	MOVB CH, AL
+	SHLQ CL, R11
+	ADDB CL, R12
+
+	// val1 := br2.peekTopBits(peekBits)
+	MOVQ DI, CX
+	MOVQ R11, R13
+	SHRQ CL, R13
+
+	// v1 := table[val1&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br2.advance(uint8(v1.entry))
+	MOVB CH, AH
+	SHLQ CL, R11
+	ADDB CL, R12
+
+	// these two writes get coalesced
+	// out[id * dstEvery + 0] = uint8(v0.entry >> 8)
+	// out[id * dstEvery + 1] = uint8(v1.entry >> 8)
+	MOVW AX, (BX)(R8*2)
+
+	// update the bitreader structure
+	MOVQ R11, 128(R10)
+	MOVB R12, 136(R10)
+
+	// br3.fillFast32()
+	MOVQ    176(R10), R11
+	MOVBQZX 184(R10), R12
+	CMPQ    R12, $0x20
+	JBE     skip_fill3
+	MOVQ    168(R10), AX
+	SUBQ    $0x20, R12
+	SUBQ    $0x04, AX
+	MOVQ    144(R10), R13
+
+	// b.value |= uint64(low) << (b.bitsRead & 63)
+	MOVL (AX)(R13*1), R13
+	MOVQ R12, CX
+	SHLQ CL, R13
+	MOVQ AX, 168(R10)
+	ORQ  R13, R11
+
+	// exhausted += (br3.off < 4)
+	CMPQ AX, $0x04
+	ADCB $+0, DL
+
+skip_fill3:
+	// val0 := br3.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v0 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br3.advance(uint8(v0.entry)
+	MOVB CH, AL
+	SHLQ CL, R11
+	ADDB CL, R12
+
+	// val1 := br3.peekTopBits(peekBits)
+	MOVQ DI, CX
+	MOVQ R11, R13
+	SHRQ CL, R13
+
+	// v1 := table[val1&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br3.advance(uint8(v1.entry))
+	MOVB CH, AH
+	SHLQ CL, R11
+	ADDB CL, R12
+
+	// these two writes get coalesced
+	// out[id * dstEvery + 0] = uint8(v0.entry >> 8)
+	// out[id * dstEvery + 1] = uint8(v1.entry >> 8)
+	LEAQ (R8)(R8*2), CX
+	MOVW AX, (BX)(CX*1)
+
+	// update the bitreader structure
+	MOVQ  R11, 176(R10)
+	MOVB  R12, 184(R10)
+	ADDQ  $0x02, BX
+	TESTB DL, DL
+	JZ    main_loop
+	MOVQ  ctx+0(FP), AX
+	SUBQ  16(AX), BX
+	SHLQ  $0x02, BX
+	MOVQ  BX, 40(AX)
+	RET
+
+// func decompress4x_8b_main_loop_amd64(ctx *decompress4xContext)
+TEXT ·decompress4x_8b_main_loop_amd64(SB), $0-8
+	// Preload values
+	MOVQ    ctx+0(FP), CX
+	MOVBQZX 8(CX), DI
+	MOVQ    16(CX), BX
+	MOVQ    48(CX), SI
+	MOVQ    24(CX), R8
+	MOVQ    32(CX), R9
+	MOVQ    (CX), R10
+
+	// Main loop
+main_loop:
+	XORL  DX, DX
+	CMPQ  BX, SI
+	SETGE DL
+
+	// br0.fillFast32()
+	MOVQ    32(R10), R11
+	MOVBQZX 40(R10), R12
+	CMPQ    R12, $0x20
+	JBE     skip_fill0
+	MOVQ    24(R10), R13
+	SUBQ    $0x20, R12
+	SUBQ    $0x04, R13
+	MOVQ    (R10), R14
+
+	// b.value |= uint64(low) << (b.bitsRead & 63)
+	MOVL (R13)(R14*1), R14
+	MOVQ R12, CX
+	SHLQ CL, R14
+	MOVQ R13, 24(R10)
+	ORQ  R14, R11
+
+	// exhausted += (br0.off < 4)
+	CMPQ R13, $0x04
+	ADCB $+0, DL
+
+skip_fill0:
+	// val0 := br0.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v0 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br0.advance(uint8(v0.entry)
+	MOVB CH, AL
+	SHLQ CL, R11
+	ADDB CL, R12
+
+	// val1 := br0.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v1 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br0.advance(uint8(v1.entry)
+	MOVB   CH, AH
+	SHLQ   CL, R11
+	ADDB   CL, R12
+	BSWAPL AX
+
+	// val2 := br0.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v2 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br0.advance(uint8(v2.entry)
+	MOVB CH, AH
+	SHLQ CL, R11
+	ADDB CL, R12
+
+	// val3 := br0.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v3 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br0.advance(uint8(v3.entry)
+	MOVB   CH, AL
+	SHLQ   CL, R11
+	ADDB   CL, R12
+	BSWAPL AX
+
+	// these four writes get coalesced
+	// out[id * dstEvery + 0] = uint8(v0.entry >> 8)
+	// out[id * dstEvery + 1] = uint8(v1.entry >> 8)
+	// out[id * dstEvery + 3] = uint8(v2.entry >> 8)
+	// out[id * dstEvery + 4] = uint8(v3.entry >> 8)
+	MOVL AX, (BX)
+
+	// update the bitreader structure
+	MOVQ R11, 32(R10)
+	MOVB R12, 40(R10)
+
+	// br1.fillFast32()
+	MOVQ    80(R10), R11
+	MOVBQZX 88(R10), R12
+	CMPQ    R12, $0x20
+	JBE     skip_fill1
+	MOVQ    72(R10), R13
+	SUBQ    $0x20, R12
+	SUBQ    $0x04, R13
+	MOVQ    48(R10), R14
+
+	// b.value |= uint64(low) << (b.bitsRead & 63)
+	MOVL (R13)(R14*1), R14
+	MOVQ R12, CX
+	SHLQ CL, R14
+	MOVQ R13, 72(R10)
+	ORQ  R14, R11
+
+	// exhausted += (br1.off < 4)
+	CMPQ R13, $0x04
+	ADCB $+0, DL
+
+skip_fill1:
+	// val0 := br1.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v0 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br1.advance(uint8(v0.entry)
+	MOVB CH, AL
+	SHLQ CL, R11
+	ADDB CL, R12
+
+	// val1 := br1.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v1 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br1.advance(uint8(v1.entry)
+	MOVB   CH, AH
+	SHLQ   CL, R11
+	ADDB   CL, R12
+	BSWAPL AX
+
+	// val2 := br1.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v2 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br1.advance(uint8(v2.entry)
+	MOVB CH, AH
+	SHLQ CL, R11
+	ADDB CL, R12
+
+	// val3 := br1.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v3 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br1.advance(uint8(v3.entry)
+	MOVB   CH, AL
+	SHLQ   CL, R11
+	ADDB   CL, R12
+	BSWAPL AX
+
+	// these four writes get coalesced
+	// out[id * dstEvery + 0] = uint8(v0.entry >> 8)
+	// out[id * dstEvery + 1] = uint8(v1.entry >> 8)
+	// out[id * dstEvery + 3] = uint8(v2.entry >> 8)
+	// out[id * dstEvery + 4] = uint8(v3.entry >> 8)
+	MOVL AX, (BX)(R8*1)
+
+	// update the bitreader structure
+	MOVQ R11, 80(R10)
+	MOVB R12, 88(R10)
+
+	// br2.fillFast32()
+	MOVQ    128(R10), R11
+	MOVBQZX 136(R10), R12
+	CMPQ    R12, $0x20
+	JBE     skip_fill2
+	MOVQ    120(R10), R13
+	SUBQ    $0x20, R12
+	SUBQ    $0x04, R13
+	MOVQ    96(R10), R14
+
+	// b.value |= uint64(low) << (b.bitsRead & 63)
+	MOVL (R13)(R14*1), R14
+	MOVQ R12, CX
+	SHLQ CL, R14
+	MOVQ R13, 120(R10)
+	ORQ  R14, R11
+
+	// exhausted += (br2.off < 4)
+	CMPQ R13, $0x04
+	ADCB $+0, DL
+
+skip_fill2:
+	// val0 := br2.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v0 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br2.advance(uint8(v0.entry)
+	MOVB CH, AL
+	SHLQ CL, R11
+	ADDB CL, R12
+
+	// val1 := br2.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v1 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br2.advance(uint8(v1.entry)
+	MOVB   CH, AH
+	SHLQ   CL, R11
+	ADDB   CL, R12
+	BSWAPL AX
+
+	// val2 := br2.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v2 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br2.advance(uint8(v2.entry)
+	MOVB CH, AH
+	SHLQ CL, R11
+	ADDB CL, R12
+
+	// val3 := br2.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v3 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br2.advance(uint8(v3.entry)
+	MOVB   CH, AL
+	SHLQ   CL, R11
+	ADDB   CL, R12
+	BSWAPL AX
+
+	// these four writes get coalesced
+	// out[id * dstEvery + 0] = uint8(v0.entry >> 8)
+	// out[id * dstEvery + 1] = uint8(v1.entry >> 8)
+	// out[id * dstEvery + 3] = uint8(v2.entry >> 8)
+	// out[id * dstEvery + 4] = uint8(v3.entry >> 8)
+	MOVL AX, (BX)(R8*2)
+
+	// update the bitreader structure
+	MOVQ R11, 128(R10)
+	MOVB R12, 136(R10)
+
+	// br3.fillFast32()
+	MOVQ    176(R10), R11
+	MOVBQZX 184(R10), R12
+	CMPQ    R12, $0x20
+	JBE     skip_fill3
+	MOVQ    168(R10), R13
+	SUBQ    $0x20, R12
+	SUBQ    $0x04, R13
+	MOVQ    144(R10), R14
+
+	// b.value |= uint64(low) << (b.bitsRead & 63)
+	MOVL (R13)(R14*1), R14
+	MOVQ R12, CX
+	SHLQ CL, R14
+	MOVQ R13, 168(R10)
+	ORQ  R14, R11
+
+	// exhausted += (br3.off < 4)
+	CMPQ R13, $0x04
+	ADCB $+0, DL
+
+skip_fill3:
+	// val0 := br3.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v0 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br3.advance(uint8(v0.entry)
+	MOVB CH, AL
+	SHLQ CL, R11
+	ADDB CL, R12
+
+	// val1 := br3.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v1 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br3.advance(uint8(v1.entry)
+	MOVB   CH, AH
+	SHLQ   CL, R11
+	ADDB   CL, R12
+	BSWAPL AX
+
+	// val2 := br3.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v2 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br3.advance(uint8(v2.entry)
+	MOVB CH, AH
+	SHLQ CL, R11
+	ADDB CL, R12
+
+	// val3 := br3.peekTopBits(peekBits)
+	MOVQ R11, R13
+	MOVQ DI, CX
+	SHRQ CL, R13
+
+	// v3 := table[val0&mask]
+	MOVW (R9)(R13*2), CX
+
+	// br3.advance(uint8(v3.entry)
+	MOVB   CH, AL
+	SHLQ   CL, R11
+	ADDB   CL, R12
+	BSWAPL AX
+
+	// these four writes get coalesced
+	// out[id * dstEvery + 0] = uint8(v0.entry >> 8)
+	// out[id * dstEvery + 1] = uint8(v1.entry >> 8)
+	// out[id * dstEvery + 3] = uint8(v2.entry >> 8)
+	// out[id * dstEvery + 4] = uint8(v3.entry >> 8)
+	LEAQ (R8)(R8*2), CX
+	MOVL AX, (BX)(CX*1)
+
+	// update the bitreader structure
+	MOVQ  R11, 176(R10)
+	MOVB  R12, 184(R10)
+	ADDQ  $0x04, BX
+	TESTB DL, DL
+	JZ    main_loop
+	MOVQ  ctx+0(FP), AX
+	SUBQ  16(AX), BX
+	SHLQ  $0x02, BX
+	MOVQ  BX, 40(AX)
+	RET
+
+// func decompress1x_main_loop_amd64(ctx *decompress1xContext)
+TEXT ·decompress1x_main_loop_amd64(SB), $0-8
+	MOVQ    ctx+0(FP), CX
+	MOVQ    16(CX), DX
+	MOVQ    24(CX), BX
+	CMPQ    BX, $0x04
+	JB      error_max_decoded_size_exceeded
+	LEAQ    (DX)(BX*1), BX
+	MOVQ    (CX), SI
+	MOVQ    (SI), R8
+	MOVQ    24(SI), R9
+	MOVQ    32(SI), R10
+	MOVBQZX 40(SI), R11
+	MOVQ    32(CX), SI
+	MOVBQZX 8(CX), DI
+	JMP     loop_condition
+
+main_loop:
+	// Check if we have room for 4 bytes in the output buffer
+	LEAQ 4(DX), CX
+	CMPQ CX, BX
+	JGE  error_max_decoded_size_exceeded
+
+	// Decode 4 values
+	CMPQ R11, $0x20
+	JL   bitReader_fillFast_1_end
+	SUBQ $0x20, R11
+	SUBQ $0x04, R9
+	MOVL (R8)(R9*1), R12
+	MOVQ R11, CX
+	SHLQ CL, R12
+	ORQ  R12, R10
+
+bitReader_fillFast_1_end:
+	MOVQ    DI, CX
+	MOVQ    R10, R12
+	SHRQ    CL, R12
+	MOVW    (SI)(R12*2), CX
+	MOVB    CH, AL
+	MOVBQZX CL, CX
+	ADDQ    CX, R11
+	SHLQ    CL, R10
+	MOVQ    DI, CX
+	MOVQ    R10, R12
+	SHRQ    CL, R12
+	MOVW    (SI)(R12*2), CX
+	MOVB    CH, AH
+	MOVBQZX CL, CX
+	ADDQ    CX, R11
+	SHLQ    CL, R10
+	BSWAPL  AX
+	CMPQ    R11, $0x20
+	JL      bitReader_fillFast_2_end
+	SUBQ    $0x20, R11
+	SUBQ    $0x04, R9
+	MOVL    (R8)(R9*1), R12
+	MOVQ    R11, CX
+	SHLQ    CL, R12
+	ORQ     R12, R10
+
+bitReader_fillFast_2_end:
+	MOVQ    DI, CX
+	MOVQ    R10, R12
+	SHRQ    CL, R12
+	MOVW    (SI)(R12*2), CX
+	MOVB    CH, AH
+	MOVBQZX CL, CX
+	ADDQ    CX, R11
+	SHLQ    CL, R10
+	MOVQ    DI, CX
+	MOVQ    R10, R12
+	SHRQ    CL, R12
+	MOVW    (SI)(R12*2), CX
+	MOVB    CH, AL
+	MOVBQZX CL, CX
+	ADDQ    CX, R11
+	SHLQ    CL, R10
+	BSWAPL  AX
+
+	// Store the decoded values
+	MOVL AX, (DX)
+	ADDQ $0x04, DX
+
+loop_condition:
+	CMPQ R9, $0x08
+	JGE  main_loop
+
+	// Update ctx structure
+	MOVQ ctx+0(FP), AX
+	SUBQ 16(AX), DX
+	MOVQ DX, 40(AX)
+	MOVQ (AX), AX
+	MOVQ R9, 24(AX)
+	MOVQ R10, 32(AX)
+	MOVB R11, 40(AX)
+	RET
+
+	// Report error
+error_max_decoded_size_exceeded:
+	MOVQ ctx+0(FP), AX
+	MOVQ $-1, CX
+	MOVQ CX, 40(AX)
+	RET
+
+// func decompress1x_main_loop_bmi2(ctx *decompress1xContext)
+// Requires: BMI2
+TEXT ·decompress1x_main_loop_bmi2(SB), $0-8
+	MOVQ    ctx+0(FP), CX
+	MOVQ    16(CX), DX
+	MOVQ    24(CX), BX
+	CMPQ    BX, $0x04
+	JB      error_max_decoded_size_exceeded
+	LEAQ    (DX)(BX*1), BX
+	MOVQ    (CX), SI
+	MOVQ    (SI), R8
+	MOVQ    24(SI), R9
+	MOVQ    32(SI), R10
+	MOVBQZX 40(SI), R11
+	MOVQ    32(CX), SI
+	MOVBQZX 8(CX), DI
+	JMP     loop_condition
+
+main_loop:
+	// Check if we have room for 4 bytes in the output buffer
+	LEAQ 4(DX), CX
+	CMPQ CX, BX
+	JGE  error_max_decoded_size_exceeded
+
+	// Decode 4 values
+	CMPQ  R11, $0x20
+	JL    bitReader_fillFast_1_end
+	SUBQ  $0x20, R11
+	SUBQ  $0x04, R9
+	MOVL  (R8)(R9*1), CX
+	SHLXQ R11, CX, CX
+	ORQ   CX, R10
+
+bitReader_fillFast_1_end:
+	SHRXQ   DI, R10, CX
+	MOVW    (SI)(CX*2), CX
+	MOVB    CH, AL
+	MOVBQZX CL, CX
+	ADDQ    CX, R11
+	SHLXQ   CX, R10, R10
+	SHRXQ   DI, R10, CX
+	MOVW    (SI)(CX*2), CX
+	MOVB    CH, AH
+	MOVBQZX CL, CX
+	ADDQ    CX, R11
+	SHLXQ   CX, R10, R10
+	BSWAPL  AX
+	CMPQ    R11, $0x20
+	JL      bitReader_fillFast_2_end
+	SUBQ    $0x20, R11
+	SUBQ    $0x04, R9
+	MOVL    (R8)(R9*1), CX
+	SHLXQ   R11, CX, CX
+	ORQ     CX, R10
+
+bitReader_fillFast_2_end:
+	SHRXQ   DI, R10, CX
+	MOVW    (SI)(CX*2), CX
+	MOVB    CH, AH
+	MOVBQZX CL, CX
+	ADDQ    CX, R11
+	SHLXQ   CX, R10, R10
+	SHRXQ   DI, R10, CX
+	MOVW    (SI)(CX*2), CX
+	MOVB    CH, AL
+	MOVBQZX CL, CX
+	ADDQ    CX, R11
+	SHLXQ   CX, R10, R10
+	BSWAPL  AX
+
+	// Store the decoded values
+	MOVL AX, (DX)
+	ADDQ $0x04, DX
+
+loop_condition:
+	CMPQ R9, $0x08
+	JGE  main_loop
+
+	// Update ctx structure
+	MOVQ ctx+0(FP), AX
+	SUBQ 16(AX), DX
+	MOVQ DX, 40(AX)
+	MOVQ (AX), AX
+	MOVQ R9, 24(AX)
+	MOVQ R10, 32(AX)
+	MOVB R11, 40(AX)
+	RET
+
+	// Report error
+error_max_decoded_size_exceeded:
+	MOVQ ctx+0(FP), AX
+	MOVQ $-1, CX
+	MOVQ CX, 40(AX)
+	RET
diff --git a/vendor/github.com/klauspost/compress/huff0/decompress_generic.go b/vendor/github.com/klauspost/compress/huff0/decompress_generic.go
new file mode 100644
index 00000000..908c17de
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/huff0/decompress_generic.go
@@ -0,0 +1,299 @@
+//go:build !amd64 || appengine || !gc || noasm
+// +build !amd64 appengine !gc noasm
+
+// This file contains a generic implementation of Decoder.Decompress4X.
+package huff0
+
+import (
+	"errors"
+	"fmt"
+)
+
+// Decompress4X will decompress a 4X encoded stream.
+// The length of the supplied input must match the end of a block exactly.
+// The *capacity* of the dst slice must match the destination size of
+// the uncompressed data exactly.
+func (d *Decoder) Decompress4X(dst, src []byte) ([]byte, error) {
+	if len(d.dt.single) == 0 {
+		return nil, errors.New("no table loaded")
+	}
+	if len(src) < 6+(4*1) {
+		return nil, errors.New("input too small")
+	}
+	if use8BitTables && d.actualTableLog <= 8 {
+		return d.decompress4X8bit(dst, src)
+	}
+
+	var br [4]bitReaderShifted
+	// Decode "jump table"
+	start := 6
+	for i := 0; i < 3; i++ {
+		length := int(src[i*2]) | (int(src[i*2+1]) << 8)
+		if start+length >= len(src) {
+			return nil, errors.New("truncated input (or invalid offset)")
+		}
+		err := br[i].init(src[start : start+length])
+		if err != nil {
+			return nil, err
+		}
+		start += length
+	}
+	err := br[3].init(src[start:])
+	if err != nil {
+		return nil, err
+	}
+
+	// destination, offset to match first output
+	dstSize := cap(dst)
+	dst = dst[:dstSize]
+	out := dst
+	dstEvery := (dstSize + 3) / 4
+
+	const tlSize = 1 << tableLogMax
+	const tlMask = tlSize - 1
+	single := d.dt.single[:tlSize]
+
+	// Use temp table to avoid bound checks/append penalty.
+	buf := d.buffer()
+	var off uint8
+	var decoded int
+
+	// Decode 2 values from each decoder/loop.
+	const bufoff = 256
+	for {
+		if br[0].off < 4 || br[1].off < 4 || br[2].off < 4 || br[3].off < 4 {
+			break
+		}
+
+		{
+			const stream = 0
+			const stream2 = 1
+			br[stream].fillFast()
+			br[stream2].fillFast()
+
+			val := br[stream].peekBitsFast(d.actualTableLog)
+			val2 := br[stream2].peekBitsFast(d.actualTableLog)
+			v := single[val&tlMask]
+			v2 := single[val2&tlMask]
+			br[stream].advance(uint8(v.entry))
+			br[stream2].advance(uint8(v2.entry))
+			buf[stream][off] = uint8(v.entry >> 8)
+			buf[stream2][off] = uint8(v2.entry >> 8)
+
+			val = br[stream].peekBitsFast(d.actualTableLog)
+			val2 = br[stream2].peekBitsFast(d.actualTableLog)
+			v = single[val&tlMask]
+			v2 = single[val2&tlMask]
+			br[stream].advance(uint8(v.entry))
+			br[stream2].advance(uint8(v2.entry))
+			buf[stream][off+1] = uint8(v.entry >> 8)
+			buf[stream2][off+1] = uint8(v2.entry >> 8)
+		}
+
+		{
+			const stream = 2
+			const stream2 = 3
+			br[stream].fillFast()
+			br[stream2].fillFast()
+
+			val := br[stream].peekBitsFast(d.actualTableLog)
+			val2 := br[stream2].peekBitsFast(d.actualTableLog)
+			v := single[val&tlMask]
+			v2 := single[val2&tlMask]
+			br[stream].advance(uint8(v.entry))
+			br[stream2].advance(uint8(v2.entry))
+			buf[stream][off] = uint8(v.entry >> 8)
+			buf[stream2][off] = uint8(v2.entry >> 8)
+
+			val = br[stream].peekBitsFast(d.actualTableLog)
+			val2 = br[stream2].peekBitsFast(d.actualTableLog)
+			v = single[val&tlMask]
+			v2 = single[val2&tlMask]
+			br[stream].advance(uint8(v.entry))
+			br[stream2].advance(uint8(v2.entry))
+			buf[stream][off+1] = uint8(v.entry >> 8)
+			buf[stream2][off+1] = uint8(v2.entry >> 8)
+		}
+
+		off += 2
+
+		if off == 0 {
+			if bufoff > dstEvery {
+				d.bufs.Put(buf)
+				return nil, errors.New("corruption detected: stream overrun 1")
+			}
+			// There must at least be 3 buffers left.
+			if len(out)-bufoff < dstEvery*3 {
+				d.bufs.Put(buf)
+				return nil, errors.New("corruption detected: stream overrun 2")
+			}
+			//copy(out, buf[0][:])
+			//copy(out[dstEvery:], buf[1][:])
+			//copy(out[dstEvery*2:], buf[2][:])
+			//copy(out[dstEvery*3:], buf[3][:])
+			*(*[bufoff]byte)(out) = buf[0]
+			*(*[bufoff]byte)(out[dstEvery:]) = buf[1]
+			*(*[bufoff]byte)(out[dstEvery*2:]) = buf[2]
+			*(*[bufoff]byte)(out[dstEvery*3:]) = buf[3]
+			out = out[bufoff:]
+			decoded += bufoff * 4
+		}
+	}
+	if off > 0 {
+		ioff := int(off)
+		if len(out) < dstEvery*3+ioff {
+			d.bufs.Put(buf)
+			return nil, errors.New("corruption detected: stream overrun 3")
+		}
+		copy(out, buf[0][:off])
+		copy(out[dstEvery:], buf[1][:off])
+		copy(out[dstEvery*2:], buf[2][:off])
+		copy(out[dstEvery*3:], buf[3][:off])
+		decoded += int(off) * 4
+		out = out[off:]
+	}
+
+	// Decode remaining.
+	remainBytes := dstEvery - (decoded / 4)
+	for i := range br {
+		offset := dstEvery * i
+		endsAt := offset + remainBytes
+		if endsAt > len(out) {
+			endsAt = len(out)
+		}
+		br := &br[i]
+		bitsLeft := br.remaining()
+		for bitsLeft > 0 {
+			br.fill()
+			if offset >= endsAt {
+				d.bufs.Put(buf)
+				return nil, errors.New("corruption detected: stream overrun 4")
+			}
+
+			// Read value and increment offset.
+			val := br.peekBitsFast(d.actualTableLog)
+			v := single[val&tlMask].entry
+			nBits := uint8(v)
+			br.advance(nBits)
+			bitsLeft -= uint(nBits)
+			out[offset] = uint8(v >> 8)
+			offset++
+		}
+		if offset != endsAt {
+			d.bufs.Put(buf)
+			return nil, fmt.Errorf("corruption detected: short output block %d, end %d != %d", i, offset, endsAt)
+		}
+		decoded += offset - dstEvery*i
+		err = br.close()
+		if err != nil {
+			return nil, err
+		}
+	}
+	d.bufs.Put(buf)
+	if dstSize != decoded {
+		return nil, errors.New("corruption detected: short output block")
+	}
+	return dst, nil
+}
+
+// Decompress1X will decompress a 1X encoded stream.
+// The cap of the output buffer will be the maximum decompressed size.
+// The length of the supplied input must match the end of a block exactly.
+func (d *Decoder) Decompress1X(dst, src []byte) ([]byte, error) {
+	if len(d.dt.single) == 0 {
+		return nil, errors.New("no table loaded")
+	}
+	if use8BitTables && d.actualTableLog <= 8 {
+		return d.decompress1X8Bit(dst, src)
+	}
+	var br bitReaderShifted
+	err := br.init(src)
+	if err != nil {
+		return dst, err
+	}
+	maxDecodedSize := cap(dst)
+	dst = dst[:0]
+
+	// Avoid bounds check by always having full sized table.
+	const tlSize = 1 << tableLogMax
+	const tlMask = tlSize - 1
+	dt := d.dt.single[:tlSize]
+
+	// Use temp table to avoid bound checks/append penalty.
+	bufs := d.buffer()
+	buf := &bufs[0]
+	var off uint8
+
+	for br.off >= 8 {
+		br.fillFast()
+		v := dt[br.peekBitsFast(d.actualTableLog)&tlMask]
+		br.advance(uint8(v.entry))
+		buf[off+0] = uint8(v.entry >> 8)
+
+		v = dt[br.peekBitsFast(d.actualTableLog)&tlMask]
+		br.advance(uint8(v.entry))
+		buf[off+1] = uint8(v.entry >> 8)
+
+		// Refill
+		br.fillFast()
+
+		v = dt[br.peekBitsFast(d.actualTableLog)&tlMask]
+		br.advance(uint8(v.entry))
+		buf[off+2] = uint8(v.entry >> 8)
+
+		v = dt[br.peekBitsFast(d.actualTableLog)&tlMask]
+		br.advance(uint8(v.entry))
+		buf[off+3] = uint8(v.entry >> 8)
+
+		off += 4
+		if off == 0 {
+			if len(dst)+256 > maxDecodedSize {
+				br.close()
+				d.bufs.Put(bufs)
+				return nil, ErrMaxDecodedSizeExceeded
+			}
+			dst = append(dst, buf[:]...)
+		}
+	}
+
+	if len(dst)+int(off) > maxDecodedSize {
+		d.bufs.Put(bufs)
+		br.close()
+		return nil, ErrMaxDecodedSizeExceeded
+	}
+	dst = append(dst, buf[:off]...)
+
+	// br < 8, so uint8 is fine
+	bitsLeft := uint8(br.off)*8 + 64 - br.bitsRead
+	for bitsLeft > 0 {
+		br.fill()
+		if false && br.bitsRead >= 32 {
+			if br.off >= 4 {
+				v := br.in[br.off-4:]
+				v = v[:4]
+				low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
+				br.value = (br.value << 32) | uint64(low)
+				br.bitsRead -= 32
+				br.off -= 4
+			} else {
+				for br.off > 0 {
+					br.value = (br.value << 8) | uint64(br.in[br.off-1])
+					br.bitsRead -= 8
+					br.off--
+				}
+			}
+		}
+		if len(dst) >= maxDecodedSize {
+			d.bufs.Put(bufs)
+			br.close()
+			return nil, ErrMaxDecodedSizeExceeded
+		}
+		v := d.dt.single[br.peekBitsFast(d.actualTableLog)&tlMask]
+		nBits := uint8(v.entry)
+		br.advance(nBits)
+		bitsLeft -= nBits
+		dst = append(dst, uint8(v.entry>>8))
+	}
+	d.bufs.Put(bufs)
+	return dst, br.close()
+}
diff --git a/vendor/github.com/klauspost/compress/huff0/huff0.go b/vendor/github.com/klauspost/compress/huff0/huff0.go
index 3ee00ecb..e8ad17ad 100644
--- a/vendor/github.com/klauspost/compress/huff0/huff0.go
+++ b/vendor/github.com/klauspost/compress/huff0/huff0.go
@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"math"
 	"math/bits"
+	"sync"
 
 	"github.com/klauspost/compress/fse"
 )
@@ -116,6 +117,7 @@ type Scratch struct {
 	nodes          []nodeElt
 	tmpOut         [4][]byte
 	fse            *fse.Scratch
+	decPool        sync.Pool // *[4][256]byte buffers.
 	huffWeight     [maxSymbolValue + 1]byte
 }
 
diff --git a/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo.go b/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo.go
new file mode 100644
index 00000000..3954c512
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo.go
@@ -0,0 +1,34 @@
+// Package cpuinfo gives runtime info about the current CPU.
+//
+// This is a very limited module meant for use internally
+// in this project. For more versatile solution check
+// https://github.com/klauspost/cpuid.
+package cpuinfo
+
+// HasBMI1 checks whether an x86 CPU supports the BMI1 extension.
+func HasBMI1() bool {
+	return hasBMI1
+}
+
+// HasBMI2 checks whether an x86 CPU supports the BMI2 extension.
+func HasBMI2() bool {
+	return hasBMI2
+}
+
+// DisableBMI2 will disable BMI2, for testing purposes.
+// Call returned function to restore previous state.
+func DisableBMI2() func() {
+	old := hasBMI2
+	hasBMI2 = false
+	return func() {
+		hasBMI2 = old
+	}
+}
+
+// HasBMI checks whether an x86 CPU supports both BMI1 and BMI2 extensions.
+func HasBMI() bool {
+	return HasBMI1() && HasBMI2()
+}
+
+var hasBMI1 bool
+var hasBMI2 bool
diff --git a/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.go b/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.go
new file mode 100644
index 00000000..e802579c
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.go
@@ -0,0 +1,11 @@
+//go:build amd64 && !appengine && !noasm && gc
+// +build amd64,!appengine,!noasm,gc
+
+package cpuinfo
+
+// go:noescape
+func x86extensions() (bmi1, bmi2 bool)
+
+func init() {
+	hasBMI1, hasBMI2 = x86extensions()
+}
diff --git a/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.s b/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.s
new file mode 100644
index 00000000..4465fbe9
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.s
@@ -0,0 +1,36 @@
+// +build !appengine
+// +build gc
+// +build !noasm
+
+#include "textflag.h"
+#include "funcdata.h"
+#include "go_asm.h"
+
+TEXT ·x86extensions(SB), NOSPLIT, $0
+	// 1. determine max EAX value
+	XORQ AX, AX
+	CPUID
+
+	CMPQ AX, $7
+	JB   unsupported
+
+	// 2. EAX = 7, ECX = 0 --- see Table 3-8 "Information Returned by CPUID Instruction"
+	MOVQ $7, AX
+	MOVQ $0, CX
+	CPUID
+
+	BTQ   $3, BX // bit 3 = BMI1
+	SETCS AL
+
+	BTQ   $8, BX // bit 8 = BMI2
+	SETCS AH
+
+	MOVB AL, bmi1+0(FP)
+	MOVB AH, bmi2+1(FP)
+	RET
+
+unsupported:
+	XORQ AX, AX
+	MOVB AL, bmi1+0(FP)
+	MOVB AL, bmi2+1(FP)
+	RET
diff --git a/vendor/github.com/klauspost/compress/internal/snapref/encode_other.go b/vendor/github.com/klauspost/compress/internal/snapref/encode_other.go
index 511bba65..2aa6a95a 100644
--- a/vendor/github.com/klauspost/compress/internal/snapref/encode_other.go
+++ b/vendor/github.com/klauspost/compress/internal/snapref/encode_other.go
@@ -18,6 +18,7 @@ func load64(b []byte, i int) uint64 {
 // emitLiteral writes a literal chunk and returns the number of bytes written.
 //
 // It assumes that:
+//
 //	dst is long enough to hold the encoded bytes
 //	1 <= len(lit) && len(lit) <= 65536
 func emitLiteral(dst, lit []byte) int {
@@ -42,6 +43,7 @@ func emitLiteral(dst, lit []byte) int {
 // emitCopy writes a copy chunk and returns the number of bytes written.
 //
 // It assumes that:
+//
 //	dst is long enough to hold the encoded bytes
 //	1 <= offset && offset <= 65535
 //	4 <= length && length <= 65535
@@ -85,28 +87,40 @@ func emitCopy(dst []byte, offset, length int) int {
 	return i + 2
 }
 
-// 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 {
-	for ; j < len(src) && src[i] == src[j]; i, j = i+1, j+1 {
-	}
-	return j
-}
-
 func hash(u, shift uint32) uint32 {
 	return (u * 0x1e35a7bd) >> shift
 }
 
+// EncodeBlockInto exposes encodeBlock but checks dst size.
+func EncodeBlockInto(dst, src []byte) (d int) {
+	if MaxEncodedLen(len(src)) > len(dst) {
+		return 0
+	}
+
+	// encodeBlock breaks on too big blocks, so split.
+	for len(src) > 0 {
+		p := src
+		src = nil
+		if len(p) > maxBlockSize {
+			p, src = p[:maxBlockSize], p[maxBlockSize:]
+		}
+		if len(p) < minNonLiteralBlockSize {
+			d += emitLiteral(dst[d:], p)
+		} else {
+			d += encodeBlock(dst[d:], p)
+		}
+	}
+	return d
+}
+
 // encodeBlock encodes a non-empty src to a guaranteed-large-enough dst. It
 // assumes that the varint-encoded length of the decompressed bytes has already
 // been written.
 //
 // It also assumes that:
+//
 //	len(dst) >= MaxEncodedLen(len(src)) &&
-// 	minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSize
+//	minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSize
 func encodeBlock(dst, src []byte) (d int) {
 	// Initialize the hash table. Its size ranges from 1<<8 to 1<<14 inclusive.
 	// The table element type is uint16, as s < sLimit and sLimit < len(src)
diff --git a/vendor/github.com/klauspost/compress/zstd/README.md b/vendor/github.com/klauspost/compress/zstd/README.md
index c8f0f16f..bdd49c8b 100644
--- a/vendor/github.com/klauspost/compress/zstd/README.md
+++ b/vendor/github.com/klauspost/compress/zstd/README.md
@@ -12,6 +12,8 @@ The `zstd` package is provided as open source software using a Go standard licen
 
 Currently the package is heavily optimized for 64 bit processors and will be significantly slower on 32 bit processors.
 
+For seekable zstd streams, see [this excellent package](https://github.com/SaveTheRbtz/zstd-seekable-format-go).
+
 ## Installation
 
 Install using `go get -u github.com/klauspost/compress`. The package is located in `github.com/klauspost/compress/zstd`.
@@ -78,6 +80,9 @@ of a stream. This is independent of the `WithEncoderConcurrency(n)`, but that is
 in the future. So if you want to limit concurrency for future updates, specify the concurrency
 you would like.
 
+If you would like stream encoding to be done without spawning async goroutines, use `WithEncoderConcurrency(1)`
+which will compress input as each block is completed, blocking on writes until each has completed.
+
 You can specify your desired compression level using `WithEncoderLevel()` option. Currently only pre-defined 
 compression settings can be specified.
 
@@ -104,7 +109,8 @@ and seems to ignore concatenated streams, even though [it is part of the spec](h
 For compressing small blocks, the returned encoder has a function called `EncodeAll(src, dst []byte) []byte`.
 
 `EncodeAll` will encode all input in src and append it to dst.
-This function can be called concurrently, but each call will only run on a single goroutine.
+This function can be called concurrently. 
+Each call will only run on a same goroutine as the caller.
 
 Encoded blocks can be concatenated and the result will be the combined input stream.
 Data compressed with EncodeAll can be decoded with the Decoder, using either a stream or `DecodeAll`.
@@ -149,10 +155,10 @@ http://sun.aei.polsl.pl/~sdeor/corpus/silesia.zip
 
 This package:
 file    out     level   insize      outsize     millis  mb/s
-silesia.tar zskp    1   211947520   73101992    643     313.87
-silesia.tar zskp    2   211947520   67504318    969     208.38
-silesia.tar zskp    3   211947520   64595893    2007    100.68
-silesia.tar zskp    4   211947520   60995370    8825    22.90
+silesia.tar zskp    1   211947520   73821326    634     318.47
+silesia.tar zskp    2   211947520   67655404    1508    133.96
+silesia.tar zskp    3   211947520   64746933    3000    67.37
+silesia.tar zskp    4   211947520   60073508    16926   11.94
 
 cgo zstd:
 silesia.tar zstd    1   211947520   73605392    543     371.56
@@ -161,94 +167,94 @@ silesia.tar zstd    6   211947520   62916450    1913    105.66
 silesia.tar zstd    9   211947520   60212393    5063    39.92
 
 gzip, stdlib/this package:
-silesia.tar gzstd   1   211947520   80007735    1654    122.21
-silesia.tar gzkp    1   211947520   80136201    1152    175.45
+silesia.tar gzstd   1   211947520   80007735    1498    134.87
+silesia.tar gzkp    1   211947520   80088272    1009    200.31
 
 GOB stream of binary data. Highly compressible.
 https://files.klauspost.com/compress/gob-stream.7z
 
 file        out     level   insize  outsize     millis  mb/s
-gob-stream  zskp    1   1911399616  235022249   3088    590.30
-gob-stream  zskp    2   1911399616  205669791   3786    481.34
-gob-stream  zskp    3   1911399616  175034659   9636    189.17
-gob-stream  zskp    4   1911399616  165609838   50369   36.19
+gob-stream  zskp    1   1911399616  233948096   3230    564.34
+gob-stream  zskp    2   1911399616  203997694   4997    364.73
+gob-stream  zskp    3   1911399616  173526523   13435   135.68
+gob-stream  zskp    4   1911399616  162195235   47559   38.33
 
 gob-stream  zstd    1   1911399616  249810424   2637    691.26
 gob-stream  zstd    3   1911399616  208192146   3490    522.31
 gob-stream  zstd    6   1911399616  193632038   6687    272.56
 gob-stream  zstd    9   1911399616  177620386   16175   112.70
 
-gob-stream  gzstd   1   1911399616  357382641   10251   177.82
-gob-stream  gzkp    1   1911399616  359753026   5438    335.20
+gob-stream  gzstd   1   1911399616  357382013   9046    201.49
+gob-stream  gzkp    1   1911399616  359136669   4885    373.08
 
 The test data for the Large Text Compression Benchmark is the first
 10^9 bytes of the English Wikipedia dump on Mar. 3, 2006.
 http://mattmahoney.net/dc/textdata.html
 
 file    out level   insize      outsize     millis  mb/s
-enwik9  zskp    1   1000000000  343848582   3609    264.18
-enwik9  zskp    2   1000000000  317276632   5746    165.97
-enwik9  zskp    3   1000000000  292243069   12162   78.41
-enwik9  zskp    4   1000000000  262183768   82837   11.51
+enwik9  zskp    1   1000000000  343833605   3687    258.64
+enwik9  zskp    2   1000000000  317001237   7672    124.29
+enwik9  zskp    3   1000000000  291915823   15923   59.89
+enwik9  zskp    4   1000000000  261710291   77697   12.27
 
 enwik9  zstd    1   1000000000  358072021   3110    306.65
 enwik9  zstd    3   1000000000  313734672   4784    199.35
 enwik9  zstd    6   1000000000  295138875   10290   92.68
 enwik9  zstd    9   1000000000  278348700   28549   33.40
 
-enwik9  gzstd   1   1000000000  382578136   9604    99.30
-enwik9  gzkp    1   1000000000  383825945   6544    145.73
+enwik9  gzstd   1   1000000000  382578136   8608    110.78
+enwik9  gzkp    1   1000000000  382781160   5628    169.45
 
 Highly compressible JSON file.
 https://files.klauspost.com/compress/github-june-2days-2019.json.zst
 
 file                        out level   insize      outsize     millis  mb/s
-github-june-2days-2019.json zskp    1   6273951764  699045015   10620   563.40
-github-june-2days-2019.json zskp    2   6273951764  617881763   11687   511.96
-github-june-2days-2019.json zskp    3   6273951764  524340691   34043   175.75
-github-june-2days-2019.json zskp    4   6273951764  470320075   170190  35.16
+github-june-2days-2019.json zskp    1   6273951764  697439532   9789    611.17
+github-june-2days-2019.json zskp    2   6273951764  610876538   18553   322.49
+github-june-2days-2019.json zskp    3   6273951764  517662858   44186   135.41
+github-june-2days-2019.json zskp    4   6273951764  464617114   165373  36.18
 
 github-june-2days-2019.json zstd    1   6273951764  766284037   8450    708.00
 github-june-2days-2019.json zstd    3   6273951764  661889476   10927   547.57
 github-june-2days-2019.json zstd    6   6273951764  642756859   22996   260.18
 github-june-2days-2019.json zstd    9   6273951764  601974523   52413   114.16
 
-github-june-2days-2019.json gzstd   1   6273951764  1164400847  29948   199.79
-github-june-2days-2019.json gzkp    1   6273951764  1125417694  21788   274.61
+github-june-2days-2019.json gzstd   1   6273951764  1164397768  26793   223.32
+github-june-2days-2019.json gzkp    1   6273951764  1120631856  17693   338.16
 
 VM Image, Linux mint with a few installed applications:
 https://files.klauspost.com/compress/rawstudio-mint14.7z
 
 file                    out level   insize      outsize     millis  mb/s
-rawstudio-mint14.tar    zskp    1   8558382592  3667489370  20210   403.84
-rawstudio-mint14.tar    zskp    2   8558382592  3364592300  31873   256.07
-rawstudio-mint14.tar    zskp    3   8558382592  3158085214  77675   105.08
-rawstudio-mint14.tar    zskp    4   8558382592  2965110639  857750  9.52
+rawstudio-mint14.tar    zskp    1   8558382592  3718400221  18206   448.29
+rawstudio-mint14.tar    zskp    2   8558382592  3326118337  37074   220.15
+rawstudio-mint14.tar    zskp    3   8558382592  3163842361  87306   93.49
+rawstudio-mint14.tar    zskp    4   8558382592  2970480650  783862  10.41
 
 rawstudio-mint14.tar    zstd    1   8558382592  3609250104  17136   476.27
 rawstudio-mint14.tar    zstd    3   8558382592  3341679997  29262   278.92
 rawstudio-mint14.tar    zstd    6   8558382592  3235846406  77904   104.77
 rawstudio-mint14.tar    zstd    9   8558382592  3160778861  140946  57.91
 
-rawstudio-mint14.tar    gzstd   1   8558382592  3926257486  57722   141.40
-rawstudio-mint14.tar    gzkp    1   8558382592  3962605659  45113   180.92
+rawstudio-mint14.tar    gzstd   1   8558382592  3926234992  51345   158.96
+rawstudio-mint14.tar    gzkp    1   8558382592  3960117298  36722   222.26
 
 CSV data:
 https://files.klauspost.com/compress/nyc-taxi-data-10M.csv.zst
 
 file                    out level   insize      outsize     millis  mb/s
-nyc-taxi-data-10M.csv   zskp    1   3325605752  641339945   8925    355.35
-nyc-taxi-data-10M.csv   zskp    2   3325605752  591748091   11268   281.44
-nyc-taxi-data-10M.csv   zskp    3   3325605752  530289687   25239   125.66
-nyc-taxi-data-10M.csv   zskp    4   3325605752  476268884   135958  23.33
+nyc-taxi-data-10M.csv   zskp    1   3325605752  641319332   9462    335.17
+nyc-taxi-data-10M.csv   zskp    2   3325605752  588976126   17570   180.50
+nyc-taxi-data-10M.csv   zskp    3   3325605752  529329260   32432   97.79
+nyc-taxi-data-10M.csv   zskp    4   3325605752  474949772   138025  22.98
 
 nyc-taxi-data-10M.csv   zstd    1   3325605752  687399637   8233    385.18
 nyc-taxi-data-10M.csv   zstd    3   3325605752  598514411   10065   315.07
 nyc-taxi-data-10M.csv   zstd    6   3325605752  570522953   20038   158.27
 nyc-taxi-data-10M.csv   zstd    9   3325605752  517554797   64565   49.12
 
-nyc-taxi-data-10M.csv   gzstd   1   3325605752  928656485   23876   132.83
-nyc-taxi-data-10M.csv   gzkp    1   3325605752  922257165   16780   189.00
+nyc-taxi-data-10M.csv   gzstd   1   3325605752  928654908   21270   149.11
+nyc-taxi-data-10M.csv   gzkp    1   3325605752  922273214   13929   227.68
 ```
 
 ## Decompressor
@@ -283,8 +289,13 @@ func Decompress(in io.Reader, out io.Writer) error {
 }
 ```
 
-It is important to use the "Close" function when you no longer need the Reader to stop running goroutines. 
-See "Allocation-less operation" below.
+It is important to use the "Close" function when you no longer need the Reader to stop running goroutines, 
+when running with default settings.
+Goroutines will exit once an error has been returned, including `io.EOF` at the end of a stream.
+
+Streams are decoded concurrently in 4 asynchronous stages to give the best possible throughput.
+However, if you prefer synchronous decompression, use `WithDecoderConcurrency(1)` which will decompress data 
+as it is being requested only.
 
 For decoding buffers, it could look something like this:
 
@@ -293,7 +304,7 @@ import "github.com/klauspost/compress/zstd"
 
 // Create a reader that caches decompressors.
 // For this operation type we supply a nil Reader.
-var decoder, _ = zstd.NewReader(nil)
+var decoder, _ = zstd.NewReader(nil, zstd.WithDecoderConcurrency(0))
 
 // Decompress a buffer. We don't supply a destination buffer,
 // so it will be allocated by the decoder.
@@ -303,9 +314,12 @@ func Decompress(src []byte) ([]byte, error) {
 ```
 
 Both of these cases should provide the functionality needed. 
-The decoder can be used for *concurrent* decompression of multiple buffers. 
+The decoder can be used for *concurrent* decompression of multiple buffers.
+By default 4 decompressors will be created. 
+
 It will only allow a certain number of concurrent operations to run. 
-To tweak that yourself use the `WithDecoderConcurrency(n)` option when creating the decoder.   
+To tweak that yourself use the `WithDecoderConcurrency(n)` option when creating the decoder.
+It is possible to use `WithDecoderConcurrency(0)` to create GOMAXPROCS decoders.
 
 ### Dictionaries
 
@@ -357,62 +371,48 @@ In this case no unneeded allocations should be made.
 The buffer decoder does everything on the same goroutine and does nothing concurrently.
 It can however decode several buffers concurrently. Use `WithDecoderConcurrency(n)` to limit that.
 
-The stream decoder operates on
+The stream decoder will create goroutines that:
 
-* One goroutine reads input and splits the input to several block decoders.
-* A number of decoders will decode blocks.
-* A goroutine coordinates these blocks and sends history from one to the next.
+1) Reads input and splits the input into blocks.
+2) Decompression of literals.
+3) Decompression of sequences.
+4) Reconstruction of output stream.
 
 So effectively this also means the decoder will "read ahead" and prepare data to always be available for output.
 
+The concurrency level will, for streams, determine how many blocks ahead the compression will start.
+
 Since "blocks" are quite dependent on the output of the previous block stream decoding will only have limited concurrency.
 
-In practice this means that concurrency is often limited to utilizing about 2 cores effectively.
- 
- 
+In practice this means that concurrency is often limited to utilizing about 3 cores effectively.
+  
 ### Benchmarks
 
-These are some examples of performance compared to [datadog cgo library](https://github.com/DataDog/zstd).
-
 The first two are streaming decodes and the last are smaller inputs. 
- 
+
+Running on AMD Ryzen 9 3950X 16-Core Processor. AMD64 assembly used.
+
 ```
-BenchmarkDecoderSilesia-8                          3     385000067 ns/op     550.51 MB/s        5498 B/op          8 allocs/op
-BenchmarkDecoderSilesiaCgo-8                       6     197666567 ns/op    1072.25 MB/s      270672 B/op          8 allocs/op
-
-BenchmarkDecoderEnwik9-8                           1    2027001600 ns/op     493.34 MB/s       10496 B/op         18 allocs/op
-BenchmarkDecoderEnwik9Cgo-8                        2     979499200 ns/op    1020.93 MB/s      270672 B/op          8 allocs/op
-
-Concurrent performance:
-
-BenchmarkDecoder_DecodeAllParallel/kppkn.gtb.zst-16                28915         42469 ns/op    4340.07 MB/s         114 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/geo.protodata.zst-16           116505          9965 ns/op    11900.16 MB/s         16 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/plrabn12.txt.zst-16              8952        134272 ns/op    3588.70 MB/s         915 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/lcet10.txt.zst-16               11820        102538 ns/op    4161.90 MB/s         594 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/asyoulik.txt.zst-16             34782         34184 ns/op    3661.88 MB/s          60 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/alice29.txt.zst-16              27712         43447 ns/op    3500.58 MB/s          99 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/html_x_4.zst-16                 62826         18750 ns/op    21845.10 MB/s        104 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/paper-100k.pdf.zst-16          631545          1794 ns/op    57078.74 MB/s          2 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/fireworks.jpeg.zst-16         1690140           712 ns/op    172938.13 MB/s         1 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/urls.10K.zst-16                 10432        113593 ns/op    6180.73 MB/s        1143 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/html.zst-16                    113206         10671 ns/op    9596.27 MB/s          15 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/comp-data.bin.zst-16          1530615           779 ns/op    5229.49 MB/s           0 B/op          0 allocs/op
-
-BenchmarkDecoder_DecodeAllParallelCgo/kppkn.gtb.zst-16             65217         16192 ns/op    11383.34 MB/s         46 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallelCgo/geo.protodata.zst-16        292671          4039 ns/op    29363.19 MB/s          6 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallelCgo/plrabn12.txt.zst-16          26314         46021 ns/op    10470.43 MB/s        293 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallelCgo/lcet10.txt.zst-16            33897         34900 ns/op    12227.96 MB/s        205 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallelCgo/asyoulik.txt.zst-16         104348         11433 ns/op    10949.01 MB/s         20 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallelCgo/alice29.txt.zst-16           75949         15510 ns/op    9805.60 MB/s          32 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallelCgo/html_x_4.zst-16             173910          6756 ns/op    60624.29 MB/s         37 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallelCgo/paper-100k.pdf.zst-16       923076          1339 ns/op    76474.87 MB/s          1 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallelCgo/fireworks.jpeg.zst-16       922920          1351 ns/op    91102.57 MB/s          2 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallelCgo/urls.10K.zst-16              27649         43618 ns/op    16096.19 MB/s        407 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallelCgo/html.zst-16                 279073          4160 ns/op    24614.18 MB/s          6 B/op          0 allocs/op
-BenchmarkDecoder_DecodeAllParallelCgo/comp-data.bin.zst-16        749938          1579 ns/op    2581.71 MB/s           0 B/op          0 allocs/op
+BenchmarkDecoderSilesia-32    	                   5	 206878840 ns/op	1024.50 MB/s	   49808 B/op	      43 allocs/op
+BenchmarkDecoderEnwik9-32                          1	1271809000 ns/op	 786.28 MB/s	   72048 B/op	      52 allocs/op
+
+Concurrent blocks, performance:
+
+BenchmarkDecoder_DecodeAllParallel/kppkn.gtb.zst-32         	   67356	     17857 ns/op	10321.96 MB/s	        22.48 pct	     102 B/op	       0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/geo.protodata.zst-32     	  266656	      4421 ns/op	26823.21 MB/s	        11.89 pct	      19 B/op	       0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/plrabn12.txt.zst-32      	   20992	     56842 ns/op	8477.17 MB/s	        39.90 pct	     754 B/op	       0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/lcet10.txt.zst-32        	   27456	     43932 ns/op	9714.01 MB/s	        33.27 pct	     524 B/op	       0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/asyoulik.txt.zst-32      	   78432	     15047 ns/op	8319.15 MB/s	        40.34 pct	      66 B/op	       0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/alice29.txt.zst-32       	   65800	     18436 ns/op	8249.63 MB/s	        37.75 pct	      88 B/op	       0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/html_x_4.zst-32          	  102993	     11523 ns/op	35546.09 MB/s	         3.637 pct	     143 B/op	       0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/paper-100k.pdf.zst-32    	 1000000	      1070 ns/op	95720.98 MB/s	        80.53 pct	       3 B/op	       0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/fireworks.jpeg.zst-32    	  749802	      1752 ns/op	70272.35 MB/s	       100.0 pct	       5 B/op	       0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/urls.10K.zst-32          	   22640	     52934 ns/op	13263.37 MB/s	        26.25 pct	    1014 B/op	       0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/html.zst-32              	  226412	      5232 ns/op	19572.27 MB/s	        14.49 pct	      20 B/op	       0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/comp-data.bin.zst-32     	  923041	      1276 ns/op	3194.71 MB/s	        31.26 pct	       0 B/op	       0 allocs/op
 ```
 
-This reflects the performance around May 2020, but this may be out of date.
+This reflects the performance around May 2022, but this may be out of date.
 
 ## Zstd inside ZIP files
 
diff --git a/vendor/github.com/klauspost/compress/zstd/bitreader.go b/vendor/github.com/klauspost/compress/zstd/bitreader.go
index 85445853..97299d49 100644
--- a/vendor/github.com/klauspost/compress/zstd/bitreader.go
+++ b/vendor/github.com/klauspost/compress/zstd/bitreader.go
@@ -7,6 +7,7 @@ package zstd
 import (
 	"encoding/binary"
 	"errors"
+	"fmt"
 	"io"
 	"math/bits"
 )
@@ -50,16 +51,16 @@ func (b *bitReader) getBits(n uint8) int {
 	if n == 0 /*|| b.bitsRead >= 64 */ {
 		return 0
 	}
-	return b.getBitsFast(n)
+	return int(b.get32BitsFast(n))
 }
 
-// getBitsFast requires that at least one bit is requested every time.
+// get32BitsFast requires that at least one bit is requested every time.
 // There are no checks if the buffer is filled.
-func (b *bitReader) getBitsFast(n uint8) int {
+func (b *bitReader) get32BitsFast(n uint8) uint32 {
 	const regMask = 64 - 1
 	v := uint32((b.value << (b.bitsRead & regMask)) >> ((regMask + 1 - n) & regMask))
 	b.bitsRead += n
-	return int(v)
+	return v
 }
 
 // fillFast() will make sure at least 32 bits are available.
@@ -125,6 +126,9 @@ func (b *bitReader) remain() uint {
 func (b *bitReader) close() error {
 	// Release reference.
 	b.in = nil
+	if !b.finished() {
+		return fmt.Errorf("%d extra bits on block, should be 0", b.remain())
+	}
 	if b.bitsRead > 64 {
 		return io.ErrUnexpectedEOF
 	}
diff --git a/vendor/github.com/klauspost/compress/zstd/bitwriter.go b/vendor/github.com/klauspost/compress/zstd/bitwriter.go
index 303ae90f..78b3c61b 100644
--- a/vendor/github.com/klauspost/compress/zstd/bitwriter.go
+++ b/vendor/github.com/klauspost/compress/zstd/bitwriter.go
@@ -5,8 +5,6 @@
 
 package zstd
 
-import "fmt"
-
 // bitWriter will write bits.
 // First bit will be LSB of the first byte of output.
 type bitWriter struct {
@@ -38,7 +36,7 @@ func (b *bitWriter) addBits16NC(value uint16, bits uint8) {
 	b.nBits += bits
 }
 
-// addBits32NC will add up to 32 bits.
+// addBits32NC will add up to 31 bits.
 // It will not check if there is space for them,
 // so the caller must ensure that it has flushed recently.
 func (b *bitWriter) addBits32NC(value uint32, bits uint8) {
@@ -46,6 +44,26 @@ func (b *bitWriter) addBits32NC(value uint32, bits uint8) {
 	b.nBits += bits
 }
 
+// addBits64NC will add up to 64 bits.
+// There must be space for 32 bits.
+func (b *bitWriter) addBits64NC(value uint64, bits uint8) {
+	if bits <= 31 {
+		b.addBits32Clean(uint32(value), bits)
+		return
+	}
+	b.addBits32Clean(uint32(value), 32)
+	b.flush32()
+	b.addBits32Clean(uint32(value>>32), bits-32)
+}
+
+// addBits32Clean will add up to 32 bits.
+// It will not check if there is space for them.
+// The input must not contain more bits than specified.
+func (b *bitWriter) addBits32Clean(value uint32, bits uint8) {
+	b.bitContainer |= uint64(value) << (b.nBits & 63)
+	b.nBits += bits
+}
+
 // addBits16Clean will add up to 16 bits. value may not contain more set bits than indicated.
 // It will not check if there is space for them, so the caller must ensure that it has flushed recently.
 func (b *bitWriter) addBits16Clean(value uint16, bits uint8) {
@@ -53,80 +71,6 @@ func (b *bitWriter) addBits16Clean(value uint16, bits uint8) {
 	b.nBits += bits
 }
 
-// flush will flush all pending full bytes.
-// There will be at least 56 bits available for writing when this has been called.
-// Using flush32 is faster, but leaves less space for writing.
-func (b *bitWriter) flush() {
-	v := b.nBits >> 3
-	switch v {
-	case 0:
-	case 1:
-		b.out = append(b.out,
-			byte(b.bitContainer),
-		)
-	case 2:
-		b.out = append(b.out,
-			byte(b.bitContainer),
-			byte(b.bitContainer>>8),
-		)
-	case 3:
-		b.out = append(b.out,
-			byte(b.bitContainer),
-			byte(b.bitContainer>>8),
-			byte(b.bitContainer>>16),
-		)
-	case 4:
-		b.out = append(b.out,
-			byte(b.bitContainer),
-			byte(b.bitContainer>>8),
-			byte(b.bitContainer>>16),
-			byte(b.bitContainer>>24),
-		)
-	case 5:
-		b.out = append(b.out,
-			byte(b.bitContainer),
-			byte(b.bitContainer>>8),
-			byte(b.bitContainer>>16),
-			byte(b.bitContainer>>24),
-			byte(b.bitContainer>>32),
-		)
-	case 6:
-		b.out = append(b.out,
-			byte(b.bitContainer),
-			byte(b.bitContainer>>8),
-			byte(b.bitContainer>>16),
-			byte(b.bitContainer>>24),
-			byte(b.bitContainer>>32),
-			byte(b.bitContainer>>40),
-		)
-	case 7:
-		b.out = append(b.out,
-			byte(b.bitContainer),
-			byte(b.bitContainer>>8),
-			byte(b.bitContainer>>16),
-			byte(b.bitContainer>>24),
-			byte(b.bitContainer>>32),
-			byte(b.bitContainer>>40),
-			byte(b.bitContainer>>48),
-		)
-	case 8:
-		b.out = append(b.out,
-			byte(b.bitContainer),
-			byte(b.bitContainer>>8),
-			byte(b.bitContainer>>16),
-			byte(b.bitContainer>>24),
-			byte(b.bitContainer>>32),
-			byte(b.bitContainer>>40),
-			byte(b.bitContainer>>48),
-			byte(b.bitContainer>>56),
-		)
-	default:
-		panic(fmt.Errorf("bits (%d) > 64", b.nBits))
-	}
-	b.bitContainer >>= v << 3
-	b.nBits &= 7
-}
-
 // flush32 will flush out, so there are at least 32 bits available for writing.
 func (b *bitWriter) flush32() {
 	if b.nBits < 32 {
diff --git a/vendor/github.com/klauspost/compress/zstd/blockdec.go b/vendor/github.com/klauspost/compress/zstd/blockdec.go
index 8a98c456..9f17ce60 100644
--- a/vendor/github.com/klauspost/compress/zstd/blockdec.go
+++ b/vendor/github.com/klauspost/compress/zstd/blockdec.go
@@ -5,9 +5,14 @@
 package zstd
 
 import (
+	"bytes"
+	"encoding/binary"
 	"errors"
 	"fmt"
+	"hash/crc32"
 	"io"
+	"os"
+	"path/filepath"
 	"sync"
 
 	"github.com/klauspost/compress/huff0"
@@ -38,14 +43,14 @@ const (
 	// maxCompressedBlockSize is the biggest allowed compressed block size (128KB)
 	maxCompressedBlockSize = 128 << 10
 
+	compressedBlockOverAlloc    = 16
+	maxCompressedBlockSizeAlloc = 128<<10 + compressedBlockOverAlloc
+
 	// Maximum possible block size (all Raw+Uncompressed).
 	maxBlockSize = (1 << 21) - 1
 
-	// https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#literals_section_header
-	maxCompressedLiteralSize = 1 << 18
-	maxRLELiteralSize        = 1 << 20
-	maxMatchLen              = 131074
-	maxSequences             = 0x7f00 + 0xffff
+	maxMatchLen  = 131074
+	maxSequences = 0x7f00 + 0xffff
 
 	// We support slightly less than the reference decoder to be able to
 	// use ints on 32 bit archs.
@@ -76,20 +81,28 @@ type blockDec struct {
 	// Window size of the block.
 	WindowSize uint64
 
-	history     chan *history
-	input       chan struct{}
-	result      chan decodeOutput
-	sequenceBuf []seq
-	err         error
-	decWG       sync.WaitGroup
+	err error
+
+	// Check against this crc, if hasCRC is true.
+	checkCRC uint32
+	hasCRC   bool
 
 	// Frame to use for singlethreaded decoding.
 	// Should not be used by the decoder itself since parent may be another frame.
 	localFrame *frameDec
 
+	sequence []seqVals
+
+	async struct {
+		newHist  *history
+		literals []byte
+		seqData  []byte
+		seqSize  int // Size of uncompressed sequences
+		fcs      uint64
+	}
+
 	// Block is RLE, this is the size.
 	RLESize uint32
-	tmp     [4]byte
 
 	Type blockType
 
@@ -109,13 +122,8 @@ func (b *blockDec) String() string {
 
 func newBlockDec(lowMem bool) *blockDec {
 	b := blockDec{
-		lowMem:  lowMem,
-		result:  make(chan decodeOutput, 1),
-		input:   make(chan struct{}, 1),
-		history: make(chan *history, 1),
+		lowMem: lowMem,
 	}
-	b.decWG.Add(1)
-	go b.startDecoder()
 	return &b
 }
 
@@ -133,11 +141,17 @@ func (b *blockDec) reset(br byteBuffer, windowSize uint64) error {
 	b.Type = blockType((bh >> 1) & 3)
 	// find size.
 	cSize := int(bh >> 3)
-	maxSize := maxBlockSize
+	maxSize := maxCompressedBlockSizeAlloc
 	switch b.Type {
 	case blockTypeReserved:
 		return ErrReservedBlockType
 	case blockTypeRLE:
+		if cSize > maxCompressedBlockSize || cSize > int(b.WindowSize) {
+			if debugDecoder {
+				printf("rle block too big: csize:%d block: %+v\n", uint64(cSize), b)
+			}
+			return ErrWindowSizeExceeded
+		}
 		b.RLESize = uint32(cSize)
 		if b.lowMem {
 			maxSize = cSize
@@ -148,9 +162,9 @@ func (b *blockDec) reset(br byteBuffer, windowSize uint64) error {
 			println("Data size on stream:", cSize)
 		}
 		b.RLESize = 0
-		maxSize = maxCompressedBlockSize
+		maxSize = maxCompressedBlockSizeAlloc
 		if windowSize < maxCompressedBlockSize && b.lowMem {
-			maxSize = int(windowSize)
+			maxSize = int(windowSize) + compressedBlockOverAlloc
 		}
 		if cSize > maxCompressedBlockSize || uint64(cSize) > b.WindowSize {
 			if debugDecoder {
@@ -158,7 +172,19 @@ func (b *blockDec) reset(br byteBuffer, windowSize uint64) error {
 			}
 			return ErrCompressedSizeTooBig
 		}
+		// Empty compressed blocks must at least be 2 bytes
+		// for Literals_Block_Type and one for Sequences_Section_Header.
+		if cSize < 2 {
+			return ErrBlockTooSmall
+		}
 	case blockTypeRaw:
+		if cSize > maxCompressedBlockSize || cSize > int(b.WindowSize) {
+			if debugDecoder {
+				printf("rle block too big: csize:%d block: %+v\n", uint64(cSize), b)
+			}
+			return ErrWindowSizeExceeded
+		}
+
 		b.RLESize = 0
 		// We do not need a destination for raw blocks.
 		maxSize = -1
@@ -167,16 +193,14 @@ func (b *blockDec) reset(br byteBuffer, windowSize uint64) error {
 	}
 
 	// Read block data.
-	if cap(b.dataStorage) < cSize {
+	if _, ok := br.(*byteBuf); !ok && cap(b.dataStorage) < cSize {
+		// byteBuf doesn't need a destination buffer.
 		if b.lowMem || cSize > maxCompressedBlockSize {
-			b.dataStorage = make([]byte, 0, cSize)
+			b.dataStorage = make([]byte, 0, cSize+compressedBlockOverAlloc)
 		} else {
-			b.dataStorage = make([]byte, 0, maxCompressedBlockSize)
+			b.dataStorage = make([]byte, 0, maxCompressedBlockSizeAlloc)
 		}
 	}
-	if cap(b.dst) <= maxSize {
-		b.dst = make([]byte, 0, maxSize+1)
-	}
 	b.data, err = br.readBig(cSize, b.dataStorage)
 	if err != nil {
 		if debugDecoder {
@@ -185,6 +209,9 @@ func (b *blockDec) reset(br byteBuffer, windowSize uint64) error {
 		}
 		return err
 	}
+	if cap(b.dst) <= maxSize {
+		b.dst = make([]byte, 0, maxSize+1)
+	}
 	return nil
 }
 
@@ -193,85 +220,14 @@ func (b *blockDec) sendErr(err error) {
 	b.Last = true
 	b.Type = blockTypeReserved
 	b.err = err
-	b.input <- struct{}{}
 }
 
 // Close will release resources.
 // Closed blockDec cannot be reset.
 func (b *blockDec) Close() {
-	close(b.input)
-	close(b.history)
-	close(b.result)
-	b.decWG.Wait()
 }
 
-// decodeAsync will prepare decoding the block when it receives input.
-// This will separate output and history.
-func (b *blockDec) startDecoder() {
-	defer b.decWG.Done()
-	for range b.input {
-		//println("blockDec: Got block input")
-		switch b.Type {
-		case blockTypeRLE:
-			if cap(b.dst) < int(b.RLESize) {
-				if b.lowMem {
-					b.dst = make([]byte, b.RLESize)
-				} else {
-					b.dst = make([]byte, maxBlockSize)
-				}
-			}
-			o := decodeOutput{
-				d:   b,
-				b:   b.dst[:b.RLESize],
-				err: nil,
-			}
-			v := b.data[0]
-			for i := range o.b {
-				o.b[i] = v
-			}
-			hist := <-b.history
-			hist.append(o.b)
-			b.result <- o
-		case blockTypeRaw:
-			o := decodeOutput{
-				d:   b,
-				b:   b.data,
-				err: nil,
-			}
-			hist := <-b.history
-			hist.append(o.b)
-			b.result <- o
-		case blockTypeCompressed:
-			b.dst = b.dst[:0]
-			err := b.decodeCompressed(nil)
-			o := decodeOutput{
-				d:   b,
-				b:   b.dst,
-				err: err,
-			}
-			if debugDecoder {
-				println("Decompressed to", len(b.dst), "bytes, error:", err)
-			}
-			b.result <- o
-		case blockTypeReserved:
-			// Used for returning errors.
-			<-b.history
-			b.result <- decodeOutput{
-				d:   b,
-				b:   nil,
-				err: b.err,
-			}
-		default:
-			panic("Invalid block type")
-		}
-		if debugDecoder {
-			println("blockDec: Finished block")
-		}
-	}
-}
-
-// decodeAsync will prepare decoding the block when it receives the history.
-// If history is provided, it will not fetch it from the channel.
+// decodeBuf
 func (b *blockDec) decodeBuf(hist *history) error {
 	switch b.Type {
 	case blockTypeRLE:
@@ -279,7 +235,7 @@ func (b *blockDec) decodeBuf(hist *history) error {
 			if b.lowMem {
 				b.dst = make([]byte, b.RLESize)
 			} else {
-				b.dst = make([]byte, maxBlockSize)
+				b.dst = make([]byte, maxCompressedBlockSize)
 			}
 		}
 		b.dst = b.dst[:b.RLESize]
@@ -294,14 +250,23 @@ func (b *blockDec) decodeBuf(hist *history) error {
 		return nil
 	case blockTypeCompressed:
 		saved := b.dst
-		b.dst = hist.b
-		hist.b = nil
+		// Append directly to history
+		if hist.ignoreBuffer == 0 {
+			b.dst = hist.b
+			hist.b = nil
+		} else {
+			b.dst = b.dst[:0]
+		}
 		err := b.decodeCompressed(hist)
 		if debugDecoder {
 			println("Decompressed to total", len(b.dst), "bytes, hash:", xxhash.Sum64(b.dst), "error:", err)
 		}
-		hist.b = b.dst
-		b.dst = saved
+		if hist.ignoreBuffer == 0 {
+			hist.b = b.dst
+			b.dst = saved
+		} else {
+			hist.appendKeep(b.dst)
+		}
 		return err
 	case blockTypeReserved:
 		// Used for returning errors.
@@ -311,30 +276,18 @@ func (b *blockDec) decodeBuf(hist *history) error {
 	}
 }
 
-// decodeCompressed will start decompressing a block.
-// If no history is supplied the decoder will decodeAsync as much as possible
-// before fetching from blockDec.history
-func (b *blockDec) decodeCompressed(hist *history) error {
-	in := b.data
-	delayedHistory := hist == nil
-
-	if delayedHistory {
-		// We must always grab history.
-		defer func() {
-			if hist == nil {
-				<-b.history
-			}
-		}()
-	}
+func (b *blockDec) decodeLiterals(in []byte, hist *history) (remain []byte, err error) {
 	// There must be at least one byte for Literals_Block_Type and one for Sequences_Section_Header
 	if len(in) < 2 {
-		return ErrBlockTooSmall
+		return in, ErrBlockTooSmall
 	}
+
 	litType := literalsBlockType(in[0] & 3)
 	var litRegenSize int
 	var litCompSize int
 	sizeFormat := (in[0] >> 2) & 3
 	var fourStreams bool
+	var literals []byte
 	switch litType {
 	case literalsBlockRaw, literalsBlockRLE:
 		switch sizeFormat {
@@ -350,7 +303,7 @@ func (b *blockDec) decodeCompressed(hist *history) error {
 			//  Regenerated_Size uses 20 bits (0-1048575). Literals_Section_Header uses 3 bytes.
 			if len(in) < 3 {
 				println("too small: litType:", litType, " sizeFormat", sizeFormat, len(in))
-				return ErrBlockTooSmall
+				return in, ErrBlockTooSmall
 			}
 			litRegenSize = int(in[0]>>4) + (int(in[1]) << 4) + (int(in[2]) << 12)
 			in = in[3:]
@@ -361,7 +314,7 @@ func (b *blockDec) decodeCompressed(hist *history) error {
 			// Both Regenerated_Size and Compressed_Size use 10 bits (0-1023).
 			if len(in) < 3 {
 				println("too small: litType:", litType, " sizeFormat", sizeFormat, len(in))
-				return ErrBlockTooSmall
+				return in, ErrBlockTooSmall
 			}
 			n := uint64(in[0]>>4) + (uint64(in[1]) << 4) + (uint64(in[2]) << 12)
 			litRegenSize = int(n & 1023)
@@ -372,7 +325,7 @@ func (b *blockDec) decodeCompressed(hist *history) error {
 			fourStreams = true
 			if len(in) < 4 {
 				println("too small: litType:", litType, " sizeFormat", sizeFormat, len(in))
-				return ErrBlockTooSmall
+				return in, ErrBlockTooSmall
 			}
 			n := uint64(in[0]>>4) + (uint64(in[1]) << 4) + (uint64(in[2]) << 12) + (uint64(in[3]) << 20)
 			litRegenSize = int(n & 16383)
@@ -382,7 +335,7 @@ func (b *blockDec) decodeCompressed(hist *history) error {
 			fourStreams = true
 			if len(in) < 5 {
 				println("too small: litType:", litType, " sizeFormat", sizeFormat, len(in))
-				return ErrBlockTooSmall
+				return in, ErrBlockTooSmall
 			}
 			n := uint64(in[0]>>4) + (uint64(in[1]) << 4) + (uint64(in[2]) << 12) + (uint64(in[3]) << 20) + (uint64(in[4]) << 28)
 			litRegenSize = int(n & 262143)
@@ -393,13 +346,15 @@ func (b *blockDec) decodeCompressed(hist *history) error {
 	if debugDecoder {
 		println("literals type:", litType, "litRegenSize:", litRegenSize, "litCompSize:", litCompSize, "sizeFormat:", sizeFormat, "4X:", fourStreams)
 	}
-	var literals []byte
-	var huff *huff0.Scratch
+	if litRegenSize > int(b.WindowSize) || litRegenSize > maxCompressedBlockSize {
+		return in, ErrWindowSizeExceeded
+	}
+
 	switch litType {
 	case literalsBlockRaw:
 		if len(in) < litRegenSize {
 			println("too small: litType:", litType, " sizeFormat", sizeFormat, "remain:", len(in), "want:", litRegenSize)
-			return ErrBlockTooSmall
+			return in, ErrBlockTooSmall
 		}
 		literals = in[:litRegenSize]
 		in = in[litRegenSize:]
@@ -407,19 +362,13 @@ func (b *blockDec) decodeCompressed(hist *history) error {
 	case literalsBlockRLE:
 		if len(in) < 1 {
 			println("too small: litType:", litType, " sizeFormat", sizeFormat, "remain:", len(in), "want:", 1)
-			return ErrBlockTooSmall
+			return in, ErrBlockTooSmall
 		}
 		if cap(b.literalBuf) < litRegenSize {
 			if b.lowMem {
-				b.literalBuf = make([]byte, litRegenSize)
+				b.literalBuf = make([]byte, litRegenSize, litRegenSize+compressedBlockOverAlloc)
 			} else {
-				if litRegenSize > maxCompressedLiteralSize {
-					// Exceptional
-					b.literalBuf = make([]byte, litRegenSize)
-				} else {
-					b.literalBuf = make([]byte, litRegenSize, maxCompressedLiteralSize)
-
-				}
+				b.literalBuf = make([]byte, litRegenSize, maxCompressedBlockSize+compressedBlockOverAlloc)
 			}
 		}
 		literals = b.literalBuf[:litRegenSize]
@@ -434,7 +383,7 @@ func (b *blockDec) decodeCompressed(hist *history) error {
 	case literalsBlockTreeless:
 		if len(in) < litCompSize {
 			println("too small: litType:", litType, " sizeFormat", sizeFormat, "remain:", len(in), "want:", litCompSize)
-			return ErrBlockTooSmall
+			return in, ErrBlockTooSmall
 		}
 		// Store compressed literals, so we defer decoding until we get history.
 		literals = in[:litCompSize]
@@ -442,31 +391,68 @@ func (b *blockDec) decodeCompressed(hist *history) error {
 		if debugDecoder {
 			printf("Found %d compressed literals\n", litCompSize)
 		}
+		huff := hist.huffTree
+		if huff == nil {
+			return in, errors.New("literal block was treeless, but no history was defined")
+		}
+		// Ensure we have space to store it.
+		if cap(b.literalBuf) < litRegenSize {
+			if b.lowMem {
+				b.literalBuf = make([]byte, 0, litRegenSize+compressedBlockOverAlloc)
+			} else {
+				b.literalBuf = make([]byte, 0, maxCompressedBlockSize+compressedBlockOverAlloc)
+			}
+		}
+		var err error
+		// Use our out buffer.
+		huff.MaxDecodedSize = litRegenSize
+		if fourStreams {
+			literals, err = huff.Decoder().Decompress4X(b.literalBuf[:0:litRegenSize], literals)
+		} else {
+			literals, err = huff.Decoder().Decompress1X(b.literalBuf[:0:litRegenSize], literals)
+		}
+		// Make sure we don't leak our literals buffer
+		if err != nil {
+			println("decompressing literals:", err)
+			return in, err
+		}
+		if len(literals) != litRegenSize {
+			return in, fmt.Errorf("literal output size mismatch want %d, got %d", litRegenSize, len(literals))
+		}
+
 	case literalsBlockCompressed:
 		if len(in) < litCompSize {
 			println("too small: litType:", litType, " sizeFormat", sizeFormat, "remain:", len(in), "want:", litCompSize)
-			return ErrBlockTooSmall
+			return in, ErrBlockTooSmall
 		}
 		literals = in[:litCompSize]
 		in = in[litCompSize:]
-		huff = huffDecoderPool.Get().(*huff0.Scratch)
-		var err error
 		// Ensure we have space to store it.
 		if cap(b.literalBuf) < litRegenSize {
 			if b.lowMem {
-				b.literalBuf = make([]byte, 0, litRegenSize)
+				b.literalBuf = make([]byte, 0, litRegenSize+compressedBlockOverAlloc)
 			} else {
-				b.literalBuf = make([]byte, 0, maxCompressedLiteralSize)
+				b.literalBuf = make([]byte, 0, maxCompressedBlockSize+compressedBlockOverAlloc)
 			}
 		}
-		if huff == nil {
-			huff = &huff0.Scratch{}
+		huff := hist.huffTree
+		if huff == nil || (hist.dict != nil && huff == hist.dict.litEnc) {
+			huff = huffDecoderPool.Get().(*huff0.Scratch)
+			if huff == nil {
+				huff = &huff0.Scratch{}
+			}
+		}
+		var err error
+		if debugDecoder {
+			println("huff table input:", len(literals), "CRC:", crc32.ChecksumIEEE(literals))
 		}
 		huff, literals, err = huff0.ReadTable(literals, huff)
 		if err != nil {
 			println("reading huffman table:", err)
-			return err
+			return in, err
 		}
+		hist.huffTree = huff
+		huff.MaxDecodedSize = litRegenSize
 		// Use our out buffer.
 		if fourStreams {
 			literals, err = huff.Decoder().Decompress4X(b.literalBuf[:0:litRegenSize], literals)
@@ -475,27 +461,63 @@ func (b *blockDec) decodeCompressed(hist *history) error {
 		}
 		if err != nil {
 			println("decoding compressed literals:", err)
-			return err
+			return in, err
 		}
 		// Make sure we don't leak our literals buffer
 		if len(literals) != litRegenSize {
-			return fmt.Errorf("literal output size mismatch want %d, got %d", litRegenSize, len(literals))
+			return in, fmt.Errorf("literal output size mismatch want %d, got %d", litRegenSize, len(literals))
 		}
+		// Re-cap to get extra size.
+		literals = b.literalBuf[:len(literals)]
 		if debugDecoder {
 			printf("Decompressed %d literals into %d bytes\n", litCompSize, litRegenSize)
 		}
 	}
+	hist.decoders.literals = literals
+	return in, nil
+}
+
+// decodeCompressed will start decompressing a block.
+func (b *blockDec) decodeCompressed(hist *history) error {
+	in := b.data
+	in, err := b.decodeLiterals(in, hist)
+	if err != nil {
+		return err
+	}
+	err = b.prepareSequences(in, hist)
+	if err != nil {
+		return err
+	}
+	if hist.decoders.nSeqs == 0 {
+		b.dst = append(b.dst, hist.decoders.literals...)
+		return nil
+	}
+	before := len(hist.decoders.out)
+	err = hist.decoders.decodeSync(hist.b[hist.ignoreBuffer:])
+	if err != nil {
+		return err
+	}
+	if hist.decoders.maxSyncLen > 0 {
+		hist.decoders.maxSyncLen += uint64(before)
+		hist.decoders.maxSyncLen -= uint64(len(hist.decoders.out))
+	}
+	b.dst = hist.decoders.out
+	hist.recentOffsets = hist.decoders.prevOffset
+	return nil
+}
 
+func (b *blockDec) prepareSequences(in []byte, hist *history) (err error) {
+	if debugDecoder {
+		printf("prepareSequences: %d byte(s) input\n", len(in))
+	}
 	// Decode Sequences
 	// https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#sequences-section
 	if len(in) < 1 {
 		return ErrBlockTooSmall
 	}
+	var nSeqs int
 	seqHeader := in[0]
-	nSeqs := 0
 	switch {
-	case seqHeader == 0:
-		in = in[1:]
 	case seqHeader < 128:
 		nSeqs = int(seqHeader)
 		in = in[1:]
@@ -512,19 +534,16 @@ func (b *blockDec) decodeCompressed(hist *history) error {
 		nSeqs = 0x7f00 + int(in[1]) + (int(in[2]) << 8)
 		in = in[3:]
 	}
-	// Allocate sequences
-	if cap(b.sequenceBuf) < nSeqs {
-		if b.lowMem {
-			b.sequenceBuf = make([]seq, nSeqs)
-		} else {
-			// Allocate max
-			b.sequenceBuf = make([]seq, nSeqs, maxSequences)
+	if nSeqs == 0 && len(in) != 0 {
+		// When no sequences, there should not be any more data...
+		if debugDecoder {
+			printf("prepareSequences: 0 sequences, but %d byte(s) left on stream\n", len(in))
 		}
-	} else {
-		// Reuse buffer
-		b.sequenceBuf = b.sequenceBuf[:nSeqs]
+		return ErrUnexpectedBlockSize
 	}
-	var seqs = &sequenceDecs{}
+
+	var seqs = &hist.decoders
+	seqs.nSeqs = nSeqs
 	if nSeqs > 0 {
 		if len(in) < 1 {
 			return ErrBlockTooSmall
@@ -553,6 +572,9 @@ func (b *blockDec) decodeCompressed(hist *history) error {
 			}
 			switch mode {
 			case compModePredefined:
+				if seq.fse != nil && !seq.fse.preDefined {
+					fseDecoderPool.Put(seq.fse)
+				}
 				seq.fse = &fsePredef[i]
 			case compModeRLE:
 				if br.remain() < 1 {
@@ -560,34 +582,36 @@ func (b *blockDec) decodeCompressed(hist *history) error {
 				}
 				v := br.Uint8()
 				br.advance(1)
-				dec := fseDecoderPool.Get().(*fseDecoder)
+				if seq.fse == nil || seq.fse.preDefined {
+					seq.fse = fseDecoderPool.Get().(*fseDecoder)
+				}
 				symb, err := decSymbolValue(v, symbolTableX[i])
 				if err != nil {
 					printf("RLE Transform table (%v) error: %v", tableIndex(i), err)
 					return err
 				}
-				dec.setRLE(symb)
-				seq.fse = dec
+				seq.fse.setRLE(symb)
 				if debugDecoder {
-					printf("RLE set to %+v, code: %v", symb, v)
+					printf("RLE set to 0x%x, code: %v", symb, v)
 				}
 			case compModeFSE:
 				println("Reading table for", tableIndex(i))
-				dec := fseDecoderPool.Get().(*fseDecoder)
-				err := dec.readNCount(&br, uint16(maxTableSymbol[i]))
+				if seq.fse == nil || seq.fse.preDefined {
+					seq.fse = fseDecoderPool.Get().(*fseDecoder)
+				}
+				err := seq.fse.readNCount(&br, uint16(maxTableSymbol[i]))
 				if err != nil {
 					println("Read table error:", err)
 					return err
 				}
-				err = dec.transform(symbolTableX[i])
+				err = seq.fse.transform(symbolTableX[i])
 				if err != nil {
 					println("Transform table error:", err)
 					return err
 				}
 				if debugDecoder {
-					println("Read table ok", "symbolLen:", dec.symbolLen)
+					println("Read table ok", "symbolLen:", seq.fse.symbolLen)
 				}
-				seq.fse = dec
 			case compModeRepeat:
 				seq.repeat = true
 			}
@@ -597,140 +621,106 @@ func (b *blockDec) decodeCompressed(hist *history) error {
 		}
 		in = br.unread()
 	}
-
-	// Wait for history.
-	// All time spent after this is critical since it is strictly sequential.
-	if hist == nil {
-		hist = <-b.history
-		if hist.error {
-			return ErrDecoderClosed
-		}
-	}
-
-	// Decode treeless literal block.
-	if litType == literalsBlockTreeless {
-		// TODO: We could send the history early WITHOUT the stream history.
-		//   This would allow decoding treeless literals before the byte history is available.
-		//   Silencia stats: Treeless 4393, with: 32775, total: 37168, 11% treeless.
-		//   So not much obvious gain here.
-
-		if hist.huffTree == nil {
-			return errors.New("literal block was treeless, but no history was defined")
-		}
-		// Ensure we have space to store it.
-		if cap(b.literalBuf) < litRegenSize {
-			if b.lowMem {
-				b.literalBuf = make([]byte, 0, litRegenSize)
-			} else {
-				b.literalBuf = make([]byte, 0, maxCompressedLiteralSize)
-			}
-		}
-		var err error
-		// Use our out buffer.
-		huff = hist.huffTree
-		if fourStreams {
-			literals, err = huff.Decoder().Decompress4X(b.literalBuf[:0:litRegenSize], literals)
-		} else {
-			literals, err = huff.Decoder().Decompress1X(b.literalBuf[:0:litRegenSize], literals)
-		}
-		// Make sure we don't leak our literals buffer
-		if err != nil {
-			println("decompressing literals:", err)
-			return err
-		}
-		if len(literals) != litRegenSize {
-			return fmt.Errorf("literal output size mismatch want %d, got %d", litRegenSize, len(literals))
-		}
-	} else {
-		if hist.huffTree != nil && huff != nil {
-			if hist.dict == nil || hist.dict.litEnc != hist.huffTree {
-				huffDecoderPool.Put(hist.huffTree)
-			}
-			hist.huffTree = nil
-		}
-	}
-	if huff != nil {
-		hist.huffTree = huff
-	}
 	if debugDecoder {
-		println("Final literals:", len(literals), "hash:", xxhash.Sum64(literals), "and", nSeqs, "sequences.")
+		println("Literals:", len(seqs.literals), "hash:", xxhash.Sum64(seqs.literals), "and", seqs.nSeqs, "sequences.")
 	}
 
 	if nSeqs == 0 {
-		// Decompressed content is defined entirely as Literals Section content.
-		b.dst = append(b.dst, literals...)
-		if delayedHistory {
-			hist.append(literals)
+		if len(b.sequence) > 0 {
+			b.sequence = b.sequence[:0]
 		}
 		return nil
 	}
+	br := seqs.br
+	if br == nil {
+		br = &bitReader{}
+	}
+	if err := br.init(in); err != nil {
+		return err
+	}
 
-	seqs, err := seqs.mergeHistory(&hist.decoders)
-	if err != nil {
+	if err := seqs.initialize(br, hist, b.dst); err != nil {
+		println("initializing sequences:", err)
 		return err
 	}
-	if debugDecoder {
-		println("History merged ok")
+	// Extract blocks...
+	if false && hist.dict == nil {
+		fatalErr := func(err error) {
+			if err != nil {
+				panic(err)
+			}
+		}
+		fn := fmt.Sprintf("n-%d-lits-%d-prev-%d-%d-%d-win-%d.blk", hist.decoders.nSeqs, len(hist.decoders.literals), hist.recentOffsets[0], hist.recentOffsets[1], hist.recentOffsets[2], hist.windowSize)
+		var buf bytes.Buffer
+		fatalErr(binary.Write(&buf, binary.LittleEndian, hist.decoders.litLengths.fse))
+		fatalErr(binary.Write(&buf, binary.LittleEndian, hist.decoders.matchLengths.fse))
+		fatalErr(binary.Write(&buf, binary.LittleEndian, hist.decoders.offsets.fse))
+		buf.Write(in)
+		os.WriteFile(filepath.Join("testdata", "seqs", fn), buf.Bytes(), os.ModePerm)
 	}
-	br := &bitReader{}
-	if err := br.init(in); err != nil {
-		return err
+
+	return nil
+}
+
+func (b *blockDec) decodeSequences(hist *history) error {
+	if cap(b.sequence) < hist.decoders.nSeqs {
+		if b.lowMem {
+			b.sequence = make([]seqVals, 0, hist.decoders.nSeqs)
+		} else {
+			b.sequence = make([]seqVals, 0, 0x7F00+0xffff)
+		}
+	}
+	b.sequence = b.sequence[:hist.decoders.nSeqs]
+	if hist.decoders.nSeqs == 0 {
+		hist.decoders.seqSize = len(hist.decoders.literals)
+		return nil
 	}
+	hist.decoders.windowSize = hist.windowSize
+	hist.decoders.prevOffset = hist.recentOffsets
 
-	// TODO: Investigate if sending history without decoders are faster.
-	//   This would allow the sequences to be decoded async and only have to construct stream history.
-	//   If only recent offsets were not transferred, this would be an obvious win.
-	// 	 Also, if first 3 sequences don't reference recent offsets, all sequences can be decoded.
+	err := hist.decoders.decode(b.sequence)
+	hist.recentOffsets = hist.decoders.prevOffset
+	return err
+}
 
+func (b *blockDec) executeSequences(hist *history) error {
 	hbytes := hist.b
 	if len(hbytes) > hist.windowSize {
 		hbytes = hbytes[len(hbytes)-hist.windowSize:]
-		// We do not need history any more.
+		// We do not need history anymore.
 		if hist.dict != nil {
 			hist.dict.content = nil
 		}
 	}
-
-	if err := seqs.initialize(br, hist, literals, b.dst); err != nil {
-		println("initializing sequences:", err)
-		return err
-	}
-
-	err = seqs.decode(nSeqs, br, hbytes)
+	hist.decoders.windowSize = hist.windowSize
+	hist.decoders.out = b.dst[:0]
+	err := hist.decoders.execute(b.sequence, hbytes)
 	if err != nil {
 		return err
 	}
-	if !br.finished() {
-		return fmt.Errorf("%d extra bits on block, should be 0", br.remain())
-	}
+	return b.updateHistory(hist)
+}
 
-	err = br.close()
-	if err != nil {
-		printf("Closing sequences: %v, %+v\n", err, *br)
-	}
+func (b *blockDec) updateHistory(hist *history) error {
 	if len(b.data) > maxCompressedBlockSize {
 		return fmt.Errorf("compressed block size too large (%d)", len(b.data))
 	}
 	// Set output and release references.
-	b.dst = seqs.out
-	seqs.out, seqs.literals, seqs.hist = nil, nil, nil
+	b.dst = hist.decoders.out
+	hist.recentOffsets = hist.decoders.prevOffset
 
-	if !delayedHistory {
-		// If we don't have delayed history, no need to update.
-		hist.recentOffsets = seqs.prevOffset
-		return nil
-	}
 	if b.Last {
 		// if last block we don't care about history.
 		println("Last block, no history returned")
 		hist.b = hist.b[:0]
 		return nil
+	} else {
+		hist.append(b.dst)
+		if debugDecoder {
+			println("Finished block with ", len(b.sequence), "sequences. Added", len(b.dst), "to history, now length", len(hist.b))
+		}
 	}
-	hist.append(b.dst)
-	hist.recentOffsets = seqs.prevOffset
-	if debugDecoder {
-		println("Finished block with literals:", len(literals), "and", nSeqs, "sequences.")
-	}
+	hist.decoders.out, hist.decoders.literals = nil, nil
 
 	return nil
 }
diff --git a/vendor/github.com/klauspost/compress/zstd/blockenc.go b/vendor/github.com/klauspost/compress/zstd/blockenc.go
index 3df185ee..fd4a36f7 100644
--- a/vendor/github.com/klauspost/compress/zstd/blockenc.go
+++ b/vendor/github.com/klauspost/compress/zstd/blockenc.go
@@ -51,7 +51,7 @@ func (b *blockEnc) init() {
 		if cap(b.literals) < maxCompressedBlockSize {
 			b.literals = make([]byte, 0, maxCompressedBlockSize)
 		}
-		const defSeqs = 200
+		const defSeqs = 2000
 		if cap(b.sequences) < defSeqs {
 			b.sequences = make([]seq, 0, defSeqs)
 		}
@@ -426,7 +426,7 @@ func fuzzFseEncoder(data []byte) int {
 		return 0
 	}
 	enc := fseEncoder{}
-	hist := enc.Histogram()[:256]
+	hist := enc.Histogram()
 	maxSym := uint8(0)
 	for i, v := range data {
 		v = v & 63
@@ -473,7 +473,7 @@ func (b *blockEnc) encode(org []byte, raw, rawAllLits bool) error {
 		return b.encodeLits(b.literals, rawAllLits)
 	}
 	// We want some difference to at least account for the headers.
-	saved := b.size - len(b.literals) - (b.size >> 5)
+	saved := b.size - len(b.literals) - (b.size >> 6)
 	if saved < 16 {
 		if org == nil {
 			return errIncompressible
@@ -722,52 +722,53 @@ func (b *blockEnc) encode(org []byte, raw, rawAllLits bool) error {
 		println("Encoded seq", seq, s, "codes:", s.llCode, s.mlCode, s.ofCode, "states:", ll.state, ml.state, of.state, "bits:", llB, mlB, ofB)
 	}
 	seq--
-	if llEnc.maxBits+mlEnc.maxBits+ofEnc.maxBits <= 32 {
-		// No need to flush (common)
-		for seq >= 0 {
-			s = b.sequences[seq]
-			wr.flush32()
-			llB, ofB, mlB := llTT[s.llCode], ofTT[s.ofCode], mlTT[s.mlCode]
-			// tabelog max is 8 for all.
-			of.encode(ofB)
-			ml.encode(mlB)
-			ll.encode(llB)
-			wr.flush32()
-
-			// We checked that all can stay within 32 bits
-			wr.addBits32NC(s.litLen, llB.outBits)
-			wr.addBits32NC(s.matchLen, mlB.outBits)
-			wr.addBits32NC(s.offset, ofB.outBits)
-
-			if debugSequences {
-				println("Encoded seq", seq, s)
-			}
-
-			seq--
-		}
-	} else {
-		for seq >= 0 {
-			s = b.sequences[seq]
-			wr.flush32()
-			llB, ofB, mlB := llTT[s.llCode], ofTT[s.ofCode], mlTT[s.mlCode]
-			// tabelog max is below 8 for each.
-			of.encode(ofB)
-			ml.encode(mlB)
-			ll.encode(llB)
-			wr.flush32()
-
-			// ml+ll = max 32 bits total
-			wr.addBits32NC(s.litLen, llB.outBits)
-			wr.addBits32NC(s.matchLen, mlB.outBits)
-			wr.flush32()
-			wr.addBits32NC(s.offset, ofB.outBits)
-
-			if debugSequences {
-				println("Encoded seq", seq, s)
-			}
-
-			seq--
-		}
+	// Store sequences in reverse...
+	for seq >= 0 {
+		s = b.sequences[seq]
+
+		ofB := ofTT[s.ofCode]
+		wr.flush32() // tablelog max is below 8 for each, so it will fill max 24 bits.
+		//of.encode(ofB)
+		nbBitsOut := (uint32(of.state) + ofB.deltaNbBits) >> 16
+		dstState := int32(of.state>>(nbBitsOut&15)) + int32(ofB.deltaFindState)
+		wr.addBits16NC(of.state, uint8(nbBitsOut))
+		of.state = of.stateTable[dstState]
+
+		// Accumulate extra bits.
+		outBits := ofB.outBits & 31
+		extraBits := uint64(s.offset & bitMask32[outBits])
+		extraBitsN := outBits
+
+		mlB := mlTT[s.mlCode]
+		//ml.encode(mlB)
+		nbBitsOut = (uint32(ml.state) + mlB.deltaNbBits) >> 16
+		dstState = int32(ml.state>>(nbBitsOut&15)) + int32(mlB.deltaFindState)
+		wr.addBits16NC(ml.state, uint8(nbBitsOut))
+		ml.state = ml.stateTable[dstState]
+
+		outBits = mlB.outBits & 31
+		extraBits = extraBits<<outBits | uint64(s.matchLen&bitMask32[outBits])
+		extraBitsN += outBits
+
+		llB := llTT[s.llCode]
+		//ll.encode(llB)
+		nbBitsOut = (uint32(ll.state) + llB.deltaNbBits) >> 16
+		dstState = int32(ll.state>>(nbBitsOut&15)) + int32(llB.deltaFindState)
+		wr.addBits16NC(ll.state, uint8(nbBitsOut))
+		ll.state = ll.stateTable[dstState]
+
+		outBits = llB.outBits & 31
+		extraBits = extraBits<<outBits | uint64(s.litLen&bitMask32[outBits])
+		extraBitsN += outBits
+
+		wr.flush32()
+		wr.addBits64NC(extraBits, extraBitsN)
+
+		if debugSequences {
+			println("Encoded seq", seq, s)
+		}
+
+		seq--
 	}
 	ml.flush(mlEnc.actualTableLog)
 	of.flush(ofEnc.actualTableLog)
@@ -778,10 +779,13 @@ func (b *blockEnc) encode(org []byte, raw, rawAllLits bool) error {
 	}
 	b.output = wr.out
 
+	// Maybe even add a bigger margin.
 	if len(b.output)-3-bhOffset >= b.size {
-		// Maybe even add a bigger margin.
+		// Discard and encode as raw block.
+		b.output = b.encodeRawTo(b.output[:bhOffset], org)
+		b.popOffsets()
 		b.litEnc.Reuse = huff0.ReusePolicyNone
-		return errIncompressible
+		return nil
 	}
 
 	// Size is output minus block header.
@@ -801,14 +805,13 @@ func (b *blockEnc) genCodes() {
 		// nothing to do
 		return
 	}
-
 	if len(b.sequences) > math.MaxUint16 {
 		panic("can only encode up to 64K sequences")
 	}
 	// No bounds checks after here:
-	llH := b.coders.llEnc.Histogram()[:256]
-	ofH := b.coders.ofEnc.Histogram()[:256]
-	mlH := b.coders.mlEnc.Histogram()[:256]
+	llH := b.coders.llEnc.Histogram()
+	ofH := b.coders.ofEnc.Histogram()
+	mlH := b.coders.mlEnc.Histogram()
 	for i := range llH {
 		llH[i] = 0
 	}
@@ -820,7 +823,8 @@ func (b *blockEnc) genCodes() {
 	}
 
 	var llMax, ofMax, mlMax uint8
-	for i, seq := range b.sequences {
+	for i := range b.sequences {
+		seq := &b.sequences[i]
 		v := llCode(seq.litLen)
 		seq.llCode = v
 		llH[v]++
@@ -844,7 +848,6 @@ func (b *blockEnc) genCodes() {
 				panic(fmt.Errorf("mlMax > maxMatchLengthSymbol (%d), matchlen: %d", mlMax, seq.matchLen))
 			}
 		}
-		b.sequences[i] = seq
 	}
 	maxCount := func(a []uint32) int {
 		var max uint32
diff --git a/vendor/github.com/klauspost/compress/zstd/bytebuf.go b/vendor/github.com/klauspost/compress/zstd/bytebuf.go
index aab71c6c..55a38855 100644
--- a/vendor/github.com/klauspost/compress/zstd/bytebuf.go
+++ b/vendor/github.com/klauspost/compress/zstd/bytebuf.go
@@ -7,7 +7,6 @@ package zstd
 import (
 	"fmt"
 	"io"
-	"io/ioutil"
 )
 
 type byteBuffer interface {
@@ -23,7 +22,7 @@ type byteBuffer interface {
 	readByte() (byte, error)
 
 	// Skip n bytes.
-	skipN(n int) error
+	skipN(n int64) error
 }
 
 // in-memory buffer
@@ -52,23 +51,22 @@ func (b *byteBuf) readBig(n int, dst []byte) ([]byte, error) {
 	return r, nil
 }
 
-func (b *byteBuf) remain() []byte {
-	return *b
-}
-
 func (b *byteBuf) readByte() (byte, error) {
 	bb := *b
 	if len(bb) < 1 {
-		return 0, nil
+		return 0, io.ErrUnexpectedEOF
 	}
 	r := bb[0]
 	*b = bb[1:]
 	return r, nil
 }
 
-func (b *byteBuf) skipN(n int) error {
+func (b *byteBuf) skipN(n int64) error {
 	bb := *b
-	if len(bb) < n {
+	if n < 0 {
+		return fmt.Errorf("negative skip (%d) requested", n)
+	}
+	if int64(len(bb)) < n {
 		return io.ErrUnexpectedEOF
 	}
 	*b = bb[n:]
@@ -111,8 +109,11 @@ func (r *readerWrapper) readBig(n int, dst []byte) ([]byte, error) {
 }
 
 func (r *readerWrapper) readByte() (byte, error) {
-	n2, err := r.r.Read(r.tmp[:1])
+	n2, err := io.ReadFull(r.r, r.tmp[:1])
 	if err != nil {
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
 		return 0, err
 	}
 	if n2 != 1 {
@@ -121,9 +122,9 @@ func (r *readerWrapper) readByte() (byte, error) {
 	return r.tmp[0], nil
 }
 
-func (r *readerWrapper) skipN(n int) error {
-	n2, err := io.CopyN(ioutil.Discard, r.r, int64(n))
-	if n2 != int64(n) {
+func (r *readerWrapper) skipN(n int64) error {
+	n2, err := io.CopyN(io.Discard, r.r, n)
+	if n2 != n {
 		err = io.ErrUnexpectedEOF
 	}
 	return err
diff --git a/vendor/github.com/klauspost/compress/zstd/bytereader.go b/vendor/github.com/klauspost/compress/zstd/bytereader.go
index 2c4fca17..0e59a242 100644
--- a/vendor/github.com/klauspost/compress/zstd/bytereader.go
+++ b/vendor/github.com/klauspost/compress/zstd/bytereader.go
@@ -13,12 +13,6 @@ type byteReader struct {
 	off int
 }
 
-// init will initialize the reader and set the input.
-func (b *byteReader) init(in []byte) {
-	b.b = in
-	b.off = 0
-}
-
 // advance the stream b n bytes.
 func (b *byteReader) advance(n uint) {
 	b.off += int(n)
diff --git a/vendor/github.com/klauspost/compress/zstd/decodeheader.go b/vendor/github.com/klauspost/compress/zstd/decodeheader.go
index 69736e8d..f6a24097 100644
--- a/vendor/github.com/klauspost/compress/zstd/decodeheader.go
+++ b/vendor/github.com/klauspost/compress/zstd/decodeheader.go
@@ -4,7 +4,7 @@
 package zstd
 
 import (
-	"bytes"
+	"encoding/binary"
 	"errors"
 	"io"
 )
@@ -15,18 +15,50 @@ const HeaderMaxSize = 14 + 3
 
 // Header contains information about the first frame and block within that.
 type Header struct {
-	// Window Size the window of data to keep while decoding.
-	// Will only be set if HasFCS is false.
-	WindowSize uint64
+	// SingleSegment specifies whether the data is to be decompressed into a
+	// single contiguous memory segment.
+	// It implies that WindowSize is invalid and that FrameContentSize is valid.
+	SingleSegment bool
 
-	// Frame content size.
-	// Expected size of the entire frame.
-	FrameContentSize uint64
+	// WindowSize is the window of data to keep while decoding.
+	// Will only be set if SingleSegment is false.
+	WindowSize uint64
 
 	// Dictionary ID.
 	// If 0, no dictionary.
 	DictionaryID uint32
 
+	// HasFCS specifies whether FrameContentSize has a valid value.
+	HasFCS bool
+
+	// FrameContentSize is the expected uncompressed size of the entire frame.
+	FrameContentSize uint64
+
+	// Skippable will be true if the frame is meant to be skipped.
+	// This implies that FirstBlock.OK is false.
+	Skippable bool
+
+	// SkippableID is the user-specific ID for the skippable frame.
+	// Valid values are between 0 to 15, inclusive.
+	SkippableID int
+
+	// SkippableSize is the length of the user data to skip following
+	// the header.
+	SkippableSize uint32
+
+	// HeaderSize is the raw size of the frame header.
+	//
+	// For normal frames, it includes the size of the magic number and
+	// the size of the header (per section 3.1.1.1).
+	// It does not include the size for any data blocks (section 3.1.1.2) nor
+	// the size for the trailing content checksum.
+	//
+	// For skippable frames, this counts the size of the magic number
+	// along with the size of the size field of the payload.
+	// It does not include the size of the skippable payload itself.
+	// The total frame size is the HeaderSize plus the SkippableSize.
+	HeaderSize int
+
 	// First block information.
 	FirstBlock struct {
 		// OK will be set if first block could be decoded.
@@ -51,17 +83,9 @@ type Header struct {
 		CompressedSize int
 	}
 
-	// Skippable will be true if the frame is meant to be skipped.
-	// No other information will be populated.
-	Skippable bool
-
 	// If set there is a checksum present for the block content.
+	// The checksum field at the end is always 4 bytes long.
 	HasCheckSum bool
-
-	// If this is true FrameContentSize will have a valid value
-	HasFCS bool
-
-	SingleSegment bool
 }
 
 // Decode the header from the beginning of the stream.
@@ -71,39 +95,46 @@ type Header struct {
 // If there isn't enough input, io.ErrUnexpectedEOF is returned.
 // The FirstBlock.OK will indicate if enough information was available to decode the first block header.
 func (h *Header) Decode(in []byte) error {
+	*h = Header{}
 	if len(in) < 4 {
 		return io.ErrUnexpectedEOF
 	}
+	h.HeaderSize += 4
 	b, in := in[:4], in[4:]
-	if !bytes.Equal(b, frameMagic) {
-		if !bytes.Equal(b[1:4], skippableFrameMagic) || b[0]&0xf0 != 0x50 {
+	if string(b) != frameMagic {
+		if string(b[1:4]) != skippableFrameMagic || b[0]&0xf0 != 0x50 {
 			return ErrMagicMismatch
 		}
-		*h = Header{Skippable: true}
+		if len(in) < 4 {
+			return io.ErrUnexpectedEOF
+		}
+		h.HeaderSize += 4
+		h.Skippable = true
+		h.SkippableID = int(b[0] & 0xf)
+		h.SkippableSize = binary.LittleEndian.Uint32(in)
 		return nil
 	}
+
+	// Read Window_Descriptor
+	// https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#window_descriptor
 	if len(in) < 1 {
 		return io.ErrUnexpectedEOF
 	}
-
-	// Clear output
-	*h = Header{}
 	fhd, in := in[0], in[1:]
+	h.HeaderSize++
 	h.SingleSegment = fhd&(1<<5) != 0
 	h.HasCheckSum = fhd&(1<<2) != 0
-
 	if fhd&(1<<3) != 0 {
 		return errors.New("reserved bit set on frame header")
 	}
 
-	// Read Window_Descriptor
-	// https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#window_descriptor
 	if !h.SingleSegment {
 		if len(in) < 1 {
 			return io.ErrUnexpectedEOF
 		}
 		var wd byte
 		wd, in = in[0], in[1:]
+		h.HeaderSize++
 		windowLog := 10 + (wd >> 3)
 		windowBase := uint64(1) << windowLog
 		windowAdd := (windowBase / 8) * uint64(wd&0x7)
@@ -120,10 +151,8 @@ func (h *Header) Decode(in []byte) error {
 			return io.ErrUnexpectedEOF
 		}
 		b, in = in[:size], in[size:]
-		if b == nil {
-			return io.ErrUnexpectedEOF
-		}
-		switch size {
+		h.HeaderSize += int(size)
+		switch len(b) {
 		case 1:
 			h.DictionaryID = uint32(b[0])
 		case 2:
@@ -152,10 +181,8 @@ func (h *Header) Decode(in []byte) error {
 			return io.ErrUnexpectedEOF
 		}
 		b, in = in[:fcsSize], in[fcsSize:]
-		if b == nil {
-			return io.ErrUnexpectedEOF
-		}
-		switch fcsSize {
+		h.HeaderSize += int(fcsSize)
+		switch len(b) {
 		case 1:
 			h.FrameContentSize = uint64(b[0])
 		case 2:
diff --git a/vendor/github.com/klauspost/compress/zstd/decoder.go b/vendor/github.com/klauspost/compress/zstd/decoder.go
index f430f58b..f04aaa21 100644
--- a/vendor/github.com/klauspost/compress/zstd/decoder.go
+++ b/vendor/github.com/klauspost/compress/zstd/decoder.go
@@ -5,9 +5,12 @@
 package zstd
 
 import (
-	"errors"
+	"context"
+	"encoding/binary"
 	"io"
 	"sync"
+
+	"github.com/klauspost/compress/zstd/internal/xxhash"
 )
 
 // Decoder provides decoding of zstandard streams.
@@ -22,15 +25,22 @@ type Decoder struct {
 	// Unreferenced decoders, ready for use.
 	decoders chan *blockDec
 
-	// Streams ready to be decoded.
-	stream chan decodeStream
-
 	// Current read position used for Reader functionality.
 	current decoderState
 
+	// sync stream decoding
+	syncStream struct {
+		decodedFrame uint64
+		br           readerWrapper
+		enabled      bool
+		inFrame      bool
+		dstBuf       []byte
+	}
+
+	frame *frameDec
+
 	// Custom dictionaries.
-	// Always uses copies.
-	dicts map[uint32]dict
+	dicts map[uint32]*dict
 
 	// streamWg is the waitgroup for all streams
 	streamWg sync.WaitGroup
@@ -46,7 +56,10 @@ type decoderState struct {
 	output chan decodeOutput
 
 	// cancel remaining output.
-	cancel chan struct{}
+	cancel context.CancelFunc
+
+	// crc of current frame
+	crc *xxhash.Digest
 
 	flushed bool
 }
@@ -81,7 +94,7 @@ func NewReader(r io.Reader, opts ...DOption) (*Decoder, error) {
 			return nil, err
 		}
 	}
-	d.current.output = make(chan decodeOutput, d.o.concurrent)
+	d.current.crc = xxhash.New()
 	d.current.flushed = true
 
 	if r == nil {
@@ -89,7 +102,7 @@ func NewReader(r io.Reader, opts ...DOption) (*Decoder, error) {
 	}
 
 	// Transfer option dicts.
-	d.dicts = make(map[uint32]dict, len(d.o.dicts))
+	d.dicts = make(map[uint32]*dict, len(d.o.dicts))
 	for _, dc := range d.o.dicts {
 		d.dicts[dc.id] = dc
 	}
@@ -130,7 +143,7 @@ func (d *Decoder) Read(p []byte) (int, error) {
 				break
 			}
 			if !d.nextBlock(n == 0) {
-				return n, nil
+				return n, d.current.err
 			}
 		}
 	}
@@ -162,6 +175,7 @@ func (d *Decoder) Reset(r io.Reader) error {
 
 	d.drainOutput()
 
+	d.syncStream.br.r = nil
 	if r == nil {
 		d.current.err = ErrDecoderNilInput
 		if len(d.current.b) > 0 {
@@ -172,21 +186,23 @@ func (d *Decoder) Reset(r io.Reader) error {
 	}
 
 	// If bytes buffer and < 5MB, do sync decoding anyway.
-	if bb, ok := r.(byter); ok && bb.Len() < 5<<20 {
+	if bb, ok := r.(byter); ok && bb.Len() < d.o.decodeBufsBelow && !d.o.limitToCap {
 		bb2 := bb
 		if debugDecoder {
 			println("*bytes.Buffer detected, doing sync decode, len:", bb.Len())
 		}
 		b := bb2.Bytes()
 		var dst []byte
-		if cap(d.current.b) > 0 {
-			dst = d.current.b
+		if cap(d.syncStream.dstBuf) > 0 {
+			dst = d.syncStream.dstBuf[:0]
 		}
 
-		dst, err := d.DecodeAll(b, dst[:0])
+		dst, err := d.DecodeAll(b, dst)
 		if err == nil {
 			err = io.EOF
 		}
+		// Save output buffer
+		d.syncStream.dstBuf = dst
 		d.current.b = dst
 		d.current.err = err
 		d.current.flushed = true
@@ -195,33 +211,40 @@ func (d *Decoder) Reset(r io.Reader) error {
 		}
 		return nil
 	}
-
-	if d.stream == nil {
-		d.stream = make(chan decodeStream, 1)
-		d.streamWg.Add(1)
-		go d.startStreamDecoder(d.stream)
-	}
-
 	// Remove current block.
+	d.stashDecoder()
 	d.current.decodeOutput = decodeOutput{}
 	d.current.err = nil
-	d.current.cancel = make(chan struct{})
 	d.current.flushed = false
 	d.current.d = nil
+	d.syncStream.dstBuf = nil
 
-	d.stream <- decodeStream{
-		r:      r,
-		output: d.current.output,
-		cancel: d.current.cancel,
+	// Ensure no-one else is still running...
+	d.streamWg.Wait()
+	if d.frame == nil {
+		d.frame = newFrameDec(d.o)
 	}
+
+	if d.o.concurrent == 1 {
+		return d.startSyncDecoder(r)
+	}
+
+	d.current.output = make(chan decodeOutput, d.o.concurrent)
+	ctx, cancel := context.WithCancel(context.Background())
+	d.current.cancel = cancel
+	d.streamWg.Add(1)
+	go d.startStreamDecoder(ctx, r, d.current.output)
+
 	return nil
 }
 
 // drainOutput will drain the output until errEndOfStream is sent.
 func (d *Decoder) drainOutput() {
 	if d.current.cancel != nil {
-		println("cancelling current")
-		close(d.current.cancel)
+		if debugDecoder {
+			println("cancelling current")
+		}
+		d.current.cancel()
 		d.current.cancel = nil
 	}
 	if d.current.d != nil {
@@ -243,12 +266,9 @@ func (d *Decoder) drainOutput() {
 			}
 			d.decoders <- v.d
 		}
-		if v.err == errEndOfStream {
-			println("current flushed")
-			d.current.flushed = true
-			return
-		}
 	}
+	d.current.output = nil
+	d.current.flushed = true
 }
 
 // WriteTo writes data to w until there's no more data to write or when an error occurs.
@@ -287,19 +307,23 @@ func (d *Decoder) WriteTo(w io.Writer) (int64, error) {
 // DecodeAll can be used concurrently.
 // The Decoder concurrency limits will be respected.
 func (d *Decoder) DecodeAll(input, dst []byte) ([]byte, error) {
-	if d.current.err == ErrDecoderClosed {
+	if d.decoders == nil {
 		return dst, ErrDecoderClosed
 	}
 
 	// Grab a block decoder and frame decoder.
 	block := <-d.decoders
 	frame := block.localFrame
+	initialSize := len(dst)
 	defer func() {
 		if debugDecoder {
 			printf("re-adding decoder: %p", block)
 		}
 		frame.rawInput = nil
 		frame.bBuf = nil
+		if frame.history.decoders.br != nil {
+			frame.history.decoders.br.in = nil
+		}
 		d.decoders <- block
 	}()
 	frame.bBuf = input
@@ -307,34 +331,45 @@ func (d *Decoder) DecodeAll(input, dst []byte) ([]byte, error) {
 	for {
 		frame.history.reset()
 		err := frame.reset(&frame.bBuf)
-		if err == io.EOF {
-			if debugDecoder {
-				println("frame reset return EOF")
-			}
-			return dst, nil
-		}
-		if frame.DictionaryID != nil {
-			dict, ok := d.dicts[*frame.DictionaryID]
-			if !ok {
-				return nil, ErrUnknownDictionary
-			}
-			frame.history.setDict(&dict)
-		}
 		if err != nil {
+			if err == io.EOF {
+				if debugDecoder {
+					println("frame reset return EOF")
+				}
+				return dst, nil
+			}
 			return dst, err
 		}
-		if frame.FrameContentSize > d.o.maxDecodedSize-uint64(len(dst)) {
-			return dst, ErrDecoderSizeExceeded
+		if err = d.setDict(frame); err != nil {
+			return nil, err
 		}
-		if frame.FrameContentSize > 0 && frame.FrameContentSize < 1<<30 {
-			// Never preallocate moe than 1 GB up front.
+		if frame.WindowSize > d.o.maxWindowSize {
+			if debugDecoder {
+				println("window size exceeded:", frame.WindowSize, ">", d.o.maxWindowSize)
+			}
+			return dst, ErrWindowSizeExceeded
+		}
+		if frame.FrameContentSize != fcsUnknown {
+			if frame.FrameContentSize > d.o.maxDecodedSize-uint64(len(dst)-initialSize) {
+				if debugDecoder {
+					println("decoder size exceeded; fcs:", frame.FrameContentSize, "> mcs:", d.o.maxDecodedSize-uint64(len(dst)-initialSize), "len:", len(dst))
+				}
+				return dst, ErrDecoderSizeExceeded
+			}
+			if d.o.limitToCap && frame.FrameContentSize > uint64(cap(dst)-len(dst)) {
+				if debugDecoder {
+					println("decoder size exceeded; fcs:", frame.FrameContentSize, "> (cap-len)", cap(dst)-len(dst))
+				}
+				return dst, ErrDecoderSizeExceeded
+			}
 			if cap(dst)-len(dst) < int(frame.FrameContentSize) {
-				dst2 := make([]byte, len(dst), len(dst)+int(frame.FrameContentSize))
+				dst2 := make([]byte, len(dst), len(dst)+int(frame.FrameContentSize)+compressedBlockOverAlloc)
 				copy(dst2, dst)
 				dst = dst2
 			}
 		}
-		if cap(dst) == 0 {
+
+		if cap(dst) == 0 && !d.o.limitToCap {
 			// Allocate len(input) * 2 by default if nothing is provided
 			// and we didn't get frame content size.
 			size := len(input) * 2
@@ -352,6 +387,9 @@ func (d *Decoder) DecodeAll(input, dst []byte) ([]byte, error) {
 		if err != nil {
 			return dst, err
 		}
+		if uint64(len(dst)-initialSize) > d.o.maxDecodedSize {
+			return dst, ErrDecoderSizeExceeded
+		}
 		if len(frame.bBuf) == 0 {
 			if debugDecoder {
 				println("frame dbuf empty")
@@ -368,33 +406,167 @@ func (d *Decoder) DecodeAll(input, dst []byte) ([]byte, error) {
 // If non-blocking mode is used the returned boolean will be false
 // if no data was available without blocking.
 func (d *Decoder) nextBlock(blocking bool) (ok bool) {
-	if d.current.d != nil {
-		if debugDecoder {
-			printf("re-adding current decoder %p", d.current.d)
-		}
-		d.decoders <- d.current.d
-		d.current.d = nil
-	}
 	if d.current.err != nil {
 		// Keep error state.
-		return blocking
+		return false
 	}
+	d.current.b = d.current.b[:0]
 
+	// SYNC:
+	if d.syncStream.enabled {
+		if !blocking {
+			return false
+		}
+		ok = d.nextBlockSync()
+		if !ok {
+			d.stashDecoder()
+		}
+		return ok
+	}
+
+	//ASYNC:
+	d.stashDecoder()
 	if blocking {
-		d.current.decodeOutput = <-d.current.output
+		d.current.decodeOutput, ok = <-d.current.output
 	} else {
 		select {
-		case d.current.decodeOutput = <-d.current.output:
+		case d.current.decodeOutput, ok = <-d.current.output:
 		default:
 			return false
 		}
 	}
+	if !ok {
+		// This should not happen, so signal error state...
+		d.current.err = io.ErrUnexpectedEOF
+		return false
+	}
+	next := d.current.decodeOutput
+	if next.d != nil && next.d.async.newHist != nil {
+		d.current.crc.Reset()
+	}
 	if debugDecoder {
-		println("got", len(d.current.b), "bytes, error:", d.current.err)
+		var tmp [4]byte
+		binary.LittleEndian.PutUint32(tmp[:], uint32(xxhash.Sum64(next.b)))
+		println("got", len(d.current.b), "bytes, error:", d.current.err, "data crc:", tmp)
+	}
+
+	if d.o.ignoreChecksum {
+		return true
+	}
+
+	if len(next.b) > 0 {
+		d.current.crc.Write(next.b)
+	}
+	if next.err == nil && next.d != nil && next.d.hasCRC {
+		got := uint32(d.current.crc.Sum64())
+		if got != next.d.checkCRC {
+			if debugDecoder {
+				printf("CRC Check Failed: %08x (got) != %08x (on stream)\n", got, next.d.checkCRC)
+			}
+			d.current.err = ErrCRCMismatch
+		} else {
+			if debugDecoder {
+				printf("CRC ok %08x\n", got)
+			}
+		}
+	}
+
+	return true
+}
+
+func (d *Decoder) nextBlockSync() (ok bool) {
+	if d.current.d == nil {
+		d.current.d = <-d.decoders
+	}
+	for len(d.current.b) == 0 {
+		if !d.syncStream.inFrame {
+			d.frame.history.reset()
+			d.current.err = d.frame.reset(&d.syncStream.br)
+			if d.current.err == nil {
+				d.current.err = d.setDict(d.frame)
+			}
+			if d.current.err != nil {
+				return false
+			}
+			if d.frame.WindowSize > d.o.maxDecodedSize || d.frame.WindowSize > d.o.maxWindowSize {
+				d.current.err = ErrDecoderSizeExceeded
+				return false
+			}
+
+			d.syncStream.decodedFrame = 0
+			d.syncStream.inFrame = true
+		}
+		d.current.err = d.frame.next(d.current.d)
+		if d.current.err != nil {
+			return false
+		}
+		d.frame.history.ensureBlock()
+		if debugDecoder {
+			println("History trimmed:", len(d.frame.history.b), "decoded already:", d.syncStream.decodedFrame)
+		}
+		histBefore := len(d.frame.history.b)
+		d.current.err = d.current.d.decodeBuf(&d.frame.history)
+
+		if d.current.err != nil {
+			println("error after:", d.current.err)
+			return false
+		}
+		d.current.b = d.frame.history.b[histBefore:]
+		if debugDecoder {
+			println("history after:", len(d.frame.history.b))
+		}
+
+		// Check frame size (before CRC)
+		d.syncStream.decodedFrame += uint64(len(d.current.b))
+		if d.syncStream.decodedFrame > d.frame.FrameContentSize {
+			if debugDecoder {
+				printf("DecodedFrame (%d) > FrameContentSize (%d)\n", d.syncStream.decodedFrame, d.frame.FrameContentSize)
+			}
+			d.current.err = ErrFrameSizeExceeded
+			return false
+		}
+
+		// Check FCS
+		if d.current.d.Last && d.frame.FrameContentSize != fcsUnknown && d.syncStream.decodedFrame != d.frame.FrameContentSize {
+			if debugDecoder {
+				printf("DecodedFrame (%d) != FrameContentSize (%d)\n", d.syncStream.decodedFrame, d.frame.FrameContentSize)
+			}
+			d.current.err = ErrFrameSizeMismatch
+			return false
+		}
+
+		// Update/Check CRC
+		if d.frame.HasCheckSum {
+			if !d.o.ignoreChecksum {
+				d.frame.crc.Write(d.current.b)
+			}
+			if d.current.d.Last {
+				if !d.o.ignoreChecksum {
+					d.current.err = d.frame.checkCRC()
+				} else {
+					d.current.err = d.frame.consumeCRC()
+				}
+				if d.current.err != nil {
+					println("CRC error:", d.current.err)
+					return false
+				}
+			}
+		}
+		d.syncStream.inFrame = !d.current.d.Last
 	}
 	return true
 }
 
+func (d *Decoder) stashDecoder() {
+	if d.current.d != nil {
+		if debugDecoder {
+			printf("re-adding current decoder %p", d.current.d)
+		}
+		d.decoders <- d.current.d
+		d.current.d = nil
+	}
+}
+
 // Close will release all resources.
 // It is NOT possible to reuse the decoder after this.
 func (d *Decoder) Close() {
@@ -402,10 +574,10 @@ func (d *Decoder) Close() {
 		return
 	}
 	d.drainOutput()
-	if d.stream != nil {
-		close(d.stream)
+	if d.current.cancel != nil {
+		d.current.cancel()
 		d.streamWg.Wait()
-		d.stream = nil
+		d.current.cancel = nil
 	}
 	if d.decoders != nil {
 		close(d.decoders)
@@ -456,100 +628,321 @@ type decodeOutput struct {
 	err error
 }
 
-type decodeStream struct {
-	r io.Reader
-
-	// Blocks ready to be written to output.
-	output chan decodeOutput
-
-	// cancel reading from the input
-	cancel chan struct{}
+func (d *Decoder) startSyncDecoder(r io.Reader) error {
+	d.frame.history.reset()
+	d.syncStream.br = readerWrapper{r: r}
+	d.syncStream.inFrame = false
+	d.syncStream.enabled = true
+	d.syncStream.decodedFrame = 0
+	return nil
 }
 
-// errEndOfStream indicates that everything from the stream was read.
-var errEndOfStream = errors.New("end-of-stream")
-
 // Create Decoder:
-// Spawn n block decoders. These accept tasks to decode a block.
-// Create goroutine that handles stream processing, this will send history to decoders as they are available.
-// Decoders update the history as they decode.
-// When a block is returned:
-// 		a) history is sent to the next decoder,
-// 		b) content written to CRC.
-// 		c) return data to WRITER.
-// 		d) wait for next block to return data.
-// Once WRITTEN, the decoders reused by the writer frame decoder for re-use.
-func (d *Decoder) startStreamDecoder(inStream chan decodeStream) {
+// ASYNC:
+// Spawn 3 go routines.
+// 0: Read frames and decode block literals.
+// 1: Decode sequences.
+// 2: Execute sequences, send to output.
+func (d *Decoder) startStreamDecoder(ctx context.Context, r io.Reader, output chan decodeOutput) {
 	defer d.streamWg.Done()
-	frame := newFrameDec(d.o)
-	for stream := range inStream {
-		if debugDecoder {
-			println("got new stream")
+	br := readerWrapper{r: r}
+
+	var seqDecode = make(chan *blockDec, d.o.concurrent)
+	var seqExecute = make(chan *blockDec, d.o.concurrent)
+
+	// Async 1: Decode sequences...
+	go func() {
+		var hist history
+		var hasErr bool
+
+		for block := range seqDecode {
+			if hasErr {
+				if block != nil {
+					seqExecute <- block
+				}
+				continue
+			}
+			if block.async.newHist != nil {
+				if debugDecoder {
+					println("Async 1: new history, recent:", block.async.newHist.recentOffsets)
+				}
+				hist.reset()
+				hist.decoders = block.async.newHist.decoders
+				hist.recentOffsets = block.async.newHist.recentOffsets
+				hist.windowSize = block.async.newHist.windowSize
+				if block.async.newHist.dict != nil {
+					hist.setDict(block.async.newHist.dict)
+				}
+			}
+			if block.err != nil || block.Type != blockTypeCompressed {
+				hasErr = block.err != nil
+				seqExecute <- block
+				continue
+			}
+
+			hist.decoders.literals = block.async.literals
+			block.err = block.prepareSequences(block.async.seqData, &hist)
+			if debugDecoder && block.err != nil {
+				println("prepareSequences returned:", block.err)
+			}
+			hasErr = block.err != nil
+			if block.err == nil {
+				block.err = block.decodeSequences(&hist)
+				if debugDecoder && block.err != nil {
+					println("decodeSequences returned:", block.err)
+				}
+				hasErr = block.err != nil
+				//				block.async.sequence = hist.decoders.seq[:hist.decoders.nSeqs]
+				block.async.seqSize = hist.decoders.seqSize
+			}
+			seqExecute <- block
 		}
-		br := readerWrapper{r: stream.r}
-	decodeStream:
-		for {
-			frame.history.reset()
-			err := frame.reset(&br)
-			if debugDecoder && err != nil {
-				println("Frame decoder returned", err)
+		close(seqExecute)
+		hist.reset()
+	}()
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+
+	// Async 3: Execute sequences...
+	frameHistCache := d.frame.history.b
+	go func() {
+		var hist history
+		var decodedFrame uint64
+		var fcs uint64
+		var hasErr bool
+		for block := range seqExecute {
+			out := decodeOutput{err: block.err, d: block}
+			if block.err != nil || hasErr {
+				hasErr = true
+				output <- out
+				continue
+			}
+			if block.async.newHist != nil {
+				if debugDecoder {
+					println("Async 2: new history")
+				}
+				hist.reset()
+				hist.windowSize = block.async.newHist.windowSize
+				hist.allocFrameBuffer = block.async.newHist.allocFrameBuffer
+				if block.async.newHist.dict != nil {
+					hist.setDict(block.async.newHist.dict)
+				}
+
+				if cap(hist.b) < hist.allocFrameBuffer {
+					if cap(frameHistCache) >= hist.allocFrameBuffer {
+						hist.b = frameHistCache
+					} else {
+						hist.b = make([]byte, 0, hist.allocFrameBuffer)
+						println("Alloc history sized", hist.allocFrameBuffer)
+					}
+				}
+				hist.b = hist.b[:0]
+				fcs = block.async.fcs
+				decodedFrame = 0
 			}
-			if err == nil && frame.DictionaryID != nil {
-				dict, ok := d.dicts[*frame.DictionaryID]
-				if !ok {
-					err = ErrUnknownDictionary
+			do := decodeOutput{err: block.err, d: block}
+			switch block.Type {
+			case blockTypeRLE:
+				if debugDecoder {
+					println("add rle block length:", block.RLESize)
+				}
+
+				if cap(block.dst) < int(block.RLESize) {
+					if block.lowMem {
+						block.dst = make([]byte, block.RLESize)
+					} else {
+						block.dst = make([]byte, maxCompressedBlockSize)
+					}
+				}
+				block.dst = block.dst[:block.RLESize]
+				v := block.data[0]
+				for i := range block.dst {
+					block.dst[i] = v
+				}
+				hist.append(block.dst)
+				do.b = block.dst
+			case blockTypeRaw:
+				if debugDecoder {
+					println("add raw block length:", len(block.data))
+				}
+				hist.append(block.data)
+				do.b = block.data
+			case blockTypeCompressed:
+				if debugDecoder {
+					println("execute with history length:", len(hist.b), "window:", hist.windowSize)
+				}
+				hist.decoders.seqSize = block.async.seqSize
+				hist.decoders.literals = block.async.literals
+				do.err = block.executeSequences(&hist)
+				hasErr = do.err != nil
+				if debugDecoder && hasErr {
+					println("executeSequences returned:", do.err)
+				}
+				do.b = block.dst
+			}
+			if !hasErr {
+				decodedFrame += uint64(len(do.b))
+				if decodedFrame > fcs {
+					println("fcs exceeded", block.Last, fcs, decodedFrame)
+					do.err = ErrFrameSizeExceeded
+					hasErr = true
+				} else if block.Last && fcs != fcsUnknown && decodedFrame != fcs {
+					do.err = ErrFrameSizeMismatch
+					hasErr = true
 				} else {
-					frame.history.setDict(&dict)
+					if debugDecoder {
+						println("fcs ok", block.Last, fcs, decodedFrame)
+					}
 				}
 			}
-			if err != nil {
-				stream.output <- decodeOutput{
-					err: err,
+			output <- do
+		}
+		close(output)
+		frameHistCache = hist.b
+		wg.Done()
+		if debugDecoder {
+			println("decoder goroutines finished")
+		}
+		hist.reset()
+	}()
+
+	var hist history
+decodeStream:
+	for {
+		var hasErr bool
+		hist.reset()
+		decodeBlock := func(block *blockDec) {
+			if hasErr {
+				if block != nil {
+					seqDecode <- block
 				}
-				break
+				return
 			}
+			if block.err != nil || block.Type != blockTypeCompressed {
+				hasErr = block.err != nil
+				seqDecode <- block
+				return
+			}
+
+			remain, err := block.decodeLiterals(block.data, &hist)
+			block.err = err
+			hasErr = block.err != nil
+			if err == nil {
+				block.async.literals = hist.decoders.literals
+				block.async.seqData = remain
+			} else if debugDecoder {
+				println("decodeLiterals error:", err)
+			}
+			seqDecode <- block
+		}
+		frame := d.frame
+		if debugDecoder {
+			println("New frame...")
+		}
+		var historySent bool
+		frame.history.reset()
+		err := frame.reset(&br)
+		if debugDecoder && err != nil {
+			println("Frame decoder returned", err)
+		}
+		if err == nil {
+			err = d.setDict(frame)
+		}
+		if err == nil && d.frame.WindowSize > d.o.maxWindowSize {
 			if debugDecoder {
-				println("starting frame decoder")
-			}
-
-			// This goroutine will forward history between frames.
-			frame.frameDone.Add(1)
-			frame.initAsync()
-
-			go frame.startDecoder(stream.output)
-		decodeFrame:
-			// Go through all blocks of the frame.
-			for {
-				dec := <-d.decoders
-				select {
-				case <-stream.cancel:
-					if !frame.sendErr(dec, io.EOF) {
-						// To not let the decoder dangle, send it back.
-						stream.output <- decodeOutput{d: dec}
-					}
-					break decodeStream
-				default:
+				println("decoder size exceeded, fws:", d.frame.WindowSize, "> mws:", d.o.maxWindowSize)
+			}
+
+			err = ErrDecoderSizeExceeded
+		}
+		if err != nil {
+			select {
+			case <-ctx.Done():
+			case dec := <-d.decoders:
+				dec.sendErr(err)
+				decodeBlock(dec)
+			}
+			break decodeStream
+		}
+
+		// Go through all blocks of the frame.
+		for {
+			var dec *blockDec
+			select {
+			case <-ctx.Done():
+				break decodeStream
+			case dec = <-d.decoders:
+				// Once we have a decoder, we MUST return it.
+			}
+			err := frame.next(dec)
+			if !historySent {
+				h := frame.history
+				if debugDecoder {
+					println("Alloc History:", h.allocFrameBuffer)
+				}
+				hist.reset()
+				if h.dict != nil {
+					hist.setDict(h.dict)
 				}
-				err := frame.next(dec)
-				switch err {
-				case io.EOF:
-					// End of current frame, no error
-					println("EOF on next block")
-					break decodeFrame
-				case nil:
-					continue
-				default:
-					println("block decoder returned", err)
-					break decodeStream
+				dec.async.newHist = &h
+				dec.async.fcs = frame.FrameContentSize
+				historySent = true
+			} else {
+				dec.async.newHist = nil
+			}
+			if debugDecoder && err != nil {
+				println("next block returned error:", err)
+			}
+			dec.err = err
+			dec.hasCRC = false
+			if dec.Last && frame.HasCheckSum && err == nil {
+				crc, err := frame.rawInput.readSmall(4)
+				if len(crc) < 4 {
+					if err == nil {
+						err = io.ErrUnexpectedEOF
+
+					}
+					println("CRC missing?", err)
+					dec.err = err
+				} else {
+					dec.checkCRC = binary.LittleEndian.Uint32(crc)
+					dec.hasCRC = true
+					if debugDecoder {
+						printf("found crc to check: %08x\n", dec.checkCRC)
+					}
 				}
 			}
-			// All blocks have started decoding, check if there are more frames.
-			println("waiting for done")
-			frame.frameDone.Wait()
-			println("done waiting...")
+			err = dec.err
+			last := dec.Last
+			decodeBlock(dec)
+			if err != nil {
+				break decodeStream
+			}
+			if last {
+				break
+			}
 		}
-		frame.frameDone.Wait()
-		println("Sending EOS")
-		stream.output <- decodeOutput{err: errEndOfStream}
 	}
+	close(seqDecode)
+	wg.Wait()
+	hist.reset()
+	d.frame.history.b = frameHistCache
+}
+
+func (d *Decoder) setDict(frame *frameDec) (err error) {
+	dict, ok := d.dicts[frame.DictionaryID]
+	if ok {
+		if debugDecoder {
+			println("setting dict", frame.DictionaryID)
+		}
+		frame.history.setDict(dict)
+	} else if frame.DictionaryID != 0 {
+		// A zero or missing dictionary id is ambiguous:
+		// either dictionary zero, or no dictionary. In particular,
+		// zstd --patch-from uses this id for the source file,
+		// so only return an error if the dictionary id is not zero.
+		err = ErrUnknownDictionary
+	}
+	return err
 }
diff --git a/vendor/github.com/klauspost/compress/zstd/decoder_options.go b/vendor/github.com/klauspost/compress/zstd/decoder_options.go
index 95cc9b8b..774c5f00 100644
--- a/vendor/github.com/klauspost/compress/zstd/decoder_options.go
+++ b/vendor/github.com/klauspost/compress/zstd/decoder_options.go
@@ -6,6 +6,8 @@ package zstd
 
 import (
 	"errors"
+	"fmt"
+	"math/bits"
 	"runtime"
 )
 
@@ -14,21 +16,28 @@ type DOption func(*decoderOptions) error
 
 // options retains accumulated state of multiple options.
 type decoderOptions struct {
-	lowMem         bool
-	concurrent     int
-	maxDecodedSize uint64
-	maxWindowSize  uint64
-	dicts          []dict
+	lowMem          bool
+	concurrent      int
+	maxDecodedSize  uint64
+	maxWindowSize   uint64
+	dicts           []*dict
+	ignoreChecksum  bool
+	limitToCap      bool
+	decodeBufsBelow int
 }
 
 func (o *decoderOptions) setDefault() {
 	*o = decoderOptions{
 		// use less ram: true for now, but may change.
-		lowMem:        true,
-		concurrent:    runtime.GOMAXPROCS(0),
-		maxWindowSize: MaxWindowSize,
+		lowMem:          true,
+		concurrent:      runtime.GOMAXPROCS(0),
+		maxWindowSize:   MaxWindowSize,
+		decodeBufsBelow: 128 << 10,
 	}
-	o.maxDecodedSize = 1 << 63
+	if o.concurrent > 4 {
+		o.concurrent = 4
+	}
+	o.maxDecodedSize = 64 << 30
 }
 
 // WithDecoderLowmem will set whether to use a lower amount of memory,
@@ -37,16 +46,25 @@ func WithDecoderLowmem(b bool) DOption {
 	return func(o *decoderOptions) error { o.lowMem = b; return nil }
 }
 
-// WithDecoderConcurrency will set the concurrency,
-// meaning the maximum number of decoders to run concurrently.
-// The value supplied must be at least 1.
-// By default this will be set to GOMAXPROCS.
+// WithDecoderConcurrency sets the number of created decoders.
+// When decoding block with DecodeAll, this will limit the number
+// of possible concurrently running decodes.
+// When decoding streams, this will limit the number of
+// inflight blocks.
+// When decoding streams and setting maximum to 1,
+// no async decoding will be done.
+// When a value of 0 is provided GOMAXPROCS will be used.
+// By default this will be set to 4 or GOMAXPROCS, whatever is lower.
 func WithDecoderConcurrency(n int) DOption {
 	return func(o *decoderOptions) error {
-		if n <= 0 {
+		if n < 0 {
 			return errors.New("concurrency must be at least 1")
 		}
-		o.concurrent = n
+		if n == 0 {
+			o.concurrent = runtime.GOMAXPROCS(0)
+		} else {
+			o.concurrent = n
+		}
 		return nil
 	}
 }
@@ -54,7 +72,7 @@ func WithDecoderConcurrency(n int) DOption {
 // WithDecoderMaxMemory allows to set a maximum decoded size for in-memory
 // non-streaming operations or maximum window size for streaming operations.
 // This can be used to control memory usage of potentially hostile content.
-// Maximum and default is 1 << 63 bytes.
+// Maximum is 1 << 63 bytes. Default is 64GiB.
 func WithDecoderMaxMemory(n uint64) DOption {
 	return func(o *decoderOptions) error {
 		if n == 0 {
@@ -69,7 +87,13 @@ func WithDecoderMaxMemory(n uint64) DOption {
 }
 
 // WithDecoderDicts allows to register one or more dictionaries for the decoder.
-// If several dictionaries with the same ID is provided the last one will be used.
+//
+// Each slice in dict must be in the [dictionary format] produced by
+// "zstd --train" from the Zstandard reference implementation.
+//
+// If several dictionaries with the same ID are provided, the last one will be used.
+//
+// [dictionary format]: https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#dictionary-format
 func WithDecoderDicts(dicts ...[]byte) DOption {
 	return func(o *decoderOptions) error {
 		for _, b := range dicts {
@@ -77,8 +101,20 @@ func WithDecoderDicts(dicts ...[]byte) DOption {
 			if err != nil {
 				return err
 			}
-			o.dicts = append(o.dicts, *d)
+			o.dicts = append(o.dicts, d)
+		}
+		return nil
+	}
+}
+
+// WithDecoderDictRaw registers a dictionary that may be used by the decoder.
+// The slice content can be arbitrary data.
+func WithDecoderDictRaw(id uint32, content []byte) DOption {
+	return func(o *decoderOptions) error {
+		if bits.UintSize > 32 && uint(len(content)) > dictMaxLength {
+			return fmt.Errorf("dictionary of size %d > 2GiB too large", len(content))
 		}
+		o.dicts = append(o.dicts, &dict{id: id, content: content, offsets: [3]int{1, 4, 8}})
 		return nil
 	}
 }
@@ -100,3 +136,34 @@ func WithDecoderMaxWindow(size uint64) DOption {
 		return nil
 	}
 }
+
+// WithDecodeAllCapLimit will limit DecodeAll to decoding cap(dst)-len(dst) bytes,
+// or any size set in WithDecoderMaxMemory.
+// This can be used to limit decoding to a specific maximum output size.
+// Disabled by default.
+func WithDecodeAllCapLimit(b bool) DOption {
+	return func(o *decoderOptions) error {
+		o.limitToCap = b
+		return nil
+	}
+}
+
+// WithDecodeBuffersBelow will fully decode readers that have a
+// `Bytes() []byte` and `Len() int` interface similar to bytes.Buffer.
+// This typically uses less allocations but will have the full decompressed object in memory.
+// Note that DecodeAllCapLimit will disable this, as well as giving a size of 0 or less.
+// Default is 128KiB.
+func WithDecodeBuffersBelow(size int) DOption {
+	return func(o *decoderOptions) error {
+		o.decodeBufsBelow = size
+		return nil
+	}
+}
+
+// IgnoreChecksum allows to forcibly ignore checksum checking.
+func IgnoreChecksum(b bool) DOption {
+	return func(o *decoderOptions) error {
+		o.ignoreChecksum = b
+		return nil
+	}
+}
diff --git a/vendor/github.com/klauspost/compress/zstd/dict.go b/vendor/github.com/klauspost/compress/zstd/dict.go
index a36ae83e..ca095145 100644
--- a/vendor/github.com/klauspost/compress/zstd/dict.go
+++ b/vendor/github.com/klauspost/compress/zstd/dict.go
@@ -1,7 +1,6 @@
 package zstd
 
 import (
-	"bytes"
 	"encoding/binary"
 	"errors"
 	"fmt"
@@ -20,7 +19,10 @@ type dict struct {
 	content []byte
 }
 
-var dictMagic = [4]byte{0x37, 0xa4, 0x30, 0xec}
+const dictMagic = "\x37\xa4\x30\xec"
+
+// Maximum dictionary size for the reference implementation (1.5.3) is 2 GiB.
+const dictMaxLength = 1 << 31
 
 // ID returns the dictionary id or 0 if d is nil.
 func (d *dict) ID() uint32 {
@@ -30,14 +32,38 @@ func (d *dict) ID() uint32 {
 	return d.id
 }
 
-// DictContentSize returns the dictionary content size or 0 if d is nil.
-func (d *dict) DictContentSize() int {
+// ContentSize returns the dictionary content size or 0 if d is nil.
+func (d *dict) ContentSize() int {
 	if d == nil {
 		return 0
 	}
 	return len(d.content)
 }
 
+// Content returns the dictionary content.
+func (d *dict) Content() []byte {
+	if d == nil {
+		return nil
+	}
+	return d.content
+}
+
+// Offsets returns the initial offsets.
+func (d *dict) Offsets() [3]int {
+	if d == nil {
+		return [3]int{}
+	}
+	return d.offsets
+}
+
+// LitEncoder returns the literal encoder.
+func (d *dict) LitEncoder() *huff0.Scratch {
+	if d == nil {
+		return nil
+	}
+	return d.litEnc
+}
+
 // Load a dictionary as described in
 // https://github.com/facebook/zstd/blob/master/doc/zstd_compression_format.md#dictionary-format
 func loadDict(b []byte) (*dict, error) {
@@ -50,7 +76,7 @@ func loadDict(b []byte) (*dict, error) {
 		ofDec: sequenceDec{fse: &fseDecoder{}},
 		mlDec: sequenceDec{fse: &fseDecoder{}},
 	}
-	if !bytes.Equal(b[:4], dictMagic[:]) {
+	if string(b[:4]) != dictMagic {
 		return nil, ErrMagicMismatch
 	}
 	d.id = binary.LittleEndian.Uint32(b[4:8])
@@ -62,7 +88,7 @@ func loadDict(b []byte) (*dict, error) {
 	var err error
 	d.litEnc, b, err = huff0.ReadTable(b[8:], nil)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("loading literal table: %w", err)
 	}
 	d.litEnc.Reuse = huff0.ReusePolicyMust
 
@@ -120,3 +146,16 @@ func loadDict(b []byte) (*dict, error) {
 
 	return &d, nil
 }
+
+// InspectDictionary loads a zstd dictionary and provides functions to inspect the content.
+func InspectDictionary(b []byte) (interface {
+	ID() uint32
+	ContentSize() int
+	Content() []byte
+	Offsets() [3]int
+	LitEncoder() *huff0.Scratch
+}, error) {
+	initPredefined()
+	d, err := loadDict(b)
+	return d, err
+}
diff --git a/vendor/github.com/klauspost/compress/zstd/enc_base.go b/vendor/github.com/klauspost/compress/zstd/enc_base.go
index 295cd602..5ca46038 100644
--- a/vendor/github.com/klauspost/compress/zstd/enc_base.go
+++ b/vendor/github.com/klauspost/compress/zstd/enc_base.go
@@ -16,6 +16,7 @@ type fastBase struct {
 	cur int32
 	// maximum offset. Should be at least 2x block size.
 	maxMatchOff int32
+	bufferReset int32
 	hist        []byte
 	crc         *xxhash.Digest
 	tmp         [8]byte
@@ -56,8 +57,8 @@ func (e *fastBase) Block() *blockEnc {
 }
 
 func (e *fastBase) addBlock(src []byte) int32 {
-	if debugAsserts && e.cur > bufferReset {
-		panic(fmt.Sprintf("ecur (%d) > buffer reset (%d)", e.cur, bufferReset))
+	if debugAsserts && e.cur > e.bufferReset {
+		panic(fmt.Sprintf("ecur (%d) > buffer reset (%d)", e.cur, e.bufferReset))
 	}
 	// check if we have space already
 	if len(e.hist)+len(src) > cap(e.hist) {
@@ -108,11 +109,6 @@ func (e *fastBase) UseBlock(enc *blockEnc) {
 	e.blk = enc
 }
 
-func (e *fastBase) matchlenNoHist(s, t int32, src []byte) int32 {
-	// Extend the match to be as long as possible.
-	return int32(matchLen(src[s:], src[t:]))
-}
-
 func (e *fastBase) matchlen(s, t int32, src []byte) int32 {
 	if debugAsserts {
 		if s < 0 {
@@ -131,8 +127,6 @@ func (e *fastBase) matchlen(s, t int32, src []byte) int32 {
 			panic(fmt.Sprintf("len(src)-s (%d) > maxCompressedBlockSize (%d)", len(src)-int(s), maxCompressedBlockSize))
 		}
 	}
-
-	// Extend the match to be as long as possible.
 	return int32(matchLen(src[s:], src[t:]))
 }
 
@@ -150,18 +144,19 @@ func (e *fastBase) resetBase(d *dict, singleBlock bool) {
 	} else {
 		e.crc.Reset()
 	}
+	e.blk.dictLitEnc = nil
 	if d != nil {
 		low := e.lowMem
 		if singleBlock {
 			e.lowMem = true
 		}
-		e.ensureHist(d.DictContentSize() + maxCompressedBlockSize)
+		e.ensureHist(d.ContentSize() + maxCompressedBlockSize)
 		e.lowMem = low
 	}
 
 	// We offset current position so everything will be out of reach.
 	// If above reset line, history will be purged.
-	if e.cur < bufferReset {
+	if e.cur < e.bufferReset {
 		e.cur += e.maxMatchOff + int32(len(e.hist))
 	}
 	e.hist = e.hist[:0]
diff --git a/vendor/github.com/klauspost/compress/zstd/enc_best.go b/vendor/github.com/klauspost/compress/zstd/enc_best.go
index 96028ecd..9819d414 100644
--- a/vendor/github.com/klauspost/compress/zstd/enc_best.go
+++ b/vendor/github.com/klauspost/compress/zstd/enc_best.go
@@ -34,7 +34,7 @@ type match struct {
 	est    int32
 }
 
-const highScore = 25000
+const highScore = maxMatchLen * 8
 
 // estBits will estimate output bits from predefined tables.
 func (m *match) estBits(bitsPerByte int32) {
@@ -84,14 +84,10 @@ func (e *bestFastEncoder) Encode(blk *blockEnc, src []byte) {
 	)
 
 	// Protect against e.cur wraparound.
-	for e.cur >= bufferReset {
+	for e.cur >= e.bufferReset-int32(len(e.hist)) {
 		if len(e.hist) == 0 {
-			for i := range e.table[:] {
-				e.table[i] = prevEntry{}
-			}
-			for i := range e.longTable[:] {
-				e.longTable[i] = prevEntry{}
-			}
+			e.table = [bestShortTableSize]prevEntry{}
+			e.longTable = [bestLongTableSize]prevEntry{}
 			e.cur = e.maxMatchOff
 			break
 		}
@@ -163,7 +159,6 @@ func (e *bestFastEncoder) Encode(blk *blockEnc, src []byte) {
 
 	// nextEmit is where in src the next emitLiteral should start from.
 	nextEmit := s
-	cv := load6432(src, s)
 
 	// Relative offsets
 	offset1 := int32(blk.recentOffsets[0])
@@ -177,7 +172,6 @@ func (e *bestFastEncoder) Encode(blk *blockEnc, src []byte) {
 		blk.literals = append(blk.literals, src[nextEmit:until]...)
 		s.litLen = uint32(until - nextEmit)
 	}
-	_ = addLiterals
 
 	if debugEncoder {
 		println("recent offsets:", blk.recentOffsets)
@@ -192,49 +186,96 @@ encodeLoop:
 			panic("offset0 was 0")
 		}
 
-		bestOf := func(a, b match) match {
-			if a.est+(a.s-b.s)*bitsPerByte>>10 < b.est+(b.s-a.s)*bitsPerByte>>10 {
-				return a
-			}
-			return b
-		}
-		const goodEnough = 100
+		const goodEnough = 250
+
+		cv := load6432(src, s)
 
 		nextHashL := hashLen(cv, bestLongTableBits, bestLongLen)
 		nextHashS := hashLen(cv, bestShortTableBits, bestShortLen)
 		candidateL := e.longTable[nextHashL]
 		candidateS := e.table[nextHashS]
 
-		matchAt := func(offset int32, s int32, first uint32, rep int32) match {
+		// Set m to a match at offset if it looks like that will improve compression.
+		improve := func(m *match, offset int32, s int32, first uint32, rep int32) {
 			if s-offset >= e.maxMatchOff || load3232(src, offset) != first {
-				return match{s: s, est: highScore}
+				return
 			}
 			if debugAsserts {
+				if offset <= 0 {
+					panic(offset)
+				}
 				if !bytes.Equal(src[s:s+4], src[offset:offset+4]) {
 					panic(fmt.Sprintf("first match mismatch: %v != %v, first: %08x", src[s:s+4], src[offset:offset+4], first))
 				}
 			}
-			m := match{offset: offset, s: s, length: 4 + e.matchlen(s+4, offset+4, src), rep: rep}
-			m.estBits(bitsPerByte)
-			return m
+			// Try to quick reject if we already have a long match.
+			if m.length > 16 {
+				left := len(src) - int(m.s+m.length)
+				// If we are too close to the end, keep as is.
+				if left <= 0 {
+					return
+				}
+				checkLen := m.length - (s - m.s) - 8
+				if left > 2 && checkLen > 4 {
+					// Check 4 bytes, 4 bytes from the end of the current match.
+					a := load3232(src, offset+checkLen)
+					b := load3232(src, s+checkLen)
+					if a != b {
+						return
+					}
+				}
+			}
+			l := 4 + e.matchlen(s+4, offset+4, src)
+			if rep < 0 {
+				// Extend candidate match backwards as far as possible.
+				tMin := s - e.maxMatchOff
+				if tMin < 0 {
+					tMin = 0
+				}
+				for offset > tMin && s > nextEmit && src[offset-1] == src[s-1] && l < maxMatchLength {
+					s--
+					offset--
+					l++
+				}
+			}
+
+			cand := match{offset: offset, s: s, length: l, rep: rep}
+			cand.estBits(bitsPerByte)
+			if m.est >= highScore || cand.est-m.est+(cand.s-m.s)*bitsPerByte>>10 < 0 {
+				*m = cand
+			}
 		}
 
-		best := bestOf(matchAt(candidateL.offset-e.cur, s, uint32(cv), -1), matchAt(candidateL.prev-e.cur, s, uint32(cv), -1))
-		best = bestOf(best, matchAt(candidateS.offset-e.cur, s, uint32(cv), -1))
-		best = bestOf(best, matchAt(candidateS.prev-e.cur, s, uint32(cv), -1))
+		best := match{s: s, est: highScore}
+		improve(&best, candidateL.offset-e.cur, s, uint32(cv), -1)
+		improve(&best, candidateL.prev-e.cur, s, uint32(cv), -1)
+		improve(&best, candidateS.offset-e.cur, s, uint32(cv), -1)
+		improve(&best, candidateS.prev-e.cur, s, uint32(cv), -1)
 
 		if canRepeat && best.length < goodEnough {
-			cv32 := uint32(cv >> 8)
-			spp := s + 1
-			best = bestOf(best, matchAt(spp-offset1, spp, cv32, 1))
-			best = bestOf(best, matchAt(spp-offset2, spp, cv32, 2))
-			best = bestOf(best, matchAt(spp-offset3, spp, cv32, 3))
-			if best.length > 0 {
-				cv32 = uint32(cv >> 24)
-				spp += 2
-				best = bestOf(best, matchAt(spp-offset1, spp, cv32, 1))
-				best = bestOf(best, matchAt(spp-offset2, spp, cv32, 2))
-				best = bestOf(best, matchAt(spp-offset3, spp, cv32, 3))
+			if s == nextEmit {
+				// Check repeats straight after a match.
+				improve(&best, s-offset2, s, uint32(cv), 1|4)
+				improve(&best, s-offset3, s, uint32(cv), 2|4)
+				if offset1 > 1 {
+					improve(&best, s-(offset1-1), s, uint32(cv), 3|4)
+				}
+			}
+
+			// If either no match or a non-repeat match, check at + 1
+			if best.rep <= 0 {
+				cv32 := uint32(cv >> 8)
+				spp := s + 1
+				improve(&best, spp-offset1, spp, cv32, 1)
+				improve(&best, spp-offset2, spp, cv32, 2)
+				improve(&best, spp-offset3, spp, cv32, 3)
+				if best.rep < 0 {
+					cv32 = uint32(cv >> 24)
+					spp += 2
+					improve(&best, spp-offset1, spp, cv32, 1)
+					improve(&best, spp-offset2, spp, cv32, 2)
+					improve(&best, spp-offset3, spp, cv32, 3)
+				}
 			}
 		}
 		// Load next and check...
@@ -249,40 +290,45 @@ encodeLoop:
 				if s >= sLimit {
 					break encodeLoop
 				}
-				cv = load6432(src, s)
 				continue
 			}
 
-			s++
 			candidateS = e.table[hashLen(cv>>8, bestShortTableBits, bestShortLen)]
-			cv = load6432(src, s)
-			cv2 := load6432(src, s+1)
+			cv = load6432(src, s+1)
+			cv2 := load6432(src, s+2)
 			candidateL = e.longTable[hashLen(cv, bestLongTableBits, bestLongLen)]
 			candidateL2 := e.longTable[hashLen(cv2, bestLongTableBits, bestLongLen)]
 
 			// Short at s+1
-			best = bestOf(best, matchAt(candidateS.offset-e.cur, s, uint32(cv), -1))
+			improve(&best, candidateS.offset-e.cur, s+1, uint32(cv), -1)
 			// Long at s+1, s+2
-			best = bestOf(best, matchAt(candidateL.offset-e.cur, s, uint32(cv), -1))
-			best = bestOf(best, matchAt(candidateL.prev-e.cur, s, uint32(cv), -1))
-			best = bestOf(best, matchAt(candidateL2.offset-e.cur, s+1, uint32(cv2), -1))
-			best = bestOf(best, matchAt(candidateL2.prev-e.cur, s+1, uint32(cv2), -1))
+			improve(&best, candidateL.offset-e.cur, s+1, uint32(cv), -1)
+			improve(&best, candidateL.prev-e.cur, s+1, uint32(cv), -1)
+			improve(&best, candidateL2.offset-e.cur, s+2, uint32(cv2), -1)
+			improve(&best, candidateL2.prev-e.cur, s+2, uint32(cv2), -1)
 			if false {
 				// Short at s+3.
 				// Too often worse...
-				best = bestOf(best, matchAt(e.table[hashLen(cv2>>8, bestShortTableBits, bestShortLen)].offset-e.cur, s+2, uint32(cv2>>8), -1))
+				improve(&best, e.table[hashLen(cv2>>8, bestShortTableBits, bestShortLen)].offset-e.cur, s+3, uint32(cv2>>8), -1)
 			}
-			// See if we can find a better match by checking where the current best ends.
-			// Use that offset to see if we can find a better full match.
-			if sAt := best.s + best.length; sAt < sLimit {
-				nextHashL := hashLen(load6432(src, sAt), bestLongTableBits, bestLongLen)
-				candidateEnd := e.longTable[nextHashL]
-				if pos := candidateEnd.offset - e.cur - best.length; pos >= 0 {
-					bestEnd := bestOf(best, matchAt(pos, best.s, load3232(src, best.s), -1))
-					if pos := candidateEnd.prev - e.cur - best.length; pos >= 0 {
-						bestEnd = bestOf(bestEnd, matchAt(pos, best.s, load3232(src, best.s), -1))
+
+			// Start check at a fixed offset to allow for a few mismatches.
+			// For this compression level 2 yields the best results.
+			// We cannot do this if we have already indexed this position.
+			const skipBeginning = 2
+			if best.s > s-skipBeginning {
+				// See if we can find a better match by checking where the current best ends.
+				// Use that offset to see if we can find a better full match.
+				if sAt := best.s + best.length; sAt < sLimit {
+					nextHashL := hashLen(load6432(src, sAt), bestLongTableBits, bestLongLen)
+					candidateEnd := e.longTable[nextHashL]
+
+					if off := candidateEnd.offset - e.cur - best.length + skipBeginning; off >= 0 {
+						improve(&best, off, best.s+skipBeginning, load3232(src, best.s+skipBeginning), -1)
+						if off := candidateEnd.prev - e.cur - best.length + skipBeginning; off >= 0 {
+							improve(&best, off, best.s+skipBeginning, load3232(src, best.s+skipBeginning), -1)
+						}
 					}
-					best = bestEnd
 				}
 			}
 		}
@@ -295,51 +341,34 @@ encodeLoop:
 
 		// We have a match, we can store the forward value
 		if best.rep > 0 {
-			s = best.s
 			var seq seq
 			seq.matchLen = uint32(best.length - zstdMinMatch)
-
-			// We might be able to match backwards.
-			// Extend as long as we can.
-			start := best.s
-			// We end the search early, so we don't risk 0 literals
-			// and have to do special offset treatment.
-			startLimit := nextEmit + 1
-
-			tMin := s - e.maxMatchOff
-			if tMin < 0 {
-				tMin = 0
-			}
-			repIndex := best.offset
-			for repIndex > tMin && start > startLimit && src[repIndex-1] == src[start-1] && seq.matchLen < maxMatchLength-zstdMinMatch-1 {
-				repIndex--
-				start--
-				seq.matchLen++
+			if debugAsserts && s <= nextEmit {
+				panic("s <= nextEmit")
 			}
-			addLiterals(&seq, start)
+			addLiterals(&seq, best.s)
 
-			// rep 0
-			seq.offset = uint32(best.rep)
+			// Repeat. If bit 4 is set, this is a non-lit repeat.
+			seq.offset = uint32(best.rep & 3)
 			if debugSequences {
 				println("repeat sequence", seq, "next s:", s)
 			}
 			blk.sequences = append(blk.sequences, seq)
 
-			// Index match start+1 (long) -> s - 1
-			index0 := s
+			// Index old s + 1 -> s - 1
+			index0 := s + 1
 			s = best.s + best.length
 
 			nextEmit = s
 			if s >= sLimit {
 				if debugEncoder {
 					println("repeat ended", s, best.length)
-
 				}
 				break encodeLoop
 			}
 			// Index skipped...
 			off := index0 + e.cur
-			for index0 < s-1 {
+			for index0 < s {
 				cv0 := load6432(src, index0)
 				h0 := hashLen(cv0, bestLongTableBits, bestLongLen)
 				h1 := hashLen(cv0, bestShortTableBits, bestShortLen)
@@ -349,17 +378,19 @@ encodeLoop:
 				index0++
 			}
 			switch best.rep {
-			case 2:
+			case 2, 4 | 1:
 				offset1, offset2 = offset2, offset1
-			case 3:
+			case 3, 4 | 2:
 				offset1, offset2, offset3 = offset3, offset1, offset2
+			case 4 | 3:
+				offset1, offset2, offset3 = offset1-1, offset1, offset2
 			}
-			cv = load6432(src, s)
 			continue
 		}
 
 		// A 4-byte match has been found. Update recent offsets.
 		// We'll later see if more than 4 bytes.
+		index0 := s + 1
 		s = best.s
 		t := best.offset
 		offset1, offset2, offset3 = s-t, offset1, offset2
@@ -372,22 +403,9 @@ encodeLoop:
 			panic("invalid offset")
 		}
 
-		// Extend the n-byte match as long as possible.
-		l := best.length
-
-		// Extend backwards
-		tMin := s - e.maxMatchOff
-		if tMin < 0 {
-			tMin = 0
-		}
-		for t > tMin && s > nextEmit && src[t-1] == src[s-1] && l < maxMatchLength {
-			s--
-			t--
-			l++
-		}
-
 		// Write our sequence
 		var seq seq
+		l := best.length
 		seq.litLen = uint32(s - nextEmit)
 		seq.matchLen = uint32(l - zstdMinMatch)
 		if seq.litLen > 0 {
@@ -404,10 +422,8 @@ encodeLoop:
 			break encodeLoop
 		}
 
-		// Index match start+1 (long) -> s - 1
-		index0 := s - l + 1
-		// every entry
-		for index0 < s-1 {
+		// Index old s + 1 -> s - 1
+		for index0 < s {
 			cv0 := load6432(src, index0)
 			h0 := hashLen(cv0, bestLongTableBits, bestLongLen)
 			h1 := hashLen(cv0, bestShortTableBits, bestShortLen)
@@ -416,50 +432,6 @@ encodeLoop:
 			e.table[h1] = prevEntry{offset: off, prev: e.table[h1].offset}
 			index0++
 		}
-
-		cv = load6432(src, s)
-		if !canRepeat {
-			continue
-		}
-
-		// Check offset 2
-		for {
-			o2 := s - offset2
-			if load3232(src, o2) != uint32(cv) {
-				// Do regular search
-				break
-			}
-
-			// Store this, since we have it.
-			nextHashS := hashLen(cv, bestShortTableBits, bestShortLen)
-			nextHashL := hashLen(cv, bestLongTableBits, bestLongLen)
-
-			// We have at least 4 byte match.
-			// No need to check backwards. We come straight from a match
-			l := 4 + e.matchlen(s+4, o2+4, src)
-
-			e.longTable[nextHashL] = prevEntry{offset: s + e.cur, prev: e.longTable[nextHashL].offset}
-			e.table[nextHashS] = prevEntry{offset: s + e.cur, prev: e.table[nextHashS].offset}
-			seq.matchLen = uint32(l) - zstdMinMatch
-			seq.litLen = 0
-
-			// Since litlen is always 0, this is offset 1.
-			seq.offset = 1
-			s += l
-			nextEmit = s
-			if debugSequences {
-				println("sequence", seq, "next s:", s)
-			}
-			blk.sequences = append(blk.sequences, seq)
-
-			// Swap offset 1 and 2.
-			offset1, offset2 = offset2, offset1
-			if s >= sLimit {
-				// Finished
-				break encodeLoop
-			}
-			cv = load6432(src, s)
-		}
 	}
 
 	if int(nextEmit) < len(src) {
diff --git a/vendor/github.com/klauspost/compress/zstd/enc_better.go b/vendor/github.com/klauspost/compress/zstd/enc_better.go
index 602c05ee..8582f31a 100644
--- a/vendor/github.com/klauspost/compress/zstd/enc_better.go
+++ b/vendor/github.com/klauspost/compress/zstd/enc_better.go
@@ -62,14 +62,10 @@ func (e *betterFastEncoder) Encode(blk *blockEnc, src []byte) {
 	)
 
 	// Protect against e.cur wraparound.
-	for e.cur >= bufferReset {
+	for e.cur >= e.bufferReset-int32(len(e.hist)) {
 		if len(e.hist) == 0 {
-			for i := range e.table[:] {
-				e.table[i] = tableEntry{}
-			}
-			for i := range e.longTable[:] {
-				e.longTable[i] = prevEntry{}
-			}
+			e.table = [betterShortTableSize]tableEntry{}
+			e.longTable = [betterLongTableSize]prevEntry{}
 			e.cur = e.maxMatchOff
 			break
 		}
@@ -156,8 +152,8 @@ encodeLoop:
 				panic("offset0 was 0")
 			}
 
-			nextHashS := hashLen(cv, betterShortTableBits, betterShortLen)
 			nextHashL := hashLen(cv, betterLongTableBits, betterLongLen)
+			nextHashS := hashLen(cv, betterShortTableBits, betterShortLen)
 			candidateL := e.longTable[nextHashL]
 			candidateS := e.table[nextHashS]
 
@@ -416,15 +412,23 @@ encodeLoop:
 
 		// Try to find a better match by searching for a long match at the end of the current best match
 		if s+matched < sLimit {
+			// Allow some bytes at the beginning to mismatch.
+			// Sweet spot is around 3 bytes, but depends on input.
+			// The skipped bytes are tested in Extend backwards,
+			// and still picked up as part of the match if they do.
+			const skipBeginning = 3
+
 			nextHashL := hashLen(load6432(src, s+matched), betterLongTableBits, betterLongLen)
-			cv := load3232(src, s)
+			s2 := s + skipBeginning
+			cv := load3232(src, s2)
 			candidateL := e.longTable[nextHashL]
-			coffsetL := candidateL.offset - e.cur - matched
-			if coffsetL >= 0 && coffsetL < s && s-coffsetL < e.maxMatchOff && cv == load3232(src, coffsetL) {
+			coffsetL := candidateL.offset - e.cur - matched + skipBeginning
+			if coffsetL >= 0 && coffsetL < s2 && s2-coffsetL < e.maxMatchOff && cv == load3232(src, coffsetL) {
 				// Found a long match, at least 4 bytes.
-				matchedNext := e.matchlen(s+4, coffsetL+4, src) + 4
+				matchedNext := e.matchlen(s2+4, coffsetL+4, src) + 4
 				if matchedNext > matched {
 					t = coffsetL
+					s = s2
 					matched = matchedNext
 					if debugMatches {
 						println("long match at end-of-match")
@@ -434,12 +438,13 @@ encodeLoop:
 
 			// Check prev long...
 			if true {
-				coffsetL = candidateL.prev - e.cur - matched
-				if coffsetL >= 0 && coffsetL < s && s-coffsetL < e.maxMatchOff && cv == load3232(src, coffsetL) {
+				coffsetL = candidateL.prev - e.cur - matched + skipBeginning
+				if coffsetL >= 0 && coffsetL < s2 && s2-coffsetL < e.maxMatchOff && cv == load3232(src, coffsetL) {
 					// Found a long match, at least 4 bytes.
-					matchedNext := e.matchlen(s+4, coffsetL+4, src) + 4
+					matchedNext := e.matchlen(s2+4, coffsetL+4, src) + 4
 					if matchedNext > matched {
 						t = coffsetL
+						s = s2
 						matched = matchedNext
 						if debugMatches {
 							println("prev long match at end-of-match")
@@ -518,8 +523,8 @@ encodeLoop:
 			}
 
 			// Store this, since we have it.
-			nextHashS := hashLen(cv, betterShortTableBits, betterShortLen)
 			nextHashL := hashLen(cv, betterLongTableBits, betterLongLen)
+			nextHashS := hashLen(cv, betterShortTableBits, betterShortLen)
 
 			// We have at least 4 byte match.
 			// No need to check backwards. We come straight from a match
@@ -578,7 +583,7 @@ func (e *betterFastEncoderDict) Encode(blk *blockEnc, src []byte) {
 	)
 
 	// Protect against e.cur wraparound.
-	for e.cur >= bufferReset {
+	for e.cur >= e.bufferReset-int32(len(e.hist)) {
 		if len(e.hist) == 0 {
 			for i := range e.table[:] {
 				e.table[i] = tableEntry{}
@@ -674,8 +679,8 @@ encodeLoop:
 				panic("offset0 was 0")
 			}
 
-			nextHashS := hashLen(cv, betterShortTableBits, betterShortLen)
 			nextHashL := hashLen(cv, betterLongTableBits, betterLongLen)
+			nextHashS := hashLen(cv, betterShortTableBits, betterShortLen)
 			candidateL := e.longTable[nextHashL]
 			candidateS := e.table[nextHashS]
 
@@ -1047,8 +1052,8 @@ encodeLoop:
 			}
 
 			// Store this, since we have it.
-			nextHashS := hashLen(cv, betterShortTableBits, betterShortLen)
 			nextHashL := hashLen(cv, betterLongTableBits, betterLongLen)
+			nextHashS := hashLen(cv, betterShortTableBits, betterShortLen)
 
 			// We have at least 4 byte match.
 			// No need to check backwards. We come straight from a match
diff --git a/vendor/github.com/klauspost/compress/zstd/enc_dfast.go b/vendor/github.com/klauspost/compress/zstd/enc_dfast.go
index d6b31042..a154c18f 100644
--- a/vendor/github.com/klauspost/compress/zstd/enc_dfast.go
+++ b/vendor/github.com/klauspost/compress/zstd/enc_dfast.go
@@ -44,14 +44,10 @@ func (e *doubleFastEncoder) Encode(blk *blockEnc, src []byte) {
 	)
 
 	// Protect against e.cur wraparound.
-	for e.cur >= bufferReset {
+	for e.cur >= e.bufferReset-int32(len(e.hist)) {
 		if len(e.hist) == 0 {
-			for i := range e.table[:] {
-				e.table[i] = tableEntry{}
-			}
-			for i := range e.longTable[:] {
-				e.longTable[i] = tableEntry{}
-			}
+			e.table = [dFastShortTableSize]tableEntry{}
+			e.longTable = [dFastLongTableSize]tableEntry{}
 			e.cur = e.maxMatchOff
 			break
 		}
@@ -127,8 +123,8 @@ encodeLoop:
 				panic("offset0 was 0")
 			}
 
-			nextHashS := hashLen(cv, dFastShortTableBits, dFastShortLen)
 			nextHashL := hashLen(cv, dFastLongTableBits, dFastLongLen)
+			nextHashS := hashLen(cv, dFastShortTableBits, dFastShortLen)
 			candidateL := e.longTable[nextHashL]
 			candidateS := e.table[nextHashS]
 
@@ -388,7 +384,7 @@ func (e *doubleFastEncoder) EncodeNoHist(blk *blockEnc, src []byte) {
 	)
 
 	// Protect against e.cur wraparound.
-	if e.cur >= bufferReset {
+	if e.cur >= e.bufferReset {
 		for i := range e.table[:] {
 			e.table[i] = tableEntry{}
 		}
@@ -439,8 +435,8 @@ encodeLoop:
 		var t int32
 		for {
 
-			nextHashS := hashLen(cv, dFastShortTableBits, dFastShortLen)
 			nextHashL := hashLen(cv, dFastLongTableBits, dFastLongLen)
+			nextHashS := hashLen(cv, dFastShortTableBits, dFastShortLen)
 			candidateL := e.longTable[nextHashL]
 			candidateS := e.table[nextHashS]
 
@@ -685,7 +681,7 @@ encodeLoop:
 	}
 
 	// We do not store history, so we must offset e.cur to avoid false matches for next user.
-	if e.cur < bufferReset {
+	if e.cur < e.bufferReset {
 		e.cur += int32(len(src))
 	}
 }
@@ -700,7 +696,7 @@ func (e *doubleFastEncoderDict) Encode(blk *blockEnc, src []byte) {
 	)
 
 	// Protect against e.cur wraparound.
-	for e.cur >= bufferReset {
+	for e.cur >= e.bufferReset-int32(len(e.hist)) {
 		if len(e.hist) == 0 {
 			for i := range e.table[:] {
 				e.table[i] = tableEntry{}
@@ -785,8 +781,8 @@ encodeLoop:
 				panic("offset0 was 0")
 			}
 
-			nextHashS := hashLen(cv, dFastShortTableBits, dFastShortLen)
 			nextHashL := hashLen(cv, dFastLongTableBits, dFastLongLen)
+			nextHashS := hashLen(cv, dFastShortTableBits, dFastShortLen)
 			candidateL := e.longTable[nextHashL]
 			candidateS := e.table[nextHashS]
 
@@ -969,7 +965,7 @@ encodeLoop:
 		te0 := tableEntry{offset: index0 + e.cur, val: uint32(cv0)}
 		te1 := tableEntry{offset: index1 + e.cur, val: uint32(cv1)}
 		longHash1 := hashLen(cv0, dFastLongTableBits, dFastLongLen)
-		longHash2 := hashLen(cv0, dFastLongTableBits, dFastLongLen)
+		longHash2 := hashLen(cv1, dFastLongTableBits, dFastLongLen)
 		e.longTable[longHash1] = te0
 		e.longTable[longHash2] = te1
 		e.markLongShardDirty(longHash1)
@@ -1002,8 +998,8 @@ encodeLoop:
 			}
 
 			// Store this, since we have it.
-			nextHashS := hashLen(cv, dFastShortTableBits, dFastShortLen)
 			nextHashL := hashLen(cv, dFastLongTableBits, dFastLongLen)
+			nextHashS := hashLen(cv, dFastShortTableBits, dFastShortLen)
 
 			// We have at least 4 byte match.
 			// No need to check backwards. We come straight from a match
@@ -1088,7 +1084,7 @@ func (e *doubleFastEncoderDict) Reset(d *dict, singleBlock bool) {
 			}
 		}
 		e.lastDictID = d.id
-		e.allDirty = true
+		allDirty = true
 	}
 	// Reset table to initial state
 	e.cur = e.maxMatchOff
@@ -1103,7 +1099,8 @@ func (e *doubleFastEncoderDict) Reset(d *dict, singleBlock bool) {
 	}
 
 	if allDirty || dirtyShardCnt > dLongTableShardCnt/2 {
-		copy(e.longTable[:], e.dictLongTable)
+		//copy(e.longTable[:], e.dictLongTable)
+		e.longTable = *(*[dFastLongTableSize]tableEntry)(e.dictLongTable)
 		for i := range e.longTableShardDirty {
 			e.longTableShardDirty[i] = false
 		}
@@ -1114,7 +1111,9 @@ func (e *doubleFastEncoderDict) Reset(d *dict, singleBlock bool) {
 			continue
 		}
 
-		copy(e.longTable[i*dLongTableShardSize:(i+1)*dLongTableShardSize], e.dictLongTable[i*dLongTableShardSize:(i+1)*dLongTableShardSize])
+		// copy(e.longTable[i*dLongTableShardSize:(i+1)*dLongTableShardSize], e.dictLongTable[i*dLongTableShardSize:(i+1)*dLongTableShardSize])
+		*(*[dLongTableShardSize]tableEntry)(e.longTable[i*dLongTableShardSize:]) = *(*[dLongTableShardSize]tableEntry)(e.dictLongTable[i*dLongTableShardSize:])
+
 		e.longTableShardDirty[i] = false
 	}
 }
diff --git a/vendor/github.com/klauspost/compress/zstd/enc_fast.go b/vendor/github.com/klauspost/compress/zstd/enc_fast.go
index f2502629..f45a3da7 100644
--- a/vendor/github.com/klauspost/compress/zstd/enc_fast.go
+++ b/vendor/github.com/klauspost/compress/zstd/enc_fast.go
@@ -6,8 +6,6 @@ package zstd
 
 import (
 	"fmt"
-	"math"
-	"math/bits"
 )
 
 const (
@@ -45,7 +43,7 @@ func (e *fastEncoder) Encode(blk *blockEnc, src []byte) {
 	)
 
 	// Protect against e.cur wraparound.
-	for e.cur >= bufferReset {
+	for e.cur >= e.bufferReset-int32(len(e.hist)) {
 		if len(e.hist) == 0 {
 			for i := range e.table[:] {
 				e.table[i] = tableEntry{}
@@ -87,7 +85,7 @@ func (e *fastEncoder) Encode(blk *blockEnc, src []byte) {
 	// TEMPLATE
 	const hashLog = tableBits
 	// seems global, but would be nice to tweak.
-	const kSearchStrength = 7
+	const kSearchStrength = 6
 
 	// nextEmit is where in src the next emitLiteral should start from.
 	nextEmit := s
@@ -135,21 +133,7 @@ encodeLoop:
 			if canRepeat && repIndex >= 0 && load3232(src, repIndex) == uint32(cv>>16) {
 				// Consider history as well.
 				var seq seq
-				var length int32
-				// length = 4 + e.matchlen(s+6, repIndex+4, src)
-				{
-					a := src[s+6:]
-					b := src[repIndex+4:]
-					endI := len(a) & (math.MaxInt32 - 7)
-					length = int32(endI) + 4
-					for i := 0; i < endI; i += 8 {
-						if diff := load64(a, i) ^ load64(b, i); diff != 0 {
-							length = int32(i+bits.TrailingZeros64(diff)>>3) + 4
-							break
-						}
-					}
-				}
-
+				length := 4 + e.matchlen(s+6, repIndex+4, src)
 				seq.matchLen = uint32(length - zstdMinMatch)
 
 				// We might be able to match backwards.
@@ -236,20 +220,7 @@ encodeLoop:
 		}
 
 		// Extend the 4-byte match as long as possible.
-		//l := e.matchlen(s+4, t+4, src) + 4
-		var l int32
-		{
-			a := src[s+4:]
-			b := src[t+4:]
-			endI := len(a) & (math.MaxInt32 - 7)
-			l = int32(endI) + 4
-			for i := 0; i < endI; i += 8 {
-				if diff := load64(a, i) ^ load64(b, i); diff != 0 {
-					l = int32(i+bits.TrailingZeros64(diff)>>3) + 4
-					break
-				}
-			}
-		}
+		l := e.matchlen(s+4, t+4, src) + 4
 
 		// Extend backwards
 		tMin := s - e.maxMatchOff
@@ -286,20 +257,7 @@ encodeLoop:
 		if o2 := s - offset2; canRepeat && load3232(src, o2) == uint32(cv) {
 			// We have at least 4 byte match.
 			// No need to check backwards. We come straight from a match
-			//l := 4 + e.matchlen(s+4, o2+4, src)
-			var l int32
-			{
-				a := src[s+4:]
-				b := src[o2+4:]
-				endI := len(a) & (math.MaxInt32 - 7)
-				l = int32(endI) + 4
-				for i := 0; i < endI; i += 8 {
-					if diff := load64(a, i) ^ load64(b, i); diff != 0 {
-						l = int32(i+bits.TrailingZeros64(diff)>>3) + 4
-						break
-					}
-				}
-			}
+			l := 4 + e.matchlen(s+4, o2+4, src)
 
 			// Store this, since we have it.
 			nextHash := hashLen(cv, hashLog, tableFastHashLen)
@@ -345,13 +303,13 @@ func (e *fastEncoder) EncodeNoHist(blk *blockEnc, src []byte) {
 		minNonLiteralBlockSize = 1 + 1 + inputMargin
 	)
 	if debugEncoder {
-		if len(src) > maxBlockSize {
+		if len(src) > maxCompressedBlockSize {
 			panic("src too big")
 		}
 	}
 
 	// Protect against e.cur wraparound.
-	if e.cur >= bufferReset {
+	if e.cur >= e.bufferReset {
 		for i := range e.table[:] {
 			e.table[i] = tableEntry{}
 		}
@@ -375,7 +333,7 @@ func (e *fastEncoder) EncodeNoHist(blk *blockEnc, src []byte) {
 	// TEMPLATE
 	const hashLog = tableBits
 	// seems global, but would be nice to tweak.
-	const kSearchStrength = 8
+	const kSearchStrength = 6
 
 	// nextEmit is where in src the next emitLiteral should start from.
 	nextEmit := s
@@ -418,21 +376,7 @@ encodeLoop:
 			if len(blk.sequences) > 2 && load3232(src, repIndex) == uint32(cv>>16) {
 				// Consider history as well.
 				var seq seq
-				// length := 4 + e.matchlen(s+6, repIndex+4, src)
-				// length := 4 + int32(matchLen(src[s+6:], src[repIndex+4:]))
-				var length int32
-				{
-					a := src[s+6:]
-					b := src[repIndex+4:]
-					endI := len(a) & (math.MaxInt32 - 7)
-					length = int32(endI) + 4
-					for i := 0; i < endI; i += 8 {
-						if diff := load64(a, i) ^ load64(b, i); diff != 0 {
-							length = int32(i+bits.TrailingZeros64(diff)>>3) + 4
-							break
-						}
-					}
-				}
+				length := 4 + e.matchlen(s+6, repIndex+4, src)
 
 				seq.matchLen = uint32(length - zstdMinMatch)
 
@@ -522,21 +466,7 @@ encodeLoop:
 			panic(fmt.Sprintf("t (%d) < 0 ", t))
 		}
 		// Extend the 4-byte match as long as possible.
-		//l := e.matchlenNoHist(s+4, t+4, src) + 4
-		// l := int32(matchLen(src[s+4:], src[t+4:])) + 4
-		var l int32
-		{
-			a := src[s+4:]
-			b := src[t+4:]
-			endI := len(a) & (math.MaxInt32 - 7)
-			l = int32(endI) + 4
-			for i := 0; i < endI; i += 8 {
-				if diff := load64(a, i) ^ load64(b, i); diff != 0 {
-					l = int32(i+bits.TrailingZeros64(diff)>>3) + 4
-					break
-				}
-			}
-		}
+		l := e.matchlen(s+4, t+4, src) + 4
 
 		// Extend backwards
 		tMin := s - e.maxMatchOff
@@ -573,21 +503,7 @@ encodeLoop:
 		if o2 := s - offset2; len(blk.sequences) > 2 && load3232(src, o2) == uint32(cv) {
 			// We have at least 4 byte match.
 			// No need to check backwards. We come straight from a match
-			//l := 4 + e.matchlenNoHist(s+4, o2+4, src)
-			// l := 4 + int32(matchLen(src[s+4:], src[o2+4:]))
-			var l int32
-			{
-				a := src[s+4:]
-				b := src[o2+4:]
-				endI := len(a) & (math.MaxInt32 - 7)
-				l = int32(endI) + 4
-				for i := 0; i < endI; i += 8 {
-					if diff := load64(a, i) ^ load64(b, i); diff != 0 {
-						l = int32(i+bits.TrailingZeros64(diff)>>3) + 4
-						break
-					}
-				}
-			}
+			l := 4 + e.matchlen(s+4, o2+4, src)
 
 			// Store this, since we have it.
 			nextHash := hashLen(cv, hashLog, tableFastHashLen)
@@ -621,7 +537,7 @@ encodeLoop:
 		println("returning, recent offsets:", blk.recentOffsets, "extra literals:", blk.extraLits)
 	}
 	// We do not store history, so we must offset e.cur to avoid false matches for next user.
-	if e.cur < bufferReset {
+	if e.cur < e.bufferReset {
 		e.cur += int32(len(src))
 	}
 }
@@ -638,11 +554,9 @@ func (e *fastEncoderDict) Encode(blk *blockEnc, src []byte) {
 		return
 	}
 	// Protect against e.cur wraparound.
-	for e.cur >= bufferReset {
+	for e.cur >= e.bufferReset-int32(len(e.hist)) {
 		if len(e.hist) == 0 {
-			for i := range e.table[:] {
-				e.table[i] = tableEntry{}
-			}
+			e.table = [tableSize]tableEntry{}
 			e.cur = e.maxMatchOff
 			break
 		}
@@ -730,20 +644,7 @@ encodeLoop:
 			if canRepeat && repIndex >= 0 && load3232(src, repIndex) == uint32(cv>>16) {
 				// Consider history as well.
 				var seq seq
-				var length int32
-				// length = 4 + e.matchlen(s+6, repIndex+4, src)
-				{
-					a := src[s+6:]
-					b := src[repIndex+4:]
-					endI := len(a) & (math.MaxInt32 - 7)
-					length = int32(endI) + 4
-					for i := 0; i < endI; i += 8 {
-						if diff := load64(a, i) ^ load64(b, i); diff != 0 {
-							length = int32(i+bits.TrailingZeros64(diff)>>3) + 4
-							break
-						}
-					}
-				}
+				length := 4 + e.matchlen(s+6, repIndex+4, src)
 
 				seq.matchLen = uint32(length - zstdMinMatch)
 
@@ -831,20 +732,7 @@ encodeLoop:
 		}
 
 		// Extend the 4-byte match as long as possible.
-		//l := e.matchlen(s+4, t+4, src) + 4
-		var l int32
-		{
-			a := src[s+4:]
-			b := src[t+4:]
-			endI := len(a) & (math.MaxInt32 - 7)
-			l = int32(endI) + 4
-			for i := 0; i < endI; i += 8 {
-				if diff := load64(a, i) ^ load64(b, i); diff != 0 {
-					l = int32(i+bits.TrailingZeros64(diff)>>3) + 4
-					break
-				}
-			}
-		}
+		l := e.matchlen(s+4, t+4, src) + 4
 
 		// Extend backwards
 		tMin := s - e.maxMatchOff
@@ -881,20 +769,7 @@ encodeLoop:
 		if o2 := s - offset2; canRepeat && load3232(src, o2) == uint32(cv) {
 			// We have at least 4 byte match.
 			// No need to check backwards. We come straight from a match
-			//l := 4 + e.matchlen(s+4, o2+4, src)
-			var l int32
-			{
-				a := src[s+4:]
-				b := src[o2+4:]
-				endI := len(a) & (math.MaxInt32 - 7)
-				l = int32(endI) + 4
-				for i := 0; i < endI; i += 8 {
-					if diff := load64(a, i) ^ load64(b, i); diff != 0 {
-						l = int32(i+bits.TrailingZeros64(diff)>>3) + 4
-						break
-					}
-				}
-			}
+			l := 4 + e.matchlen(s+4, o2+4, src)
 
 			// Store this, since we have it.
 			nextHash := hashLen(cv, hashLog, tableFastHashLen)
@@ -954,13 +829,12 @@ func (e *fastEncoderDict) Reset(d *dict, singleBlock bool) {
 		}
 		if true {
 			end := e.maxMatchOff + int32(len(d.content)) - 8
-			for i := e.maxMatchOff; i < end; i += 3 {
+			for i := e.maxMatchOff; i < end; i += 2 {
 				const hashLog = tableBits
 
 				cv := load6432(d.content, i-e.maxMatchOff)
-				nextHash := hashLen(cv, hashLog, tableFastHashLen)      // 0 -> 5
-				nextHash1 := hashLen(cv>>8, hashLog, tableFastHashLen)  // 1 -> 6
-				nextHash2 := hashLen(cv>>16, hashLog, tableFastHashLen) // 2 -> 7
+				nextHash := hashLen(cv, hashLog, tableFastHashLen)     // 0 -> 6
+				nextHash1 := hashLen(cv>>8, hashLog, tableFastHashLen) // 1 -> 7
 				e.dictTable[nextHash] = tableEntry{
 					val:    uint32(cv),
 					offset: i,
@@ -969,10 +843,6 @@ func (e *fastEncoderDict) Reset(d *dict, singleBlock bool) {
 					val:    uint32(cv >> 8),
 					offset: i + 1,
 				}
-				e.dictTable[nextHash2] = tableEntry{
-					val:    uint32(cv >> 16),
-					offset: i + 2,
-				}
 			}
 		}
 		e.lastDictID = d.id
@@ -992,7 +862,8 @@ func (e *fastEncoderDict) Reset(d *dict, singleBlock bool) {
 	const shardCnt = tableShardCnt
 	const shardSize = tableShardSize
 	if e.allDirty || dirtyShardCnt > shardCnt*4/6 {
-		copy(e.table[:], e.dictTable)
+		//copy(e.table[:], e.dictTable)
+		e.table = *(*[tableSize]tableEntry)(e.dictTable)
 		for i := range e.tableShardDirty {
 			e.tableShardDirty[i] = false
 		}
@@ -1004,7 +875,8 @@ func (e *fastEncoderDict) Reset(d *dict, singleBlock bool) {
 			continue
 		}
 
-		copy(e.table[i*shardSize:(i+1)*shardSize], e.dictTable[i*shardSize:(i+1)*shardSize])
+		//copy(e.table[i*shardSize:(i+1)*shardSize], e.dictTable[i*shardSize:(i+1)*shardSize])
+		*(*[shardSize]tableEntry)(e.table[i*shardSize:]) = *(*[shardSize]tableEntry)(e.dictTable[i*shardSize:])
 		e.tableShardDirty[i] = false
 	}
 	e.allDirty = false
diff --git a/vendor/github.com/klauspost/compress/zstd/encoder.go b/vendor/github.com/klauspost/compress/zstd/encoder.go
index e6e31596..4de0aed0 100644
--- a/vendor/github.com/klauspost/compress/zstd/encoder.go
+++ b/vendor/github.com/klauspost/compress/zstd/encoder.go
@@ -8,6 +8,7 @@ import (
 	"crypto/rand"
 	"fmt"
 	"io"
+	"math"
 	rdebug "runtime/debug"
 	"sync"
 
@@ -98,23 +99,25 @@ func (e *Encoder) Reset(w io.Writer) {
 	if cap(s.filling) == 0 {
 		s.filling = make([]byte, 0, e.o.blockSize)
 	}
-	if cap(s.current) == 0 {
-		s.current = make([]byte, 0, e.o.blockSize)
-	}
-	if cap(s.previous) == 0 {
-		s.previous = make([]byte, 0, e.o.blockSize)
+	if e.o.concurrent > 1 {
+		if cap(s.current) == 0 {
+			s.current = make([]byte, 0, e.o.blockSize)
+		}
+		if cap(s.previous) == 0 {
+			s.previous = make([]byte, 0, e.o.blockSize)
+		}
+		s.current = s.current[:0]
+		s.previous = s.previous[:0]
+		if s.writing == nil {
+			s.writing = &blockEnc{lowMem: e.o.lowMem}
+			s.writing.init()
+		}
+		s.writing.initNewEncode()
 	}
 	if s.encoder == nil {
 		s.encoder = e.o.encoder()
 	}
-	if s.writing == nil {
-		s.writing = &blockEnc{lowMem: e.o.lowMem}
-		s.writing.init()
-	}
-	s.writing.initNewEncode()
 	s.filling = s.filling[:0]
-	s.current = s.current[:0]
-	s.previous = s.previous[:0]
 	s.encoder.Reset(e.o.dict, false)
 	s.headerWritten = false
 	s.eofWritten = false
@@ -258,6 +261,32 @@ func (e *Encoder) nextBlock(final bool) error {
 		return s.err
 	}
 
+	// SYNC:
+	if e.o.concurrent == 1 {
+		src := s.filling
+		s.nInput += int64(len(s.filling))
+		if debugEncoder {
+			println("Adding sync block,", len(src), "bytes, final:", final)
+		}
+		enc := s.encoder
+		blk := enc.Block()
+		blk.reset(nil)
+		enc.Encode(blk, src)
+		blk.last = final
+		if final {
+			s.eofWritten = true
+		}
+
+		s.err = blk.encode(src, e.o.noEntropy, !e.o.allLitEntropy)
+		if s.err != nil {
+			return s.err
+		}
+		_, s.err = s.w.Write(blk.output)
+		s.nWritten += int64(len(blk.output))
+		s.filling = s.filling[:0]
+		return s.err
+	}
+
 	// Move blocks forward.
 	s.filling, s.current, s.previous = s.previous[:0], s.filling, s.current
 	s.nInput += int64(len(s.current))
@@ -300,22 +329,8 @@ func (e *Encoder) nextBlock(final bool) error {
 				}
 				s.wWg.Done()
 			}()
-			err := errIncompressible
-			// If we got the exact same number of literals as input,
-			// assume the literals cannot be compressed.
-			if len(src) != len(blk.literals) || len(src) != e.o.blockSize {
-				err = blk.encode(src, e.o.noEntropy, !e.o.allLitEntropy)
-			}
-			switch err {
-			case errIncompressible:
-				if debugEncoder {
-					println("Storing incompressible block as raw")
-				}
-				blk.encodeRaw(src)
-				// In fast mode, we do not transfer offsets, so we don't have to deal with changing the.
-			case nil:
-			default:
-				s.writeErr = err
+			s.writeErr = blk.encode(src, e.o.noEntropy, !e.o.allLitEntropy)
+			if s.writeErr != nil {
 				return
 			}
 			_, s.writeErr = s.w.Write(blk.output)
@@ -486,8 +501,8 @@ func (e *Encoder) EncodeAll(src, dst []byte) []byte {
 		// If a non-single block is needed the encoder will reset again.
 		e.encoders <- enc
 	}()
-	// Use single segments when above minimum window and below 1MB.
-	single := len(src) < 1<<20 && len(src) > MinWindowSize
+	// Use single segments when above minimum window and below window size.
+	single := len(src) <= e.o.windowSize && len(src) > MinWindowSize
 	if e.o.single != nil {
 		single = *e.o.single
 	}
@@ -509,7 +524,7 @@ func (e *Encoder) EncodeAll(src, dst []byte) []byte {
 	}
 
 	// If we can do everything in one block, prefer that.
-	if len(src) <= maxCompressedBlockSize {
+	if len(src) <= e.o.blockSize {
 		enc.Reset(e.o.dict, true)
 		// Slightly faster with no history and everything in one block.
 		if e.o.crc {
@@ -525,25 +540,15 @@ func (e *Encoder) EncodeAll(src, dst []byte) []byte {
 
 		// If we got the exact same number of literals as input,
 		// assume the literals cannot be compressed.
-		err := errIncompressible
 		oldout := blk.output
-		if len(blk.literals) != len(src) || len(src) != e.o.blockSize {
-			// Output directly to dst
-			blk.output = dst
-			err = blk.encode(src, e.o.noEntropy, !e.o.allLitEntropy)
-		}
+		// Output directly to dst
+		blk.output = dst
 
-		switch err {
-		case errIncompressible:
-			if debugEncoder {
-				println("Storing incompressible block as raw")
-			}
-			dst = blk.encodeRawTo(dst, src)
-		case nil:
-			dst = blk.output
-		default:
+		err := blk.encode(src, e.o.noEntropy, !e.o.allLitEntropy)
+		if err != nil {
 			panic(err)
 		}
+		dst = blk.output
 		blk.output = oldout
 	} else {
 		enc.Reset(e.o.dict, false)
@@ -562,25 +567,11 @@ func (e *Encoder) EncodeAll(src, dst []byte) []byte {
 			if len(src) == 0 {
 				blk.last = true
 			}
-			err := errIncompressible
-			// If we got the exact same number of literals as input,
-			// assume the literals cannot be compressed.
-			if len(blk.literals) != len(todo) || len(todo) != e.o.blockSize {
-				err = blk.encode(todo, e.o.noEntropy, !e.o.allLitEntropy)
-			}
-
-			switch err {
-			case errIncompressible:
-				if debugEncoder {
-					println("Storing incompressible block as raw")
-				}
-				dst = blk.encodeRawTo(dst, todo)
-				blk.popOffsets()
-			case nil:
-				dst = append(dst, blk.output...)
-			default:
+			err := blk.encode(todo, e.o.noEntropy, !e.o.allLitEntropy)
+			if err != nil {
 				panic(err)
 			}
+			dst = append(dst, blk.output...)
 			blk.reset(nil)
 		}
 	}
@@ -597,3 +588,37 @@ func (e *Encoder) EncodeAll(src, dst []byte) []byte {
 	}
 	return dst
 }
+
+// MaxEncodedSize returns the expected maximum
+// size of an encoded block or stream.
+func (e *Encoder) MaxEncodedSize(size int) int {
+	frameHeader := 4 + 2 // magic + frame header & window descriptor
+	if e.o.dict != nil {
+		frameHeader += 4
+	}
+	// Frame content size:
+	if size < 256 {
+		frameHeader++
+	} else if size < 65536+256 {
+		frameHeader += 2
+	} else if size < math.MaxInt32 {
+		frameHeader += 4
+	} else {
+		frameHeader += 8
+	}
+	// Final crc
+	if e.o.crc {
+		frameHeader += 4
+	}
+
+	// Max overhead is 3 bytes/block.
+	// There cannot be 0 blocks.
+	blocks := (size + e.o.blockSize) / e.o.blockSize
+
+	// Combine, add padding.
+	maxSz := frameHeader + 3*blocks + size
+	if e.o.pad > 1 {
+		maxSz += calcSkippableFrame(int64(maxSz), int64(e.o.pad))
+	}
+	return maxSz
+}
diff --git a/vendor/github.com/klauspost/compress/zstd/encoder_options.go b/vendor/github.com/klauspost/compress/zstd/encoder_options.go
index 7d29e1d6..faaf8192 100644
--- a/vendor/github.com/klauspost/compress/zstd/encoder_options.go
+++ b/vendor/github.com/klauspost/compress/zstd/encoder_options.go
@@ -3,6 +3,8 @@ package zstd
 import (
 	"errors"
 	"fmt"
+	"math"
+	"math/bits"
 	"runtime"
 	"strings"
 )
@@ -24,6 +26,7 @@ type encoderOptions struct {
 	allLitEntropy   bool
 	customWindow    bool
 	customALEntropy bool
+	customBlockSize bool
 	lowMem          bool
 	dict            *dict
 }
@@ -33,10 +36,10 @@ func (o *encoderOptions) setDefault() {
 		concurrent:    runtime.GOMAXPROCS(0),
 		crc:           true,
 		single:        nil,
-		blockSize:     1 << 16,
+		blockSize:     maxCompressedBlockSize,
 		windowSize:    8 << 20,
 		level:         SpeedDefault,
-		allLitEntropy: true,
+		allLitEntropy: false,
 		lowMem:        false,
 	}
 }
@@ -46,22 +49,22 @@ func (o encoderOptions) encoder() encoder {
 	switch o.level {
 	case SpeedFastest:
 		if o.dict != nil {
-			return &fastEncoderDict{fastEncoder: fastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), lowMem: o.lowMem}}}
+			return &fastEncoderDict{fastEncoder: fastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), bufferReset: math.MaxInt32 - int32(o.windowSize*2), lowMem: o.lowMem}}}
 		}
-		return &fastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), lowMem: o.lowMem}}
+		return &fastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), bufferReset: math.MaxInt32 - int32(o.windowSize*2), lowMem: o.lowMem}}
 
 	case SpeedDefault:
 		if o.dict != nil {
-			return &doubleFastEncoderDict{fastEncoderDict: fastEncoderDict{fastEncoder: fastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), lowMem: o.lowMem}}}}
+			return &doubleFastEncoderDict{fastEncoderDict: fastEncoderDict{fastEncoder: fastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), bufferReset: math.MaxInt32 - int32(o.windowSize*2), lowMem: o.lowMem}}}}
 		}
-		return &doubleFastEncoder{fastEncoder: fastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), lowMem: o.lowMem}}}
+		return &doubleFastEncoder{fastEncoder: fastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), bufferReset: math.MaxInt32 - int32(o.windowSize*2), lowMem: o.lowMem}}}
 	case SpeedBetterCompression:
 		if o.dict != nil {
-			return &betterFastEncoderDict{betterFastEncoder: betterFastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), lowMem: o.lowMem}}}
+			return &betterFastEncoderDict{betterFastEncoder: betterFastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), bufferReset: math.MaxInt32 - int32(o.windowSize*2), lowMem: o.lowMem}}}
 		}
-		return &betterFastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), lowMem: o.lowMem}}
+		return &betterFastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), bufferReset: math.MaxInt32 - int32(o.windowSize*2), lowMem: o.lowMem}}
 	case SpeedBestCompression:
-		return &bestFastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), lowMem: o.lowMem}}
+		return &bestFastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), bufferReset: math.MaxInt32 - int32(o.windowSize*2), lowMem: o.lowMem}}
 	}
 	panic("unknown compression level")
 }
@@ -75,6 +78,7 @@ func WithEncoderCRC(b bool) EOption {
 // WithEncoderConcurrency will set the concurrency,
 // meaning the maximum number of encoders to run concurrently.
 // The value supplied must be at least 1.
+// For streams, setting a value of 1 will disable async compression.
 // By default this will be set to GOMAXPROCS.
 func WithEncoderConcurrency(n int) EOption {
 	return func(o *encoderOptions) error {
@@ -106,6 +110,7 @@ func WithWindowSize(n int) EOption {
 		o.customWindow = true
 		if o.blockSize > o.windowSize {
 			o.blockSize = o.windowSize
+			o.customBlockSize = true
 		}
 		return nil
 	}
@@ -124,7 +129,7 @@ func WithEncoderPadding(n int) EOption {
 		}
 		// No need to waste our time.
 		if n == 1 {
-			o.pad = 0
+			n = 0
 		}
 		if n > 1<<30 {
 			return fmt.Errorf("padding must less than 1GB (1<<30 bytes) ")
@@ -188,10 +193,9 @@ func EncoderLevelFromZstd(level int) EncoderLevel {
 		return SpeedDefault
 	case level >= 6 && level < 10:
 		return SpeedBetterCompression
-	case level >= 10:
+	default:
 		return SpeedBestCompression
 	}
-	return SpeedDefault
 }
 
 // String provides a string representation of the compression level.
@@ -222,6 +226,9 @@ func WithEncoderLevel(l EncoderLevel) EOption {
 			switch o.level {
 			case SpeedFastest:
 				o.windowSize = 4 << 20
+				if !o.customBlockSize {
+					o.blockSize = 1 << 16
+				}
 			case SpeedDefault:
 				o.windowSize = 8 << 20
 			case SpeedBetterCompression:
@@ -231,7 +238,7 @@ func WithEncoderLevel(l EncoderLevel) EOption {
 			}
 		}
 		if !o.customALEntropy {
-			o.allLitEntropy = l > SpeedFastest
+			o.allLitEntropy = l > SpeedDefault
 		}
 
 		return nil
@@ -278,7 +285,7 @@ func WithNoEntropyCompression(b bool) EOption {
 // a decoder is allowed to reject a compressed frame which requests a memory size beyond decoder's authorized range.
 // For broader compatibility, decoders are recommended to support memory sizes of at least 8 MB.
 // This is only a recommendation, each decoder is free to support higher or lower limits, depending on local limitations.
-// If this is not specified, block encodes will automatically choose this based on the input size.
+// If this is not specified, block encodes will automatically choose this based on the input size and the window size.
 // This setting has no effect on streamed encodes.
 func WithSingleSegment(b bool) EOption {
 	return func(o *encoderOptions) error {
@@ -299,7 +306,13 @@ func WithLowerEncoderMem(b bool) EOption {
 }
 
 // WithEncoderDict allows to register a dictionary that will be used for the encode.
+//
+// The slice dict must be in the [dictionary format] produced by
+// "zstd --train" from the Zstandard reference implementation.
+//
 // The encoder *may* choose to use no dictionary instead for certain payloads.
+//
+// [dictionary format]: https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#dictionary-format
 func WithEncoderDict(dict []byte) EOption {
 	return func(o *encoderOptions) error {
 		d, err := loadDict(dict)
@@ -310,3 +323,17 @@ func WithEncoderDict(dict []byte) EOption {
 		return nil
 	}
 }
+
+// WithEncoderDictRaw registers a dictionary that may be used by the encoder.
+//
+// The slice content may contain arbitrary data. It will be used as an initial
+// history.
+func WithEncoderDictRaw(id uint32, content []byte) EOption {
+	return func(o *encoderOptions) error {
+		if bits.UintSize > 32 && uint(len(content)) > dictMaxLength {
+			return fmt.Errorf("dictionary of size %d > 2GiB too large", len(content))
+		}
+		o.dict = &dict{id: id, content: content, offsets: [3]int{1, 4, 8}}
+		return nil
+	}
+}
diff --git a/vendor/github.com/klauspost/compress/zstd/framedec.go b/vendor/github.com/klauspost/compress/zstd/framedec.go
index 989c79f8..53e160f7 100644
--- a/vendor/github.com/klauspost/compress/zstd/framedec.go
+++ b/vendor/github.com/klauspost/compress/zstd/framedec.go
@@ -5,26 +5,20 @@
 package zstd
 
 import (
-	"bytes"
+	"encoding/binary"
 	"encoding/hex"
 	"errors"
-	"hash"
 	"io"
-	"sync"
 
 	"github.com/klauspost/compress/zstd/internal/xxhash"
 )
 
 type frameDec struct {
-	o      decoderOptions
-	crc    hash.Hash64
-	offset int64
+	o   decoderOptions
+	crc *xxhash.Digest
 
 	WindowSize uint64
 
-	// In order queue of blocks being decoded.
-	decoding chan *blockDec
-
 	// Frame history passed between blocks
 	history history
 
@@ -34,15 +28,10 @@ type frameDec struct {
 	bBuf byteBuf
 
 	FrameContentSize uint64
-	frameDone        sync.WaitGroup
 
-	DictionaryID  *uint32
+	DictionaryID  uint32
 	HasCheckSum   bool
 	SingleSegment bool
-
-	// asyncRunning indicates whether the async routine processes input on 'decoding'.
-	asyncRunningMu sync.Mutex
-	asyncRunning   bool
 }
 
 const (
@@ -54,9 +43,9 @@ const (
 	MaxWindowSize = 1 << 29
 )
 
-var (
-	frameMagic          = []byte{0x28, 0xb5, 0x2f, 0xfd}
-	skippableFrameMagic = []byte{0x2a, 0x4d, 0x18}
+const (
+	frameMagic          = "\x28\xb5\x2f\xfd"
+	skippableFrameMagic = "\x2a\x4d\x18"
 )
 
 func newFrameDec(o decoderOptions) *frameDec {
@@ -84,25 +73,25 @@ func (d *frameDec) reset(br byteBuffer) error {
 		switch err {
 		case io.EOF, io.ErrUnexpectedEOF:
 			return io.EOF
-		default:
-			return err
 		case nil:
 			signature[0] = b[0]
+		default:
+			return err
 		}
 		// Read the rest, don't allow io.ErrUnexpectedEOF
 		b, err = br.readSmall(3)
 		switch err {
 		case io.EOF:
 			return io.EOF
-		default:
-			return err
 		case nil:
 			copy(signature[1:], b)
+		default:
+			return err
 		}
 
-		if !bytes.Equal(signature[1:4], skippableFrameMagic) || signature[0]&0xf0 != 0x50 {
+		if string(signature[1:4]) != skippableFrameMagic || signature[0]&0xf0 != 0x50 {
 			if debugDecoder {
-				println("Not skippable", hex.EncodeToString(signature[:]), hex.EncodeToString(skippableFrameMagic))
+				println("Not skippable", hex.EncodeToString(signature[:]), hex.EncodeToString([]byte(skippableFrameMagic)))
 			}
 			// Break if not skippable frame.
 			break
@@ -117,7 +106,7 @@ func (d *frameDec) reset(br byteBuffer) error {
 		}
 		n := uint32(b[0]) | (uint32(b[1]) << 8) | (uint32(b[2]) << 16) | (uint32(b[3]) << 24)
 		println("Skipping frame with", n, "bytes.")
-		err = br.skipN(int(n))
+		err = br.skipN(int64(n))
 		if err != nil {
 			if debugDecoder {
 				println("Reading discarded frame", err)
@@ -125,9 +114,9 @@ func (d *frameDec) reset(br byteBuffer) error {
 			return err
 		}
 	}
-	if !bytes.Equal(signature[:], frameMagic) {
+	if string(signature[:]) != frameMagic {
 		if debugDecoder {
-			println("Got magic numbers: ", signature, "want:", frameMagic)
+			println("Got magic numbers: ", signature, "want:", []byte(frameMagic))
 		}
 		return ErrMagicMismatch
 	}
@@ -166,7 +155,7 @@ func (d *frameDec) reset(br byteBuffer) error {
 
 	// Read Dictionary_ID
 	// https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#dictionary_id
-	d.DictionaryID = nil
+	d.DictionaryID = 0
 	if size := fhd & 3; size != 0 {
 		if size == 3 {
 			size = 4
@@ -178,7 +167,7 @@ func (d *frameDec) reset(br byteBuffer) error {
 			return err
 		}
 		var id uint32
-		switch size {
+		switch len(b) {
 		case 1:
 			id = uint32(b[0])
 		case 2:
@@ -189,11 +178,7 @@ func (d *frameDec) reset(br byteBuffer) error {
 		if debugDecoder {
 			println("Dict size", size, "ID:", id)
 		}
-		if id > 0 {
-			// ID 0 means "sorry, no dictionary anyway".
-			// https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#dictionary-format
-			d.DictionaryID = &id
-		}
+		d.DictionaryID = id
 	}
 
 	// Read Frame_Content_Size
@@ -208,14 +193,14 @@ func (d *frameDec) reset(br byteBuffer) error {
 	default:
 		fcsSize = 1 << v
 	}
-	d.FrameContentSize = 0
+	d.FrameContentSize = fcsUnknown
 	if fcsSize > 0 {
 		b, err := br.readSmall(fcsSize)
 		if err != nil {
 			println("Reading Frame content", err)
 			return err
 		}
-		switch fcsSize {
+		switch len(b) {
 		case 1:
 			d.FrameContentSize = uint64(b[0])
 		case 2:
@@ -229,9 +214,10 @@ func (d *frameDec) reset(br byteBuffer) error {
 			d.FrameContentSize = uint64(d1) | (uint64(d2) << 32)
 		}
 		if debugDecoder {
-			println("field size bits:", v, "fcsSize:", fcsSize, "FrameContentSize:", d.FrameContentSize, hex.EncodeToString(b[:fcsSize]), "singleseg:", d.SingleSegment, "window:", d.WindowSize)
+			println("Read FCS:", d.FrameContentSize)
 		}
 	}
+
 	// Move this to shared.
 	d.HasCheckSum = fhd&(1<<2) != 0
 	if d.HasCheckSum {
@@ -241,20 +227,27 @@ func (d *frameDec) reset(br byteBuffer) error {
 		d.crc.Reset()
 	}
 
+	if d.WindowSize > d.o.maxWindowSize {
+		if debugDecoder {
+			printf("window size %d > max %d\n", d.WindowSize, d.o.maxWindowSize)
+		}
+		return ErrWindowSizeExceeded
+	}
+
 	if d.WindowSize == 0 && d.SingleSegment {
 		// We may not need window in this case.
 		d.WindowSize = d.FrameContentSize
 		if d.WindowSize < MinWindowSize {
 			d.WindowSize = MinWindowSize
 		}
-	}
-
-	if d.WindowSize > uint64(d.o.maxWindowSize) {
-		if debugDecoder {
-			printf("window size %d > max %d\n", d.WindowSize, d.o.maxWindowSize)
+		if d.WindowSize > d.o.maxDecodedSize {
+			if debugDecoder {
+				printf("window size %d > max %d\n", d.WindowSize, d.o.maxWindowSize)
+			}
+			return ErrDecoderSizeExceeded
 		}
-		return ErrWindowSizeExceeded
 	}
+
 	// The minimum Window_Size is 1 KB.
 	if d.WindowSize < MinWindowSize {
 		if debugDecoder {
@@ -263,11 +256,23 @@ func (d *frameDec) reset(br byteBuffer) error {
 		return ErrWindowSizeTooSmall
 	}
 	d.history.windowSize = int(d.WindowSize)
-	if d.o.lowMem && d.history.windowSize < maxBlockSize {
-		d.history.maxSize = d.history.windowSize * 2
+	if !d.o.lowMem || d.history.windowSize < maxBlockSize {
+		// Alloc 2x window size if not low-mem, or window size below 2MB.
+		d.history.allocFrameBuffer = d.history.windowSize * 2
 	} else {
-		d.history.maxSize = d.history.windowSize + maxBlockSize
+		if d.o.lowMem {
+			// Alloc with 1MB extra.
+			d.history.allocFrameBuffer = d.history.windowSize + maxBlockSize/2
+		} else {
+			// Alloc with 2MB extra.
+			d.history.allocFrameBuffer = d.history.windowSize + maxBlockSize
+		}
 	}
+
+	if debugDecoder {
+		println("Frame: Dict:", d.DictionaryID, "FrameContentSize:", d.FrameContentSize, "singleseg:", d.SingleSegment, "window:", d.WindowSize, "crc:", d.HasCheckSum)
+	}
+
 	// history contains input - maybe we do something
 	d.rawInput = br
 	return nil
@@ -276,209 +281,85 @@ func (d *frameDec) reset(br byteBuffer) error {
 // next will start decoding the next block from stream.
 func (d *frameDec) next(block *blockDec) error {
 	if debugDecoder {
-		printf("decoding new block %p:%p", block, block.data)
+		println("decoding new block")
 	}
 	err := block.reset(d.rawInput, d.WindowSize)
 	if err != nil {
 		println("block error:", err)
 		// Signal the frame decoder we have a problem.
-		d.sendErr(block, err)
+		block.sendErr(err)
 		return err
 	}
-	block.input <- struct{}{}
-	if debugDecoder {
-		println("next block:", block)
-	}
-	d.asyncRunningMu.Lock()
-	defer d.asyncRunningMu.Unlock()
-	if !d.asyncRunning {
-		return nil
-	}
-	if block.Last {
-		// We indicate the frame is done by sending io.EOF
-		d.decoding <- block
-		return io.EOF
-	}
-	d.decoding <- block
 	return nil
 }
 
-// sendEOF will queue an error block on the frame.
-// This will cause the frame decoder to return when it encounters the block.
-// Returns true if the decoder was added.
-func (d *frameDec) sendErr(block *blockDec, err error) bool {
-	d.asyncRunningMu.Lock()
-	defer d.asyncRunningMu.Unlock()
-	if !d.asyncRunning {
-		return false
-	}
-
-	println("sending error", err.Error())
-	block.sendErr(err)
-	d.decoding <- block
-	return true
-}
-
-// checkCRC will check the checksum if the frame has one.
+// checkCRC will check the checksum, assuming the frame has one.
 // Will return ErrCRCMismatch if crc check failed, otherwise nil.
 func (d *frameDec) checkCRC() error {
-	if !d.HasCheckSum {
-		return nil
-	}
-	var tmp [4]byte
-	got := d.crc.Sum64()
-	// Flip to match file order.
-	tmp[0] = byte(got >> 0)
-	tmp[1] = byte(got >> 8)
-	tmp[2] = byte(got >> 16)
-	tmp[3] = byte(got >> 24)
-
 	// We can overwrite upper tmp now
-	want, err := d.rawInput.readSmall(4)
+	buf, err := d.rawInput.readSmall(4)
 	if err != nil {
 		println("CRC missing?", err)
 		return err
 	}
 
-	if !bytes.Equal(tmp[:], want) {
+	want := binary.LittleEndian.Uint32(buf[:4])
+	got := uint32(d.crc.Sum64())
+
+	if got != want {
 		if debugDecoder {
-			println("CRC Check Failed:", tmp[:], "!=", want)
+			printf("CRC check failed: got %08x, want %08x\n", got, want)
 		}
 		return ErrCRCMismatch
 	}
 	if debugDecoder {
-		println("CRC ok", tmp[:])
+		printf("CRC ok %08x\n", got)
 	}
 	return nil
 }
 
-func (d *frameDec) initAsync() {
-	if !d.o.lowMem && !d.SingleSegment {
-		// set max extra size history to 2MB.
-		d.history.maxSize = d.history.windowSize + maxBlockSize
-	}
-	// re-alloc if more than one extra block size.
-	if d.o.lowMem && cap(d.history.b) > d.history.maxSize+maxBlockSize {
-		d.history.b = make([]byte, 0, d.history.maxSize)
-	}
-	if cap(d.history.b) < d.history.maxSize {
-		d.history.b = make([]byte, 0, d.history.maxSize)
-	}
-	if cap(d.decoding) < d.o.concurrent {
-		d.decoding = make(chan *blockDec, d.o.concurrent)
-	}
-	if debugDecoder {
-		h := d.history
-		printf("history init. len: %d, cap: %d", len(h.b), cap(h.b))
-	}
-	d.asyncRunningMu.Lock()
-	d.asyncRunning = true
-	d.asyncRunningMu.Unlock()
-}
-
-// startDecoder will start decoding blocks and write them to the writer.
-// The decoder will stop as soon as an error occurs or at end of frame.
-// When the frame has finished decoding the *bufio.Reader
-// containing the remaining input will be sent on frameDec.frameDone.
-func (d *frameDec) startDecoder(output chan decodeOutput) {
-	written := int64(0)
-
-	defer func() {
-		d.asyncRunningMu.Lock()
-		d.asyncRunning = false
-		d.asyncRunningMu.Unlock()
-
-		// Drain the currently decoding.
-		d.history.error = true
-	flushdone:
-		for {
-			select {
-			case b := <-d.decoding:
-				b.history <- &d.history
-				output <- <-b.result
-			default:
-				break flushdone
-			}
-		}
-		println("frame decoder done, signalling done")
-		d.frameDone.Done()
-	}()
-	// Get decoder for first block.
-	block := <-d.decoding
-	block.history <- &d.history
-	for {
-		var next *blockDec
-		// Get result
-		r := <-block.result
-		if r.err != nil {
-			println("Result contained error", r.err)
-			output <- r
-			return
-		}
-		if debugDecoder {
-			println("got result, from ", d.offset, "to", d.offset+int64(len(r.b)))
-			d.offset += int64(len(r.b))
-		}
-		if !block.Last {
-			// Send history to next block
-			select {
-			case next = <-d.decoding:
-				if debugDecoder {
-					println("Sending ", len(d.history.b), "bytes as history")
-				}
-				next.history <- &d.history
-			default:
-				// Wait until we have sent the block, so
-				// other decoders can potentially get the decoder.
-				next = nil
-			}
-		}
-
-		// Add checksum, async to decoding.
-		if d.HasCheckSum {
-			n, err := d.crc.Write(r.b)
-			if err != nil {
-				r.err = err
-				if n != len(r.b) {
-					r.err = io.ErrShortWrite
-				}
-				output <- r
-				return
-			}
-		}
-		written += int64(len(r.b))
-		if d.SingleSegment && uint64(written) > d.FrameContentSize {
-			println("runDecoder: single segment and", uint64(written), ">", d.FrameContentSize)
-			r.err = ErrFrameSizeExceeded
-			output <- r
-			return
-		}
-		if block.Last {
-			r.err = d.checkCRC()
-			output <- r
-			return
-		}
-		output <- r
-		if next == nil {
-			// There was no decoder available, we wait for one now that we have sent to the writer.
-			if debugDecoder {
-				println("Sending ", len(d.history.b), " bytes as history")
-			}
-			next = <-d.decoding
-			next.history <- &d.history
-		}
-		block = next
+// consumeCRC skips over the checksum, assuming the frame has one.
+func (d *frameDec) consumeCRC() error {
+	_, err := d.rawInput.readSmall(4)
+	if err != nil {
+		println("CRC missing?", err)
 	}
+	return err
 }
 
-// runDecoder will create a sync decoder that will decode a block of data.
+// runDecoder will run the decoder for the remainder of the frame.
 func (d *frameDec) runDecoder(dst []byte, dec *blockDec) ([]byte, error) {
 	saved := d.history.b
 
 	// We use the history for output to avoid copying it.
 	d.history.b = dst
+	d.history.ignoreBuffer = len(dst)
 	// Store input length, so we only check new data.
 	crcStart := len(dst)
+	d.history.decoders.maxSyncLen = 0
+	if d.o.limitToCap {
+		d.history.decoders.maxSyncLen = uint64(cap(dst) - len(dst))
+	}
+	if d.FrameContentSize != fcsUnknown {
+		if !d.o.limitToCap || d.FrameContentSize+uint64(len(dst)) < d.history.decoders.maxSyncLen {
+			d.history.decoders.maxSyncLen = d.FrameContentSize + uint64(len(dst))
+		}
+		if d.history.decoders.maxSyncLen > d.o.maxDecodedSize {
+			if debugDecoder {
+				println("maxSyncLen:", d.history.decoders.maxSyncLen, "> maxDecodedSize:", d.o.maxDecodedSize)
+			}
+			return dst, ErrDecoderSizeExceeded
+		}
+		if debugDecoder {
+			println("maxSyncLen:", d.history.decoders.maxSyncLen)
+		}
+		if !d.o.limitToCap && uint64(cap(dst)) < d.history.decoders.maxSyncLen {
+			// Alloc for output
+			dst2 := make([]byte, len(dst), d.history.decoders.maxSyncLen+compressedBlockOverAlloc)
+			copy(dst2, dst)
+			dst = dst2
+		}
+	}
 	var err error
 	for {
 		err = dec.reset(d.rawInput, d.WindowSize)
@@ -489,30 +370,41 @@ func (d *frameDec) runDecoder(dst []byte, dec *blockDec) ([]byte, error) {
 			println("next block:", dec)
 		}
 		err = dec.decodeBuf(&d.history)
-		if err != nil || dec.Last {
+		if err != nil {
+			break
+		}
+		if uint64(len(d.history.b)-crcStart) > d.o.maxDecodedSize {
+			println("runDecoder: maxDecodedSize exceeded", uint64(len(d.history.b)-crcStart), ">", d.o.maxDecodedSize)
+			err = ErrDecoderSizeExceeded
 			break
 		}
-		if uint64(len(d.history.b)) > d.o.maxDecodedSize {
+		if d.o.limitToCap && len(d.history.b) > cap(dst) {
+			println("runDecoder: cap exceeded", uint64(len(d.history.b)), ">", cap(dst))
 			err = ErrDecoderSizeExceeded
 			break
 		}
-		if d.SingleSegment && uint64(len(d.history.b)) > d.o.maxDecodedSize {
-			println("runDecoder: single segment and", uint64(len(d.history.b)), ">", d.o.maxDecodedSize)
+		if uint64(len(d.history.b)-crcStart) > d.FrameContentSize {
+			println("runDecoder: FrameContentSize exceeded", uint64(len(d.history.b)-crcStart), ">", d.FrameContentSize)
 			err = ErrFrameSizeExceeded
 			break
 		}
+		if dec.Last {
+			break
+		}
+		if debugDecoder {
+			println("runDecoder: FrameContentSize", uint64(len(d.history.b)-crcStart), "<=", d.FrameContentSize)
+		}
 	}
 	dst = d.history.b
 	if err == nil {
-		if d.HasCheckSum {
-			var n int
-			n, err = d.crc.Write(dst[crcStart:])
-			if err == nil {
-				if n != len(dst)-crcStart {
-					err = io.ErrShortWrite
-				} else {
-					err = d.checkCRC()
-				}
+		if d.FrameContentSize != fcsUnknown && uint64(len(d.history.b)-crcStart) != d.FrameContentSize {
+			err = ErrFrameSizeMismatch
+		} else if d.HasCheckSum {
+			if d.o.ignoreChecksum {
+				err = d.consumeCRC()
+			} else {
+				d.crc.Write(dst[crcStart:])
+				err = d.checkCRC()
 			}
 		}
 	}
diff --git a/vendor/github.com/klauspost/compress/zstd/fse_decoder.go b/vendor/github.com/klauspost/compress/zstd/fse_decoder.go
index e6d3d49b..2f8860a7 100644
--- a/vendor/github.com/klauspost/compress/zstd/fse_decoder.go
+++ b/vendor/github.com/klauspost/compress/zstd/fse_decoder.go
@@ -5,8 +5,10 @@
 package zstd
 
 import (
+	"encoding/binary"
 	"errors"
 	"fmt"
+	"io"
 )
 
 const (
@@ -178,10 +180,32 @@ func (s *fseDecoder) readNCount(b *byteReader, maxSymbol uint16) error {
 		return fmt.Errorf("corruption detected (total %d != %d)", gotTotal, 1<<s.actualTableLog)
 	}
 	b.advance((bitCount + 7) >> 3)
-	// println(s.norm[:s.symbolLen], s.symbolLen)
 	return s.buildDtable()
 }
 
+func (s *fseDecoder) mustReadFrom(r io.Reader) {
+	fatalErr := func(err error) {
+		if err != nil {
+			panic(err)
+		}
+	}
+	// 	dt             [maxTablesize]decSymbol // Decompression table.
+	//	symbolLen      uint16                  // Length of active part of the symbol table.
+	//	actualTableLog uint8                   // Selected tablelog.
+	//	maxBits        uint8                   // Maximum number of additional bits
+	//	// used for table creation to avoid allocations.
+	//	stateTable [256]uint16
+	//	norm       [maxSymbolValue + 1]int16
+	//	preDefined bool
+	fatalErr(binary.Read(r, binary.LittleEndian, &s.dt))
+	fatalErr(binary.Read(r, binary.LittleEndian, &s.symbolLen))
+	fatalErr(binary.Read(r, binary.LittleEndian, &s.actualTableLog))
+	fatalErr(binary.Read(r, binary.LittleEndian, &s.maxBits))
+	fatalErr(binary.Read(r, binary.LittleEndian, &s.stateTable))
+	fatalErr(binary.Read(r, binary.LittleEndian, &s.norm))
+	fatalErr(binary.Read(r, binary.LittleEndian, &s.preDefined))
+}
+
 // decSymbol contains information about a state entry,
 // Including the state offset base, the output symbol and
 // the number of bits to read for the low part of the destination state.
@@ -204,18 +228,10 @@ func (d decSymbol) newState() uint16 {
 	return uint16(d >> 16)
 }
 
-func (d decSymbol) baseline() uint32 {
-	return uint32(d >> 32)
-}
-
 func (d decSymbol) baselineInt() int {
 	return int(d >> 32)
 }
 
-func (d *decSymbol) set(nbits, addBits uint8, newState uint16, baseline uint32) {
-	*d = decSymbol(nbits) | (decSymbol(addBits) << 8) | (decSymbol(newState) << 16) | (decSymbol(baseline) << 32)
-}
-
 func (d *decSymbol) setNBits(nBits uint8) {
 	const mask = 0xffffffffffffff00
 	*d = (*d & mask) | decSymbol(nBits)
@@ -231,11 +247,6 @@ func (d *decSymbol) setNewState(state uint16) {
 	*d = (*d & mask) | decSymbol(state)<<16
 }
 
-func (d *decSymbol) setBaseline(baseline uint32) {
-	const mask = 0xffffffff
-	*d = (*d & mask) | decSymbol(baseline)<<32
-}
-
 func (d *decSymbol) setExt(addBits uint8, baseline uint32) {
 	const mask = 0xffff00ff
 	*d = (*d & mask) | (decSymbol(addBits) << 8) | (decSymbol(baseline) << 32)
@@ -257,68 +268,6 @@ func (s *fseDecoder) setRLE(symbol decSymbol) {
 	s.dt[0] = symbol
 }
 
-// buildDtable will build the decoding table.
-func (s *fseDecoder) buildDtable() error {
-	tableSize := uint32(1 << s.actualTableLog)
-	highThreshold := tableSize - 1
-	symbolNext := s.stateTable[:256]
-
-	// Init, lay down lowprob symbols
-	{
-		for i, v := range s.norm[:s.symbolLen] {
-			if v == -1 {
-				s.dt[highThreshold].setAddBits(uint8(i))
-				highThreshold--
-				symbolNext[i] = 1
-			} else {
-				symbolNext[i] = uint16(v)
-			}
-		}
-	}
-	// Spread symbols
-	{
-		tableMask := tableSize - 1
-		step := tableStep(tableSize)
-		position := uint32(0)
-		for ss, v := range s.norm[:s.symbolLen] {
-			for i := 0; i < int(v); i++ {
-				s.dt[position].setAddBits(uint8(ss))
-				position = (position + step) & tableMask
-				for position > highThreshold {
-					// lowprob area
-					position = (position + step) & tableMask
-				}
-			}
-		}
-		if position != 0 {
-			// position must reach all cells once, otherwise normalizedCounter is incorrect
-			return errors.New("corrupted input (position != 0)")
-		}
-	}
-
-	// Build Decoding table
-	{
-		tableSize := uint16(1 << s.actualTableLog)
-		for u, v := range s.dt[:tableSize] {
-			symbol := v.addBits()
-			nextState := symbolNext[symbol]
-			symbolNext[symbol] = nextState + 1
-			nBits := s.actualTableLog - byte(highBits(uint32(nextState)))
-			s.dt[u&maxTableMask].setNBits(nBits)
-			newState := (nextState << nBits) - tableSize
-			if newState > tableSize {
-				return fmt.Errorf("newState (%d) outside table size (%d)", newState, tableSize)
-			}
-			if newState == uint16(u) && nBits == 0 {
-				// Seems weird that this is possible with nbits > 0.
-				return fmt.Errorf("newState (%d) == oldState (%d) and no bits", newState, u)
-			}
-			s.dt[u&maxTableMask].setNewState(newState)
-		}
-	}
-	return nil
-}
-
 // transform will transform the decoder table into a table usable for
 // decoding without having to apply the transformation while decoding.
 // The state will contain the base value and the number of bits to read.
@@ -352,34 +301,7 @@ func (s *fseState) init(br *bitReader, tableLog uint8, dt []decSymbol) {
 	s.state = dt[br.getBits(tableLog)]
 }
 
-// next returns the current symbol and sets the next state.
-// At least tablelog bits must be available in the bit reader.
-func (s *fseState) next(br *bitReader) {
-	lowBits := uint16(br.getBits(s.state.nbBits()))
-	s.state = s.dt[s.state.newState()+lowBits]
-}
-
-// finished returns true if all bits have been read from the bitstream
-// and the next state would require reading bits from the input.
-func (s *fseState) finished(br *bitReader) bool {
-	return br.finished() && s.state.nbBits() > 0
-}
-
-// final returns the current state symbol without decoding the next.
-func (s *fseState) final() (int, uint8) {
-	return s.state.baselineInt(), s.state.addBits()
-}
-
 // final returns the current state symbol without decoding the next.
 func (s decSymbol) final() (int, uint8) {
 	return s.baselineInt(), s.addBits()
 }
-
-// nextFast returns the next symbol and sets the next state.
-// This can only be used if no symbols are 0 bits.
-// At least tablelog bits must be available in the bit reader.
-func (s *fseState) nextFast(br *bitReader) (uint32, uint8) {
-	lowBits := uint16(br.getBitsFast(s.state.nbBits()))
-	s.state = s.dt[s.state.newState()+lowBits]
-	return s.state.baseline(), s.state.addBits()
-}
diff --git a/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.go b/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.go
new file mode 100644
index 00000000..d04a829b
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.go
@@ -0,0 +1,65 @@
+//go:build amd64 && !appengine && !noasm && gc
+// +build amd64,!appengine,!noasm,gc
+
+package zstd
+
+import (
+	"fmt"
+)
+
+type buildDtableAsmContext struct {
+	// inputs
+	stateTable *uint16
+	norm       *int16
+	dt         *uint64
+
+	// outputs --- set by the procedure in the case of error;
+	// for interpretation please see the error handling part below
+	errParam1 uint64
+	errParam2 uint64
+}
+
+// buildDtable_asm is an x86 assembly implementation of fseDecoder.buildDtable.
+// Function returns non-zero exit code on error.
+//
+//go:noescape
+func buildDtable_asm(s *fseDecoder, ctx *buildDtableAsmContext) int
+
+// please keep in sync with _generate/gen_fse.go
+const (
+	errorCorruptedNormalizedCounter = 1
+	errorNewStateTooBig             = 2
+	errorNewStateNoBits             = 3
+)
+
+// buildDtable will build the decoding table.
+func (s *fseDecoder) buildDtable() error {
+	ctx := buildDtableAsmContext{
+		stateTable: &s.stateTable[0],
+		norm:       &s.norm[0],
+		dt:         (*uint64)(&s.dt[0]),
+	}
+	code := buildDtable_asm(s, &ctx)
+
+	if code != 0 {
+		switch code {
+		case errorCorruptedNormalizedCounter:
+			position := ctx.errParam1
+			return fmt.Errorf("corrupted input (position=%d, expected 0)", position)
+
+		case errorNewStateTooBig:
+			newState := decSymbol(ctx.errParam1)
+			size := ctx.errParam2
+			return fmt.Errorf("newState (%d) outside table size (%d)", newState, size)
+
+		case errorNewStateNoBits:
+			newState := decSymbol(ctx.errParam1)
+			oldState := decSymbol(ctx.errParam2)
+			return fmt.Errorf("newState (%d) == oldState (%d) and no bits", newState, oldState)
+
+		default:
+			return fmt.Errorf("buildDtable_asm returned unhandled nonzero code = %d", code)
+		}
+	}
+	return nil
+}
diff --git a/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.s b/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.s
new file mode 100644
index 00000000..bcde3986
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.s
@@ -0,0 +1,126 @@
+// Code generated by command: go run gen_fse.go -out ../fse_decoder_amd64.s -pkg=zstd. DO NOT EDIT.
+
+//go:build !appengine && !noasm && gc && !noasm
+
+// func buildDtable_asm(s *fseDecoder, ctx *buildDtableAsmContext) int
+TEXT ·buildDtable_asm(SB), $0-24
+	MOVQ ctx+8(FP), CX
+	MOVQ s+0(FP), DI
+
+	// Load values
+	MOVBQZX 4098(DI), DX
+	XORQ    AX, AX
+	BTSQ    DX, AX
+	MOVQ    (CX), BX
+	MOVQ    16(CX), SI
+	LEAQ    -1(AX), R8
+	MOVQ    8(CX), CX
+	MOVWQZX 4096(DI), DI
+
+	// End load values
+	// Init, lay down lowprob symbols
+	XORQ R9, R9
+	JMP  init_main_loop_condition
+
+init_main_loop:
+	MOVWQSX (CX)(R9*2), R10
+	CMPW    R10, $-1
+	JNE     do_not_update_high_threshold
+	MOVB    R9, 1(SI)(R8*8)
+	DECQ    R8
+	MOVQ    $0x0000000000000001, R10
+
+do_not_update_high_threshold:
+	MOVW R10, (BX)(R9*2)
+	INCQ R9
+
+init_main_loop_condition:
+	CMPQ R9, DI
+	JL   init_main_loop
+
+	// Spread symbols
+	// Calculate table step
+	MOVQ AX, R9
+	SHRQ $0x01, R9
+	MOVQ AX, R10
+	SHRQ $0x03, R10
+	LEAQ 3(R9)(R10*1), R9
+
+	// Fill add bits values
+	LEAQ -1(AX), R10
+	XORQ R11, R11
+	XORQ R12, R12
+	JMP  spread_main_loop_condition
+
+spread_main_loop:
+	XORQ    R13, R13
+	MOVWQSX (CX)(R12*2), R14
+	JMP     spread_inner_loop_condition
+
+spread_inner_loop:
+	MOVB R12, 1(SI)(R11*8)
+
+adjust_position:
+	ADDQ R9, R11
+	ANDQ R10, R11
+	CMPQ R11, R8
+	JG   adjust_position
+	INCQ R13
+
+spread_inner_loop_condition:
+	CMPQ R13, R14
+	JL   spread_inner_loop
+	INCQ R12
+
+spread_main_loop_condition:
+	CMPQ  R12, DI
+	JL    spread_main_loop
+	TESTQ R11, R11
+	JZ    spread_check_ok
+	MOVQ  ctx+8(FP), AX
+	MOVQ  R11, 24(AX)
+	MOVQ  $+1, ret+16(FP)
+	RET
+
+spread_check_ok:
+	// Build Decoding table
+	XORQ DI, DI
+
+build_table_main_table:
+	MOVBQZX 1(SI)(DI*8), CX
+	MOVWQZX (BX)(CX*2), R8
+	LEAQ    1(R8), R9
+	MOVW    R9, (BX)(CX*2)
+	MOVQ    R8, R9
+	BSRQ    R9, R9
+	MOVQ    DX, CX
+	SUBQ    R9, CX
+	SHLQ    CL, R8
+	SUBQ    AX, R8
+	MOVB    CL, (SI)(DI*8)
+	MOVW    R8, 2(SI)(DI*8)
+	CMPQ    R8, AX
+	JLE     build_table_check1_ok
+	MOVQ    ctx+8(FP), CX
+	MOVQ    R8, 24(CX)
+	MOVQ    AX, 32(CX)
+	MOVQ    $+2, ret+16(FP)
+	RET
+
+build_table_check1_ok:
+	TESTB CL, CL
+	JNZ   build_table_check2_ok
+	CMPW  R8, DI
+	JNE   build_table_check2_ok
+	MOVQ  ctx+8(FP), AX
+	MOVQ  R8, 24(AX)
+	MOVQ  DI, 32(AX)
+	MOVQ  $+3, ret+16(FP)
+	RET
+
+build_table_check2_ok:
+	INCQ DI
+	CMPQ DI, AX
+	JL   build_table_main_table
+	MOVQ $+0, ret+16(FP)
+	RET
diff --git a/vendor/github.com/klauspost/compress/zstd/fse_decoder_generic.go b/vendor/github.com/klauspost/compress/zstd/fse_decoder_generic.go
new file mode 100644
index 00000000..332e51fe
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/zstd/fse_decoder_generic.go
@@ -0,0 +1,72 @@
+//go:build !amd64 || appengine || !gc || noasm
+// +build !amd64 appengine !gc noasm
+
+package zstd
+
+import (
+	"errors"
+	"fmt"
+)
+
+// buildDtable will build the decoding table.
+func (s *fseDecoder) buildDtable() error {
+	tableSize := uint32(1 << s.actualTableLog)
+	highThreshold := tableSize - 1
+	symbolNext := s.stateTable[:256]
+
+	// Init, lay down lowprob symbols
+	{
+		for i, v := range s.norm[:s.symbolLen] {
+			if v == -1 {
+				s.dt[highThreshold].setAddBits(uint8(i))
+				highThreshold--
+				symbolNext[i] = 1
+			} else {
+				symbolNext[i] = uint16(v)
+			}
+		}
+	}
+
+	// Spread symbols
+	{
+		tableMask := tableSize - 1
+		step := tableStep(tableSize)
+		position := uint32(0)
+		for ss, v := range s.norm[:s.symbolLen] {
+			for i := 0; i < int(v); i++ {
+				s.dt[position].setAddBits(uint8(ss))
+				position = (position + step) & tableMask
+				for position > highThreshold {
+					// lowprob area
+					position = (position + step) & tableMask
+				}
+			}
+		}
+		if position != 0 {
+			// position must reach all cells once, otherwise normalizedCounter is incorrect
+			return errors.New("corrupted input (position != 0)")
+		}
+	}
+
+	// Build Decoding table
+	{
+		tableSize := uint16(1 << s.actualTableLog)
+		for u, v := range s.dt[:tableSize] {
+			symbol := v.addBits()
+			nextState := symbolNext[symbol]
+			symbolNext[symbol] = nextState + 1
+			nBits := s.actualTableLog - byte(highBits(uint32(nextState)))
+			s.dt[u&maxTableMask].setNBits(nBits)
+			newState := (nextState << nBits) - tableSize
+			if newState > tableSize {
+				return fmt.Errorf("newState (%d) outside table size (%d)", newState, tableSize)
+			}
+			if newState == uint16(u) && nBits == 0 {
+				// Seems weird that this is possible with nbits > 0.
+				return fmt.Errorf("newState (%d) == oldState (%d) and no bits", newState, u)
+			}
+			s.dt[u&maxTableMask].setNewState(newState)
+		}
+	}
+	return nil
+}
diff --git a/vendor/github.com/klauspost/compress/zstd/fse_encoder.go b/vendor/github.com/klauspost/compress/zstd/fse_encoder.go
index b4757ee3..ab26326a 100644
--- a/vendor/github.com/klauspost/compress/zstd/fse_encoder.go
+++ b/vendor/github.com/klauspost/compress/zstd/fse_encoder.go
@@ -62,9 +62,8 @@ func (s symbolTransform) String() string {
 // To indicate that you have populated the histogram call HistogramFinished
 // with the value of the highest populated symbol, as well as the number of entries
 // in the most populated entry. These are accepted at face value.
-// The returned slice will always be length 256.
-func (s *fseEncoder) Histogram() []uint32 {
-	return s.count[:]
+func (s *fseEncoder) Histogram() *[256]uint32 {
+	return &s.count
 }
 
 // HistogramFinished can be called to indicate that the histogram has been populated.
@@ -77,21 +76,6 @@ func (s *fseEncoder) HistogramFinished(maxSymbol uint8, maxCount int) {
 	s.clearCount = maxCount != 0
 }
 
-// prepare will prepare and allocate scratch tables used for both compression and decompression.
-func (s *fseEncoder) prepare() (*fseEncoder, error) {
-	if s == nil {
-		s = &fseEncoder{}
-	}
-	s.useRLE = false
-	if s.clearCount && s.maxCount == 0 {
-		for i := range s.count {
-			s.count[i] = 0
-		}
-		s.clearCount = false
-	}
-	return s, nil
-}
-
 // allocCtable will allocate tables needed for compression.
 // If existing tables a re big enough, they are simply re-used.
 func (s *fseEncoder) allocCtable() {
@@ -710,14 +694,6 @@ func (c *cState) init(bw *bitWriter, ct *cTable, first symbolTransform) {
 	c.state = c.stateTable[lu]
 }
 
-// encode the output symbol provided and write it to the bitstream.
-func (c *cState) encode(symbolTT symbolTransform) {
-	nbBitsOut := (uint32(c.state) + symbolTT.deltaNbBits) >> 16
-	dstState := int32(c.state>>(nbBitsOut&15)) + int32(symbolTT.deltaFindState)
-	c.bw.addBits16NC(c.state, uint8(nbBitsOut))
-	c.state = c.stateTable[dstState]
-}
-
 // flush will write the tablelog to the output and flush the remaining full bytes.
 func (c *cState) flush(tableLog uint8) {
 	c.bw.flush32()
diff --git a/vendor/github.com/klauspost/compress/zstd/hash.go b/vendor/github.com/klauspost/compress/zstd/hash.go
index cf33f29a..5d73c21e 100644
--- a/vendor/github.com/klauspost/compress/zstd/hash.go
+++ b/vendor/github.com/klauspost/compress/zstd/hash.go
@@ -33,9 +33,3 @@ func hashLen(u uint64, length, mls uint8) uint32 {
 		return (uint32(u) * prime4bytes) >> (32 - length)
 	}
 }
-
-// hash3 returns the hash of the lower 3 bytes of u to fit in a hash table with h bits.
-// Preferably h should be a constant and should always be <32.
-func hash3(u uint32, h uint8) uint32 {
-	return ((u << (32 - 24)) * prime3bytes) >> ((32 - h) & 31)
-}
diff --git a/vendor/github.com/klauspost/compress/zstd/history.go b/vendor/github.com/klauspost/compress/zstd/history.go
index f783e32d..09164856 100644
--- a/vendor/github.com/klauspost/compress/zstd/history.go
+++ b/vendor/github.com/klauspost/compress/zstd/history.go
@@ -10,40 +10,48 @@ import (
 
 // history contains the information transferred between blocks.
 type history struct {
-	b             []byte
-	huffTree      *huff0.Scratch
-	recentOffsets [3]int
+	// Literal decompression
+	huffTree *huff0.Scratch
+
+	// Sequence decompression
 	decoders      sequenceDecs
-	windowSize    int
-	maxSize       int
-	error         bool
-	dict          *dict
+	recentOffsets [3]int
+
+	// History buffer...
+	b []byte
+
+	// ignoreBuffer is meant to ignore a number of bytes
+	// when checking for matches in history
+	ignoreBuffer int
+
+	windowSize       int
+	allocFrameBuffer int // needed?
+	error            bool
+	dict             *dict
 }
 
 // reset will reset the history to initial state of a frame.
 // The history must already have been initialized to the desired size.
 func (h *history) reset() {
 	h.b = h.b[:0]
+	h.ignoreBuffer = 0
 	h.error = false
 	h.recentOffsets = [3]int{1, 4, 8}
-	if f := h.decoders.litLengths.fse; f != nil && !f.preDefined {
-		fseDecoderPool.Put(f)
-	}
-	if f := h.decoders.offsets.fse; f != nil && !f.preDefined {
-		fseDecoderPool.Put(f)
-	}
-	if f := h.decoders.matchLengths.fse; f != nil && !f.preDefined {
-		fseDecoderPool.Put(f)
-	}
-	h.decoders = sequenceDecs{}
+	h.decoders.freeDecoders()
+	h.decoders = sequenceDecs{br: h.decoders.br}
+	h.freeHuffDecoder()
+	h.huffTree = nil
+	h.dict = nil
+	//printf("history created: %+v (l: %d, c: %d)", *h, len(h.b), cap(h.b))
+}
+
+func (h *history) freeHuffDecoder() {
 	if h.huffTree != nil {
 		if h.dict == nil || h.dict.litEnc != h.huffTree {
 			huffDecoderPool.Put(h.huffTree)
+			h.huffTree = nil
 		}
 	}
-	h.huffTree = nil
-	h.dict = nil
-	//printf("history created: %+v (l: %d, c: %d)", *h, len(h.b), cap(h.b))
 }
 
 func (h *history) setDict(dict *dict) {
@@ -54,6 +62,7 @@ func (h *history) setDict(dict *dict) {
 	h.decoders.litLengths = dict.llDec
 	h.decoders.offsets = dict.ofDec
 	h.decoders.matchLengths = dict.mlDec
+	h.decoders.dict = dict.content
 	h.recentOffsets = dict.offsets
 	h.huffTree = dict.litEnc
 }
@@ -83,6 +92,24 @@ func (h *history) append(b []byte) {
 	copy(h.b[h.windowSize-len(b):], b)
 }
 
+// ensureBlock will ensure there is space for at least one block...
+func (h *history) ensureBlock() {
+	if cap(h.b) < h.allocFrameBuffer {
+		h.b = make([]byte, 0, h.allocFrameBuffer)
+		return
+	}
+
+	avail := cap(h.b) - len(h.b)
+	if avail >= h.windowSize || avail > maxCompressedBlockSize {
+		return
+	}
+	// Move data down so we only have window size left.
+	// We know we have less than window size in b at this point.
+	discard := len(h.b) - h.windowSize
+	copy(h.b, h.b[discard:])
+	h.b = h.b[:h.windowSize]
+}
+
 // append bytes to history without ever discarding anything.
 func (h *history) appendKeep(b []byte) {
 	h.b = append(h.b, b...)
diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/README.md b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/README.md
index 69aa3bb5..777290d4 100644
--- a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/README.md
+++ b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/README.md
@@ -2,12 +2,7 @@
 
 VENDORED: Go to [github.com/cespare/xxhash](https://github.com/cespare/xxhash) for original package.
 
-
-[![GoDoc](https://godoc.org/github.com/cespare/xxhash?status.svg)](https://godoc.org/github.com/cespare/xxhash)
-[![Build Status](https://travis-ci.org/cespare/xxhash.svg?branch=master)](https://travis-ci.org/cespare/xxhash)
-
-xxhash is a Go implementation of the 64-bit
-[xxHash](http://cyan4973.github.io/xxHash/) algorithm, XXH64. This is a
+xxhash is a Go implementation of the 64-bit [xxHash] algorithm, XXH64. This is a
 high-quality hashing algorithm that is much faster than anything in the Go
 standard library.
 
@@ -28,31 +23,49 @@ func (*Digest) WriteString(string) (int, error)
 func (*Digest) Sum64() uint64
 ```
 
-This implementation provides a fast pure-Go implementation and an even faster
-assembly implementation for amd64.
+The package is written with optimized pure Go and also contains even faster
+assembly implementations for amd64 and arm64. If desired, the `purego` build tag
+opts into using the Go code even on those architectures.
+
+[xxHash]: http://cyan4973.github.io/xxHash/
+
+## Compatibility
+
+This package is in a module and the latest code is in version 2 of the module.
+You need a version of Go with at least "minimal module compatibility" to use
+github.com/cespare/xxhash/v2:
+
+* 1.9.7+ for Go 1.9
+* 1.10.3+ for Go 1.10
+* Go 1.11 or later
+
+I recommend using the latest release of Go.
 
 ## Benchmarks
 
 Here are some quick benchmarks comparing the pure-Go and assembly
 implementations of Sum64.
 
-| input size | purego | asm |
-| --- | --- | --- |
-| 5 B   |  979.66 MB/s |  1291.17 MB/s  |
-| 100 B | 7475.26 MB/s | 7973.40 MB/s  |
-| 4 KB  | 17573.46 MB/s | 17602.65 MB/s |
-| 10 MB | 17131.46 MB/s | 17142.16 MB/s |
+| input size | purego    | asm       |
+| ---------- | --------- | --------- |
+| 4 B        |  1.3 GB/s |  1.2 GB/s |
+| 16 B       |  2.9 GB/s |  3.5 GB/s |
+| 100 B      |  6.9 GB/s |  8.1 GB/s |
+| 4 KB       | 11.7 GB/s | 16.7 GB/s |
+| 10 MB      | 12.0 GB/s | 17.3 GB/s |
 
-These numbers were generated on Ubuntu 18.04 with an Intel i7-8700K CPU using
-the following commands under Go 1.11.2:
+These numbers were generated on Ubuntu 20.04 with an Intel Xeon Platinum 8252C
+CPU using the following commands under Go 1.19.2:
 
 ```
-$ go test -tags purego -benchtime 10s -bench '/xxhash,direct,bytes'
-$ go test -benchtime 10s -bench '/xxhash,direct,bytes'
+benchstat <(go test -tags purego -benchtime 500ms -count 15 -bench 'Sum64$')
+benchstat <(go test -benchtime 500ms -count 15 -bench 'Sum64$')
 ```
 
 ## Projects using this package
 
 - [InfluxDB](https://github.com/influxdata/influxdb)
 - [Prometheus](https://github.com/prometheus/prometheus)
+- [VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics)
 - [FreeCache](https://github.com/coocood/freecache)
+- [FastCache](https://github.com/VictoriaMetrics/fastcache)
diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash.go b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash.go
index 2c112a0a..fc40c820 100644
--- a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash.go
+++ b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash.go
@@ -18,19 +18,11 @@ const (
 	prime5 uint64 = 2870177450012600261
 )
 
-// NOTE(caleb): I'm using both consts and vars of the primes. Using consts where
-// possible in the Go code is worth a small (but measurable) performance boost
-// by avoiding some MOVQs. Vars are needed for the asm and also are useful for
-// convenience in the Go code in a few places where we need to intentionally
-// avoid constant arithmetic (e.g., v1 := prime1 + prime2 fails because the
-// result overflows a uint64).
-var (
-	prime1v = prime1
-	prime2v = prime2
-	prime3v = prime3
-	prime4v = prime4
-	prime5v = prime5
-)
+// Store the primes in an array as well.
+//
+// The consts are used when possible in Go code to avoid MOVs but we need a
+// contiguous array of the assembly code.
+var primes = [...]uint64{prime1, prime2, prime3, prime4, prime5}
 
 // Digest implements hash.Hash64.
 type Digest struct {
@@ -52,10 +44,10 @@ func New() *Digest {
 
 // Reset clears the Digest's state so that it can be reused.
 func (d *Digest) Reset() {
-	d.v1 = prime1v + prime2
+	d.v1 = primes[0] + prime2
 	d.v2 = prime2
 	d.v3 = 0
-	d.v4 = -prime1v
+	d.v4 = -primes[0]
 	d.total = 0
 	d.n = 0
 }
@@ -71,21 +63,23 @@ func (d *Digest) Write(b []byte) (n int, err error) {
 	n = len(b)
 	d.total += uint64(n)
 
+	memleft := d.mem[d.n&(len(d.mem)-1):]
+
 	if d.n+n < 32 {
 		// This new data doesn't even fill the current block.
-		copy(d.mem[d.n:], b)
+		copy(memleft, b)
 		d.n += n
 		return
 	}
 
 	if d.n > 0 {
 		// Finish off the partial block.
-		copy(d.mem[d.n:], b)
+		c := copy(memleft, b)
 		d.v1 = round(d.v1, u64(d.mem[0:8]))
 		d.v2 = round(d.v2, u64(d.mem[8:16]))
 		d.v3 = round(d.v3, u64(d.mem[16:24]))
 		d.v4 = round(d.v4, u64(d.mem[24:32]))
-		b = b[32-d.n:]
+		b = b[c:]
 		d.n = 0
 	}
 
@@ -135,21 +129,20 @@ func (d *Digest) Sum64() uint64 {
 
 	h += d.total
 
-	i, end := 0, d.n
-	for ; i+8 <= end; i += 8 {
-		k1 := round(0, u64(d.mem[i:i+8]))
+	b := d.mem[:d.n&(len(d.mem)-1)]
+	for ; len(b) >= 8; b = b[8:] {
+		k1 := round(0, u64(b[:8]))
 		h ^= k1
 		h = rol27(h)*prime1 + prime4
 	}
-	if i+4 <= end {
-		h ^= uint64(u32(d.mem[i:i+4])) * prime1
+	if len(b) >= 4 {
+		h ^= uint64(u32(b[:4])) * prime1
 		h = rol23(h)*prime2 + prime3
-		i += 4
+		b = b[4:]
 	}
-	for i < end {
-		h ^= uint64(d.mem[i]) * prime5
+	for ; len(b) > 0; b = b[1:] {
+		h ^= uint64(b[0]) * prime5
 		h = rol11(h) * prime1
-		i++
 	}
 
 	h ^= h >> 33
diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_amd64.go b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_amd64.go
deleted file mode 100644
index 0ae847f7..00000000
--- a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_amd64.go
+++ /dev/null
@@ -1,12 +0,0 @@
-//go:build !appengine && gc && !purego
-// +build !appengine,gc,!purego
-
-package xxhash
-
-// Sum64 computes the 64-bit xxHash digest of b.
-//
-//go:noescape
-func Sum64(b []byte) uint64
-
-//go:noescape
-func writeBlocks(d *Digest, b []byte) int
diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_amd64.s b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_amd64.s
index be8db5bf..ddb63aa9 100644
--- a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_amd64.s
+++ b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_amd64.s
@@ -1,215 +1,210 @@
+//go:build !appengine && gc && !purego && !noasm
 // +build !appengine
 // +build gc
 // +build !purego
+// +build !noasm
 
 #include "textflag.h"
 
-// Register allocation:
-// AX	h
-// SI	pointer to advance through b
-// DX	n
-// BX	loop end
-// R8	v1, k1
-// R9	v2
-// R10	v3
-// R11	v4
-// R12	tmp
-// R13	prime1v
-// R14	prime2v
-// DI	prime4v
-
-// round reads from and advances the buffer pointer in SI.
-// It assumes that R13 has prime1v and R14 has prime2v.
-#define round(r) \
-	MOVQ  (SI), R12 \
-	ADDQ  $8, SI    \
-	IMULQ R14, R12  \
-	ADDQ  R12, r    \
-	ROLQ  $31, r    \
-	IMULQ R13, r
-
-// mergeRound applies a merge round on the two registers acc and val.
-// It assumes that R13 has prime1v, R14 has prime2v, and DI has prime4v.
-#define mergeRound(acc, val) \
-	IMULQ R14, val \
-	ROLQ  $31, val \
-	IMULQ R13, val \
-	XORQ  val, acc \
-	IMULQ R13, acc \
-	ADDQ  DI, acc
+// Registers:
+#define h      AX
+#define d      AX
+#define p      SI // pointer to advance through b
+#define n      DX
+#define end    BX // loop end
+#define v1     R8
+#define v2     R9
+#define v3     R10
+#define v4     R11
+#define x      R12
+#define prime1 R13
+#define prime2 R14
+#define prime4 DI
+
+#define round(acc, x) \
+	IMULQ prime2, x   \
+	ADDQ  x, acc      \
+	ROLQ  $31, acc    \
+	IMULQ prime1, acc
+
+// round0 performs the operation x = round(0, x).
+#define round0(x) \
+	IMULQ prime2, x \
+	ROLQ  $31, x    \
+	IMULQ prime1, x
+
+// mergeRound applies a merge round on the two registers acc and x.
+// It assumes that prime1, prime2, and prime4 have been loaded.
+#define mergeRound(acc, x) \
+	round0(x)         \
+	XORQ  x, acc      \
+	IMULQ prime1, acc \
+	ADDQ  prime4, acc
+
+// blockLoop processes as many 32-byte blocks as possible,
+// updating v1, v2, v3, and v4. It assumes that there is at least one block
+// to process.
+#define blockLoop() \
+loop:  \
+	MOVQ +0(p), x  \
+	round(v1, x)   \
+	MOVQ +8(p), x  \
+	round(v2, x)   \
+	MOVQ +16(p), x \
+	round(v3, x)   \
+	MOVQ +24(p), x \
+	round(v4, x)   \
+	ADDQ $32, p    \
+	CMPQ p, end    \
+	JLE  loop
 
 // func Sum64(b []byte) uint64
-TEXT ·Sum64(SB), NOSPLIT, $0-32
+TEXT ·Sum64(SB), NOSPLIT|NOFRAME, $0-32
 	// Load fixed primes.
-	MOVQ ·prime1v(SB), R13
-	MOVQ ·prime2v(SB), R14
-	MOVQ ·prime4v(SB), DI
+	MOVQ ·primes+0(SB), prime1
+	MOVQ ·primes+8(SB), prime2
+	MOVQ ·primes+24(SB), prime4
 
 	// Load slice.
-	MOVQ b_base+0(FP), SI
-	MOVQ b_len+8(FP), DX
-	LEAQ (SI)(DX*1), BX
+	MOVQ b_base+0(FP), p
+	MOVQ b_len+8(FP), n
+	LEAQ (p)(n*1), end
 
 	// The first loop limit will be len(b)-32.
-	SUBQ $32, BX
+	SUBQ $32, end
 
 	// Check whether we have at least one block.
-	CMPQ DX, $32
+	CMPQ n, $32
 	JLT  noBlocks
 
 	// Set up initial state (v1, v2, v3, v4).
-	MOVQ R13, R8
-	ADDQ R14, R8
-	MOVQ R14, R9
-	XORQ R10, R10
-	XORQ R11, R11
-	SUBQ R13, R11
-
-	// Loop until SI > BX.
-blockLoop:
-	round(R8)
-	round(R9)
-	round(R10)
-	round(R11)
-
-	CMPQ SI, BX
-	JLE  blockLoop
-
-	MOVQ R8, AX
-	ROLQ $1, AX
-	MOVQ R9, R12
-	ROLQ $7, R12
-	ADDQ R12, AX
-	MOVQ R10, R12
-	ROLQ $12, R12
-	ADDQ R12, AX
-	MOVQ R11, R12
-	ROLQ $18, R12
-	ADDQ R12, AX
-
-	mergeRound(AX, R8)
-	mergeRound(AX, R9)
-	mergeRound(AX, R10)
-	mergeRound(AX, R11)
+	MOVQ prime1, v1
+	ADDQ prime2, v1
+	MOVQ prime2, v2
+	XORQ v3, v3
+	XORQ v4, v4
+	SUBQ prime1, v4
+
+	blockLoop()
+
+	MOVQ v1, h
+	ROLQ $1, h
+	MOVQ v2, x
+	ROLQ $7, x
+	ADDQ x, h
+	MOVQ v3, x
+	ROLQ $12, x
+	ADDQ x, h
+	MOVQ v4, x
+	ROLQ $18, x
+	ADDQ x, h
+
+	mergeRound(h, v1)
+	mergeRound(h, v2)
+	mergeRound(h, v3)
+	mergeRound(h, v4)
 
 	JMP afterBlocks
 
 noBlocks:
-	MOVQ ·prime5v(SB), AX
+	MOVQ ·primes+32(SB), h
 
 afterBlocks:
-	ADDQ DX, AX
-
-	// Right now BX has len(b)-32, and we want to loop until SI > len(b)-8.
-	ADDQ $24, BX
-
-	CMPQ SI, BX
-	JG   fourByte
-
-wordLoop:
-	// Calculate k1.
-	MOVQ  (SI), R8
-	ADDQ  $8, SI
-	IMULQ R14, R8
-	ROLQ  $31, R8
-	IMULQ R13, R8
-
-	XORQ  R8, AX
-	ROLQ  $27, AX
-	IMULQ R13, AX
-	ADDQ  DI, AX
-
-	CMPQ SI, BX
-	JLE  wordLoop
-
-fourByte:
-	ADDQ $4, BX
-	CMPQ SI, BX
-	JG   singles
-
-	MOVL  (SI), R8
-	ADDQ  $4, SI
-	IMULQ R13, R8
-	XORQ  R8, AX
-
-	ROLQ  $23, AX
-	IMULQ R14, AX
-	ADDQ  ·prime3v(SB), AX
-
-singles:
-	ADDQ $4, BX
-	CMPQ SI, BX
+	ADDQ n, h
+
+	ADDQ $24, end
+	CMPQ p, end
+	JG   try4
+
+loop8:
+	MOVQ  (p), x
+	ADDQ  $8, p
+	round0(x)
+	XORQ  x, h
+	ROLQ  $27, h
+	IMULQ prime1, h
+	ADDQ  prime4, h
+
+	CMPQ p, end
+	JLE  loop8
+
+try4:
+	ADDQ $4, end
+	CMPQ p, end
+	JG   try1
+
+	MOVL  (p), x
+	ADDQ  $4, p
+	IMULQ prime1, x
+	XORQ  x, h
+
+	ROLQ  $23, h
+	IMULQ prime2, h
+	ADDQ  ·primes+16(SB), h
+
+try1:
+	ADDQ $4, end
+	CMPQ p, end
 	JGE  finalize
 
-singlesLoop:
-	MOVBQZX (SI), R12
-	ADDQ    $1, SI
-	IMULQ   ·prime5v(SB), R12
-	XORQ    R12, AX
+loop1:
+	MOVBQZX (p), x
+	ADDQ    $1, p
+	IMULQ   ·primes+32(SB), x
+	XORQ    x, h
+	ROLQ    $11, h
+	IMULQ   prime1, h
 
-	ROLQ  $11, AX
-	IMULQ R13, AX
-
-	CMPQ SI, BX
-	JL   singlesLoop
+	CMPQ p, end
+	JL   loop1
 
 finalize:
-	MOVQ  AX, R12
-	SHRQ  $33, R12
-	XORQ  R12, AX
-	IMULQ R14, AX
-	MOVQ  AX, R12
-	SHRQ  $29, R12
-	XORQ  R12, AX
-	IMULQ ·prime3v(SB), AX
-	MOVQ  AX, R12
-	SHRQ  $32, R12
-	XORQ  R12, AX
-
-	MOVQ AX, ret+24(FP)
+	MOVQ  h, x
+	SHRQ  $33, x
+	XORQ  x, h
+	IMULQ prime2, h
+	MOVQ  h, x
+	SHRQ  $29, x
+	XORQ  x, h
+	IMULQ ·primes+16(SB), h
+	MOVQ  h, x
+	SHRQ  $32, x
+	XORQ  x, h
+
+	MOVQ h, ret+24(FP)
 	RET
 
-// writeBlocks uses the same registers as above except that it uses AX to store
-// the d pointer.
-
 // func writeBlocks(d *Digest, b []byte) int
-TEXT ·writeBlocks(SB), NOSPLIT, $0-40
+TEXT ·writeBlocks(SB), NOSPLIT|NOFRAME, $0-40
 	// Load fixed primes needed for round.
-	MOVQ ·prime1v(SB), R13
-	MOVQ ·prime2v(SB), R14
+	MOVQ ·primes+0(SB), prime1
+	MOVQ ·primes+8(SB), prime2
 
 	// Load slice.
-	MOVQ b_base+8(FP), SI
-	MOVQ b_len+16(FP), DX
-	LEAQ (SI)(DX*1), BX
-	SUBQ $32, BX
+	MOVQ b_base+8(FP), p
+	MOVQ b_len+16(FP), n
+	LEAQ (p)(n*1), end
+	SUBQ $32, end
 
 	// Load vN from d.
-	MOVQ d+0(FP), AX
-	MOVQ 0(AX), R8   // v1
-	MOVQ 8(AX), R9   // v2
-	MOVQ 16(AX), R10 // v3
-	MOVQ 24(AX), R11 // v4
+	MOVQ s+0(FP), d
+	MOVQ 0(d), v1
+	MOVQ 8(d), v2
+	MOVQ 16(d), v3
+	MOVQ 24(d), v4
 
 	// We don't need to check the loop condition here; this function is
 	// always called with at least one block of data to process.
-blockLoop:
-	round(R8)
-	round(R9)
-	round(R10)
-	round(R11)
-
-	CMPQ SI, BX
-	JLE  blockLoop
+	blockLoop()
 
 	// Copy vN back to d.
-	MOVQ R8, 0(AX)
-	MOVQ R9, 8(AX)
-	MOVQ R10, 16(AX)
-	MOVQ R11, 24(AX)
-
-	// The number of bytes written is SI minus the old base pointer.
-	SUBQ b_base+8(FP), SI
-	MOVQ SI, ret+32(FP)
+	MOVQ v1, 0(d)
+	MOVQ v2, 8(d)
+	MOVQ v3, 16(d)
+	MOVQ v4, 24(d)
+
+	// The number of bytes written is p minus the old base pointer.
+	SUBQ b_base+8(FP), p
+	MOVQ p, ret+32(FP)
 
 	RET
diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_arm64.s b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_arm64.s
new file mode 100644
index 00000000..17901e08
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_arm64.s
@@ -0,0 +1,184 @@
+//go:build !appengine && gc && !purego && !noasm
+// +build !appengine
+// +build gc
+// +build !purego
+// +build !noasm
+
+#include "textflag.h"
+
+// Registers:
+#define digest	R1
+#define h	R2 // return value
+#define p	R3 // input pointer
+#define n	R4 // input length
+#define nblocks	R5 // n / 32
+#define prime1	R7
+#define prime2	R8
+#define prime3	R9
+#define prime4	R10
+#define prime5	R11
+#define v1	R12
+#define v2	R13
+#define v3	R14
+#define v4	R15
+#define x1	R20
+#define x2	R21
+#define x3	R22
+#define x4	R23
+
+#define round(acc, x) \
+	MADD prime2, acc, x, acc \
+	ROR  $64-31, acc         \
+	MUL  prime1, acc
+
+// round0 performs the operation x = round(0, x).
+#define round0(x) \
+	MUL prime2, x \
+	ROR $64-31, x \
+	MUL prime1, x
+
+#define mergeRound(acc, x) \
+	round0(x)                     \
+	EOR  x, acc                   \
+	MADD acc, prime4, prime1, acc
+
+// blockLoop processes as many 32-byte blocks as possible,
+// updating v1, v2, v3, and v4. It assumes that n >= 32.
+#define blockLoop() \
+	LSR     $5, n, nblocks  \
+	PCALIGN $16             \
+	loop:                   \
+	LDP.P   16(p), (x1, x2) \
+	LDP.P   16(p), (x3, x4) \
+	round(v1, x1)           \
+	round(v2, x2)           \
+	round(v3, x3)           \
+	round(v4, x4)           \
+	SUB     $1, nblocks     \
+	CBNZ    nblocks, loop
+
+// func Sum64(b []byte) uint64
+TEXT ·Sum64(SB), NOSPLIT|NOFRAME, $0-32
+	LDP b_base+0(FP), (p, n)
+
+	LDP  ·primes+0(SB), (prime1, prime2)
+	LDP  ·primes+16(SB), (prime3, prime4)
+	MOVD ·primes+32(SB), prime5
+
+	CMP  $32, n
+	CSEL LT, prime5, ZR, h // if n < 32 { h = prime5 } else { h = 0 }
+	BLT  afterLoop
+
+	ADD  prime1, prime2, v1
+	MOVD prime2, v2
+	MOVD $0, v3
+	NEG  prime1, v4
+
+	blockLoop()
+
+	ROR $64-1, v1, x1
+	ROR $64-7, v2, x2
+	ADD x1, x2
+	ROR $64-12, v3, x3
+	ROR $64-18, v4, x4
+	ADD x3, x4
+	ADD x2, x4, h
+
+	mergeRound(h, v1)
+	mergeRound(h, v2)
+	mergeRound(h, v3)
+	mergeRound(h, v4)
+
+afterLoop:
+	ADD n, h
+
+	TBZ   $4, n, try8
+	LDP.P 16(p), (x1, x2)
+
+	round0(x1)
+
+	// NOTE: here and below, sequencing the EOR after the ROR (using a
+	// rotated register) is worth a small but measurable speedup for small
+	// inputs.
+	ROR  $64-27, h
+	EOR  x1 @> 64-27, h, h
+	MADD h, prime4, prime1, h
+
+	round0(x2)
+	ROR  $64-27, h
+	EOR  x2 @> 64-27, h, h
+	MADD h, prime4, prime1, h
+
+try8:
+	TBZ    $3, n, try4
+	MOVD.P 8(p), x1
+
+	round0(x1)
+	ROR  $64-27, h
+	EOR  x1 @> 64-27, h, h
+	MADD h, prime4, prime1, h
+
+try4:
+	TBZ     $2, n, try2
+	MOVWU.P 4(p), x2
+
+	MUL  prime1, x2
+	ROR  $64-23, h
+	EOR  x2 @> 64-23, h, h
+	MADD h, prime3, prime2, h
+
+try2:
+	TBZ     $1, n, try1
+	MOVHU.P 2(p), x3
+	AND     $255, x3, x1
+	LSR     $8, x3, x2
+
+	MUL prime5, x1
+	ROR $64-11, h
+	EOR x1 @> 64-11, h, h
+	MUL prime1, h
+
+	MUL prime5, x2
+	ROR $64-11, h
+	EOR x2 @> 64-11, h, h
+	MUL prime1, h
+
+try1:
+	TBZ   $0, n, finalize
+	MOVBU (p), x4
+
+	MUL prime5, x4
+	ROR $64-11, h
+	EOR x4 @> 64-11, h, h
+	MUL prime1, h
+
+finalize:
+	EOR h >> 33, h
+	MUL prime2, h
+	EOR h >> 29, h
+	MUL prime3, h
+	EOR h >> 32, h
+
+	MOVD h, ret+24(FP)
+	RET
+
+// func writeBlocks(d *Digest, b []byte) int
+TEXT ·writeBlocks(SB), NOSPLIT|NOFRAME, $0-40
+	LDP ·primes+0(SB), (prime1, prime2)
+
+	// Load state. Assume v[1-4] are stored contiguously.
+	MOVD d+0(FP), digest
+	LDP  0(digest), (v1, v2)
+	LDP  16(digest), (v3, v4)
+
+	LDP b_base+8(FP), (p, n)
+
+	blockLoop()
+
+	// Store updated state.
+	STP (v1, v2), 0(digest)
+	STP (v3, v4), 16(digest)
+
+	BIC  $31, n
+	MOVD n, ret+32(FP)
+	RET
diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_asm.go b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_asm.go
new file mode 100644
index 00000000..d4221edf
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_asm.go
@@ -0,0 +1,16 @@
+//go:build (amd64 || arm64) && !appengine && gc && !purego && !noasm
+// +build amd64 arm64
+// +build !appengine
+// +build gc
+// +build !purego
+// +build !noasm
+
+package xxhash
+
+// Sum64 computes the 64-bit xxHash digest of b.
+//
+//go:noescape
+func Sum64(b []byte) uint64
+
+//go:noescape
+func writeBlocks(s *Digest, b []byte) int
diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_other.go b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_other.go
index 1f52f296..0be16cef 100644
--- a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_other.go
+++ b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_other.go
@@ -1,5 +1,5 @@
-//go:build !amd64 || appengine || !gc || purego
-// +build !amd64 appengine !gc purego
+//go:build (!amd64 && !arm64) || appengine || !gc || purego || noasm
+// +build !amd64,!arm64 appengine !gc purego noasm
 
 package xxhash
 
@@ -15,10 +15,10 @@ func Sum64(b []byte) uint64 {
 	var h uint64
 
 	if n >= 32 {
-		v1 := prime1v + prime2
+		v1 := primes[0] + prime2
 		v2 := prime2
 		v3 := uint64(0)
-		v4 := -prime1v
+		v4 := -primes[0]
 		for len(b) >= 32 {
 			v1 = round(v1, u64(b[0:8:len(b)]))
 			v2 = round(v2, u64(b[8:16:len(b)]))
@@ -37,19 +37,18 @@ func Sum64(b []byte) uint64 {
 
 	h += uint64(n)
 
-	i, end := 0, len(b)
-	for ; i+8 <= end; i += 8 {
-		k1 := round(0, u64(b[i:i+8:len(b)]))
+	for ; len(b) >= 8; b = b[8:] {
+		k1 := round(0, u64(b[:8]))
 		h ^= k1
 		h = rol27(h)*prime1 + prime4
 	}
-	if i+4 <= end {
-		h ^= uint64(u32(b[i:i+4:len(b)])) * prime1
+	if len(b) >= 4 {
+		h ^= uint64(u32(b[:4])) * prime1
 		h = rol23(h)*prime2 + prime3
-		i += 4
+		b = b[4:]
 	}
-	for ; i < end; i++ {
-		h ^= uint64(b[i]) * prime5
+	for ; len(b) > 0; b = b[1:] {
+		h ^= uint64(b[0]) * prime5
 		h = rol11(h) * prime1
 	}
 
diff --git a/vendor/github.com/klauspost/compress/zstd/matchlen_amd64.go b/vendor/github.com/klauspost/compress/zstd/matchlen_amd64.go
new file mode 100644
index 00000000..f41932b7
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/zstd/matchlen_amd64.go
@@ -0,0 +1,16 @@
+//go:build amd64 && !appengine && !noasm && gc
+// +build amd64,!appengine,!noasm,gc
+
+// Copyright 2019+ Klaus Post. All rights reserved.
+// License information can be found in the LICENSE file.
+
+package zstd
+
+// matchLen returns how many bytes match in a and b
+//
+// It assumes that:
+//
+//	len(a) <= len(b) and len(a) > 0
+//
+//go:noescape
+func matchLen(a []byte, b []byte) int
diff --git a/vendor/github.com/klauspost/compress/zstd/matchlen_amd64.s b/vendor/github.com/klauspost/compress/zstd/matchlen_amd64.s
new file mode 100644
index 00000000..9a7655c0
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/zstd/matchlen_amd64.s
@@ -0,0 +1,68 @@
+// Copied from S2 implementation.
+
+//go:build !appengine && !noasm && gc && !noasm
+
+#include "textflag.h"
+
+// func matchLen(a []byte, b []byte) int
+// Requires: BMI
+TEXT ·matchLen(SB), NOSPLIT, $0-56
+	MOVQ a_base+0(FP), AX
+	MOVQ b_base+24(FP), CX
+	MOVQ a_len+8(FP), DX
+
+	// matchLen
+	XORL SI, SI
+	CMPL DX, $0x08
+	JB   matchlen_match4_standalone
+
+matchlen_loopback_standalone:
+	MOVQ  (AX)(SI*1), BX
+	XORQ  (CX)(SI*1), BX
+	TESTQ BX, BX
+	JZ    matchlen_loop_standalone
+
+#ifdef GOAMD64_v3
+	TZCNTQ BX, BX
+#else
+	BSFQ BX, BX
+#endif
+	SARQ $0x03, BX
+	LEAL (SI)(BX*1), SI
+	JMP  gen_match_len_end
+
+matchlen_loop_standalone:
+	LEAL -8(DX), DX
+	LEAL 8(SI), SI
+	CMPL DX, $0x08
+	JAE  matchlen_loopback_standalone
+
+matchlen_match4_standalone:
+	CMPL DX, $0x04
+	JB   matchlen_match2_standalone
+	MOVL (AX)(SI*1), BX
+	CMPL (CX)(SI*1), BX
+	JNE  matchlen_match2_standalone
+	LEAL -4(DX), DX
+	LEAL 4(SI), SI
+
+matchlen_match2_standalone:
+	CMPL DX, $0x02
+	JB   matchlen_match1_standalone
+	MOVW (AX)(SI*1), BX
+	CMPW (CX)(SI*1), BX
+	JNE  matchlen_match1_standalone
+	LEAL -2(DX), DX
+	LEAL 2(SI), SI
+
+matchlen_match1_standalone:
+	CMPL DX, $0x01
+	JB   gen_match_len_end
+	MOVB (AX)(SI*1), BL
+	CMPB (CX)(SI*1), BL
+	JNE  gen_match_len_end
+	INCL SI
+
+gen_match_len_end:
+	MOVQ SI, ret+48(FP)
+	RET
diff --git a/vendor/github.com/klauspost/compress/zstd/matchlen_generic.go b/vendor/github.com/klauspost/compress/zstd/matchlen_generic.go
new file mode 100644
index 00000000..57b9c31c
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/zstd/matchlen_generic.go
@@ -0,0 +1,33 @@
+//go:build !amd64 || appengine || !gc || noasm
+// +build !amd64 appengine !gc noasm
+
+// Copyright 2019+ Klaus Post. All rights reserved.
+// License information can be found in the LICENSE file.
+
+package zstd
+
+import (
+	"encoding/binary"
+	"math/bits"
+)
+
+// matchLen returns the maximum common prefix length of a and b.
+// a must be the shortest of the two.
+func matchLen(a, b []byte) (n int) {
+	for ; len(a) >= 8 && len(b) >= 8; a, b = a[8:], b[8:] {
+		diff := binary.LittleEndian.Uint64(a) ^ binary.LittleEndian.Uint64(b)
+		if diff != 0 {
+			return n + bits.TrailingZeros64(diff)>>3
+		}
+		n += 8
+	}
+
+	for i := range a {
+		if a[i] != b[i] {
+			break
+		}
+		n++
+	}
+	return n
+
+}
diff --git a/vendor/github.com/klauspost/compress/zstd/seqdec.go b/vendor/github.com/klauspost/compress/zstd/seqdec.go
index 1dd39e63..9405fcf1 100644
--- a/vendor/github.com/klauspost/compress/zstd/seqdec.go
+++ b/vendor/github.com/klauspost/compress/zstd/seqdec.go
@@ -20,6 +20,10 @@ type seq struct {
 	llCode, mlCode, ofCode uint8
 }
 
+type seqVals struct {
+	ll, ml, mo int
+}
+
 func (s seq) String() string {
 	if s.offset <= 3 {
 		if s.offset == 0 {
@@ -61,16 +65,19 @@ type sequenceDecs struct {
 	offsets      sequenceDec
 	matchLengths sequenceDec
 	prevOffset   [3]int
-	hist         []byte
 	dict         []byte
 	literals     []byte
 	out          []byte
+	nSeqs        int
+	br           *bitReader
+	seqSize      int
 	windowSize   int
 	maxBits      uint8
+	maxSyncLen   uint64
 }
 
 // initialize all 3 decoders from the stream input.
-func (s *sequenceDecs) initialize(br *bitReader, hist *history, literals, out []byte) error {
+func (s *sequenceDecs) initialize(br *bitReader, hist *history, out []byte) error {
 	if err := s.litLengths.init(br); err != nil {
 		return errors.New("litLengths:" + err.Error())
 	}
@@ -80,8 +87,7 @@ func (s *sequenceDecs) initialize(br *bitReader, hist *history, literals, out []
 	if err := s.matchLengths.init(br); err != nil {
 		return errors.New("matchLengths:" + err.Error())
 	}
-	s.literals = literals
-	s.hist = hist.b
+	s.br = br
 	s.prevOffset = hist.recentOffsets
 	s.maxBits = s.litLengths.fse.maxBits + s.offsets.fse.maxBits + s.matchLengths.fse.maxBits
 	s.windowSize = hist.windowSize
@@ -93,16 +99,149 @@ func (s *sequenceDecs) initialize(br *bitReader, hist *history, literals, out []
 	return nil
 }
 
+func (s *sequenceDecs) freeDecoders() {
+	if f := s.litLengths.fse; f != nil && !f.preDefined {
+		fseDecoderPool.Put(f)
+		s.litLengths.fse = nil
+	}
+	if f := s.offsets.fse; f != nil && !f.preDefined {
+		fseDecoderPool.Put(f)
+		s.offsets.fse = nil
+	}
+	if f := s.matchLengths.fse; f != nil && !f.preDefined {
+		fseDecoderPool.Put(f)
+		s.matchLengths.fse = nil
+	}
+}
+
+// execute will execute the decoded sequence with the provided history.
+// The sequence must be evaluated before being sent.
+func (s *sequenceDecs) execute(seqs []seqVals, hist []byte) error {
+	if len(s.dict) == 0 {
+		return s.executeSimple(seqs, hist)
+	}
+
+	// Ensure we have enough output size...
+	if len(s.out)+s.seqSize > cap(s.out) {
+		addBytes := s.seqSize + len(s.out)
+		s.out = append(s.out, make([]byte, addBytes)...)
+		s.out = s.out[:len(s.out)-addBytes]
+	}
+
+	if debugDecoder {
+		printf("Execute %d seqs with hist %d, dict %d, literals: %d into %d bytes\n", len(seqs), len(hist), len(s.dict), len(s.literals), s.seqSize)
+	}
+
+	var t = len(s.out)
+	out := s.out[:t+s.seqSize]
+
+	for _, seq := range seqs {
+		// Add literals
+		copy(out[t:], s.literals[:seq.ll])
+		t += seq.ll
+		s.literals = s.literals[seq.ll:]
+
+		// Copy from dictionary...
+		if seq.mo > t+len(hist) || seq.mo > s.windowSize {
+			if len(s.dict) == 0 {
+				return fmt.Errorf("match offset (%d) bigger than current history (%d)", seq.mo, t+len(hist))
+			}
+
+			// we may be in dictionary.
+			dictO := len(s.dict) - (seq.mo - (t + len(hist)))
+			if dictO < 0 || dictO >= len(s.dict) {
+				return fmt.Errorf("match offset (%d) bigger than current history+dict (%d)", seq.mo, t+len(hist)+len(s.dict))
+			}
+			end := dictO + seq.ml
+			if end > len(s.dict) {
+				n := len(s.dict) - dictO
+				copy(out[t:], s.dict[dictO:])
+				t += n
+				seq.ml -= n
+			} else {
+				copy(out[t:], s.dict[dictO:end])
+				t += end - dictO
+				continue
+			}
+		}
+
+		// Copy from history.
+		if v := seq.mo - t; v > 0 {
+			// v is the start position in history from end.
+			start := len(hist) - v
+			if seq.ml > v {
+				// Some goes into current block.
+				// Copy remainder of history
+				copy(out[t:], hist[start:])
+				t += v
+				seq.ml -= v
+			} else {
+				copy(out[t:], hist[start:start+seq.ml])
+				t += seq.ml
+				continue
+			}
+		}
+		// We must be in current buffer now
+		if seq.ml > 0 {
+			start := t - seq.mo
+			if seq.ml <= t-start {
+				// No overlap
+				copy(out[t:], out[start:start+seq.ml])
+				t += seq.ml
+				continue
+			} else {
+				// Overlapping copy
+				// Extend destination slice and copy one byte at the time.
+				src := out[start : start+seq.ml]
+				dst := out[t:]
+				dst = dst[:len(src)]
+				t += len(src)
+				// Destination is the space we just added.
+				for i := range src {
+					dst[i] = src[i]
+				}
+			}
+		}
+	}
+
+	// Add final literals
+	copy(out[t:], s.literals)
+	if debugDecoder {
+		t += len(s.literals)
+		if t != len(out) {
+			panic(fmt.Errorf("length mismatch, want %d, got %d, ss: %d", len(out), t, s.seqSize))
+		}
+	}
+	s.out = out
+
+	return nil
+}
+
 // decode sequences from the stream with the provided history.
-func (s *sequenceDecs) decode(seqs int, br *bitReader, hist []byte) error {
+func (s *sequenceDecs) decodeSync(hist []byte) error {
+	supported, err := s.decodeSyncSimple(hist)
+	if supported {
+		return err
+	}
+
+	br := s.br
+	seqs := s.nSeqs
 	startSize := len(s.out)
 	// Grab full sizes tables, to avoid bounds checks.
 	llTable, mlTable, ofTable := s.litLengths.fse.dt[:maxTablesize], s.matchLengths.fse.dt[:maxTablesize], s.offsets.fse.dt[:maxTablesize]
 	llState, mlState, ofState := s.litLengths.state.state, s.matchLengths.state.state, s.offsets.state.state
+	out := s.out
+	maxBlockSize := maxCompressedBlockSize
+	if s.windowSize < maxBlockSize {
+		maxBlockSize = s.windowSize
+	}
 
+	if debugDecoder {
+		println("decodeSync: decoding", seqs, "sequences", br.remain(), "bits remain on stream")
+	}
 	for i := seqs - 1; i >= 0; i-- {
 		if br.overread() {
-			printf("reading sequence %d, exceeded available data\n", seqs-i)
+			printf("reading sequence %d, exceeded available data. Overread by %d\n", seqs-i, -br.remain())
 			return io.ErrUnexpectedEOF
 		}
 		var ll, mo, ml int
@@ -151,7 +290,7 @@ func (s *sequenceDecs) decode(seqs int, br *bitReader, hist []byte) error {
 
 					if temp == 0 {
 						// 0 is not valid; input is corrupted; force offset to 1
-						println("temp was 0")
+						println("WARNING: temp was 0")
 						temp = 1
 					}
 
@@ -176,51 +315,49 @@ func (s *sequenceDecs) decode(seqs int, br *bitReader, hist []byte) error {
 		if ll > len(s.literals) {
 			return fmt.Errorf("unexpected literal count, want %d bytes, but only %d is available", ll, len(s.literals))
 		}
-		size := ll + ml + len(s.out)
+		size := ll + ml + len(out)
 		if size-startSize > maxBlockSize {
-			return fmt.Errorf("output (%d) bigger than max block size", size)
+			return fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
 		}
-		if size > cap(s.out) {
+		if size > cap(out) {
 			// Not enough size, which can happen under high volume block streaming conditions
 			// but could be if destination slice is too small for sync operations.
 			// over-allocating here can create a large amount of GC pressure so we try to keep
 			// it as contained as possible
-			used := len(s.out) - startSize
+			used := len(out) - startSize
 			addBytes := 256 + ll + ml + used>>2
 			// Clamp to max block size.
 			if used+addBytes > maxBlockSize {
 				addBytes = maxBlockSize - used
 			}
-			s.out = append(s.out, make([]byte, addBytes)...)
-			s.out = s.out[:len(s.out)-addBytes]
+			out = append(out, make([]byte, addBytes)...)
+			out = out[:len(out)-addBytes]
 		}
 		if ml > maxMatchLen {
 			return fmt.Errorf("match len (%d) bigger than max allowed length", ml)
 		}
 
 		// Add literals
-		s.out = append(s.out, s.literals[:ll]...)
+		out = append(out, s.literals[:ll]...)
 		s.literals = s.literals[ll:]
-		out := s.out
 
 		if mo == 0 && ml > 0 {
 			return fmt.Errorf("zero matchoff and matchlen (%d) > 0", ml)
 		}
 
-		if mo > len(s.out)+len(hist) || mo > s.windowSize {
+		if mo > len(out)+len(hist) || mo > s.windowSize {
 			if len(s.dict) == 0 {
-				return fmt.Errorf("match offset (%d) bigger than current history (%d)", mo, len(s.out)+len(hist))
+				return fmt.Errorf("match offset (%d) bigger than current history (%d)", mo, len(out)+len(hist)-startSize)
 			}
 
 			// we may be in dictionary.
-			dictO := len(s.dict) - (mo - (len(s.out) + len(hist)))
+			dictO := len(s.dict) - (mo - (len(out) + len(hist)))
 			if dictO < 0 || dictO >= len(s.dict) {
-				return fmt.Errorf("match offset (%d) bigger than current history (%d)", mo, len(s.out)+len(hist))
+				return fmt.Errorf("match offset (%d) bigger than current history (%d)", mo, len(out)+len(hist)-startSize)
 			}
 			end := dictO + ml
 			if end > len(s.dict) {
 				out = append(out, s.dict[dictO:]...)
-				mo -= len(s.dict) - dictO
 				ml -= len(s.dict) - dictO
 			} else {
 				out = append(out, s.dict[dictO:end]...)
@@ -231,26 +368,25 @@ func (s *sequenceDecs) decode(seqs int, br *bitReader, hist []byte) error {
 
 		// Copy from history.
 		// TODO: Blocks without history could be made to ignore this completely.
-		if v := mo - len(s.out); v > 0 {
+		if v := mo - len(out); v > 0 {
 			// v is the start position in history from end.
-			start := len(s.hist) - v
+			start := len(hist) - v
 			if ml > v {
 				// Some goes into current block.
 				// Copy remainder of history
-				out = append(out, s.hist[start:]...)
-				mo -= v
+				out = append(out, hist[start:]...)
 				ml -= v
 			} else {
-				out = append(out, s.hist[start:start+ml]...)
+				out = append(out, hist[start:start+ml]...)
 				ml = 0
 			}
 		}
 		// We must be in current buffer now
 		if ml > 0 {
-			start := len(s.out) - mo
-			if ml <= len(s.out)-start {
+			start := len(out) - mo
+			if ml <= len(out)-start {
 				// No overlap
-				out = append(out, s.out[start:start+ml]...)
+				out = append(out, out[start:start+ml]...)
 			} else {
 				// Overlapping copy
 				// Extend destination slice and copy one byte at the time.
@@ -264,7 +400,6 @@ func (s *sequenceDecs) decode(seqs int, br *bitReader, hist []byte) error {
 				}
 			}
 		}
-		s.out = out
 		if i == 0 {
 			// This is the last sequence, so we shouldn't update state.
 			break
@@ -278,7 +413,8 @@ func (s *sequenceDecs) decode(seqs int, br *bitReader, hist []byte) error {
 			mlState = mlTable[mlState.newState()&maxTableMask]
 			ofState = ofTable[ofState.newState()&maxTableMask]
 		} else {
-			bits := br.getBitsFast(nBits)
+			bits := br.get32BitsFast(nBits)
+
 			lowBits := uint16(bits >> ((ofState.nbBits() + mlState.nbBits()) & 31))
 			llState = llTable[(llState.newState()+lowBits)&maxTableMask]
 
@@ -291,19 +427,13 @@ func (s *sequenceDecs) decode(seqs int, br *bitReader, hist []byte) error {
 		}
 	}
 
-	// Add final literals
-	s.out = append(s.out, s.literals...)
-	return nil
-}
+	if size := len(s.literals) + len(out) - startSize; size > maxBlockSize {
+		return fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
+	}
 
-// update states, at least 27 bits must be available.
-func (s *sequenceDecs) update(br *bitReader) {
-	// Max 8 bits
-	s.litLengths.state.next(br)
-	// Max 9 bits
-	s.matchLengths.state.next(br)
-	// Max 8 bits
-	s.offsets.state.next(br)
+	// Add final literals
+	s.out = append(out, s.literals...)
+	return br.close()
 }
 
 var bitMask [16]uint16
@@ -314,87 +444,6 @@ func init() {
 	}
 }
 
-// update states, at least 27 bits must be available.
-func (s *sequenceDecs) updateAlt(br *bitReader) {
-	// Update all 3 states at once. Approx 20% faster.
-	a, b, c := s.litLengths.state.state, s.matchLengths.state.state, s.offsets.state.state
-
-	nBits := a.nbBits() + b.nbBits() + c.nbBits()
-	if nBits == 0 {
-		s.litLengths.state.state = s.litLengths.state.dt[a.newState()]
-		s.matchLengths.state.state = s.matchLengths.state.dt[b.newState()]
-		s.offsets.state.state = s.offsets.state.dt[c.newState()]
-		return
-	}
-	bits := br.getBitsFast(nBits)
-	lowBits := uint16(bits >> ((c.nbBits() + b.nbBits()) & 31))
-	s.litLengths.state.state = s.litLengths.state.dt[a.newState()+lowBits]
-
-	lowBits = uint16(bits >> (c.nbBits() & 31))
-	lowBits &= bitMask[b.nbBits()&15]
-	s.matchLengths.state.state = s.matchLengths.state.dt[b.newState()+lowBits]
-
-	lowBits = uint16(bits) & bitMask[c.nbBits()&15]
-	s.offsets.state.state = s.offsets.state.dt[c.newState()+lowBits]
-}
-
-// nextFast will return new states when there are at least 4 unused bytes left on the stream when done.
-func (s *sequenceDecs) nextFast(br *bitReader, llState, mlState, ofState decSymbol) (ll, mo, ml int) {
-	// Final will not read from stream.
-	ll, llB := llState.final()
-	ml, mlB := mlState.final()
-	mo, moB := ofState.final()
-
-	// extra bits are stored in reverse order.
-	br.fillFast()
-	mo += br.getBits(moB)
-	if s.maxBits > 32 {
-		br.fillFast()
-	}
-	ml += br.getBits(mlB)
-	ll += br.getBits(llB)
-
-	if moB > 1 {
-		s.prevOffset[2] = s.prevOffset[1]
-		s.prevOffset[1] = s.prevOffset[0]
-		s.prevOffset[0] = mo
-		return
-	}
-	// mo = s.adjustOffset(mo, ll, moB)
-	// Inlined for rather big speedup
-	if ll == 0 {
-		// There is an exception though, when current sequence's literals_length = 0.
-		// In this case, repeated offsets are shifted by one, so an offset_value of 1 means Repeated_Offset2,
-		// an offset_value of 2 means Repeated_Offset3, and an offset_value of 3 means Repeated_Offset1 - 1_byte.
-		mo++
-	}
-
-	if mo == 0 {
-		mo = s.prevOffset[0]
-		return
-	}
-	var temp int
-	if mo == 3 {
-		temp = s.prevOffset[0] - 1
-	} else {
-		temp = s.prevOffset[mo]
-	}
-
-	if temp == 0 {
-		// 0 is not valid; input is corrupted; force offset to 1
-		println("temp was 0")
-		temp = 1
-	}
-
-	if mo != 1 {
-		s.prevOffset[2] = s.prevOffset[1]
-	}
-	s.prevOffset[1] = s.prevOffset[0]
-	s.prevOffset[0] = temp
-	mo = temp
-	return
-}
-
 func (s *sequenceDecs) next(br *bitReader, llState, mlState, ofState decSymbol) (ll, mo, ml int) {
 	// Final will not read from stream.
 	ll, llB := llState.final()
@@ -457,36 +506,3 @@ func (s *sequenceDecs) adjustOffset(offset, litLen int, offsetB uint8) int {
 	s.prevOffset[0] = temp
 	return temp
 }
-
-// mergeHistory will merge history.
-func (s *sequenceDecs) mergeHistory(hist *sequenceDecs) (*sequenceDecs, error) {
-	for i := uint(0); i < 3; i++ {
-		var sNew, sHist *sequenceDec
-		switch i {
-		default:
-			// same as "case 0":
-			sNew = &s.litLengths
-			sHist = &hist.litLengths
-		case 1:
-			sNew = &s.offsets
-			sHist = &hist.offsets
-		case 2:
-			sNew = &s.matchLengths
-			sHist = &hist.matchLengths
-		}
-		if sNew.repeat {
-			if sHist.fse == nil {
-				return nil, fmt.Errorf("sequence stream %d, repeat requested, but no history", i)
-			}
-			continue
-		}
-		if sNew.fse == nil {
-			return nil, fmt.Errorf("sequence stream %d, no fse found", i)
-		}
-		if sHist.fse != nil && !sHist.fse.preDefined {
-			fseDecoderPool.Put(sHist.fse)
-		}
-		sHist.fse = sNew.fse
-	}
-	return hist, nil
-}
diff --git a/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.go b/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.go
new file mode 100644
index 00000000..8adabd82
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.go
@@ -0,0 +1,394 @@
+//go:build amd64 && !appengine && !noasm && gc
+// +build amd64,!appengine,!noasm,gc
+
+package zstd
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/klauspost/compress/internal/cpuinfo"
+)
+
+type decodeSyncAsmContext struct {
+	llTable     []decSymbol
+	mlTable     []decSymbol
+	ofTable     []decSymbol
+	llState     uint64
+	mlState     uint64
+	ofState     uint64
+	iteration   int
+	litRemain   int
+	out         []byte
+	outPosition int
+	literals    []byte
+	litPosition int
+	history     []byte
+	windowSize  int
+	ll          int // set on error (not for all errors, please refer to _generate/gen.go)
+	ml          int // set on error (not for all errors, please refer to _generate/gen.go)
+	mo          int // set on error (not for all errors, please refer to _generate/gen.go)
+}
+
+// sequenceDecs_decodeSync_amd64 implements the main loop of sequenceDecs.decodeSync in x86 asm.
+//
+// Please refer to seqdec_generic.go for the reference implementation.
+//
+//go:noescape
+func sequenceDecs_decodeSync_amd64(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
+
+// sequenceDecs_decodeSync_bmi2 implements the main loop of sequenceDecs.decodeSync in x86 asm with BMI2 extensions.
+//
+//go:noescape
+func sequenceDecs_decodeSync_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
+
+// sequenceDecs_decodeSync_safe_amd64 does the same as above, but does not write more than output buffer.
+//
+//go:noescape
+func sequenceDecs_decodeSync_safe_amd64(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
+
+// sequenceDecs_decodeSync_safe_bmi2 does the same as above, but does not write more than output buffer.
+//
+//go:noescape
+func sequenceDecs_decodeSync_safe_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
+
+// decode sequences from the stream with the provided history but without a dictionary.
+func (s *sequenceDecs) decodeSyncSimple(hist []byte) (bool, error) {
+	if len(s.dict) > 0 {
+		return false, nil
+	}
+	if s.maxSyncLen == 0 && cap(s.out)-len(s.out) < maxCompressedBlockSize {
+		return false, nil
+	}
+
+	// FIXME: Using unsafe memory copies leads to rare, random crashes
+	// with fuzz testing. It is therefore disabled for now.
+	const useSafe = true
+	/*
+		useSafe := false
+		if s.maxSyncLen == 0 && cap(s.out)-len(s.out) < maxCompressedBlockSizeAlloc {
+			useSafe = true
+		}
+		if s.maxSyncLen > 0 && cap(s.out)-len(s.out)-compressedBlockOverAlloc < int(s.maxSyncLen) {
+			useSafe = true
+		}
+		if cap(s.literals) < len(s.literals)+compressedBlockOverAlloc {
+			useSafe = true
+		}
+	*/
+
+	br := s.br
+
+	maxBlockSize := maxCompressedBlockSize
+	if s.windowSize < maxBlockSize {
+		maxBlockSize = s.windowSize
+	}
+
+	ctx := decodeSyncAsmContext{
+		llTable:     s.litLengths.fse.dt[:maxTablesize],
+		mlTable:     s.matchLengths.fse.dt[:maxTablesize],
+		ofTable:     s.offsets.fse.dt[:maxTablesize],
+		llState:     uint64(s.litLengths.state.state),
+		mlState:     uint64(s.matchLengths.state.state),
+		ofState:     uint64(s.offsets.state.state),
+		iteration:   s.nSeqs - 1,
+		litRemain:   len(s.literals),
+		out:         s.out,
+		outPosition: len(s.out),
+		literals:    s.literals,
+		windowSize:  s.windowSize,
+		history:     hist,
+	}
+
+	s.seqSize = 0
+	startSize := len(s.out)
+
+	var errCode int
+	if cpuinfo.HasBMI2() {
+		if useSafe {
+			errCode = sequenceDecs_decodeSync_safe_bmi2(s, br, &ctx)
+		} else {
+			errCode = sequenceDecs_decodeSync_bmi2(s, br, &ctx)
+		}
+	} else {
+		if useSafe {
+			errCode = sequenceDecs_decodeSync_safe_amd64(s, br, &ctx)
+		} else {
+			errCode = sequenceDecs_decodeSync_amd64(s, br, &ctx)
+		}
+	}
+	switch errCode {
+	case noError:
+		break
+
+	case errorMatchLenOfsMismatch:
+		return true, fmt.Errorf("zero matchoff and matchlen (%d) > 0", ctx.ml)
+
+	case errorMatchLenTooBig:
+		return true, fmt.Errorf("match len (%d) bigger than max allowed length", ctx.ml)
+
+	case errorMatchOffTooBig:
+		return true, fmt.Errorf("match offset (%d) bigger than current history (%d)",
+			ctx.mo, ctx.outPosition+len(hist)-startSize)
+
+	case errorNotEnoughLiterals:
+		return true, fmt.Errorf("unexpected literal count, want %d bytes, but only %d is available",
+			ctx.ll, ctx.litRemain+ctx.ll)
+
+	case errorOverread:
+		return true, io.ErrUnexpectedEOF
+
+	case errorNotEnoughSpace:
+		size := ctx.outPosition + ctx.ll + ctx.ml
+		if debugDecoder {
+			println("msl:", s.maxSyncLen, "cap", cap(s.out), "bef:", startSize, "sz:", size-startSize, "mbs:", maxBlockSize, "outsz:", cap(s.out)-startSize)
+		}
+		return true, fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
+
+	default:
+		return true, fmt.Errorf("sequenceDecs_decode returned erronous code %d", errCode)
+	}
+
+	s.seqSize += ctx.litRemain
+	if s.seqSize > maxBlockSize {
+		return true, fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
+	}
+	err := br.close()
+	if err != nil {
+		printf("Closing sequences: %v, %+v\n", err, *br)
+		return true, err
+	}
+
+	s.literals = s.literals[ctx.litPosition:]
+	t := ctx.outPosition
+	s.out = s.out[:t]
+
+	// Add final literals
+	s.out = append(s.out, s.literals...)
+	if debugDecoder {
+		t += len(s.literals)
+		if t != len(s.out) {
+			panic(fmt.Errorf("length mismatch, want %d, got %d", len(s.out), t))
+		}
+	}
+
+	return true, nil
+}
+
+// --------------------------------------------------------------------------------
+
+type decodeAsmContext struct {
+	llTable   []decSymbol
+	mlTable   []decSymbol
+	ofTable   []decSymbol
+	llState   uint64
+	mlState   uint64
+	ofState   uint64
+	iteration int
+	seqs      []seqVals
+	litRemain int
+}
+
+const noError = 0
+
+// error reported when mo == 0 && ml > 0
+const errorMatchLenOfsMismatch = 1
+
+// error reported when ml > maxMatchLen
+const errorMatchLenTooBig = 2
+
+// error reported when mo > available history or mo > s.windowSize
+const errorMatchOffTooBig = 3
+
+// error reported when the sum of literal lengths exeeceds the literal buffer size
+const errorNotEnoughLiterals = 4
+
+// error reported when capacity of `out` is too small
+const errorNotEnoughSpace = 5
+
+// error reported when bits are overread.
+const errorOverread = 6
+
+// sequenceDecs_decode implements the main loop of sequenceDecs in x86 asm.
+//
+// Please refer to seqdec_generic.go for the reference implementation.
+//
+//go:noescape
+func sequenceDecs_decode_amd64(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
+
+// sequenceDecs_decode implements the main loop of sequenceDecs in x86 asm.
+//
+// Please refer to seqdec_generic.go for the reference implementation.
+//
+//go:noescape
+func sequenceDecs_decode_56_amd64(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
+
+// sequenceDecs_decode implements the main loop of sequenceDecs in x86 asm with BMI2 extensions.
+//
+//go:noescape
+func sequenceDecs_decode_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
+
+// sequenceDecs_decode implements the main loop of sequenceDecs in x86 asm with BMI2 extensions.
+//
+//go:noescape
+func sequenceDecs_decode_56_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
+
+// decode sequences from the stream without the provided history.
+func (s *sequenceDecs) decode(seqs []seqVals) error {
+	br := s.br
+
+	maxBlockSize := maxCompressedBlockSize
+	if s.windowSize < maxBlockSize {
+		maxBlockSize = s.windowSize
+	}
+
+	ctx := decodeAsmContext{
+		llTable:   s.litLengths.fse.dt[:maxTablesize],
+		mlTable:   s.matchLengths.fse.dt[:maxTablesize],
+		ofTable:   s.offsets.fse.dt[:maxTablesize],
+		llState:   uint64(s.litLengths.state.state),
+		mlState:   uint64(s.matchLengths.state.state),
+		ofState:   uint64(s.offsets.state.state),
+		seqs:      seqs,
+		iteration: len(seqs) - 1,
+		litRemain: len(s.literals),
+	}
+
+	if debugDecoder {
+		println("decode: decoding", len(seqs), "sequences", br.remain(), "bits remain on stream")
+	}
+
+	s.seqSize = 0
+	lte56bits := s.maxBits+s.offsets.fse.actualTableLog+s.matchLengths.fse.actualTableLog+s.litLengths.fse.actualTableLog <= 56
+	var errCode int
+	if cpuinfo.HasBMI2() {
+		if lte56bits {
+			errCode = sequenceDecs_decode_56_bmi2(s, br, &ctx)
+		} else {
+			errCode = sequenceDecs_decode_bmi2(s, br, &ctx)
+		}
+	} else {
+		if lte56bits {
+			errCode = sequenceDecs_decode_56_amd64(s, br, &ctx)
+		} else {
+			errCode = sequenceDecs_decode_amd64(s, br, &ctx)
+		}
+	}
+	if errCode != 0 {
+		i := len(seqs) - ctx.iteration - 1
+		switch errCode {
+		case errorMatchLenOfsMismatch:
+			ml := ctx.seqs[i].ml
+			return fmt.Errorf("zero matchoff and matchlen (%d) > 0", ml)
+
+		case errorMatchLenTooBig:
+			ml := ctx.seqs[i].ml
+			return fmt.Errorf("match len (%d) bigger than max allowed length", ml)
+
+		case errorNotEnoughLiterals:
+			ll := ctx.seqs[i].ll
+			return fmt.Errorf("unexpected literal count, want %d bytes, but only %d is available", ll, ctx.litRemain+ll)
+		case errorOverread:
+			return io.ErrUnexpectedEOF
+		}
+
+		return fmt.Errorf("sequenceDecs_decode_amd64 returned erronous code %d", errCode)
+	}
+
+	if ctx.litRemain < 0 {
+		return fmt.Errorf("literal count is too big: total available %d, total requested %d",
+			len(s.literals), len(s.literals)-ctx.litRemain)
+	}
+
+	s.seqSize += ctx.litRemain
+	if s.seqSize > maxBlockSize {
+		return fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
+	}
+	if debugDecoder {
+		println("decode: ", br.remain(), "bits remain on stream. code:", errCode)
+	}
+	err := br.close()
+	if err != nil {
+		printf("Closing sequences: %v, %+v\n", err, *br)
+	}
+	return err
+}
+
+// --------------------------------------------------------------------------------
+
+type executeAsmContext struct {
+	seqs        []seqVals
+	seqIndex    int
+	out         []byte
+	history     []byte
+	literals    []byte
+	outPosition int
+	litPosition int
+	windowSize  int
+}
+
+// sequenceDecs_executeSimple_amd64 implements the main loop of sequenceDecs.executeSimple in x86 asm.
+//
+// Returns false if a match offset is too big.
+//
+// Please refer to seqdec_generic.go for the reference implementation.
+//
+//go:noescape
+func sequenceDecs_executeSimple_amd64(ctx *executeAsmContext) bool
+
+// Same as above, but with safe memcopies
+//
+//go:noescape
+func sequenceDecs_executeSimple_safe_amd64(ctx *executeAsmContext) bool
+
+// executeSimple handles cases when dictionary is not used.
+func (s *sequenceDecs) executeSimple(seqs []seqVals, hist []byte) error {
+	// Ensure we have enough output size...
+	if len(s.out)+s.seqSize+compressedBlockOverAlloc > cap(s.out) {
+		addBytes := s.seqSize + len(s.out) + compressedBlockOverAlloc
+		s.out = append(s.out, make([]byte, addBytes)...)
+		s.out = s.out[:len(s.out)-addBytes]
+	}
+
+	if debugDecoder {
+		printf("Execute %d seqs with literals: %d into %d bytes\n", len(seqs), len(s.literals), s.seqSize)
+	}
+
+	var t = len(s.out)
+	out := s.out[:t+s.seqSize]
+
+	ctx := executeAsmContext{
+		seqs:        seqs,
+		seqIndex:    0,
+		out:         out,
+		history:     hist,
+		outPosition: t,
+		litPosition: 0,
+		literals:    s.literals,
+		windowSize:  s.windowSize,
+	}
+	var ok bool
+	if cap(s.literals) < len(s.literals)+compressedBlockOverAlloc {
+		ok = sequenceDecs_executeSimple_safe_amd64(&ctx)
+	} else {
+		ok = sequenceDecs_executeSimple_amd64(&ctx)
+	}
+	if !ok {
+		return fmt.Errorf("match offset (%d) bigger than current history (%d)",
+			seqs[ctx.seqIndex].mo, ctx.outPosition+len(hist))
+	}
+	s.literals = s.literals[ctx.litPosition:]
+	t = ctx.outPosition
+
+	// Add final literals
+	copy(out[t:], s.literals)
+	if debugDecoder {
+		t += len(s.literals)
+		if t != len(out) {
+			panic(fmt.Errorf("length mismatch, want %d, got %d, ss: %d", len(out), t, s.seqSize))
+		}
+	}
+	s.out = out
+
+	return nil
+}
diff --git a/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.s b/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.s
new file mode 100644
index 00000000..b6f4ba6f
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.s
@@ -0,0 +1,4175 @@
+// Code generated by command: go run gen.go -out ../seqdec_amd64.s -pkg=zstd. DO NOT EDIT.
+
+//go:build !appengine && !noasm && gc && !noasm
+
+// func sequenceDecs_decode_amd64(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
+// Requires: CMOV
+TEXT ·sequenceDecs_decode_amd64(SB), $8-32
+	MOVQ    br+8(FP), AX
+	MOVQ    32(AX), DX
+	MOVBQZX 40(AX), BX
+	MOVQ    24(AX), SI
+	MOVQ    (AX), AX
+	ADDQ    SI, AX
+	MOVQ    AX, (SP)
+	MOVQ    ctx+16(FP), AX
+	MOVQ    72(AX), DI
+	MOVQ    80(AX), R8
+	MOVQ    88(AX), R9
+	MOVQ    104(AX), R10
+	MOVQ    s+0(FP), AX
+	MOVQ    144(AX), R11
+	MOVQ    152(AX), R12
+	MOVQ    160(AX), R13
+
+sequenceDecs_decode_amd64_main_loop:
+	MOVQ (SP), R14
+
+	// Fill bitreader to have enough for the offset and match length.
+	CMPQ SI, $0x08
+	JL   sequenceDecs_decode_amd64_fill_byte_by_byte
+	MOVQ BX, AX
+	SHRQ $0x03, AX
+	SUBQ AX, R14
+	MOVQ (R14), DX
+	SUBQ AX, SI
+	ANDQ $0x07, BX
+	JMP  sequenceDecs_decode_amd64_fill_end
+
+sequenceDecs_decode_amd64_fill_byte_by_byte:
+	CMPQ    SI, $0x00
+	JLE     sequenceDecs_decode_amd64_fill_check_overread
+	CMPQ    BX, $0x07
+	JLE     sequenceDecs_decode_amd64_fill_end
+	SHLQ    $0x08, DX
+	SUBQ    $0x01, R14
+	SUBQ    $0x01, SI
+	SUBQ    $0x08, BX
+	MOVBQZX (R14), AX
+	ORQ     AX, DX
+	JMP     sequenceDecs_decode_amd64_fill_byte_by_byte
+
+sequenceDecs_decode_amd64_fill_check_overread:
+	CMPQ BX, $0x40
+	JA   error_overread
+
+sequenceDecs_decode_amd64_fill_end:
+	// Update offset
+	MOVQ  R9, AX
+	MOVQ  BX, CX
+	MOVQ  DX, R15
+	SHLQ  CL, R15
+	MOVB  AH, CL
+	SHRQ  $0x20, AX
+	TESTQ CX, CX
+	JZ    sequenceDecs_decode_amd64_of_update_zero
+	ADDQ  CX, BX
+	CMPQ  BX, $0x40
+	JA    sequenceDecs_decode_amd64_of_update_zero
+	CMPQ  CX, $0x40
+	JAE   sequenceDecs_decode_amd64_of_update_zero
+	NEGQ  CX
+	SHRQ  CL, R15
+	ADDQ  R15, AX
+
+sequenceDecs_decode_amd64_of_update_zero:
+	MOVQ AX, 16(R10)
+
+	// Update match length
+	MOVQ  R8, AX
+	MOVQ  BX, CX
+	MOVQ  DX, R15
+	SHLQ  CL, R15
+	MOVB  AH, CL
+	SHRQ  $0x20, AX
+	TESTQ CX, CX
+	JZ    sequenceDecs_decode_amd64_ml_update_zero
+	ADDQ  CX, BX
+	CMPQ  BX, $0x40
+	JA    sequenceDecs_decode_amd64_ml_update_zero
+	CMPQ  CX, $0x40
+	JAE   sequenceDecs_decode_amd64_ml_update_zero
+	NEGQ  CX
+	SHRQ  CL, R15
+	ADDQ  R15, AX
+
+sequenceDecs_decode_amd64_ml_update_zero:
+	MOVQ AX, 8(R10)
+
+	// Fill bitreader to have enough for the remaining
+	CMPQ SI, $0x08
+	JL   sequenceDecs_decode_amd64_fill_2_byte_by_byte
+	MOVQ BX, AX
+	SHRQ $0x03, AX
+	SUBQ AX, R14
+	MOVQ (R14), DX
+	SUBQ AX, SI
+	ANDQ $0x07, BX
+	JMP  sequenceDecs_decode_amd64_fill_2_end
+
+sequenceDecs_decode_amd64_fill_2_byte_by_byte:
+	CMPQ    SI, $0x00
+	JLE     sequenceDecs_decode_amd64_fill_2_check_overread
+	CMPQ    BX, $0x07
+	JLE     sequenceDecs_decode_amd64_fill_2_end
+	SHLQ    $0x08, DX
+	SUBQ    $0x01, R14
+	SUBQ    $0x01, SI
+	SUBQ    $0x08, BX
+	MOVBQZX (R14), AX
+	ORQ     AX, DX
+	JMP     sequenceDecs_decode_amd64_fill_2_byte_by_byte
+
+sequenceDecs_decode_amd64_fill_2_check_overread:
+	CMPQ BX, $0x40
+	JA   error_overread
+
+sequenceDecs_decode_amd64_fill_2_end:
+	// Update literal length
+	MOVQ  DI, AX
+	MOVQ  BX, CX
+	MOVQ  DX, R15
+	SHLQ  CL, R15
+	MOVB  AH, CL
+	SHRQ  $0x20, AX
+	TESTQ CX, CX
+	JZ    sequenceDecs_decode_amd64_ll_update_zero
+	ADDQ  CX, BX
+	CMPQ  BX, $0x40
+	JA    sequenceDecs_decode_amd64_ll_update_zero
+	CMPQ  CX, $0x40
+	JAE   sequenceDecs_decode_amd64_ll_update_zero
+	NEGQ  CX
+	SHRQ  CL, R15
+	ADDQ  R15, AX
+
+sequenceDecs_decode_amd64_ll_update_zero:
+	MOVQ AX, (R10)
+
+	// Fill bitreader for state updates
+	MOVQ    R14, (SP)
+	MOVQ    R9, AX
+	SHRQ    $0x08, AX
+	MOVBQZX AL, AX
+	MOVQ    ctx+16(FP), CX
+	CMPQ    96(CX), $0x00
+	JZ      sequenceDecs_decode_amd64_skip_update
+
+	// Update Literal Length State
+	MOVBQZX DI, R14
+	SHRQ    $0x10, DI
+	MOVWQZX DI, DI
+	LEAQ    (BX)(R14*1), CX
+	MOVQ    DX, R15
+	MOVQ    CX, BX
+	ROLQ    CL, R15
+	MOVL    $0x00000001, BP
+	MOVB    R14, CL
+	SHLL    CL, BP
+	DECL    BP
+	ANDQ    BP, R15
+	ADDQ    R15, DI
+
+	// Load ctx.llTable
+	MOVQ ctx+16(FP), CX
+	MOVQ (CX), CX
+	MOVQ (CX)(DI*8), DI
+
+	// Update Match Length State
+	MOVBQZX R8, R14
+	SHRQ    $0x10, R8
+	MOVWQZX R8, R8
+	LEAQ    (BX)(R14*1), CX
+	MOVQ    DX, R15
+	MOVQ    CX, BX
+	ROLQ    CL, R15
+	MOVL    $0x00000001, BP
+	MOVB    R14, CL
+	SHLL    CL, BP
+	DECL    BP
+	ANDQ    BP, R15
+	ADDQ    R15, R8
+
+	// Load ctx.mlTable
+	MOVQ ctx+16(FP), CX
+	MOVQ 24(CX), CX
+	MOVQ (CX)(R8*8), R8
+
+	// Update Offset State
+	MOVBQZX R9, R14
+	SHRQ    $0x10, R9
+	MOVWQZX R9, R9
+	LEAQ    (BX)(R14*1), CX
+	MOVQ    DX, R15
+	MOVQ    CX, BX
+	ROLQ    CL, R15
+	MOVL    $0x00000001, BP
+	MOVB    R14, CL
+	SHLL    CL, BP
+	DECL    BP
+	ANDQ    BP, R15
+	ADDQ    R15, R9
+
+	// Load ctx.ofTable
+	MOVQ ctx+16(FP), CX
+	MOVQ 48(CX), CX
+	MOVQ (CX)(R9*8), R9
+
+sequenceDecs_decode_amd64_skip_update:
+	// Adjust offset
+	MOVQ 16(R10), CX
+	CMPQ AX, $0x01
+	JBE  sequenceDecs_decode_amd64_adjust_offsetB_1_or_0
+	MOVQ R12, R13
+	MOVQ R11, R12
+	MOVQ CX, R11
+	JMP  sequenceDecs_decode_amd64_after_adjust
+
+sequenceDecs_decode_amd64_adjust_offsetB_1_or_0:
+	CMPQ (R10), $0x00000000
+	JNE  sequenceDecs_decode_amd64_adjust_offset_maybezero
+	INCQ CX
+	JMP  sequenceDecs_decode_amd64_adjust_offset_nonzero
+
+sequenceDecs_decode_amd64_adjust_offset_maybezero:
+	TESTQ CX, CX
+	JNZ   sequenceDecs_decode_amd64_adjust_offset_nonzero
+	MOVQ  R11, CX
+	JMP   sequenceDecs_decode_amd64_after_adjust
+
+sequenceDecs_decode_amd64_adjust_offset_nonzero:
+	CMPQ CX, $0x01
+	JB   sequenceDecs_decode_amd64_adjust_zero
+	JEQ  sequenceDecs_decode_amd64_adjust_one
+	CMPQ CX, $0x02
+	JA   sequenceDecs_decode_amd64_adjust_three
+	JMP  sequenceDecs_decode_amd64_adjust_two
+
+sequenceDecs_decode_amd64_adjust_zero:
+	MOVQ R11, AX
+	JMP  sequenceDecs_decode_amd64_adjust_test_temp_valid
+
+sequenceDecs_decode_amd64_adjust_one:
+	MOVQ R12, AX
+	JMP  sequenceDecs_decode_amd64_adjust_test_temp_valid
+
+sequenceDecs_decode_amd64_adjust_two:
+	MOVQ R13, AX
+	JMP  sequenceDecs_decode_amd64_adjust_test_temp_valid
+
+sequenceDecs_decode_amd64_adjust_three:
+	LEAQ -1(R11), AX
+
+sequenceDecs_decode_amd64_adjust_test_temp_valid:
+	TESTQ AX, AX
+	JNZ   sequenceDecs_decode_amd64_adjust_temp_valid
+	MOVQ  $0x00000001, AX
+
+sequenceDecs_decode_amd64_adjust_temp_valid:
+	CMPQ    CX, $0x01
+	CMOVQNE R12, R13
+	MOVQ    R11, R12
+	MOVQ    AX, R11
+	MOVQ    AX, CX
+
+sequenceDecs_decode_amd64_after_adjust:
+	MOVQ CX, 16(R10)
+
+	// Check values
+	MOVQ  8(R10), AX
+	MOVQ  (R10), R14
+	LEAQ  (AX)(R14*1), R15
+	MOVQ  s+0(FP), BP
+	ADDQ  R15, 256(BP)
+	MOVQ  ctx+16(FP), R15
+	SUBQ  R14, 128(R15)
+	JS    error_not_enough_literals
+	CMPQ  AX, $0x00020002
+	JA    sequenceDecs_decode_amd64_error_match_len_too_big
+	TESTQ CX, CX
+	JNZ   sequenceDecs_decode_amd64_match_len_ofs_ok
+	TESTQ AX, AX
+	JNZ   sequenceDecs_decode_amd64_error_match_len_ofs_mismatch
+
+sequenceDecs_decode_amd64_match_len_ofs_ok:
+	ADDQ $0x18, R10
+	MOVQ ctx+16(FP), AX
+	DECQ 96(AX)
+	JNS  sequenceDecs_decode_amd64_main_loop
+	MOVQ s+0(FP), AX
+	MOVQ R11, 144(AX)
+	MOVQ R12, 152(AX)
+	MOVQ R13, 160(AX)
+	MOVQ br+8(FP), AX
+	MOVQ DX, 32(AX)
+	MOVB BL, 40(AX)
+	MOVQ SI, 24(AX)
+
+	// Return success
+	MOVQ $0x00000000, ret+24(FP)
+	RET
+
+	// Return with match length error
+sequenceDecs_decode_amd64_error_match_len_ofs_mismatch:
+	MOVQ $0x00000001, ret+24(FP)
+	RET
+
+	// Return with match too long error
+sequenceDecs_decode_amd64_error_match_len_too_big:
+	MOVQ $0x00000002, ret+24(FP)
+	RET
+
+	// Return with match offset too long error
+	MOVQ $0x00000003, ret+24(FP)
+	RET
+
+	// Return with not enough literals error
+error_not_enough_literals:
+	MOVQ $0x00000004, ret+24(FP)
+	RET
+
+	// Return with overread error
+error_overread:
+	MOVQ $0x00000006, ret+24(FP)
+	RET
+
+// func sequenceDecs_decode_56_amd64(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
+// Requires: CMOV
+TEXT ·sequenceDecs_decode_56_amd64(SB), $8-32
+	MOVQ    br+8(FP), AX
+	MOVQ    32(AX), DX
+	MOVBQZX 40(AX), BX
+	MOVQ    24(AX), SI
+	MOVQ    (AX), AX
+	ADDQ    SI, AX
+	MOVQ    AX, (SP)
+	MOVQ    ctx+16(FP), AX
+	MOVQ    72(AX), DI
+	MOVQ    80(AX), R8
+	MOVQ    88(AX), R9
+	MOVQ    104(AX), R10
+	MOVQ    s+0(FP), AX
+	MOVQ    144(AX), R11
+	MOVQ    152(AX), R12
+	MOVQ    160(AX), R13
+
+sequenceDecs_decode_56_amd64_main_loop:
+	MOVQ (SP), R14
+
+	// Fill bitreader to have enough for the offset and match length.
+	CMPQ SI, $0x08
+	JL   sequenceDecs_decode_56_amd64_fill_byte_by_byte
+	MOVQ BX, AX
+	SHRQ $0x03, AX
+	SUBQ AX, R14
+	MOVQ (R14), DX
+	SUBQ AX, SI
+	ANDQ $0x07, BX
+	JMP  sequenceDecs_decode_56_amd64_fill_end
+
+sequenceDecs_decode_56_amd64_fill_byte_by_byte:
+	CMPQ    SI, $0x00
+	JLE     sequenceDecs_decode_56_amd64_fill_check_overread
+	CMPQ    BX, $0x07
+	JLE     sequenceDecs_decode_56_amd64_fill_end
+	SHLQ    $0x08, DX
+	SUBQ    $0x01, R14
+	SUBQ    $0x01, SI
+	SUBQ    $0x08, BX
+	MOVBQZX (R14), AX
+	ORQ     AX, DX
+	JMP     sequenceDecs_decode_56_amd64_fill_byte_by_byte
+
+sequenceDecs_decode_56_amd64_fill_check_overread:
+	CMPQ BX, $0x40
+	JA   error_overread
+
+sequenceDecs_decode_56_amd64_fill_end:
+	// Update offset
+	MOVQ  R9, AX
+	MOVQ  BX, CX
+	MOVQ  DX, R15
+	SHLQ  CL, R15
+	MOVB  AH, CL
+	SHRQ  $0x20, AX
+	TESTQ CX, CX
+	JZ    sequenceDecs_decode_56_amd64_of_update_zero
+	ADDQ  CX, BX
+	CMPQ  BX, $0x40
+	JA    sequenceDecs_decode_56_amd64_of_update_zero
+	CMPQ  CX, $0x40
+	JAE   sequenceDecs_decode_56_amd64_of_update_zero
+	NEGQ  CX
+	SHRQ  CL, R15
+	ADDQ  R15, AX
+
+sequenceDecs_decode_56_amd64_of_update_zero:
+	MOVQ AX, 16(R10)
+
+	// Update match length
+	MOVQ  R8, AX
+	MOVQ  BX, CX
+	MOVQ  DX, R15
+	SHLQ  CL, R15
+	MOVB  AH, CL
+	SHRQ  $0x20, AX
+	TESTQ CX, CX
+	JZ    sequenceDecs_decode_56_amd64_ml_update_zero
+	ADDQ  CX, BX
+	CMPQ  BX, $0x40
+	JA    sequenceDecs_decode_56_amd64_ml_update_zero
+	CMPQ  CX, $0x40
+	JAE   sequenceDecs_decode_56_amd64_ml_update_zero
+	NEGQ  CX
+	SHRQ  CL, R15
+	ADDQ  R15, AX
+
+sequenceDecs_decode_56_amd64_ml_update_zero:
+	MOVQ AX, 8(R10)
+
+	// Update literal length
+	MOVQ  DI, AX
+	MOVQ  BX, CX
+	MOVQ  DX, R15
+	SHLQ  CL, R15
+	MOVB  AH, CL
+	SHRQ  $0x20, AX
+	TESTQ CX, CX
+	JZ    sequenceDecs_decode_56_amd64_ll_update_zero
+	ADDQ  CX, BX
+	CMPQ  BX, $0x40
+	JA    sequenceDecs_decode_56_amd64_ll_update_zero
+	CMPQ  CX, $0x40
+	JAE   sequenceDecs_decode_56_amd64_ll_update_zero
+	NEGQ  CX
+	SHRQ  CL, R15
+	ADDQ  R15, AX
+
+sequenceDecs_decode_56_amd64_ll_update_zero:
+	MOVQ AX, (R10)
+
+	// Fill bitreader for state updates
+	MOVQ    R14, (SP)
+	MOVQ    R9, AX
+	SHRQ    $0x08, AX
+	MOVBQZX AL, AX
+	MOVQ    ctx+16(FP), CX
+	CMPQ    96(CX), $0x00
+	JZ      sequenceDecs_decode_56_amd64_skip_update
+
+	// Update Literal Length State
+	MOVBQZX DI, R14
+	SHRQ    $0x10, DI
+	MOVWQZX DI, DI
+	LEAQ    (BX)(R14*1), CX
+	MOVQ    DX, R15
+	MOVQ    CX, BX
+	ROLQ    CL, R15
+	MOVL    $0x00000001, BP
+	MOVB    R14, CL
+	SHLL    CL, BP
+	DECL    BP
+	ANDQ    BP, R15
+	ADDQ    R15, DI
+
+	// Load ctx.llTable
+	MOVQ ctx+16(FP), CX
+	MOVQ (CX), CX
+	MOVQ (CX)(DI*8), DI
+
+	// Update Match Length State
+	MOVBQZX R8, R14
+	SHRQ    $0x10, R8
+	MOVWQZX R8, R8
+	LEAQ    (BX)(R14*1), CX
+	MOVQ    DX, R15
+	MOVQ    CX, BX
+	ROLQ    CL, R15
+	MOVL    $0x00000001, BP
+	MOVB    R14, CL
+	SHLL    CL, BP
+	DECL    BP
+	ANDQ    BP, R15
+	ADDQ    R15, R8
+
+	// Load ctx.mlTable
+	MOVQ ctx+16(FP), CX
+	MOVQ 24(CX), CX
+	MOVQ (CX)(R8*8), R8
+
+	// Update Offset State
+	MOVBQZX R9, R14
+	SHRQ    $0x10, R9
+	MOVWQZX R9, R9
+	LEAQ    (BX)(R14*1), CX
+	MOVQ    DX, R15
+	MOVQ    CX, BX
+	ROLQ    CL, R15
+	MOVL    $0x00000001, BP
+	MOVB    R14, CL
+	SHLL    CL, BP
+	DECL    BP
+	ANDQ    BP, R15
+	ADDQ    R15, R9
+
+	// Load ctx.ofTable
+	MOVQ ctx+16(FP), CX
+	MOVQ 48(CX), CX
+	MOVQ (CX)(R9*8), R9
+
+sequenceDecs_decode_56_amd64_skip_update:
+	// Adjust offset
+	MOVQ 16(R10), CX
+	CMPQ AX, $0x01
+	JBE  sequenceDecs_decode_56_amd64_adjust_offsetB_1_or_0
+	MOVQ R12, R13
+	MOVQ R11, R12
+	MOVQ CX, R11
+	JMP  sequenceDecs_decode_56_amd64_after_adjust
+
+sequenceDecs_decode_56_amd64_adjust_offsetB_1_or_0:
+	CMPQ (R10), $0x00000000
+	JNE  sequenceDecs_decode_56_amd64_adjust_offset_maybezero
+	INCQ CX
+	JMP  sequenceDecs_decode_56_amd64_adjust_offset_nonzero
+
+sequenceDecs_decode_56_amd64_adjust_offset_maybezero:
+	TESTQ CX, CX
+	JNZ   sequenceDecs_decode_56_amd64_adjust_offset_nonzero
+	MOVQ  R11, CX
+	JMP   sequenceDecs_decode_56_amd64_after_adjust
+
+sequenceDecs_decode_56_amd64_adjust_offset_nonzero:
+	CMPQ CX, $0x01
+	JB   sequenceDecs_decode_56_amd64_adjust_zero
+	JEQ  sequenceDecs_decode_56_amd64_adjust_one
+	CMPQ CX, $0x02
+	JA   sequenceDecs_decode_56_amd64_adjust_three
+	JMP  sequenceDecs_decode_56_amd64_adjust_two
+
+sequenceDecs_decode_56_amd64_adjust_zero:
+	MOVQ R11, AX
+	JMP  sequenceDecs_decode_56_amd64_adjust_test_temp_valid
+
+sequenceDecs_decode_56_amd64_adjust_one:
+	MOVQ R12, AX
+	JMP  sequenceDecs_decode_56_amd64_adjust_test_temp_valid
+
+sequenceDecs_decode_56_amd64_adjust_two:
+	MOVQ R13, AX
+	JMP  sequenceDecs_decode_56_amd64_adjust_test_temp_valid
+
+sequenceDecs_decode_56_amd64_adjust_three:
+	LEAQ -1(R11), AX
+
+sequenceDecs_decode_56_amd64_adjust_test_temp_valid:
+	TESTQ AX, AX
+	JNZ   sequenceDecs_decode_56_amd64_adjust_temp_valid
+	MOVQ  $0x00000001, AX
+
+sequenceDecs_decode_56_amd64_adjust_temp_valid:
+	CMPQ    CX, $0x01
+	CMOVQNE R12, R13
+	MOVQ    R11, R12
+	MOVQ    AX, R11
+	MOVQ    AX, CX
+
+sequenceDecs_decode_56_amd64_after_adjust:
+	MOVQ CX, 16(R10)
+
+	// Check values
+	MOVQ  8(R10), AX
+	MOVQ  (R10), R14
+	LEAQ  (AX)(R14*1), R15
+	MOVQ  s+0(FP), BP
+	ADDQ  R15, 256(BP)
+	MOVQ  ctx+16(FP), R15
+	SUBQ  R14, 128(R15)
+	JS    error_not_enough_literals
+	CMPQ  AX, $0x00020002
+	JA    sequenceDecs_decode_56_amd64_error_match_len_too_big
+	TESTQ CX, CX
+	JNZ   sequenceDecs_decode_56_amd64_match_len_ofs_ok
+	TESTQ AX, AX
+	JNZ   sequenceDecs_decode_56_amd64_error_match_len_ofs_mismatch
+
+sequenceDecs_decode_56_amd64_match_len_ofs_ok:
+	ADDQ $0x18, R10
+	MOVQ ctx+16(FP), AX
+	DECQ 96(AX)
+	JNS  sequenceDecs_decode_56_amd64_main_loop
+	MOVQ s+0(FP), AX
+	MOVQ R11, 144(AX)
+	MOVQ R12, 152(AX)
+	MOVQ R13, 160(AX)
+	MOVQ br+8(FP), AX
+	MOVQ DX, 32(AX)
+	MOVB BL, 40(AX)
+	MOVQ SI, 24(AX)
+
+	// Return success
+	MOVQ $0x00000000, ret+24(FP)
+	RET
+
+	// Return with match length error
+sequenceDecs_decode_56_amd64_error_match_len_ofs_mismatch:
+	MOVQ $0x00000001, ret+24(FP)
+	RET
+
+	// Return with match too long error
+sequenceDecs_decode_56_amd64_error_match_len_too_big:
+	MOVQ $0x00000002, ret+24(FP)
+	RET
+
+	// Return with match offset too long error
+	MOVQ $0x00000003, ret+24(FP)
+	RET
+
+	// Return with not enough literals error
+error_not_enough_literals:
+	MOVQ $0x00000004, ret+24(FP)
+	RET
+
+	// Return with overread error
+error_overread:
+	MOVQ $0x00000006, ret+24(FP)
+	RET
+
+// func sequenceDecs_decode_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
+// Requires: BMI, BMI2, CMOV
+TEXT ·sequenceDecs_decode_bmi2(SB), $8-32
+	MOVQ    br+8(FP), CX
+	MOVQ    32(CX), AX
+	MOVBQZX 40(CX), DX
+	MOVQ    24(CX), BX
+	MOVQ    (CX), CX
+	ADDQ    BX, CX
+	MOVQ    CX, (SP)
+	MOVQ    ctx+16(FP), CX
+	MOVQ    72(CX), SI
+	MOVQ    80(CX), DI
+	MOVQ    88(CX), R8
+	MOVQ    104(CX), R9
+	MOVQ    s+0(FP), CX
+	MOVQ    144(CX), R10
+	MOVQ    152(CX), R11
+	MOVQ    160(CX), R12
+
+sequenceDecs_decode_bmi2_main_loop:
+	MOVQ (SP), R13
+
+	// Fill bitreader to have enough for the offset and match length.
+	CMPQ BX, $0x08
+	JL   sequenceDecs_decode_bmi2_fill_byte_by_byte
+	MOVQ DX, CX
+	SHRQ $0x03, CX
+	SUBQ CX, R13
+	MOVQ (R13), AX
+	SUBQ CX, BX
+	ANDQ $0x07, DX
+	JMP  sequenceDecs_decode_bmi2_fill_end
+
+sequenceDecs_decode_bmi2_fill_byte_by_byte:
+	CMPQ    BX, $0x00
+	JLE     sequenceDecs_decode_bmi2_fill_check_overread
+	CMPQ    DX, $0x07
+	JLE     sequenceDecs_decode_bmi2_fill_end
+	SHLQ    $0x08, AX
+	SUBQ    $0x01, R13
+	SUBQ    $0x01, BX
+	SUBQ    $0x08, DX
+	MOVBQZX (R13), CX
+	ORQ     CX, AX
+	JMP     sequenceDecs_decode_bmi2_fill_byte_by_byte
+
+sequenceDecs_decode_bmi2_fill_check_overread:
+	CMPQ DX, $0x40
+	JA   error_overread
+
+sequenceDecs_decode_bmi2_fill_end:
+	// Update offset
+	MOVQ   $0x00000808, CX
+	BEXTRQ CX, R8, R14
+	MOVQ   AX, R15
+	LEAQ   (DX)(R14*1), CX
+	ROLQ   CL, R15
+	BZHIQ  R14, R15, R15
+	MOVQ   CX, DX
+	MOVQ   R8, CX
+	SHRQ   $0x20, CX
+	ADDQ   R15, CX
+	MOVQ   CX, 16(R9)
+
+	// Update match length
+	MOVQ   $0x00000808, CX
+	BEXTRQ CX, DI, R14
+	MOVQ   AX, R15
+	LEAQ   (DX)(R14*1), CX
+	ROLQ   CL, R15
+	BZHIQ  R14, R15, R15
+	MOVQ   CX, DX
+	MOVQ   DI, CX
+	SHRQ   $0x20, CX
+	ADDQ   R15, CX
+	MOVQ   CX, 8(R9)
+
+	// Fill bitreader to have enough for the remaining
+	CMPQ BX, $0x08
+	JL   sequenceDecs_decode_bmi2_fill_2_byte_by_byte
+	MOVQ DX, CX
+	SHRQ $0x03, CX
+	SUBQ CX, R13
+	MOVQ (R13), AX
+	SUBQ CX, BX
+	ANDQ $0x07, DX
+	JMP  sequenceDecs_decode_bmi2_fill_2_end
+
+sequenceDecs_decode_bmi2_fill_2_byte_by_byte:
+	CMPQ    BX, $0x00
+	JLE     sequenceDecs_decode_bmi2_fill_2_check_overread
+	CMPQ    DX, $0x07
+	JLE     sequenceDecs_decode_bmi2_fill_2_end
+	SHLQ    $0x08, AX
+	SUBQ    $0x01, R13
+	SUBQ    $0x01, BX
+	SUBQ    $0x08, DX
+	MOVBQZX (R13), CX
+	ORQ     CX, AX
+	JMP     sequenceDecs_decode_bmi2_fill_2_byte_by_byte
+
+sequenceDecs_decode_bmi2_fill_2_check_overread:
+	CMPQ DX, $0x40
+	JA   error_overread
+
+sequenceDecs_decode_bmi2_fill_2_end:
+	// Update literal length
+	MOVQ   $0x00000808, CX
+	BEXTRQ CX, SI, R14
+	MOVQ   AX, R15
+	LEAQ   (DX)(R14*1), CX
+	ROLQ   CL, R15
+	BZHIQ  R14, R15, R15
+	MOVQ   CX, DX
+	MOVQ   SI, CX
+	SHRQ   $0x20, CX
+	ADDQ   R15, CX
+	MOVQ   CX, (R9)
+
+	// Fill bitreader for state updates
+	MOVQ    R13, (SP)
+	MOVQ    $0x00000808, CX
+	BEXTRQ  CX, R8, R13
+	MOVQ    ctx+16(FP), CX
+	CMPQ    96(CX), $0x00
+	JZ      sequenceDecs_decode_bmi2_skip_update
+	LEAQ    (SI)(DI*1), R14
+	ADDQ    R8, R14
+	MOVBQZX R14, R14
+	LEAQ    (DX)(R14*1), CX
+	MOVQ    AX, R15
+	MOVQ    CX, DX
+	ROLQ    CL, R15
+	BZHIQ   R14, R15, R15
+
+	// Update Offset State
+	BZHIQ  R8, R15, CX
+	SHRXQ  R8, R15, R15
+	MOVQ   $0x00001010, R14
+	BEXTRQ R14, R8, R8
+	ADDQ   CX, R8
+
+	// Load ctx.ofTable
+	MOVQ ctx+16(FP), CX
+	MOVQ 48(CX), CX
+	MOVQ (CX)(R8*8), R8
+
+	// Update Match Length State
+	BZHIQ  DI, R15, CX
+	SHRXQ  DI, R15, R15
+	MOVQ   $0x00001010, R14
+	BEXTRQ R14, DI, DI
+	ADDQ   CX, DI
+
+	// Load ctx.mlTable
+	MOVQ ctx+16(FP), CX
+	MOVQ 24(CX), CX
+	MOVQ (CX)(DI*8), DI
+
+	// Update Literal Length State
+	BZHIQ  SI, R15, CX
+	MOVQ   $0x00001010, R14
+	BEXTRQ R14, SI, SI
+	ADDQ   CX, SI
+
+	// Load ctx.llTable
+	MOVQ ctx+16(FP), CX
+	MOVQ (CX), CX
+	MOVQ (CX)(SI*8), SI
+
+sequenceDecs_decode_bmi2_skip_update:
+	// Adjust offset
+	MOVQ 16(R9), CX
+	CMPQ R13, $0x01
+	JBE  sequenceDecs_decode_bmi2_adjust_offsetB_1_or_0
+	MOVQ R11, R12
+	MOVQ R10, R11
+	MOVQ CX, R10
+	JMP  sequenceDecs_decode_bmi2_after_adjust
+
+sequenceDecs_decode_bmi2_adjust_offsetB_1_or_0:
+	CMPQ (R9), $0x00000000
+	JNE  sequenceDecs_decode_bmi2_adjust_offset_maybezero
+	INCQ CX
+	JMP  sequenceDecs_decode_bmi2_adjust_offset_nonzero
+
+sequenceDecs_decode_bmi2_adjust_offset_maybezero:
+	TESTQ CX, CX
+	JNZ   sequenceDecs_decode_bmi2_adjust_offset_nonzero
+	MOVQ  R10, CX
+	JMP   sequenceDecs_decode_bmi2_after_adjust
+
+sequenceDecs_decode_bmi2_adjust_offset_nonzero:
+	CMPQ CX, $0x01
+	JB   sequenceDecs_decode_bmi2_adjust_zero
+	JEQ  sequenceDecs_decode_bmi2_adjust_one
+	CMPQ CX, $0x02
+	JA   sequenceDecs_decode_bmi2_adjust_three
+	JMP  sequenceDecs_decode_bmi2_adjust_two
+
+sequenceDecs_decode_bmi2_adjust_zero:
+	MOVQ R10, R13
+	JMP  sequenceDecs_decode_bmi2_adjust_test_temp_valid
+
+sequenceDecs_decode_bmi2_adjust_one:
+	MOVQ R11, R13
+	JMP  sequenceDecs_decode_bmi2_adjust_test_temp_valid
+
+sequenceDecs_decode_bmi2_adjust_two:
+	MOVQ R12, R13
+	JMP  sequenceDecs_decode_bmi2_adjust_test_temp_valid
+
+sequenceDecs_decode_bmi2_adjust_three:
+	LEAQ -1(R10), R13
+
+sequenceDecs_decode_bmi2_adjust_test_temp_valid:
+	TESTQ R13, R13
+	JNZ   sequenceDecs_decode_bmi2_adjust_temp_valid
+	MOVQ  $0x00000001, R13
+
+sequenceDecs_decode_bmi2_adjust_temp_valid:
+	CMPQ    CX, $0x01
+	CMOVQNE R11, R12
+	MOVQ    R10, R11
+	MOVQ    R13, R10
+	MOVQ    R13, CX
+
+sequenceDecs_decode_bmi2_after_adjust:
+	MOVQ CX, 16(R9)
+
+	// Check values
+	MOVQ  8(R9), R13
+	MOVQ  (R9), R14
+	LEAQ  (R13)(R14*1), R15
+	MOVQ  s+0(FP), BP
+	ADDQ  R15, 256(BP)
+	MOVQ  ctx+16(FP), R15
+	SUBQ  R14, 128(R15)
+	JS    error_not_enough_literals
+	CMPQ  R13, $0x00020002
+	JA    sequenceDecs_decode_bmi2_error_match_len_too_big
+	TESTQ CX, CX
+	JNZ   sequenceDecs_decode_bmi2_match_len_ofs_ok
+	TESTQ R13, R13
+	JNZ   sequenceDecs_decode_bmi2_error_match_len_ofs_mismatch
+
+sequenceDecs_decode_bmi2_match_len_ofs_ok:
+	ADDQ $0x18, R9
+	MOVQ ctx+16(FP), CX
+	DECQ 96(CX)
+	JNS  sequenceDecs_decode_bmi2_main_loop
+	MOVQ s+0(FP), CX
+	MOVQ R10, 144(CX)
+	MOVQ R11, 152(CX)
+	MOVQ R12, 160(CX)
+	MOVQ br+8(FP), CX
+	MOVQ AX, 32(CX)
+	MOVB DL, 40(CX)
+	MOVQ BX, 24(CX)
+
+	// Return success
+	MOVQ $0x00000000, ret+24(FP)
+	RET
+
+	// Return with match length error
+sequenceDecs_decode_bmi2_error_match_len_ofs_mismatch:
+	MOVQ $0x00000001, ret+24(FP)
+	RET
+
+	// Return with match too long error
+sequenceDecs_decode_bmi2_error_match_len_too_big:
+	MOVQ $0x00000002, ret+24(FP)
+	RET
+
+	// Return with match offset too long error
+	MOVQ $0x00000003, ret+24(FP)
+	RET
+
+	// Return with not enough literals error
+error_not_enough_literals:
+	MOVQ $0x00000004, ret+24(FP)
+	RET
+
+	// Return with overread error
+error_overread:
+	MOVQ $0x00000006, ret+24(FP)
+	RET
+
+// func sequenceDecs_decode_56_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
+// Requires: BMI, BMI2, CMOV
+TEXT ·sequenceDecs_decode_56_bmi2(SB), $8-32
+	MOVQ    br+8(FP), CX
+	MOVQ    32(CX), AX
+	MOVBQZX 40(CX), DX
+	MOVQ    24(CX), BX
+	MOVQ    (CX), CX
+	ADDQ    BX, CX
+	MOVQ    CX, (SP)
+	MOVQ    ctx+16(FP), CX
+	MOVQ    72(CX), SI
+	MOVQ    80(CX), DI
+	MOVQ    88(CX), R8
+	MOVQ    104(CX), R9
+	MOVQ    s+0(FP), CX
+	MOVQ    144(CX), R10
+	MOVQ    152(CX), R11
+	MOVQ    160(CX), R12
+
+sequenceDecs_decode_56_bmi2_main_loop:
+	MOVQ (SP), R13
+
+	// Fill bitreader to have enough for the offset and match length.
+	CMPQ BX, $0x08
+	JL   sequenceDecs_decode_56_bmi2_fill_byte_by_byte
+	MOVQ DX, CX
+	SHRQ $0x03, CX
+	SUBQ CX, R13
+	MOVQ (R13), AX
+	SUBQ CX, BX
+	ANDQ $0x07, DX
+	JMP  sequenceDecs_decode_56_bmi2_fill_end
+
+sequenceDecs_decode_56_bmi2_fill_byte_by_byte:
+	CMPQ    BX, $0x00
+	JLE     sequenceDecs_decode_56_bmi2_fill_check_overread
+	CMPQ    DX, $0x07
+	JLE     sequenceDecs_decode_56_bmi2_fill_end
+	SHLQ    $0x08, AX
+	SUBQ    $0x01, R13
+	SUBQ    $0x01, BX
+	SUBQ    $0x08, DX
+	MOVBQZX (R13), CX
+	ORQ     CX, AX
+	JMP     sequenceDecs_decode_56_bmi2_fill_byte_by_byte
+
+sequenceDecs_decode_56_bmi2_fill_check_overread:
+	CMPQ DX, $0x40
+	JA   error_overread
+
+sequenceDecs_decode_56_bmi2_fill_end:
+	// Update offset
+	MOVQ   $0x00000808, CX
+	BEXTRQ CX, R8, R14
+	MOVQ   AX, R15
+	LEAQ   (DX)(R14*1), CX
+	ROLQ   CL, R15
+	BZHIQ  R14, R15, R15
+	MOVQ   CX, DX
+	MOVQ   R8, CX
+	SHRQ   $0x20, CX
+	ADDQ   R15, CX
+	MOVQ   CX, 16(R9)
+
+	// Update match length
+	MOVQ   $0x00000808, CX
+	BEXTRQ CX, DI, R14
+	MOVQ   AX, R15
+	LEAQ   (DX)(R14*1), CX
+	ROLQ   CL, R15
+	BZHIQ  R14, R15, R15
+	MOVQ   CX, DX
+	MOVQ   DI, CX
+	SHRQ   $0x20, CX
+	ADDQ   R15, CX
+	MOVQ   CX, 8(R9)
+
+	// Update literal length
+	MOVQ   $0x00000808, CX
+	BEXTRQ CX, SI, R14
+	MOVQ   AX, R15
+	LEAQ   (DX)(R14*1), CX
+	ROLQ   CL, R15
+	BZHIQ  R14, R15, R15
+	MOVQ   CX, DX
+	MOVQ   SI, CX
+	SHRQ   $0x20, CX
+	ADDQ   R15, CX
+	MOVQ   CX, (R9)
+
+	// Fill bitreader for state updates
+	MOVQ    R13, (SP)
+	MOVQ    $0x00000808, CX
+	BEXTRQ  CX, R8, R13
+	MOVQ    ctx+16(FP), CX
+	CMPQ    96(CX), $0x00
+	JZ      sequenceDecs_decode_56_bmi2_skip_update
+	LEAQ    (SI)(DI*1), R14
+	ADDQ    R8, R14
+	MOVBQZX R14, R14
+	LEAQ    (DX)(R14*1), CX
+	MOVQ    AX, R15
+	MOVQ    CX, DX
+	ROLQ    CL, R15
+	BZHIQ   R14, R15, R15
+
+	// Update Offset State
+	BZHIQ  R8, R15, CX
+	SHRXQ  R8, R15, R15
+	MOVQ   $0x00001010, R14
+	BEXTRQ R14, R8, R8
+	ADDQ   CX, R8
+
+	// Load ctx.ofTable
+	MOVQ ctx+16(FP), CX
+	MOVQ 48(CX), CX
+	MOVQ (CX)(R8*8), R8
+
+	// Update Match Length State
+	BZHIQ  DI, R15, CX
+	SHRXQ  DI, R15, R15
+	MOVQ   $0x00001010, R14
+	BEXTRQ R14, DI, DI
+	ADDQ   CX, DI
+
+	// Load ctx.mlTable
+	MOVQ ctx+16(FP), CX
+	MOVQ 24(CX), CX
+	MOVQ (CX)(DI*8), DI
+
+	// Update Literal Length State
+	BZHIQ  SI, R15, CX
+	MOVQ   $0x00001010, R14
+	BEXTRQ R14, SI, SI
+	ADDQ   CX, SI
+
+	// Load ctx.llTable
+	MOVQ ctx+16(FP), CX
+	MOVQ (CX), CX
+	MOVQ (CX)(SI*8), SI
+
+sequenceDecs_decode_56_bmi2_skip_update:
+	// Adjust offset
+	MOVQ 16(R9), CX
+	CMPQ R13, $0x01
+	JBE  sequenceDecs_decode_56_bmi2_adjust_offsetB_1_or_0
+	MOVQ R11, R12
+	MOVQ R10, R11
+	MOVQ CX, R10
+	JMP  sequenceDecs_decode_56_bmi2_after_adjust
+
+sequenceDecs_decode_56_bmi2_adjust_offsetB_1_or_0:
+	CMPQ (R9), $0x00000000
+	JNE  sequenceDecs_decode_56_bmi2_adjust_offset_maybezero
+	INCQ CX
+	JMP  sequenceDecs_decode_56_bmi2_adjust_offset_nonzero
+
+sequenceDecs_decode_56_bmi2_adjust_offset_maybezero:
+	TESTQ CX, CX
+	JNZ   sequenceDecs_decode_56_bmi2_adjust_offset_nonzero
+	MOVQ  R10, CX
+	JMP   sequenceDecs_decode_56_bmi2_after_adjust
+
+sequenceDecs_decode_56_bmi2_adjust_offset_nonzero:
+	CMPQ CX, $0x01
+	JB   sequenceDecs_decode_56_bmi2_adjust_zero
+	JEQ  sequenceDecs_decode_56_bmi2_adjust_one
+	CMPQ CX, $0x02
+	JA   sequenceDecs_decode_56_bmi2_adjust_three
+	JMP  sequenceDecs_decode_56_bmi2_adjust_two
+
+sequenceDecs_decode_56_bmi2_adjust_zero:
+	MOVQ R10, R13
+	JMP  sequenceDecs_decode_56_bmi2_adjust_test_temp_valid
+
+sequenceDecs_decode_56_bmi2_adjust_one:
+	MOVQ R11, R13
+	JMP  sequenceDecs_decode_56_bmi2_adjust_test_temp_valid
+
+sequenceDecs_decode_56_bmi2_adjust_two:
+	MOVQ R12, R13
+	JMP  sequenceDecs_decode_56_bmi2_adjust_test_temp_valid
+
+sequenceDecs_decode_56_bmi2_adjust_three:
+	LEAQ -1(R10), R13
+
+sequenceDecs_decode_56_bmi2_adjust_test_temp_valid:
+	TESTQ R13, R13
+	JNZ   sequenceDecs_decode_56_bmi2_adjust_temp_valid
+	MOVQ  $0x00000001, R13
+
+sequenceDecs_decode_56_bmi2_adjust_temp_valid:
+	CMPQ    CX, $0x01
+	CMOVQNE R11, R12
+	MOVQ    R10, R11
+	MOVQ    R13, R10
+	MOVQ    R13, CX
+
+sequenceDecs_decode_56_bmi2_after_adjust:
+	MOVQ CX, 16(R9)
+
+	// Check values
+	MOVQ  8(R9), R13
+	MOVQ  (R9), R14
+	LEAQ  (R13)(R14*1), R15
+	MOVQ  s+0(FP), BP
+	ADDQ  R15, 256(BP)
+	MOVQ  ctx+16(FP), R15
+	SUBQ  R14, 128(R15)
+	JS    error_not_enough_literals
+	CMPQ  R13, $0x00020002
+	JA    sequenceDecs_decode_56_bmi2_error_match_len_too_big
+	TESTQ CX, CX
+	JNZ   sequenceDecs_decode_56_bmi2_match_len_ofs_ok
+	TESTQ R13, R13
+	JNZ   sequenceDecs_decode_56_bmi2_error_match_len_ofs_mismatch
+
+sequenceDecs_decode_56_bmi2_match_len_ofs_ok:
+	ADDQ $0x18, R9
+	MOVQ ctx+16(FP), CX
+	DECQ 96(CX)
+	JNS  sequenceDecs_decode_56_bmi2_main_loop
+	MOVQ s+0(FP), CX
+	MOVQ R10, 144(CX)
+	MOVQ R11, 152(CX)
+	MOVQ R12, 160(CX)
+	MOVQ br+8(FP), CX
+	MOVQ AX, 32(CX)
+	MOVB DL, 40(CX)
+	MOVQ BX, 24(CX)
+
+	// Return success
+	MOVQ $0x00000000, ret+24(FP)
+	RET
+
+	// Return with match length error
+sequenceDecs_decode_56_bmi2_error_match_len_ofs_mismatch:
+	MOVQ $0x00000001, ret+24(FP)
+	RET
+
+	// Return with match too long error
+sequenceDecs_decode_56_bmi2_error_match_len_too_big:
+	MOVQ $0x00000002, ret+24(FP)
+	RET
+
+	// Return with match offset too long error
+	MOVQ $0x00000003, ret+24(FP)
+	RET
+
+	// Return with not enough literals error
+error_not_enough_literals:
+	MOVQ $0x00000004, ret+24(FP)
+	RET
+
+	// Return with overread error
+error_overread:
+	MOVQ $0x00000006, ret+24(FP)
+	RET
+
+// func sequenceDecs_executeSimple_amd64(ctx *executeAsmContext) bool
+// Requires: SSE
+TEXT ·sequenceDecs_executeSimple_amd64(SB), $8-9
+	MOVQ  ctx+0(FP), R10
+	MOVQ  8(R10), CX
+	TESTQ CX, CX
+	JZ    empty_seqs
+	MOVQ  (R10), AX
+	MOVQ  24(R10), DX
+	MOVQ  32(R10), BX
+	MOVQ  80(R10), SI
+	MOVQ  104(R10), DI
+	MOVQ  120(R10), R8
+	MOVQ  56(R10), R9
+	MOVQ  64(R10), R10
+	ADDQ  R10, R9
+
+	// seqsBase += 24 * seqIndex
+	LEAQ (DX)(DX*2), R11
+	SHLQ $0x03, R11
+	ADDQ R11, AX
+
+	// outBase += outPosition
+	ADDQ DI, BX
+
+main_loop:
+	MOVQ (AX), R11
+	MOVQ 16(AX), R12
+	MOVQ 8(AX), R13
+
+	// Copy literals
+	TESTQ R11, R11
+	JZ    check_offset
+	XORQ  R14, R14
+
+copy_1:
+	MOVUPS (SI)(R14*1), X0
+	MOVUPS X0, (BX)(R14*1)
+	ADDQ   $0x10, R14
+	CMPQ   R14, R11
+	JB     copy_1
+	ADDQ   R11, SI
+	ADDQ   R11, BX
+	ADDQ   R11, DI
+
+	// Malformed input if seq.mo > t+len(hist) || seq.mo > s.windowSize)
+check_offset:
+	LEAQ (DI)(R10*1), R11
+	CMPQ R12, R11
+	JG   error_match_off_too_big
+	CMPQ R12, R8
+	JG   error_match_off_too_big
+
+	// Copy match from history
+	MOVQ R12, R11
+	SUBQ DI, R11
+	JLS  copy_match
+	MOVQ R9, R14
+	SUBQ R11, R14
+	CMPQ R13, R11
+	JG   copy_all_from_history
+	MOVQ R13, R11
+	SUBQ $0x10, R11
+	JB   copy_4_small
+
+copy_4_loop:
+	MOVUPS (R14), X0
+	MOVUPS X0, (BX)
+	ADDQ   $0x10, R14
+	ADDQ   $0x10, BX
+	SUBQ   $0x10, R11
+	JAE    copy_4_loop
+	LEAQ   16(R14)(R11*1), R14
+	LEAQ   16(BX)(R11*1), BX
+	MOVUPS -16(R14), X0
+	MOVUPS X0, -16(BX)
+	JMP    copy_4_end
+
+copy_4_small:
+	CMPQ R13, $0x03
+	JE   copy_4_move_3
+	CMPQ R13, $0x08
+	JB   copy_4_move_4through7
+	JMP  copy_4_move_8through16
+
+copy_4_move_3:
+	MOVW (R14), R11
+	MOVB 2(R14), R12
+	MOVW R11, (BX)
+	MOVB R12, 2(BX)
+	ADDQ R13, R14
+	ADDQ R13, BX
+	JMP  copy_4_end
+
+copy_4_move_4through7:
+	MOVL (R14), R11
+	MOVL -4(R14)(R13*1), R12
+	MOVL R11, (BX)
+	MOVL R12, -4(BX)(R13*1)
+	ADDQ R13, R14
+	ADDQ R13, BX
+	JMP  copy_4_end
+
+copy_4_move_8through16:
+	MOVQ (R14), R11
+	MOVQ -8(R14)(R13*1), R12
+	MOVQ R11, (BX)
+	MOVQ R12, -8(BX)(R13*1)
+	ADDQ R13, R14
+	ADDQ R13, BX
+
+copy_4_end:
+	ADDQ R13, DI
+	ADDQ $0x18, AX
+	INCQ DX
+	CMPQ DX, CX
+	JB   main_loop
+	JMP  loop_finished
+
+copy_all_from_history:
+	MOVQ R11, R15
+	SUBQ $0x10, R15
+	JB   copy_5_small
+
+copy_5_loop:
+	MOVUPS (R14), X0
+	MOVUPS X0, (BX)
+	ADDQ   $0x10, R14
+	ADDQ   $0x10, BX
+	SUBQ   $0x10, R15
+	JAE    copy_5_loop
+	LEAQ   16(R14)(R15*1), R14
+	LEAQ   16(BX)(R15*1), BX
+	MOVUPS -16(R14), X0
+	MOVUPS X0, -16(BX)
+	JMP    copy_5_end
+
+copy_5_small:
+	CMPQ R11, $0x03
+	JE   copy_5_move_3
+	JB   copy_5_move_1or2
+	CMPQ R11, $0x08
+	JB   copy_5_move_4through7
+	JMP  copy_5_move_8through16
+
+copy_5_move_1or2:
+	MOVB (R14), R15
+	MOVB -1(R14)(R11*1), BP
+	MOVB R15, (BX)
+	MOVB BP, -1(BX)(R11*1)
+	ADDQ R11, R14
+	ADDQ R11, BX
+	JMP  copy_5_end
+
+copy_5_move_3:
+	MOVW (R14), R15
+	MOVB 2(R14), BP
+	MOVW R15, (BX)
+	MOVB BP, 2(BX)
+	ADDQ R11, R14
+	ADDQ R11, BX
+	JMP  copy_5_end
+
+copy_5_move_4through7:
+	MOVL (R14), R15
+	MOVL -4(R14)(R11*1), BP
+	MOVL R15, (BX)
+	MOVL BP, -4(BX)(R11*1)
+	ADDQ R11, R14
+	ADDQ R11, BX
+	JMP  copy_5_end
+
+copy_5_move_8through16:
+	MOVQ (R14), R15
+	MOVQ -8(R14)(R11*1), BP
+	MOVQ R15, (BX)
+	MOVQ BP, -8(BX)(R11*1)
+	ADDQ R11, R14
+	ADDQ R11, BX
+
+copy_5_end:
+	ADDQ R11, DI
+	SUBQ R11, R13
+
+	// Copy match from the current buffer
+copy_match:
+	MOVQ BX, R11
+	SUBQ R12, R11
+
+	// ml <= mo
+	CMPQ R13, R12
+	JA   copy_overlapping_match
+
+	// Copy non-overlapping match
+	ADDQ R13, DI
+	MOVQ BX, R12
+	ADDQ R13, BX
+
+copy_2:
+	MOVUPS (R11), X0
+	MOVUPS X0, (R12)
+	ADDQ   $0x10, R11
+	ADDQ   $0x10, R12
+	SUBQ   $0x10, R13
+	JHI    copy_2
+	JMP    handle_loop
+
+	// Copy overlapping match
+copy_overlapping_match:
+	ADDQ R13, DI
+
+copy_slow_3:
+	MOVB (R11), R12
+	MOVB R12, (BX)
+	INCQ R11
+	INCQ BX
+	DECQ R13
+	JNZ  copy_slow_3
+
+handle_loop:
+	ADDQ $0x18, AX
+	INCQ DX
+	CMPQ DX, CX
+	JB   main_loop
+
+loop_finished:
+	// Return value
+	MOVB $0x01, ret+8(FP)
+
+	// Update the context
+	MOVQ ctx+0(FP), AX
+	MOVQ DX, 24(AX)
+	MOVQ DI, 104(AX)
+	SUBQ 80(AX), SI
+	MOVQ SI, 112(AX)
+	RET
+
+error_match_off_too_big:
+	// Return value
+	MOVB $0x00, ret+8(FP)
+
+	// Update the context
+	MOVQ ctx+0(FP), AX
+	MOVQ DX, 24(AX)
+	MOVQ DI, 104(AX)
+	SUBQ 80(AX), SI
+	MOVQ SI, 112(AX)
+	RET
+
+empty_seqs:
+	// Return value
+	MOVB $0x01, ret+8(FP)
+	RET
+
+// func sequenceDecs_executeSimple_safe_amd64(ctx *executeAsmContext) bool
+// Requires: SSE
+TEXT ·sequenceDecs_executeSimple_safe_amd64(SB), $8-9
+	MOVQ  ctx+0(FP), R10
+	MOVQ  8(R10), CX
+	TESTQ CX, CX
+	JZ    empty_seqs
+	MOVQ  (R10), AX
+	MOVQ  24(R10), DX
+	MOVQ  32(R10), BX
+	MOVQ  80(R10), SI
+	MOVQ  104(R10), DI
+	MOVQ  120(R10), R8
+	MOVQ  56(R10), R9
+	MOVQ  64(R10), R10
+	ADDQ  R10, R9
+
+	// seqsBase += 24 * seqIndex
+	LEAQ (DX)(DX*2), R11
+	SHLQ $0x03, R11
+	ADDQ R11, AX
+
+	// outBase += outPosition
+	ADDQ DI, BX
+
+main_loop:
+	MOVQ (AX), R11
+	MOVQ 16(AX), R12
+	MOVQ 8(AX), R13
+
+	// Copy literals
+	TESTQ R11, R11
+	JZ    check_offset
+	MOVQ  R11, R14
+	SUBQ  $0x10, R14
+	JB    copy_1_small
+
+copy_1_loop:
+	MOVUPS (SI), X0
+	MOVUPS X0, (BX)
+	ADDQ   $0x10, SI
+	ADDQ   $0x10, BX
+	SUBQ   $0x10, R14
+	JAE    copy_1_loop
+	LEAQ   16(SI)(R14*1), SI
+	LEAQ   16(BX)(R14*1), BX
+	MOVUPS -16(SI), X0
+	MOVUPS X0, -16(BX)
+	JMP    copy_1_end
+
+copy_1_small:
+	CMPQ R11, $0x03
+	JE   copy_1_move_3
+	JB   copy_1_move_1or2
+	CMPQ R11, $0x08
+	JB   copy_1_move_4through7
+	JMP  copy_1_move_8through16
+
+copy_1_move_1or2:
+	MOVB (SI), R14
+	MOVB -1(SI)(R11*1), R15
+	MOVB R14, (BX)
+	MOVB R15, -1(BX)(R11*1)
+	ADDQ R11, SI
+	ADDQ R11, BX
+	JMP  copy_1_end
+
+copy_1_move_3:
+	MOVW (SI), R14
+	MOVB 2(SI), R15
+	MOVW R14, (BX)
+	MOVB R15, 2(BX)
+	ADDQ R11, SI
+	ADDQ R11, BX
+	JMP  copy_1_end
+
+copy_1_move_4through7:
+	MOVL (SI), R14
+	MOVL -4(SI)(R11*1), R15
+	MOVL R14, (BX)
+	MOVL R15, -4(BX)(R11*1)
+	ADDQ R11, SI
+	ADDQ R11, BX
+	JMP  copy_1_end
+
+copy_1_move_8through16:
+	MOVQ (SI), R14
+	MOVQ -8(SI)(R11*1), R15
+	MOVQ R14, (BX)
+	MOVQ R15, -8(BX)(R11*1)
+	ADDQ R11, SI
+	ADDQ R11, BX
+
+copy_1_end:
+	ADDQ R11, DI
+
+	// Malformed input if seq.mo > t+len(hist) || seq.mo > s.windowSize)
+check_offset:
+	LEAQ (DI)(R10*1), R11
+	CMPQ R12, R11
+	JG   error_match_off_too_big
+	CMPQ R12, R8
+	JG   error_match_off_too_big
+
+	// Copy match from history
+	MOVQ R12, R11
+	SUBQ DI, R11
+	JLS  copy_match
+	MOVQ R9, R14
+	SUBQ R11, R14
+	CMPQ R13, R11
+	JG   copy_all_from_history
+	MOVQ R13, R11
+	SUBQ $0x10, R11
+	JB   copy_4_small
+
+copy_4_loop:
+	MOVUPS (R14), X0
+	MOVUPS X0, (BX)
+	ADDQ   $0x10, R14
+	ADDQ   $0x10, BX
+	SUBQ   $0x10, R11
+	JAE    copy_4_loop
+	LEAQ   16(R14)(R11*1), R14
+	LEAQ   16(BX)(R11*1), BX
+	MOVUPS -16(R14), X0
+	MOVUPS X0, -16(BX)
+	JMP    copy_4_end
+
+copy_4_small:
+	CMPQ R13, $0x03
+	JE   copy_4_move_3
+	CMPQ R13, $0x08
+	JB   copy_4_move_4through7
+	JMP  copy_4_move_8through16
+
+copy_4_move_3:
+	MOVW (R14), R11
+	MOVB 2(R14), R12
+	MOVW R11, (BX)
+	MOVB R12, 2(BX)
+	ADDQ R13, R14
+	ADDQ R13, BX
+	JMP  copy_4_end
+
+copy_4_move_4through7:
+	MOVL (R14), R11
+	MOVL -4(R14)(R13*1), R12
+	MOVL R11, (BX)
+	MOVL R12, -4(BX)(R13*1)
+	ADDQ R13, R14
+	ADDQ R13, BX
+	JMP  copy_4_end
+
+copy_4_move_8through16:
+	MOVQ (R14), R11
+	MOVQ -8(R14)(R13*1), R12
+	MOVQ R11, (BX)
+	MOVQ R12, -8(BX)(R13*1)
+	ADDQ R13, R14
+	ADDQ R13, BX
+
+copy_4_end:
+	ADDQ R13, DI
+	ADDQ $0x18, AX
+	INCQ DX
+	CMPQ DX, CX
+	JB   main_loop
+	JMP  loop_finished
+
+copy_all_from_history:
+	MOVQ R11, R15
+	SUBQ $0x10, R15
+	JB   copy_5_small
+
+copy_5_loop:
+	MOVUPS (R14), X0
+	MOVUPS X0, (BX)
+	ADDQ   $0x10, R14
+	ADDQ   $0x10, BX
+	SUBQ   $0x10, R15
+	JAE    copy_5_loop
+	LEAQ   16(R14)(R15*1), R14
+	LEAQ   16(BX)(R15*1), BX
+	MOVUPS -16(R14), X0
+	MOVUPS X0, -16(BX)
+	JMP    copy_5_end
+
+copy_5_small:
+	CMPQ R11, $0x03
+	JE   copy_5_move_3
+	JB   copy_5_move_1or2
+	CMPQ R11, $0x08
+	JB   copy_5_move_4through7
+	JMP  copy_5_move_8through16
+
+copy_5_move_1or2:
+	MOVB (R14), R15
+	MOVB -1(R14)(R11*1), BP
+	MOVB R15, (BX)
+	MOVB BP, -1(BX)(R11*1)
+	ADDQ R11, R14
+	ADDQ R11, BX
+	JMP  copy_5_end
+
+copy_5_move_3:
+	MOVW (R14), R15
+	MOVB 2(R14), BP
+	MOVW R15, (BX)
+	MOVB BP, 2(BX)
+	ADDQ R11, R14
+	ADDQ R11, BX
+	JMP  copy_5_end
+
+copy_5_move_4through7:
+	MOVL (R14), R15
+	MOVL -4(R14)(R11*1), BP
+	MOVL R15, (BX)
+	MOVL BP, -4(BX)(R11*1)
+	ADDQ R11, R14
+	ADDQ R11, BX
+	JMP  copy_5_end
+
+copy_5_move_8through16:
+	MOVQ (R14), R15
+	MOVQ -8(R14)(R11*1), BP
+	MOVQ R15, (BX)
+	MOVQ BP, -8(BX)(R11*1)
+	ADDQ R11, R14
+	ADDQ R11, BX
+
+copy_5_end:
+	ADDQ R11, DI
+	SUBQ R11, R13
+
+	// Copy match from the current buffer
+copy_match:
+	MOVQ BX, R11
+	SUBQ R12, R11
+
+	// ml <= mo
+	CMPQ R13, R12
+	JA   copy_overlapping_match
+
+	// Copy non-overlapping match
+	ADDQ R13, DI
+	MOVQ R13, R12
+	SUBQ $0x10, R12
+	JB   copy_2_small
+
+copy_2_loop:
+	MOVUPS (R11), X0
+	MOVUPS X0, (BX)
+	ADDQ   $0x10, R11
+	ADDQ   $0x10, BX
+	SUBQ   $0x10, R12
+	JAE    copy_2_loop
+	LEAQ   16(R11)(R12*1), R11
+	LEAQ   16(BX)(R12*1), BX
+	MOVUPS -16(R11), X0
+	MOVUPS X0, -16(BX)
+	JMP    copy_2_end
+
+copy_2_small:
+	CMPQ R13, $0x03
+	JE   copy_2_move_3
+	JB   copy_2_move_1or2
+	CMPQ R13, $0x08
+	JB   copy_2_move_4through7
+	JMP  copy_2_move_8through16
+
+copy_2_move_1or2:
+	MOVB (R11), R12
+	MOVB -1(R11)(R13*1), R14
+	MOVB R12, (BX)
+	MOVB R14, -1(BX)(R13*1)
+	ADDQ R13, R11
+	ADDQ R13, BX
+	JMP  copy_2_end
+
+copy_2_move_3:
+	MOVW (R11), R12
+	MOVB 2(R11), R14
+	MOVW R12, (BX)
+	MOVB R14, 2(BX)
+	ADDQ R13, R11
+	ADDQ R13, BX
+	JMP  copy_2_end
+
+copy_2_move_4through7:
+	MOVL (R11), R12
+	MOVL -4(R11)(R13*1), R14
+	MOVL R12, (BX)
+	MOVL R14, -4(BX)(R13*1)
+	ADDQ R13, R11
+	ADDQ R13, BX
+	JMP  copy_2_end
+
+copy_2_move_8through16:
+	MOVQ (R11), R12
+	MOVQ -8(R11)(R13*1), R14
+	MOVQ R12, (BX)
+	MOVQ R14, -8(BX)(R13*1)
+	ADDQ R13, R11
+	ADDQ R13, BX
+
+copy_2_end:
+	JMP handle_loop
+
+	// Copy overlapping match
+copy_overlapping_match:
+	ADDQ R13, DI
+
+copy_slow_3:
+	MOVB (R11), R12
+	MOVB R12, (BX)
+	INCQ R11
+	INCQ BX
+	DECQ R13
+	JNZ  copy_slow_3
+
+handle_loop:
+	ADDQ $0x18, AX
+	INCQ DX
+	CMPQ DX, CX
+	JB   main_loop
+
+loop_finished:
+	// Return value
+	MOVB $0x01, ret+8(FP)
+
+	// Update the context
+	MOVQ ctx+0(FP), AX
+	MOVQ DX, 24(AX)
+	MOVQ DI, 104(AX)
+	SUBQ 80(AX), SI
+	MOVQ SI, 112(AX)
+	RET
+
+error_match_off_too_big:
+	// Return value
+	MOVB $0x00, ret+8(FP)
+
+	// Update the context
+	MOVQ ctx+0(FP), AX
+	MOVQ DX, 24(AX)
+	MOVQ DI, 104(AX)
+	SUBQ 80(AX), SI
+	MOVQ SI, 112(AX)
+	RET
+
+empty_seqs:
+	// Return value
+	MOVB $0x01, ret+8(FP)
+	RET
+
+// func sequenceDecs_decodeSync_amd64(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
+// Requires: CMOV, SSE
+TEXT ·sequenceDecs_decodeSync_amd64(SB), $64-32
+	MOVQ    br+8(FP), AX
+	MOVQ    32(AX), DX
+	MOVBQZX 40(AX), BX
+	MOVQ    24(AX), SI
+	MOVQ    (AX), AX
+	ADDQ    SI, AX
+	MOVQ    AX, (SP)
+	MOVQ    ctx+16(FP), AX
+	MOVQ    72(AX), DI
+	MOVQ    80(AX), R8
+	MOVQ    88(AX), R9
+	XORQ    CX, CX
+	MOVQ    CX, 8(SP)
+	MOVQ    CX, 16(SP)
+	MOVQ    CX, 24(SP)
+	MOVQ    112(AX), R10
+	MOVQ    128(AX), CX
+	MOVQ    CX, 32(SP)
+	MOVQ    144(AX), R11
+	MOVQ    136(AX), R12
+	MOVQ    200(AX), CX
+	MOVQ    CX, 56(SP)
+	MOVQ    176(AX), CX
+	MOVQ    CX, 48(SP)
+	MOVQ    184(AX), AX
+	MOVQ    AX, 40(SP)
+	MOVQ    40(SP), AX
+	ADDQ    AX, 48(SP)
+
+	// Calculate poiter to s.out[cap(s.out)] (a past-end pointer)
+	ADDQ R10, 32(SP)
+
+	// outBase += outPosition
+	ADDQ R12, R10
+
+sequenceDecs_decodeSync_amd64_main_loop:
+	MOVQ (SP), R13
+
+	// Fill bitreader to have enough for the offset and match length.
+	CMPQ SI, $0x08
+	JL   sequenceDecs_decodeSync_amd64_fill_byte_by_byte
+	MOVQ BX, AX
+	SHRQ $0x03, AX
+	SUBQ AX, R13
+	MOVQ (R13), DX
+	SUBQ AX, SI
+	ANDQ $0x07, BX
+	JMP  sequenceDecs_decodeSync_amd64_fill_end
+
+sequenceDecs_decodeSync_amd64_fill_byte_by_byte:
+	CMPQ    SI, $0x00
+	JLE     sequenceDecs_decodeSync_amd64_fill_check_overread
+	CMPQ    BX, $0x07
+	JLE     sequenceDecs_decodeSync_amd64_fill_end
+	SHLQ    $0x08, DX
+	SUBQ    $0x01, R13
+	SUBQ    $0x01, SI
+	SUBQ    $0x08, BX
+	MOVBQZX (R13), AX
+	ORQ     AX, DX
+	JMP     sequenceDecs_decodeSync_amd64_fill_byte_by_byte
+
+sequenceDecs_decodeSync_amd64_fill_check_overread:
+	CMPQ BX, $0x40
+	JA   error_overread
+
+sequenceDecs_decodeSync_amd64_fill_end:
+	// Update offset
+	MOVQ  R9, AX
+	MOVQ  BX, CX
+	MOVQ  DX, R14
+	SHLQ  CL, R14
+	MOVB  AH, CL
+	SHRQ  $0x20, AX
+	TESTQ CX, CX
+	JZ    sequenceDecs_decodeSync_amd64_of_update_zero
+	ADDQ  CX, BX
+	CMPQ  BX, $0x40
+	JA    sequenceDecs_decodeSync_amd64_of_update_zero
+	CMPQ  CX, $0x40
+	JAE   sequenceDecs_decodeSync_amd64_of_update_zero
+	NEGQ  CX
+	SHRQ  CL, R14
+	ADDQ  R14, AX
+
+sequenceDecs_decodeSync_amd64_of_update_zero:
+	MOVQ AX, 8(SP)
+
+	// Update match length
+	MOVQ  R8, AX
+	MOVQ  BX, CX
+	MOVQ  DX, R14
+	SHLQ  CL, R14
+	MOVB  AH, CL
+	SHRQ  $0x20, AX
+	TESTQ CX, CX
+	JZ    sequenceDecs_decodeSync_amd64_ml_update_zero
+	ADDQ  CX, BX
+	CMPQ  BX, $0x40
+	JA    sequenceDecs_decodeSync_amd64_ml_update_zero
+	CMPQ  CX, $0x40
+	JAE   sequenceDecs_decodeSync_amd64_ml_update_zero
+	NEGQ  CX
+	SHRQ  CL, R14
+	ADDQ  R14, AX
+
+sequenceDecs_decodeSync_amd64_ml_update_zero:
+	MOVQ AX, 16(SP)
+
+	// Fill bitreader to have enough for the remaining
+	CMPQ SI, $0x08
+	JL   sequenceDecs_decodeSync_amd64_fill_2_byte_by_byte
+	MOVQ BX, AX
+	SHRQ $0x03, AX
+	SUBQ AX, R13
+	MOVQ (R13), DX
+	SUBQ AX, SI
+	ANDQ $0x07, BX
+	JMP  sequenceDecs_decodeSync_amd64_fill_2_end
+
+sequenceDecs_decodeSync_amd64_fill_2_byte_by_byte:
+	CMPQ    SI, $0x00
+	JLE     sequenceDecs_decodeSync_amd64_fill_2_check_overread
+	CMPQ    BX, $0x07
+	JLE     sequenceDecs_decodeSync_amd64_fill_2_end
+	SHLQ    $0x08, DX
+	SUBQ    $0x01, R13
+	SUBQ    $0x01, SI
+	SUBQ    $0x08, BX
+	MOVBQZX (R13), AX
+	ORQ     AX, DX
+	JMP     sequenceDecs_decodeSync_amd64_fill_2_byte_by_byte
+
+sequenceDecs_decodeSync_amd64_fill_2_check_overread:
+	CMPQ BX, $0x40
+	JA   error_overread
+
+sequenceDecs_decodeSync_amd64_fill_2_end:
+	// Update literal length
+	MOVQ  DI, AX
+	MOVQ  BX, CX
+	MOVQ  DX, R14
+	SHLQ  CL, R14
+	MOVB  AH, CL
+	SHRQ  $0x20, AX
+	TESTQ CX, CX
+	JZ    sequenceDecs_decodeSync_amd64_ll_update_zero
+	ADDQ  CX, BX
+	CMPQ  BX, $0x40
+	JA    sequenceDecs_decodeSync_amd64_ll_update_zero
+	CMPQ  CX, $0x40
+	JAE   sequenceDecs_decodeSync_amd64_ll_update_zero
+	NEGQ  CX
+	SHRQ  CL, R14
+	ADDQ  R14, AX
+
+sequenceDecs_decodeSync_amd64_ll_update_zero:
+	MOVQ AX, 24(SP)
+
+	// Fill bitreader for state updates
+	MOVQ    R13, (SP)
+	MOVQ    R9, AX
+	SHRQ    $0x08, AX
+	MOVBQZX AL, AX
+	MOVQ    ctx+16(FP), CX
+	CMPQ    96(CX), $0x00
+	JZ      sequenceDecs_decodeSync_amd64_skip_update
+
+	// Update Literal Length State
+	MOVBQZX DI, R13
+	SHRQ    $0x10, DI
+	MOVWQZX DI, DI
+	LEAQ    (BX)(R13*1), CX
+	MOVQ    DX, R14
+	MOVQ    CX, BX
+	ROLQ    CL, R14
+	MOVL    $0x00000001, R15
+	MOVB    R13, CL
+	SHLL    CL, R15
+	DECL    R15
+	ANDQ    R15, R14
+	ADDQ    R14, DI
+
+	// Load ctx.llTable
+	MOVQ ctx+16(FP), CX
+	MOVQ (CX), CX
+	MOVQ (CX)(DI*8), DI
+
+	// Update Match Length State
+	MOVBQZX R8, R13
+	SHRQ    $0x10, R8
+	MOVWQZX R8, R8
+	LEAQ    (BX)(R13*1), CX
+	MOVQ    DX, R14
+	MOVQ    CX, BX
+	ROLQ    CL, R14
+	MOVL    $0x00000001, R15
+	MOVB    R13, CL
+	SHLL    CL, R15
+	DECL    R15
+	ANDQ    R15, R14
+	ADDQ    R14, R8
+
+	// Load ctx.mlTable
+	MOVQ ctx+16(FP), CX
+	MOVQ 24(CX), CX
+	MOVQ (CX)(R8*8), R8
+
+	// Update Offset State
+	MOVBQZX R9, R13
+	SHRQ    $0x10, R9
+	MOVWQZX R9, R9
+	LEAQ    (BX)(R13*1), CX
+	MOVQ    DX, R14
+	MOVQ    CX, BX
+	ROLQ    CL, R14
+	MOVL    $0x00000001, R15
+	MOVB    R13, CL
+	SHLL    CL, R15
+	DECL    R15
+	ANDQ    R15, R14
+	ADDQ    R14, R9
+
+	// Load ctx.ofTable
+	MOVQ ctx+16(FP), CX
+	MOVQ 48(CX), CX
+	MOVQ (CX)(R9*8), R9
+
+sequenceDecs_decodeSync_amd64_skip_update:
+	// Adjust offset
+	MOVQ   s+0(FP), CX
+	MOVQ   8(SP), R13
+	CMPQ   AX, $0x01
+	JBE    sequenceDecs_decodeSync_amd64_adjust_offsetB_1_or_0
+	MOVUPS 144(CX), X0
+	MOVQ   R13, 144(CX)
+	MOVUPS X0, 152(CX)
+	JMP    sequenceDecs_decodeSync_amd64_after_adjust
+
+sequenceDecs_decodeSync_amd64_adjust_offsetB_1_or_0:
+	CMPQ 24(SP), $0x00000000
+	JNE  sequenceDecs_decodeSync_amd64_adjust_offset_maybezero
+	INCQ R13
+	JMP  sequenceDecs_decodeSync_amd64_adjust_offset_nonzero
+
+sequenceDecs_decodeSync_amd64_adjust_offset_maybezero:
+	TESTQ R13, R13
+	JNZ   sequenceDecs_decodeSync_amd64_adjust_offset_nonzero
+	MOVQ  144(CX), R13
+	JMP   sequenceDecs_decodeSync_amd64_after_adjust
+
+sequenceDecs_decodeSync_amd64_adjust_offset_nonzero:
+	MOVQ    R13, AX
+	XORQ    R14, R14
+	MOVQ    $-1, R15
+	CMPQ    R13, $0x03
+	CMOVQEQ R14, AX
+	CMOVQEQ R15, R14
+	ADDQ    144(CX)(AX*8), R14
+	JNZ     sequenceDecs_decodeSync_amd64_adjust_temp_valid
+	MOVQ    $0x00000001, R14
+
+sequenceDecs_decodeSync_amd64_adjust_temp_valid:
+	CMPQ R13, $0x01
+	JZ   sequenceDecs_decodeSync_amd64_adjust_skip
+	MOVQ 152(CX), AX
+	MOVQ AX, 160(CX)
+
+sequenceDecs_decodeSync_amd64_adjust_skip:
+	MOVQ 144(CX), AX
+	MOVQ AX, 152(CX)
+	MOVQ R14, 144(CX)
+	MOVQ R14, R13
+
+sequenceDecs_decodeSync_amd64_after_adjust:
+	MOVQ R13, 8(SP)
+
+	// Check values
+	MOVQ  16(SP), AX
+	MOVQ  24(SP), CX
+	LEAQ  (AX)(CX*1), R14
+	MOVQ  s+0(FP), R15
+	ADDQ  R14, 256(R15)
+	MOVQ  ctx+16(FP), R14
+	SUBQ  CX, 104(R14)
+	JS    error_not_enough_literals
+	CMPQ  AX, $0x00020002
+	JA    sequenceDecs_decodeSync_amd64_error_match_len_too_big
+	TESTQ R13, R13
+	JNZ   sequenceDecs_decodeSync_amd64_match_len_ofs_ok
+	TESTQ AX, AX
+	JNZ   sequenceDecs_decodeSync_amd64_error_match_len_ofs_mismatch
+
+sequenceDecs_decodeSync_amd64_match_len_ofs_ok:
+	MOVQ 24(SP), AX
+	MOVQ 8(SP), CX
+	MOVQ 16(SP), R13
+
+	// Check if we have enough space in s.out
+	LEAQ (AX)(R13*1), R14
+	ADDQ R10, R14
+	CMPQ R14, 32(SP)
+	JA   error_not_enough_space
+
+	// Copy literals
+	TESTQ AX, AX
+	JZ    check_offset
+	XORQ  R14, R14
+
+copy_1:
+	MOVUPS (R11)(R14*1), X0
+	MOVUPS X0, (R10)(R14*1)
+	ADDQ   $0x10, R14
+	CMPQ   R14, AX
+	JB     copy_1
+	ADDQ   AX, R11
+	ADDQ   AX, R10
+	ADDQ   AX, R12
+
+	// Malformed input if seq.mo > t+len(hist) || seq.mo > s.windowSize)
+check_offset:
+	MOVQ R12, AX
+	ADDQ 40(SP), AX
+	CMPQ CX, AX
+	JG   error_match_off_too_big
+	CMPQ CX, 56(SP)
+	JG   error_match_off_too_big
+
+	// Copy match from history
+	MOVQ CX, AX
+	SUBQ R12, AX
+	JLS  copy_match
+	MOVQ 48(SP), R14
+	SUBQ AX, R14
+	CMPQ R13, AX
+	JG   copy_all_from_history
+	MOVQ R13, AX
+	SUBQ $0x10, AX
+	JB   copy_4_small
+
+copy_4_loop:
+	MOVUPS (R14), X0
+	MOVUPS X0, (R10)
+	ADDQ   $0x10, R14
+	ADDQ   $0x10, R10
+	SUBQ   $0x10, AX
+	JAE    copy_4_loop
+	LEAQ   16(R14)(AX*1), R14
+	LEAQ   16(R10)(AX*1), R10
+	MOVUPS -16(R14), X0
+	MOVUPS X0, -16(R10)
+	JMP    copy_4_end
+
+copy_4_small:
+	CMPQ R13, $0x03
+	JE   copy_4_move_3
+	CMPQ R13, $0x08
+	JB   copy_4_move_4through7
+	JMP  copy_4_move_8through16
+
+copy_4_move_3:
+	MOVW (R14), AX
+	MOVB 2(R14), CL
+	MOVW AX, (R10)
+	MOVB CL, 2(R10)
+	ADDQ R13, R14
+	ADDQ R13, R10
+	JMP  copy_4_end
+
+copy_4_move_4through7:
+	MOVL (R14), AX
+	MOVL -4(R14)(R13*1), CX
+	MOVL AX, (R10)
+	MOVL CX, -4(R10)(R13*1)
+	ADDQ R13, R14
+	ADDQ R13, R10
+	JMP  copy_4_end
+
+copy_4_move_8through16:
+	MOVQ (R14), AX
+	MOVQ -8(R14)(R13*1), CX
+	MOVQ AX, (R10)
+	MOVQ CX, -8(R10)(R13*1)
+	ADDQ R13, R14
+	ADDQ R13, R10
+
+copy_4_end:
+	ADDQ R13, R12
+	JMP  handle_loop
+	JMP loop_finished
+
+copy_all_from_history:
+	MOVQ AX, R15
+	SUBQ $0x10, R15
+	JB   copy_5_small
+
+copy_5_loop:
+	MOVUPS (R14), X0
+	MOVUPS X0, (R10)
+	ADDQ   $0x10, R14
+	ADDQ   $0x10, R10
+	SUBQ   $0x10, R15
+	JAE    copy_5_loop
+	LEAQ   16(R14)(R15*1), R14
+	LEAQ   16(R10)(R15*1), R10
+	MOVUPS -16(R14), X0
+	MOVUPS X0, -16(R10)
+	JMP    copy_5_end
+
+copy_5_small:
+	CMPQ AX, $0x03
+	JE   copy_5_move_3
+	JB   copy_5_move_1or2
+	CMPQ AX, $0x08
+	JB   copy_5_move_4through7
+	JMP  copy_5_move_8through16
+
+copy_5_move_1or2:
+	MOVB (R14), R15
+	MOVB -1(R14)(AX*1), BP
+	MOVB R15, (R10)
+	MOVB BP, -1(R10)(AX*1)
+	ADDQ AX, R14
+	ADDQ AX, R10
+	JMP  copy_5_end
+
+copy_5_move_3:
+	MOVW (R14), R15
+	MOVB 2(R14), BP
+	MOVW R15, (R10)
+	MOVB BP, 2(R10)
+	ADDQ AX, R14
+	ADDQ AX, R10
+	JMP  copy_5_end
+
+copy_5_move_4through7:
+	MOVL (R14), R15
+	MOVL -4(R14)(AX*1), BP
+	MOVL R15, (R10)
+	MOVL BP, -4(R10)(AX*1)
+	ADDQ AX, R14
+	ADDQ AX, R10
+	JMP  copy_5_end
+
+copy_5_move_8through16:
+	MOVQ (R14), R15
+	MOVQ -8(R14)(AX*1), BP
+	MOVQ R15, (R10)
+	MOVQ BP, -8(R10)(AX*1)
+	ADDQ AX, R14
+	ADDQ AX, R10
+
+copy_5_end:
+	ADDQ AX, R12
+	SUBQ AX, R13
+
+	// Copy match from the current buffer
+copy_match:
+	MOVQ R10, AX
+	SUBQ CX, AX
+
+	// ml <= mo
+	CMPQ R13, CX
+	JA   copy_overlapping_match
+
+	// Copy non-overlapping match
+	ADDQ R13, R12
+	MOVQ R10, CX
+	ADDQ R13, R10
+
+copy_2:
+	MOVUPS (AX), X0
+	MOVUPS X0, (CX)
+	ADDQ   $0x10, AX
+	ADDQ   $0x10, CX
+	SUBQ   $0x10, R13
+	JHI    copy_2
+	JMP    handle_loop
+
+	// Copy overlapping match
+copy_overlapping_match:
+	ADDQ R13, R12
+
+copy_slow_3:
+	MOVB (AX), CL
+	MOVB CL, (R10)
+	INCQ AX
+	INCQ R10
+	DECQ R13
+	JNZ  copy_slow_3
+
+handle_loop:
+	MOVQ ctx+16(FP), AX
+	DECQ 96(AX)
+	JNS  sequenceDecs_decodeSync_amd64_main_loop
+
+loop_finished:
+	MOVQ br+8(FP), AX
+	MOVQ DX, 32(AX)
+	MOVB BL, 40(AX)
+	MOVQ SI, 24(AX)
+
+	// Update the context
+	MOVQ ctx+16(FP), AX
+	MOVQ R12, 136(AX)
+	MOVQ 144(AX), CX
+	SUBQ CX, R11
+	MOVQ R11, 168(AX)
+
+	// Return success
+	MOVQ $0x00000000, ret+24(FP)
+	RET
+
+	// Return with match length error
+sequenceDecs_decodeSync_amd64_error_match_len_ofs_mismatch:
+	MOVQ 16(SP), AX
+	MOVQ ctx+16(FP), CX
+	MOVQ AX, 216(CX)
+	MOVQ $0x00000001, ret+24(FP)
+	RET
+
+	// Return with match too long error
+sequenceDecs_decodeSync_amd64_error_match_len_too_big:
+	MOVQ ctx+16(FP), AX
+	MOVQ 16(SP), CX
+	MOVQ CX, 216(AX)
+	MOVQ $0x00000002, ret+24(FP)
+	RET
+
+	// Return with match offset too long error
+error_match_off_too_big:
+	MOVQ ctx+16(FP), AX
+	MOVQ 8(SP), CX
+	MOVQ CX, 224(AX)
+	MOVQ R12, 136(AX)
+	MOVQ $0x00000003, ret+24(FP)
+	RET
+
+	// Return with not enough literals error
+error_not_enough_literals:
+	MOVQ ctx+16(FP), AX
+	MOVQ 24(SP), CX
+	MOVQ CX, 208(AX)
+	MOVQ $0x00000004, ret+24(FP)
+	RET
+
+	// Return with overread error
+error_overread:
+	MOVQ $0x00000006, ret+24(FP)
+	RET
+
+	// Return with not enough output space error
+error_not_enough_space:
+	MOVQ ctx+16(FP), AX
+	MOVQ 24(SP), CX
+	MOVQ CX, 208(AX)
+	MOVQ 16(SP), CX
+	MOVQ CX, 216(AX)
+	MOVQ R12, 136(AX)
+	MOVQ $0x00000005, ret+24(FP)
+	RET
+
+// func sequenceDecs_decodeSync_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
+// Requires: BMI, BMI2, CMOV, SSE
+TEXT ·sequenceDecs_decodeSync_bmi2(SB), $64-32
+	MOVQ    br+8(FP), CX
+	MOVQ    32(CX), AX
+	MOVBQZX 40(CX), DX
+	MOVQ    24(CX), BX
+	MOVQ    (CX), CX
+	ADDQ    BX, CX
+	MOVQ    CX, (SP)
+	MOVQ    ctx+16(FP), CX
+	MOVQ    72(CX), SI
+	MOVQ    80(CX), DI
+	MOVQ    88(CX), R8
+	XORQ    R9, R9
+	MOVQ    R9, 8(SP)
+	MOVQ    R9, 16(SP)
+	MOVQ    R9, 24(SP)
+	MOVQ    112(CX), R9
+	MOVQ    128(CX), R10
+	MOVQ    R10, 32(SP)
+	MOVQ    144(CX), R10
+	MOVQ    136(CX), R11
+	MOVQ    200(CX), R12
+	MOVQ    R12, 56(SP)
+	MOVQ    176(CX), R12
+	MOVQ    R12, 48(SP)
+	MOVQ    184(CX), CX
+	MOVQ    CX, 40(SP)
+	MOVQ    40(SP), CX
+	ADDQ    CX, 48(SP)
+
+	// Calculate poiter to s.out[cap(s.out)] (a past-end pointer)
+	ADDQ R9, 32(SP)
+
+	// outBase += outPosition
+	ADDQ R11, R9
+
+sequenceDecs_decodeSync_bmi2_main_loop:
+	MOVQ (SP), R12
+
+	// Fill bitreader to have enough for the offset and match length.
+	CMPQ BX, $0x08
+	JL   sequenceDecs_decodeSync_bmi2_fill_byte_by_byte
+	MOVQ DX, CX
+	SHRQ $0x03, CX
+	SUBQ CX, R12
+	MOVQ (R12), AX
+	SUBQ CX, BX
+	ANDQ $0x07, DX
+	JMP  sequenceDecs_decodeSync_bmi2_fill_end
+
+sequenceDecs_decodeSync_bmi2_fill_byte_by_byte:
+	CMPQ    BX, $0x00
+	JLE     sequenceDecs_decodeSync_bmi2_fill_check_overread
+	CMPQ    DX, $0x07
+	JLE     sequenceDecs_decodeSync_bmi2_fill_end
+	SHLQ    $0x08, AX
+	SUBQ    $0x01, R12
+	SUBQ    $0x01, BX
+	SUBQ    $0x08, DX
+	MOVBQZX (R12), CX
+	ORQ     CX, AX
+	JMP     sequenceDecs_decodeSync_bmi2_fill_byte_by_byte
+
+sequenceDecs_decodeSync_bmi2_fill_check_overread:
+	CMPQ DX, $0x40
+	JA   error_overread
+
+sequenceDecs_decodeSync_bmi2_fill_end:
+	// Update offset
+	MOVQ   $0x00000808, CX
+	BEXTRQ CX, R8, R13
+	MOVQ   AX, R14
+	LEAQ   (DX)(R13*1), CX
+	ROLQ   CL, R14
+	BZHIQ  R13, R14, R14
+	MOVQ   CX, DX
+	MOVQ   R8, CX
+	SHRQ   $0x20, CX
+	ADDQ   R14, CX
+	MOVQ   CX, 8(SP)
+
+	// Update match length
+	MOVQ   $0x00000808, CX
+	BEXTRQ CX, DI, R13
+	MOVQ   AX, R14
+	LEAQ   (DX)(R13*1), CX
+	ROLQ   CL, R14
+	BZHIQ  R13, R14, R14
+	MOVQ   CX, DX
+	MOVQ   DI, CX
+	SHRQ   $0x20, CX
+	ADDQ   R14, CX
+	MOVQ   CX, 16(SP)
+
+	// Fill bitreader to have enough for the remaining
+	CMPQ BX, $0x08
+	JL   sequenceDecs_decodeSync_bmi2_fill_2_byte_by_byte
+	MOVQ DX, CX
+	SHRQ $0x03, CX
+	SUBQ CX, R12
+	MOVQ (R12), AX
+	SUBQ CX, BX
+	ANDQ $0x07, DX
+	JMP  sequenceDecs_decodeSync_bmi2_fill_2_end
+
+sequenceDecs_decodeSync_bmi2_fill_2_byte_by_byte:
+	CMPQ    BX, $0x00
+	JLE     sequenceDecs_decodeSync_bmi2_fill_2_check_overread
+	CMPQ    DX, $0x07
+	JLE     sequenceDecs_decodeSync_bmi2_fill_2_end
+	SHLQ    $0x08, AX
+	SUBQ    $0x01, R12
+	SUBQ    $0x01, BX
+	SUBQ    $0x08, DX
+	MOVBQZX (R12), CX
+	ORQ     CX, AX
+	JMP     sequenceDecs_decodeSync_bmi2_fill_2_byte_by_byte
+
+sequenceDecs_decodeSync_bmi2_fill_2_check_overread:
+	CMPQ DX, $0x40
+	JA   error_overread
+
+sequenceDecs_decodeSync_bmi2_fill_2_end:
+	// Update literal length
+	MOVQ   $0x00000808, CX
+	BEXTRQ CX, SI, R13
+	MOVQ   AX, R14
+	LEAQ   (DX)(R13*1), CX
+	ROLQ   CL, R14
+	BZHIQ  R13, R14, R14
+	MOVQ   CX, DX
+	MOVQ   SI, CX
+	SHRQ   $0x20, CX
+	ADDQ   R14, CX
+	MOVQ   CX, 24(SP)
+
+	// Fill bitreader for state updates
+	MOVQ    R12, (SP)
+	MOVQ    $0x00000808, CX
+	BEXTRQ  CX, R8, R12
+	MOVQ    ctx+16(FP), CX
+	CMPQ    96(CX), $0x00
+	JZ      sequenceDecs_decodeSync_bmi2_skip_update
+	LEAQ    (SI)(DI*1), R13
+	ADDQ    R8, R13
+	MOVBQZX R13, R13
+	LEAQ    (DX)(R13*1), CX
+	MOVQ    AX, R14
+	MOVQ    CX, DX
+	ROLQ    CL, R14
+	BZHIQ   R13, R14, R14
+
+	// Update Offset State
+	BZHIQ  R8, R14, CX
+	SHRXQ  R8, R14, R14
+	MOVQ   $0x00001010, R13
+	BEXTRQ R13, R8, R8
+	ADDQ   CX, R8
+
+	// Load ctx.ofTable
+	MOVQ ctx+16(FP), CX
+	MOVQ 48(CX), CX
+	MOVQ (CX)(R8*8), R8
+
+	// Update Match Length State
+	BZHIQ  DI, R14, CX
+	SHRXQ  DI, R14, R14
+	MOVQ   $0x00001010, R13
+	BEXTRQ R13, DI, DI
+	ADDQ   CX, DI
+
+	// Load ctx.mlTable
+	MOVQ ctx+16(FP), CX
+	MOVQ 24(CX), CX
+	MOVQ (CX)(DI*8), DI
+
+	// Update Literal Length State
+	BZHIQ  SI, R14, CX
+	MOVQ   $0x00001010, R13
+	BEXTRQ R13, SI, SI
+	ADDQ   CX, SI
+
+	// Load ctx.llTable
+	MOVQ ctx+16(FP), CX
+	MOVQ (CX), CX
+	MOVQ (CX)(SI*8), SI
+
+sequenceDecs_decodeSync_bmi2_skip_update:
+	// Adjust offset
+	MOVQ   s+0(FP), CX
+	MOVQ   8(SP), R13
+	CMPQ   R12, $0x01
+	JBE    sequenceDecs_decodeSync_bmi2_adjust_offsetB_1_or_0
+	MOVUPS 144(CX), X0
+	MOVQ   R13, 144(CX)
+	MOVUPS X0, 152(CX)
+	JMP    sequenceDecs_decodeSync_bmi2_after_adjust
+
+sequenceDecs_decodeSync_bmi2_adjust_offsetB_1_or_0:
+	CMPQ 24(SP), $0x00000000
+	JNE  sequenceDecs_decodeSync_bmi2_adjust_offset_maybezero
+	INCQ R13
+	JMP  sequenceDecs_decodeSync_bmi2_adjust_offset_nonzero
+
+sequenceDecs_decodeSync_bmi2_adjust_offset_maybezero:
+	TESTQ R13, R13
+	JNZ   sequenceDecs_decodeSync_bmi2_adjust_offset_nonzero
+	MOVQ  144(CX), R13
+	JMP   sequenceDecs_decodeSync_bmi2_after_adjust
+
+sequenceDecs_decodeSync_bmi2_adjust_offset_nonzero:
+	MOVQ    R13, R12
+	XORQ    R14, R14
+	MOVQ    $-1, R15
+	CMPQ    R13, $0x03
+	CMOVQEQ R14, R12
+	CMOVQEQ R15, R14
+	ADDQ    144(CX)(R12*8), R14
+	JNZ     sequenceDecs_decodeSync_bmi2_adjust_temp_valid
+	MOVQ    $0x00000001, R14
+
+sequenceDecs_decodeSync_bmi2_adjust_temp_valid:
+	CMPQ R13, $0x01
+	JZ   sequenceDecs_decodeSync_bmi2_adjust_skip
+	MOVQ 152(CX), R12
+	MOVQ R12, 160(CX)
+
+sequenceDecs_decodeSync_bmi2_adjust_skip:
+	MOVQ 144(CX), R12
+	MOVQ R12, 152(CX)
+	MOVQ R14, 144(CX)
+	MOVQ R14, R13
+
+sequenceDecs_decodeSync_bmi2_after_adjust:
+	MOVQ R13, 8(SP)
+
+	// Check values
+	MOVQ  16(SP), CX
+	MOVQ  24(SP), R12
+	LEAQ  (CX)(R12*1), R14
+	MOVQ  s+0(FP), R15
+	ADDQ  R14, 256(R15)
+	MOVQ  ctx+16(FP), R14
+	SUBQ  R12, 104(R14)
+	JS    error_not_enough_literals
+	CMPQ  CX, $0x00020002
+	JA    sequenceDecs_decodeSync_bmi2_error_match_len_too_big
+	TESTQ R13, R13
+	JNZ   sequenceDecs_decodeSync_bmi2_match_len_ofs_ok
+	TESTQ CX, CX
+	JNZ   sequenceDecs_decodeSync_bmi2_error_match_len_ofs_mismatch
+
+sequenceDecs_decodeSync_bmi2_match_len_ofs_ok:
+	MOVQ 24(SP), CX
+	MOVQ 8(SP), R12
+	MOVQ 16(SP), R13
+
+	// Check if we have enough space in s.out
+	LEAQ (CX)(R13*1), R14
+	ADDQ R9, R14
+	CMPQ R14, 32(SP)
+	JA   error_not_enough_space
+
+	// Copy literals
+	TESTQ CX, CX
+	JZ    check_offset
+	XORQ  R14, R14
+
+copy_1:
+	MOVUPS (R10)(R14*1), X0
+	MOVUPS X0, (R9)(R14*1)
+	ADDQ   $0x10, R14
+	CMPQ   R14, CX
+	JB     copy_1
+	ADDQ   CX, R10
+	ADDQ   CX, R9
+	ADDQ   CX, R11
+
+	// Malformed input if seq.mo > t+len(hist) || seq.mo > s.windowSize)
+check_offset:
+	MOVQ R11, CX
+	ADDQ 40(SP), CX
+	CMPQ R12, CX
+	JG   error_match_off_too_big
+	CMPQ R12, 56(SP)
+	JG   error_match_off_too_big
+
+	// Copy match from history
+	MOVQ R12, CX
+	SUBQ R11, CX
+	JLS  copy_match
+	MOVQ 48(SP), R14
+	SUBQ CX, R14
+	CMPQ R13, CX
+	JG   copy_all_from_history
+	MOVQ R13, CX
+	SUBQ $0x10, CX
+	JB   copy_4_small
+
+copy_4_loop:
+	MOVUPS (R14), X0
+	MOVUPS X0, (R9)
+	ADDQ   $0x10, R14
+	ADDQ   $0x10, R9
+	SUBQ   $0x10, CX
+	JAE    copy_4_loop
+	LEAQ   16(R14)(CX*1), R14
+	LEAQ   16(R9)(CX*1), R9
+	MOVUPS -16(R14), X0
+	MOVUPS X0, -16(R9)
+	JMP    copy_4_end
+
+copy_4_small:
+	CMPQ R13, $0x03
+	JE   copy_4_move_3
+	CMPQ R13, $0x08
+	JB   copy_4_move_4through7
+	JMP  copy_4_move_8through16
+
+copy_4_move_3:
+	MOVW (R14), CX
+	MOVB 2(R14), R12
+	MOVW CX, (R9)
+	MOVB R12, 2(R9)
+	ADDQ R13, R14
+	ADDQ R13, R9
+	JMP  copy_4_end
+
+copy_4_move_4through7:
+	MOVL (R14), CX
+	MOVL -4(R14)(R13*1), R12
+	MOVL CX, (R9)
+	MOVL R12, -4(R9)(R13*1)
+	ADDQ R13, R14
+	ADDQ R13, R9
+	JMP  copy_4_end
+
+copy_4_move_8through16:
+	MOVQ (R14), CX
+	MOVQ -8(R14)(R13*1), R12
+	MOVQ CX, (R9)
+	MOVQ R12, -8(R9)(R13*1)
+	ADDQ R13, R14
+	ADDQ R13, R9
+
+copy_4_end:
+	ADDQ R13, R11
+	JMP  handle_loop
+	JMP loop_finished
+
+copy_all_from_history:
+	MOVQ CX, R15
+	SUBQ $0x10, R15
+	JB   copy_5_small
+
+copy_5_loop:
+	MOVUPS (R14), X0
+	MOVUPS X0, (R9)
+	ADDQ   $0x10, R14
+	ADDQ   $0x10, R9
+	SUBQ   $0x10, R15
+	JAE    copy_5_loop
+	LEAQ   16(R14)(R15*1), R14
+	LEAQ   16(R9)(R15*1), R9
+	MOVUPS -16(R14), X0
+	MOVUPS X0, -16(R9)
+	JMP    copy_5_end
+
+copy_5_small:
+	CMPQ CX, $0x03
+	JE   copy_5_move_3
+	JB   copy_5_move_1or2
+	CMPQ CX, $0x08
+	JB   copy_5_move_4through7
+	JMP  copy_5_move_8through16
+
+copy_5_move_1or2:
+	MOVB (R14), R15
+	MOVB -1(R14)(CX*1), BP
+	MOVB R15, (R9)
+	MOVB BP, -1(R9)(CX*1)
+	ADDQ CX, R14
+	ADDQ CX, R9
+	JMP  copy_5_end
+
+copy_5_move_3:
+	MOVW (R14), R15
+	MOVB 2(R14), BP
+	MOVW R15, (R9)
+	MOVB BP, 2(R9)
+	ADDQ CX, R14
+	ADDQ CX, R9
+	JMP  copy_5_end
+
+copy_5_move_4through7:
+	MOVL (R14), R15
+	MOVL -4(R14)(CX*1), BP
+	MOVL R15, (R9)
+	MOVL BP, -4(R9)(CX*1)
+	ADDQ CX, R14
+	ADDQ CX, R9
+	JMP  copy_5_end
+
+copy_5_move_8through16:
+	MOVQ (R14), R15
+	MOVQ -8(R14)(CX*1), BP
+	MOVQ R15, (R9)
+	MOVQ BP, -8(R9)(CX*1)
+	ADDQ CX, R14
+	ADDQ CX, R9
+
+copy_5_end:
+	ADDQ CX, R11
+	SUBQ CX, R13
+
+	// Copy match from the current buffer
+copy_match:
+	MOVQ R9, CX
+	SUBQ R12, CX
+
+	// ml <= mo
+	CMPQ R13, R12
+	JA   copy_overlapping_match
+
+	// Copy non-overlapping match
+	ADDQ R13, R11
+	MOVQ R9, R12
+	ADDQ R13, R9
+
+copy_2:
+	MOVUPS (CX), X0
+	MOVUPS X0, (R12)
+	ADDQ   $0x10, CX
+	ADDQ   $0x10, R12
+	SUBQ   $0x10, R13
+	JHI    copy_2
+	JMP    handle_loop
+
+	// Copy overlapping match
+copy_overlapping_match:
+	ADDQ R13, R11
+
+copy_slow_3:
+	MOVB (CX), R12
+	MOVB R12, (R9)
+	INCQ CX
+	INCQ R9
+	DECQ R13
+	JNZ  copy_slow_3
+
+handle_loop:
+	MOVQ ctx+16(FP), CX
+	DECQ 96(CX)
+	JNS  sequenceDecs_decodeSync_bmi2_main_loop
+
+loop_finished:
+	MOVQ br+8(FP), CX
+	MOVQ AX, 32(CX)
+	MOVB DL, 40(CX)
+	MOVQ BX, 24(CX)
+
+	// Update the context
+	MOVQ ctx+16(FP), AX
+	MOVQ R11, 136(AX)
+	MOVQ 144(AX), CX
+	SUBQ CX, R10
+	MOVQ R10, 168(AX)
+
+	// Return success
+	MOVQ $0x00000000, ret+24(FP)
+	RET
+
+	// Return with match length error
+sequenceDecs_decodeSync_bmi2_error_match_len_ofs_mismatch:
+	MOVQ 16(SP), AX
+	MOVQ ctx+16(FP), CX
+	MOVQ AX, 216(CX)
+	MOVQ $0x00000001, ret+24(FP)
+	RET
+
+	// Return with match too long error
+sequenceDecs_decodeSync_bmi2_error_match_len_too_big:
+	MOVQ ctx+16(FP), AX
+	MOVQ 16(SP), CX
+	MOVQ CX, 216(AX)
+	MOVQ $0x00000002, ret+24(FP)
+	RET
+
+	// Return with match offset too long error
+error_match_off_too_big:
+	MOVQ ctx+16(FP), AX
+	MOVQ 8(SP), CX
+	MOVQ CX, 224(AX)
+	MOVQ R11, 136(AX)
+	MOVQ $0x00000003, ret+24(FP)
+	RET
+
+	// Return with not enough literals error
+error_not_enough_literals:
+	MOVQ ctx+16(FP), AX
+	MOVQ 24(SP), CX
+	MOVQ CX, 208(AX)
+	MOVQ $0x00000004, ret+24(FP)
+	RET
+
+	// Return with overread error
+error_overread:
+	MOVQ $0x00000006, ret+24(FP)
+	RET
+
+	// Return with not enough output space error
+error_not_enough_space:
+	MOVQ ctx+16(FP), AX
+	MOVQ 24(SP), CX
+	MOVQ CX, 208(AX)
+	MOVQ 16(SP), CX
+	MOVQ CX, 216(AX)
+	MOVQ R11, 136(AX)
+	MOVQ $0x00000005, ret+24(FP)
+	RET
+
+// func sequenceDecs_decodeSync_safe_amd64(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
+// Requires: CMOV, SSE
+TEXT ·sequenceDecs_decodeSync_safe_amd64(SB), $64-32
+	MOVQ    br+8(FP), AX
+	MOVQ    32(AX), DX
+	MOVBQZX 40(AX), BX
+	MOVQ    24(AX), SI
+	MOVQ    (AX), AX
+	ADDQ    SI, AX
+	MOVQ    AX, (SP)
+	MOVQ    ctx+16(FP), AX
+	MOVQ    72(AX), DI
+	MOVQ    80(AX), R8
+	MOVQ    88(AX), R9
+	XORQ    CX, CX
+	MOVQ    CX, 8(SP)
+	MOVQ    CX, 16(SP)
+	MOVQ    CX, 24(SP)
+	MOVQ    112(AX), R10
+	MOVQ    128(AX), CX
+	MOVQ    CX, 32(SP)
+	MOVQ    144(AX), R11
+	MOVQ    136(AX), R12
+	MOVQ    200(AX), CX
+	MOVQ    CX, 56(SP)
+	MOVQ    176(AX), CX
+	MOVQ    CX, 48(SP)
+	MOVQ    184(AX), AX
+	MOVQ    AX, 40(SP)
+	MOVQ    40(SP), AX
+	ADDQ    AX, 48(SP)
+
+	// Calculate poiter to s.out[cap(s.out)] (a past-end pointer)
+	ADDQ R10, 32(SP)
+
+	// outBase += outPosition
+	ADDQ R12, R10
+
+sequenceDecs_decodeSync_safe_amd64_main_loop:
+	MOVQ (SP), R13
+
+	// Fill bitreader to have enough for the offset and match length.
+	CMPQ SI, $0x08
+	JL   sequenceDecs_decodeSync_safe_amd64_fill_byte_by_byte
+	MOVQ BX, AX
+	SHRQ $0x03, AX
+	SUBQ AX, R13
+	MOVQ (R13), DX
+	SUBQ AX, SI
+	ANDQ $0x07, BX
+	JMP  sequenceDecs_decodeSync_safe_amd64_fill_end
+
+sequenceDecs_decodeSync_safe_amd64_fill_byte_by_byte:
+	CMPQ    SI, $0x00
+	JLE     sequenceDecs_decodeSync_safe_amd64_fill_check_overread
+	CMPQ    BX, $0x07
+	JLE     sequenceDecs_decodeSync_safe_amd64_fill_end
+	SHLQ    $0x08, DX
+	SUBQ    $0x01, R13
+	SUBQ    $0x01, SI
+	SUBQ    $0x08, BX
+	MOVBQZX (R13), AX
+	ORQ     AX, DX
+	JMP     sequenceDecs_decodeSync_safe_amd64_fill_byte_by_byte
+
+sequenceDecs_decodeSync_safe_amd64_fill_check_overread:
+	CMPQ BX, $0x40
+	JA   error_overread
+
+sequenceDecs_decodeSync_safe_amd64_fill_end:
+	// Update offset
+	MOVQ  R9, AX
+	MOVQ  BX, CX
+	MOVQ  DX, R14
+	SHLQ  CL, R14
+	MOVB  AH, CL
+	SHRQ  $0x20, AX
+	TESTQ CX, CX
+	JZ    sequenceDecs_decodeSync_safe_amd64_of_update_zero
+	ADDQ  CX, BX
+	CMPQ  BX, $0x40
+	JA    sequenceDecs_decodeSync_safe_amd64_of_update_zero
+	CMPQ  CX, $0x40
+	JAE   sequenceDecs_decodeSync_safe_amd64_of_update_zero
+	NEGQ  CX
+	SHRQ  CL, R14
+	ADDQ  R14, AX
+
+sequenceDecs_decodeSync_safe_amd64_of_update_zero:
+	MOVQ AX, 8(SP)
+
+	// Update match length
+	MOVQ  R8, AX
+	MOVQ  BX, CX
+	MOVQ  DX, R14
+	SHLQ  CL, R14
+	MOVB  AH, CL
+	SHRQ  $0x20, AX
+	TESTQ CX, CX
+	JZ    sequenceDecs_decodeSync_safe_amd64_ml_update_zero
+	ADDQ  CX, BX
+	CMPQ  BX, $0x40
+	JA    sequenceDecs_decodeSync_safe_amd64_ml_update_zero
+	CMPQ  CX, $0x40
+	JAE   sequenceDecs_decodeSync_safe_amd64_ml_update_zero
+	NEGQ  CX
+	SHRQ  CL, R14
+	ADDQ  R14, AX
+
+sequenceDecs_decodeSync_safe_amd64_ml_update_zero:
+	MOVQ AX, 16(SP)
+
+	// Fill bitreader to have enough for the remaining
+	CMPQ SI, $0x08
+	JL   sequenceDecs_decodeSync_safe_amd64_fill_2_byte_by_byte
+	MOVQ BX, AX
+	SHRQ $0x03, AX
+	SUBQ AX, R13
+	MOVQ (R13), DX
+	SUBQ AX, SI
+	ANDQ $0x07, BX
+	JMP  sequenceDecs_decodeSync_safe_amd64_fill_2_end
+
+sequenceDecs_decodeSync_safe_amd64_fill_2_byte_by_byte:
+	CMPQ    SI, $0x00
+	JLE     sequenceDecs_decodeSync_safe_amd64_fill_2_check_overread
+	CMPQ    BX, $0x07
+	JLE     sequenceDecs_decodeSync_safe_amd64_fill_2_end
+	SHLQ    $0x08, DX
+	SUBQ    $0x01, R13
+	SUBQ    $0x01, SI
+	SUBQ    $0x08, BX
+	MOVBQZX (R13), AX
+	ORQ     AX, DX
+	JMP     sequenceDecs_decodeSync_safe_amd64_fill_2_byte_by_byte
+
+sequenceDecs_decodeSync_safe_amd64_fill_2_check_overread:
+	CMPQ BX, $0x40
+	JA   error_overread
+
+sequenceDecs_decodeSync_safe_amd64_fill_2_end:
+	// Update literal length
+	MOVQ  DI, AX
+	MOVQ  BX, CX
+	MOVQ  DX, R14
+	SHLQ  CL, R14
+	MOVB  AH, CL
+	SHRQ  $0x20, AX
+	TESTQ CX, CX
+	JZ    sequenceDecs_decodeSync_safe_amd64_ll_update_zero
+	ADDQ  CX, BX
+	CMPQ  BX, $0x40
+	JA    sequenceDecs_decodeSync_safe_amd64_ll_update_zero
+	CMPQ  CX, $0x40
+	JAE   sequenceDecs_decodeSync_safe_amd64_ll_update_zero
+	NEGQ  CX
+	SHRQ  CL, R14
+	ADDQ  R14, AX
+
+sequenceDecs_decodeSync_safe_amd64_ll_update_zero:
+	MOVQ AX, 24(SP)
+
+	// Fill bitreader for state updates
+	MOVQ    R13, (SP)
+	MOVQ    R9, AX
+	SHRQ    $0x08, AX
+	MOVBQZX AL, AX
+	MOVQ    ctx+16(FP), CX
+	CMPQ    96(CX), $0x00
+	JZ      sequenceDecs_decodeSync_safe_amd64_skip_update
+
+	// Update Literal Length State
+	MOVBQZX DI, R13
+	SHRQ    $0x10, DI
+	MOVWQZX DI, DI
+	LEAQ    (BX)(R13*1), CX
+	MOVQ    DX, R14
+	MOVQ    CX, BX
+	ROLQ    CL, R14
+	MOVL    $0x00000001, R15
+	MOVB    R13, CL
+	SHLL    CL, R15
+	DECL    R15
+	ANDQ    R15, R14
+	ADDQ    R14, DI
+
+	// Load ctx.llTable
+	MOVQ ctx+16(FP), CX
+	MOVQ (CX), CX
+	MOVQ (CX)(DI*8), DI
+
+	// Update Match Length State
+	MOVBQZX R8, R13
+	SHRQ    $0x10, R8
+	MOVWQZX R8, R8
+	LEAQ    (BX)(R13*1), CX
+	MOVQ    DX, R14
+	MOVQ    CX, BX
+	ROLQ    CL, R14
+	MOVL    $0x00000001, R15
+	MOVB    R13, CL
+	SHLL    CL, R15
+	DECL    R15
+	ANDQ    R15, R14
+	ADDQ    R14, R8
+
+	// Load ctx.mlTable
+	MOVQ ctx+16(FP), CX
+	MOVQ 24(CX), CX
+	MOVQ (CX)(R8*8), R8
+
+	// Update Offset State
+	MOVBQZX R9, R13
+	SHRQ    $0x10, R9
+	MOVWQZX R9, R9
+	LEAQ    (BX)(R13*1), CX
+	MOVQ    DX, R14
+	MOVQ    CX, BX
+	ROLQ    CL, R14
+	MOVL    $0x00000001, R15
+	MOVB    R13, CL
+	SHLL    CL, R15
+	DECL    R15
+	ANDQ    R15, R14
+	ADDQ    R14, R9
+
+	// Load ctx.ofTable
+	MOVQ ctx+16(FP), CX
+	MOVQ 48(CX), CX
+	MOVQ (CX)(R9*8), R9
+
+sequenceDecs_decodeSync_safe_amd64_skip_update:
+	// Adjust offset
+	MOVQ   s+0(FP), CX
+	MOVQ   8(SP), R13
+	CMPQ   AX, $0x01
+	JBE    sequenceDecs_decodeSync_safe_amd64_adjust_offsetB_1_or_0
+	MOVUPS 144(CX), X0
+	MOVQ   R13, 144(CX)
+	MOVUPS X0, 152(CX)
+	JMP    sequenceDecs_decodeSync_safe_amd64_after_adjust
+
+sequenceDecs_decodeSync_safe_amd64_adjust_offsetB_1_or_0:
+	CMPQ 24(SP), $0x00000000
+	JNE  sequenceDecs_decodeSync_safe_amd64_adjust_offset_maybezero
+	INCQ R13
+	JMP  sequenceDecs_decodeSync_safe_amd64_adjust_offset_nonzero
+
+sequenceDecs_decodeSync_safe_amd64_adjust_offset_maybezero:
+	TESTQ R13, R13
+	JNZ   sequenceDecs_decodeSync_safe_amd64_adjust_offset_nonzero
+	MOVQ  144(CX), R13
+	JMP   sequenceDecs_decodeSync_safe_amd64_after_adjust
+
+sequenceDecs_decodeSync_safe_amd64_adjust_offset_nonzero:
+	MOVQ    R13, AX
+	XORQ    R14, R14
+	MOVQ    $-1, R15
+	CMPQ    R13, $0x03
+	CMOVQEQ R14, AX
+	CMOVQEQ R15, R14
+	ADDQ    144(CX)(AX*8), R14
+	JNZ     sequenceDecs_decodeSync_safe_amd64_adjust_temp_valid
+	MOVQ    $0x00000001, R14
+
+sequenceDecs_decodeSync_safe_amd64_adjust_temp_valid:
+	CMPQ R13, $0x01
+	JZ   sequenceDecs_decodeSync_safe_amd64_adjust_skip
+	MOVQ 152(CX), AX
+	MOVQ AX, 160(CX)
+
+sequenceDecs_decodeSync_safe_amd64_adjust_skip:
+	MOVQ 144(CX), AX
+	MOVQ AX, 152(CX)
+	MOVQ R14, 144(CX)
+	MOVQ R14, R13
+
+sequenceDecs_decodeSync_safe_amd64_after_adjust:
+	MOVQ R13, 8(SP)
+
+	// Check values
+	MOVQ  16(SP), AX
+	MOVQ  24(SP), CX
+	LEAQ  (AX)(CX*1), R14
+	MOVQ  s+0(FP), R15
+	ADDQ  R14, 256(R15)
+	MOVQ  ctx+16(FP), R14
+	SUBQ  CX, 104(R14)
+	JS    error_not_enough_literals
+	CMPQ  AX, $0x00020002
+	JA    sequenceDecs_decodeSync_safe_amd64_error_match_len_too_big
+	TESTQ R13, R13
+	JNZ   sequenceDecs_decodeSync_safe_amd64_match_len_ofs_ok
+	TESTQ AX, AX
+	JNZ   sequenceDecs_decodeSync_safe_amd64_error_match_len_ofs_mismatch
+
+sequenceDecs_decodeSync_safe_amd64_match_len_ofs_ok:
+	MOVQ 24(SP), AX
+	MOVQ 8(SP), CX
+	MOVQ 16(SP), R13
+
+	// Check if we have enough space in s.out
+	LEAQ (AX)(R13*1), R14
+	ADDQ R10, R14
+	CMPQ R14, 32(SP)
+	JA   error_not_enough_space
+
+	// Copy literals
+	TESTQ AX, AX
+	JZ    check_offset
+	MOVQ  AX, R14
+	SUBQ  $0x10, R14
+	JB    copy_1_small
+
+copy_1_loop:
+	MOVUPS (R11), X0
+	MOVUPS X0, (R10)
+	ADDQ   $0x10, R11
+	ADDQ   $0x10, R10
+	SUBQ   $0x10, R14
+	JAE    copy_1_loop
+	LEAQ   16(R11)(R14*1), R11
+	LEAQ   16(R10)(R14*1), R10
+	MOVUPS -16(R11), X0
+	MOVUPS X0, -16(R10)
+	JMP    copy_1_end
+
+copy_1_small:
+	CMPQ AX, $0x03
+	JE   copy_1_move_3
+	JB   copy_1_move_1or2
+	CMPQ AX, $0x08
+	JB   copy_1_move_4through7
+	JMP  copy_1_move_8through16
+
+copy_1_move_1or2:
+	MOVB (R11), R14
+	MOVB -1(R11)(AX*1), R15
+	MOVB R14, (R10)
+	MOVB R15, -1(R10)(AX*1)
+	ADDQ AX, R11
+	ADDQ AX, R10
+	JMP  copy_1_end
+
+copy_1_move_3:
+	MOVW (R11), R14
+	MOVB 2(R11), R15
+	MOVW R14, (R10)
+	MOVB R15, 2(R10)
+	ADDQ AX, R11
+	ADDQ AX, R10
+	JMP  copy_1_end
+
+copy_1_move_4through7:
+	MOVL (R11), R14
+	MOVL -4(R11)(AX*1), R15
+	MOVL R14, (R10)
+	MOVL R15, -4(R10)(AX*1)
+	ADDQ AX, R11
+	ADDQ AX, R10
+	JMP  copy_1_end
+
+copy_1_move_8through16:
+	MOVQ (R11), R14
+	MOVQ -8(R11)(AX*1), R15
+	MOVQ R14, (R10)
+	MOVQ R15, -8(R10)(AX*1)
+	ADDQ AX, R11
+	ADDQ AX, R10
+
+copy_1_end:
+	ADDQ AX, R12
+
+	// Malformed input if seq.mo > t+len(hist) || seq.mo > s.windowSize)
+check_offset:
+	MOVQ R12, AX
+	ADDQ 40(SP), AX
+	CMPQ CX, AX
+	JG   error_match_off_too_big
+	CMPQ CX, 56(SP)
+	JG   error_match_off_too_big
+
+	// Copy match from history
+	MOVQ CX, AX
+	SUBQ R12, AX
+	JLS  copy_match
+	MOVQ 48(SP), R14
+	SUBQ AX, R14
+	CMPQ R13, AX
+	JG   copy_all_from_history
+	MOVQ R13, AX
+	SUBQ $0x10, AX
+	JB   copy_4_small
+
+copy_4_loop:
+	MOVUPS (R14), X0
+	MOVUPS X0, (R10)
+	ADDQ   $0x10, R14
+	ADDQ   $0x10, R10
+	SUBQ   $0x10, AX
+	JAE    copy_4_loop
+	LEAQ   16(R14)(AX*1), R14
+	LEAQ   16(R10)(AX*1), R10
+	MOVUPS -16(R14), X0
+	MOVUPS X0, -16(R10)
+	JMP    copy_4_end
+
+copy_4_small:
+	CMPQ R13, $0x03
+	JE   copy_4_move_3
+	CMPQ R13, $0x08
+	JB   copy_4_move_4through7
+	JMP  copy_4_move_8through16
+
+copy_4_move_3:
+	MOVW (R14), AX
+	MOVB 2(R14), CL
+	MOVW AX, (R10)
+	MOVB CL, 2(R10)
+	ADDQ R13, R14
+	ADDQ R13, R10
+	JMP  copy_4_end
+
+copy_4_move_4through7:
+	MOVL (R14), AX
+	MOVL -4(R14)(R13*1), CX
+	MOVL AX, (R10)
+	MOVL CX, -4(R10)(R13*1)
+	ADDQ R13, R14
+	ADDQ R13, R10
+	JMP  copy_4_end
+
+copy_4_move_8through16:
+	MOVQ (R14), AX
+	MOVQ -8(R14)(R13*1), CX
+	MOVQ AX, (R10)
+	MOVQ CX, -8(R10)(R13*1)
+	ADDQ R13, R14
+	ADDQ R13, R10
+
+copy_4_end:
+	ADDQ R13, R12
+	JMP  handle_loop
+	JMP loop_finished
+
+copy_all_from_history:
+	MOVQ AX, R15
+	SUBQ $0x10, R15
+	JB   copy_5_small
+
+copy_5_loop:
+	MOVUPS (R14), X0
+	MOVUPS X0, (R10)
+	ADDQ   $0x10, R14
+	ADDQ   $0x10, R10
+	SUBQ   $0x10, R15
+	JAE    copy_5_loop
+	LEAQ   16(R14)(R15*1), R14
+	LEAQ   16(R10)(R15*1), R10
+	MOVUPS -16(R14), X0
+	MOVUPS X0, -16(R10)
+	JMP    copy_5_end
+
+copy_5_small:
+	CMPQ AX, $0x03
+	JE   copy_5_move_3
+	JB   copy_5_move_1or2
+	CMPQ AX, $0x08
+	JB   copy_5_move_4through7
+	JMP  copy_5_move_8through16
+
+copy_5_move_1or2:
+	MOVB (R14), R15
+	MOVB -1(R14)(AX*1), BP
+	MOVB R15, (R10)
+	MOVB BP, -1(R10)(AX*1)
+	ADDQ AX, R14
+	ADDQ AX, R10
+	JMP  copy_5_end
+
+copy_5_move_3:
+	MOVW (R14), R15
+	MOVB 2(R14), BP
+	MOVW R15, (R10)
+	MOVB BP, 2(R10)
+	ADDQ AX, R14
+	ADDQ AX, R10
+	JMP  copy_5_end
+
+copy_5_move_4through7:
+	MOVL (R14), R15
+	MOVL -4(R14)(AX*1), BP
+	MOVL R15, (R10)
+	MOVL BP, -4(R10)(AX*1)
+	ADDQ AX, R14
+	ADDQ AX, R10
+	JMP  copy_5_end
+
+copy_5_move_8through16:
+	MOVQ (R14), R15
+	MOVQ -8(R14)(AX*1), BP
+	MOVQ R15, (R10)
+	MOVQ BP, -8(R10)(AX*1)
+	ADDQ AX, R14
+	ADDQ AX, R10
+
+copy_5_end:
+	ADDQ AX, R12
+	SUBQ AX, R13
+
+	// Copy match from the current buffer
+copy_match:
+	MOVQ R10, AX
+	SUBQ CX, AX
+
+	// ml <= mo
+	CMPQ R13, CX
+	JA   copy_overlapping_match
+
+	// Copy non-overlapping match
+	ADDQ R13, R12
+	MOVQ R13, CX
+	SUBQ $0x10, CX
+	JB   copy_2_small
+
+copy_2_loop:
+	MOVUPS (AX), X0
+	MOVUPS X0, (R10)
+	ADDQ   $0x10, AX
+	ADDQ   $0x10, R10
+	SUBQ   $0x10, CX
+	JAE    copy_2_loop
+	LEAQ   16(AX)(CX*1), AX
+	LEAQ   16(R10)(CX*1), R10
+	MOVUPS -16(AX), X0
+	MOVUPS X0, -16(R10)
+	JMP    copy_2_end
+
+copy_2_small:
+	CMPQ R13, $0x03
+	JE   copy_2_move_3
+	JB   copy_2_move_1or2
+	CMPQ R13, $0x08
+	JB   copy_2_move_4through7
+	JMP  copy_2_move_8through16
+
+copy_2_move_1or2:
+	MOVB (AX), CL
+	MOVB -1(AX)(R13*1), R14
+	MOVB CL, (R10)
+	MOVB R14, -1(R10)(R13*1)
+	ADDQ R13, AX
+	ADDQ R13, R10
+	JMP  copy_2_end
+
+copy_2_move_3:
+	MOVW (AX), CX
+	MOVB 2(AX), R14
+	MOVW CX, (R10)
+	MOVB R14, 2(R10)
+	ADDQ R13, AX
+	ADDQ R13, R10
+	JMP  copy_2_end
+
+copy_2_move_4through7:
+	MOVL (AX), CX
+	MOVL -4(AX)(R13*1), R14
+	MOVL CX, (R10)
+	MOVL R14, -4(R10)(R13*1)
+	ADDQ R13, AX
+	ADDQ R13, R10
+	JMP  copy_2_end
+
+copy_2_move_8through16:
+	MOVQ (AX), CX
+	MOVQ -8(AX)(R13*1), R14
+	MOVQ CX, (R10)
+	MOVQ R14, -8(R10)(R13*1)
+	ADDQ R13, AX
+	ADDQ R13, R10
+
+copy_2_end:
+	JMP handle_loop
+
+	// Copy overlapping match
+copy_overlapping_match:
+	ADDQ R13, R12
+
+copy_slow_3:
+	MOVB (AX), CL
+	MOVB CL, (R10)
+	INCQ AX
+	INCQ R10
+	DECQ R13
+	JNZ  copy_slow_3
+
+handle_loop:
+	MOVQ ctx+16(FP), AX
+	DECQ 96(AX)
+	JNS  sequenceDecs_decodeSync_safe_amd64_main_loop
+
+loop_finished:
+	MOVQ br+8(FP), AX
+	MOVQ DX, 32(AX)
+	MOVB BL, 40(AX)
+	MOVQ SI, 24(AX)
+
+	// Update the context
+	MOVQ ctx+16(FP), AX
+	MOVQ R12, 136(AX)
+	MOVQ 144(AX), CX
+	SUBQ CX, R11
+	MOVQ R11, 168(AX)
+
+	// Return success
+	MOVQ $0x00000000, ret+24(FP)
+	RET
+
+	// Return with match length error
+sequenceDecs_decodeSync_safe_amd64_error_match_len_ofs_mismatch:
+	MOVQ 16(SP), AX
+	MOVQ ctx+16(FP), CX
+	MOVQ AX, 216(CX)
+	MOVQ $0x00000001, ret+24(FP)
+	RET
+
+	// Return with match too long error
+sequenceDecs_decodeSync_safe_amd64_error_match_len_too_big:
+	MOVQ ctx+16(FP), AX
+	MOVQ 16(SP), CX
+	MOVQ CX, 216(AX)
+	MOVQ $0x00000002, ret+24(FP)
+	RET
+
+	// Return with match offset too long error
+error_match_off_too_big:
+	MOVQ ctx+16(FP), AX
+	MOVQ 8(SP), CX
+	MOVQ CX, 224(AX)
+	MOVQ R12, 136(AX)
+	MOVQ $0x00000003, ret+24(FP)
+	RET
+
+	// Return with not enough literals error
+error_not_enough_literals:
+	MOVQ ctx+16(FP), AX
+	MOVQ 24(SP), CX
+	MOVQ CX, 208(AX)
+	MOVQ $0x00000004, ret+24(FP)
+	RET
+
+	// Return with overread error
+error_overread:
+	MOVQ $0x00000006, ret+24(FP)
+	RET
+
+	// Return with not enough output space error
+error_not_enough_space:
+	MOVQ ctx+16(FP), AX
+	MOVQ 24(SP), CX
+	MOVQ CX, 208(AX)
+	MOVQ 16(SP), CX
+	MOVQ CX, 216(AX)
+	MOVQ R12, 136(AX)
+	MOVQ $0x00000005, ret+24(FP)
+	RET
+
+// func sequenceDecs_decodeSync_safe_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
+// Requires: BMI, BMI2, CMOV, SSE
+TEXT ·sequenceDecs_decodeSync_safe_bmi2(SB), $64-32
+	MOVQ    br+8(FP), CX
+	MOVQ    32(CX), AX
+	MOVBQZX 40(CX), DX
+	MOVQ    24(CX), BX
+	MOVQ    (CX), CX
+	ADDQ    BX, CX
+	MOVQ    CX, (SP)
+	MOVQ    ctx+16(FP), CX
+	MOVQ    72(CX), SI
+	MOVQ    80(CX), DI
+	MOVQ    88(CX), R8
+	XORQ    R9, R9
+	MOVQ    R9, 8(SP)
+	MOVQ    R9, 16(SP)
+	MOVQ    R9, 24(SP)
+	MOVQ    112(CX), R9
+	MOVQ    128(CX), R10
+	MOVQ    R10, 32(SP)
+	MOVQ    144(CX), R10
+	MOVQ    136(CX), R11
+	MOVQ    200(CX), R12
+	MOVQ    R12, 56(SP)
+	MOVQ    176(CX), R12
+	MOVQ    R12, 48(SP)
+	MOVQ    184(CX), CX
+	MOVQ    CX, 40(SP)
+	MOVQ    40(SP), CX
+	ADDQ    CX, 48(SP)
+
+	// Calculate poiter to s.out[cap(s.out)] (a past-end pointer)
+	ADDQ R9, 32(SP)
+
+	// outBase += outPosition
+	ADDQ R11, R9
+
+sequenceDecs_decodeSync_safe_bmi2_main_loop:
+	MOVQ (SP), R12
+
+	// Fill bitreader to have enough for the offset and match length.
+	CMPQ BX, $0x08
+	JL   sequenceDecs_decodeSync_safe_bmi2_fill_byte_by_byte
+	MOVQ DX, CX
+	SHRQ $0x03, CX
+	SUBQ CX, R12
+	MOVQ (R12), AX
+	SUBQ CX, BX
+	ANDQ $0x07, DX
+	JMP  sequenceDecs_decodeSync_safe_bmi2_fill_end
+
+sequenceDecs_decodeSync_safe_bmi2_fill_byte_by_byte:
+	CMPQ    BX, $0x00
+	JLE     sequenceDecs_decodeSync_safe_bmi2_fill_check_overread
+	CMPQ    DX, $0x07
+	JLE     sequenceDecs_decodeSync_safe_bmi2_fill_end
+	SHLQ    $0x08, AX
+	SUBQ    $0x01, R12
+	SUBQ    $0x01, BX
+	SUBQ    $0x08, DX
+	MOVBQZX (R12), CX
+	ORQ     CX, AX
+	JMP     sequenceDecs_decodeSync_safe_bmi2_fill_byte_by_byte
+
+sequenceDecs_decodeSync_safe_bmi2_fill_check_overread:
+	CMPQ DX, $0x40
+	JA   error_overread
+
+sequenceDecs_decodeSync_safe_bmi2_fill_end:
+	// Update offset
+	MOVQ   $0x00000808, CX
+	BEXTRQ CX, R8, R13
+	MOVQ   AX, R14
+	LEAQ   (DX)(R13*1), CX
+	ROLQ   CL, R14
+	BZHIQ  R13, R14, R14
+	MOVQ   CX, DX
+	MOVQ   R8, CX
+	SHRQ   $0x20, CX
+	ADDQ   R14, CX
+	MOVQ   CX, 8(SP)
+
+	// Update match length
+	MOVQ   $0x00000808, CX
+	BEXTRQ CX, DI, R13
+	MOVQ   AX, R14
+	LEAQ   (DX)(R13*1), CX
+	ROLQ   CL, R14
+	BZHIQ  R13, R14, R14
+	MOVQ   CX, DX
+	MOVQ   DI, CX
+	SHRQ   $0x20, CX
+	ADDQ   R14, CX
+	MOVQ   CX, 16(SP)
+
+	// Fill bitreader to have enough for the remaining
+	CMPQ BX, $0x08
+	JL   sequenceDecs_decodeSync_safe_bmi2_fill_2_byte_by_byte
+	MOVQ DX, CX
+	SHRQ $0x03, CX
+	SUBQ CX, R12
+	MOVQ (R12), AX
+	SUBQ CX, BX
+	ANDQ $0x07, DX
+	JMP  sequenceDecs_decodeSync_safe_bmi2_fill_2_end
+
+sequenceDecs_decodeSync_safe_bmi2_fill_2_byte_by_byte:
+	CMPQ    BX, $0x00
+	JLE     sequenceDecs_decodeSync_safe_bmi2_fill_2_check_overread
+	CMPQ    DX, $0x07
+	JLE     sequenceDecs_decodeSync_safe_bmi2_fill_2_end
+	SHLQ    $0x08, AX
+	SUBQ    $0x01, R12
+	SUBQ    $0x01, BX
+	SUBQ    $0x08, DX
+	MOVBQZX (R12), CX
+	ORQ     CX, AX
+	JMP     sequenceDecs_decodeSync_safe_bmi2_fill_2_byte_by_byte
+
+sequenceDecs_decodeSync_safe_bmi2_fill_2_check_overread:
+	CMPQ DX, $0x40
+	JA   error_overread
+
+sequenceDecs_decodeSync_safe_bmi2_fill_2_end:
+	// Update literal length
+	MOVQ   $0x00000808, CX
+	BEXTRQ CX, SI, R13
+	MOVQ   AX, R14
+	LEAQ   (DX)(R13*1), CX
+	ROLQ   CL, R14
+	BZHIQ  R13, R14, R14
+	MOVQ   CX, DX
+	MOVQ   SI, CX
+	SHRQ   $0x20, CX
+	ADDQ   R14, CX
+	MOVQ   CX, 24(SP)
+
+	// Fill bitreader for state updates
+	MOVQ    R12, (SP)
+	MOVQ    $0x00000808, CX
+	BEXTRQ  CX, R8, R12
+	MOVQ    ctx+16(FP), CX
+	CMPQ    96(CX), $0x00
+	JZ      sequenceDecs_decodeSync_safe_bmi2_skip_update
+	LEAQ    (SI)(DI*1), R13
+	ADDQ    R8, R13
+	MOVBQZX R13, R13
+	LEAQ    (DX)(R13*1), CX
+	MOVQ    AX, R14
+	MOVQ    CX, DX
+	ROLQ    CL, R14
+	BZHIQ   R13, R14, R14
+
+	// Update Offset State
+	BZHIQ  R8, R14, CX
+	SHRXQ  R8, R14, R14
+	MOVQ   $0x00001010, R13
+	BEXTRQ R13, R8, R8
+	ADDQ   CX, R8
+
+	// Load ctx.ofTable
+	MOVQ ctx+16(FP), CX
+	MOVQ 48(CX), CX
+	MOVQ (CX)(R8*8), R8
+
+	// Update Match Length State
+	BZHIQ  DI, R14, CX
+	SHRXQ  DI, R14, R14
+	MOVQ   $0x00001010, R13
+	BEXTRQ R13, DI, DI
+	ADDQ   CX, DI
+
+	// Load ctx.mlTable
+	MOVQ ctx+16(FP), CX
+	MOVQ 24(CX), CX
+	MOVQ (CX)(DI*8), DI
+
+	// Update Literal Length State
+	BZHIQ  SI, R14, CX
+	MOVQ   $0x00001010, R13
+	BEXTRQ R13, SI, SI
+	ADDQ   CX, SI
+
+	// Load ctx.llTable
+	MOVQ ctx+16(FP), CX
+	MOVQ (CX), CX
+	MOVQ (CX)(SI*8), SI
+
+sequenceDecs_decodeSync_safe_bmi2_skip_update:
+	// Adjust offset
+	MOVQ   s+0(FP), CX
+	MOVQ   8(SP), R13
+	CMPQ   R12, $0x01
+	JBE    sequenceDecs_decodeSync_safe_bmi2_adjust_offsetB_1_or_0
+	MOVUPS 144(CX), X0
+	MOVQ   R13, 144(CX)
+	MOVUPS X0, 152(CX)
+	JMP    sequenceDecs_decodeSync_safe_bmi2_after_adjust
+
+sequenceDecs_decodeSync_safe_bmi2_adjust_offsetB_1_or_0:
+	CMPQ 24(SP), $0x00000000
+	JNE  sequenceDecs_decodeSync_safe_bmi2_adjust_offset_maybezero
+	INCQ R13
+	JMP  sequenceDecs_decodeSync_safe_bmi2_adjust_offset_nonzero
+
+sequenceDecs_decodeSync_safe_bmi2_adjust_offset_maybezero:
+	TESTQ R13, R13
+	JNZ   sequenceDecs_decodeSync_safe_bmi2_adjust_offset_nonzero
+	MOVQ  144(CX), R13
+	JMP   sequenceDecs_decodeSync_safe_bmi2_after_adjust
+
+sequenceDecs_decodeSync_safe_bmi2_adjust_offset_nonzero:
+	MOVQ    R13, R12
+	XORQ    R14, R14
+	MOVQ    $-1, R15
+	CMPQ    R13, $0x03
+	CMOVQEQ R14, R12
+	CMOVQEQ R15, R14
+	ADDQ    144(CX)(R12*8), R14
+	JNZ     sequenceDecs_decodeSync_safe_bmi2_adjust_temp_valid
+	MOVQ    $0x00000001, R14
+
+sequenceDecs_decodeSync_safe_bmi2_adjust_temp_valid:
+	CMPQ R13, $0x01
+	JZ   sequenceDecs_decodeSync_safe_bmi2_adjust_skip
+	MOVQ 152(CX), R12
+	MOVQ R12, 160(CX)
+
+sequenceDecs_decodeSync_safe_bmi2_adjust_skip:
+	MOVQ 144(CX), R12
+	MOVQ R12, 152(CX)
+	MOVQ R14, 144(CX)
+	MOVQ R14, R13
+
+sequenceDecs_decodeSync_safe_bmi2_after_adjust:
+	MOVQ R13, 8(SP)
+
+	// Check values
+	MOVQ  16(SP), CX
+	MOVQ  24(SP), R12
+	LEAQ  (CX)(R12*1), R14
+	MOVQ  s+0(FP), R15
+	ADDQ  R14, 256(R15)
+	MOVQ  ctx+16(FP), R14
+	SUBQ  R12, 104(R14)
+	JS    error_not_enough_literals
+	CMPQ  CX, $0x00020002
+	JA    sequenceDecs_decodeSync_safe_bmi2_error_match_len_too_big
+	TESTQ R13, R13
+	JNZ   sequenceDecs_decodeSync_safe_bmi2_match_len_ofs_ok
+	TESTQ CX, CX
+	JNZ   sequenceDecs_decodeSync_safe_bmi2_error_match_len_ofs_mismatch
+
+sequenceDecs_decodeSync_safe_bmi2_match_len_ofs_ok:
+	MOVQ 24(SP), CX
+	MOVQ 8(SP), R12
+	MOVQ 16(SP), R13
+
+	// Check if we have enough space in s.out
+	LEAQ (CX)(R13*1), R14
+	ADDQ R9, R14
+	CMPQ R14, 32(SP)
+	JA   error_not_enough_space
+
+	// Copy literals
+	TESTQ CX, CX
+	JZ    check_offset
+	MOVQ  CX, R14
+	SUBQ  $0x10, R14
+	JB    copy_1_small
+
+copy_1_loop:
+	MOVUPS (R10), X0
+	MOVUPS X0, (R9)
+	ADDQ   $0x10, R10
+	ADDQ   $0x10, R9
+	SUBQ   $0x10, R14
+	JAE    copy_1_loop
+	LEAQ   16(R10)(R14*1), R10
+	LEAQ   16(R9)(R14*1), R9
+	MOVUPS -16(R10), X0
+	MOVUPS X0, -16(R9)
+	JMP    copy_1_end
+
+copy_1_small:
+	CMPQ CX, $0x03
+	JE   copy_1_move_3
+	JB   copy_1_move_1or2
+	CMPQ CX, $0x08
+	JB   copy_1_move_4through7
+	JMP  copy_1_move_8through16
+
+copy_1_move_1or2:
+	MOVB (R10), R14
+	MOVB -1(R10)(CX*1), R15
+	MOVB R14, (R9)
+	MOVB R15, -1(R9)(CX*1)
+	ADDQ CX, R10
+	ADDQ CX, R9
+	JMP  copy_1_end
+
+copy_1_move_3:
+	MOVW (R10), R14
+	MOVB 2(R10), R15
+	MOVW R14, (R9)
+	MOVB R15, 2(R9)
+	ADDQ CX, R10
+	ADDQ CX, R9
+	JMP  copy_1_end
+
+copy_1_move_4through7:
+	MOVL (R10), R14
+	MOVL -4(R10)(CX*1), R15
+	MOVL R14, (R9)
+	MOVL R15, -4(R9)(CX*1)
+	ADDQ CX, R10
+	ADDQ CX, R9
+	JMP  copy_1_end
+
+copy_1_move_8through16:
+	MOVQ (R10), R14
+	MOVQ -8(R10)(CX*1), R15
+	MOVQ R14, (R9)
+	MOVQ R15, -8(R9)(CX*1)
+	ADDQ CX, R10
+	ADDQ CX, R9
+
+copy_1_end:
+	ADDQ CX, R11
+
+	// Malformed input if seq.mo > t+len(hist) || seq.mo > s.windowSize)
+check_offset:
+	MOVQ R11, CX
+	ADDQ 40(SP), CX
+	CMPQ R12, CX
+	JG   error_match_off_too_big
+	CMPQ R12, 56(SP)
+	JG   error_match_off_too_big
+
+	// Copy match from history
+	MOVQ R12, CX
+	SUBQ R11, CX
+	JLS  copy_match
+	MOVQ 48(SP), R14
+	SUBQ CX, R14
+	CMPQ R13, CX
+	JG   copy_all_from_history
+	MOVQ R13, CX
+	SUBQ $0x10, CX
+	JB   copy_4_small
+
+copy_4_loop:
+	MOVUPS (R14), X0
+	MOVUPS X0, (R9)
+	ADDQ   $0x10, R14
+	ADDQ   $0x10, R9
+	SUBQ   $0x10, CX
+	JAE    copy_4_loop
+	LEAQ   16(R14)(CX*1), R14
+	LEAQ   16(R9)(CX*1), R9
+	MOVUPS -16(R14), X0
+	MOVUPS X0, -16(R9)
+	JMP    copy_4_end
+
+copy_4_small:
+	CMPQ R13, $0x03
+	JE   copy_4_move_3
+	CMPQ R13, $0x08
+	JB   copy_4_move_4through7
+	JMP  copy_4_move_8through16
+
+copy_4_move_3:
+	MOVW (R14), CX
+	MOVB 2(R14), R12
+	MOVW CX, (R9)
+	MOVB R12, 2(R9)
+	ADDQ R13, R14
+	ADDQ R13, R9
+	JMP  copy_4_end
+
+copy_4_move_4through7:
+	MOVL (R14), CX
+	MOVL -4(R14)(R13*1), R12
+	MOVL CX, (R9)
+	MOVL R12, -4(R9)(R13*1)
+	ADDQ R13, R14
+	ADDQ R13, R9
+	JMP  copy_4_end
+
+copy_4_move_8through16:
+	MOVQ (R14), CX
+	MOVQ -8(R14)(R13*1), R12
+	MOVQ CX, (R9)
+	MOVQ R12, -8(R9)(R13*1)
+	ADDQ R13, R14
+	ADDQ R13, R9
+
+copy_4_end:
+	ADDQ R13, R11
+	JMP  handle_loop
+	JMP loop_finished
+
+copy_all_from_history:
+	MOVQ CX, R15
+	SUBQ $0x10, R15
+	JB   copy_5_small
+
+copy_5_loop:
+	MOVUPS (R14), X0
+	MOVUPS X0, (R9)
+	ADDQ   $0x10, R14
+	ADDQ   $0x10, R9
+	SUBQ   $0x10, R15
+	JAE    copy_5_loop
+	LEAQ   16(R14)(R15*1), R14
+	LEAQ   16(R9)(R15*1), R9
+	MOVUPS -16(R14), X0
+	MOVUPS X0, -16(R9)
+	JMP    copy_5_end
+
+copy_5_small:
+	CMPQ CX, $0x03
+	JE   copy_5_move_3
+	JB   copy_5_move_1or2
+	CMPQ CX, $0x08
+	JB   copy_5_move_4through7
+	JMP  copy_5_move_8through16
+
+copy_5_move_1or2:
+	MOVB (R14), R15
+	MOVB -1(R14)(CX*1), BP
+	MOVB R15, (R9)
+	MOVB BP, -1(R9)(CX*1)
+	ADDQ CX, R14
+	ADDQ CX, R9
+	JMP  copy_5_end
+
+copy_5_move_3:
+	MOVW (R14), R15
+	MOVB 2(R14), BP
+	MOVW R15, (R9)
+	MOVB BP, 2(R9)
+	ADDQ CX, R14
+	ADDQ CX, R9
+	JMP  copy_5_end
+
+copy_5_move_4through7:
+	MOVL (R14), R15
+	MOVL -4(R14)(CX*1), BP
+	MOVL R15, (R9)
+	MOVL BP, -4(R9)(CX*1)
+	ADDQ CX, R14
+	ADDQ CX, R9
+	JMP  copy_5_end
+
+copy_5_move_8through16:
+	MOVQ (R14), R15
+	MOVQ -8(R14)(CX*1), BP
+	MOVQ R15, (R9)
+	MOVQ BP, -8(R9)(CX*1)
+	ADDQ CX, R14
+	ADDQ CX, R9
+
+copy_5_end:
+	ADDQ CX, R11
+	SUBQ CX, R13
+
+	// Copy match from the current buffer
+copy_match:
+	MOVQ R9, CX
+	SUBQ R12, CX
+
+	// ml <= mo
+	CMPQ R13, R12
+	JA   copy_overlapping_match
+
+	// Copy non-overlapping match
+	ADDQ R13, R11
+	MOVQ R13, R12
+	SUBQ $0x10, R12
+	JB   copy_2_small
+
+copy_2_loop:
+	MOVUPS (CX), X0
+	MOVUPS X0, (R9)
+	ADDQ   $0x10, CX
+	ADDQ   $0x10, R9
+	SUBQ   $0x10, R12
+	JAE    copy_2_loop
+	LEAQ   16(CX)(R12*1), CX
+	LEAQ   16(R9)(R12*1), R9
+	MOVUPS -16(CX), X0
+	MOVUPS X0, -16(R9)
+	JMP    copy_2_end
+
+copy_2_small:
+	CMPQ R13, $0x03
+	JE   copy_2_move_3
+	JB   copy_2_move_1or2
+	CMPQ R13, $0x08
+	JB   copy_2_move_4through7
+	JMP  copy_2_move_8through16
+
+copy_2_move_1or2:
+	MOVB (CX), R12
+	MOVB -1(CX)(R13*1), R14
+	MOVB R12, (R9)
+	MOVB R14, -1(R9)(R13*1)
+	ADDQ R13, CX
+	ADDQ R13, R9
+	JMP  copy_2_end
+
+copy_2_move_3:
+	MOVW (CX), R12
+	MOVB 2(CX), R14
+	MOVW R12, (R9)
+	MOVB R14, 2(R9)
+	ADDQ R13, CX
+	ADDQ R13, R9
+	JMP  copy_2_end
+
+copy_2_move_4through7:
+	MOVL (CX), R12
+	MOVL -4(CX)(R13*1), R14
+	MOVL R12, (R9)
+	MOVL R14, -4(R9)(R13*1)
+	ADDQ R13, CX
+	ADDQ R13, R9
+	JMP  copy_2_end
+
+copy_2_move_8through16:
+	MOVQ (CX), R12
+	MOVQ -8(CX)(R13*1), R14
+	MOVQ R12, (R9)
+	MOVQ R14, -8(R9)(R13*1)
+	ADDQ R13, CX
+	ADDQ R13, R9
+
+copy_2_end:
+	JMP handle_loop
+
+	// Copy overlapping match
+copy_overlapping_match:
+	ADDQ R13, R11
+
+copy_slow_3:
+	MOVB (CX), R12
+	MOVB R12, (R9)
+	INCQ CX
+	INCQ R9
+	DECQ R13
+	JNZ  copy_slow_3
+
+handle_loop:
+	MOVQ ctx+16(FP), CX
+	DECQ 96(CX)
+	JNS  sequenceDecs_decodeSync_safe_bmi2_main_loop
+
+loop_finished:
+	MOVQ br+8(FP), CX
+	MOVQ AX, 32(CX)
+	MOVB DL, 40(CX)
+	MOVQ BX, 24(CX)
+
+	// Update the context
+	MOVQ ctx+16(FP), AX
+	MOVQ R11, 136(AX)
+	MOVQ 144(AX), CX
+	SUBQ CX, R10
+	MOVQ R10, 168(AX)
+
+	// Return success
+	MOVQ $0x00000000, ret+24(FP)
+	RET
+
+	// Return with match length error
+sequenceDecs_decodeSync_safe_bmi2_error_match_len_ofs_mismatch:
+	MOVQ 16(SP), AX
+	MOVQ ctx+16(FP), CX
+	MOVQ AX, 216(CX)
+	MOVQ $0x00000001, ret+24(FP)
+	RET
+
+	// Return with match too long error
+sequenceDecs_decodeSync_safe_bmi2_error_match_len_too_big:
+	MOVQ ctx+16(FP), AX
+	MOVQ 16(SP), CX
+	MOVQ CX, 216(AX)
+	MOVQ $0x00000002, ret+24(FP)
+	RET
+
+	// Return with match offset too long error
+error_match_off_too_big:
+	MOVQ ctx+16(FP), AX
+	MOVQ 8(SP), CX
+	MOVQ CX, 224(AX)
+	MOVQ R11, 136(AX)
+	MOVQ $0x00000003, ret+24(FP)
+	RET
+
+	// Return with not enough literals error
+error_not_enough_literals:
+	MOVQ ctx+16(FP), AX
+	MOVQ 24(SP), CX
+	MOVQ CX, 208(AX)
+	MOVQ $0x00000004, ret+24(FP)
+	RET
+
+	// Return with overread error
+error_overread:
+	MOVQ $0x00000006, ret+24(FP)
+	RET
+
+	// Return with not enough output space error
+error_not_enough_space:
+	MOVQ ctx+16(FP), AX
+	MOVQ 24(SP), CX
+	MOVQ CX, 208(AX)
+	MOVQ 16(SP), CX
+	MOVQ CX, 216(AX)
+	MOVQ R11, 136(AX)
+	MOVQ $0x00000005, ret+24(FP)
+	RET
diff --git a/vendor/github.com/klauspost/compress/zstd/seqdec_generic.go b/vendor/github.com/klauspost/compress/zstd/seqdec_generic.go
new file mode 100644
index 00000000..ac2a80d2
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/zstd/seqdec_generic.go
@@ -0,0 +1,237 @@
+//go:build !amd64 || appengine || !gc || noasm
+// +build !amd64 appengine !gc noasm
+
+package zstd
+
+import (
+	"fmt"
+	"io"
+)
+
+// decode sequences from the stream with the provided history but without dictionary.
+func (s *sequenceDecs) decodeSyncSimple(hist []byte) (bool, error) {
+	return false, nil
+}
+
+// decode sequences from the stream without the provided history.
+func (s *sequenceDecs) decode(seqs []seqVals) error {
+	br := s.br
+
+	// Grab full sizes tables, to avoid bounds checks.
+	llTable, mlTable, ofTable := s.litLengths.fse.dt[:maxTablesize], s.matchLengths.fse.dt[:maxTablesize], s.offsets.fse.dt[:maxTablesize]
+	llState, mlState, ofState := s.litLengths.state.state, s.matchLengths.state.state, s.offsets.state.state
+	s.seqSize = 0
+	litRemain := len(s.literals)
+
+	maxBlockSize := maxCompressedBlockSize
+	if s.windowSize < maxBlockSize {
+		maxBlockSize = s.windowSize
+	}
+	for i := range seqs {
+		var ll, mo, ml int
+		if br.off > 4+((maxOffsetBits+16+16)>>3) {
+			// inlined function:
+			// ll, mo, ml = s.nextFast(br, llState, mlState, ofState)
+
+			// Final will not read from stream.
+			var llB, mlB, moB uint8
+			ll, llB = llState.final()
+			ml, mlB = mlState.final()
+			mo, moB = ofState.final()
+
+			// extra bits are stored in reverse order.
+			br.fillFast()
+			mo += br.getBits(moB)
+			if s.maxBits > 32 {
+				br.fillFast()
+			}
+			ml += br.getBits(mlB)
+			ll += br.getBits(llB)
+
+			if moB > 1 {
+				s.prevOffset[2] = s.prevOffset[1]
+				s.prevOffset[1] = s.prevOffset[0]
+				s.prevOffset[0] = mo
+			} else {
+				// mo = s.adjustOffset(mo, ll, moB)
+				// Inlined for rather big speedup
+				if ll == 0 {
+					// There is an exception though, when current sequence's literals_length = 0.
+					// In this case, repeated offsets are shifted by one, so an offset_value of 1 means Repeated_Offset2,
+					// an offset_value of 2 means Repeated_Offset3, and an offset_value of 3 means Repeated_Offset1 - 1_byte.
+					mo++
+				}
+
+				if mo == 0 {
+					mo = s.prevOffset[0]
+				} else {
+					var temp int
+					if mo == 3 {
+						temp = s.prevOffset[0] - 1
+					} else {
+						temp = s.prevOffset[mo]
+					}
+
+					if temp == 0 {
+						// 0 is not valid; input is corrupted; force offset to 1
+						println("WARNING: temp was 0")
+						temp = 1
+					}
+
+					if mo != 1 {
+						s.prevOffset[2] = s.prevOffset[1]
+					}
+					s.prevOffset[1] = s.prevOffset[0]
+					s.prevOffset[0] = temp
+					mo = temp
+				}
+			}
+			br.fillFast()
+		} else {
+			if br.overread() {
+				if debugDecoder {
+					printf("reading sequence %d, exceeded available data\n", i)
+				}
+				return io.ErrUnexpectedEOF
+			}
+			ll, mo, ml = s.next(br, llState, mlState, ofState)
+			br.fill()
+		}
+
+		if debugSequences {
+			println("Seq", i, "Litlen:", ll, "mo:", mo, "(abs) ml:", ml)
+		}
+		// Evaluate.
+		// We might be doing this async, so do it early.
+		if mo == 0 && ml > 0 {
+			return fmt.Errorf("zero matchoff and matchlen (%d) > 0", ml)
+		}
+		if ml > maxMatchLen {
+			return fmt.Errorf("match len (%d) bigger than max allowed length", ml)
+		}
+		s.seqSize += ll + ml
+		if s.seqSize > maxBlockSize {
+			return fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
+		}
+		litRemain -= ll
+		if litRemain < 0 {
+			return fmt.Errorf("unexpected literal count, want %d bytes, but only %d is available", ll, litRemain+ll)
+		}
+		seqs[i] = seqVals{
+			ll: ll,
+			ml: ml,
+			mo: mo,
+		}
+		if i == len(seqs)-1 {
+			// This is the last sequence, so we shouldn't update state.
+			break
+		}
+
+		// Manually inlined, ~ 5-20% faster
+		// Update all 3 states at once. Approx 20% faster.
+		nBits := llState.nbBits() + mlState.nbBits() + ofState.nbBits()
+		if nBits == 0 {
+			llState = llTable[llState.newState()&maxTableMask]
+			mlState = mlTable[mlState.newState()&maxTableMask]
+			ofState = ofTable[ofState.newState()&maxTableMask]
+		} else {
+			bits := br.get32BitsFast(nBits)
+			lowBits := uint16(bits >> ((ofState.nbBits() + mlState.nbBits()) & 31))
+			llState = llTable[(llState.newState()+lowBits)&maxTableMask]
+
+			lowBits = uint16(bits >> (ofState.nbBits() & 31))
+			lowBits &= bitMask[mlState.nbBits()&15]
+			mlState = mlTable[(mlState.newState()+lowBits)&maxTableMask]
+
+			lowBits = uint16(bits) & bitMask[ofState.nbBits()&15]
+			ofState = ofTable[(ofState.newState()+lowBits)&maxTableMask]
+		}
+	}
+	s.seqSize += litRemain
+	if s.seqSize > maxBlockSize {
+		return fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
+	}
+	err := br.close()
+	if err != nil {
+		printf("Closing sequences: %v, %+v\n", err, *br)
+	}
+	return err
+}
+
+// executeSimple handles cases when a dictionary is not used.
+func (s *sequenceDecs) executeSimple(seqs []seqVals, hist []byte) error {
+	// Ensure we have enough output size...
+	if len(s.out)+s.seqSize > cap(s.out) {
+		addBytes := s.seqSize + len(s.out)
+		s.out = append(s.out, make([]byte, addBytes)...)
+		s.out = s.out[:len(s.out)-addBytes]
+	}
+
+	if debugDecoder {
+		printf("Execute %d seqs with literals: %d into %d bytes\n", len(seqs), len(s.literals), s.seqSize)
+	}
+
+	var t = len(s.out)
+	out := s.out[:t+s.seqSize]
+
+	for _, seq := range seqs {
+		// Add literals
+		copy(out[t:], s.literals[:seq.ll])
+		t += seq.ll
+		s.literals = s.literals[seq.ll:]
+
+		// Malformed input
+		if seq.mo > t+len(hist) || seq.mo > s.windowSize {
+			return fmt.Errorf("match offset (%d) bigger than current history (%d)", seq.mo, t+len(hist))
+		}
+
+		// Copy from history.
+		if v := seq.mo - t; v > 0 {
+			// v is the start position in history from end.
+			start := len(hist) - v
+			if seq.ml > v {
+				// Some goes into the current block.
+				// Copy remainder of history
+				copy(out[t:], hist[start:])
+				t += v
+				seq.ml -= v
+			} else {
+				copy(out[t:], hist[start:start+seq.ml])
+				t += seq.ml
+				continue
+			}
+		}
+
+		// We must be in the current buffer now
+		if seq.ml > 0 {
+			start := t - seq.mo
+			if seq.ml <= t-start {
+				// No overlap
+				copy(out[t:], out[start:start+seq.ml])
+				t += seq.ml
+			} else {
+				// Overlapping copy
+				// Extend destination slice and copy one byte at the time.
+				src := out[start : start+seq.ml]
+				dst := out[t:]
+				dst = dst[:len(src)]
+				t += len(src)
+				// Destination is the space we just added.
+				for i := range src {
+					dst[i] = src[i]
+				}
+			}
+		}
+	}
+	// Add final literals
+	copy(out[t:], s.literals)
+	if debugDecoder {
+		t += len(s.literals)
+		if t != len(out) {
+			panic(fmt.Errorf("length mismatch, want %d, got %d, ss: %d", len(out), t, s.seqSize))
+		}
+	}
+	s.out = out
+
+	return nil
+}
diff --git a/vendor/github.com/klauspost/compress/zstd/zip.go b/vendor/github.com/klauspost/compress/zstd/zip.go
index 967f29b3..29c15c8c 100644
--- a/vendor/github.com/klauspost/compress/zstd/zip.go
+++ b/vendor/github.com/klauspost/compress/zstd/zip.go
@@ -18,36 +18,58 @@ const ZipMethodWinZip = 93
 // See https://pkware.cachefly.net/webdocs/APPNOTE/APPNOTE-6.3.9.TXT
 const ZipMethodPKWare = 20
 
-var zipReaderPool sync.Pool
+// zipReaderPool is the default reader pool.
+var zipReaderPool = sync.Pool{New: func() interface{} {
+	z, err := NewReader(nil, WithDecoderLowmem(true), WithDecoderMaxWindow(128<<20), WithDecoderConcurrency(1))
+	if err != nil {
+		panic(err)
+	}
+	return z
+}}
 
-// newZipReader cannot be used since we would leak goroutines...
-func newZipReader(r io.Reader) io.ReadCloser {
-	dec, ok := zipReaderPool.Get().(*Decoder)
-	if ok {
-		dec.Reset(r)
-	} else {
-		d, err := NewReader(r, WithDecoderConcurrency(1), WithDecoderLowmem(true))
-		if err != nil {
-			panic(err)
+// newZipReader creates a pooled zip decompressor.
+func newZipReader(opts ...DOption) func(r io.Reader) io.ReadCloser {
+	pool := &zipReaderPool
+	if len(opts) > 0 {
+		opts = append([]DOption{WithDecoderLowmem(true), WithDecoderMaxWindow(128 << 20)}, opts...)
+		// Force concurrency 1
+		opts = append(opts, WithDecoderConcurrency(1))
+		// Create our own pool
+		pool = &sync.Pool{}
+	}
+	return func(r io.Reader) io.ReadCloser {
+		dec, ok := pool.Get().(*Decoder)
+		if ok {
+			dec.Reset(r)
+		} else {
+			d, err := NewReader(r, opts...)
+			if err != nil {
+				panic(err)
+			}
+			dec = d
 		}
-		dec = d
+		return &pooledZipReader{dec: dec, pool: pool}
 	}
-	return &pooledZipReader{dec: dec}
 }
 
 type pooledZipReader struct {
-	mu  sync.Mutex // guards Close and Read
-	dec *Decoder
+	mu   sync.Mutex // guards Close and Read
+	pool *sync.Pool
+	dec  *Decoder
 }
 
 func (r *pooledZipReader) Read(p []byte) (n int, err error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	if r.dec == nil {
-		return 0, errors.New("Read after Close")
+		return 0, errors.New("read after close or EOF")
 	}
 	dec, err := r.dec.Read(p)
-
+	if err == io.EOF {
+		r.dec.Reset(nil)
+		r.pool.Put(r.dec)
+		r.dec = nil
+	}
 	return dec, err
 }
 
@@ -57,7 +79,7 @@ func (r *pooledZipReader) Close() error {
 	var err error
 	if r.dec != nil {
 		err = r.dec.Reset(nil)
-		zipReaderPool.Put(r.dec)
+		r.pool.Put(r.dec)
 		r.dec = nil
 	}
 	return err
@@ -111,12 +133,9 @@ func ZipCompressor(opts ...EOption) func(w io.Writer) (io.WriteCloser, error) {
 
 // ZipDecompressor returns a decompressor that can be registered with zip libraries.
 // See ZipCompressor for example.
-func ZipDecompressor() func(r io.Reader) io.ReadCloser {
-	return func(r io.Reader) io.ReadCloser {
-		d, err := NewReader(r, WithDecoderConcurrency(1), WithDecoderLowmem(true))
-		if err != nil {
-			panic(err)
-		}
-		return d.IOReadCloser()
-	}
+// Options can be specified. WithDecoderConcurrency(1) is forced,
+// and by default a 128MB maximum decompression window is specified.
+// The window size can be overridden if required.
+func ZipDecompressor(opts ...DOption) func(r io.Reader) io.ReadCloser {
+	return newZipReader(opts...)
 }
diff --git a/vendor/github.com/klauspost/compress/zstd/zstd.go b/vendor/github.com/klauspost/compress/zstd/zstd.go
index ef1d49a0..4be7cc73 100644
--- a/vendor/github.com/klauspost/compress/zstd/zstd.go
+++ b/vendor/github.com/klauspost/compress/zstd/zstd.go
@@ -9,7 +9,6 @@ import (
 	"errors"
 	"log"
 	"math"
-	"math/bits"
 )
 
 // enable debug printing
@@ -36,8 +35,8 @@ const forcePreDef = false
 // zstdMinMatch is the minimum zstd match length.
 const zstdMinMatch = 3
 
-// Reset the buffer offset when reaching this.
-const bufferReset = math.MaxInt32 - MaxWindowSize
+// fcsUnknown is used for unknown frame content size.
+const fcsUnknown = math.MaxUint64
 
 var (
 	// ErrReservedBlockType is returned when a reserved block type is found.
@@ -52,6 +51,10 @@ var (
 	// Typically returned on invalid input.
 	ErrBlockTooSmall = errors.New("block too small")
 
+	// ErrUnexpectedBlockSize is returned when a block has unexpected size.
+	// Typically returned on invalid input.
+	ErrUnexpectedBlockSize = errors.New("unexpected block size")
+
 	// ErrMagicMismatch is returned when a "magic" number isn't what is expected.
 	// Typically this indicates wrong or corrupted input.
 	ErrMagicMismatch = errors.New("invalid input: magic number mismatch")
@@ -68,13 +71,16 @@ var (
 	ErrDecoderSizeExceeded = errors.New("decompressed size exceeds configured limit")
 
 	// ErrUnknownDictionary is returned if the dictionary ID is unknown.
-	// For the time being dictionaries are not supported.
 	ErrUnknownDictionary = errors.New("unknown dictionary")
 
 	// ErrFrameSizeExceeded is returned if the stated frame size is exceeded.
 	// This is only returned if SingleSegment is specified on the frame.
 	ErrFrameSizeExceeded = errors.New("frame size exceeded")
 
+	// ErrFrameSizeMismatch is returned if the stated frame size does not match the expected size.
+	// This is only returned if SingleSegment is specified on the frame.
+	ErrFrameSizeMismatch = errors.New("frame size does not match size on stream")
+
 	// ErrCRCMismatch is returned if CRC mismatches.
 	ErrCRCMismatch = errors.New("CRC check failed")
 
@@ -99,49 +105,12 @@ func printf(format string, a ...interface{}) {
 	}
 }
 
-// matchLenFast does matching, but will not match the last up to 7 bytes.
-func matchLenFast(a, b []byte) int {
-	endI := len(a) & (math.MaxInt32 - 7)
-	for i := 0; i < endI; i += 8 {
-		if diff := load64(a, i) ^ load64(b, i); diff != 0 {
-			return i + bits.TrailingZeros64(diff)>>3
-		}
-	}
-	return endI
-}
-
-// matchLen returns the maximum length.
-// a must be the shortest of the two.
-// The function also returns whether all bytes matched.
-func matchLen(a, b []byte) int {
-	b = b[:len(a)]
-	for i := 0; i < len(a)-7; i += 8 {
-		if diff := load64(a, i) ^ load64(b, i); diff != 0 {
-			return i + (bits.TrailingZeros64(diff) >> 3)
-		}
-	}
-
-	checked := (len(a) >> 3) << 3
-	a = a[checked:]
-	b = b[checked:]
-	for i := range a {
-		if a[i] != b[i] {
-			return i + checked
-		}
-	}
-	return len(a) + checked
-}
-
 func load3232(b []byte, i int32) uint32 {
-	return binary.LittleEndian.Uint32(b[i:])
+	return binary.LittleEndian.Uint32(b[:len(b):len(b)][i:])
 }
 
 func load6432(b []byte, i int32) uint64 {
-	return binary.LittleEndian.Uint64(b[i:])
-}
-
-func load64(b []byte, i int) uint64 {
-	return binary.LittleEndian.Uint64(b[i:])
+	return binary.LittleEndian.Uint64(b[:len(b):len(b)][i:])
 }
 
 type byter interface {
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/LICENSE b/vendor/go.mongodb.org/mongo-driver/v2/LICENSE
new file mode 100644
index 00000000..261eeb9e
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/array_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/array_codec.go
new file mode 100644
index 00000000..4642fb6e
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/array_codec.go
@@ -0,0 +1,42 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"reflect"
+
+	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
+)
+
+// arrayCodec is the Codec used for bsoncore.Array values.
+type arrayCodec struct{}
+
+// EncodeValue is the ValueEncoder for bsoncore.Array values.
+func (ac *arrayCodec) EncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tCoreArray {
+		return ValueEncoderError{Name: "CoreArrayEncodeValue", Types: []reflect.Type{tCoreArray}, Received: val}
+	}
+
+	arr := val.Interface().(bsoncore.Array)
+	return copyArrayFromBytes(vw, arr)
+}
+
+// DecodeValue is the ValueDecoder for bsoncore.Array values.
+func (ac *arrayCodec) DecodeValue(_ DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tCoreArray {
+		return ValueDecoderError{Name: "CoreArrayDecodeValue", Types: []reflect.Type{tCoreArray}, Received: val}
+	}
+
+	if val.IsNil() {
+		val.Set(reflect.MakeSlice(val.Type(), 0, 0))
+	}
+
+	val.SetLen(0)
+	arr, err := appendArrayBytes(val.Interface().(bsoncore.Array), vr)
+	val.Set(reflect.ValueOf(arr))
+	return err
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/bsoncodec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/bsoncodec.go
new file mode 100644
index 00000000..91592a3e
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/bsoncodec.go
@@ -0,0 +1,203 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+var (
+	emptyValue = reflect.Value{}
+)
+
+// ValueEncoderError is an error returned from a ValueEncoder when the provided value can't be
+// encoded by the ValueEncoder.
+type ValueEncoderError struct {
+	Name     string
+	Types    []reflect.Type
+	Kinds    []reflect.Kind
+	Received reflect.Value
+}
+
+func (vee ValueEncoderError) Error() string {
+	typeKinds := make([]string, 0, len(vee.Types)+len(vee.Kinds))
+	for _, t := range vee.Types {
+		typeKinds = append(typeKinds, t.String())
+	}
+	for _, k := range vee.Kinds {
+		if k == reflect.Map {
+			typeKinds = append(typeKinds, "map[string]*")
+			continue
+		}
+		typeKinds = append(typeKinds, k.String())
+	}
+	received := vee.Received.Kind().String()
+	if vee.Received.IsValid() {
+		received = vee.Received.Type().String()
+	}
+	return fmt.Sprintf("%s can only encode valid %s, but got %s", vee.Name, strings.Join(typeKinds, ", "), received)
+}
+
+// ValueDecoderError is an error returned from a ValueDecoder when the provided value can't be
+// decoded by the ValueDecoder.
+type ValueDecoderError struct {
+	Name     string
+	Types    []reflect.Type
+	Kinds    []reflect.Kind
+	Received reflect.Value
+}
+
+func (vde ValueDecoderError) Error() string {
+	typeKinds := make([]string, 0, len(vde.Types)+len(vde.Kinds))
+	for _, t := range vde.Types {
+		typeKinds = append(typeKinds, t.String())
+	}
+	for _, k := range vde.Kinds {
+		if k == reflect.Map {
+			typeKinds = append(typeKinds, "map[string]*")
+			continue
+		}
+		typeKinds = append(typeKinds, k.String())
+	}
+	received := vde.Received.Kind().String()
+	if vde.Received.IsValid() {
+		received = vde.Received.Type().String()
+	}
+	if !vde.Received.CanSet() {
+		received = "unsettable " + received
+	}
+	return fmt.Sprintf("%s can only decode valid and settable %s, but got %s", vde.Name, strings.Join(typeKinds, ", "), received)
+}
+
+// EncodeContext is the contextual information required for a Codec to encode a
+// value.
+type EncodeContext struct {
+	*Registry
+
+	// minSize causes the Encoder to marshal Go integer values (int, int8, int16, int32, int64,
+	// uint, uint8, uint16, uint32, or uint64) as the minimum BSON int size (either 32 or 64 bits)
+	// that can represent the integer value.
+	minSize bool
+
+	errorOnInlineDuplicates bool
+	stringifyMapKeysWithFmt bool
+	nilMapAsEmpty           bool
+	nilSliceAsEmpty         bool
+	nilByteSliceAsEmpty     bool
+	omitZeroStruct          bool
+	omitEmpty               bool
+	useJSONStructTags       bool
+}
+
+// DecodeContext is the contextual information required for a Codec to decode a
+// value.
+type DecodeContext struct {
+	*Registry
+
+	// truncate, if true, instructs decoders to to truncate the fractional part of BSON "double"
+	// values when attempting to unmarshal them into a Go integer (int, int8, int16, int32, int64,
+	// uint, uint8, uint16, uint32, or uint64) struct field. The truncation logic does not apply to
+	// BSON "decimal128" values.
+	truncate bool
+
+	// defaultDocumentType specifies the Go type to decode top-level and nested BSON documents into. In particular, the
+	// usage for this field is restricted to data typed as "interface{}" or "map[string]interface{}". If DocumentType is
+	// set to a type that a BSON document cannot be unmarshaled into (e.g. "string"), unmarshalling will result in an
+	// error.
+	defaultDocumentType reflect.Type
+
+	binaryAsSlice bool
+
+	// a false value results in a decoding error.
+	objectIDAsHexString bool
+
+	useJSONStructTags bool
+	useLocalTimeZone  bool
+	zeroMaps          bool
+	zeroStructs       bool
+}
+
+// ValueEncoder is the interface implemented by types that can encode a provided Go type to BSON.
+// The value to encode is provided as a reflect.Value and a bson.ValueWriter is used within the
+// EncodeValue method to actually create the BSON representation. For convenience, ValueEncoderFunc
+// is provided to allow use of a function with the correct signature as a ValueEncoder. An
+// EncodeContext instance is provided to allow implementations to lookup further ValueEncoders and
+// to provide configuration information.
+type ValueEncoder interface {
+	EncodeValue(EncodeContext, ValueWriter, reflect.Value) error
+}
+
+// ValueEncoderFunc is an adapter function that allows a function with the correct signature to be
+// used as a ValueEncoder.
+type ValueEncoderFunc func(EncodeContext, ValueWriter, reflect.Value) error
+
+// EncodeValue implements the ValueEncoder interface.
+func (fn ValueEncoderFunc) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
+	return fn(ec, vw, val)
+}
+
+// ValueDecoder is the interface implemented by types that can decode BSON to a provided Go type.
+// Implementations should ensure that the value they receive is settable. Similar to ValueEncoderFunc,
+// ValueDecoderFunc is provided to allow the use of a function with the correct signature as a
+// ValueDecoder. A DecodeContext instance is provided and serves similar functionality to the
+// EncodeContext.
+type ValueDecoder interface {
+	DecodeValue(DecodeContext, ValueReader, reflect.Value) error
+}
+
+// ValueDecoderFunc is an adapter function that allows a function with the correct signature to be
+// used as a ValueDecoder.
+type ValueDecoderFunc func(DecodeContext, ValueReader, reflect.Value) error
+
+// DecodeValue implements the ValueDecoder interface.
+func (fn ValueDecoderFunc) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	return fn(dc, vr, val)
+}
+
+// typeDecoder is the interface implemented by types that can handle the decoding of a value given its type.
+type typeDecoder interface {
+	decodeType(DecodeContext, ValueReader, reflect.Type) (reflect.Value, error)
+}
+
+// typeDecoderFunc is an adapter function that allows a function with the correct signature to be used as a typeDecoder.
+type typeDecoderFunc func(DecodeContext, ValueReader, reflect.Type) (reflect.Value, error)
+
+func (fn typeDecoderFunc) decodeType(dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	return fn(dc, vr, t)
+}
+
+// decodeAdapter allows two functions with the correct signatures to be used as both a ValueDecoder and typeDecoder.
+type decodeAdapter struct {
+	ValueDecoderFunc
+	typeDecoderFunc
+}
+
+var _ ValueDecoder = decodeAdapter{}
+var _ typeDecoder = decodeAdapter{}
+
+func decodeTypeOrValueWithInfo(vd ValueDecoder, dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if td, _ := vd.(typeDecoder); td != nil {
+		val, err := td.decodeType(dc, vr, t)
+		if err == nil && val.Type() != t {
+			// This conversion step is necessary for slices and maps. If a user declares variables like:
+			//
+			// type myBool bool
+			// var m map[string]myBool
+			//
+			// and tries to decode BSON bytes into the map, the decoding will fail if this conversion is not present
+			// because we'll try to assign a value of type bool to one of type myBool.
+			val = val.Convert(t)
+		}
+		return val, err
+	}
+
+	val := reflect.New(t).Elem()
+	err := vd.DecodeValue(dc, vr, val)
+	return val, err
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/byte_slice_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/byte_slice_codec.go
new file mode 100644
index 00000000..bd44cf9a
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/byte_slice_codec.go
@@ -0,0 +1,97 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// byteSliceCodec is the Codec used for []byte values.
+type byteSliceCodec struct {
+	// encodeNilAsEmpty causes EncodeValue to marshal nil Go byte slices as empty BSON binary values
+	// instead of BSON null.
+	encodeNilAsEmpty bool
+}
+
+// Assert that byteSliceCodec satisfies the typeDecoder interface, which allows it to be
+// used by collection type decoders (e.g. map, slice, etc) to set individual values in a
+// collection.
+var _ typeDecoder = &byteSliceCodec{}
+
+// EncodeValue is the ValueEncoder for []byte.
+func (bsc *byteSliceCodec) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tByteSlice {
+		return ValueEncoderError{Name: "ByteSliceEncodeValue", Types: []reflect.Type{tByteSlice}, Received: val}
+	}
+	if val.IsNil() && !bsc.encodeNilAsEmpty && !ec.nilByteSliceAsEmpty {
+		return vw.WriteNull()
+	}
+	return vw.WriteBinary(val.Interface().([]byte))
+}
+
+func (bsc *byteSliceCodec) decodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tByteSlice {
+		return emptyValue, ValueDecoderError{
+			Name:     "ByteSliceDecodeValue",
+			Types:    []reflect.Type{tByteSlice},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	var data []byte
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeString:
+		str, err := vr.ReadString()
+		if err != nil {
+			return emptyValue, err
+		}
+		data = []byte(str)
+	case TypeSymbol:
+		sym, err := vr.ReadSymbol()
+		if err != nil {
+			return emptyValue, err
+		}
+		data = []byte(sym)
+	case TypeBinary:
+		var subtype byte
+		data, subtype, err = vr.ReadBinary()
+		if err != nil {
+			return emptyValue, err
+		}
+		if subtype != TypeBinaryGeneric && subtype != TypeBinaryBinaryOld {
+			return emptyValue, decodeBinaryError{subtype: subtype, typeName: "[]byte"}
+		}
+	case TypeNull:
+		err = vr.ReadNull()
+	case TypeUndefined:
+		err = vr.ReadUndefined()
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a []byte", vrType)
+	}
+	if err != nil {
+		return emptyValue, err
+	}
+
+	return reflect.ValueOf(data), nil
+}
+
+// DecodeValue is the ValueDecoder for []byte.
+func (bsc *byteSliceCodec) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tByteSlice {
+		return ValueDecoderError{Name: "ByteSliceDecodeValue", Types: []reflect.Type{tByteSlice}, Received: val}
+	}
+
+	elem, err := bsc.decodeType(dc, vr, tByteSlice)
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/codec_cache.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/codec_cache.go
new file mode 100644
index 00000000..b4042822
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/codec_cache.go
@@ -0,0 +1,166 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"reflect"
+	"sync"
+	"sync/atomic"
+)
+
+// Runtime check that the kind encoder and decoder caches can store any valid
+// reflect.Kind constant.
+func init() {
+	if s := reflect.Kind(len(kindEncoderCache{}.entries)).String(); s != "kind27" {
+		panic("The capacity of kindEncoderCache is too small.\n" +
+			"This is due to a new type being added to reflect.Kind.")
+	}
+}
+
+// statically assert array size
+var _ = (kindEncoderCache{}).entries[reflect.UnsafePointer]
+var _ = (kindDecoderCache{}).entries[reflect.UnsafePointer]
+
+type typeEncoderCache struct {
+	cache sync.Map // map[reflect.Type]ValueEncoder
+}
+
+func (c *typeEncoderCache) Store(rt reflect.Type, enc ValueEncoder) {
+	c.cache.Store(rt, enc)
+}
+
+func (c *typeEncoderCache) Load(rt reflect.Type) (ValueEncoder, bool) {
+	if v, _ := c.cache.Load(rt); v != nil {
+		return v.(ValueEncoder), true
+	}
+	return nil, false
+}
+
+func (c *typeEncoderCache) LoadOrStore(rt reflect.Type, enc ValueEncoder) ValueEncoder {
+	if v, loaded := c.cache.LoadOrStore(rt, enc); loaded {
+		enc = v.(ValueEncoder)
+	}
+	return enc
+}
+
+func (c *typeEncoderCache) Clone() *typeEncoderCache {
+	cc := new(typeEncoderCache)
+	c.cache.Range(func(k, v interface{}) bool {
+		if k != nil && v != nil {
+			cc.cache.Store(k, v)
+		}
+		return true
+	})
+	return cc
+}
+
+type typeDecoderCache struct {
+	cache sync.Map // map[reflect.Type]ValueDecoder
+}
+
+func (c *typeDecoderCache) Store(rt reflect.Type, dec ValueDecoder) {
+	c.cache.Store(rt, dec)
+}
+
+func (c *typeDecoderCache) Load(rt reflect.Type) (ValueDecoder, bool) {
+	if v, _ := c.cache.Load(rt); v != nil {
+		return v.(ValueDecoder), true
+	}
+	return nil, false
+}
+
+func (c *typeDecoderCache) LoadOrStore(rt reflect.Type, dec ValueDecoder) ValueDecoder {
+	if v, loaded := c.cache.LoadOrStore(rt, dec); loaded {
+		dec = v.(ValueDecoder)
+	}
+	return dec
+}
+
+func (c *typeDecoderCache) Clone() *typeDecoderCache {
+	cc := new(typeDecoderCache)
+	c.cache.Range(func(k, v interface{}) bool {
+		if k != nil && v != nil {
+			cc.cache.Store(k, v)
+		}
+		return true
+	})
+	return cc
+}
+
+// atomic.Value requires that all calls to Store() have the same concrete type
+// so we wrap the ValueEncoder with a kindEncoderCacheEntry to ensure the type
+// is always the same (since different concrete types may implement the
+// ValueEncoder interface).
+type kindEncoderCacheEntry struct {
+	enc ValueEncoder
+}
+
+type kindEncoderCache struct {
+	entries [reflect.UnsafePointer + 1]atomic.Value // *kindEncoderCacheEntry
+}
+
+func (c *kindEncoderCache) Store(rt reflect.Kind, enc ValueEncoder) {
+	if enc != nil && rt < reflect.Kind(len(c.entries)) {
+		c.entries[rt].Store(&kindEncoderCacheEntry{enc: enc})
+	}
+}
+
+func (c *kindEncoderCache) Load(rt reflect.Kind) (ValueEncoder, bool) {
+	if rt < reflect.Kind(len(c.entries)) {
+		if ent, ok := c.entries[rt].Load().(*kindEncoderCacheEntry); ok {
+			return ent.enc, ent.enc != nil
+		}
+	}
+	return nil, false
+}
+
+func (c *kindEncoderCache) Clone() *kindEncoderCache {
+	cc := new(kindEncoderCache)
+	for i, v := range c.entries {
+		if val := v.Load(); val != nil {
+			cc.entries[i].Store(val)
+		}
+	}
+	return cc
+}
+
+// atomic.Value requires that all calls to Store() have the same concrete type
+// so we wrap the ValueDecoder with a kindDecoderCacheEntry to ensure the type
+// is always the same (since different concrete types may implement the
+// ValueDecoder interface).
+type kindDecoderCacheEntry struct {
+	dec ValueDecoder
+}
+
+type kindDecoderCache struct {
+	entries [reflect.UnsafePointer + 1]atomic.Value // *kindDecoderCacheEntry
+}
+
+func (c *kindDecoderCache) Store(rt reflect.Kind, dec ValueDecoder) {
+	if rt < reflect.Kind(len(c.entries)) {
+		c.entries[rt].Store(&kindDecoderCacheEntry{dec: dec})
+	}
+}
+
+func (c *kindDecoderCache) Load(rt reflect.Kind) (ValueDecoder, bool) {
+	if rt < reflect.Kind(len(c.entries)) {
+		if ent, ok := c.entries[rt].Load().(*kindDecoderCacheEntry); ok {
+			return ent.dec, ent.dec != nil
+		}
+	}
+	return nil, false
+}
+
+func (c *kindDecoderCache) Clone() *kindDecoderCache {
+	cc := new(kindDecoderCache)
+	for i, v := range c.entries {
+		if val := v.Load(); val != nil {
+			cc.entries[i].Store(val)
+		}
+	}
+	return cc
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/cond_addr_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/cond_addr_codec.go
new file mode 100644
index 00000000..fed4d1f8
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/cond_addr_codec.go
@@ -0,0 +1,61 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"reflect"
+)
+
+// condAddrEncoder is the encoder used when a pointer to the encoding value has an encoder.
+type condAddrEncoder struct {
+	canAddrEnc ValueEncoder
+	elseEnc    ValueEncoder
+}
+
+var _ ValueEncoder = &condAddrEncoder{}
+
+// newCondAddrEncoder returns an condAddrEncoder.
+func newCondAddrEncoder(canAddrEnc, elseEnc ValueEncoder) *condAddrEncoder {
+	encoder := condAddrEncoder{canAddrEnc: canAddrEnc, elseEnc: elseEnc}
+	return &encoder
+}
+
+// EncodeValue is the ValueEncoderFunc for a value that may be addressable.
+func (cae *condAddrEncoder) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if val.CanAddr() {
+		return cae.canAddrEnc.EncodeValue(ec, vw, val)
+	}
+	if cae.elseEnc != nil {
+		return cae.elseEnc.EncodeValue(ec, vw, val)
+	}
+	return errNoEncoder{Type: val.Type()}
+}
+
+// condAddrDecoder is the decoder used when a pointer to the value has a decoder.
+type condAddrDecoder struct {
+	canAddrDec ValueDecoder
+	elseDec    ValueDecoder
+}
+
+var _ ValueDecoder = &condAddrDecoder{}
+
+// newCondAddrDecoder returns an CondAddrDecoder.
+func newCondAddrDecoder(canAddrDec, elseDec ValueDecoder) *condAddrDecoder {
+	decoder := condAddrDecoder{canAddrDec: canAddrDec, elseDec: elseDec}
+	return &decoder
+}
+
+// DecodeValue is the ValueDecoderFunc for a value that may be addressable.
+func (cad *condAddrDecoder) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if val.CanAddr() {
+		return cad.canAddrDec.DecodeValue(dc, vr, val)
+	}
+	if cad.elseDec != nil {
+		return cad.elseDec.DecodeValue(dc, vr, val)
+	}
+	return errNoDecoder{Type: val.Type()}
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/copier.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/copier.go
new file mode 100644
index 00000000..6279f072
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/copier.go
@@ -0,0 +1,431 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+
+	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
+)
+
+// copyDocument handles copying one document from the src to the dst.
+func copyDocument(dst ValueWriter, src ValueReader) error {
+	dr, err := src.ReadDocument()
+	if err != nil {
+		return err
+	}
+
+	dw, err := dst.WriteDocument()
+	if err != nil {
+		return err
+	}
+
+	return copyDocumentCore(dw, dr)
+}
+
+// copyArrayFromBytes copies the values from a BSON array represented as a
+// []byte to a ValueWriter.
+func copyArrayFromBytes(dst ValueWriter, src []byte) error {
+	aw, err := dst.WriteArray()
+	if err != nil {
+		return err
+	}
+
+	err = copyBytesToArrayWriter(aw, src)
+	if err != nil {
+		return err
+	}
+
+	return aw.WriteArrayEnd()
+}
+
+// copyDocumentFromBytes copies the values from a BSON document represented as a
+// []byte to a ValueWriter.
+func copyDocumentFromBytes(dst ValueWriter, src []byte) error {
+	dw, err := dst.WriteDocument()
+	if err != nil {
+		return err
+	}
+
+	err = copyBytesToDocumentWriter(dw, src)
+	if err != nil {
+		return err
+	}
+
+	return dw.WriteDocumentEnd()
+}
+
+type writeElementFn func(key string) (ValueWriter, error)
+
+// copyBytesToArrayWriter copies the values from a BSON Array represented as a []byte to an
+// ArrayWriter.
+func copyBytesToArrayWriter(dst ArrayWriter, src []byte) error {
+	wef := func(_ string) (ValueWriter, error) {
+		return dst.WriteArrayElement()
+	}
+
+	return copyBytesToValueWriter(src, wef)
+}
+
+// copyBytesToDocumentWriter copies the values from a BSON document represented as a []byte to a
+// DocumentWriter.
+func copyBytesToDocumentWriter(dst DocumentWriter, src []byte) error {
+	wef := func(key string) (ValueWriter, error) {
+		return dst.WriteDocumentElement(key)
+	}
+
+	return copyBytesToValueWriter(src, wef)
+}
+
+func copyBytesToValueWriter(src []byte, wef writeElementFn) error {
+	// TODO(skriptble): Create errors types here. Anything that is a tag should be a property.
+	length, rem, ok := bsoncore.ReadLength(src)
+	if !ok {
+		return fmt.Errorf("couldn't read length from src, not enough bytes. length=%d", len(src))
+	}
+	if len(src) < int(length) {
+		return fmt.Errorf("length read exceeds number of bytes available. length=%d bytes=%d", len(src), length)
+	}
+	rem = rem[:length-4]
+
+	var t bsoncore.Type
+	var key string
+	var val bsoncore.Value
+	for {
+		t, rem, ok = bsoncore.ReadType(rem)
+		if !ok {
+			return io.EOF
+		}
+		if t == bsoncore.Type(0) {
+			if len(rem) != 0 {
+				return fmt.Errorf("document end byte found before end of document. remaining bytes=%v", rem)
+			}
+			break
+		}
+
+		key, rem, ok = bsoncore.ReadKey(rem)
+		if !ok {
+			return fmt.Errorf("invalid key found. remaining bytes=%v", rem)
+		}
+
+		// write as either array element or document element using writeElementFn
+		vw, err := wef(key)
+		if err != nil {
+			return err
+		}
+
+		val, rem, ok = bsoncore.ReadValue(rem, t)
+		if !ok {
+			return fmt.Errorf("not enough bytes available to read type. bytes=%d type=%s", len(rem), t)
+		}
+		err = copyValueFromBytes(vw, Type(t), val.Data)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// copyDocumentToBytes copies an entire document from the ValueReader and
+// returns it as bytes.
+func copyDocumentToBytes(src ValueReader) ([]byte, error) {
+	return appendDocumentBytes(nil, src)
+}
+
+// appendDocumentBytes functions the same as CopyDocumentToBytes, but will
+// append the result to dst.
+func appendDocumentBytes(dst []byte, src ValueReader) ([]byte, error) {
+	if br, ok := src.(bytesReader); ok {
+		_, dst, err := br.readValueBytes(dst)
+		return dst, err
+	}
+
+	vw := vwPool.Get().(*valueWriter)
+	defer putValueWriter(vw)
+
+	vw.reset(dst)
+
+	err := copyDocument(vw, src)
+	dst = vw.buf
+	return dst, err
+}
+
+// appendArrayBytes copies an array from the ValueReader to dst.
+func appendArrayBytes(dst []byte, src ValueReader) ([]byte, error) {
+	if br, ok := src.(bytesReader); ok {
+		_, dst, err := br.readValueBytes(dst)
+		return dst, err
+	}
+
+	vw := vwPool.Get().(*valueWriter)
+	defer putValueWriter(vw)
+
+	vw.reset(dst)
+
+	err := copyArray(vw, src)
+	dst = vw.buf
+	return dst, err
+}
+
+// copyValueFromBytes will write the value represtend by t and src to dst.
+func copyValueFromBytes(dst ValueWriter, t Type, src []byte) error {
+	if wvb, ok := dst.(bytesWriter); ok {
+		return wvb.writeValueBytes(t, src)
+	}
+
+	vr := newDocumentReader(bytes.NewReader(src))
+	vr.pushElement(t)
+
+	return copyValue(dst, vr)
+}
+
+// copyValueToBytes copies a value from src and returns it as a Type and a
+// []byte.
+func copyValueToBytes(src ValueReader) (Type, []byte, error) {
+	if br, ok := src.(bytesReader); ok {
+		return br.readValueBytes(nil)
+	}
+
+	vw := vwPool.Get().(*valueWriter)
+	defer putValueWriter(vw)
+
+	vw.reset(nil)
+	vw.push(mElement)
+
+	err := copyValue(vw, src)
+	if err != nil {
+		return 0, nil, err
+	}
+
+	return Type(vw.buf[0]), vw.buf[2:], nil
+}
+
+// copyValue will copy a single value from src to dst.
+func copyValue(dst ValueWriter, src ValueReader) error {
+	var err error
+	switch src.Type() {
+	case TypeDouble:
+		var f64 float64
+		f64, err = src.ReadDouble()
+		if err != nil {
+			break
+		}
+		err = dst.WriteDouble(f64)
+	case TypeString:
+		var str string
+		str, err = src.ReadString()
+		if err != nil {
+			return err
+		}
+		err = dst.WriteString(str)
+	case TypeEmbeddedDocument:
+		err = copyDocument(dst, src)
+	case TypeArray:
+		err = copyArray(dst, src)
+	case TypeBinary:
+		var data []byte
+		var subtype byte
+		data, subtype, err = src.ReadBinary()
+		if err != nil {
+			break
+		}
+		err = dst.WriteBinaryWithSubtype(data, subtype)
+	case TypeUndefined:
+		err = src.ReadUndefined()
+		if err != nil {
+			break
+		}
+		err = dst.WriteUndefined()
+	case TypeObjectID:
+		var oid ObjectID
+		oid, err = src.ReadObjectID()
+		if err != nil {
+			break
+		}
+		err = dst.WriteObjectID(oid)
+	case TypeBoolean:
+		var b bool
+		b, err = src.ReadBoolean()
+		if err != nil {
+			break
+		}
+		err = dst.WriteBoolean(b)
+	case TypeDateTime:
+		var dt int64
+		dt, err = src.ReadDateTime()
+		if err != nil {
+			break
+		}
+		err = dst.WriteDateTime(dt)
+	case TypeNull:
+		err = src.ReadNull()
+		if err != nil {
+			break
+		}
+		err = dst.WriteNull()
+	case TypeRegex:
+		var pattern, options string
+		pattern, options, err = src.ReadRegex()
+		if err != nil {
+			break
+		}
+		err = dst.WriteRegex(pattern, options)
+	case TypeDBPointer:
+		var ns string
+		var pointer ObjectID
+		ns, pointer, err = src.ReadDBPointer()
+		if err != nil {
+			break
+		}
+		err = dst.WriteDBPointer(ns, pointer)
+	case TypeJavaScript:
+		var js string
+		js, err = src.ReadJavascript()
+		if err != nil {
+			break
+		}
+		err = dst.WriteJavascript(js)
+	case TypeSymbol:
+		var symbol string
+		symbol, err = src.ReadSymbol()
+		if err != nil {
+			break
+		}
+		err = dst.WriteSymbol(symbol)
+	case TypeCodeWithScope:
+		var code string
+		var srcScope DocumentReader
+		code, srcScope, err = src.ReadCodeWithScope()
+		if err != nil {
+			break
+		}
+
+		var dstScope DocumentWriter
+		dstScope, err = dst.WriteCodeWithScope(code)
+		if err != nil {
+			break
+		}
+		err = copyDocumentCore(dstScope, srcScope)
+	case TypeInt32:
+		var i32 int32
+		i32, err = src.ReadInt32()
+		if err != nil {
+			break
+		}
+		err = dst.WriteInt32(i32)
+	case TypeTimestamp:
+		var t, i uint32
+		t, i, err = src.ReadTimestamp()
+		if err != nil {
+			break
+		}
+		err = dst.WriteTimestamp(t, i)
+	case TypeInt64:
+		var i64 int64
+		i64, err = src.ReadInt64()
+		if err != nil {
+			break
+		}
+		err = dst.WriteInt64(i64)
+	case TypeDecimal128:
+		var d128 Decimal128
+		d128, err = src.ReadDecimal128()
+		if err != nil {
+			break
+		}
+		err = dst.WriteDecimal128(d128)
+	case TypeMinKey:
+		err = src.ReadMinKey()
+		if err != nil {
+			break
+		}
+		err = dst.WriteMinKey()
+	case TypeMaxKey:
+		err = src.ReadMaxKey()
+		if err != nil {
+			break
+		}
+		err = dst.WriteMaxKey()
+	default:
+		err = fmt.Errorf("cannot copy unknown BSON type %s", src.Type())
+	}
+
+	return err
+}
+
+func copyArray(dst ValueWriter, src ValueReader) error {
+	ar, err := src.ReadArray()
+	if err != nil {
+		return err
+	}
+
+	aw, err := dst.WriteArray()
+	if err != nil {
+		return err
+	}
+
+	for {
+		vr, err := ar.ReadValue()
+		if errors.Is(err, ErrEOA) {
+			break
+		}
+		if err != nil {
+			return err
+		}
+
+		vw, err := aw.WriteArrayElement()
+		if err != nil {
+			return err
+		}
+
+		err = copyValue(vw, vr)
+		if err != nil {
+			return err
+		}
+	}
+
+	return aw.WriteArrayEnd()
+}
+
+func copyDocumentCore(dw DocumentWriter, dr DocumentReader) error {
+	for {
+		key, vr, err := dr.ReadElement()
+		if errors.Is(err, ErrEOD) {
+			break
+		}
+		if err != nil {
+			return err
+		}
+
+		vw, err := dw.WriteDocumentElement(key)
+		if err != nil {
+			return err
+		}
+
+		err = copyValue(vw, vr)
+		if err != nil {
+			return err
+		}
+	}
+
+	return dw.WriteDocumentEnd()
+}
+
+// bytesReader is the interface used to read BSON bytes from a valueReader.
+//
+// The bytes of the value will be appended to dst.
+type bytesReader interface {
+	readValueBytes(dst []byte) (Type, []byte, error)
+}
+
+// bytesWriter is the interface used to write BSON bytes to a valueWriter.
+type bytesWriter interface {
+	writeValueBytes(t Type, b []byte) error
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/decimal.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/decimal.go
new file mode 100644
index 00000000..85c506ef
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/decimal.go
@@ -0,0 +1,339 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+//
+// Based on gopkg.in/mgo.v2/bson by Gustavo Niemeyer
+// See THIRD-PARTY-NOTICES for original license terms.
+
+package bson
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"math/big"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"go.mongodb.org/mongo-driver/v2/internal/decimal128"
+)
+
+// These constants are the maximum and minimum values for the exponent field in a decimal128 value.
+const (
+	MaxDecimal128Exp = 6111
+	MinDecimal128Exp = -6176
+)
+
+// These errors are returned when an invalid value is parsed as a big.Int.
+var (
+	ErrParseNaN    = errors.New("cannot parse NaN as a *big.Int")
+	ErrParseInf    = errors.New("cannot parse Infinity as a *big.Int")
+	ErrParseNegInf = errors.New("cannot parse -Infinity as a *big.Int")
+)
+
+// Decimal128 holds decimal128 BSON values.
+type Decimal128 struct {
+	h, l uint64
+}
+
+// NewDecimal128 creates a Decimal128 using the provide high and low uint64s.
+func NewDecimal128(h, l uint64) Decimal128 {
+	return Decimal128{h: h, l: l}
+}
+
+// GetBytes returns the underlying bytes of the BSON decimal value as two uint64 values. The first
+// contains the most first 8 bytes of the value and the second contains the latter.
+func (d Decimal128) GetBytes() (uint64, uint64) {
+	return d.h, d.l
+}
+
+// String returns a string representation of the decimal value.
+func (d Decimal128) String() string {
+	return decimal128.String(d.h, d.l)
+}
+
+// BigInt returns significand as big.Int and exponent, bi * 10 ^ exp.
+func (d Decimal128) BigInt() (*big.Int, int, error) {
+	high, low := d.GetBytes()
+	posSign := high>>63&1 == 0 // positive sign
+
+	switch high >> 58 & (1<<5 - 1) {
+	case 0x1F:
+		return nil, 0, ErrParseNaN
+	case 0x1E:
+		if posSign {
+			return nil, 0, ErrParseInf
+		}
+		return nil, 0, ErrParseNegInf
+	}
+
+	var exp int
+	if high>>61&3 == 3 {
+		// Bits: 1*sign 2*ignored 14*exponent 111*significand.
+		// Implicit 0b100 prefix in significand.
+		exp = int(high >> 47 & (1<<14 - 1))
+		// Spec says all of these values are out of range.
+		high, low = 0, 0
+	} else {
+		// Bits: 1*sign 14*exponent 113*significand
+		exp = int(high >> 49 & (1<<14 - 1))
+		high &= (1<<49 - 1)
+	}
+	exp += MinDecimal128Exp
+
+	// Would be handled by the logic below, but that's trivial and common.
+	if high == 0 && low == 0 && exp == 0 {
+		return new(big.Int), 0, nil
+	}
+
+	bi := big.NewInt(0)
+	const host32bit = ^uint(0)>>32 == 0
+	if host32bit {
+		bi.SetBits([]big.Word{big.Word(low), big.Word(low >> 32), big.Word(high), big.Word(high >> 32)})
+	} else {
+		bi.SetBits([]big.Word{big.Word(low), big.Word(high)})
+	}
+
+	if !posSign {
+		return bi.Neg(bi), exp, nil
+	}
+	return bi, exp, nil
+}
+
+// IsNaN returns whether d is NaN.
+func (d Decimal128) IsNaN() bool {
+	return d.h>>58&(1<<5-1) == 0x1F
+}
+
+// IsInf returns:
+//
+//	+1 d == Infinity
+//	 0 other case
+//	-1 d == -Infinity
+func (d Decimal128) IsInf() int {
+	if d.h>>58&(1<<5-1) != 0x1E {
+		return 0
+	}
+
+	if d.h>>63&1 == 0 {
+		return 1
+	}
+	return -1
+}
+
+// IsZero returns true if d is the empty Decimal128.
+func (d Decimal128) IsZero() bool {
+	return d.h == 0 && d.l == 0
+}
+
+// MarshalJSON returns Decimal128 as a string.
+func (d Decimal128) MarshalJSON() ([]byte, error) {
+	return json.Marshal(d.String())
+}
+
+// UnmarshalJSON creates a Decimal128 from a JSON string, an extended JSON $numberDecimal value, or the string
+// "null". If b is a JSON string or extended JSON value, d will have the value of that string, and if b is "null", d will
+// be unchanged.
+func (d *Decimal128) UnmarshalJSON(b []byte) error {
+	// Ignore "null" to keep parity with the standard library. Decoding a JSON null into a non-pointer Decimal128 field
+	// will leave the field unchanged. For pointer values, encoding/json will set the pointer to nil and will not
+	// enter the UnmarshalJSON hook.
+	if string(b) == "null" {
+		return nil
+	}
+
+	var res interface{}
+	err := json.Unmarshal(b, &res)
+	if err != nil {
+		return err
+	}
+	str, ok := res.(string)
+
+	// Extended JSON
+	if !ok {
+		m, ok := res.(map[string]interface{})
+		if !ok {
+			return errors.New("not an extended JSON Decimal128: expected document")
+		}
+		d128, ok := m["$numberDecimal"]
+		if !ok {
+			return errors.New("not an extended JSON Decimal128: expected key $numberDecimal")
+		}
+		str, ok = d128.(string)
+		if !ok {
+			return errors.New("not an extended JSON Decimal128: expected decimal to be string")
+		}
+	}
+
+	*d, err = ParseDecimal128(str)
+	return err
+}
+
+var dNaN = Decimal128{0x1F << 58, 0}
+var dPosInf = Decimal128{0x1E << 58, 0}
+var dNegInf = Decimal128{0x3E << 58, 0}
+
+func dErr(s string) (Decimal128, error) {
+	return dNaN, fmt.Errorf("cannot parse %q as a decimal128", s)
+}
+
+// match scientific notation number, example -10.15e-18
+var normalNumber = regexp.MustCompile(`^(?P<int>[-+]?\d*)?(?:\.(?P<dec>\d*))?(?:[Ee](?P<exp>[-+]?\d+))?$`)
+
+// ParseDecimal128 takes the given string and attempts to parse it into a valid
+// Decimal128 value.
+func ParseDecimal128(s string) (Decimal128, error) {
+	if s == "" {
+		return dErr(s)
+	}
+
+	matches := normalNumber.FindStringSubmatch(s)
+	if len(matches) == 0 {
+		orig := s
+		neg := s[0] == '-'
+		if neg || s[0] == '+' {
+			s = s[1:]
+		}
+
+		if s == "NaN" || s == "nan" || strings.EqualFold(s, "nan") {
+			return dNaN, nil
+		}
+		if s == "Inf" || s == "inf" || strings.EqualFold(s, "inf") || strings.EqualFold(s, "infinity") {
+			if neg {
+				return dNegInf, nil
+			}
+			return dPosInf, nil
+		}
+		return dErr(orig)
+	}
+
+	intPart := matches[1]
+	decPart := matches[2]
+	expPart := matches[3]
+
+	var err error
+	exp := 0
+	if expPart != "" {
+		exp, err = strconv.Atoi(expPart)
+		if err != nil {
+			return dErr(s)
+		}
+	}
+	if decPart != "" {
+		exp -= len(decPart)
+	}
+
+	if len(strings.Trim(intPart+decPart, "-0")) > 35 {
+		return dErr(s)
+	}
+
+	// Parse the significand (i.e. the non-exponent part) as a big.Int.
+	bi, ok := new(big.Int).SetString(intPart+decPart, 10)
+	if !ok {
+		return dErr(s)
+	}
+
+	d, ok := ParseDecimal128FromBigInt(bi, exp)
+	if !ok {
+		return dErr(s)
+	}
+
+	if bi.Sign() == 0 && s[0] == '-' {
+		d.h |= 1 << 63
+	}
+
+	return d, nil
+}
+
+var (
+	ten  = big.NewInt(10)
+	zero = new(big.Int)
+
+	maxS, _ = new(big.Int).SetString("9999999999999999999999999999999999", 10)
+)
+
+// ParseDecimal128FromBigInt attempts to parse the given significand and exponent into a valid Decimal128 value.
+func ParseDecimal128FromBigInt(bi *big.Int, exp int) (Decimal128, bool) {
+	// copy
+	bi = new(big.Int).Set(bi)
+
+	q := new(big.Int)
+	r := new(big.Int)
+
+	// If the significand is zero, the logical value will always be zero, independent of the
+	// exponent. However, the loops for handling out-of-range exponent values below may be extremely
+	// slow for zero values because the significand never changes. Limit the exponent value to the
+	// supported range here to prevent entering the loops below.
+	if bi.Cmp(zero) == 0 {
+		if exp > MaxDecimal128Exp {
+			exp = MaxDecimal128Exp
+		}
+		if exp < MinDecimal128Exp {
+			exp = MinDecimal128Exp
+		}
+	}
+
+	for bigIntCmpAbs(bi, maxS) == 1 {
+		bi, _ = q.QuoRem(bi, ten, r)
+		if r.Cmp(zero) != 0 {
+			return Decimal128{}, false
+		}
+		exp++
+		if exp > MaxDecimal128Exp {
+			return Decimal128{}, false
+		}
+	}
+
+	for exp < MinDecimal128Exp {
+		// Subnormal.
+		bi, _ = q.QuoRem(bi, ten, r)
+		if r.Cmp(zero) != 0 {
+			return Decimal128{}, false
+		}
+		exp++
+	}
+	for exp > MaxDecimal128Exp {
+		// Clamped.
+		bi.Mul(bi, ten)
+		if bigIntCmpAbs(bi, maxS) == 1 {
+			return Decimal128{}, false
+		}
+		exp--
+	}
+
+	b := bi.Bytes()
+	var h, l uint64
+	for i := 0; i < len(b); i++ {
+		if i < len(b)-8 {
+			h = h<<8 | uint64(b[i])
+			continue
+		}
+		l = l<<8 | uint64(b[i])
+	}
+
+	h |= uint64(exp-MinDecimal128Exp) & uint64(1<<14-1) << 49
+	if bi.Sign() == -1 {
+		h |= 1 << 63
+	}
+
+	return Decimal128{h: h, l: l}, true
+}
+
+// bigIntCmpAbs computes big.Int.Cmp(absoluteValue(x), absoluteValue(y)).
+func bigIntCmpAbs(x, y *big.Int) int {
+	xAbs := bigIntAbsValue(x)
+	yAbs := bigIntAbsValue(y)
+	return xAbs.Cmp(yAbs)
+}
+
+// bigIntAbsValue returns a big.Int containing the absolute value of b.
+// If b is already a non-negative number, it is returned without any changes or copies.
+func bigIntAbsValue(b *big.Int) *big.Int {
+	if b.Sign() >= 0 {
+		return b // already positive
+	}
+	return new(big.Int).Abs(b)
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/decoder.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/decoder.go
new file mode 100644
index 00000000..2fa9e6f1
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/decoder.go
@@ -0,0 +1,136 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"sync"
+)
+
+// ErrDecodeToNil is the error returned when trying to decode to a nil value
+var ErrDecodeToNil = errors.New("cannot Decode to nil value")
+
+// This pool is used to keep the allocations of Decoders down. This is only used for the Marshal*
+// methods and is not consumable from outside of this package. The Decoders retrieved from this pool
+// must have both Reset and SetRegistry called on them.
+var decPool = sync.Pool{
+	New: func() interface{} {
+		return new(Decoder)
+	},
+}
+
+// A Decoder reads and decodes BSON documents from a stream. It reads from a ValueReader as
+// the source of BSON data.
+type Decoder struct {
+	dc DecodeContext
+	vr ValueReader
+}
+
+// NewDecoder returns a new decoder that reads from vr.
+func NewDecoder(vr ValueReader) *Decoder {
+	return &Decoder{
+		dc: DecodeContext{Registry: defaultRegistry},
+		vr: vr,
+	}
+}
+
+// Decode reads the next BSON document from the stream and decodes it into the
+// value pointed to by val.
+//
+// See [Unmarshal] for details about BSON unmarshaling behavior.
+func (d *Decoder) Decode(val interface{}) error {
+	if unmarshaler, ok := val.(Unmarshaler); ok {
+		// TODO(skriptble): Reuse a []byte here and use the AppendDocumentBytes method.
+		buf, err := copyDocumentToBytes(d.vr)
+		if err != nil {
+			return err
+		}
+		return unmarshaler.UnmarshalBSON(buf)
+	}
+
+	rval := reflect.ValueOf(val)
+	switch rval.Kind() {
+	case reflect.Ptr:
+		if rval.IsNil() {
+			return ErrDecodeToNil
+		}
+		rval = rval.Elem()
+	case reflect.Map:
+		if rval.IsNil() {
+			return ErrDecodeToNil
+		}
+	default:
+		return fmt.Errorf("argument to Decode must be a pointer or a map, but got %v", rval)
+	}
+	decoder, err := d.dc.LookupDecoder(rval.Type())
+	if err != nil {
+		return err
+	}
+
+	return decoder.DecodeValue(d.dc, d.vr, rval)
+}
+
+// Reset will reset the state of the decoder, using the same *DecodeContext used in
+// the original construction but using vr for reading.
+func (d *Decoder) Reset(vr ValueReader) {
+	d.vr = vr
+}
+
+// SetRegistry replaces the current registry of the decoder with r.
+func (d *Decoder) SetRegistry(r *Registry) {
+	d.dc.Registry = r
+}
+
+// DefaultDocumentM causes the Decoder to always unmarshal documents into the bson.M type. This
+// behavior is restricted to data typed as "interface{}" or "map[string]interface{}".
+func (d *Decoder) DefaultDocumentM() {
+	d.dc.defaultDocumentType = reflect.TypeOf(M{})
+}
+
+// AllowTruncatingDoubles causes the Decoder to truncate the fractional part of BSON "double" values
+// when attempting to unmarshal them into a Go integer (int, int8, int16, int32, or int64) struct
+// field. The truncation logic does not apply to BSON "decimal128" values.
+func (d *Decoder) AllowTruncatingDoubles() {
+	d.dc.truncate = true
+}
+
+// BinaryAsSlice causes the Decoder to unmarshal BSON binary field values that are the "Generic" or
+// "Old" BSON binary subtype as a Go byte slice instead of a bson.Binary.
+func (d *Decoder) BinaryAsSlice() {
+	d.dc.binaryAsSlice = true
+}
+
+// ObjectIDAsHexString causes the Decoder to decode object IDs to their hex representation.
+func (d *Decoder) ObjectIDAsHexString() {
+	d.dc.objectIDAsHexString = true
+}
+
+// UseJSONStructTags causes the Decoder to fall back to using the "json" struct tag if a "bson"
+// struct tag is not specified.
+func (d *Decoder) UseJSONStructTags() {
+	d.dc.useJSONStructTags = true
+}
+
+// UseLocalTimeZone causes the Decoder to unmarshal time.Time values in the local timezone instead
+// of the UTC timezone.
+func (d *Decoder) UseLocalTimeZone() {
+	d.dc.useLocalTimeZone = true
+}
+
+// ZeroMaps causes the Decoder to delete any existing values from Go maps in the destination value
+// passed to Decode before unmarshaling BSON documents into them.
+func (d *Decoder) ZeroMaps() {
+	d.dc.zeroMaps = true
+}
+
+// ZeroStructs causes the Decoder to delete any existing values from Go structs in the destination
+// value passed to Decode before unmarshaling BSON documents into them.
+func (d *Decoder) ZeroStructs() {
+	d.dc.zeroStructs = true
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/default_value_decoders.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/default_value_decoders.go
new file mode 100644
index 00000000..b7d20339
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/default_value_decoders.go
@@ -0,0 +1,1518 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"math"
+	"net/url"
+	"reflect"
+	"strconv"
+
+	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
+)
+
+var errCannotTruncate = errors.New("float64 can only be truncated to a lower precision type when truncation is enabled")
+
+type decodeBinaryError struct {
+	subtype  byte
+	typeName string
+}
+
+func (d decodeBinaryError) Error() string {
+	return fmt.Sprintf("only binary values with subtype 0x00 or 0x02 can be decoded into %s, but got subtype %v", d.typeName, d.subtype)
+}
+
+// registerDefaultDecoders will register the decoder methods attached to DefaultValueDecoders with
+// the provided RegistryBuilder.
+//
+// There is no support for decoding map[string]interface{} because there is no decoder for
+// interface{}, so users must either register this decoder themselves or use the
+// EmptyInterfaceDecoder available in the bson package.
+func registerDefaultDecoders(reg *Registry) {
+	intDecoder := decodeAdapter{intDecodeValue, intDecodeType}
+	floatDecoder := decodeAdapter{floatDecodeValue, floatDecodeType}
+	uintCodec := &uintCodec{}
+
+	reg.RegisterTypeDecoder(tD, ValueDecoderFunc(dDecodeValue))
+	reg.RegisterTypeDecoder(tBinary, decodeAdapter{binaryDecodeValue, binaryDecodeType})
+	reg.RegisterTypeDecoder(tVector, decodeAdapter{vectorDecodeValue, vectorDecodeType})
+	reg.RegisterTypeDecoder(tUndefined, decodeAdapter{undefinedDecodeValue, undefinedDecodeType})
+	reg.RegisterTypeDecoder(tDateTime, decodeAdapter{dateTimeDecodeValue, dateTimeDecodeType})
+	reg.RegisterTypeDecoder(tNull, decodeAdapter{nullDecodeValue, nullDecodeType})
+	reg.RegisterTypeDecoder(tRegex, decodeAdapter{regexDecodeValue, regexDecodeType})
+	reg.RegisterTypeDecoder(tDBPointer, decodeAdapter{dbPointerDecodeValue, dbPointerDecodeType})
+	reg.RegisterTypeDecoder(tTimestamp, decodeAdapter{timestampDecodeValue, timestampDecodeType})
+	reg.RegisterTypeDecoder(tMinKey, decodeAdapter{minKeyDecodeValue, minKeyDecodeType})
+	reg.RegisterTypeDecoder(tMaxKey, decodeAdapter{maxKeyDecodeValue, maxKeyDecodeType})
+	reg.RegisterTypeDecoder(tJavaScript, decodeAdapter{javaScriptDecodeValue, javaScriptDecodeType})
+	reg.RegisterTypeDecoder(tSymbol, decodeAdapter{symbolDecodeValue, symbolDecodeType})
+	reg.RegisterTypeDecoder(tByteSlice, &byteSliceCodec{})
+	reg.RegisterTypeDecoder(tTime, &timeCodec{})
+	reg.RegisterTypeDecoder(tEmpty, &emptyInterfaceCodec{})
+	reg.RegisterTypeDecoder(tCoreArray, &arrayCodec{})
+	reg.RegisterTypeDecoder(tOID, decodeAdapter{objectIDDecodeValue, objectIDDecodeType})
+	reg.RegisterTypeDecoder(tDecimal, decodeAdapter{decimal128DecodeValue, decimal128DecodeType})
+	reg.RegisterTypeDecoder(tJSONNumber, decodeAdapter{jsonNumberDecodeValue, jsonNumberDecodeType})
+	reg.RegisterTypeDecoder(tURL, decodeAdapter{urlDecodeValue, urlDecodeType})
+	reg.RegisterTypeDecoder(tCoreDocument, ValueDecoderFunc(coreDocumentDecodeValue))
+	reg.RegisterTypeDecoder(tCodeWithScope, decodeAdapter{codeWithScopeDecodeValue, codeWithScopeDecodeType})
+	reg.RegisterKindDecoder(reflect.Bool, decodeAdapter{booleanDecodeValue, booleanDecodeType})
+	reg.RegisterKindDecoder(reflect.Int, intDecoder)
+	reg.RegisterKindDecoder(reflect.Int8, intDecoder)
+	reg.RegisterKindDecoder(reflect.Int16, intDecoder)
+	reg.RegisterKindDecoder(reflect.Int32, intDecoder)
+	reg.RegisterKindDecoder(reflect.Int64, intDecoder)
+	reg.RegisterKindDecoder(reflect.Uint, uintCodec)
+	reg.RegisterKindDecoder(reflect.Uint8, uintCodec)
+	reg.RegisterKindDecoder(reflect.Uint16, uintCodec)
+	reg.RegisterKindDecoder(reflect.Uint32, uintCodec)
+	reg.RegisterKindDecoder(reflect.Uint64, uintCodec)
+	reg.RegisterKindDecoder(reflect.Float32, floatDecoder)
+	reg.RegisterKindDecoder(reflect.Float64, floatDecoder)
+	reg.RegisterKindDecoder(reflect.Array, ValueDecoderFunc(arrayDecodeValue))
+	reg.RegisterKindDecoder(reflect.Map, &mapCodec{})
+	reg.RegisterKindDecoder(reflect.Slice, &sliceCodec{})
+	reg.RegisterKindDecoder(reflect.String, &stringCodec{})
+	reg.RegisterKindDecoder(reflect.Struct, newStructCodec(nil))
+	reg.RegisterKindDecoder(reflect.Ptr, &pointerCodec{})
+	reg.RegisterTypeMapEntry(TypeDouble, tFloat64)
+	reg.RegisterTypeMapEntry(TypeString, tString)
+	reg.RegisterTypeMapEntry(TypeArray, tA)
+	reg.RegisterTypeMapEntry(TypeBinary, tBinary)
+	reg.RegisterTypeMapEntry(TypeUndefined, tUndefined)
+	reg.RegisterTypeMapEntry(TypeObjectID, tOID)
+	reg.RegisterTypeMapEntry(TypeBoolean, tBool)
+	reg.RegisterTypeMapEntry(TypeDateTime, tDateTime)
+	reg.RegisterTypeMapEntry(TypeRegex, tRegex)
+	reg.RegisterTypeMapEntry(TypeDBPointer, tDBPointer)
+	reg.RegisterTypeMapEntry(TypeJavaScript, tJavaScript)
+	reg.RegisterTypeMapEntry(TypeSymbol, tSymbol)
+	reg.RegisterTypeMapEntry(TypeCodeWithScope, tCodeWithScope)
+	reg.RegisterTypeMapEntry(TypeInt32, tInt32)
+	reg.RegisterTypeMapEntry(TypeInt64, tInt64)
+	reg.RegisterTypeMapEntry(TypeTimestamp, tTimestamp)
+	reg.RegisterTypeMapEntry(TypeDecimal128, tDecimal)
+	reg.RegisterTypeMapEntry(TypeMinKey, tMinKey)
+	reg.RegisterTypeMapEntry(TypeMaxKey, tMaxKey)
+	reg.RegisterTypeMapEntry(Type(0), tD)
+	reg.RegisterTypeMapEntry(TypeEmbeddedDocument, tD)
+	reg.RegisterInterfaceDecoder(tValueUnmarshaler, ValueDecoderFunc(valueUnmarshalerDecodeValue))
+	reg.RegisterInterfaceDecoder(tUnmarshaler, ValueDecoderFunc(unmarshalerDecodeValue))
+}
+
+// dDecodeValue is the ValueDecoderFunc for D instances.
+func dDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.IsValid() || !val.CanSet() || val.Type() != tD {
+		return ValueDecoderError{Name: "DDecodeValue", Kinds: []reflect.Kind{reflect.Slice}, Received: val}
+	}
+
+	switch vrType := vr.Type(); vrType {
+	case Type(0), TypeEmbeddedDocument:
+		break
+	case TypeNull:
+		val.Set(reflect.Zero(val.Type()))
+		return vr.ReadNull()
+	default:
+		return fmt.Errorf("cannot decode %v into a D", vrType)
+	}
+
+	dr, err := vr.ReadDocument()
+	if err != nil {
+		return err
+	}
+
+	decoder, err := dc.LookupDecoder(tEmpty)
+	if err != nil {
+		return err
+	}
+
+	// Use the elements in the provided value if it's non nil. Otherwise, allocate a new D instance.
+	var elems D
+	if !val.IsNil() {
+		val.SetLen(0)
+		elems = val.Interface().(D)
+	} else {
+		elems = make(D, 0)
+	}
+
+	for {
+		key, elemVr, err := dr.ReadElement()
+		if errors.Is(err, ErrEOD) {
+			break
+		} else if err != nil {
+			return err
+		}
+
+		var v interface{}
+		err = decoder.DecodeValue(dc, elemVr, reflect.ValueOf(&v).Elem())
+		if err != nil {
+			return err
+		}
+
+		elems = append(elems, E{Key: key, Value: v})
+	}
+
+	val.Set(reflect.ValueOf(elems))
+	return nil
+}
+
+func booleanDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t.Kind() != reflect.Bool {
+		return emptyValue, ValueDecoderError{
+			Name:     "BooleanDecodeValue",
+			Kinds:    []reflect.Kind{reflect.Bool},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	var b bool
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeInt32:
+		i32, err := vr.ReadInt32()
+		if err != nil {
+			return emptyValue, err
+		}
+		b = (i32 != 0)
+	case TypeInt64:
+		i64, err := vr.ReadInt64()
+		if err != nil {
+			return emptyValue, err
+		}
+		b = (i64 != 0)
+	case TypeDouble:
+		f64, err := vr.ReadDouble()
+		if err != nil {
+			return emptyValue, err
+		}
+		b = (f64 != 0)
+	case TypeBoolean:
+		b, err = vr.ReadBoolean()
+	case TypeNull:
+		err = vr.ReadNull()
+	case TypeUndefined:
+		err = vr.ReadUndefined()
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a boolean", vrType)
+	}
+	if err != nil {
+		return emptyValue, err
+	}
+
+	return reflect.ValueOf(b), nil
+}
+
+// booleanDecodeValue is the ValueDecoderFunc for bool types.
+func booleanDecodeValue(dctx DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.IsValid() || !val.CanSet() || val.Kind() != reflect.Bool {
+		return ValueDecoderError{Name: "BooleanDecodeValue", Kinds: []reflect.Kind{reflect.Bool}, Received: val}
+	}
+
+	elem, err := booleanDecodeType(dctx, vr, val.Type())
+	if err != nil {
+		return err
+	}
+
+	val.SetBool(elem.Bool())
+	return nil
+}
+
+func intDecodeType(dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	var i64 int64
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeInt32:
+		i32, err := vr.ReadInt32()
+		if err != nil {
+			return emptyValue, err
+		}
+		i64 = int64(i32)
+	case TypeInt64:
+		i64, err = vr.ReadInt64()
+		if err != nil {
+			return emptyValue, err
+		}
+	case TypeDouble:
+		f64, err := vr.ReadDouble()
+		if err != nil {
+			return emptyValue, err
+		}
+		if !dc.truncate && math.Floor(f64) != f64 {
+			return emptyValue, errCannotTruncate
+		}
+		if f64 > float64(math.MaxInt64) {
+			return emptyValue, fmt.Errorf("%g overflows int64", f64)
+		}
+		i64 = int64(f64)
+	case TypeBoolean:
+		b, err := vr.ReadBoolean()
+		if err != nil {
+			return emptyValue, err
+		}
+		if b {
+			i64 = 1
+		}
+	case TypeNull:
+		if err = vr.ReadNull(); err != nil {
+			return emptyValue, err
+		}
+	case TypeUndefined:
+		if err = vr.ReadUndefined(); err != nil {
+			return emptyValue, err
+		}
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into an integer type", vrType)
+	}
+
+	switch t.Kind() {
+	case reflect.Int8:
+		if i64 < math.MinInt8 || i64 > math.MaxInt8 {
+			return emptyValue, fmt.Errorf("%d overflows int8", i64)
+		}
+
+		return reflect.ValueOf(int8(i64)), nil
+	case reflect.Int16:
+		if i64 < math.MinInt16 || i64 > math.MaxInt16 {
+			return emptyValue, fmt.Errorf("%d overflows int16", i64)
+		}
+
+		return reflect.ValueOf(int16(i64)), nil
+	case reflect.Int32:
+		if i64 < math.MinInt32 || i64 > math.MaxInt32 {
+			return emptyValue, fmt.Errorf("%d overflows int32", i64)
+		}
+
+		return reflect.ValueOf(int32(i64)), nil
+	case reflect.Int64:
+		return reflect.ValueOf(i64), nil
+	case reflect.Int:
+		if i64 > math.MaxInt { // Can we fit this inside of an int
+			return emptyValue, fmt.Errorf("%d overflows int", i64)
+		}
+
+		return reflect.ValueOf(int(i64)), nil
+	default:
+		return emptyValue, ValueDecoderError{
+			Name:     "IntDecodeValue",
+			Kinds:    []reflect.Kind{reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int},
+			Received: reflect.Zero(t),
+		}
+	}
+}
+
+// intDecodeValue is the ValueDecoderFunc for int types.
+func intDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() {
+		return ValueDecoderError{
+			Name:     "IntDecodeValue",
+			Kinds:    []reflect.Kind{reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int},
+			Received: val,
+		}
+	}
+
+	elem, err := intDecodeType(dc, vr, val.Type())
+	if err != nil {
+		return err
+	}
+
+	val.SetInt(elem.Int())
+	return nil
+}
+
+func floatDecodeType(dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	var f float64
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeInt32:
+		i32, err := vr.ReadInt32()
+		if err != nil {
+			return emptyValue, err
+		}
+		f = float64(i32)
+	case TypeInt64:
+		i64, err := vr.ReadInt64()
+		if err != nil {
+			return emptyValue, err
+		}
+		f = float64(i64)
+	case TypeDouble:
+		f, err = vr.ReadDouble()
+		if err != nil {
+			return emptyValue, err
+		}
+	case TypeBoolean:
+		b, err := vr.ReadBoolean()
+		if err != nil {
+			return emptyValue, err
+		}
+		if b {
+			f = 1
+		}
+	case TypeNull:
+		if err = vr.ReadNull(); err != nil {
+			return emptyValue, err
+		}
+	case TypeUndefined:
+		if err = vr.ReadUndefined(); err != nil {
+			return emptyValue, err
+		}
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a float32 or float64 type", vrType)
+	}
+
+	switch t.Kind() {
+	case reflect.Float32:
+		if !dc.truncate && float64(float32(f)) != f {
+			return emptyValue, errCannotTruncate
+		}
+
+		return reflect.ValueOf(float32(f)), nil
+	case reflect.Float64:
+		return reflect.ValueOf(f), nil
+	default:
+		return emptyValue, ValueDecoderError{
+			Name:     "FloatDecodeValue",
+			Kinds:    []reflect.Kind{reflect.Float32, reflect.Float64},
+			Received: reflect.Zero(t),
+		}
+	}
+}
+
+// floatDecodeValue is the ValueDecoderFunc for float types.
+func floatDecodeValue(ec DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() {
+		return ValueDecoderError{
+			Name:     "FloatDecodeValue",
+			Kinds:    []reflect.Kind{reflect.Float32, reflect.Float64},
+			Received: val,
+		}
+	}
+
+	elem, err := floatDecodeType(ec, vr, val.Type())
+	if err != nil {
+		return err
+	}
+
+	val.SetFloat(elem.Float())
+	return nil
+}
+
+func javaScriptDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tJavaScript {
+		return emptyValue, ValueDecoderError{
+			Name:     "JavaScriptDecodeValue",
+			Types:    []reflect.Type{tJavaScript},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	var js string
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeJavaScript:
+		js, err = vr.ReadJavascript()
+	case TypeNull:
+		err = vr.ReadNull()
+	case TypeUndefined:
+		err = vr.ReadUndefined()
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a JavaScript", vrType)
+	}
+	if err != nil {
+		return emptyValue, err
+	}
+
+	return reflect.ValueOf(JavaScript(js)), nil
+}
+
+// javaScriptDecodeValue is the ValueDecoderFunc for the JavaScript type.
+func javaScriptDecodeValue(dctx DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tJavaScript {
+		return ValueDecoderError{Name: "JavaScriptDecodeValue", Types: []reflect.Type{tJavaScript}, Received: val}
+	}
+
+	elem, err := javaScriptDecodeType(dctx, vr, tJavaScript)
+	if err != nil {
+		return err
+	}
+
+	val.SetString(elem.String())
+	return nil
+}
+
+func symbolDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tSymbol {
+		return emptyValue, ValueDecoderError{
+			Name:     "SymbolDecodeValue",
+			Types:    []reflect.Type{tSymbol},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	var symbol string
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeString:
+		symbol, err = vr.ReadString()
+	case TypeSymbol:
+		symbol, err = vr.ReadSymbol()
+	case TypeBinary:
+		data, subtype, err := vr.ReadBinary()
+		if err != nil {
+			return emptyValue, err
+		}
+
+		if subtype != TypeBinaryGeneric && subtype != TypeBinaryBinaryOld {
+			return emptyValue, decodeBinaryError{subtype: subtype, typeName: "Symbol"}
+		}
+		symbol = string(data)
+	case TypeNull:
+		err = vr.ReadNull()
+	case TypeUndefined:
+		err = vr.ReadUndefined()
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a Symbol", vrType)
+	}
+	if err != nil {
+		return emptyValue, err
+	}
+
+	return reflect.ValueOf(Symbol(symbol)), nil
+}
+
+// symbolDecodeValue is the ValueDecoderFunc for the Symbol type.
+func symbolDecodeValue(dctx DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tSymbol {
+		return ValueDecoderError{Name: "SymbolDecodeValue", Types: []reflect.Type{tSymbol}, Received: val}
+	}
+
+	elem, err := symbolDecodeType(dctx, vr, tSymbol)
+	if err != nil {
+		return err
+	}
+
+	val.SetString(elem.String())
+	return nil
+}
+
+func binaryDecode(vr ValueReader) (Binary, error) {
+	var b Binary
+
+	var data []byte
+	var subtype byte
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeBinary:
+		data, subtype, err = vr.ReadBinary()
+	case TypeNull:
+		err = vr.ReadNull()
+	case TypeUndefined:
+		err = vr.ReadUndefined()
+	default:
+		return b, fmt.Errorf("cannot decode %v into a Binary", vrType)
+	}
+	if err != nil {
+		return b, err
+	}
+	b.Subtype = subtype
+	b.Data = data
+
+	return b, nil
+}
+
+func binaryDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tBinary {
+		return emptyValue, ValueDecoderError{
+			Name:     "BinaryDecodeValue",
+			Types:    []reflect.Type{tBinary},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	b, err := binaryDecode(vr)
+	if err != nil {
+		return emptyValue, err
+	}
+	return reflect.ValueOf(b), nil
+}
+
+// binaryDecodeValue is the ValueDecoderFunc for Binary.
+func binaryDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tBinary {
+		return ValueDecoderError{Name: "BinaryDecodeValue", Types: []reflect.Type{tBinary}, Received: val}
+	}
+
+	elem, err := binaryDecodeType(dc, vr, tBinary)
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
+
+func vectorDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tVector {
+		return emptyValue, ValueDecoderError{
+			Name:     "VectorDecodeValue",
+			Types:    []reflect.Type{tVector},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	b, err := binaryDecode(vr)
+	if err != nil {
+		return emptyValue, err
+	}
+
+	v, err := NewVectorFromBinary(b)
+	if err != nil {
+		return emptyValue, err
+	}
+
+	return reflect.ValueOf(v), nil
+}
+
+// vectorDecodeValue is the ValueDecoderFunc for Vector.
+func vectorDecodeValue(dctx DecodeContext, vr ValueReader, val reflect.Value) error {
+	t := val.Type()
+	if !val.CanSet() || t != tVector {
+		return ValueDecoderError{
+			Name:     "VectorDecodeValue",
+			Types:    []reflect.Type{tVector},
+			Received: val,
+		}
+	}
+
+	elem, err := vectorDecodeType(dctx, vr, t)
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
+
+func undefinedDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tUndefined {
+		return emptyValue, ValueDecoderError{
+			Name:     "UndefinedDecodeValue",
+			Types:    []reflect.Type{tUndefined},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeUndefined:
+		err = vr.ReadUndefined()
+	case TypeNull:
+		err = vr.ReadNull()
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into an Undefined", vr.Type())
+	}
+	if err != nil {
+		return emptyValue, err
+	}
+
+	return reflect.ValueOf(Undefined{}), nil
+}
+
+// undefinedDecodeValue is the ValueDecoderFunc for Undefined.
+func undefinedDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tUndefined {
+		return ValueDecoderError{Name: "UndefinedDecodeValue", Types: []reflect.Type{tUndefined}, Received: val}
+	}
+
+	elem, err := undefinedDecodeType(dc, vr, tUndefined)
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
+
+// Accept both 12-byte string and pretty-printed 24-byte hex string formats.
+func objectIDDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tOID {
+		return emptyValue, ValueDecoderError{
+			Name:     "ObjectIDDecodeValue",
+			Types:    []reflect.Type{tOID},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	var oid ObjectID
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeObjectID:
+		oid, err = vr.ReadObjectID()
+		if err != nil {
+			return emptyValue, err
+		}
+	case TypeString:
+		str, err := vr.ReadString()
+		if err != nil {
+			return emptyValue, err
+		}
+		if oid, err = ObjectIDFromHex(str); err == nil {
+			break
+		}
+		if len(str) != 12 {
+			return emptyValue, fmt.Errorf("an ObjectID string must be exactly 12 bytes long (got %v)", len(str))
+		}
+		byteArr := []byte(str)
+		copy(oid[:], byteArr)
+	case TypeNull:
+		if err = vr.ReadNull(); err != nil {
+			return emptyValue, err
+		}
+	case TypeUndefined:
+		if err = vr.ReadUndefined(); err != nil {
+			return emptyValue, err
+		}
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into an ObjectID", vrType)
+	}
+
+	return reflect.ValueOf(oid), nil
+}
+
+// objectIDDecodeValue is the ValueDecoderFunc for ObjectID.
+func objectIDDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tOID {
+		return ValueDecoderError{Name: "ObjectIDDecodeValue", Types: []reflect.Type{tOID}, Received: val}
+	}
+
+	elem, err := objectIDDecodeType(dc, vr, tOID)
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
+
+func dateTimeDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tDateTime {
+		return emptyValue, ValueDecoderError{
+			Name:     "DateTimeDecodeValue",
+			Types:    []reflect.Type{tDateTime},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	var dt int64
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeDateTime:
+		dt, err = vr.ReadDateTime()
+	case TypeNull:
+		err = vr.ReadNull()
+	case TypeUndefined:
+		err = vr.ReadUndefined()
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a DateTime", vrType)
+	}
+	if err != nil {
+		return emptyValue, err
+	}
+
+	return reflect.ValueOf(DateTime(dt)), nil
+}
+
+// dateTimeDecodeValue is the ValueDecoderFunc for DateTime.
+func dateTimeDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tDateTime {
+		return ValueDecoderError{Name: "DateTimeDecodeValue", Types: []reflect.Type{tDateTime}, Received: val}
+	}
+
+	elem, err := dateTimeDecodeType(dc, vr, tDateTime)
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
+
+func nullDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tNull {
+		return emptyValue, ValueDecoderError{
+			Name:     "NullDecodeValue",
+			Types:    []reflect.Type{tNull},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeUndefined:
+		err = vr.ReadUndefined()
+	case TypeNull:
+		err = vr.ReadNull()
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a Null", vr.Type())
+	}
+	if err != nil {
+		return emptyValue, err
+	}
+
+	return reflect.ValueOf(Null{}), nil
+}
+
+// nullDecodeValue is the ValueDecoderFunc for Null.
+func nullDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tNull {
+		return ValueDecoderError{Name: "NullDecodeValue", Types: []reflect.Type{tNull}, Received: val}
+	}
+
+	elem, err := nullDecodeType(dc, vr, tNull)
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
+
+func regexDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tRegex {
+		return emptyValue, ValueDecoderError{
+			Name:     "RegexDecodeValue",
+			Types:    []reflect.Type{tRegex},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	var pattern, options string
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeRegex:
+		pattern, options, err = vr.ReadRegex()
+	case TypeNull:
+		err = vr.ReadNull()
+	case TypeUndefined:
+		err = vr.ReadUndefined()
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a Regex", vrType)
+	}
+	if err != nil {
+		return emptyValue, err
+	}
+
+	return reflect.ValueOf(Regex{Pattern: pattern, Options: options}), nil
+}
+
+// regexDecodeValue is the ValueDecoderFunc for Regex.
+func regexDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tRegex {
+		return ValueDecoderError{Name: "RegexDecodeValue", Types: []reflect.Type{tRegex}, Received: val}
+	}
+
+	elem, err := regexDecodeType(dc, vr, tRegex)
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
+
+func dbPointerDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tDBPointer {
+		return emptyValue, ValueDecoderError{
+			Name:     "DBPointerDecodeValue",
+			Types:    []reflect.Type{tDBPointer},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	var ns string
+	var pointer ObjectID
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeDBPointer:
+		ns, pointer, err = vr.ReadDBPointer()
+	case TypeNull:
+		err = vr.ReadNull()
+	case TypeUndefined:
+		err = vr.ReadUndefined()
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a DBPointer", vrType)
+	}
+	if err != nil {
+		return emptyValue, err
+	}
+
+	return reflect.ValueOf(DBPointer{DB: ns, Pointer: pointer}), nil
+}
+
+// dbPointerDecodeValue is the ValueDecoderFunc for DBPointer.
+func dbPointerDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tDBPointer {
+		return ValueDecoderError{Name: "DBPointerDecodeValue", Types: []reflect.Type{tDBPointer}, Received: val}
+	}
+
+	elem, err := dbPointerDecodeType(dc, vr, tDBPointer)
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
+
+func timestampDecodeType(_ DecodeContext, vr ValueReader, reflectType reflect.Type) (reflect.Value, error) {
+	if reflectType != tTimestamp {
+		return emptyValue, ValueDecoderError{
+			Name:     "TimestampDecodeValue",
+			Types:    []reflect.Type{tTimestamp},
+			Received: reflect.Zero(reflectType),
+		}
+	}
+
+	var t, incr uint32
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeTimestamp:
+		t, incr, err = vr.ReadTimestamp()
+	case TypeNull:
+		err = vr.ReadNull()
+	case TypeUndefined:
+		err = vr.ReadUndefined()
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a Timestamp", vrType)
+	}
+	if err != nil {
+		return emptyValue, err
+	}
+
+	return reflect.ValueOf(Timestamp{T: t, I: incr}), nil
+}
+
+// timestampDecodeValue is the ValueDecoderFunc for Timestamp.
+func timestampDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tTimestamp {
+		return ValueDecoderError{Name: "TimestampDecodeValue", Types: []reflect.Type{tTimestamp}, Received: val}
+	}
+
+	elem, err := timestampDecodeType(dc, vr, tTimestamp)
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
+
+func minKeyDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tMinKey {
+		return emptyValue, ValueDecoderError{
+			Name:     "MinKeyDecodeValue",
+			Types:    []reflect.Type{tMinKey},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeMinKey:
+		err = vr.ReadMinKey()
+	case TypeNull:
+		err = vr.ReadNull()
+	case TypeUndefined:
+		err = vr.ReadUndefined()
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a MinKey", vr.Type())
+	}
+	if err != nil {
+		return emptyValue, err
+	}
+
+	return reflect.ValueOf(MinKey{}), nil
+}
+
+// minKeyDecodeValue is the ValueDecoderFunc for MinKey.
+func minKeyDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tMinKey {
+		return ValueDecoderError{Name: "MinKeyDecodeValue", Types: []reflect.Type{tMinKey}, Received: val}
+	}
+
+	elem, err := minKeyDecodeType(dc, vr, tMinKey)
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
+
+func maxKeyDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tMaxKey {
+		return emptyValue, ValueDecoderError{
+			Name:     "MaxKeyDecodeValue",
+			Types:    []reflect.Type{tMaxKey},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeMaxKey:
+		err = vr.ReadMaxKey()
+	case TypeNull:
+		err = vr.ReadNull()
+	case TypeUndefined:
+		err = vr.ReadUndefined()
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a MaxKey", vr.Type())
+	}
+	if err != nil {
+		return emptyValue, err
+	}
+
+	return reflect.ValueOf(MaxKey{}), nil
+}
+
+// maxKeyDecodeValue is the ValueDecoderFunc for MaxKey.
+func maxKeyDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tMaxKey {
+		return ValueDecoderError{Name: "MaxKeyDecodeValue", Types: []reflect.Type{tMaxKey}, Received: val}
+	}
+
+	elem, err := maxKeyDecodeType(dc, vr, tMaxKey)
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
+
+func decimal128DecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tDecimal {
+		return emptyValue, ValueDecoderError{
+			Name:     "Decimal128DecodeValue",
+			Types:    []reflect.Type{tDecimal},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	var d128 Decimal128
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeDecimal128:
+		d128, err = vr.ReadDecimal128()
+	case TypeNull:
+		err = vr.ReadNull()
+	case TypeUndefined:
+		err = vr.ReadUndefined()
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a Decimal128", vr.Type())
+	}
+	if err != nil {
+		return emptyValue, err
+	}
+
+	return reflect.ValueOf(d128), nil
+}
+
+// decimal128DecodeValue is the ValueDecoderFunc for Decimal128.
+func decimal128DecodeValue(dctx DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tDecimal {
+		return ValueDecoderError{Name: "Decimal128DecodeValue", Types: []reflect.Type{tDecimal}, Received: val}
+	}
+
+	elem, err := decimal128DecodeType(dctx, vr, tDecimal)
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
+
+func jsonNumberDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tJSONNumber {
+		return emptyValue, ValueDecoderError{
+			Name:     "JSONNumberDecodeValue",
+			Types:    []reflect.Type{tJSONNumber},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	var jsonNum json.Number
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeDouble:
+		f64, err := vr.ReadDouble()
+		if err != nil {
+			return emptyValue, err
+		}
+		jsonNum = json.Number(strconv.FormatFloat(f64, 'f', -1, 64))
+	case TypeInt32:
+		i32, err := vr.ReadInt32()
+		if err != nil {
+			return emptyValue, err
+		}
+		jsonNum = json.Number(strconv.FormatInt(int64(i32), 10))
+	case TypeInt64:
+		i64, err := vr.ReadInt64()
+		if err != nil {
+			return emptyValue, err
+		}
+		jsonNum = json.Number(strconv.FormatInt(i64, 10))
+	case TypeNull:
+		err = vr.ReadNull()
+	case TypeUndefined:
+		err = vr.ReadUndefined()
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a json.Number", vrType)
+	}
+	if err != nil {
+		return emptyValue, err
+	}
+
+	return reflect.ValueOf(jsonNum), nil
+}
+
+// jsonNumberDecodeValue is the ValueDecoderFunc for json.Number.
+func jsonNumberDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tJSONNumber {
+		return ValueDecoderError{Name: "JSONNumberDecodeValue", Types: []reflect.Type{tJSONNumber}, Received: val}
+	}
+
+	elem, err := jsonNumberDecodeType(dc, vr, tJSONNumber)
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
+
+func urlDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tURL {
+		return emptyValue, ValueDecoderError{
+			Name:     "URLDecodeValue",
+			Types:    []reflect.Type{tURL},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	urlPtr := &url.URL{}
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeString:
+		var str string // Declare str here to avoid shadowing err during the ReadString call.
+		str, err = vr.ReadString()
+		if err != nil {
+			return emptyValue, err
+		}
+
+		urlPtr, err = url.Parse(str)
+	case TypeNull:
+		err = vr.ReadNull()
+	case TypeUndefined:
+		err = vr.ReadUndefined()
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a *url.URL", vrType)
+	}
+	if err != nil {
+		return emptyValue, err
+	}
+
+	return reflect.ValueOf(urlPtr).Elem(), nil
+}
+
+// urlDecodeValue is the ValueDecoderFunc for url.URL.
+func urlDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tURL {
+		return ValueDecoderError{Name: "URLDecodeValue", Types: []reflect.Type{tURL}, Received: val}
+	}
+
+	elem, err := urlDecodeType(dc, vr, tURL)
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
+
+// arrayDecodeValue is the ValueDecoderFunc for array types.
+func arrayDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.IsValid() || val.Kind() != reflect.Array {
+		return ValueDecoderError{Name: "ArrayDecodeValue", Kinds: []reflect.Kind{reflect.Array}, Received: val}
+	}
+
+	switch vrType := vr.Type(); vrType {
+	case TypeArray:
+	case Type(0), TypeEmbeddedDocument:
+		if val.Type().Elem() != tE {
+			return fmt.Errorf("cannot decode document into %s", val.Type())
+		}
+	case TypeBinary:
+		if val.Type().Elem() != tByte {
+			return fmt.Errorf("ArrayDecodeValue can only be used to decode binary into a byte array, got %v", vrType)
+		}
+		data, subtype, err := vr.ReadBinary()
+		if err != nil {
+			return err
+		}
+		if subtype != TypeBinaryGeneric && subtype != TypeBinaryBinaryOld {
+			return fmt.Errorf("ArrayDecodeValue can only be used to decode subtype 0x00 or 0x02 for %s, got %v", TypeBinary, subtype)
+		}
+
+		if len(data) > val.Len() {
+			return fmt.Errorf("more elements returned in array than can fit inside %s", val.Type())
+		}
+
+		for idx, elem := range data {
+			val.Index(idx).Set(reflect.ValueOf(elem))
+		}
+		return nil
+	case TypeNull:
+		val.Set(reflect.Zero(val.Type()))
+		return vr.ReadNull()
+	case TypeUndefined:
+		val.Set(reflect.Zero(val.Type()))
+		return vr.ReadUndefined()
+	default:
+		return fmt.Errorf("cannot decode %v into an array", vrType)
+	}
+
+	var elemsFunc func(DecodeContext, ValueReader, reflect.Value) ([]reflect.Value, error)
+	switch val.Type().Elem() {
+	case tE:
+		elemsFunc = decodeD
+	default:
+		elemsFunc = decodeDefault
+	}
+
+	elems, err := elemsFunc(dc, vr, val)
+	if err != nil {
+		return err
+	}
+
+	if len(elems) > val.Len() {
+		return fmt.Errorf("more elements returned in array than can fit inside %s, got %v elements", val.Type(), len(elems))
+	}
+
+	for idx, elem := range elems {
+		val.Index(idx).Set(elem)
+	}
+
+	return nil
+}
+
+// valueUnmarshalerDecodeValue is the ValueDecoderFunc for ValueUnmarshaler implementations.
+func valueUnmarshalerDecodeValue(_ DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.IsValid() || (!val.Type().Implements(tValueUnmarshaler) && !reflect.PtrTo(val.Type()).Implements(tValueUnmarshaler)) {
+		return ValueDecoderError{Name: "ValueUnmarshalerDecodeValue", Types: []reflect.Type{tValueUnmarshaler}, Received: val}
+	}
+
+	// If BSON value is null and the go value is a pointer, then don't call
+	// UnmarshalBSONValue. Even if the Go pointer is already initialized (i.e.,
+	// non-nil), encountering null in BSON will result in the pointer being
+	// directly set to nil here. Since the pointer is being replaced with nil,
+	// there is no opportunity (or reason) for the custom UnmarshalBSONValue logic
+	// to be called.
+	if vr.Type() == TypeNull && val.Kind() == reflect.Ptr {
+		val.Set(reflect.Zero(val.Type()))
+
+		return vr.ReadNull()
+	}
+
+	if val.Kind() == reflect.Ptr && val.IsNil() {
+		if !val.CanSet() {
+			return ValueDecoderError{Name: "ValueUnmarshalerDecodeValue", Types: []reflect.Type{tValueUnmarshaler}, Received: val}
+		}
+		val.Set(reflect.New(val.Type().Elem()))
+	}
+
+	if !val.Type().Implements(tValueUnmarshaler) {
+		if !val.CanAddr() {
+			return ValueDecoderError{Name: "ValueUnmarshalerDecodeValue", Types: []reflect.Type{tValueUnmarshaler}, Received: val}
+		}
+		val = val.Addr() // If the type doesn't implement the interface, a pointer to it must.
+	}
+
+	t, src, err := copyValueToBytes(vr)
+	if err != nil {
+		return err
+	}
+
+	m, ok := val.Interface().(ValueUnmarshaler)
+	if !ok {
+		// NB: this error should be unreachable due to the above checks
+		return ValueDecoderError{Name: "ValueUnmarshalerDecodeValue", Types: []reflect.Type{tValueUnmarshaler}, Received: val}
+	}
+	return m.UnmarshalBSONValue(byte(t), src)
+}
+
+// unmarshalerDecodeValue is the ValueDecoderFunc for Unmarshaler implementations.
+func unmarshalerDecodeValue(_ DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.IsValid() || (!val.Type().Implements(tUnmarshaler) && !reflect.PtrTo(val.Type()).Implements(tUnmarshaler)) {
+		return ValueDecoderError{Name: "UnmarshalerDecodeValue", Types: []reflect.Type{tUnmarshaler}, Received: val}
+	}
+
+	if val.Kind() == reflect.Ptr && val.IsNil() {
+		if !val.CanSet() {
+			return ValueDecoderError{Name: "UnmarshalerDecodeValue", Types: []reflect.Type{tUnmarshaler}, Received: val}
+		}
+		val.Set(reflect.New(val.Type().Elem()))
+	}
+
+	_, src, err := copyValueToBytes(vr)
+	if err != nil {
+		return err
+	}
+
+	// If the target Go value is a pointer and the BSON field value is empty, set the value to the
+	// zero value of the pointer (nil) and don't call UnmarshalBSON. UnmarshalBSON has no way to
+	// change the pointer value from within the function (only the value at the pointer address),
+	// so it can't set the pointer to "nil" itself. Since the most common Go value for an empty BSON
+	// field value is "nil", we set "nil" here and don't call UnmarshalBSON. This behavior matches
+	// the behavior of the Go "encoding/json" unmarshaler when the target Go value is a pointer and
+	// the JSON field value is "null".
+	if val.Kind() == reflect.Ptr && len(src) == 0 {
+		val.Set(reflect.Zero(val.Type()))
+		return nil
+	}
+
+	if !val.Type().Implements(tUnmarshaler) {
+		if !val.CanAddr() {
+			return ValueDecoderError{Name: "UnmarshalerDecodeValue", Types: []reflect.Type{tUnmarshaler}, Received: val}
+		}
+		val = val.Addr() // If the type doesn't implement the interface, a pointer to it must.
+	}
+
+	m, ok := val.Interface().(Unmarshaler)
+	if !ok {
+		// NB: this error should be unreachable due to the above checks
+		return ValueDecoderError{Name: "UnmarshalerDecodeValue", Types: []reflect.Type{tUnmarshaler}, Received: val}
+	}
+	return m.UnmarshalBSON(src)
+}
+
+// coreDocumentDecodeValue is the ValueDecoderFunc for bsoncore.Document.
+func coreDocumentDecodeValue(_ DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tCoreDocument {
+		return ValueDecoderError{Name: "CoreDocumentDecodeValue", Types: []reflect.Type{tCoreDocument}, Received: val}
+	}
+
+	if val.IsNil() {
+		val.Set(reflect.MakeSlice(val.Type(), 0, 0))
+	}
+
+	val.SetLen(0)
+
+	cdoc, err := appendDocumentBytes(val.Interface().(bsoncore.Document), vr)
+	val.Set(reflect.ValueOf(cdoc))
+	return err
+}
+
+func decodeDefault(dc DecodeContext, vr ValueReader, val reflect.Value) ([]reflect.Value, error) {
+	elems := make([]reflect.Value, 0)
+
+	ar, err := vr.ReadArray()
+	if err != nil {
+		return nil, err
+	}
+
+	eType := val.Type().Elem()
+
+	isInterfaceSlice := eType.Kind() == reflect.Interface && val.Len() > 0
+
+	// If this is not an interface slice with pre-populated elements, we can look up
+	// the decoder for eType once.
+	var vDecoder ValueDecoder
+	if !isInterfaceSlice {
+		vDecoder, err = dc.LookupDecoder(eType)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	idx := 0
+	for {
+		vr, err := ar.ReadValue()
+		if errors.Is(err, ErrEOA) {
+			break
+		}
+		if err != nil {
+			return nil, err
+		}
+
+		var elem reflect.Value
+		if isInterfaceSlice && idx < val.Len() {
+			// Decode into an existing interface{} slot.
+
+			elem = val.Index(idx).Elem()
+			switch {
+			case elem.Kind() != reflect.Ptr || elem.IsNil():
+				valueDecoder, err := dc.LookupDecoder(elem.Type())
+				if err != nil {
+					return nil, err
+				}
+
+				// If an element is allocated and unsettable, it must be overwritten.
+				if !elem.CanSet() {
+					elem = reflect.New(elem.Type()).Elem()
+				}
+
+				err = valueDecoder.DecodeValue(dc, vr, elem)
+				if err != nil {
+					return nil, newDecodeError(strconv.Itoa(idx), err)
+				}
+			case vr.Type() == TypeNull:
+				if err = vr.ReadNull(); err != nil {
+					return nil, err
+				}
+				elem = reflect.Zero(val.Index(idx).Type())
+			default:
+				e := elem.Elem()
+				valueDecoder, err := dc.LookupDecoder(e.Type())
+				if err != nil {
+					return nil, err
+				}
+				err = valueDecoder.DecodeValue(dc, vr, e)
+				if err != nil {
+					return nil, newDecodeError(strconv.Itoa(idx), err)
+				}
+			}
+		} else {
+			// For non-interface slices, or if we've exhausted the pre-populated
+			// slots, we create a fresh value.
+
+			if vDecoder == nil {
+				vDecoder, err = dc.LookupDecoder(eType)
+				if err != nil {
+					return nil, err
+				}
+			}
+			elem, err = decodeTypeOrValueWithInfo(vDecoder, dc, vr, eType)
+			if err != nil {
+				return nil, newDecodeError(strconv.Itoa(idx), err)
+			}
+		}
+
+		elems = append(elems, elem)
+		idx++
+	}
+
+	return elems, nil
+}
+
+func codeWithScopeDecodeType(dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tCodeWithScope {
+		return emptyValue, ValueDecoderError{
+			Name:     "CodeWithScopeDecodeValue",
+			Types:    []reflect.Type{tCodeWithScope},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	var cws CodeWithScope
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeCodeWithScope:
+		code, dr, err := vr.ReadCodeWithScope()
+		if err != nil {
+			return emptyValue, err
+		}
+
+		scope := reflect.New(tD).Elem()
+		elems, err := decodeElemsFromDocumentReader(dc, dr)
+		if err != nil {
+			return emptyValue, err
+		}
+
+		scope.Set(reflect.MakeSlice(tD, 0, len(elems)))
+		scope.Set(reflect.Append(scope, elems...))
+
+		cws = CodeWithScope{
+			Code:  JavaScript(code),
+			Scope: scope.Interface().(D),
+		}
+	case TypeNull:
+		err = vr.ReadNull()
+	case TypeUndefined:
+		err = vr.ReadUndefined()
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a CodeWithScope", vrType)
+	}
+	if err != nil {
+		return emptyValue, err
+	}
+
+	return reflect.ValueOf(cws), nil
+}
+
+// codeWithScopeDecodeValue is the ValueDecoderFunc for CodeWithScope.
+func codeWithScopeDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tCodeWithScope {
+		return ValueDecoderError{Name: "CodeWithScopeDecodeValue", Types: []reflect.Type{tCodeWithScope}, Received: val}
+	}
+
+	elem, err := codeWithScopeDecodeType(dc, vr, tCodeWithScope)
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
+
+func decodeD(dc DecodeContext, vr ValueReader, _ reflect.Value) ([]reflect.Value, error) {
+	switch vr.Type() {
+	case Type(0), TypeEmbeddedDocument:
+	default:
+		return nil, fmt.Errorf("cannot decode %v into a D", vr.Type())
+	}
+
+	dr, err := vr.ReadDocument()
+	if err != nil {
+		return nil, err
+	}
+
+	return decodeElemsFromDocumentReader(dc, dr)
+}
+
+func decodeElemsFromDocumentReader(dc DecodeContext, dr DocumentReader) ([]reflect.Value, error) {
+	decoder, err := dc.LookupDecoder(tEmpty)
+	if err != nil {
+		return nil, err
+	}
+
+	elems := make([]reflect.Value, 0)
+	for {
+		key, vr, err := dr.ReadElement()
+		if errors.Is(err, ErrEOD) {
+			break
+		}
+		if err != nil {
+			return nil, err
+		}
+
+		val := reflect.New(tEmpty).Elem()
+		err = decoder.DecodeValue(dc, vr, val)
+		if err != nil {
+			return nil, newDecodeError(key, err)
+		}
+
+		elems = append(elems, reflect.ValueOf(E{Key: key, Value: val.Interface()}))
+	}
+
+	return elems, nil
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/default_value_encoders.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/default_value_encoders.go
new file mode 100644
index 00000000..bd5a20f2
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/default_value_encoders.go
@@ -0,0 +1,517 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"encoding/json"
+	"errors"
+	"math"
+	"net/url"
+	"reflect"
+	"sync"
+
+	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
+)
+
+var bvwPool = sync.Pool{
+	New: func() interface{} {
+		return new(valueWriter)
+	},
+}
+
+var errInvalidValue = errors.New("cannot encode invalid element")
+
+var sliceWriterPool = sync.Pool{
+	New: func() interface{} {
+		sw := make(sliceWriter, 0)
+		return &sw
+	},
+}
+
+func encodeElement(ec EncodeContext, dw DocumentWriter, e E) error {
+	vw, err := dw.WriteDocumentElement(e.Key)
+	if err != nil {
+		return err
+	}
+
+	if e.Value == nil {
+		return vw.WriteNull()
+	}
+	encoder, err := ec.LookupEncoder(reflect.TypeOf(e.Value))
+	if err != nil {
+		return err
+	}
+
+	err = encoder.EncodeValue(ec, vw, reflect.ValueOf(e.Value))
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// registerDefaultEncoders will register the encoder methods attached to DefaultValueEncoders with
+// the provided RegistryBuilder.
+func registerDefaultEncoders(reg *Registry) {
+	mapEncoder := &mapCodec{}
+	uintCodec := &uintCodec{}
+
+	reg.RegisterTypeEncoder(tByteSlice, &byteSliceCodec{})
+	reg.RegisterTypeEncoder(tTime, &timeCodec{})
+	reg.RegisterTypeEncoder(tEmpty, &emptyInterfaceCodec{})
+	reg.RegisterTypeEncoder(tCoreArray, &arrayCodec{})
+	reg.RegisterTypeEncoder(tOID, ValueEncoderFunc(objectIDEncodeValue))
+	reg.RegisterTypeEncoder(tDecimal, ValueEncoderFunc(decimal128EncodeValue))
+	reg.RegisterTypeEncoder(tJSONNumber, ValueEncoderFunc(jsonNumberEncodeValue))
+	reg.RegisterTypeEncoder(tURL, ValueEncoderFunc(urlEncodeValue))
+	reg.RegisterTypeEncoder(tJavaScript, ValueEncoderFunc(javaScriptEncodeValue))
+	reg.RegisterTypeEncoder(tSymbol, ValueEncoderFunc(symbolEncodeValue))
+	reg.RegisterTypeEncoder(tBinary, ValueEncoderFunc(binaryEncodeValue))
+	reg.RegisterTypeEncoder(tVector, ValueEncoderFunc(vectorEncodeValue))
+	reg.RegisterTypeEncoder(tUndefined, ValueEncoderFunc(undefinedEncodeValue))
+	reg.RegisterTypeEncoder(tDateTime, ValueEncoderFunc(dateTimeEncodeValue))
+	reg.RegisterTypeEncoder(tNull, ValueEncoderFunc(nullEncodeValue))
+	reg.RegisterTypeEncoder(tRegex, ValueEncoderFunc(regexEncodeValue))
+	reg.RegisterTypeEncoder(tDBPointer, ValueEncoderFunc(dbPointerEncodeValue))
+	reg.RegisterTypeEncoder(tTimestamp, ValueEncoderFunc(timestampEncodeValue))
+	reg.RegisterTypeEncoder(tMinKey, ValueEncoderFunc(minKeyEncodeValue))
+	reg.RegisterTypeEncoder(tMaxKey, ValueEncoderFunc(maxKeyEncodeValue))
+	reg.RegisterTypeEncoder(tCoreDocument, ValueEncoderFunc(coreDocumentEncodeValue))
+	reg.RegisterTypeEncoder(tCodeWithScope, ValueEncoderFunc(codeWithScopeEncodeValue))
+	reg.RegisterKindEncoder(reflect.Bool, ValueEncoderFunc(booleanEncodeValue))
+	reg.RegisterKindEncoder(reflect.Int, ValueEncoderFunc(intEncodeValue))
+	reg.RegisterKindEncoder(reflect.Int8, ValueEncoderFunc(intEncodeValue))
+	reg.RegisterKindEncoder(reflect.Int16, ValueEncoderFunc(intEncodeValue))
+	reg.RegisterKindEncoder(reflect.Int32, ValueEncoderFunc(intEncodeValue))
+	reg.RegisterKindEncoder(reflect.Int64, ValueEncoderFunc(intEncodeValue))
+	reg.RegisterKindEncoder(reflect.Uint, uintCodec)
+	reg.RegisterKindEncoder(reflect.Uint8, uintCodec)
+	reg.RegisterKindEncoder(reflect.Uint16, uintCodec)
+	reg.RegisterKindEncoder(reflect.Uint32, uintCodec)
+	reg.RegisterKindEncoder(reflect.Uint64, uintCodec)
+	reg.RegisterKindEncoder(reflect.Float32, ValueEncoderFunc(floatEncodeValue))
+	reg.RegisterKindEncoder(reflect.Float64, ValueEncoderFunc(floatEncodeValue))
+	reg.RegisterKindEncoder(reflect.Array, ValueEncoderFunc(arrayEncodeValue))
+	reg.RegisterKindEncoder(reflect.Map, mapEncoder)
+	reg.RegisterKindEncoder(reflect.Slice, &sliceCodec{})
+	reg.RegisterKindEncoder(reflect.String, &stringCodec{})
+	reg.RegisterKindEncoder(reflect.Struct, newStructCodec(mapEncoder))
+	reg.RegisterKindEncoder(reflect.Ptr, &pointerCodec{})
+	reg.RegisterInterfaceEncoder(tValueMarshaler, ValueEncoderFunc(valueMarshalerEncodeValue))
+	reg.RegisterInterfaceEncoder(tMarshaler, ValueEncoderFunc(marshalerEncodeValue))
+}
+
+// booleanEncodeValue is the ValueEncoderFunc for bool types.
+func booleanEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Kind() != reflect.Bool {
+		return ValueEncoderError{Name: "BooleanEncodeValue", Kinds: []reflect.Kind{reflect.Bool}, Received: val}
+	}
+	return vw.WriteBoolean(val.Bool())
+}
+
+func fitsIn32Bits(i int64) bool {
+	return math.MinInt32 <= i && i <= math.MaxInt32
+}
+
+// intEncodeValue is the ValueEncoderFunc for int types.
+func intEncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
+	switch val.Kind() {
+	case reflect.Int8, reflect.Int16, reflect.Int32:
+		return vw.WriteInt32(int32(val.Int()))
+	case reflect.Int:
+		i64 := val.Int()
+		if fitsIn32Bits(i64) {
+			return vw.WriteInt32(int32(i64))
+		}
+		return vw.WriteInt64(i64)
+	case reflect.Int64:
+		i64 := val.Int()
+		if ec.minSize && fitsIn32Bits(i64) {
+			return vw.WriteInt32(int32(i64))
+		}
+		return vw.WriteInt64(i64)
+	}
+
+	return ValueEncoderError{
+		Name:     "IntEncodeValue",
+		Kinds:    []reflect.Kind{reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int},
+		Received: val,
+	}
+}
+
+// floatEncodeValue is the ValueEncoderFunc for float types.
+func floatEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	switch val.Kind() {
+	case reflect.Float32, reflect.Float64:
+		return vw.WriteDouble(val.Float())
+	}
+
+	return ValueEncoderError{Name: "FloatEncodeValue", Kinds: []reflect.Kind{reflect.Float32, reflect.Float64}, Received: val}
+}
+
+// objectIDEncodeValue is the ValueEncoderFunc for ObjectID.
+func objectIDEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tOID {
+		return ValueEncoderError{Name: "ObjectIDEncodeValue", Types: []reflect.Type{tOID}, Received: val}
+	}
+	return vw.WriteObjectID(val.Interface().(ObjectID))
+}
+
+// decimal128EncodeValue is the ValueEncoderFunc for Decimal128.
+func decimal128EncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tDecimal {
+		return ValueEncoderError{Name: "Decimal128EncodeValue", Types: []reflect.Type{tDecimal}, Received: val}
+	}
+	return vw.WriteDecimal128(val.Interface().(Decimal128))
+}
+
+// jsonNumberEncodeValue is the ValueEncoderFunc for json.Number.
+func jsonNumberEncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tJSONNumber {
+		return ValueEncoderError{Name: "JSONNumberEncodeValue", Types: []reflect.Type{tJSONNumber}, Received: val}
+	}
+	jsnum := val.Interface().(json.Number)
+
+	// Attempt int first, then float64
+	if i64, err := jsnum.Int64(); err == nil {
+		return intEncodeValue(ec, vw, reflect.ValueOf(i64))
+	}
+
+	f64, err := jsnum.Float64()
+	if err != nil {
+		return err
+	}
+
+	return floatEncodeValue(ec, vw, reflect.ValueOf(f64))
+}
+
+// urlEncodeValue is the ValueEncoderFunc for url.URL.
+func urlEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tURL {
+		return ValueEncoderError{Name: "URLEncodeValue", Types: []reflect.Type{tURL}, Received: val}
+	}
+	u := val.Interface().(url.URL)
+	return vw.WriteString(u.String())
+}
+
+// arrayEncodeValue is the ValueEncoderFunc for array types.
+func arrayEncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Kind() != reflect.Array {
+		return ValueEncoderError{Name: "ArrayEncodeValue", Kinds: []reflect.Kind{reflect.Array}, Received: val}
+	}
+
+	// If we have a []E we want to treat it as a document instead of as an array.
+	if val.Type().Elem() == tE {
+		dw, err := vw.WriteDocument()
+		if err != nil {
+			return err
+		}
+
+		for idx := 0; idx < val.Len(); idx++ {
+			e := val.Index(idx).Interface().(E)
+			err = encodeElement(ec, dw, e)
+			if err != nil {
+				return err
+			}
+		}
+
+		return dw.WriteDocumentEnd()
+	}
+
+	// If we have a []byte we want to treat it as a binary instead of as an array.
+	if val.Type().Elem() == tByte {
+		var byteSlice []byte
+		for idx := 0; idx < val.Len(); idx++ {
+			byteSlice = append(byteSlice, val.Index(idx).Interface().(byte))
+		}
+		return vw.WriteBinary(byteSlice)
+	}
+
+	aw, err := vw.WriteArray()
+	if err != nil {
+		return err
+	}
+
+	elemType := val.Type().Elem()
+	encoder, err := ec.LookupEncoder(elemType)
+	if err != nil && elemType.Kind() != reflect.Interface {
+		return err
+	}
+
+	for idx := 0; idx < val.Len(); idx++ {
+		currEncoder, currVal, lookupErr := lookupElementEncoder(ec, encoder, val.Index(idx))
+		if lookupErr != nil && !errors.Is(lookupErr, errInvalidValue) {
+			return lookupErr
+		}
+
+		vw, err := aw.WriteArrayElement()
+		if err != nil {
+			return err
+		}
+
+		if errors.Is(lookupErr, errInvalidValue) {
+			err = vw.WriteNull()
+			if err != nil {
+				return err
+			}
+			continue
+		}
+
+		err = currEncoder.EncodeValue(ec, vw, currVal)
+		if err != nil {
+			return err
+		}
+	}
+	return aw.WriteArrayEnd()
+}
+
+func lookupElementEncoder(ec EncodeContext, origEncoder ValueEncoder, currVal reflect.Value) (ValueEncoder, reflect.Value, error) {
+	if origEncoder != nil || (currVal.Kind() != reflect.Interface) {
+		return origEncoder, currVal, nil
+	}
+	currVal = currVal.Elem()
+	if !currVal.IsValid() {
+		return nil, currVal, errInvalidValue
+	}
+	currEncoder, err := ec.LookupEncoder(currVal.Type())
+
+	return currEncoder, currVal, err
+}
+
+// valueMarshalerEncodeValue is the ValueEncoderFunc for ValueMarshaler implementations.
+func valueMarshalerEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	// Either val or a pointer to val must implement ValueMarshaler
+	switch {
+	case !val.IsValid():
+		return ValueEncoderError{Name: "ValueMarshalerEncodeValue", Types: []reflect.Type{tValueMarshaler}, Received: val}
+	case val.Type().Implements(tValueMarshaler):
+		// If ValueMarshaler is implemented on a concrete type, make sure that val isn't a nil pointer
+		if isImplementationNil(val, tValueMarshaler) {
+			return vw.WriteNull()
+		}
+	case reflect.PtrTo(val.Type()).Implements(tValueMarshaler) && val.CanAddr():
+		val = val.Addr()
+	default:
+		return ValueEncoderError{Name: "ValueMarshalerEncodeValue", Types: []reflect.Type{tValueMarshaler}, Received: val}
+	}
+
+	m, ok := val.Interface().(ValueMarshaler)
+	if !ok {
+		return vw.WriteNull()
+	}
+	t, data, err := m.MarshalBSONValue()
+	if err != nil {
+		return err
+	}
+	return copyValueFromBytes(vw, Type(t), data)
+}
+
+// marshalerEncodeValue is the ValueEncoderFunc for Marshaler implementations.
+func marshalerEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	// Either val or a pointer to val must implement Marshaler
+	switch {
+	case !val.IsValid():
+		return ValueEncoderError{Name: "MarshalerEncodeValue", Types: []reflect.Type{tMarshaler}, Received: val}
+	case val.Type().Implements(tMarshaler):
+		// If Marshaler is implemented on a concrete type, make sure that val isn't a nil pointer
+		if isImplementationNil(val, tMarshaler) {
+			return vw.WriteNull()
+		}
+	case reflect.PtrTo(val.Type()).Implements(tMarshaler) && val.CanAddr():
+		val = val.Addr()
+	default:
+		return ValueEncoderError{Name: "MarshalerEncodeValue", Types: []reflect.Type{tMarshaler}, Received: val}
+	}
+
+	m, ok := val.Interface().(Marshaler)
+	if !ok {
+		return vw.WriteNull()
+	}
+	data, err := m.MarshalBSON()
+	if err != nil {
+		return err
+	}
+	return copyValueFromBytes(vw, TypeEmbeddedDocument, data)
+}
+
+// javaScriptEncodeValue is the ValueEncoderFunc for the JavaScript type.
+func javaScriptEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tJavaScript {
+		return ValueEncoderError{Name: "JavaScriptEncodeValue", Types: []reflect.Type{tJavaScript}, Received: val}
+	}
+
+	return vw.WriteJavascript(val.String())
+}
+
+// symbolEncodeValue is the ValueEncoderFunc for the Symbol type.
+func symbolEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tSymbol {
+		return ValueEncoderError{Name: "SymbolEncodeValue", Types: []reflect.Type{tSymbol}, Received: val}
+	}
+
+	return vw.WriteSymbol(val.String())
+}
+
+// binaryEncodeValue is the ValueEncoderFunc for Binary.
+func binaryEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tBinary {
+		return ValueEncoderError{Name: "BinaryEncodeValue", Types: []reflect.Type{tBinary}, Received: val}
+	}
+	b := val.Interface().(Binary)
+
+	return vw.WriteBinaryWithSubtype(b.Data, b.Subtype)
+}
+
+// vectorEncodeValue is the ValueEncoderFunc for Vector.
+func vectorEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	t := val.Type()
+	if !val.IsValid() || t != tVector {
+		return ValueEncoderError{Name: "VectorEncodeValue",
+			Types:    []reflect.Type{tVector},
+			Received: val,
+		}
+	}
+	v := val.Interface().(Vector)
+	b := v.Binary()
+	return vw.WriteBinaryWithSubtype(b.Data, b.Subtype)
+}
+
+// undefinedEncodeValue is the ValueEncoderFunc for Undefined.
+func undefinedEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tUndefined {
+		return ValueEncoderError{Name: "UndefinedEncodeValue", Types: []reflect.Type{tUndefined}, Received: val}
+	}
+
+	return vw.WriteUndefined()
+}
+
+// dateTimeEncodeValue is the ValueEncoderFunc for DateTime.
+func dateTimeEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tDateTime {
+		return ValueEncoderError{Name: "DateTimeEncodeValue", Types: []reflect.Type{tDateTime}, Received: val}
+	}
+
+	return vw.WriteDateTime(val.Int())
+}
+
+// nullEncodeValue is the ValueEncoderFunc for Null.
+func nullEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tNull {
+		return ValueEncoderError{Name: "NullEncodeValue", Types: []reflect.Type{tNull}, Received: val}
+	}
+
+	return vw.WriteNull()
+}
+
+// regexEncodeValue is the ValueEncoderFunc for Regex.
+func regexEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tRegex {
+		return ValueEncoderError{Name: "RegexEncodeValue", Types: []reflect.Type{tRegex}, Received: val}
+	}
+
+	regex := val.Interface().(Regex)
+
+	return vw.WriteRegex(regex.Pattern, regex.Options)
+}
+
+// dbPointerEncodeValue is the ValueEncoderFunc for DBPointer.
+func dbPointerEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tDBPointer {
+		return ValueEncoderError{Name: "DBPointerEncodeValue", Types: []reflect.Type{tDBPointer}, Received: val}
+	}
+
+	dbp := val.Interface().(DBPointer)
+
+	return vw.WriteDBPointer(dbp.DB, dbp.Pointer)
+}
+
+// timestampEncodeValue is the ValueEncoderFunc for Timestamp.
+func timestampEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tTimestamp {
+		return ValueEncoderError{Name: "TimestampEncodeValue", Types: []reflect.Type{tTimestamp}, Received: val}
+	}
+
+	ts := val.Interface().(Timestamp)
+
+	return vw.WriteTimestamp(ts.T, ts.I)
+}
+
+// minKeyEncodeValue is the ValueEncoderFunc for MinKey.
+func minKeyEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tMinKey {
+		return ValueEncoderError{Name: "MinKeyEncodeValue", Types: []reflect.Type{tMinKey}, Received: val}
+	}
+
+	return vw.WriteMinKey()
+}
+
+// maxKeyEncodeValue is the ValueEncoderFunc for MaxKey.
+func maxKeyEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tMaxKey {
+		return ValueEncoderError{Name: "MaxKeyEncodeValue", Types: []reflect.Type{tMaxKey}, Received: val}
+	}
+
+	return vw.WriteMaxKey()
+}
+
+// coreDocumentEncodeValue is the ValueEncoderFunc for bsoncore.Document.
+func coreDocumentEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tCoreDocument {
+		return ValueEncoderError{Name: "CoreDocumentEncodeValue", Types: []reflect.Type{tCoreDocument}, Received: val}
+	}
+
+	cdoc := val.Interface().(bsoncore.Document)
+
+	return copyDocumentFromBytes(vw, cdoc)
+}
+
+// codeWithScopeEncodeValue is the ValueEncoderFunc for CodeWithScope.
+func codeWithScopeEncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tCodeWithScope {
+		return ValueEncoderError{Name: "CodeWithScopeEncodeValue", Types: []reflect.Type{tCodeWithScope}, Received: val}
+	}
+
+	cws := val.Interface().(CodeWithScope)
+
+	dw, err := vw.WriteCodeWithScope(string(cws.Code))
+	if err != nil {
+		return err
+	}
+
+	sw := sliceWriterPool.Get().(*sliceWriter)
+	defer sliceWriterPool.Put(sw)
+	*sw = (*sw)[:0]
+
+	scopeVW := bvwPool.Get().(*valueWriter)
+	scopeVW.reset(scopeVW.buf[:0])
+	scopeVW.w = sw
+	defer bvwPool.Put(scopeVW)
+
+	encoder, err := ec.LookupEncoder(reflect.TypeOf(cws.Scope))
+	if err != nil {
+		return err
+	}
+
+	err = encoder.EncodeValue(ec, scopeVW, reflect.ValueOf(cws.Scope))
+	if err != nil {
+		return err
+	}
+
+	err = copyBytesToDocumentWriter(dw, *sw)
+	if err != nil {
+		return err
+	}
+	return dw.WriteDocumentEnd()
+}
+
+// isImplementationNil returns if val is a nil pointer and inter is implemented on a concrete type
+func isImplementationNil(val reflect.Value, inter reflect.Type) bool {
+	vt := val.Type()
+	for vt.Kind() == reflect.Ptr {
+		vt = vt.Elem()
+	}
+	return vt.Implements(inter) && val.Kind() == reflect.Ptr && val.IsNil()
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/doc.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/doc.go
new file mode 100644
index 00000000..81aceef2
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/doc.go
@@ -0,0 +1,155 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+// Package bson is a library for reading, writing, and manipulating BSON. BSON is a binary serialization format used to
+// store documents and make remote procedure calls in MongoDB. The BSON specification is located at https://bsonspec.org.
+// The BSON library handles marshaling and unmarshaling of values through a configurable codec system. For a description
+// of the codec system and examples of registering custom codecs, see the bsoncodec package. For additional information
+// and usage examples, check out the [Work with BSON] page in the Go Driver docs site.
+//
+// # Raw BSON
+//
+// The Raw family of types is used to validate and retrieve elements from a slice of bytes. This
+// type is most useful when you want do lookups on BSON bytes without unmarshaling it into another
+// type.
+//
+// Example:
+//
+//	var raw bson.Raw = ... // bytes from somewhere
+//	err := raw.Validate()
+//	if err != nil { return err }
+//	val := raw.Lookup("foo")
+//	i32, ok := val.Int32OK()
+//	// do something with i32...
+//
+// # Native Go Types
+//
+// The D and M types defined in this package can be used to build representations of BSON using native Go types. D is a
+// slice and M is a map. For more information about the use cases for these types, see the documentation on the type
+// definitions.
+//
+// Note that a D should not be constructed with duplicate key names, as that can cause undefined server behavior.
+//
+// Example:
+//
+//	bson.D{{"foo", "bar"}, {"hello", "world"}, {"pi", 3.14159}}
+//	bson.M{"foo": "bar", "hello": "world", "pi": 3.14159}
+//
+// When decoding BSON to a D or M, the following type mappings apply when unmarshaling:
+//
+//  1. BSON int32 unmarshals to an int32.
+//  2. BSON int64 unmarshals to an int64.
+//  3. BSON double unmarshals to a float64.
+//  4. BSON string unmarshals to a string.
+//  5. BSON boolean unmarshals to a bool.
+//  6. BSON embedded document unmarshals to the parent type (i.e. D for a D, M for an M).
+//  7. BSON array unmarshals to a bson.A.
+//  8. BSON ObjectId unmarshals to a bson.ObjectID.
+//  9. BSON datetime unmarshals to a bson.DateTime.
+//  10. BSON binary unmarshals to a bson.Binary.
+//  11. BSON regular expression unmarshals to a bson.Regex.
+//  12. BSON JavaScript unmarshals to a bson.JavaScript.
+//  13. BSON code with scope unmarshals to a bson.CodeWithScope.
+//  14. BSON timestamp unmarshals to an bson.Timestamp.
+//  15. BSON 128-bit decimal unmarshals to an bson.Decimal128.
+//  16. BSON min key unmarshals to an bson.MinKey.
+//  17. BSON max key unmarshals to an bson.MaxKey.
+//  18. BSON undefined unmarshals to a bson.Undefined.
+//  19. BSON null unmarshals to nil.
+//  20. BSON DBPointer unmarshals to a bson.DBPointer.
+//  21. BSON symbol unmarshals to a bson.Symbol.
+//
+// The above mappings also apply when marshaling a D or M to BSON. Some other useful marshaling mappings are:
+//
+//  1. time.Time marshals to a BSON datetime.
+//  2. int8, int16, and int32 marshal to a BSON int32.
+//  3. int marshals to a BSON int32 if the value is between math.MinInt32 and math.MaxInt32, inclusive, and a BSON int64
+//     otherwise.
+//  4. int64 marshals to BSON int64 (unless [Encoder.IntMinSize] is set).
+//  5. uint8 and uint16 marshal to a BSON int32.
+//  6. uint, uint32, and uint64 marshal to a BSON int64 (unless [Encoder.IntMinSize] is set).
+//  7. BSON null and undefined values will unmarshal into the zero value of a field (e.g. unmarshaling a BSON null or
+//     undefined value into a string will yield the empty string.).
+//
+// # Structs
+//
+// Structs can be marshaled/unmarshaled to/from BSON or Extended JSON. When transforming structs to/from BSON or Extended
+// JSON, the following rules apply:
+//
+//  1. Only exported fields in structs will be marshaled or unmarshaled.
+//
+//  2. When marshaling a struct, each field will be lowercased to generate the key for the corresponding BSON element.
+//     For example, a struct field named "Foo" will generate key "foo". This can be overridden via a struct tag (e.g.
+//     `bson:"fooField"` to generate key "fooField" instead).
+//
+//  3. An embedded struct field is marshaled as a subdocument. The key will be the lowercased name of the field's type.
+//
+//  4. A pointer field is marshaled as the underlying type if the pointer is non-nil. If the pointer is nil, it is
+//     marshaled as a BSON null value.
+//
+//  5. When unmarshaling, a field of type interface{} will follow the D/M type mappings listed above. BSON documents
+//     unmarshaled into an interface{} field will be unmarshaled as a D.
+//
+// The encoding of each struct field can be customized by the "bson" struct tag.
+//
+// This tag behavior is configurable, and different struct tag behavior can be configured by initializing a new
+// bsoncodec.StructCodec with the desired tag parser and registering that StructCodec onto the Registry. By default, JSON
+// tags are not honored, but that can be enabled by creating a StructCodec with JSONFallbackStructTagParser, like below:
+//
+// Example:
+//
+//	structcodec, _ := bsoncodec.NewStructCodec(bsoncodec.JSONFallbackStructTagParser)
+//
+// The bson tag gives the name of the field, possibly followed by a comma-separated list of options.
+// The name may be empty in order to specify options without overriding the default field name. The following options can
+// be used to configure behavior:
+//
+//  1. omitempty: If the "omitempty" struct tag is specified on a field, the field will not be marshaled if it is set to
+//     an "empty" value. Numbers, booleans, and strings are considered empty if their value is equal to the zero value for
+//     the type (i.e. 0 for numbers, false for booleans, and "" for strings). Slices, maps, and arrays are considered
+//     empty if they are of length zero. Interfaces and pointers are considered empty if their value is nil. By default,
+//     structs are only considered empty if the struct type implements [bsoncodec.Zeroer] and the IsZero
+//     method returns true. Struct types that do not implement [bsoncodec.Zeroer] are never considered empty and will be
+//     marshaled as embedded documents. NOTE: It is recommended that this tag be used for all slice and map fields.
+//
+//  2. minsize: If the minsize struct tag is specified on a field of type int64, uint, uint32, or uint64 and the value of
+//     the field can fit in a signed int32, the field will be serialized as a BSON int32 rather than a BSON int64. For
+//     other types, this tag is ignored.
+//
+//  3. truncate: If the truncate struct tag is specified on a field with a non-float numeric type, BSON doubles
+//     unmarshaled into that field will be truncated at the decimal point. For example, if 3.14 is unmarshaled into a
+//     field of type int, it will be unmarshaled as 3. If this tag is not specified, the decoder will throw an error if
+//     the value cannot be decoded without losing precision. For float64 or non-numeric types, this tag is ignored.
+//
+//  4. inline: If the inline struct tag is specified for a struct or map field, the field will be "flattened" when
+//     marshaling and "un-flattened" when unmarshaling. This means that all of the fields in that struct/map will be
+//     pulled up one level and will become top-level fields rather than being fields in a nested document. For example,
+//     if a map field named "Map" with value map[string]interface{}{"foo": "bar"} is inlined, the resulting document will
+//     be {"foo": "bar"} instead of {"map": {"foo": "bar"}}. There can only be one inlined map field in a struct. If
+//     there are duplicated fields in the resulting document when an inlined struct is marshaled, the inlined field will
+//     be overwritten. If there are duplicated fields in the resulting document when an inlined map is marshaled, an
+//     error will be returned. This tag can be used with fields that are pointers to structs. If an inlined pointer field
+//     is nil, it will not be marshaled. For fields that are not maps or structs, this tag is ignored.
+//
+// # Marshaling and Unmarshaling
+//
+// Manually marshaling and unmarshaling can be done with the Marshal and Unmarshal family of functions.
+//
+// bsoncodec code provides a system for encoding values to BSON representations and decoding
+// values from BSON representations. This package considers both binary BSON and ExtendedJSON as
+// BSON representations. The types in this package enable a flexible system for handling this
+// encoding and decoding.
+//
+// The codec system is composed of two parts:
+//
+// 1) [ValueEncoder] and [ValueDecoder] that handle encoding and decoding Go values to and from BSON
+// representations.
+//
+// 2) A [Registry] that holds these ValueEncoders and ValueDecoders and provides methods for
+// retrieving them.
+//
+// [Work with BSON]: https://www.mongodb.com/docs/drivers/go/current/fundamentals/bson/
+package bson
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/empty_interface_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/empty_interface_codec.go
new file mode 100644
index 00000000..80d44d8c
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/empty_interface_codec.go
@@ -0,0 +1,127 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"reflect"
+)
+
+// emptyInterfaceCodec is the Codec used for interface{} values.
+type emptyInterfaceCodec struct {
+	// decodeBinaryAsSlice causes DecodeValue to unmarshal BSON binary field values that are the
+	// "Generic" or "Old" BSON binary subtype as a Go byte slice instead of a Binary.
+	decodeBinaryAsSlice bool
+}
+
+// Assert that emptyInterfaceCodec satisfies the typeDecoder interface, which allows it
+// to be used by collection type decoders (e.g. map, slice, etc) to set individual values in a
+// collection.
+var _ typeDecoder = &emptyInterfaceCodec{}
+
+// EncodeValue is the ValueEncoderFunc for interface{}.
+func (eic *emptyInterfaceCodec) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tEmpty {
+		return ValueEncoderError{Name: "EmptyInterfaceEncodeValue", Types: []reflect.Type{tEmpty}, Received: val}
+	}
+
+	if val.IsNil() {
+		return vw.WriteNull()
+	}
+	encoder, err := ec.LookupEncoder(val.Elem().Type())
+	if err != nil {
+		return err
+	}
+
+	return encoder.EncodeValue(ec, vw, val.Elem())
+}
+
+func (eic *emptyInterfaceCodec) getEmptyInterfaceDecodeType(dc DecodeContext, valueType Type) (reflect.Type, error) {
+	isDocument := valueType == Type(0) || valueType == TypeEmbeddedDocument
+	if isDocument {
+		if dc.defaultDocumentType != nil {
+			// If the bsontype is an embedded document and the DocumentType is set on the DecodeContext, then return
+			// that type.
+			return dc.defaultDocumentType, nil
+		}
+	}
+
+	rtype, err := dc.LookupTypeMapEntry(valueType)
+	if err == nil {
+		return rtype, nil
+	}
+
+	if isDocument {
+		// For documents, fallback to looking up a type map entry for Type(0) or TypeEmbeddedDocument,
+		// depending on the original valueType.
+		var lookupType Type
+		switch valueType {
+		case Type(0):
+			lookupType = TypeEmbeddedDocument
+		case TypeEmbeddedDocument:
+			lookupType = Type(0)
+		}
+
+		rtype, err = dc.LookupTypeMapEntry(lookupType)
+		if err == nil {
+			return rtype, nil
+		}
+		// fallback to bson.D
+		return tD, nil
+	}
+
+	return nil, err
+}
+
+func (eic *emptyInterfaceCodec) decodeType(dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tEmpty {
+		return emptyValue, ValueDecoderError{Name: "EmptyInterfaceDecodeValue", Types: []reflect.Type{tEmpty}, Received: reflect.Zero(t)}
+	}
+
+	rtype, err := eic.getEmptyInterfaceDecodeType(dc, vr.Type())
+	if err != nil {
+		switch vr.Type() {
+		case TypeNull:
+			return reflect.Zero(t), vr.ReadNull()
+		default:
+			return emptyValue, err
+		}
+	}
+
+	decoder, err := dc.LookupDecoder(rtype)
+	if err != nil {
+		return emptyValue, err
+	}
+
+	elem, err := decodeTypeOrValueWithInfo(decoder, dc, vr, rtype)
+	if err != nil {
+		return emptyValue, err
+	}
+
+	if (eic.decodeBinaryAsSlice || dc.binaryAsSlice) && rtype == tBinary {
+		binElem := elem.Interface().(Binary)
+		if binElem.Subtype == TypeBinaryGeneric || binElem.Subtype == TypeBinaryBinaryOld {
+			elem = reflect.ValueOf(binElem.Data)
+		}
+	}
+
+	return elem, nil
+}
+
+// DecodeValue is the ValueDecoderFunc for interface{}.
+func (eic *emptyInterfaceCodec) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tEmpty {
+		return ValueDecoderError{Name: "EmptyInterfaceDecodeValue", Types: []reflect.Type{tEmpty}, Received: val}
+	}
+
+	elem, err := eic.decodeType(dc, vr, val.Type())
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/encoder.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/encoder.go
new file mode 100644
index 00000000..8299e94f
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/encoder.go
@@ -0,0 +1,130 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"reflect"
+	"sync"
+)
+
+// This pool is used to keep the allocations of Encoders down. This is only used for the Marshal*
+// methods and is not consumable from outside of this package. The Encoders retrieved from this pool
+// must have both Reset and SetRegistry called on them.
+var encPool = sync.Pool{
+	New: func() interface{} {
+		return new(Encoder)
+	},
+}
+
+// An Encoder writes a serialization format to an output stream. It writes to a ValueWriter
+// as the destination of BSON data.
+type Encoder struct {
+	ec EncodeContext
+	vw ValueWriter
+}
+
+// NewEncoder returns a new encoder that writes to vw.
+func NewEncoder(vw ValueWriter) *Encoder {
+	return &Encoder{
+		ec: EncodeContext{Registry: defaultRegistry},
+		vw: vw,
+	}
+}
+
+// Encode writes the BSON encoding of val to the stream.
+//
+// See [Marshal] for details about BSON marshaling behavior.
+func (e *Encoder) Encode(val interface{}) error {
+	if marshaler, ok := val.(Marshaler); ok {
+		// TODO(skriptble): Should we have a MarshalAppender interface so that we can have []byte reuse?
+		buf, err := marshaler.MarshalBSON()
+		if err != nil {
+			return err
+		}
+		return copyDocumentFromBytes(e.vw, buf)
+	}
+
+	encoder, err := e.ec.LookupEncoder(reflect.TypeOf(val))
+	if err != nil {
+		return err
+	}
+
+	return encoder.EncodeValue(e.ec, e.vw, reflect.ValueOf(val))
+}
+
+// Reset will reset the state of the Encoder, using the same *EncodeContext used in
+// the original construction but using vw.
+func (e *Encoder) Reset(vw ValueWriter) {
+	e.vw = vw
+}
+
+// SetRegistry replaces the current registry of the Encoder with r.
+func (e *Encoder) SetRegistry(r *Registry) {
+	e.ec.Registry = r
+}
+
+// ErrorOnInlineDuplicates causes the Encoder to return an error if there is a duplicate field in
+// the marshaled BSON when the "inline" struct tag option is set.
+func (e *Encoder) ErrorOnInlineDuplicates() {
+	e.ec.errorOnInlineDuplicates = true
+}
+
+// IntMinSize causes the Encoder to marshal Go integer values (int, int8, int16, int32, int64, uint,
+// uint8, uint16, uint32, or uint64) as the minimum BSON int size (either 32 or 64 bits) that can
+// represent the integer value.
+func (e *Encoder) IntMinSize() {
+	e.ec.minSize = true
+}
+
+// StringifyMapKeysWithFmt causes the Encoder to convert Go map keys to BSON document field name
+// strings using fmt.Sprint instead of the default string conversion logic.
+func (e *Encoder) StringifyMapKeysWithFmt() {
+	e.ec.stringifyMapKeysWithFmt = true
+}
+
+// NilMapAsEmpty causes the Encoder to marshal nil Go maps as empty BSON documents instead of BSON
+// null.
+func (e *Encoder) NilMapAsEmpty() {
+	e.ec.nilMapAsEmpty = true
+}
+
+// NilSliceAsEmpty causes the Encoder to marshal nil Go slices as empty BSON arrays instead of BSON
+// null.
+func (e *Encoder) NilSliceAsEmpty() {
+	e.ec.nilSliceAsEmpty = true
+}
+
+// NilByteSliceAsEmpty causes the Encoder to marshal nil Go byte slices as empty BSON binary values
+// instead of BSON null.
+func (e *Encoder) NilByteSliceAsEmpty() {
+	e.ec.nilByteSliceAsEmpty = true
+}
+
+// TODO(GODRIVER-2820): Update the description to remove the note about only examining exported
+// TODO struct fields once the logic is updated to also inspect private struct fields.
+
+// OmitZeroStruct causes the Encoder to consider the zero value for a struct (e.g. MyStruct{})
+// as empty and omit it from the marshaled BSON when the "omitempty" struct tag option is set
+// or the OmitEmpty() method is called.
+//
+// Note that the Encoder only examines exported struct fields when determining if a struct is the
+// zero value. It considers pointers to a zero struct value (e.g. &MyStruct{}) not empty.
+func (e *Encoder) OmitZeroStruct() {
+	e.ec.omitZeroStruct = true
+}
+
+// OmitEmpty causes the Encoder to omit empty values from the marshaled BSON as the "omitempty"
+// struct tag option is set.
+func (e *Encoder) OmitEmpty() {
+	e.ec.omitEmpty = true
+}
+
+// UseJSONStructTags causes the Encoder to fall back to using the "json" struct tag if a "bson"
+// struct tag is not specified.
+func (e *Encoder) UseJSONStructTags() {
+	e.ec.useJSONStructTags = true
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_parser.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_parser.go
new file mode 100644
index 00000000..a63f23a2
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_parser.go
@@ -0,0 +1,804 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"encoding/base64"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+)
+
+const maxNestingDepth = 200
+
+// ErrInvalidJSON indicates the JSON input is invalid
+var ErrInvalidJSON = errors.New("invalid JSON input")
+
+type jsonParseState byte
+
+const (
+	jpsStartState jsonParseState = iota
+	jpsSawBeginObject
+	jpsSawEndObject
+	jpsSawBeginArray
+	jpsSawEndArray
+	jpsSawColon
+	jpsSawComma
+	jpsSawKey
+	jpsSawValue
+	jpsDoneState
+	jpsInvalidState
+)
+
+type jsonParseMode byte
+
+const (
+	jpmInvalidMode jsonParseMode = iota
+	jpmObjectMode
+	jpmArrayMode
+)
+
+type extJSONValue struct {
+	t Type
+	v interface{}
+}
+
+type extJSONObject struct {
+	keys   []string
+	values []*extJSONValue
+}
+
+type extJSONParser struct {
+	js *jsonScanner
+	s  jsonParseState
+	m  []jsonParseMode
+	k  string
+	v  *extJSONValue
+
+	err           error
+	canonicalOnly bool
+	depth         int
+	maxDepth      int
+
+	emptyObject bool
+	relaxedUUID bool
+}
+
+// newExtJSONParser returns a new extended JSON parser, ready to to begin
+// parsing from the first character of the argued json input. It will not
+// perform any read-ahead and will therefore not report any errors about
+// malformed JSON at this point.
+func newExtJSONParser(r io.Reader, canonicalOnly bool) *extJSONParser {
+	return &extJSONParser{
+		js:            &jsonScanner{r: r},
+		s:             jpsStartState,
+		m:             []jsonParseMode{},
+		canonicalOnly: canonicalOnly,
+		maxDepth:      maxNestingDepth,
+	}
+}
+
+// peekType examines the next value and returns its BSON Type
+func (ejp *extJSONParser) peekType() (Type, error) {
+	var t Type
+	var err error
+	initialState := ejp.s
+
+	ejp.advanceState()
+	switch ejp.s {
+	case jpsSawValue:
+		t = ejp.v.t
+	case jpsSawBeginArray:
+		t = TypeArray
+	case jpsInvalidState:
+		err = ejp.err
+	case jpsSawComma:
+		// in array mode, seeing a comma means we need to progress again to actually observe a type
+		if ejp.peekMode() == jpmArrayMode {
+			return ejp.peekType()
+		}
+	case jpsSawEndArray:
+		// this would only be a valid state if we were in array mode, so return end-of-array error
+		err = ErrEOA
+	case jpsSawBeginObject:
+		// peek key to determine type
+		ejp.advanceState()
+		switch ejp.s {
+		case jpsSawEndObject: // empty embedded document
+			t = TypeEmbeddedDocument
+			ejp.emptyObject = true
+		case jpsInvalidState:
+			err = ejp.err
+		case jpsSawKey:
+			if initialState == jpsStartState {
+				return TypeEmbeddedDocument, nil
+			}
+			t = wrapperKeyBSONType(ejp.k)
+
+			// if $uuid is encountered, parse as binary subtype 4
+			if ejp.k == "$uuid" {
+				ejp.relaxedUUID = true
+				t = TypeBinary
+			}
+
+			switch t {
+			case TypeJavaScript:
+				// just saw $code, need to check for $scope at same level
+				_, err = ejp.readValue(TypeJavaScript)
+				if err != nil {
+					break
+				}
+
+				switch ejp.s {
+				case jpsSawEndObject: // type is TypeJavaScript
+				case jpsSawComma:
+					ejp.advanceState()
+
+					if ejp.s == jpsSawKey && ejp.k == "$scope" {
+						t = TypeCodeWithScope
+					} else {
+						err = fmt.Errorf("invalid extended JSON: unexpected key %s in CodeWithScope object", ejp.k)
+					}
+				case jpsInvalidState:
+					err = ejp.err
+				default:
+					err = ErrInvalidJSON
+				}
+			case TypeCodeWithScope:
+				err = errors.New("invalid extended JSON: code with $scope must contain $code before $scope")
+			}
+		}
+	}
+
+	return t, err
+}
+
+// readKey parses the next key and its type and returns them
+func (ejp *extJSONParser) readKey() (string, Type, error) {
+	if ejp.emptyObject {
+		ejp.emptyObject = false
+		return "", 0, ErrEOD
+	}
+
+	// advance to key (or return with error)
+	switch ejp.s {
+	case jpsStartState:
+		ejp.advanceState()
+		if ejp.s == jpsSawBeginObject {
+			ejp.advanceState()
+		}
+	case jpsSawBeginObject:
+		ejp.advanceState()
+	case jpsSawValue, jpsSawEndObject, jpsSawEndArray:
+		ejp.advanceState()
+		switch ejp.s {
+		case jpsSawBeginObject, jpsSawComma:
+			ejp.advanceState()
+		case jpsSawEndObject:
+			return "", 0, ErrEOD
+		case jpsDoneState:
+			return "", 0, io.EOF
+		case jpsInvalidState:
+			return "", 0, ejp.err
+		default:
+			return "", 0, ErrInvalidJSON
+		}
+	case jpsSawKey: // do nothing (key was peeked before)
+	default:
+		return "", 0, invalidRequestError("key")
+	}
+
+	// read key
+	var key string
+
+	switch ejp.s {
+	case jpsSawKey:
+		key = ejp.k
+	case jpsSawEndObject:
+		return "", 0, ErrEOD
+	case jpsInvalidState:
+		return "", 0, ejp.err
+	default:
+		return "", 0, invalidRequestError("key")
+	}
+
+	// check for colon
+	ejp.advanceState()
+	if err := ensureColon(ejp.s, key); err != nil {
+		return "", 0, err
+	}
+
+	// peek at the value to determine type
+	t, err := ejp.peekType()
+	if err != nil {
+		return "", 0, err
+	}
+
+	return key, t, nil
+}
+
+// readValue returns the value corresponding to the Type returned by peekType
+func (ejp *extJSONParser) readValue(t Type) (*extJSONValue, error) {
+	if ejp.s == jpsInvalidState {
+		return nil, ejp.err
+	}
+
+	var v *extJSONValue
+
+	switch t {
+	case TypeNull, TypeBoolean, TypeString:
+		if ejp.s != jpsSawValue {
+			return nil, invalidRequestError(t.String())
+		}
+		v = ejp.v
+	case TypeInt32, TypeInt64, TypeDouble:
+		// relaxed version allows these to be literal number values
+		if ejp.s == jpsSawValue {
+			v = ejp.v
+			break
+		}
+		fallthrough
+	case TypeDecimal128, TypeSymbol, TypeObjectID, TypeMinKey, TypeMaxKey, TypeUndefined:
+		switch ejp.s {
+		case jpsSawKey:
+			// read colon
+			ejp.advanceState()
+			if err := ensureColon(ejp.s, ejp.k); err != nil {
+				return nil, err
+			}
+
+			// read value
+			ejp.advanceState()
+			if ejp.s != jpsSawValue || !ejp.ensureExtValueType(t) {
+				return nil, invalidJSONErrorForType("value", t)
+			}
+
+			v = ejp.v
+
+			// read end object
+			ejp.advanceState()
+			if ejp.s != jpsSawEndObject {
+				return nil, invalidJSONErrorForType("} after value", t)
+			}
+		default:
+			return nil, invalidRequestError(t.String())
+		}
+	case TypeBinary, TypeRegex, TypeTimestamp, TypeDBPointer:
+		if ejp.s != jpsSawKey {
+			return nil, invalidRequestError(t.String())
+		}
+		// read colon
+		ejp.advanceState()
+		if err := ensureColon(ejp.s, ejp.k); err != nil {
+			return nil, err
+		}
+
+		ejp.advanceState()
+		if t == TypeBinary && ejp.s == jpsSawValue {
+			// convert relaxed $uuid format
+			if ejp.relaxedUUID {
+				defer func() { ejp.relaxedUUID = false }()
+				uuid, err := ejp.v.parseSymbol()
+				if err != nil {
+					return nil, err
+				}
+
+				// RFC 4122 defines the length of a UUID as 36 and the hyphens in a UUID as appearing
+				// in the 8th, 13th, 18th, and 23rd characters.
+				//
+				// See https://tools.ietf.org/html/rfc4122#section-3
+				valid := len(uuid) == 36 &&
+					string(uuid[8]) == "-" &&
+					string(uuid[13]) == "-" &&
+					string(uuid[18]) == "-" &&
+					string(uuid[23]) == "-"
+				if !valid {
+					return nil, fmt.Errorf("$uuid value does not follow RFC 4122 format regarding length and hyphens")
+				}
+
+				// remove hyphens
+				uuidNoHyphens := strings.ReplaceAll(uuid, "-", "")
+				if len(uuidNoHyphens) != 32 {
+					return nil, fmt.Errorf("$uuid value does not follow RFC 4122 format regarding length and hyphens")
+				}
+
+				// convert hex to bytes
+				bytes, err := hex.DecodeString(uuidNoHyphens)
+				if err != nil {
+					return nil, fmt.Errorf("$uuid value does not follow RFC 4122 format regarding hex bytes: %w", err)
+				}
+
+				ejp.advanceState()
+				if ejp.s != jpsSawEndObject {
+					return nil, invalidJSONErrorForType("$uuid and value and then }", TypeBinary)
+				}
+
+				base64 := &extJSONValue{
+					t: TypeString,
+					v: base64.StdEncoding.EncodeToString(bytes),
+				}
+				subType := &extJSONValue{
+					t: TypeString,
+					v: "04",
+				}
+
+				v = &extJSONValue{
+					t: TypeEmbeddedDocument,
+					v: &extJSONObject{
+						keys:   []string{"base64", "subType"},
+						values: []*extJSONValue{base64, subType},
+					},
+				}
+
+				break
+			}
+
+			// convert legacy $binary format
+			base64 := ejp.v
+
+			ejp.advanceState()
+			if ejp.s != jpsSawComma {
+				return nil, invalidJSONErrorForType(",", TypeBinary)
+			}
+
+			ejp.advanceState()
+			key, t, err := ejp.readKey()
+			if err != nil {
+				return nil, err
+			}
+			if key != "$type" {
+				return nil, invalidJSONErrorForType("$type", TypeBinary)
+			}
+
+			subType, err := ejp.readValue(t)
+			if err != nil {
+				return nil, err
+			}
+
+			ejp.advanceState()
+			if ejp.s != jpsSawEndObject {
+				return nil, invalidJSONErrorForType("2 key-value pairs and then }", TypeBinary)
+			}
+
+			v = &extJSONValue{
+				t: TypeEmbeddedDocument,
+				v: &extJSONObject{
+					keys:   []string{"base64", "subType"},
+					values: []*extJSONValue{base64, subType},
+				},
+			}
+			break
+		}
+
+		// read KV pairs
+		if ejp.s != jpsSawBeginObject {
+			return nil, invalidJSONErrorForType("{", t)
+		}
+
+		keys, vals, err := ejp.readObject(2, true)
+		if err != nil {
+			return nil, err
+		}
+
+		ejp.advanceState()
+		if ejp.s != jpsSawEndObject {
+			return nil, invalidJSONErrorForType("2 key-value pairs and then }", t)
+		}
+
+		v = &extJSONValue{t: TypeEmbeddedDocument, v: &extJSONObject{keys: keys, values: vals}}
+
+	case TypeDateTime:
+		switch ejp.s {
+		case jpsSawValue:
+			v = ejp.v
+		case jpsSawKey:
+			// read colon
+			ejp.advanceState()
+			if err := ensureColon(ejp.s, ejp.k); err != nil {
+				return nil, err
+			}
+
+			ejp.advanceState()
+			switch ejp.s {
+			case jpsSawBeginObject:
+				keys, vals, err := ejp.readObject(1, true)
+				if err != nil {
+					return nil, err
+				}
+				v = &extJSONValue{t: TypeEmbeddedDocument, v: &extJSONObject{keys: keys, values: vals}}
+			case jpsSawValue:
+				if ejp.canonicalOnly {
+					return nil, invalidJSONError("{")
+				}
+				v = ejp.v
+			default:
+				if ejp.canonicalOnly {
+					return nil, invalidJSONErrorForType("object", t)
+				}
+				return nil, invalidJSONErrorForType("ISO-8601 Internet Date/Time Format as described in RFC-3339", t)
+			}
+
+			ejp.advanceState()
+			if ejp.s != jpsSawEndObject {
+				return nil, invalidJSONErrorForType("value and then }", t)
+			}
+		default:
+			return nil, invalidRequestError(t.String())
+		}
+	case TypeJavaScript:
+		switch ejp.s {
+		case jpsSawKey:
+			// read colon
+			ejp.advanceState()
+			if err := ensureColon(ejp.s, ejp.k); err != nil {
+				return nil, err
+			}
+
+			// read value
+			ejp.advanceState()
+			if ejp.s != jpsSawValue {
+				return nil, invalidJSONErrorForType("value", t)
+			}
+			v = ejp.v
+
+			// read end object or comma and just return
+			ejp.advanceState()
+		case jpsSawEndObject:
+			v = ejp.v
+		default:
+			return nil, invalidRequestError(t.String())
+		}
+	case TypeCodeWithScope:
+		if ejp.s == jpsSawKey && ejp.k == "$scope" {
+			v = ejp.v // this is the $code string from earlier
+
+			// read colon
+			ejp.advanceState()
+			if err := ensureColon(ejp.s, ejp.k); err != nil {
+				return nil, err
+			}
+
+			// read {
+			ejp.advanceState()
+			if ejp.s != jpsSawBeginObject {
+				return nil, invalidJSONError("$scope to be embedded document")
+			}
+		} else {
+			return nil, invalidRequestError(t.String())
+		}
+	case TypeEmbeddedDocument, TypeArray:
+		return nil, invalidRequestError(t.String())
+	}
+
+	return v, nil
+}
+
+// readObject is a utility method for reading full objects of known (or expected) size
+// it is useful for extended JSON types such as binary, datetime, regex, and timestamp
+func (ejp *extJSONParser) readObject(numKeys int, started bool) ([]string, []*extJSONValue, error) {
+	keys := make([]string, numKeys)
+	vals := make([]*extJSONValue, numKeys)
+
+	if !started {
+		ejp.advanceState()
+		if ejp.s != jpsSawBeginObject {
+			return nil, nil, invalidJSONError("{")
+		}
+	}
+
+	for i := 0; i < numKeys; i++ {
+		key, t, err := ejp.readKey()
+		if err != nil {
+			return nil, nil, err
+		}
+
+		switch ejp.s {
+		case jpsSawKey:
+			v, err := ejp.readValue(t)
+			if err != nil {
+				return nil, nil, err
+			}
+
+			keys[i] = key
+			vals[i] = v
+		case jpsSawValue:
+			keys[i] = key
+			vals[i] = ejp.v
+		default:
+			return nil, nil, invalidJSONError("value")
+		}
+	}
+
+	ejp.advanceState()
+	if ejp.s != jpsSawEndObject {
+		return nil, nil, invalidJSONError("}")
+	}
+
+	return keys, vals, nil
+}
+
+// advanceState reads the next JSON token from the scanner and transitions
+// from the current state based on that token's type
+func (ejp *extJSONParser) advanceState() {
+	if ejp.s == jpsDoneState || ejp.s == jpsInvalidState {
+		return
+	}
+
+	jt, err := ejp.js.nextToken()
+
+	if err != nil {
+		ejp.err = err
+		ejp.s = jpsInvalidState
+		return
+	}
+
+	valid := ejp.validateToken(jt.t)
+	if !valid {
+		ejp.err = unexpectedTokenError(jt)
+		ejp.s = jpsInvalidState
+		return
+	}
+
+	switch jt.t {
+	case jttBeginObject:
+		ejp.s = jpsSawBeginObject
+		ejp.pushMode(jpmObjectMode)
+		ejp.depth++
+
+		if ejp.depth > ejp.maxDepth {
+			ejp.err = nestingDepthError(jt.p, ejp.depth)
+			ejp.s = jpsInvalidState
+		}
+	case jttEndObject:
+		ejp.s = jpsSawEndObject
+		ejp.depth--
+
+		if ejp.popMode() != jpmObjectMode {
+			ejp.err = unexpectedTokenError(jt)
+			ejp.s = jpsInvalidState
+		}
+	case jttBeginArray:
+		ejp.s = jpsSawBeginArray
+		ejp.pushMode(jpmArrayMode)
+	case jttEndArray:
+		ejp.s = jpsSawEndArray
+
+		if ejp.popMode() != jpmArrayMode {
+			ejp.err = unexpectedTokenError(jt)
+			ejp.s = jpsInvalidState
+		}
+	case jttColon:
+		ejp.s = jpsSawColon
+	case jttComma:
+		ejp.s = jpsSawComma
+	case jttEOF:
+		ejp.s = jpsDoneState
+		if len(ejp.m) != 0 {
+			ejp.err = unexpectedTokenError(jt)
+			ejp.s = jpsInvalidState
+		}
+	case jttString:
+		switch ejp.s {
+		case jpsSawComma:
+			if ejp.peekMode() == jpmArrayMode {
+				ejp.s = jpsSawValue
+				ejp.v = extendJSONToken(jt)
+				return
+			}
+			fallthrough
+		case jpsSawBeginObject:
+			ejp.s = jpsSawKey
+			ejp.k = jt.v.(string)
+			return
+		}
+		fallthrough
+	default:
+		ejp.s = jpsSawValue
+		ejp.v = extendJSONToken(jt)
+	}
+}
+
+var jpsValidTransitionTokens = map[jsonParseState]map[jsonTokenType]bool{
+	jpsStartState: {
+		jttBeginObject: true,
+		jttBeginArray:  true,
+		jttInt32:       true,
+		jttInt64:       true,
+		jttDouble:      true,
+		jttString:      true,
+		jttBool:        true,
+		jttNull:        true,
+		jttEOF:         true,
+	},
+	jpsSawBeginObject: {
+		jttEndObject: true,
+		jttString:    true,
+	},
+	jpsSawEndObject: {
+		jttEndObject: true,
+		jttEndArray:  true,
+		jttComma:     true,
+		jttEOF:       true,
+	},
+	jpsSawBeginArray: {
+		jttBeginObject: true,
+		jttBeginArray:  true,
+		jttEndArray:    true,
+		jttInt32:       true,
+		jttInt64:       true,
+		jttDouble:      true,
+		jttString:      true,
+		jttBool:        true,
+		jttNull:        true,
+	},
+	jpsSawEndArray: {
+		jttEndObject: true,
+		jttEndArray:  true,
+		jttComma:     true,
+		jttEOF:       true,
+	},
+	jpsSawColon: {
+		jttBeginObject: true,
+		jttBeginArray:  true,
+		jttInt32:       true,
+		jttInt64:       true,
+		jttDouble:      true,
+		jttString:      true,
+		jttBool:        true,
+		jttNull:        true,
+	},
+	jpsSawComma: {
+		jttBeginObject: true,
+		jttBeginArray:  true,
+		jttInt32:       true,
+		jttInt64:       true,
+		jttDouble:      true,
+		jttString:      true,
+		jttBool:        true,
+		jttNull:        true,
+	},
+	jpsSawKey: {
+		jttColon: true,
+	},
+	jpsSawValue: {
+		jttEndObject: true,
+		jttEndArray:  true,
+		jttComma:     true,
+		jttEOF:       true,
+	},
+	jpsDoneState:    {},
+	jpsInvalidState: {},
+}
+
+func (ejp *extJSONParser) validateToken(jtt jsonTokenType) bool {
+	switch ejp.s {
+	case jpsSawEndObject:
+		// if we are at depth zero and the next token is a '{',
+		// we can consider it valid only if we are not in array mode.
+		if jtt == jttBeginObject && ejp.depth == 0 {
+			return ejp.peekMode() != jpmArrayMode
+		}
+	case jpsSawComma:
+		switch ejp.peekMode() {
+		// the only valid next token after a comma inside a document is a string (a key)
+		case jpmObjectMode:
+			return jtt == jttString
+		case jpmInvalidMode:
+			return false
+		}
+	}
+
+	_, ok := jpsValidTransitionTokens[ejp.s][jtt]
+	return ok
+}
+
+// ensureExtValueType returns true if the current value has the expected
+// value type for single-key extended JSON types. For example,
+// {"$numberInt": v} v must be TypeString
+func (ejp *extJSONParser) ensureExtValueType(t Type) bool {
+	switch t {
+	case TypeMinKey, TypeMaxKey:
+		return ejp.v.t == TypeInt32
+	case TypeUndefined:
+		return ejp.v.t == TypeBoolean
+	case TypeInt32, TypeInt64, TypeDouble, TypeDecimal128, TypeSymbol, TypeObjectID:
+		return ejp.v.t == TypeString
+	default:
+		return false
+	}
+}
+
+func (ejp *extJSONParser) pushMode(m jsonParseMode) {
+	ejp.m = append(ejp.m, m)
+}
+
+func (ejp *extJSONParser) popMode() jsonParseMode {
+	l := len(ejp.m)
+	if l == 0 {
+		return jpmInvalidMode
+	}
+
+	m := ejp.m[l-1]
+	ejp.m = ejp.m[:l-1]
+
+	return m
+}
+
+func (ejp *extJSONParser) peekMode() jsonParseMode {
+	l := len(ejp.m)
+	if l == 0 {
+		return jpmInvalidMode
+	}
+
+	return ejp.m[l-1]
+}
+
+func extendJSONToken(jt *jsonToken) *extJSONValue {
+	var t Type
+
+	switch jt.t {
+	case jttInt32:
+		t = TypeInt32
+	case jttInt64:
+		t = TypeInt64
+	case jttDouble:
+		t = TypeDouble
+	case jttString:
+		t = TypeString
+	case jttBool:
+		t = TypeBoolean
+	case jttNull:
+		t = TypeNull
+	default:
+		return nil
+	}
+
+	return &extJSONValue{t: t, v: jt.v}
+}
+
+func ensureColon(s jsonParseState, key string) error {
+	if s != jpsSawColon {
+		return fmt.Errorf("invalid JSON input: missing colon after key \"%s\"", key)
+	}
+
+	return nil
+}
+
+func invalidRequestError(s string) error {
+	return fmt.Errorf("invalid request to read %s", s)
+}
+
+func invalidJSONError(expected string) error {
+	return fmt.Errorf("invalid JSON input; expected %s", expected)
+}
+
+func invalidJSONErrorForType(expected string, t Type) error {
+	return fmt.Errorf("invalid JSON input; expected %s for %s", expected, t)
+}
+
+func unexpectedTokenError(jt *jsonToken) error {
+	switch jt.t {
+	case jttInt32, jttInt64, jttDouble:
+		return fmt.Errorf("invalid JSON input; unexpected number (%v) at position %d", jt.v, jt.p)
+	case jttString:
+		return fmt.Errorf("invalid JSON input; unexpected string (\"%v\") at position %d", jt.v, jt.p)
+	case jttBool:
+		return fmt.Errorf("invalid JSON input; unexpected boolean literal (%v) at position %d", jt.v, jt.p)
+	case jttNull:
+		return fmt.Errorf("invalid JSON input; unexpected null literal at position %d", jt.p)
+	case jttEOF:
+		return fmt.Errorf("invalid JSON input; unexpected end of input at position %d", jt.p)
+	default:
+		return fmt.Errorf("invalid JSON input; unexpected %c at position %d", jt.v.(byte), jt.p)
+	}
+}
+
+func nestingDepthError(p, depth int) error {
+	return fmt.Errorf("invalid JSON input; nesting too deep (%d levels) at position %d", depth, p)
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_reader.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_reader.go
new file mode 100644
index 00000000..4bee3efc
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_reader.go
@@ -0,0 +1,606 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"errors"
+	"fmt"
+	"io"
+)
+
+type ejvrState struct {
+	mode  mode
+	vType Type
+	depth int
+}
+
+// extJSONValueReader is for reading extended JSON.
+type extJSONValueReader struct {
+	p *extJSONParser
+
+	stack []ejvrState
+	frame int
+}
+
+// NewExtJSONValueReader returns a ValueReader that reads Extended JSON values
+// from r. If canonicalOnly is true, reading values from the ValueReader returns
+// an error if the Extended JSON was not marshaled in canonical mode.
+func NewExtJSONValueReader(r io.Reader, canonicalOnly bool) (ValueReader, error) {
+	return newExtJSONValueReader(r, canonicalOnly)
+}
+
+func newExtJSONValueReader(r io.Reader, canonicalOnly bool) (*extJSONValueReader, error) {
+	ejvr := new(extJSONValueReader)
+	return ejvr.reset(r, canonicalOnly)
+}
+
+func (ejvr *extJSONValueReader) reset(r io.Reader, canonicalOnly bool) (*extJSONValueReader, error) {
+	p := newExtJSONParser(r, canonicalOnly)
+	typ, err := p.peekType()
+
+	if err != nil {
+		return nil, ErrInvalidJSON
+	}
+
+	var m mode
+	switch typ {
+	case TypeEmbeddedDocument:
+		m = mTopLevel
+	case TypeArray:
+		m = mArray
+	default:
+		m = mValue
+	}
+
+	stack := make([]ejvrState, 1, 5)
+	stack[0] = ejvrState{
+		mode:  m,
+		vType: typ,
+	}
+	return &extJSONValueReader{
+		p:     p,
+		stack: stack,
+	}, nil
+}
+
+func (ejvr *extJSONValueReader) advanceFrame() {
+	if ejvr.frame+1 >= len(ejvr.stack) { // We need to grow the stack
+		length := len(ejvr.stack)
+		if length+1 >= cap(ejvr.stack) {
+			// double it
+			buf := make([]ejvrState, 2*cap(ejvr.stack)+1)
+			copy(buf, ejvr.stack)
+			ejvr.stack = buf
+		}
+		ejvr.stack = ejvr.stack[:length+1]
+	}
+	ejvr.frame++
+
+	// Clean the stack
+	ejvr.stack[ejvr.frame].mode = 0
+	ejvr.stack[ejvr.frame].vType = 0
+	ejvr.stack[ejvr.frame].depth = 0
+}
+
+func (ejvr *extJSONValueReader) pushDocument() {
+	ejvr.advanceFrame()
+
+	ejvr.stack[ejvr.frame].mode = mDocument
+	ejvr.stack[ejvr.frame].depth = ejvr.p.depth
+}
+
+func (ejvr *extJSONValueReader) pushCodeWithScope() {
+	ejvr.advanceFrame()
+
+	ejvr.stack[ejvr.frame].mode = mCodeWithScope
+}
+
+func (ejvr *extJSONValueReader) pushArray() {
+	ejvr.advanceFrame()
+
+	ejvr.stack[ejvr.frame].mode = mArray
+}
+
+func (ejvr *extJSONValueReader) push(m mode, t Type) {
+	ejvr.advanceFrame()
+
+	ejvr.stack[ejvr.frame].mode = m
+	ejvr.stack[ejvr.frame].vType = t
+}
+
+func (ejvr *extJSONValueReader) pop() {
+	switch ejvr.stack[ejvr.frame].mode {
+	case mElement, mValue:
+		ejvr.frame--
+	case mDocument, mArray, mCodeWithScope:
+		ejvr.frame -= 2 // we pop twice to jump over the vrElement: vrDocument -> vrElement -> vrDocument/TopLevel/etc...
+	}
+}
+
+func (ejvr *extJSONValueReader) skipObject() {
+	// read entire object until depth returns to 0 (last ending } or ] seen)
+	depth := 1
+	for depth > 0 {
+		ejvr.p.advanceState()
+
+		// If object is empty, raise depth and continue. When emptyObject is true, the
+		// parser has already read both the opening and closing brackets of an empty
+		// object ("{}"), so the next valid token will be part of the parent document,
+		// not part of the nested document.
+		//
+		// If there is a comma, there are remaining fields, emptyObject must be set back
+		// to false, and comma must be skipped with advanceState().
+		if ejvr.p.emptyObject {
+			if ejvr.p.s == jpsSawComma {
+				ejvr.p.emptyObject = false
+				ejvr.p.advanceState()
+			}
+			depth--
+			continue
+		}
+
+		switch ejvr.p.s {
+		case jpsSawBeginObject, jpsSawBeginArray:
+			depth++
+		case jpsSawEndObject, jpsSawEndArray:
+			depth--
+		}
+	}
+}
+
+func (ejvr *extJSONValueReader) invalidTransitionErr(destination mode, name string, modes []mode) error {
+	te := TransitionError{
+		name:        name,
+		current:     ejvr.stack[ejvr.frame].mode,
+		destination: destination,
+		modes:       modes,
+		action:      "read",
+	}
+	if ejvr.frame != 0 {
+		te.parent = ejvr.stack[ejvr.frame-1].mode
+	}
+	return te
+}
+
+func (ejvr *extJSONValueReader) typeError(t Type) error {
+	return fmt.Errorf("positioned on %s, but attempted to read %s", ejvr.stack[ejvr.frame].vType, t)
+}
+
+func (ejvr *extJSONValueReader) ensureElementValue(t Type, destination mode, callerName string, addModes ...mode) error {
+	switch ejvr.stack[ejvr.frame].mode {
+	case mElement, mValue:
+		if ejvr.stack[ejvr.frame].vType != t {
+			return ejvr.typeError(t)
+		}
+	default:
+		modes := []mode{mElement, mValue}
+		if addModes != nil {
+			modes = append(modes, addModes...)
+		}
+		return ejvr.invalidTransitionErr(destination, callerName, modes)
+	}
+
+	return nil
+}
+
+func (ejvr *extJSONValueReader) Type() Type {
+	return ejvr.stack[ejvr.frame].vType
+}
+
+func (ejvr *extJSONValueReader) Skip() error {
+	switch ejvr.stack[ejvr.frame].mode {
+	case mElement, mValue:
+	default:
+		return ejvr.invalidTransitionErr(0, "Skip", []mode{mElement, mValue})
+	}
+
+	defer ejvr.pop()
+
+	t := ejvr.stack[ejvr.frame].vType
+	switch t {
+	case TypeArray, TypeEmbeddedDocument, TypeCodeWithScope:
+		// read entire array, doc or CodeWithScope
+		ejvr.skipObject()
+	default:
+		_, err := ejvr.p.readValue(t)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (ejvr *extJSONValueReader) ReadArray() (ArrayReader, error) {
+	switch ejvr.stack[ejvr.frame].mode {
+	case mTopLevel: // allow reading array from top level
+	case mArray:
+		return ejvr, nil
+	default:
+		if err := ejvr.ensureElementValue(TypeArray, mArray, "ReadArray", mTopLevel, mArray); err != nil {
+			return nil, err
+		}
+	}
+
+	ejvr.pushArray()
+
+	return ejvr, nil
+}
+
+func (ejvr *extJSONValueReader) ReadBinary() (b []byte, btype byte, err error) {
+	if err := ejvr.ensureElementValue(TypeBinary, 0, "ReadBinary"); err != nil {
+		return nil, 0, err
+	}
+
+	v, err := ejvr.p.readValue(TypeBinary)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	b, btype, err = v.parseBinary()
+
+	ejvr.pop()
+	return b, btype, err
+}
+
+func (ejvr *extJSONValueReader) ReadBoolean() (bool, error) {
+	if err := ejvr.ensureElementValue(TypeBoolean, 0, "ReadBoolean"); err != nil {
+		return false, err
+	}
+
+	v, err := ejvr.p.readValue(TypeBoolean)
+	if err != nil {
+		return false, err
+	}
+
+	if v.t != TypeBoolean {
+		return false, fmt.Errorf("expected type bool, but got type %s", v.t)
+	}
+
+	ejvr.pop()
+	return v.v.(bool), nil
+}
+
+func (ejvr *extJSONValueReader) ReadDocument() (DocumentReader, error) {
+	switch ejvr.stack[ejvr.frame].mode {
+	case mTopLevel:
+		return ejvr, nil
+	case mElement, mValue:
+		if ejvr.stack[ejvr.frame].vType != TypeEmbeddedDocument {
+			return nil, ejvr.typeError(TypeEmbeddedDocument)
+		}
+
+		ejvr.pushDocument()
+		return ejvr, nil
+	default:
+		return nil, ejvr.invalidTransitionErr(mDocument, "ReadDocument", []mode{mTopLevel, mElement, mValue})
+	}
+}
+
+func (ejvr *extJSONValueReader) ReadCodeWithScope() (code string, dr DocumentReader, err error) {
+	if err = ejvr.ensureElementValue(TypeCodeWithScope, 0, "ReadCodeWithScope"); err != nil {
+		return "", nil, err
+	}
+
+	v, err := ejvr.p.readValue(TypeCodeWithScope)
+	if err != nil {
+		return "", nil, err
+	}
+
+	code, err = v.parseJavascript()
+
+	ejvr.pushCodeWithScope()
+	return code, ejvr, err
+}
+
+func (ejvr *extJSONValueReader) ReadDBPointer() (ns string, oid ObjectID, err error) {
+	if err = ejvr.ensureElementValue(TypeDBPointer, 0, "ReadDBPointer"); err != nil {
+		return "", NilObjectID, err
+	}
+
+	v, err := ejvr.p.readValue(TypeDBPointer)
+	if err != nil {
+		return "", NilObjectID, err
+	}
+
+	ns, oid, err = v.parseDBPointer()
+
+	ejvr.pop()
+	return ns, oid, err
+}
+
+func (ejvr *extJSONValueReader) ReadDateTime() (int64, error) {
+	if err := ejvr.ensureElementValue(TypeDateTime, 0, "ReadDateTime"); err != nil {
+		return 0, err
+	}
+
+	v, err := ejvr.p.readValue(TypeDateTime)
+	if err != nil {
+		return 0, err
+	}
+
+	d, err := v.parseDateTime()
+
+	ejvr.pop()
+	return d, err
+}
+
+func (ejvr *extJSONValueReader) ReadDecimal128() (Decimal128, error) {
+	if err := ejvr.ensureElementValue(TypeDecimal128, 0, "ReadDecimal128"); err != nil {
+		return Decimal128{}, err
+	}
+
+	v, err := ejvr.p.readValue(TypeDecimal128)
+	if err != nil {
+		return Decimal128{}, err
+	}
+
+	d, err := v.parseDecimal128()
+
+	ejvr.pop()
+	return d, err
+}
+
+func (ejvr *extJSONValueReader) ReadDouble() (float64, error) {
+	if err := ejvr.ensureElementValue(TypeDouble, 0, "ReadDouble"); err != nil {
+		return 0, err
+	}
+
+	v, err := ejvr.p.readValue(TypeDouble)
+	if err != nil {
+		return 0, err
+	}
+
+	d, err := v.parseDouble()
+
+	ejvr.pop()
+	return d, err
+}
+
+func (ejvr *extJSONValueReader) ReadInt32() (int32, error) {
+	if err := ejvr.ensureElementValue(TypeInt32, 0, "ReadInt32"); err != nil {
+		return 0, err
+	}
+
+	v, err := ejvr.p.readValue(TypeInt32)
+	if err != nil {
+		return 0, err
+	}
+
+	i, err := v.parseInt32()
+
+	ejvr.pop()
+	return i, err
+}
+
+func (ejvr *extJSONValueReader) ReadInt64() (int64, error) {
+	if err := ejvr.ensureElementValue(TypeInt64, 0, "ReadInt64"); err != nil {
+		return 0, err
+	}
+
+	v, err := ejvr.p.readValue(TypeInt64)
+	if err != nil {
+		return 0, err
+	}
+
+	i, err := v.parseInt64()
+
+	ejvr.pop()
+	return i, err
+}
+
+func (ejvr *extJSONValueReader) ReadJavascript() (code string, err error) {
+	if err = ejvr.ensureElementValue(TypeJavaScript, 0, "ReadJavascript"); err != nil {
+		return "", err
+	}
+
+	v, err := ejvr.p.readValue(TypeJavaScript)
+	if err != nil {
+		return "", err
+	}
+
+	code, err = v.parseJavascript()
+
+	ejvr.pop()
+	return code, err
+}
+
+func (ejvr *extJSONValueReader) ReadMaxKey() error {
+	if err := ejvr.ensureElementValue(TypeMaxKey, 0, "ReadMaxKey"); err != nil {
+		return err
+	}
+
+	v, err := ejvr.p.readValue(TypeMaxKey)
+	if err != nil {
+		return err
+	}
+
+	err = v.parseMinMaxKey("max")
+
+	ejvr.pop()
+	return err
+}
+
+func (ejvr *extJSONValueReader) ReadMinKey() error {
+	if err := ejvr.ensureElementValue(TypeMinKey, 0, "ReadMinKey"); err != nil {
+		return err
+	}
+
+	v, err := ejvr.p.readValue(TypeMinKey)
+	if err != nil {
+		return err
+	}
+
+	err = v.parseMinMaxKey("min")
+
+	ejvr.pop()
+	return err
+}
+
+func (ejvr *extJSONValueReader) ReadNull() error {
+	if err := ejvr.ensureElementValue(TypeNull, 0, "ReadNull"); err != nil {
+		return err
+	}
+
+	v, err := ejvr.p.readValue(TypeNull)
+	if err != nil {
+		return err
+	}
+
+	if v.t != TypeNull {
+		return fmt.Errorf("expected type null but got type %s", v.t)
+	}
+
+	ejvr.pop()
+	return nil
+}
+
+func (ejvr *extJSONValueReader) ReadObjectID() (ObjectID, error) {
+	if err := ejvr.ensureElementValue(TypeObjectID, 0, "ReadObjectID"); err != nil {
+		return ObjectID{}, err
+	}
+
+	v, err := ejvr.p.readValue(TypeObjectID)
+	if err != nil {
+		return ObjectID{}, err
+	}
+
+	oid, err := v.parseObjectID()
+
+	ejvr.pop()
+	return oid, err
+}
+
+func (ejvr *extJSONValueReader) ReadRegex() (pattern string, options string, err error) {
+	if err = ejvr.ensureElementValue(TypeRegex, 0, "ReadRegex"); err != nil {
+		return "", "", err
+	}
+
+	v, err := ejvr.p.readValue(TypeRegex)
+	if err != nil {
+		return "", "", err
+	}
+
+	pattern, options, err = v.parseRegex()
+
+	ejvr.pop()
+	return pattern, options, err
+}
+
+func (ejvr *extJSONValueReader) ReadString() (string, error) {
+	if err := ejvr.ensureElementValue(TypeString, 0, "ReadString"); err != nil {
+		return "", err
+	}
+
+	v, err := ejvr.p.readValue(TypeString)
+	if err != nil {
+		return "", err
+	}
+
+	if v.t != TypeString {
+		return "", fmt.Errorf("expected type string but got type %s", v.t)
+	}
+
+	ejvr.pop()
+	return v.v.(string), nil
+}
+
+func (ejvr *extJSONValueReader) ReadSymbol() (symbol string, err error) {
+	if err = ejvr.ensureElementValue(TypeSymbol, 0, "ReadSymbol"); err != nil {
+		return "", err
+	}
+
+	v, err := ejvr.p.readValue(TypeSymbol)
+	if err != nil {
+		return "", err
+	}
+
+	symbol, err = v.parseSymbol()
+
+	ejvr.pop()
+	return symbol, err
+}
+
+func (ejvr *extJSONValueReader) ReadTimestamp() (t uint32, i uint32, err error) {
+	if err = ejvr.ensureElementValue(TypeTimestamp, 0, "ReadTimestamp"); err != nil {
+		return 0, 0, err
+	}
+
+	v, err := ejvr.p.readValue(TypeTimestamp)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	t, i, err = v.parseTimestamp()
+
+	ejvr.pop()
+	return t, i, err
+}
+
+func (ejvr *extJSONValueReader) ReadUndefined() error {
+	if err := ejvr.ensureElementValue(TypeUndefined, 0, "ReadUndefined"); err != nil {
+		return err
+	}
+
+	v, err := ejvr.p.readValue(TypeUndefined)
+	if err != nil {
+		return err
+	}
+
+	err = v.parseUndefined()
+
+	ejvr.pop()
+	return err
+}
+
+func (ejvr *extJSONValueReader) ReadElement() (string, ValueReader, error) {
+	switch ejvr.stack[ejvr.frame].mode {
+	case mTopLevel, mDocument, mCodeWithScope:
+	default:
+		return "", nil, ejvr.invalidTransitionErr(mElement, "ReadElement", []mode{mTopLevel, mDocument, mCodeWithScope})
+	}
+
+	name, t, err := ejvr.p.readKey()
+
+	if err != nil {
+		if errors.Is(err, ErrEOD) {
+			if ejvr.stack[ejvr.frame].mode == mCodeWithScope {
+				_, err := ejvr.p.peekType()
+				if err != nil {
+					return "", nil, err
+				}
+			}
+
+			ejvr.pop()
+		}
+
+		return "", nil, err
+	}
+
+	ejvr.push(mElement, t)
+	return name, ejvr, nil
+}
+
+func (ejvr *extJSONValueReader) ReadValue() (ValueReader, error) {
+	switch ejvr.stack[ejvr.frame].mode {
+	case mArray:
+	default:
+		return nil, ejvr.invalidTransitionErr(mValue, "ReadValue", []mode{mArray})
+	}
+
+	t, err := ejvr.p.peekType()
+	if err != nil {
+		if errors.Is(err, ErrEOA) {
+			ejvr.pop()
+		}
+
+		return nil, err
+	}
+
+	ejvr.push(mValue, t)
+	return ejvr, nil
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_tables.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_tables.go
new file mode 100644
index 00000000..5384db22
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_tables.go
@@ -0,0 +1,223 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+//
+// Based on github.com/golang/go by The Go Authors
+// See THIRD-PARTY-NOTICES for original license terms.
+
+package bson
+
+import "unicode/utf8"
+
+// safeSet holds the value true if the ASCII character with the given array
+// position can be represented inside a JSON string without any further
+// escaping.
+//
+// All values are true except for the ASCII control characters (0-31), the
+// double quote ("), and the backslash character ("\").
+var safeSet = [utf8.RuneSelf]bool{
+	' ':      true,
+	'!':      true,
+	'"':      false,
+	'#':      true,
+	'$':      true,
+	'%':      true,
+	'&':      true,
+	'\'':     true,
+	'(':      true,
+	')':      true,
+	'*':      true,
+	'+':      true,
+	',':      true,
+	'-':      true,
+	'.':      true,
+	'/':      true,
+	'0':      true,
+	'1':      true,
+	'2':      true,
+	'3':      true,
+	'4':      true,
+	'5':      true,
+	'6':      true,
+	'7':      true,
+	'8':      true,
+	'9':      true,
+	':':      true,
+	';':      true,
+	'<':      true,
+	'=':      true,
+	'>':      true,
+	'?':      true,
+	'@':      true,
+	'A':      true,
+	'B':      true,
+	'C':      true,
+	'D':      true,
+	'E':      true,
+	'F':      true,
+	'G':      true,
+	'H':      true,
+	'I':      true,
+	'J':      true,
+	'K':      true,
+	'L':      true,
+	'M':      true,
+	'N':      true,
+	'O':      true,
+	'P':      true,
+	'Q':      true,
+	'R':      true,
+	'S':      true,
+	'T':      true,
+	'U':      true,
+	'V':      true,
+	'W':      true,
+	'X':      true,
+	'Y':      true,
+	'Z':      true,
+	'[':      true,
+	'\\':     false,
+	']':      true,
+	'^':      true,
+	'_':      true,
+	'`':      true,
+	'a':      true,
+	'b':      true,
+	'c':      true,
+	'd':      true,
+	'e':      true,
+	'f':      true,
+	'g':      true,
+	'h':      true,
+	'i':      true,
+	'j':      true,
+	'k':      true,
+	'l':      true,
+	'm':      true,
+	'n':      true,
+	'o':      true,
+	'p':      true,
+	'q':      true,
+	'r':      true,
+	's':      true,
+	't':      true,
+	'u':      true,
+	'v':      true,
+	'w':      true,
+	'x':      true,
+	'y':      true,
+	'z':      true,
+	'{':      true,
+	'|':      true,
+	'}':      true,
+	'~':      true,
+	'\u007f': true,
+}
+
+// htmlSafeSet holds the value true if the ASCII character with the given
+// array position can be safely represented inside a JSON string, embedded
+// inside of HTML <script> tags, without any additional escaping.
+//
+// All values are true except for the ASCII control characters (0-31), the
+// double quote ("), the backslash character ("\"), HTML opening and closing
+// tags ("<" and ">"), and the ampersand ("&").
+var htmlSafeSet = [utf8.RuneSelf]bool{
+	' ':      true,
+	'!':      true,
+	'"':      false,
+	'#':      true,
+	'$':      true,
+	'%':      true,
+	'&':      false,
+	'\'':     true,
+	'(':      true,
+	')':      true,
+	'*':      true,
+	'+':      true,
+	',':      true,
+	'-':      true,
+	'.':      true,
+	'/':      true,
+	'0':      true,
+	'1':      true,
+	'2':      true,
+	'3':      true,
+	'4':      true,
+	'5':      true,
+	'6':      true,
+	'7':      true,
+	'8':      true,
+	'9':      true,
+	':':      true,
+	';':      true,
+	'<':      false,
+	'=':      true,
+	'>':      false,
+	'?':      true,
+	'@':      true,
+	'A':      true,
+	'B':      true,
+	'C':      true,
+	'D':      true,
+	'E':      true,
+	'F':      true,
+	'G':      true,
+	'H':      true,
+	'I':      true,
+	'J':      true,
+	'K':      true,
+	'L':      true,
+	'M':      true,
+	'N':      true,
+	'O':      true,
+	'P':      true,
+	'Q':      true,
+	'R':      true,
+	'S':      true,
+	'T':      true,
+	'U':      true,
+	'V':      true,
+	'W':      true,
+	'X':      true,
+	'Y':      true,
+	'Z':      true,
+	'[':      true,
+	'\\':     false,
+	']':      true,
+	'^':      true,
+	'_':      true,
+	'`':      true,
+	'a':      true,
+	'b':      true,
+	'c':      true,
+	'd':      true,
+	'e':      true,
+	'f':      true,
+	'g':      true,
+	'h':      true,
+	'i':      true,
+	'j':      true,
+	'k':      true,
+	'l':      true,
+	'm':      true,
+	'n':      true,
+	'o':      true,
+	'p':      true,
+	'q':      true,
+	'r':      true,
+	's':      true,
+	't':      true,
+	'u':      true,
+	'v':      true,
+	'w':      true,
+	'x':      true,
+	'y':      true,
+	'z':      true,
+	'{':      true,
+	'|':      true,
+	'}':      true,
+	'~':      true,
+	'\u007f': true,
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_wrappers.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_wrappers.go
new file mode 100644
index 00000000..e98b6428
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_wrappers.go
@@ -0,0 +1,489 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"math"
+	"strconv"
+	"time"
+)
+
+func wrapperKeyBSONType(key string) Type {
+	switch key {
+	case "$numberInt":
+		return TypeInt32
+	case "$numberLong":
+		return TypeInt64
+	case "$oid":
+		return TypeObjectID
+	case "$symbol":
+		return TypeSymbol
+	case "$numberDouble":
+		return TypeDouble
+	case "$numberDecimal":
+		return TypeDecimal128
+	case "$binary":
+		return TypeBinary
+	case "$code":
+		return TypeJavaScript
+	case "$scope":
+		return TypeCodeWithScope
+	case "$timestamp":
+		return TypeTimestamp
+	case "$regularExpression":
+		return TypeRegex
+	case "$dbPointer":
+		return TypeDBPointer
+	case "$date":
+		return TypeDateTime
+	case "$minKey":
+		return TypeMinKey
+	case "$maxKey":
+		return TypeMaxKey
+	case "$undefined":
+		return TypeUndefined
+	}
+
+	return TypeEmbeddedDocument
+}
+
+func (ejv *extJSONValue) parseBinary() (b []byte, subType byte, err error) {
+	if ejv.t != TypeEmbeddedDocument {
+		return nil, 0, fmt.Errorf("$binary value should be object, but instead is %s", ejv.t)
+	}
+
+	binObj := ejv.v.(*extJSONObject)
+	bFound := false
+	stFound := false
+
+	for i, key := range binObj.keys {
+		val := binObj.values[i]
+
+		switch key {
+		case "base64":
+			if bFound {
+				return nil, 0, errors.New("duplicate base64 key in $binary")
+			}
+
+			if val.t != TypeString {
+				return nil, 0, fmt.Errorf("$binary base64 value should be string, but instead is %s", val.t)
+			}
+
+			base64Bytes, err := base64.StdEncoding.DecodeString(val.v.(string))
+			if err != nil {
+				return nil, 0, fmt.Errorf("invalid $binary base64 string: %s", val.v.(string))
+			}
+
+			b = base64Bytes
+			bFound = true
+		case "subType":
+			if stFound {
+				return nil, 0, errors.New("duplicate subType key in $binary")
+			}
+
+			if val.t != TypeString {
+				return nil, 0, fmt.Errorf("$binary subType value should be string, but instead is %s", val.t)
+			}
+
+			i, err := strconv.ParseUint(val.v.(string), 16, 8)
+			if err != nil {
+				return nil, 0, fmt.Errorf("invalid $binary subType string: %q: %w", val.v.(string), err)
+			}
+
+			subType = byte(i)
+			stFound = true
+		default:
+			return nil, 0, fmt.Errorf("invalid key in $binary object: %s", key)
+		}
+	}
+
+	if !bFound {
+		return nil, 0, errors.New("missing base64 field in $binary object")
+	}
+
+	if !stFound {
+		return nil, 0, errors.New("missing subType field in $binary object")
+
+	}
+
+	return b, subType, nil
+}
+
+func (ejv *extJSONValue) parseDBPointer() (ns string, oid ObjectID, err error) {
+	if ejv.t != TypeEmbeddedDocument {
+		return "", NilObjectID, fmt.Errorf("$dbPointer value should be object, but instead is %s", ejv.t)
+	}
+
+	dbpObj := ejv.v.(*extJSONObject)
+	oidFound := false
+	nsFound := false
+
+	for i, key := range dbpObj.keys {
+		val := dbpObj.values[i]
+
+		switch key {
+		case "$ref":
+			if nsFound {
+				return "", NilObjectID, errors.New("duplicate $ref key in $dbPointer")
+			}
+
+			if val.t != TypeString {
+				return "", NilObjectID, fmt.Errorf("$dbPointer $ref value should be string, but instead is %s", val.t)
+			}
+
+			ns = val.v.(string)
+			nsFound = true
+		case "$id":
+			if oidFound {
+				return "", NilObjectID, errors.New("duplicate $id key in $dbPointer")
+			}
+
+			if val.t != TypeString {
+				return "", NilObjectID, fmt.Errorf("$dbPointer $id value should be string, but instead is %s", val.t)
+			}
+
+			oid, err = ObjectIDFromHex(val.v.(string))
+			if err != nil {
+				return "", NilObjectID, err
+			}
+
+			oidFound = true
+		default:
+			return "", NilObjectID, fmt.Errorf("invalid key in $dbPointer object: %s", key)
+		}
+	}
+
+	if !nsFound {
+		return "", oid, errors.New("missing $ref field in $dbPointer object")
+	}
+
+	if !oidFound {
+		return "", oid, errors.New("missing $id field in $dbPointer object")
+	}
+
+	return ns, oid, nil
+}
+
+const (
+	rfc3339Milli = "2006-01-02T15:04:05.999Z07:00"
+)
+
+var (
+	timeFormats = []string{rfc3339Milli, "2006-01-02T15:04:05.999Z0700"}
+)
+
+func (ejv *extJSONValue) parseDateTime() (int64, error) {
+	switch ejv.t {
+	case TypeInt32:
+		return int64(ejv.v.(int32)), nil
+	case TypeInt64:
+		return ejv.v.(int64), nil
+	case TypeString:
+		return parseDatetimeString(ejv.v.(string))
+	case TypeEmbeddedDocument:
+		return parseDatetimeObject(ejv.v.(*extJSONObject))
+	default:
+		return 0, fmt.Errorf("$date value should be string or object, but instead is %s", ejv.t)
+	}
+}
+
+func parseDatetimeString(data string) (int64, error) {
+	var t time.Time
+	var err error
+	// try acceptable time formats until one matches
+	for _, format := range timeFormats {
+		t, err = time.Parse(format, data)
+		if err == nil {
+			break
+		}
+	}
+	if err != nil {
+		return 0, fmt.Errorf("invalid $date value string: %s", data)
+	}
+
+	return int64(NewDateTimeFromTime(t)), nil
+}
+
+func parseDatetimeObject(data *extJSONObject) (d int64, err error) {
+	dFound := false
+
+	for i, key := range data.keys {
+		val := data.values[i]
+
+		switch key {
+		case "$numberLong":
+			if dFound {
+				return 0, errors.New("duplicate $numberLong key in $date")
+			}
+
+			if val.t != TypeString {
+				return 0, fmt.Errorf("$date $numberLong field should be string, but instead is %s", val.t)
+			}
+
+			d, err = val.parseInt64()
+			if err != nil {
+				return 0, err
+			}
+			dFound = true
+		default:
+			return 0, fmt.Errorf("invalid key in $date object: %s", key)
+		}
+	}
+
+	if !dFound {
+		return 0, errors.New("missing $numberLong field in $date object")
+	}
+
+	return d, nil
+}
+
+func (ejv *extJSONValue) parseDecimal128() (Decimal128, error) {
+	if ejv.t != TypeString {
+		return Decimal128{}, fmt.Errorf("$numberDecimal value should be string, but instead is %s", ejv.t)
+	}
+
+	d, err := ParseDecimal128(ejv.v.(string))
+	if err != nil {
+		return Decimal128{}, fmt.Errorf("$invalid $numberDecimal string: %s", ejv.v.(string))
+	}
+
+	return d, nil
+}
+
+func (ejv *extJSONValue) parseDouble() (float64, error) {
+	if ejv.t == TypeDouble {
+		return ejv.v.(float64), nil
+	}
+
+	if ejv.t != TypeString {
+		return 0, fmt.Errorf("$numberDouble value should be string, but instead is %s", ejv.t)
+	}
+
+	switch ejv.v.(string) {
+	case "Infinity":
+		return math.Inf(1), nil
+	case "-Infinity":
+		return math.Inf(-1), nil
+	case "NaN":
+		return math.NaN(), nil
+	}
+
+	f, err := strconv.ParseFloat(ejv.v.(string), 64)
+	if err != nil {
+		return 0, err
+	}
+
+	return f, nil
+}
+
+func (ejv *extJSONValue) parseInt32() (int32, error) {
+	if ejv.t == TypeInt32 {
+		return ejv.v.(int32), nil
+	}
+
+	if ejv.t != TypeString {
+		return 0, fmt.Errorf("$numberInt value should be string, but instead is %s", ejv.t)
+	}
+
+	i, err := strconv.ParseInt(ejv.v.(string), 10, 64)
+	if err != nil {
+		return 0, err
+	}
+
+	if i < math.MinInt32 || i > math.MaxInt32 {
+		return 0, fmt.Errorf("$numberInt value should be int32 but instead is int64: %d", i)
+	}
+
+	return int32(i), nil
+}
+
+func (ejv *extJSONValue) parseInt64() (int64, error) {
+	if ejv.t == TypeInt64 {
+		return ejv.v.(int64), nil
+	}
+
+	if ejv.t != TypeString {
+		return 0, fmt.Errorf("$numberLong value should be string, but instead is %s", ejv.t)
+	}
+
+	i, err := strconv.ParseInt(ejv.v.(string), 10, 64)
+	if err != nil {
+		return 0, err
+	}
+
+	return i, nil
+}
+
+func (ejv *extJSONValue) parseJavascript() (code string, err error) {
+	if ejv.t != TypeString {
+		return "", fmt.Errorf("$code value should be string, but instead is %s", ejv.t)
+	}
+
+	return ejv.v.(string), nil
+}
+
+func (ejv *extJSONValue) parseMinMaxKey(minmax string) error {
+	if ejv.t != TypeInt32 {
+		return fmt.Errorf("$%sKey value should be int32, but instead is %s", minmax, ejv.t)
+	}
+
+	if ejv.v.(int32) != 1 {
+		return fmt.Errorf("$%sKey value must be 1, but instead is %d", minmax, ejv.v.(int32))
+	}
+
+	return nil
+}
+
+func (ejv *extJSONValue) parseObjectID() (ObjectID, error) {
+	if ejv.t != TypeString {
+		return NilObjectID, fmt.Errorf("$oid value should be string, but instead is %s", ejv.t)
+	}
+
+	return ObjectIDFromHex(ejv.v.(string))
+}
+
+func (ejv *extJSONValue) parseRegex() (pattern, options string, err error) {
+	if ejv.t != TypeEmbeddedDocument {
+		return "", "", fmt.Errorf("$regularExpression value should be object, but instead is %s", ejv.t)
+	}
+
+	regexObj := ejv.v.(*extJSONObject)
+	patFound := false
+	optFound := false
+
+	for i, key := range regexObj.keys {
+		val := regexObj.values[i]
+
+		switch key {
+		case "pattern":
+			if patFound {
+				return "", "", errors.New("duplicate pattern key in $regularExpression")
+			}
+
+			if val.t != TypeString {
+				return "", "", fmt.Errorf("$regularExpression pattern value should be string, but instead is %s", val.t)
+			}
+
+			pattern = val.v.(string)
+			patFound = true
+		case "options":
+			if optFound {
+				return "", "", errors.New("duplicate options key in $regularExpression")
+			}
+
+			if val.t != TypeString {
+				return "", "", fmt.Errorf("$regularExpression options value should be string, but instead is %s", val.t)
+			}
+
+			options = val.v.(string)
+			optFound = true
+		default:
+			return "", "", fmt.Errorf("invalid key in $regularExpression object: %s", key)
+		}
+	}
+
+	if !patFound {
+		return "", "", errors.New("missing pattern field in $regularExpression object")
+	}
+
+	if !optFound {
+		return "", "", errors.New("missing options field in $regularExpression object")
+
+	}
+
+	return pattern, options, nil
+}
+
+func (ejv *extJSONValue) parseSymbol() (string, error) {
+	if ejv.t != TypeString {
+		return "", fmt.Errorf("$symbol value should be string, but instead is %s", ejv.t)
+	}
+
+	return ejv.v.(string), nil
+}
+
+func (ejv *extJSONValue) parseTimestamp() (t, i uint32, err error) {
+	if ejv.t != TypeEmbeddedDocument {
+		return 0, 0, fmt.Errorf("$timestamp value should be object, but instead is %s", ejv.t)
+	}
+
+	handleKey := func(key string, val *extJSONValue, flag bool) (uint32, error) {
+		if flag {
+			return 0, fmt.Errorf("duplicate %s key in $timestamp", key)
+		}
+
+		switch val.t {
+		case TypeInt32:
+			value := val.v.(int32)
+
+			if value < 0 {
+				return 0, fmt.Errorf("$timestamp %s number should be uint32: %d", key, value)
+			}
+
+			return uint32(value), nil
+		case TypeInt64:
+			value := val.v.(int64)
+			if value < 0 || value > int64(math.MaxUint32) {
+				return 0, fmt.Errorf("$timestamp %s number should be uint32: %d", key, value)
+			}
+
+			return uint32(value), nil
+		default:
+			return 0, fmt.Errorf("$timestamp %s value should be uint32, but instead is %s", key, val.t)
+		}
+	}
+
+	tsObj := ejv.v.(*extJSONObject)
+	tFound := false
+	iFound := false
+
+	for j, key := range tsObj.keys {
+		val := tsObj.values[j]
+
+		switch key {
+		case "t":
+			if t, err = handleKey(key, val, tFound); err != nil {
+				return 0, 0, err
+			}
+
+			tFound = true
+		case "i":
+			if i, err = handleKey(key, val, iFound); err != nil {
+				return 0, 0, err
+			}
+
+			iFound = true
+		default:
+			return 0, 0, fmt.Errorf("invalid key in $timestamp object: %s", key)
+		}
+	}
+
+	if !tFound {
+		return 0, 0, errors.New("missing t field in $timestamp object")
+	}
+
+	if !iFound {
+		return 0, 0, errors.New("missing i field in $timestamp object")
+	}
+
+	return t, i, nil
+}
+
+func (ejv *extJSONValue) parseUndefined() error {
+	if ejv.t != TypeBoolean {
+		return fmt.Errorf("undefined value should be boolean, but instead is %s", ejv.t)
+	}
+
+	if !ejv.v.(bool) {
+		return fmt.Errorf("$undefined balue boolean should be true, but instead is %v", ejv.v.(bool))
+	}
+
+	return nil
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_writer.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_writer.go
new file mode 100644
index 00000000..2d43943f
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_writer.go
@@ -0,0 +1,690 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"bytes"
+	"encoding/base64"
+	"fmt"
+	"io"
+	"math"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+type ejvwState struct {
+	mode mode
+}
+
+type extJSONValueWriter struct {
+	w   io.Writer
+	buf []byte
+
+	stack      []ejvwState
+	frame      int64
+	canonical  bool
+	escapeHTML bool
+	newlines   bool
+}
+
+// NewExtJSONValueWriter creates a ValueWriter that writes Extended JSON to w.
+func NewExtJSONValueWriter(w io.Writer, canonical, escapeHTML bool) ValueWriter {
+	// Enable newlines for all Extended JSON value writers created by NewExtJSONValueWriter. We
+	// expect these value writers to be used with an Encoder, which should add newlines after
+	// encoded Extended JSON documents.
+	return newExtJSONWriter(w, canonical, escapeHTML, true)
+}
+
+func newExtJSONWriter(w io.Writer, canonical, escapeHTML, newlines bool) *extJSONValueWriter {
+	stack := make([]ejvwState, 1, 5)
+	stack[0] = ejvwState{mode: mTopLevel}
+
+	return &extJSONValueWriter{
+		w:          w,
+		buf:        []byte{},
+		stack:      stack,
+		canonical:  canonical,
+		escapeHTML: escapeHTML,
+		newlines:   newlines,
+	}
+}
+
+func newExtJSONWriterFromSlice(buf []byte, canonical, escapeHTML bool) *extJSONValueWriter {
+	stack := make([]ejvwState, 1, 5)
+	stack[0] = ejvwState{mode: mTopLevel}
+
+	return &extJSONValueWriter{
+		buf:        buf,
+		stack:      stack,
+		canonical:  canonical,
+		escapeHTML: escapeHTML,
+	}
+}
+
+func (ejvw *extJSONValueWriter) reset(buf []byte, canonical, escapeHTML bool) {
+	if ejvw.stack == nil {
+		ejvw.stack = make([]ejvwState, 1, 5)
+	}
+
+	ejvw.stack = ejvw.stack[:1]
+	ejvw.stack[0] = ejvwState{mode: mTopLevel}
+	ejvw.canonical = canonical
+	ejvw.escapeHTML = escapeHTML
+	ejvw.frame = 0
+	ejvw.buf = buf
+	ejvw.w = nil
+}
+
+func (ejvw *extJSONValueWriter) advanceFrame() {
+	if ejvw.frame+1 >= int64(len(ejvw.stack)) { // We need to grow the stack
+		length := len(ejvw.stack)
+		if length+1 >= cap(ejvw.stack) {
+			// double it
+			buf := make([]ejvwState, 2*cap(ejvw.stack)+1)
+			copy(buf, ejvw.stack)
+			ejvw.stack = buf
+		}
+		ejvw.stack = ejvw.stack[:length+1]
+	}
+	ejvw.frame++
+}
+
+func (ejvw *extJSONValueWriter) push(m mode) {
+	ejvw.advanceFrame()
+
+	ejvw.stack[ejvw.frame].mode = m
+}
+
+func (ejvw *extJSONValueWriter) pop() {
+	switch ejvw.stack[ejvw.frame].mode {
+	case mElement, mValue:
+		ejvw.frame--
+	case mDocument, mArray, mCodeWithScope:
+		ejvw.frame -= 2 // we pop twice to jump over the mElement: mDocument -> mElement -> mDocument/mTopLevel/etc...
+	}
+}
+
+func (ejvw *extJSONValueWriter) invalidTransitionErr(destination mode, name string, modes []mode) error {
+	te := TransitionError{
+		name:        name,
+		current:     ejvw.stack[ejvw.frame].mode,
+		destination: destination,
+		modes:       modes,
+		action:      "write",
+	}
+	if ejvw.frame != 0 {
+		te.parent = ejvw.stack[ejvw.frame-1].mode
+	}
+	return te
+}
+
+func (ejvw *extJSONValueWriter) ensureElementValue(destination mode, callerName string, addmodes ...mode) error {
+	switch ejvw.stack[ejvw.frame].mode {
+	case mElement, mValue:
+	default:
+		modes := []mode{mElement, mValue}
+		if addmodes != nil {
+			modes = append(modes, addmodes...)
+		}
+		return ejvw.invalidTransitionErr(destination, callerName, modes)
+	}
+
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) writeExtendedSingleValue(key string, value string, quotes bool) {
+	var s string
+	if quotes {
+		s = fmt.Sprintf(`{"$%s":"%s"}`, key, value)
+	} else {
+		s = fmt.Sprintf(`{"$%s":%s}`, key, value)
+	}
+
+	ejvw.buf = append(ejvw.buf, []byte(s)...)
+}
+
+func (ejvw *extJSONValueWriter) WriteArray() (ArrayWriter, error) {
+	if err := ejvw.ensureElementValue(mArray, "WriteArray"); err != nil {
+		return nil, err
+	}
+
+	ejvw.buf = append(ejvw.buf, '[')
+
+	ejvw.push(mArray)
+	return ejvw, nil
+}
+
+func (ejvw *extJSONValueWriter) WriteBinary(b []byte) error {
+	return ejvw.WriteBinaryWithSubtype(b, 0x00)
+}
+
+func (ejvw *extJSONValueWriter) WriteBinaryWithSubtype(b []byte, btype byte) error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteBinaryWithSubtype"); err != nil {
+		return err
+	}
+
+	var buf bytes.Buffer
+	buf.WriteString(`{"$binary":{"base64":"`)
+	buf.WriteString(base64.StdEncoding.EncodeToString(b))
+	buf.WriteString(fmt.Sprintf(`","subType":"%02x"}},`, btype))
+
+	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteBoolean(b bool) error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteBoolean"); err != nil {
+		return err
+	}
+
+	ejvw.buf = append(ejvw.buf, []byte(strconv.FormatBool(b))...)
+	ejvw.buf = append(ejvw.buf, ',')
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteCodeWithScope(code string) (DocumentWriter, error) {
+	if err := ejvw.ensureElementValue(mCodeWithScope, "WriteCodeWithScope"); err != nil {
+		return nil, err
+	}
+
+	var buf bytes.Buffer
+	buf.WriteString(`{"$code":`)
+	writeStringWithEscapes(code, &buf, ejvw.escapeHTML)
+	buf.WriteString(`,"$scope":{`)
+
+	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
+
+	ejvw.push(mCodeWithScope)
+	return ejvw, nil
+}
+
+func (ejvw *extJSONValueWriter) WriteDBPointer(ns string, oid ObjectID) error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteDBPointer"); err != nil {
+		return err
+	}
+
+	var buf bytes.Buffer
+	buf.WriteString(`{"$dbPointer":{"$ref":"`)
+	buf.WriteString(ns)
+	buf.WriteString(`","$id":{"$oid":"`)
+	buf.WriteString(oid.Hex())
+	buf.WriteString(`"}}},`)
+
+	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteDateTime(dt int64) error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteDateTime"); err != nil {
+		return err
+	}
+
+	t := time.Unix(dt/1e3, dt%1e3*1e6).UTC()
+
+	if ejvw.canonical || t.Year() < 1970 || t.Year() > 9999 {
+		s := fmt.Sprintf(`{"$numberLong":"%d"}`, dt)
+		ejvw.writeExtendedSingleValue("date", s, false)
+	} else {
+		ejvw.writeExtendedSingleValue("date", t.Format(rfc3339Milli), true)
+	}
+
+	ejvw.buf = append(ejvw.buf, ',')
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteDecimal128(d Decimal128) error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteDecimal128"); err != nil {
+		return err
+	}
+
+	ejvw.writeExtendedSingleValue("numberDecimal", d.String(), true)
+	ejvw.buf = append(ejvw.buf, ',')
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteDocument() (DocumentWriter, error) {
+	if ejvw.stack[ejvw.frame].mode == mTopLevel {
+		ejvw.buf = append(ejvw.buf, '{')
+		return ejvw, nil
+	}
+
+	if err := ejvw.ensureElementValue(mDocument, "WriteDocument", mTopLevel); err != nil {
+		return nil, err
+	}
+
+	ejvw.buf = append(ejvw.buf, '{')
+	ejvw.push(mDocument)
+	return ejvw, nil
+}
+
+func (ejvw *extJSONValueWriter) WriteDouble(f float64) error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteDouble"); err != nil {
+		return err
+	}
+
+	s := formatDouble(f)
+
+	if ejvw.canonical {
+		ejvw.writeExtendedSingleValue("numberDouble", s, true)
+	} else {
+		switch s {
+		case "Infinity":
+			fallthrough
+		case "-Infinity":
+			fallthrough
+		case "NaN":
+			s = fmt.Sprintf(`{"$numberDouble":"%s"}`, s)
+		}
+		ejvw.buf = append(ejvw.buf, []byte(s)...)
+	}
+
+	ejvw.buf = append(ejvw.buf, ',')
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteInt32(i int32) error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteInt32"); err != nil {
+		return err
+	}
+
+	s := strconv.FormatInt(int64(i), 10)
+
+	if ejvw.canonical {
+		ejvw.writeExtendedSingleValue("numberInt", s, true)
+	} else {
+		ejvw.buf = append(ejvw.buf, []byte(s)...)
+	}
+
+	ejvw.buf = append(ejvw.buf, ',')
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteInt64(i int64) error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteInt64"); err != nil {
+		return err
+	}
+
+	s := strconv.FormatInt(i, 10)
+
+	if ejvw.canonical {
+		ejvw.writeExtendedSingleValue("numberLong", s, true)
+	} else {
+		ejvw.buf = append(ejvw.buf, []byte(s)...)
+	}
+
+	ejvw.buf = append(ejvw.buf, ',')
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteJavascript(code string) error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteJavascript"); err != nil {
+		return err
+	}
+
+	var buf bytes.Buffer
+	writeStringWithEscapes(code, &buf, ejvw.escapeHTML)
+
+	ejvw.writeExtendedSingleValue("code", buf.String(), false)
+	ejvw.buf = append(ejvw.buf, ',')
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteMaxKey() error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteMaxKey"); err != nil {
+		return err
+	}
+
+	ejvw.writeExtendedSingleValue("maxKey", "1", false)
+	ejvw.buf = append(ejvw.buf, ',')
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteMinKey() error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteMinKey"); err != nil {
+		return err
+	}
+
+	ejvw.writeExtendedSingleValue("minKey", "1", false)
+	ejvw.buf = append(ejvw.buf, ',')
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteNull() error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteNull"); err != nil {
+		return err
+	}
+
+	ejvw.buf = append(ejvw.buf, []byte("null")...)
+	ejvw.buf = append(ejvw.buf, ',')
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteObjectID(oid ObjectID) error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteObjectID"); err != nil {
+		return err
+	}
+
+	ejvw.writeExtendedSingleValue("oid", oid.Hex(), true)
+	ejvw.buf = append(ejvw.buf, ',')
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteRegex(pattern string, options string) error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteRegex"); err != nil {
+		return err
+	}
+
+	options = sortStringAlphebeticAscending(options)
+	var buf bytes.Buffer
+	buf.WriteString(`{"$regularExpression":{"pattern":`)
+	writeStringWithEscapes(pattern, &buf, ejvw.escapeHTML)
+	buf.WriteString(`,"options":`)
+	writeStringWithEscapes(options, &buf, ejvw.escapeHTML)
+	buf.WriteString(`}},`)
+
+	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteString(s string) error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteString"); err != nil {
+		return err
+	}
+
+	var buf bytes.Buffer
+	writeStringWithEscapes(s, &buf, ejvw.escapeHTML)
+
+	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
+	ejvw.buf = append(ejvw.buf, ',')
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteSymbol(symbol string) error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteSymbol"); err != nil {
+		return err
+	}
+
+	var buf bytes.Buffer
+	writeStringWithEscapes(symbol, &buf, ejvw.escapeHTML)
+
+	ejvw.writeExtendedSingleValue("symbol", buf.String(), false)
+	ejvw.buf = append(ejvw.buf, ',')
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteTimestamp(t uint32, i uint32) error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteTimestamp"); err != nil {
+		return err
+	}
+
+	var buf bytes.Buffer
+	buf.WriteString(`{"$timestamp":{"t":`)
+	buf.WriteString(strconv.FormatUint(uint64(t), 10))
+	buf.WriteString(`,"i":`)
+	buf.WriteString(strconv.FormatUint(uint64(i), 10))
+	buf.WriteString(`}},`)
+
+	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteUndefined() error {
+	if err := ejvw.ensureElementValue(mode(0), "WriteUndefined"); err != nil {
+		return err
+	}
+
+	ejvw.writeExtendedSingleValue("undefined", "true", false)
+	ejvw.buf = append(ejvw.buf, ',')
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteDocumentElement(key string) (ValueWriter, error) {
+	switch ejvw.stack[ejvw.frame].mode {
+	case mDocument, mTopLevel, mCodeWithScope:
+		var buf bytes.Buffer
+		writeStringWithEscapes(key, &buf, ejvw.escapeHTML)
+
+		ejvw.buf = append(ejvw.buf, []byte(fmt.Sprintf(`%s:`, buf.String()))...)
+		ejvw.push(mElement)
+	default:
+		return nil, ejvw.invalidTransitionErr(mElement, "WriteDocumentElement", []mode{mDocument, mTopLevel, mCodeWithScope})
+	}
+
+	return ejvw, nil
+}
+
+func (ejvw *extJSONValueWriter) WriteDocumentEnd() error {
+	switch ejvw.stack[ejvw.frame].mode {
+	case mDocument, mTopLevel, mCodeWithScope:
+	default:
+		return fmt.Errorf("incorrect mode to end document: %s", ejvw.stack[ejvw.frame].mode)
+	}
+
+	// close the document
+	if ejvw.buf[len(ejvw.buf)-1] == ',' {
+		ejvw.buf[len(ejvw.buf)-1] = '}'
+	} else {
+		ejvw.buf = append(ejvw.buf, '}')
+	}
+
+	switch ejvw.stack[ejvw.frame].mode {
+	case mCodeWithScope:
+		ejvw.buf = append(ejvw.buf, '}')
+		fallthrough
+	case mDocument:
+		ejvw.buf = append(ejvw.buf, ',')
+	case mTopLevel:
+		// If the value writer has newlines enabled, end top-level documents with a newline so that
+		// multiple documents encoded to the same writer are separated by newlines. That matches the
+		// Go json.Encoder behavior and also works with NewExtJSONValueReader.
+		if ejvw.newlines {
+			ejvw.buf = append(ejvw.buf, '\n')
+		}
+		if ejvw.w != nil {
+			if _, err := ejvw.w.Write(ejvw.buf); err != nil {
+				return err
+			}
+			ejvw.buf = ejvw.buf[:0]
+		}
+	}
+
+	ejvw.pop()
+	return nil
+}
+
+func (ejvw *extJSONValueWriter) WriteArrayElement() (ValueWriter, error) {
+	switch ejvw.stack[ejvw.frame].mode {
+	case mArray:
+		ejvw.push(mValue)
+	default:
+		return nil, ejvw.invalidTransitionErr(mValue, "WriteArrayElement", []mode{mArray})
+	}
+
+	return ejvw, nil
+}
+
+func (ejvw *extJSONValueWriter) WriteArrayEnd() error {
+	switch ejvw.stack[ejvw.frame].mode {
+	case mArray:
+		// close the array
+		if ejvw.buf[len(ejvw.buf)-1] == ',' {
+			ejvw.buf[len(ejvw.buf)-1] = ']'
+		} else {
+			ejvw.buf = append(ejvw.buf, ']')
+		}
+
+		ejvw.buf = append(ejvw.buf, ',')
+
+		ejvw.pop()
+	default:
+		return fmt.Errorf("incorrect mode to end array: %s", ejvw.stack[ejvw.frame].mode)
+	}
+
+	return nil
+}
+
+func formatDouble(f float64) string {
+	var s string
+	switch {
+	case math.IsInf(f, 1):
+		s = "Infinity"
+	case math.IsInf(f, -1):
+		s = "-Infinity"
+	case math.IsNaN(f):
+		s = "NaN"
+	default:
+		// Print exactly one decimalType place for integers; otherwise, print as many are necessary to
+		// perfectly represent it.
+		s = strconv.FormatFloat(f, 'G', -1, 64)
+		if !strings.ContainsRune(s, 'E') && !strings.ContainsRune(s, '.') {
+			s += ".0"
+		}
+	}
+
+	return s
+}
+
+var hexChars = "0123456789abcdef"
+
+func writeStringWithEscapes(s string, buf *bytes.Buffer, escapeHTML bool) {
+	buf.WriteByte('"')
+	start := 0
+	for i := 0; i < len(s); {
+		if b := s[i]; b < utf8.RuneSelf {
+			if htmlSafeSet[b] || (!escapeHTML && safeSet[b]) {
+				i++
+				continue
+			}
+			if start < i {
+				buf.WriteString(s[start:i])
+			}
+			switch b {
+			case '\\', '"':
+				buf.WriteByte('\\')
+				buf.WriteByte(b)
+			case '\n':
+				buf.WriteByte('\\')
+				buf.WriteByte('n')
+			case '\r':
+				buf.WriteByte('\\')
+				buf.WriteByte('r')
+			case '\t':
+				buf.WriteByte('\\')
+				buf.WriteByte('t')
+			case '\b':
+				buf.WriteByte('\\')
+				buf.WriteByte('b')
+			case '\f':
+				buf.WriteByte('\\')
+				buf.WriteByte('f')
+			default:
+				// This encodes bytes < 0x20 except for \t, \n and \r.
+				// If escapeHTML is set, it also escapes <, >, and &
+				// because they can lead to security holes when
+				// user-controlled strings are rendered into JSON
+				// and served to some browsers.
+				buf.WriteString(`\u00`)
+				buf.WriteByte(hexChars[b>>4])
+				buf.WriteByte(hexChars[b&0xF])
+			}
+			i++
+			start = i
+			continue
+		}
+		c, size := utf8.DecodeRuneInString(s[i:])
+		if c == utf8.RuneError && size == 1 {
+			if start < i {
+				buf.WriteString(s[start:i])
+			}
+			buf.WriteString(`\ufffd`)
+			i += size
+			start = i
+			continue
+		}
+		// U+2028 is LINE SEPARATOR.
+		// U+2029 is PARAGRAPH SEPARATOR.
+		// They are both technically valid characters in JSON strings,
+		// but don't work in JSONP, which has to be evaluated as JavaScript,
+		// and can lead to security holes there. It is valid JSON to
+		// escape them, so we do so unconditionally.
+		// See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
+		if c == '\u2028' || c == '\u2029' {
+			if start < i {
+				buf.WriteString(s[start:i])
+			}
+			buf.WriteString(`\u202`)
+			buf.WriteByte(hexChars[c&0xF])
+			i += size
+			start = i
+			continue
+		}
+		i += size
+	}
+	if start < len(s) {
+		buf.WriteString(s[start:])
+	}
+	buf.WriteByte('"')
+}
+
+type sortableString []rune
+
+func (ss sortableString) Len() int {
+	return len(ss)
+}
+
+func (ss sortableString) Less(i, j int) bool {
+	return ss[i] < ss[j]
+}
+
+func (ss sortableString) Swap(i, j int) {
+	ss[i], ss[j] = ss[j], ss[i]
+}
+
+func sortStringAlphebeticAscending(s string) string {
+	ss := sortableString([]rune(s))
+	sort.Sort(ss)
+	return string([]rune(ss))
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/json_scanner.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/json_scanner.go
new file mode 100644
index 00000000..b6eba79e
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/json_scanner.go
@@ -0,0 +1,533 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"strconv"
+	"unicode"
+	"unicode/utf16"
+)
+
+type jsonTokenType byte
+
+const (
+	jttBeginObject jsonTokenType = iota
+	jttEndObject
+	jttBeginArray
+	jttEndArray
+	jttColon
+	jttComma
+	jttInt32
+	jttInt64
+	jttDouble
+	jttString
+	jttBool
+	jttNull
+	jttEOF
+)
+
+type jsonToken struct {
+	t jsonTokenType
+	v interface{}
+	p int
+}
+
+type jsonScanner struct {
+	r           io.Reader
+	buf         []byte
+	pos         int
+	lastReadErr error
+}
+
+// nextToken returns the next JSON token if one exists. A token is a character
+// of the JSON grammar, a number, a string, or a literal.
+func (js *jsonScanner) nextToken() (*jsonToken, error) {
+	c, err := js.readNextByte()
+
+	// keep reading until a non-space is encountered (break on read error or EOF)
+	for isWhiteSpace(c) && err == nil {
+		c, err = js.readNextByte()
+	}
+
+	if errors.Is(err, io.EOF) {
+		return &jsonToken{t: jttEOF}, nil
+	} else if err != nil {
+		return nil, err
+	}
+
+	// switch on the character
+	switch c {
+	case '{':
+		return &jsonToken{t: jttBeginObject, v: byte('{'), p: js.pos - 1}, nil
+	case '}':
+		return &jsonToken{t: jttEndObject, v: byte('}'), p: js.pos - 1}, nil
+	case '[':
+		return &jsonToken{t: jttBeginArray, v: byte('['), p: js.pos - 1}, nil
+	case ']':
+		return &jsonToken{t: jttEndArray, v: byte(']'), p: js.pos - 1}, nil
+	case ':':
+		return &jsonToken{t: jttColon, v: byte(':'), p: js.pos - 1}, nil
+	case ',':
+		return &jsonToken{t: jttComma, v: byte(','), p: js.pos - 1}, nil
+	case '"': // RFC-8259 only allows for double quotes (") not single (')
+		return js.scanString()
+	default:
+		// check if it's a number
+		switch {
+		case c == '-' || isDigit(c):
+			return js.scanNumber(c)
+		case c == 't' || c == 'f' || c == 'n':
+			// maybe a literal
+			return js.scanLiteral(c)
+		default:
+			return nil, fmt.Errorf("invalid JSON input. Position: %d. Character: %c", js.pos-1, c)
+		}
+	}
+}
+
+// readNextByte attempts to read the next byte from the buffer. If the buffer
+// has been exhausted, this function calls readIntoBuf, thus refilling the
+// buffer and resetting the read position to 0
+func (js *jsonScanner) readNextByte() (byte, error) {
+	if js.pos >= len(js.buf) {
+		err := js.readIntoBuf()
+
+		if err != nil {
+			return 0, err
+		}
+	}
+
+	b := js.buf[js.pos]
+	js.pos++
+
+	return b, nil
+}
+
+// readNNextBytes reads n bytes into dst, starting at offset
+func (js *jsonScanner) readNNextBytes(dst []byte, n, offset int) error {
+	var err error
+
+	for i := 0; i < n; i++ {
+		dst[i+offset], err = js.readNextByte()
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// readIntoBuf reads up to 512 bytes from the scanner's io.Reader into the buffer
+func (js *jsonScanner) readIntoBuf() error {
+	if js.lastReadErr != nil {
+		js.buf = js.buf[:0]
+		js.pos = 0
+		return js.lastReadErr
+	}
+
+	if cap(js.buf) == 0 {
+		js.buf = make([]byte, 0, 512)
+	}
+
+	n, err := js.r.Read(js.buf[:cap(js.buf)])
+	if err != nil {
+		js.lastReadErr = err
+		if n > 0 {
+			err = nil
+		}
+	}
+	js.buf = js.buf[:n]
+	js.pos = 0
+
+	return err
+}
+
+func isWhiteSpace(c byte) bool {
+	return c == ' ' || c == '\t' || c == '\r' || c == '\n'
+}
+
+func isDigit(c byte) bool {
+	return unicode.IsDigit(rune(c))
+}
+
+func isValueTerminator(c byte) bool {
+	return c == ',' || c == '}' || c == ']' || isWhiteSpace(c)
+}
+
+// getu4 decodes the 4-byte hex sequence from the beginning of s, returning the hex value as a rune,
+// or it returns -1. Note that the "\u" from the unicode escape sequence should not be present.
+// It is copied and lightly modified from the Go JSON decode function at
+// https://github.com/golang/go/blob/1b0a0316802b8048d69da49dc23c5a5ab08e8ae8/src/encoding/json/decode.go#L1169-L1188
+func getu4(s []byte) rune {
+	if len(s) < 4 {
+		return -1
+	}
+	var r rune
+	for _, c := range s[:4] {
+		switch {
+		case '0' <= c && c <= '9':
+			c -= '0'
+		case 'a' <= c && c <= 'f':
+			c = c - 'a' + 10
+		case 'A' <= c && c <= 'F':
+			c = c - 'A' + 10
+		default:
+			return -1
+		}
+		r = r*16 + rune(c)
+	}
+	return r
+}
+
+// scanString reads from an opening '"' to a closing '"' and handles escaped characters
+func (js *jsonScanner) scanString() (*jsonToken, error) {
+	var b bytes.Buffer
+	var c byte
+	var err error
+
+	p := js.pos - 1
+
+	for {
+		c, err = js.readNextByte()
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				return nil, errors.New("end of input in JSON string")
+			}
+			return nil, err
+		}
+
+	evalNextChar:
+		switch c {
+		case '\\':
+			c, err = js.readNextByte()
+			if err != nil {
+				if errors.Is(err, io.EOF) {
+					return nil, errors.New("end of input in JSON string")
+				}
+				return nil, err
+			}
+
+		evalNextEscapeChar:
+			switch c {
+			case '"', '\\', '/':
+				b.WriteByte(c)
+			case 'b':
+				b.WriteByte('\b')
+			case 'f':
+				b.WriteByte('\f')
+			case 'n':
+				b.WriteByte('\n')
+			case 'r':
+				b.WriteByte('\r')
+			case 't':
+				b.WriteByte('\t')
+			case 'u':
+				us := make([]byte, 4)
+				err = js.readNNextBytes(us, 4, 0)
+				if err != nil {
+					return nil, fmt.Errorf("invalid unicode sequence in JSON string: %s", us)
+				}
+
+				rn := getu4(us)
+
+				// If the rune we just decoded is the high or low value of a possible surrogate pair,
+				// try to decode the next sequence as the low value of a surrogate pair. We're
+				// expecting the next sequence to be another Unicode escape sequence (e.g. "\uDD1E"),
+				// but need to handle cases where the input is not a valid surrogate pair.
+				// For more context on unicode surrogate pairs, see:
+				// https://www.christianfscott.com/rust-chars-vs-go-runes/
+				// https://www.unicode.org/glossary/#high_surrogate_code_point
+				if utf16.IsSurrogate(rn) {
+					c, err = js.readNextByte()
+					if err != nil {
+						if errors.Is(err, io.EOF) {
+							return nil, errors.New("end of input in JSON string")
+						}
+						return nil, err
+					}
+
+					// If the next value isn't the beginning of a backslash escape sequence, write
+					// the Unicode replacement character for the surrogate value and goto the
+					// beginning of the next char eval block.
+					if c != '\\' {
+						b.WriteRune(unicode.ReplacementChar)
+						goto evalNextChar
+					}
+
+					c, err = js.readNextByte()
+					if err != nil {
+						if errors.Is(err, io.EOF) {
+							return nil, errors.New("end of input in JSON string")
+						}
+						return nil, err
+					}
+
+					// If the next value isn't the beginning of a unicode escape sequence, write the
+					// Unicode replacement character for the surrogate value and goto the beginning
+					// of the next escape char eval block.
+					if c != 'u' {
+						b.WriteRune(unicode.ReplacementChar)
+						goto evalNextEscapeChar
+					}
+
+					err = js.readNNextBytes(us, 4, 0)
+					if err != nil {
+						return nil, fmt.Errorf("invalid unicode sequence in JSON string: %s", us)
+					}
+
+					rn2 := getu4(us)
+
+					// Try to decode the pair of runes as a utf16 surrogate pair. If that fails, write
+					// the Unicode replacement character for the surrogate value and the 2nd decoded rune.
+					if rnPair := utf16.DecodeRune(rn, rn2); rnPair != unicode.ReplacementChar {
+						b.WriteRune(rnPair)
+					} else {
+						b.WriteRune(unicode.ReplacementChar)
+						b.WriteRune(rn2)
+					}
+
+					break
+				}
+
+				b.WriteRune(rn)
+			default:
+				return nil, fmt.Errorf("invalid escape sequence in JSON string '\\%c'", c)
+			}
+		case '"':
+			return &jsonToken{t: jttString, v: b.String(), p: p}, nil
+		default:
+			b.WriteByte(c)
+		}
+	}
+}
+
+// scanLiteral reads an unquoted sequence of characters and determines if it is one of
+// three valid JSON literals (true, false, null); if so, it returns the appropriate
+// jsonToken; otherwise, it returns an error
+func (js *jsonScanner) scanLiteral(first byte) (*jsonToken, error) {
+	p := js.pos - 1
+
+	lit := make([]byte, 4)
+	lit[0] = first
+
+	err := js.readNNextBytes(lit, 3, 1)
+	if err != nil {
+		return nil, err
+	}
+
+	c5, err := js.readNextByte()
+
+	switch {
+	case bytes.Equal([]byte("true"), lit) && (isValueTerminator(c5) || errors.Is(err, io.EOF)):
+		js.pos = int(math.Max(0, float64(js.pos-1)))
+		return &jsonToken{t: jttBool, v: true, p: p}, nil
+	case bytes.Equal([]byte("null"), lit) && (isValueTerminator(c5) || errors.Is(err, io.EOF)):
+		js.pos = int(math.Max(0, float64(js.pos-1)))
+		return &jsonToken{t: jttNull, v: nil, p: p}, nil
+	case bytes.Equal([]byte("fals"), lit):
+		if c5 == 'e' {
+			c5, err = js.readNextByte()
+
+			if isValueTerminator(c5) || errors.Is(err, io.EOF) {
+				js.pos = int(math.Max(0, float64(js.pos-1)))
+				return &jsonToken{t: jttBool, v: false, p: p}, nil
+			}
+		}
+	}
+
+	return nil, fmt.Errorf("invalid JSON literal. Position: %d, literal: %s", p, lit)
+}
+
+type numberScanState byte
+
+const (
+	nssSawLeadingMinus numberScanState = iota
+	nssSawLeadingZero
+	nssSawIntegerDigits
+	nssSawDecimalPoint
+	nssSawFractionDigits
+	nssSawExponentLetter
+	nssSawExponentSign
+	nssSawExponentDigits
+	nssDone
+	nssInvalid
+)
+
+// scanNumber reads a JSON number (according to RFC-8259)
+func (js *jsonScanner) scanNumber(first byte) (*jsonToken, error) {
+	var b bytes.Buffer
+	var s numberScanState
+	var c byte
+	var err error
+
+	t := jttInt64 // assume it's an int64 until the type can be determined
+	start := js.pos - 1
+
+	b.WriteByte(first)
+
+	switch first {
+	case '-':
+		s = nssSawLeadingMinus
+	case '0':
+		s = nssSawLeadingZero
+	default:
+		s = nssSawIntegerDigits
+	}
+
+	for {
+		c, err = js.readNextByte()
+
+		if err != nil && !errors.Is(err, io.EOF) {
+			return nil, err
+		}
+
+		switch s {
+		case nssSawLeadingMinus:
+			switch c {
+			case '0':
+				s = nssSawLeadingZero
+				b.WriteByte(c)
+			default:
+				if isDigit(c) {
+					s = nssSawIntegerDigits
+					b.WriteByte(c)
+				} else {
+					s = nssInvalid
+				}
+			}
+		case nssSawLeadingZero:
+			switch c {
+			case '.':
+				s = nssSawDecimalPoint
+				b.WriteByte(c)
+			case 'e', 'E':
+				s = nssSawExponentLetter
+				b.WriteByte(c)
+			case '}', ']', ',':
+				s = nssDone
+			default:
+				if isWhiteSpace(c) || errors.Is(err, io.EOF) {
+					s = nssDone
+				} else {
+					s = nssInvalid
+				}
+			}
+		case nssSawIntegerDigits:
+			switch c {
+			case '.':
+				s = nssSawDecimalPoint
+				b.WriteByte(c)
+			case 'e', 'E':
+				s = nssSawExponentLetter
+				b.WriteByte(c)
+			case '}', ']', ',':
+				s = nssDone
+			default:
+				switch {
+				case isWhiteSpace(c) || errors.Is(err, io.EOF):
+					s = nssDone
+				case isDigit(c):
+					s = nssSawIntegerDigits
+					b.WriteByte(c)
+				default:
+					s = nssInvalid
+				}
+			}
+		case nssSawDecimalPoint:
+			t = jttDouble
+			if isDigit(c) {
+				s = nssSawFractionDigits
+				b.WriteByte(c)
+			} else {
+				s = nssInvalid
+			}
+		case nssSawFractionDigits:
+			switch c {
+			case 'e', 'E':
+				s = nssSawExponentLetter
+				b.WriteByte(c)
+			case '}', ']', ',':
+				s = nssDone
+			default:
+				switch {
+				case isWhiteSpace(c) || errors.Is(err, io.EOF):
+					s = nssDone
+				case isDigit(c):
+					s = nssSawFractionDigits
+					b.WriteByte(c)
+				default:
+					s = nssInvalid
+				}
+			}
+		case nssSawExponentLetter:
+			t = jttDouble
+			switch c {
+			case '+', '-':
+				s = nssSawExponentSign
+				b.WriteByte(c)
+			default:
+				if isDigit(c) {
+					s = nssSawExponentDigits
+					b.WriteByte(c)
+				} else {
+					s = nssInvalid
+				}
+			}
+		case nssSawExponentSign:
+			if isDigit(c) {
+				s = nssSawExponentDigits
+				b.WriteByte(c)
+			} else {
+				s = nssInvalid
+			}
+		case nssSawExponentDigits:
+			switch c {
+			case '}', ']', ',':
+				s = nssDone
+			default:
+				switch {
+				case isWhiteSpace(c) || errors.Is(err, io.EOF):
+					s = nssDone
+				case isDigit(c):
+					s = nssSawExponentDigits
+					b.WriteByte(c)
+				default:
+					s = nssInvalid
+				}
+			}
+		}
+
+		switch s {
+		case nssInvalid:
+			return nil, fmt.Errorf("invalid JSON number. Position: %d", start)
+		case nssDone:
+			js.pos = int(math.Max(0, float64(js.pos-1)))
+			if t != jttDouble {
+				v, err := strconv.ParseInt(b.String(), 10, 64)
+				if err == nil {
+					if v < math.MinInt32 || v > math.MaxInt32 {
+						return &jsonToken{t: jttInt64, v: v, p: start}, nil
+					}
+
+					return &jsonToken{t: jttInt32, v: int32(v), p: start}, nil
+				}
+			}
+
+			v, err := strconv.ParseFloat(b.String(), 64)
+			if err != nil {
+				return nil, err
+			}
+
+			return &jsonToken{t: jttDouble, v: v, p: start}, nil
+		}
+	}
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/map_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/map_codec.go
new file mode 100644
index 00000000..4f33484b
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/map_codec.go
@@ -0,0 +1,292 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"encoding"
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+// mapCodec is the Codec used for map values.
+type mapCodec struct {
+	// DecodeZerosMap causes DecodeValue to delete any existing values from Go maps in the destination
+	// value passed to Decode before unmarshaling BSON documents into them.
+	decodeZerosMap bool
+
+	// EncodeNilAsEmpty causes EncodeValue to marshal nil Go maps as empty BSON documents instead of
+	// BSON null.
+	encodeNilAsEmpty bool
+
+	// EncodeKeysWithStringer causes the Encoder to convert Go map keys to BSON document field name
+	// strings using fmt.Sprintf() instead of the default string conversion logic.
+	encodeKeysWithStringer bool
+}
+
+// KeyMarshaler is the interface implemented by an object that can marshal itself into a string key.
+// This applies to types used as map keys and is similar to encoding.TextMarshaler.
+type KeyMarshaler interface {
+	MarshalKey() (key string, err error)
+}
+
+// KeyUnmarshaler is the interface implemented by an object that can unmarshal a string representation
+// of itself. This applies to types used as map keys and is similar to encoding.TextUnmarshaler.
+//
+// UnmarshalKey must be able to decode the form generated by MarshalKey.
+// UnmarshalKey must copy the text if it wishes to retain the text
+// after returning.
+type KeyUnmarshaler interface {
+	UnmarshalKey(key string) error
+}
+
+// EncodeValue is the ValueEncoder for map[*]* types.
+func (mc *mapCodec) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Kind() != reflect.Map {
+		return ValueEncoderError{Name: "MapEncodeValue", Kinds: []reflect.Kind{reflect.Map}, Received: val}
+	}
+
+	if val.IsNil() && !mc.encodeNilAsEmpty && !ec.nilMapAsEmpty {
+		// If we have a nil map but we can't WriteNull, that means we're probably trying to encode
+		// to a TopLevel document. We can't currently tell if this is what actually happened, but if
+		// there's a deeper underlying problem, the error will also be returned from WriteDocument,
+		// so just continue. The operations on a map reflection value are valid, so we can call
+		// MapKeys within mapEncodeValue without a problem.
+		err := vw.WriteNull()
+		if err == nil {
+			return nil
+		}
+	}
+
+	dw, err := vw.WriteDocument()
+	if err != nil {
+		return err
+	}
+
+	err = mc.encodeMapElements(ec, dw, val, nil)
+	if err != nil {
+		return err
+	}
+	return dw.WriteDocumentEnd()
+}
+
+// encodeMapElements handles encoding of the values of a map. The collisionFn returns
+// true if the provided key exists, this is mainly used for inline maps in the
+// struct codec.
+func (mc *mapCodec) encodeMapElements(ec EncodeContext, dw DocumentWriter, val reflect.Value, collisionFn func(string) bool) error {
+
+	elemType := val.Type().Elem()
+	encoder, err := ec.LookupEncoder(elemType)
+	if err != nil && elemType.Kind() != reflect.Interface {
+		return err
+	}
+
+	keys := val.MapKeys()
+	for _, key := range keys {
+		keyStr, err := mc.encodeKey(key, ec.stringifyMapKeysWithFmt)
+		if err != nil {
+			return err
+		}
+
+		if collisionFn != nil && collisionFn(keyStr) {
+			return fmt.Errorf("Key %s of inlined map conflicts with a struct field name", key)
+		}
+
+		currEncoder, currVal, lookupErr := lookupElementEncoder(ec, encoder, val.MapIndex(key))
+		if lookupErr != nil && !errors.Is(lookupErr, errInvalidValue) {
+			return lookupErr
+		}
+
+		vw, err := dw.WriteDocumentElement(keyStr)
+		if err != nil {
+			return err
+		}
+
+		if errors.Is(lookupErr, errInvalidValue) {
+			err = vw.WriteNull()
+			if err != nil {
+				return err
+			}
+			continue
+		}
+
+		err = currEncoder.EncodeValue(ec, vw, currVal)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// DecodeValue is the ValueDecoder for map[string/decimal]* types.
+func (mc *mapCodec) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if val.Kind() != reflect.Map || (!val.CanSet() && val.IsNil()) {
+		return ValueDecoderError{Name: "MapDecodeValue", Kinds: []reflect.Kind{reflect.Map}, Received: val}
+	}
+
+	switch vrType := vr.Type(); vrType {
+	case Type(0), TypeEmbeddedDocument:
+	case TypeNull:
+		val.Set(reflect.Zero(val.Type()))
+		return vr.ReadNull()
+	case TypeUndefined:
+		val.Set(reflect.Zero(val.Type()))
+		return vr.ReadUndefined()
+	default:
+		return fmt.Errorf("cannot decode %v into a %s", vrType, val.Type())
+	}
+
+	dr, err := vr.ReadDocument()
+	if err != nil {
+		return err
+	}
+
+	if val.IsNil() {
+		val.Set(reflect.MakeMap(val.Type()))
+	}
+
+	if val.Len() > 0 && (mc.decodeZerosMap || dc.zeroMaps) {
+		clearMap(val)
+	}
+
+	eType := val.Type().Elem()
+	decoder, err := dc.LookupDecoder(eType)
+	if err != nil {
+		return err
+	}
+
+	keyType := val.Type().Key()
+
+	for {
+		key, vr, err := dr.ReadElement()
+		if errors.Is(err, ErrEOD) {
+			break
+		}
+		if err != nil {
+			return err
+		}
+
+		k, err := mc.decodeKey(key, keyType)
+		if err != nil {
+			return err
+		}
+
+		elem, err := decodeTypeOrValueWithInfo(decoder, dc, vr, eType)
+		if err != nil {
+			return newDecodeError(key, err)
+		}
+
+		val.SetMapIndex(k, elem)
+	}
+	return nil
+}
+
+func clearMap(m reflect.Value) {
+	var none reflect.Value
+	for _, k := range m.MapKeys() {
+		m.SetMapIndex(k, none)
+	}
+}
+
+func (mc *mapCodec) encodeKey(val reflect.Value, encodeKeysWithStringer bool) (string, error) {
+	if mc.encodeKeysWithStringer || encodeKeysWithStringer {
+		return fmt.Sprint(val), nil
+	}
+
+	// keys of any string type are used directly
+	if val.Kind() == reflect.String {
+		return val.String(), nil
+	}
+	// KeyMarshalers are marshaled
+	if km, ok := val.Interface().(KeyMarshaler); ok {
+		if val.Kind() == reflect.Ptr && val.IsNil() {
+			return "", nil
+		}
+		buf, err := km.MarshalKey()
+		if err == nil {
+			return buf, nil
+		}
+		return "", err
+	}
+	// keys implement encoding.TextMarshaler are marshaled.
+	if km, ok := val.Interface().(encoding.TextMarshaler); ok {
+		if val.Kind() == reflect.Ptr && val.IsNil() {
+			return "", nil
+		}
+
+		buf, err := km.MarshalText()
+		if err != nil {
+			return "", err
+		}
+
+		return string(buf), nil
+	}
+
+	switch val.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return strconv.FormatInt(val.Int(), 10), nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return strconv.FormatUint(val.Uint(), 10), nil
+	}
+	return "", fmt.Errorf("unsupported key type: %v", val.Type())
+}
+
+var keyUnmarshalerType = reflect.TypeOf((*KeyUnmarshaler)(nil)).Elem()
+var textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
+
+func (mc *mapCodec) decodeKey(key string, keyType reflect.Type) (reflect.Value, error) {
+	keyVal := reflect.ValueOf(key)
+	var err error
+	switch {
+	// First, if EncodeKeysWithStringer is not enabled, try to decode withKeyUnmarshaler
+	case !mc.encodeKeysWithStringer && reflect.PtrTo(keyType).Implements(keyUnmarshalerType):
+		keyVal = reflect.New(keyType)
+		v := keyVal.Interface().(KeyUnmarshaler)
+		err = v.UnmarshalKey(key)
+		keyVal = keyVal.Elem()
+	// Try to decode encoding.TextUnmarshalers.
+	case reflect.PtrTo(keyType).Implements(textUnmarshalerType):
+		keyVal = reflect.New(keyType)
+		v := keyVal.Interface().(encoding.TextUnmarshaler)
+		err = v.UnmarshalText([]byte(key))
+		keyVal = keyVal.Elem()
+	// Otherwise, go to type specific behavior
+	default:
+		switch keyType.Kind() {
+		case reflect.String:
+			keyVal = reflect.ValueOf(key).Convert(keyType)
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			n, parseErr := strconv.ParseInt(key, 10, 64)
+			if parseErr != nil || reflect.Zero(keyType).OverflowInt(n) {
+				err = fmt.Errorf("failed to unmarshal number key %v", key)
+			}
+			keyVal = reflect.ValueOf(n).Convert(keyType)
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+			n, parseErr := strconv.ParseUint(key, 10, 64)
+			if parseErr != nil || reflect.Zero(keyType).OverflowUint(n) {
+				err = fmt.Errorf("failed to unmarshal number key %v", key)
+				break
+			}
+			keyVal = reflect.ValueOf(n).Convert(keyType)
+		case reflect.Float32, reflect.Float64:
+			if mc.encodeKeysWithStringer {
+				parsed, err := strconv.ParseFloat(key, 64)
+				if err != nil {
+					return keyVal, fmt.Errorf("Map key is defined to be a decimal type (%v) but got error %w", keyType.Kind(), err)
+				}
+				keyVal = reflect.ValueOf(parsed)
+				break
+			}
+			fallthrough
+		default:
+			return keyVal, fmt.Errorf("unsupported key type: %v", keyType)
+		}
+	}
+	return keyVal, err
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/marshal.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/marshal.go
new file mode 100644
index 00000000..88a85c0f
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/marshal.go
@@ -0,0 +1,191 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"bytes"
+	"encoding/json"
+	"sync"
+)
+
+const defaultDstCap = 256
+
+var extjPool = sync.Pool{
+	New: func() interface{} {
+		return new(extJSONValueWriter)
+	},
+}
+
+// Marshaler is the interface implemented by types that can marshal themselves
+// into a valid BSON document.
+//
+// Implementations of Marshaler must return a full BSON document. To create
+// custom BSON marshaling behavior for individual values in a BSON document,
+// implement the ValueMarshaler interface instead.
+type Marshaler interface {
+	MarshalBSON() ([]byte, error)
+}
+
+// ValueMarshaler is the interface implemented by types that can marshal
+// themselves into a valid BSON value. The format of the returned bytes must
+// match the returned type.
+//
+// Implementations of ValueMarshaler must return an individual BSON value. To
+// create custom BSON marshaling behavior for an entire BSON document, implement
+// the Marshaler interface instead.
+type ValueMarshaler interface {
+	MarshalBSONValue() (typ byte, data []byte, err error)
+}
+
+// Pool of buffers for marshalling BSON.
+var bufPool = sync.Pool{
+	New: func() interface{} {
+		return new(bytes.Buffer)
+	},
+}
+
+// Marshal returns the BSON encoding of val as a BSON document. If val is not a type that can be transformed into a
+// document, MarshalValue should be used instead.
+//
+// Marshal will use the default registry created by NewRegistry to recursively
+// marshal val into a []byte. Marshal will inspect struct tags and alter the
+// marshaling process accordingly.
+func Marshal(val interface{}) ([]byte, error) {
+	sw := bufPool.Get().(*bytes.Buffer)
+	defer func() {
+		// Proper usage of a sync.Pool requires each entry to have approximately
+		// the same memory cost. To obtain this property when the stored type
+		// contains a variably-sized buffer, we add a hard limit on the maximum
+		// buffer to place back in the pool. We limit the size to 16MiB because
+		// that's the maximum wire message size supported by any current MongoDB
+		// server.
+		//
+		// Comment based on
+		// https://cs.opensource.google/go/go/+/refs/tags/go1.19:src/fmt/print.go;l=147
+		//
+		// Recycle byte slices that are smaller than 16MiB and at least half
+		// occupied.
+		if sw.Cap() < 16*1024*1024 && sw.Cap()/2 < sw.Len() {
+			bufPool.Put(sw)
+		}
+	}()
+	sw.Reset()
+
+	vw := getDocumentWriter(sw)
+	defer putDocumentWriter(vw)
+
+	enc := encPool.Get().(*Encoder)
+	defer encPool.Put(enc)
+	enc.Reset(vw)
+	enc.SetRegistry(defaultRegistry)
+	err := enc.Encode(val)
+	if err != nil {
+		return nil, err
+	}
+	buf := append([]byte(nil), sw.Bytes()...)
+	return buf, nil
+}
+
+// MarshalValue returns the BSON encoding of val.
+//
+// MarshalValue will use bson.NewRegistry() to transform val into a BSON value. If val is a struct, this function will
+// inspect struct tags and alter the marshalling process accordingly.
+func MarshalValue(val interface{}) (Type, []byte, error) {
+	sw := bufPool.Get().(*bytes.Buffer)
+	defer func() {
+		// Proper usage of a sync.Pool requires each entry to have approximately
+		// the same memory cost. To obtain this property when the stored type
+		// contains a variably-sized buffer, we add a hard limit on the maximum
+		// buffer to place back in the pool. We limit the size to 16MiB because
+		// that's the maximum wire message size supported by any current MongoDB
+		// server.
+		//
+		// Comment based on
+		// https://cs.opensource.google/go/go/+/refs/tags/go1.19:src/fmt/print.go;l=147
+		//
+		// Recycle byte slices that are smaller than 16MiB and at least half
+		// occupied.
+		if sw.Cap() < 16*1024*1024 && sw.Cap()/2 < sw.Len() {
+			bufPool.Put(sw)
+		}
+	}()
+	sw.Reset()
+	vwFlusher := newDocumentWriter(sw)
+	vw, err := vwFlusher.WriteDocumentElement("")
+	if err != nil {
+		return 0, nil, err
+	}
+
+	// get an Encoder and encode the value
+	enc := encPool.Get().(*Encoder)
+	defer encPool.Put(enc)
+	enc.Reset(vw)
+	enc.SetRegistry(defaultRegistry)
+	if err := enc.Encode(val); err != nil {
+		return 0, nil, err
+	}
+
+	// flush the bytes written because we cannot guarantee that a full document has been written
+	// after the flush, *sw will be in the format
+	// [value type, 0 (null byte to indicate end of empty element name), value bytes..]
+	if err := vwFlusher.Flush(); err != nil {
+		return 0, nil, err
+	}
+	typ := sw.Next(2)
+	clone := append([]byte{}, sw.Bytes()...) // Don't hand out a shared reference to byte buffer bytes
+	// and fully copy the data. The byte buffer is (potentially) reused
+	// and handing out only a reference to the bytes may lead to race-conditions with the buffer.
+	return Type(typ[0]), clone, nil
+}
+
+// MarshalExtJSON returns the extended JSON encoding of val.
+func MarshalExtJSON(val interface{}, canonical, escapeHTML bool) ([]byte, error) {
+	sw := sliceWriter(make([]byte, 0, defaultDstCap))
+	ejvw := extjPool.Get().(*extJSONValueWriter)
+	ejvw.reset(sw, canonical, escapeHTML)
+	ejvw.w = &sw
+	defer func() {
+		ejvw.buf = nil
+		ejvw.w = nil
+		extjPool.Put(ejvw)
+	}()
+
+	enc := encPool.Get().(*Encoder)
+	defer encPool.Put(enc)
+
+	enc.Reset(ejvw)
+	enc.ec = EncodeContext{Registry: defaultRegistry}
+
+	err := enc.Encode(val)
+	if err != nil {
+		return nil, err
+	}
+
+	return sw, nil
+}
+
+// IndentExtJSON will prefix and indent the provided extended JSON src and append it to dst.
+func IndentExtJSON(dst *bytes.Buffer, src []byte, prefix, indent string) error {
+	return json.Indent(dst, src, prefix, indent)
+}
+
+// MarshalExtJSONIndent returns the extended JSON encoding of val with each line with prefixed
+// and indented.
+func MarshalExtJSONIndent(val interface{}, canonical, escapeHTML bool, prefix, indent string) ([]byte, error) {
+	marshaled, err := MarshalExtJSON(val, canonical, escapeHTML)
+	if err != nil {
+		return nil, err
+	}
+
+	var buf bytes.Buffer
+	err = IndentExtJSON(&buf, marshaled, prefix, indent)
+	if err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/mgoregistry.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/mgoregistry.go
new file mode 100644
index 00000000..f42935e5
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/mgoregistry.go
@@ -0,0 +1,209 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"errors"
+	"reflect"
+)
+
+var (
+	// ErrMgoSetZero may be returned from a SetBSON method to have the value set to its respective zero value.
+	ErrMgoSetZero = errors.New("set to zero")
+
+	tInt            = reflect.TypeOf(int(0))
+	tM              = reflect.TypeOf(M{})
+	tInterfaceSlice = reflect.TypeOf([]interface{}{})
+	tGetter         = reflect.TypeOf((*getter)(nil)).Elem()
+	tSetter         = reflect.TypeOf((*setter)(nil)).Elem()
+)
+
+// NewMgoRegistry creates a new bson.Registry configured with the default encoders and decoders.
+func NewMgoRegistry() *Registry {
+	mapCodec := &mapCodec{
+		decodeZerosMap:         true,
+		encodeNilAsEmpty:       true,
+		encodeKeysWithStringer: true,
+	}
+	structCodec := &structCodec{
+		inlineMapEncoder:        mapCodec,
+		decodeZeroStruct:        true,
+		encodeOmitDefaultStruct: true,
+		allowUnexportedFields:   true,
+	}
+	uintCodec := &uintCodec{encodeToMinSize: true}
+
+	reg := NewRegistry()
+	reg.RegisterTypeDecoder(tEmpty, &emptyInterfaceCodec{decodeBinaryAsSlice: true})
+	reg.RegisterKindDecoder(reflect.String, ValueDecoderFunc(mgoStringDecodeValue))
+	reg.RegisterKindDecoder(reflect.Struct, structCodec)
+	reg.RegisterKindDecoder(reflect.Map, mapCodec)
+	reg.RegisterTypeEncoder(tByteSlice, &byteSliceCodec{encodeNilAsEmpty: true})
+	reg.RegisterKindEncoder(reflect.Struct, structCodec)
+	reg.RegisterKindEncoder(reflect.Slice, &sliceCodec{encodeNilAsEmpty: true})
+	reg.RegisterKindEncoder(reflect.Map, mapCodec)
+	reg.RegisterKindEncoder(reflect.Uint, uintCodec)
+	reg.RegisterKindEncoder(reflect.Uint8, uintCodec)
+	reg.RegisterKindEncoder(reflect.Uint16, uintCodec)
+	reg.RegisterKindEncoder(reflect.Uint32, uintCodec)
+	reg.RegisterKindEncoder(reflect.Uint64, uintCodec)
+	reg.RegisterTypeMapEntry(TypeInt32, tInt)
+	reg.RegisterTypeMapEntry(TypeDateTime, tTime)
+	reg.RegisterTypeMapEntry(TypeArray, tInterfaceSlice)
+	reg.RegisterTypeMapEntry(Type(0), tM)
+	reg.RegisterTypeMapEntry(TypeEmbeddedDocument, tM)
+	reg.RegisterInterfaceEncoder(tGetter, ValueEncoderFunc(getterEncodeValue))
+	reg.RegisterInterfaceDecoder(tSetter, ValueDecoderFunc(setterDecodeValue))
+	return reg
+}
+
+// NewRespectNilValuesMgoRegistry creates a new bson.Registry configured to behave like mgo/bson
+// with RespectNilValues set to true.
+func NewRespectNilValuesMgoRegistry() *Registry {
+	mapCodec := &mapCodec{
+		decodeZerosMap: true,
+	}
+
+	reg := NewMgoRegistry()
+	reg.RegisterKindDecoder(reflect.Map, mapCodec)
+	reg.RegisterTypeEncoder(tByteSlice, &byteSliceCodec{encodeNilAsEmpty: false})
+	reg.RegisterKindEncoder(reflect.Slice, &sliceCodec{})
+	reg.RegisterKindEncoder(reflect.Map, mapCodec)
+	return reg
+}
+
+func mgoStringDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if val.Kind() != reflect.String {
+		return ValueDecoderError{
+			Name:     "StringDecodeValue",
+			Kinds:    []reflect.Kind{reflect.String},
+			Received: reflect.Zero(val.Type()),
+		}
+	}
+
+	if vr.Type() == TypeObjectID {
+		oid, err := vr.ReadObjectID()
+		if err != nil {
+			return err
+		}
+		if dc.objectIDAsHexString {
+			val.SetString(oid.Hex())
+		} else {
+			val.SetString(string(oid[:]))
+		}
+		return nil
+	}
+	return (&stringCodec{}).DecodeValue(dc, vr, val)
+}
+
+// setter interface: a value implementing the bson.Setter interface will receive the BSON
+// value via the SetBSON method during unmarshaling, and the object
+// itself will not be changed as usual.
+//
+// If setting the value works, the method should return nil or alternatively
+// ErrMgoSetZero to set the respective field to its zero value (nil for
+// pointer types). If SetBSON returns a non-nil error, the unmarshalling
+// procedure will stop and error out with the provided value.
+//
+// This interface is generally useful in pointer receivers, since the method
+// will want to change the receiver. A type field that implements the Setter
+// interface doesn't have to be a pointer, though.
+//
+// For example:
+//
+//	type MyString string
+//
+//	func (s *MyString) SetBSON(raw bson.RawValue) error {
+//	    return raw.Unmarshal(s)
+//	}
+type setter interface {
+	SetBSON(raw RawValue) error
+}
+
+// getter interface: a value implementing the bson.Getter interface will have its GetBSON
+// method called when the given value has to be marshalled, and the result
+// of this method will be marshaled in place of the actual object.
+//
+// If GetBSON returns return a non-nil error, the marshalling procedure
+// will stop and error out with the provided value.
+type getter interface {
+	GetBSON() (interface{}, error)
+}
+
+// setterDecodeValue is the ValueDecoderFunc for Setter types.
+func setterDecodeValue(_ DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.IsValid() || (!val.Type().Implements(tSetter) && !reflect.PtrTo(val.Type()).Implements(tSetter)) {
+		return ValueDecoderError{Name: "SetterDecodeValue", Types: []reflect.Type{tSetter}, Received: val}
+	}
+
+	if val.Kind() == reflect.Ptr && val.IsNil() {
+		if !val.CanSet() {
+			return ValueDecoderError{Name: "SetterDecodeValue", Types: []reflect.Type{tSetter}, Received: val}
+		}
+		val.Set(reflect.New(val.Type().Elem()))
+	}
+
+	if !val.Type().Implements(tSetter) {
+		if !val.CanAddr() {
+			return ValueDecoderError{Name: "ValueUnmarshalerDecodeValue", Types: []reflect.Type{tSetter}, Received: val}
+		}
+		val = val.Addr() // If the type doesn't implement the interface, a pointer to it must.
+	}
+
+	t, src, err := copyValueToBytes(vr)
+	if err != nil {
+		return err
+	}
+
+	m, ok := val.Interface().(setter)
+	if !ok {
+		return ValueDecoderError{Name: "SetterDecodeValue", Types: []reflect.Type{tSetter}, Received: val}
+	}
+	if err := m.SetBSON(RawValue{Type: t, Value: src}); err != nil {
+		if !errors.Is(err, ErrMgoSetZero) {
+			return err
+		}
+		val.Set(reflect.Zero(val.Type()))
+	}
+	return nil
+}
+
+// getterEncodeValue is the ValueEncoderFunc for Getter types.
+func getterEncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
+	// Either val or a pointer to val must implement Getter
+	switch {
+	case !val.IsValid():
+		return ValueEncoderError{Name: "GetterEncodeValue", Types: []reflect.Type{tGetter}, Received: val}
+	case val.Type().Implements(tGetter):
+		// If Getter is implemented on a concrete type, make sure that val isn't a nil pointer
+		if isImplementationNil(val, tGetter) {
+			return vw.WriteNull()
+		}
+	case reflect.PtrTo(val.Type()).Implements(tGetter) && val.CanAddr():
+		val = val.Addr()
+	default:
+		return ValueEncoderError{Name: "GetterEncodeValue", Types: []reflect.Type{tGetter}, Received: val}
+	}
+
+	m, ok := val.Interface().(getter)
+	if !ok {
+		return vw.WriteNull()
+	}
+	x, err := m.GetBSON()
+	if err != nil {
+		return err
+	}
+	if x == nil {
+		return vw.WriteNull()
+	}
+	vv := reflect.ValueOf(x)
+	encoder, err := ec.Registry.LookupEncoder(vv.Type())
+	if err != nil {
+		return err
+	}
+	return encoder.EncodeValue(ec, vw, vv)
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/mode.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/mode.go
new file mode 100644
index 00000000..a4563892
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/mode.go
@@ -0,0 +1,82 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"fmt"
+)
+
+type mode int
+
+const (
+	_ mode = iota
+	mTopLevel
+	mDocument
+	mArray
+	mValue
+	mElement
+	mCodeWithScope
+	mSpacer
+)
+
+func (m mode) String() string {
+	var str string
+
+	switch m {
+	case mTopLevel:
+		str = "TopLevel"
+	case mDocument:
+		str = "Document"
+	case mArray:
+		str = "Array"
+	case mValue:
+		str = "Value"
+	case mElement:
+		str = "Element"
+	case mCodeWithScope:
+		str = "CodeWithScope"
+	case mSpacer:
+		str = "CodeWithScopeSpacer"
+	default:
+		str = "Unknown"
+	}
+
+	return str
+}
+
+// TransitionError is an error returned when an invalid progressing a
+// ValueReader or ValueWriter state machine occurs.
+type TransitionError struct {
+	name        string
+	parent      mode
+	current     mode
+	destination mode
+	modes       []mode
+	action      string
+}
+
+func (te TransitionError) Error() string {
+	errString := fmt.Sprintf("%s can only %s", te.name, te.action)
+	if te.destination != mode(0) {
+		errString = fmt.Sprintf("%s a %s", errString, te.destination)
+	}
+	errString = fmt.Sprintf("%s while positioned on a", errString)
+	for ind, m := range te.modes {
+		if ind != 0 && len(te.modes) > 2 {
+			errString = fmt.Sprintf("%s,", errString)
+		}
+		if ind == len(te.modes)-1 && len(te.modes) > 1 {
+			errString = fmt.Sprintf("%s or", errString)
+		}
+		errString = fmt.Sprintf("%s %s", errString, m)
+	}
+	errString = fmt.Sprintf("%s but is positioned on a %s", errString, te.current)
+	if te.parent != mode(0) {
+		errString = fmt.Sprintf("%s with parent %s", errString, te.parent)
+	}
+	return errString
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/objectid.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/objectid.go
new file mode 100644
index 00000000..024281eb
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/objectid.go
@@ -0,0 +1,207 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+//
+// Based on gopkg.in/mgo.v2/bson by Gustavo Niemeyer
+// See THIRD-PARTY-NOTICES for original license terms.
+
+package bson
+
+import (
+	"crypto/rand"
+	"encoding"
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"sync/atomic"
+	"time"
+)
+
+// ErrInvalidHex indicates that a hex string cannot be converted to an ObjectID.
+var ErrInvalidHex = errors.New("the provided hex string is not a valid ObjectID")
+
+// ObjectID is the BSON ObjectID type.
+type ObjectID [12]byte
+
+// NilObjectID is the zero value for ObjectID.
+var NilObjectID ObjectID
+
+var objectIDCounter = readRandomUint32()
+var processUnique = processUniqueBytes()
+
+var _ encoding.TextMarshaler = ObjectID{}
+var _ encoding.TextUnmarshaler = &ObjectID{}
+
+// NewObjectID generates a new ObjectID.
+func NewObjectID() ObjectID {
+	return NewObjectIDFromTimestamp(time.Now())
+}
+
+// NewObjectIDFromTimestamp generates a new ObjectID based on the given time.
+func NewObjectIDFromTimestamp(timestamp time.Time) ObjectID {
+	var b [12]byte
+
+	binary.BigEndian.PutUint32(b[0:4], uint32(timestamp.Unix()))
+	copy(b[4:9], processUnique[:])
+	putUint24(b[9:12], atomic.AddUint32(&objectIDCounter, 1))
+
+	return b
+}
+
+// Timestamp extracts the time part of the ObjectId.
+func (id ObjectID) Timestamp() time.Time {
+	unixSecs := binary.BigEndian.Uint32(id[0:4])
+	return time.Unix(int64(unixSecs), 0).UTC()
+}
+
+// Hex returns the hex encoding of the ObjectID as a string.
+func (id ObjectID) Hex() string {
+	var buf [24]byte
+	hex.Encode(buf[:], id[:])
+	return string(buf[:])
+}
+
+func (id ObjectID) String() string {
+	return `ObjectID("` + id.Hex() + `")`
+}
+
+// IsZero returns true if id is the empty ObjectID.
+func (id ObjectID) IsZero() bool {
+	return id == NilObjectID
+}
+
+// ObjectIDFromHex creates a new ObjectID from a hex string. It returns an error if the hex string is not a
+// valid ObjectID.
+func ObjectIDFromHex(s string) (ObjectID, error) {
+	if len(s) != 24 {
+		return NilObjectID, ErrInvalidHex
+	}
+
+	var oid [12]byte
+	_, err := hex.Decode(oid[:], []byte(s))
+	if err != nil {
+		return NilObjectID, err
+	}
+
+	return oid, nil
+}
+
+// MarshalText returns the ObjectID as UTF-8-encoded text. Implementing this allows us to use ObjectID
+// as a map key when marshalling JSON. See https://pkg.go.dev/encoding#TextMarshaler
+func (id ObjectID) MarshalText() ([]byte, error) {
+	var buf [24]byte
+	hex.Encode(buf[:], id[:])
+	return buf[:], nil
+}
+
+// UnmarshalText populates the byte slice with the ObjectID. If the byte slice
+// is 24 bytes long, it will be populated with the hex representation of the
+// ObjectID. If the byte slice is 12 bytes long, it will be populated with the
+// BSON representation of the ObjectID. This method also accepts empty strings
+// and decodes them as NilObjectID.
+//
+// For any other inputs, an error will be returned.
+//
+// Implementing this allows us to use ObjectID as a map key when unmarshalling
+// JSON. See https://pkg.go.dev/encoding#TextUnmarshaler
+func (id *ObjectID) UnmarshalText(b []byte) error {
+	// NB(charlie): The json package will use UnmarshalText instead of
+	// UnmarshalJSON if the value is a string.
+
+	// An empty string is not a valid ObjectID, but we treat it as a
+	// special value that decodes as NilObjectID.
+	if len(b) == 0 {
+		return nil
+	}
+	oid, err := ObjectIDFromHex(string(b))
+	if err != nil {
+		return err
+	}
+	*id = oid
+	return nil
+}
+
+// MarshalJSON returns the ObjectID as a string
+func (id ObjectID) MarshalJSON() ([]byte, error) {
+	var buf [26]byte
+	buf[0] = '"'
+	hex.Encode(buf[1:25], id[:])
+	buf[25] = '"'
+	return buf[:], nil
+}
+
+// UnmarshalJSON populates the byte slice with the ObjectID. If the byte slice
+// is 24 bytes long, it will be populated with the hex representation of the
+// ObjectID. If the byte slice is 12 bytes long, it will be populated with the
+// BSON representation of the ObjectID. This method also accepts empty strings
+// and decodes them as NilObjectID.
+//
+// As a special case UnmarshalJSON will decode a JSON object with key "$oid"
+// that stores a hex encoded ObjectID: {"$oid": "65b3f7edd9bfca00daa6e3b31"}.
+//
+// For any other inputs, an error will be returned.
+func (id *ObjectID) UnmarshalJSON(b []byte) error {
+	// Ignore "null" to keep parity with the standard library. Decoding a JSON
+	// null into a non-pointer ObjectID field will leave the field unchanged.
+	// For pointer values, encoding/json will set the pointer to nil and will
+	// not enter the UnmarshalJSON hook.
+	if string(b) == "null" {
+		return nil
+	}
+
+	// Handle string
+	if len(b) >= 2 && b[0] == '"' {
+		// TODO: fails because of error
+		return id.UnmarshalText(b[1 : len(b)-1])
+	}
+	if len(b) == 12 {
+		copy(id[:], b)
+		return nil
+	}
+	var v struct {
+		OID *string `json:"$oid"`
+	}
+	if err := json.Unmarshal(b, &v); err != nil {
+		return fmt.Errorf("failed to parse extended JSON ObjectID: %w", err)
+	}
+	if v.OID == nil {
+		return errors.New("not an extended JSON ObjectID")
+	}
+	i, err := ObjectIDFromHex(*v.OID)
+	if err != nil {
+		return err
+	}
+	*id = i
+	return nil
+}
+
+func processUniqueBytes() [5]byte {
+	var b [5]byte
+	_, err := io.ReadFull(rand.Reader, b[:])
+	if err != nil {
+		panic(fmt.Errorf("cannot initialize objectid package with crypto.rand.Reader: %w", err))
+	}
+
+	return b
+}
+
+func readRandomUint32() uint32 {
+	var b [4]byte
+	_, err := io.ReadFull(rand.Reader, b[:])
+	if err != nil {
+		panic(fmt.Errorf("cannot initialize objectid package with crypto.rand.Reader: %w", err))
+	}
+
+	return (uint32(b[0]) << 0) | (uint32(b[1]) << 8) | (uint32(b[2]) << 16) | (uint32(b[3]) << 24)
+}
+
+func putUint24(b []byte, v uint32) {
+	b[0] = byte(v >> 16)
+	b[1] = byte(v >> 8)
+	b[2] = byte(v)
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/pointer_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/pointer_codec.go
new file mode 100644
index 00000000..ff2e940c
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/pointer_codec.go
@@ -0,0 +1,88 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"reflect"
+)
+
+var (
+	_ ValueEncoder = &pointerCodec{}
+	_ ValueDecoder = &pointerCodec{}
+)
+
+// pointerCodec is the Codec used for pointers.
+type pointerCodec struct {
+	ecache typeEncoderCache
+	dcache typeDecoderCache
+}
+
+// EncodeValue handles encoding a pointer by either encoding it to BSON Null if the pointer is nil
+// or looking up an encoder for the type of value the pointer points to.
+func (pc *pointerCodec) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if val.Kind() != reflect.Ptr {
+		if !val.IsValid() {
+			return vw.WriteNull()
+		}
+		return ValueEncoderError{Name: "PointerCodec.EncodeValue", Kinds: []reflect.Kind{reflect.Ptr}, Received: val}
+	}
+
+	if val.IsNil() {
+		return vw.WriteNull()
+	}
+
+	typ := val.Type()
+	if v, ok := pc.ecache.Load(typ); ok {
+		if v == nil {
+			return errNoEncoder{Type: typ}
+		}
+		return v.EncodeValue(ec, vw, val.Elem())
+	}
+	// TODO(charlie): handle concurrent requests for the same type
+	enc, err := ec.LookupEncoder(typ.Elem())
+	enc = pc.ecache.LoadOrStore(typ, enc)
+	if err != nil {
+		return err
+	}
+	return enc.EncodeValue(ec, vw, val.Elem())
+}
+
+// DecodeValue handles decoding a pointer by looking up a decoder for the type it points to and
+// using that to decode. If the BSON value is Null, this method will set the pointer to nil.
+func (pc *pointerCodec) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Kind() != reflect.Ptr {
+		return ValueDecoderError{Name: "PointerCodec.DecodeValue", Kinds: []reflect.Kind{reflect.Ptr}, Received: val}
+	}
+
+	typ := val.Type()
+	if vr.Type() == TypeNull {
+		val.Set(reflect.Zero(typ))
+		return vr.ReadNull()
+	}
+	if vr.Type() == TypeUndefined {
+		val.Set(reflect.Zero(typ))
+		return vr.ReadUndefined()
+	}
+
+	if val.IsNil() {
+		val.Set(reflect.New(typ.Elem()))
+	}
+
+	if v, ok := pc.dcache.Load(typ); ok {
+		if v == nil {
+			return errNoDecoder{Type: typ}
+		}
+		return v.DecodeValue(dc, vr, val.Elem())
+	}
+	// TODO(charlie): handle concurrent requests for the same type
+	dec, err := dc.LookupDecoder(typ.Elem())
+	dec = pc.dcache.LoadOrStore(typ, dec)
+	if err != nil {
+		return err
+	}
+	return dec.DecodeValue(dc, vr, val.Elem())
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/primitive.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/primitive.go
new file mode 100644
index 00000000..162bfa71
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/primitive.go
@@ -0,0 +1,379 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+//
+// Based on gopkg.in/mgo.v2/bson by Gustavo Niemeyer
+// See THIRD-PARTY-NOTICES for original license terms.
+
+package bson
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"time"
+)
+
+// Zeroer allows custom struct types to implement a report of zero
+// state. All struct types that don't implement Zeroer or where IsZero
+// returns false are considered to be not zero.
+type Zeroer interface {
+	IsZero() bool
+}
+
+// The following primitive types are similar to Go primitives for BSON types that
+// do not have direct Go primitive representations.
+
+// Binary represents a BSON binary value.
+type Binary struct {
+	Subtype byte
+	Data    []byte
+}
+
+// Equal compares bp to bp2 and returns true if they are equal.
+func (bp Binary) Equal(bp2 Binary) bool {
+	if bp.Subtype != bp2.Subtype {
+		return false
+	}
+	return bytes.Equal(bp.Data, bp2.Data)
+}
+
+// IsZero returns if bp is the empty Binary.
+func (bp Binary) IsZero() bool {
+	return bp.Subtype == 0 && len(bp.Data) == 0
+}
+
+// Undefined represents the BSON undefined value type.
+type Undefined struct{}
+
+// DateTime represents the BSON datetime value.
+type DateTime int64
+
+var _ json.Marshaler = DateTime(0)
+var _ json.Unmarshaler = (*DateTime)(nil)
+
+// MarshalJSON marshal to time type.
+func (d DateTime) MarshalJSON() ([]byte, error) {
+	return d.Time().UTC().MarshalJSON()
+}
+
+// UnmarshalJSON creates a bson.DateTime from a JSON string.
+func (d *DateTime) UnmarshalJSON(data []byte) error {
+	// Ignore "null" so that we can distinguish between a "null" value and
+	// valid value that is the zero time (as reported by time.Time.IsZero).
+	if string(data) == "null" {
+		return nil
+	}
+	var t time.Time
+	if err := t.UnmarshalJSON(data); err != nil {
+		return err
+	}
+	*d = NewDateTimeFromTime(t)
+	return nil
+}
+
+// Time returns the date as a time type.
+func (d DateTime) Time() time.Time {
+	return time.Unix(int64(d)/1000, int64(d)%1000*1000000)
+}
+
+// NewDateTimeFromTime creates a new DateTime from a Time.
+func NewDateTimeFromTime(t time.Time) DateTime {
+	return DateTime(t.Unix()*1e3 + int64(t.Nanosecond())/1e6)
+}
+
+// Null represents the BSON null value.
+type Null struct{}
+
+// Regex represents a BSON regex value.
+type Regex struct {
+	Pattern string
+	Options string
+}
+
+func (rp Regex) String() string {
+	return fmt.Sprintf(`{"pattern": "%s", "options": "%s"}`, rp.Pattern, rp.Options)
+}
+
+// Equal compares rp to rp2 and returns true if they are equal.
+func (rp Regex) Equal(rp2 Regex) bool {
+	return rp.Pattern == rp2.Pattern && rp.Options == rp2.Options
+}
+
+// IsZero returns if rp is the empty Regex.
+func (rp Regex) IsZero() bool {
+	return rp.Pattern == "" && rp.Options == ""
+}
+
+// DBPointer represents a BSON dbpointer value.
+type DBPointer struct {
+	DB      string
+	Pointer ObjectID
+}
+
+func (d DBPointer) String() string {
+	return fmt.Sprintf(`{"db": "%s", "pointer": "%s"}`, d.DB, d.Pointer)
+}
+
+// Equal compares d to d2 and returns true if they are equal.
+func (d DBPointer) Equal(d2 DBPointer) bool {
+	return d == d2
+}
+
+// IsZero returns if d is the empty DBPointer.
+func (d DBPointer) IsZero() bool {
+	return d.DB == "" && d.Pointer.IsZero()
+}
+
+// JavaScript represents a BSON JavaScript code value.
+type JavaScript string
+
+// Symbol represents a BSON symbol value.
+type Symbol string
+
+// CodeWithScope represents a BSON JavaScript code with scope value.
+type CodeWithScope struct {
+	Code  JavaScript
+	Scope interface{}
+}
+
+func (cws CodeWithScope) String() string {
+	return fmt.Sprintf(`{"code": "%s", "scope": %v}`, cws.Code, cws.Scope)
+}
+
+// Timestamp represents a BSON timestamp value.
+type Timestamp struct {
+	T uint32
+	I uint32
+}
+
+// After reports whether the time instant tp is after tp2.
+func (tp Timestamp) After(tp2 Timestamp) bool {
+	return tp.T > tp2.T || (tp.T == tp2.T && tp.I > tp2.I)
+}
+
+// Before reports whether the time instant tp is before tp2.
+func (tp Timestamp) Before(tp2 Timestamp) bool {
+	return tp.T < tp2.T || (tp.T == tp2.T && tp.I < tp2.I)
+}
+
+// Equal compares tp to tp2 and returns true if they are equal.
+func (tp Timestamp) Equal(tp2 Timestamp) bool {
+	return tp.T == tp2.T && tp.I == tp2.I
+}
+
+// IsZero returns if tp is the zero Timestamp.
+func (tp Timestamp) IsZero() bool {
+	return tp.T == 0 && tp.I == 0
+}
+
+// Compare compares the time instant tp with tp2. If tp is before tp2, it returns -1; if tp is after
+// tp2, it returns +1; if they're the same, it returns 0.
+func (tp Timestamp) Compare(tp2 Timestamp) int {
+	switch {
+	case tp.Equal(tp2):
+		return 0
+	case tp.Before(tp2):
+		return -1
+	default:
+		return +1
+	}
+}
+
+// MinKey represents the BSON minkey value.
+type MinKey struct{}
+
+// MaxKey represents the BSON maxkey value.
+type MaxKey struct{}
+
+// D is an ordered representation of a BSON document. This type should be used when the order of the elements matters,
+// such as MongoDB command documents. If the order of the elements does not matter, an M should be used instead.
+//
+// Example usage:
+//
+//	bson.D{{"foo", "bar"}, {"hello", "world"}, {"pi", 3.14159}}
+type D []E
+
+func (d D) String() string {
+	b, err := MarshalExtJSON(d, true, false)
+	if err != nil {
+		return ""
+	}
+	return string(b)
+}
+
+// MarshalJSON encodes D into JSON.
+func (d D) MarshalJSON() ([]byte, error) {
+	if d == nil {
+		return json.Marshal(nil)
+	}
+	var err error
+	var buf bytes.Buffer
+	buf.Write([]byte("{"))
+	enc := json.NewEncoder(&buf)
+	for i, e := range d {
+		err = enc.Encode(e.Key)
+		if err != nil {
+			return nil, err
+		}
+		buf.Write([]byte(":"))
+		err = enc.Encode(e.Value)
+		if err != nil {
+			return nil, err
+		}
+		if i < len(d)-1 {
+			buf.Write([]byte(","))
+		}
+	}
+	buf.Write([]byte("}"))
+	return json.RawMessage(buf.Bytes()).MarshalJSON()
+}
+
+// UnmarshalJSON decodes D from JSON.
+func (d *D) UnmarshalJSON(b []byte) error {
+	dec := json.NewDecoder(bytes.NewReader(b))
+	t, err := dec.Token()
+	if err != nil {
+		return err
+	}
+	if t == nil {
+		*d = nil
+		return nil
+	}
+	if v, ok := t.(json.Delim); !ok || v != '{' {
+		return &json.UnmarshalTypeError{
+			Value:  tokenString(t),
+			Type:   reflect.TypeOf(D(nil)),
+			Offset: dec.InputOffset(),
+		}
+	}
+	*d, err = jsonDecodeD(dec)
+	return err
+}
+
+// E represents a BSON element for a D. It is usually used inside a D.
+type E struct {
+	Key   string
+	Value interface{}
+}
+
+// M is an unordered representation of a BSON document. This type should be used when the order of the elements does not
+// matter. This type is handled as a regular map[string]interface{} when encoding and decoding. Elements will be
+// serialized in an undefined, random order. If the order of the elements matters, a D should be used instead.
+//
+// Example usage:
+//
+//	bson.M{"foo": "bar", "hello": "world", "pi": 3.14159}
+type M map[string]interface{}
+
+func (m M) String() string {
+	b, err := MarshalExtJSON(m, true, false)
+	if err != nil {
+		return ""
+	}
+	return string(b)
+}
+
+// An A is an ordered representation of a BSON array.
+//
+// Example usage:
+//
+//	bson.A{"bar", "world", 3.14159, bson.D{{"qux", 12345}}}
+type A []interface{}
+
+func jsonDecodeD(dec *json.Decoder) (D, error) {
+	res := D{}
+	for {
+		var e E
+
+		t, err := dec.Token()
+		if err != nil {
+			return nil, err
+		}
+		key, ok := t.(string)
+		if !ok {
+			break
+		}
+		e.Key = key
+
+		t, err = dec.Token()
+		if err != nil {
+			return nil, err
+		}
+		switch v := t.(type) {
+		case json.Delim:
+			switch v {
+			case '[':
+				e.Value, err = jsonDecodeSlice(dec)
+				if err != nil {
+					return nil, err
+				}
+			case '{':
+				e.Value, err = jsonDecodeD(dec)
+				if err != nil {
+					return nil, err
+				}
+			}
+		default:
+			e.Value = t
+		}
+
+		res = append(res, e)
+	}
+	return res, nil
+}
+
+func jsonDecodeSlice(dec *json.Decoder) ([]interface{}, error) {
+	var res []interface{}
+	done := false
+	for !done {
+		t, err := dec.Token()
+		if err != nil {
+			return nil, err
+		}
+		switch v := t.(type) {
+		case json.Delim:
+			switch v {
+			case '[':
+				a, err := jsonDecodeSlice(dec)
+				if err != nil {
+					return nil, err
+				}
+				res = append(res, a)
+			case '{':
+				d, err := jsonDecodeD(dec)
+				if err != nil {
+					return nil, err
+				}
+				res = append(res, d)
+			default:
+				done = true
+			}
+		default:
+			res = append(res, t)
+		}
+	}
+	return res, nil
+}
+
+func tokenString(t json.Token) string {
+	switch v := t.(type) {
+	case json.Delim:
+		switch v {
+		case '{':
+			return "object"
+		case '[':
+			return "array"
+		}
+	case bool:
+		return "bool"
+	case float64:
+		return "number"
+	case json.Number, string:
+		return "string"
+	}
+	return "unknown"
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/primitive_codecs.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/primitive_codecs.go
new file mode 100644
index 00000000..5ac5f000
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/primitive_codecs.go
@@ -0,0 +1,89 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"fmt"
+	"reflect"
+)
+
+var tRawValue = reflect.TypeOf(RawValue{})
+var tRaw = reflect.TypeOf(Raw(nil))
+
+// registerPrimitiveCodecs will register the encode and decode methods attached to PrimitiveCodecs
+// with the provided RegistryBuilder. if rb is nil, a new empty RegistryBuilder will be created.
+func registerPrimitiveCodecs(reg *Registry) {
+	reg.RegisterTypeEncoder(tRawValue, ValueEncoderFunc(rawValueEncodeValue))
+	reg.RegisterTypeEncoder(tRaw, ValueEncoderFunc(rawEncodeValue))
+	reg.RegisterTypeDecoder(tRawValue, ValueDecoderFunc(rawValueDecodeValue))
+	reg.RegisterTypeDecoder(tRaw, ValueDecoderFunc(rawDecodeValue))
+}
+
+// rawValueEncodeValue is the ValueEncoderFunc for RawValue.
+//
+// If the RawValue's Type is "invalid" and the RawValue's Value is not empty or
+// nil, then this method will return an error.
+func rawValueEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tRawValue {
+		return ValueEncoderError{
+			Name:     "RawValueEncodeValue",
+			Types:    []reflect.Type{tRawValue},
+			Received: val,
+		}
+	}
+
+	rawvalue := val.Interface().(RawValue)
+
+	if !rawvalue.Type.IsValid() {
+		return fmt.Errorf("the RawValue Type specifies an invalid BSON type: %#x", byte(rawvalue.Type))
+	}
+
+	return copyValueFromBytes(vw, rawvalue.Type, rawvalue.Value)
+}
+
+// rawValueDecodeValue is the ValueDecoderFunc for RawValue.
+func rawValueDecodeValue(_ DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tRawValue {
+		return ValueDecoderError{Name: "RawValueDecodeValue", Types: []reflect.Type{tRawValue}, Received: val}
+	}
+
+	t, value, err := copyValueToBytes(vr)
+	if err != nil {
+		return err
+	}
+
+	val.Set(reflect.ValueOf(RawValue{Type: t, Value: value}))
+	return nil
+}
+
+// rawEncodeValue is the ValueEncoderFunc for Reader.
+func rawEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tRaw {
+		return ValueEncoderError{Name: "RawEncodeValue", Types: []reflect.Type{tRaw}, Received: val}
+	}
+
+	rdr := val.Interface().(Raw)
+
+	return copyDocumentFromBytes(vw, rdr)
+}
+
+// rawDecodeValue is the ValueDecoderFunc for Reader.
+func rawDecodeValue(_ DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tRaw {
+		return ValueDecoderError{Name: "RawDecodeValue", Types: []reflect.Type{tRaw}, Received: val}
+	}
+
+	if val.IsNil() {
+		val.Set(reflect.MakeSlice(val.Type(), 0, 0))
+	}
+
+	val.SetLen(0)
+
+	rdr, err := appendDocumentBytes(val.Interface().(Raw), vr)
+	val.Set(reflect.ValueOf(rdr))
+	return err
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/raw.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/raw.go
new file mode 100644
index 00000000..1c49faee
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/raw.go
@@ -0,0 +1,93 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"errors"
+	"io"
+
+	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
+)
+
+// ErrNilReader indicates that an operation was attempted on a nil bson.Reader.
+var ErrNilReader = errors.New("nil reader")
+
+// Raw is a raw encoded BSON document. It can be used to delay BSON document decoding or precompute
+// a BSON encoded document.
+//
+// A Raw must be a full BSON document. Use the RawValue type for individual BSON values.
+type Raw []byte
+
+// ReadDocument reads a BSON document from the io.Reader and returns it as a bson.Raw. If the
+// reader contains multiple BSON documents, only the first document is read.
+func ReadDocument(r io.Reader) (Raw, error) {
+	doc, err := bsoncore.NewDocumentFromReader(r)
+	return Raw(doc), err
+}
+
+// Validate validates the document. This method only validates the first document in
+// the slice, to validate other documents, the slice must be resliced.
+func (r Raw) Validate() (err error) { return bsoncore.Document(r).Validate() }
+
+// Lookup search the document, potentially recursively, for the given key. If
+// there are multiple keys provided, this method will recurse down, as long as
+// the top and intermediate nodes are either documents or arrays.If an error
+// occurs or if the value doesn't exist, an empty RawValue is returned.
+func (r Raw) Lookup(key ...string) RawValue {
+	return convertFromCoreValue(bsoncore.Document(r).Lookup(key...))
+}
+
+// LookupErr searches the document and potentially subdocuments or arrays for the
+// provided key. Each key provided to this method represents a layer of depth.
+func (r Raw) LookupErr(key ...string) (RawValue, error) {
+	val, err := bsoncore.Document(r).LookupErr(key...)
+	return convertFromCoreValue(val), err
+}
+
+// Elements returns this document as a slice of elements. The returned slice will contain valid
+// elements. If the document is not valid, the elements up to the invalid point will be returned
+// along with an error.
+func (r Raw) Elements() ([]RawElement, error) {
+	doc := bsoncore.Document(r)
+	if len(doc) == 0 {
+		return nil, nil
+	}
+	elems, err := doc.Elements()
+	if err != nil {
+		return nil, err
+	}
+	relems := make([]RawElement, 0, len(elems))
+	for _, elem := range elems {
+		relems = append(relems, RawElement(elem))
+	}
+	return relems, nil
+}
+
+// Values returns this document as a slice of values. The returned slice will contain valid values.
+// If the document is not valid, the values up to the invalid point will be returned along with an
+// error.
+func (r Raw) Values() ([]RawValue, error) {
+	vals, err := bsoncore.Document(r).Values()
+	rvals := make([]RawValue, 0, len(vals))
+	for _, val := range vals {
+		rvals = append(rvals, convertFromCoreValue(val))
+	}
+	return rvals, err
+}
+
+// Index searches for and retrieves the element at the given index. This method will panic if
+// the document is invalid or if the index is out of bounds.
+func (r Raw) Index(index uint) RawElement { return RawElement(bsoncore.Document(r).Index(index)) }
+
+// IndexErr searches for and retrieves the element at the given index.
+func (r Raw) IndexErr(index uint) (RawElement, error) {
+	elem, err := bsoncore.Document(r).IndexErr(index)
+	return RawElement(elem), err
+}
+
+// String returns the BSON document encoded as Extended JSON.
+func (r Raw) String() string { return bsoncore.Document(r).String() }
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_array.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_array.go
new file mode 100644
index 00000000..1d2e9be7
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_array.go
@@ -0,0 +1,73 @@
+// Copyright (C) MongoDB, Inc. 2024-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"io"
+
+	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
+)
+
+// RawArray is a raw bytes representation of a BSON array.
+type RawArray []byte
+
+// ReadArray reads a BSON array from the io.Reader and returns it as a
+// bson.RawArray.
+func ReadArray(r io.Reader) (RawArray, error) {
+	doc, err := bsoncore.NewArrayFromReader(r)
+
+	return RawArray(doc), err
+}
+
+// Index searches for and retrieves the value at the given index. This method
+// will panic if the array is invalid or if the index is out of bounds.
+func (a RawArray) Index(index uint) RawValue {
+	return convertFromCoreValue(bsoncore.Array(a).Index(index))
+}
+
+// IndexErr searches for and retrieves the value at the given index.
+func (a RawArray) IndexErr(index uint) (RawValue, error) {
+	elem, err := bsoncore.Array(a).IndexErr(index)
+
+	return convertFromCoreValue(elem), err
+}
+
+// DebugString outputs a human readable version of Array. It will attempt to
+// stringify the valid components of the array even if the entire array is not
+// valid.
+func (a RawArray) DebugString() string {
+	return bsoncore.Array(a).DebugString()
+}
+
+// String outputs an ExtendedJSON version of Array. If the Array is not valid,
+// this method returns an empty string.
+func (a RawArray) String() string {
+	return bsoncore.Array(a).String()
+}
+
+// Values returns this array as a slice of values. The returned slice will
+// contain valid values. If the array is not valid, the values up to the invalid
+// point will be returned along with an error.
+func (a RawArray) Values() ([]RawValue, error) {
+	vals, err := bsoncore.Array(a).Values()
+	if err != nil {
+		return nil, err
+	}
+
+	rvals := make([]RawValue, 0, len(vals))
+	for _, val := range vals {
+		rvals = append(rvals, convertFromCoreValue(val))
+	}
+
+	return rvals, err
+}
+
+// Validate validates the array and ensures the elements contained within are
+// valid.
+func (a RawArray) Validate() error {
+	return bsoncore.Array(a).Validate()
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_element.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_element.go
new file mode 100644
index 00000000..75a00350
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_element.go
@@ -0,0 +1,48 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
+)
+
+// RawElement is a raw encoded BSON document or array element.
+type RawElement []byte
+
+// Key returns the key for this element. If the element is not valid, this method returns an empty
+// string. If knowing if the element is valid is important, use KeyErr.
+func (re RawElement) Key() string { return bsoncore.Element(re).Key() }
+
+// KeyErr returns the key for this element, returning an error if the element is not valid.
+func (re RawElement) KeyErr() (string, error) { return bsoncore.Element(re).KeyErr() }
+
+// Value returns the value of this element. If the element is not valid, this method returns an
+// empty Value. If knowing if the element is valid is important, use ValueErr.
+func (re RawElement) Value() RawValue { return convertFromCoreValue(bsoncore.Element(re).Value()) }
+
+// ValueErr returns the value for this element, returning an error if the element is not valid.
+func (re RawElement) ValueErr() (RawValue, error) {
+	val, err := bsoncore.Element(re).ValueErr()
+	return convertFromCoreValue(val), err
+}
+
+// Validate ensures re is a valid BSON element.
+func (re RawElement) Validate() error { return bsoncore.Element(re).Validate() }
+
+// String returns the BSON element encoded as Extended JSON.
+func (re RawElement) String() string {
+	doc := bsoncore.BuildDocument(nil, re)
+	j, err := MarshalExtJSON(Raw(doc), true, false)
+	if err != nil {
+		return "<malformed>"
+	}
+	return string(j)
+}
+
+// DebugString outputs a human readable version of RawElement. It will attempt to stringify the
+// valid components of the element even if the entire element is not valid.
+func (re RawElement) DebugString() string { return bsoncore.Element(re).DebugString() }
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_value.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_value.go
new file mode 100644
index 00000000..53f053f0
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_value.go
@@ -0,0 +1,306 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"reflect"
+	"time"
+
+	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
+)
+
+// ErrNilContext is returned when the provided DecodeContext is nil.
+var ErrNilContext = errors.New("DecodeContext cannot be nil")
+
+// ErrNilRegistry is returned when the provided registry is nil.
+var ErrNilRegistry = errors.New("Registry cannot be nil")
+
+// RawValue is a raw encoded BSON value. It can be used to delay BSON value decoding or precompute
+// BSON encoded value. Type is the BSON type of the value and Value is the raw encoded BSON value.
+//
+// A RawValue must be an individual BSON value. Use the Raw type for full BSON documents.
+type RawValue struct {
+	Type  Type
+	Value []byte
+
+	r *Registry
+}
+
+// IsZero reports whether the RawValue is zero, i.e. no data is present on
+// the RawValue. It returns true if Type is 0 and Value is empty or nil.
+func (rv RawValue) IsZero() bool {
+	return rv.Type == 0x00 && len(rv.Value) == 0
+}
+
+// Unmarshal deserializes BSON into the provided val. If RawValue cannot be unmarshaled into val, an
+// error is returned. This method will use the registry used to create the RawValue, if the RawValue
+// was created from partial BSON processing, or it will use the default registry. Users wishing to
+// specify the registry to use should use UnmarshalWithRegistry.
+func (rv RawValue) Unmarshal(val interface{}) error {
+	reg := rv.r
+	if reg == nil {
+		reg = defaultRegistry
+	}
+	return rv.UnmarshalWithRegistry(reg, val)
+}
+
+// Equal compares rv and rv2 and returns true if they are equal.
+func (rv RawValue) Equal(rv2 RawValue) bool {
+	if rv.Type != rv2.Type {
+		return false
+	}
+
+	if !bytes.Equal(rv.Value, rv2.Value) {
+		return false
+	}
+
+	return true
+}
+
+// UnmarshalWithRegistry performs the same unmarshalling as Unmarshal but uses the provided registry
+// instead of the one attached or the default registry.
+func (rv RawValue) UnmarshalWithRegistry(r *Registry, val interface{}) error {
+	if r == nil {
+		return ErrNilRegistry
+	}
+
+	vr := newValueReader(rv.Type, bytes.NewReader(rv.Value))
+	rval := reflect.ValueOf(val)
+	if rval.Kind() != reflect.Ptr {
+		return fmt.Errorf("argument to Unmarshal* must be a pointer to a type, but got %v", rval)
+	}
+	rval = rval.Elem()
+	dec, err := r.LookupDecoder(rval.Type())
+	if err != nil {
+		return err
+	}
+	return dec.DecodeValue(DecodeContext{Registry: r}, vr, rval)
+}
+
+// UnmarshalWithContext performs the same unmarshalling as Unmarshal but uses the provided DecodeContext
+// instead of the one attached or the default registry.
+func (rv RawValue) UnmarshalWithContext(dc *DecodeContext, val interface{}) error {
+	if dc == nil {
+		return ErrNilContext
+	}
+
+	vr := newValueReader(rv.Type, bytes.NewReader(rv.Value))
+	rval := reflect.ValueOf(val)
+	if rval.Kind() != reflect.Ptr {
+		return fmt.Errorf("argument to Unmarshal* must be a pointer to a type, but got %v", rval)
+	}
+	rval = rval.Elem()
+	dec, err := dc.LookupDecoder(rval.Type())
+	if err != nil {
+		return err
+	}
+	return dec.DecodeValue(*dc, vr, rval)
+}
+
+func convertFromCoreValue(v bsoncore.Value) RawValue {
+	return RawValue{Type: Type(v.Type), Value: v.Data}
+}
+func convertToCoreValue(v RawValue) bsoncore.Value {
+	return bsoncore.Value{Type: bsoncore.Type(v.Type), Data: v.Value}
+}
+
+// Validate ensures the value is a valid BSON value.
+func (rv RawValue) Validate() error { return convertToCoreValue(rv).Validate() }
+
+// IsNumber returns true if the type of v is a numeric BSON type.
+func (rv RawValue) IsNumber() bool { return convertToCoreValue(rv).IsNumber() }
+
+// String implements the fmt.String interface. This method will return values in extended JSON
+// format. If the value is not valid, this returns an empty string
+func (rv RawValue) String() string { return convertToCoreValue(rv).String() }
+
+// DebugString outputs a human readable version of Document. It will attempt to stringify the
+// valid components of the document even if the entire document is not valid.
+func (rv RawValue) DebugString() string { return convertToCoreValue(rv).DebugString() }
+
+// Double returns the float64 value for this element.
+// It panics if e's BSON type is not bson.TypeDouble.
+func (rv RawValue) Double() float64 { return convertToCoreValue(rv).Double() }
+
+// DoubleOK is the same as Double, but returns a boolean instead of panicking.
+func (rv RawValue) DoubleOK() (float64, bool) { return convertToCoreValue(rv).DoubleOK() }
+
+// StringValue returns the string value for this element.
+// It panics if e's BSON type is not bson.TypeString.
+//
+// NOTE: This method is called StringValue to avoid a collision with the String method which
+// implements the fmt.Stringer interface.
+func (rv RawValue) StringValue() string { return convertToCoreValue(rv).StringValue() }
+
+// StringValueOK is the same as StringValue, but returns a boolean instead of
+// panicking.
+func (rv RawValue) StringValueOK() (string, bool) { return convertToCoreValue(rv).StringValueOK() }
+
+// Document returns the BSON document the Value represents as a Document. It panics if the
+// value is a BSON type other than document.
+func (rv RawValue) Document() Raw { return Raw(convertToCoreValue(rv).Document()) }
+
+// DocumentOK is the same as Document, except it returns a boolean
+// instead of panicking.
+func (rv RawValue) DocumentOK() (Raw, bool) {
+	doc, ok := convertToCoreValue(rv).DocumentOK()
+	return Raw(doc), ok
+}
+
+// Array returns the BSON array the Value represents as an Array. It panics if the
+// value is a BSON type other than array.
+func (rv RawValue) Array() RawArray { return RawArray(convertToCoreValue(rv).Array()) }
+
+// ArrayOK is the same as Array, except it returns a boolean instead
+// of panicking.
+func (rv RawValue) ArrayOK() (RawArray, bool) {
+	doc, ok := convertToCoreValue(rv).ArrayOK()
+
+	return RawArray(doc), ok
+}
+
+// Binary returns the BSON binary value the Value represents. It panics if the value is a BSON type
+// other than binary.
+func (rv RawValue) Binary() (subtype byte, data []byte) { return convertToCoreValue(rv).Binary() }
+
+// BinaryOK is the same as Binary, except it returns a boolean instead of
+// panicking.
+func (rv RawValue) BinaryOK() (subtype byte, data []byte, ok bool) {
+	return convertToCoreValue(rv).BinaryOK()
+}
+
+// ObjectID returns the BSON objectid value the Value represents. It panics if the value is a BSON
+// type other than objectid.
+func (rv RawValue) ObjectID() ObjectID { return convertToCoreValue(rv).ObjectID() }
+
+// ObjectIDOK is the same as ObjectID, except it returns a boolean instead of
+// panicking.
+func (rv RawValue) ObjectIDOK() (ObjectID, bool) {
+	return convertToCoreValue(rv).ObjectIDOK()
+}
+
+// Boolean returns the boolean value the Value represents. It panics if the
+// value is a BSON type other than boolean.
+func (rv RawValue) Boolean() bool { return convertToCoreValue(rv).Boolean() }
+
+// BooleanOK is the same as Boolean, except it returns a boolean instead of
+// panicking.
+func (rv RawValue) BooleanOK() (bool, bool) { return convertToCoreValue(rv).BooleanOK() }
+
+// DateTime returns the BSON datetime value the Value represents as a
+// unix timestamp. It panics if the value is a BSON type other than datetime.
+func (rv RawValue) DateTime() int64 { return convertToCoreValue(rv).DateTime() }
+
+// DateTimeOK is the same as DateTime, except it returns a boolean instead of
+// panicking.
+func (rv RawValue) DateTimeOK() (int64, bool) { return convertToCoreValue(rv).DateTimeOK() }
+
+// Time returns the BSON datetime value the Value represents. It panics if the value is a BSON
+// type other than datetime.
+func (rv RawValue) Time() time.Time { return convertToCoreValue(rv).Time() }
+
+// TimeOK is the same as Time, except it returns a boolean instead of
+// panicking.
+func (rv RawValue) TimeOK() (time.Time, bool) { return convertToCoreValue(rv).TimeOK() }
+
+// Regex returns the BSON regex value the Value represents. It panics if the value is a BSON
+// type other than regex.
+func (rv RawValue) Regex() (pattern, options string) { return convertToCoreValue(rv).Regex() }
+
+// RegexOK is the same as Regex, except it returns a boolean instead of
+// panicking.
+func (rv RawValue) RegexOK() (pattern, options string, ok bool) {
+	return convertToCoreValue(rv).RegexOK()
+}
+
+// DBPointer returns the BSON dbpointer value the Value represents. It panics if the value is a BSON
+// type other than DBPointer.
+func (rv RawValue) DBPointer() (string, ObjectID) {
+	return convertToCoreValue(rv).DBPointer()
+}
+
+// DBPointerOK is the same as DBPoitner, except that it returns a boolean
+// instead of panicking.
+func (rv RawValue) DBPointerOK() (string, ObjectID, bool) {
+	return convertToCoreValue(rv).DBPointerOK()
+}
+
+// JavaScript returns the BSON JavaScript code value the Value represents. It panics if the value is
+// a BSON type other than JavaScript code.
+func (rv RawValue) JavaScript() string { return convertToCoreValue(rv).JavaScript() }
+
+// JavaScriptOK is the same as Javascript, excepti that it returns a boolean
+// instead of panicking.
+func (rv RawValue) JavaScriptOK() (string, bool) { return convertToCoreValue(rv).JavaScriptOK() }
+
+// Symbol returns the BSON symbol value the Value represents. It panics if the value is a BSON
+// type other than symbol.
+func (rv RawValue) Symbol() string { return convertToCoreValue(rv).Symbol() }
+
+// SymbolOK is the same as Symbol, excepti that it returns a boolean
+// instead of panicking.
+func (rv RawValue) SymbolOK() (string, bool) { return convertToCoreValue(rv).SymbolOK() }
+
+// CodeWithScope returns the BSON JavaScript code with scope the Value represents.
+// It panics if the value is a BSON type other than JavaScript code with scope.
+func (rv RawValue) CodeWithScope() (string, Raw) {
+	code, scope := convertToCoreValue(rv).CodeWithScope()
+	return code, Raw(scope)
+}
+
+// CodeWithScopeOK is the same as CodeWithScope, except that it returns a boolean instead of
+// panicking.
+func (rv RawValue) CodeWithScopeOK() (string, Raw, bool) {
+	code, scope, ok := convertToCoreValue(rv).CodeWithScopeOK()
+	return code, Raw(scope), ok
+}
+
+// Int32 returns the int32 the Value represents. It panics if the value is a BSON type other than
+// int32.
+func (rv RawValue) Int32() int32 { return convertToCoreValue(rv).Int32() }
+
+// Int32OK is the same as Int32, except that it returns a boolean instead of
+// panicking.
+func (rv RawValue) Int32OK() (int32, bool) { return convertToCoreValue(rv).Int32OK() }
+
+// Timestamp returns the BSON timestamp value the Value represents. It panics if the value is a
+// BSON type other than timestamp.
+func (rv RawValue) Timestamp() (t, i uint32) { return convertToCoreValue(rv).Timestamp() }
+
+// TimestampOK is the same as Timestamp, except that it returns a boolean
+// instead of panicking.
+func (rv RawValue) TimestampOK() (t, i uint32, ok bool) { return convertToCoreValue(rv).TimestampOK() }
+
+// Int64 returns the int64 the Value represents. It panics if the value is a BSON type other than
+// int64.
+func (rv RawValue) Int64() int64 { return convertToCoreValue(rv).Int64() }
+
+// Int64OK is the same as Int64, except that it returns a boolean instead of
+// panicking.
+func (rv RawValue) Int64OK() (int64, bool) { return convertToCoreValue(rv).Int64OK() }
+
+// AsInt64 returns a BSON number as an int64. If the BSON type is not a numeric one, this method
+// will panic.
+func (rv RawValue) AsInt64() int64 { return convertToCoreValue(rv).AsInt64() }
+
+// AsInt64OK is the same as AsInt64, except that it returns a boolean instead of
+// panicking.
+func (rv RawValue) AsInt64OK() (int64, bool) { return convertToCoreValue(rv).AsInt64OK() }
+
+// Decimal128 returns the decimal the Value represents. It panics if the value is a BSON type other than
+// decimal.
+func (rv RawValue) Decimal128() Decimal128 { return NewDecimal128(convertToCoreValue(rv).Decimal128()) }
+
+// Decimal128OK is the same as Decimal128, except that it returns a boolean
+// instead of panicking.
+func (rv RawValue) Decimal128OK() (Decimal128, bool) {
+	h, l, ok := convertToCoreValue(rv).Decimal128OK()
+	return NewDecimal128(h, l), ok
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/reader.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/reader.go
new file mode 100644
index 00000000..955d2e9f
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/reader.go
@@ -0,0 +1,49 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+// ArrayReader is implemented by types that allow reading values from a BSON
+// array.
+type ArrayReader interface {
+	ReadValue() (ValueReader, error)
+}
+
+// DocumentReader is implemented by types that allow reading elements from a
+// BSON document.
+type DocumentReader interface {
+	ReadElement() (string, ValueReader, error)
+}
+
+// ValueReader is a generic interface used to read values from BSON. This type
+// is implemented by several types with different underlying representations of
+// BSON, such as a bson.Document, raw BSON bytes, or extended JSON.
+type ValueReader interface {
+	Type() Type
+	Skip() error
+
+	ReadArray() (ArrayReader, error)
+	ReadBinary() (b []byte, btype byte, err error)
+	ReadBoolean() (bool, error)
+	ReadDocument() (DocumentReader, error)
+	ReadCodeWithScope() (code string, dr DocumentReader, err error)
+	ReadDBPointer() (ns string, oid ObjectID, err error)
+	ReadDateTime() (int64, error)
+	ReadDecimal128() (Decimal128, error)
+	ReadDouble() (float64, error)
+	ReadInt32() (int32, error)
+	ReadInt64() (int64, error)
+	ReadJavascript() (code string, err error)
+	ReadMaxKey() error
+	ReadMinKey() error
+	ReadNull() error
+	ReadObjectID() (ObjectID, error)
+	ReadRegex() (pattern, options string, err error)
+	ReadString() (string, error)
+	ReadSymbol() (symbol string, err error)
+	ReadTimestamp() (t, i uint32, err error)
+	ReadUndefined() error
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/registry.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/registry.go
new file mode 100644
index 00000000..d8f65ddc
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/registry.go
@@ -0,0 +1,381 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"sync"
+)
+
+// defaultRegistry is the default Registry. It contains the default codecs and the
+// primitive codecs.
+var defaultRegistry = NewRegistry()
+
+// errNoEncoder is returned when there wasn't an encoder available for a type.
+type errNoEncoder struct {
+	Type reflect.Type
+}
+
+func (ene errNoEncoder) Error() string {
+	if ene.Type == nil {
+		return "no encoder found for <nil>"
+	}
+	return "no encoder found for " + ene.Type.String()
+}
+
+// errNoDecoder is returned when there wasn't a decoder available for a type.
+type errNoDecoder struct {
+	Type reflect.Type
+}
+
+func (end errNoDecoder) Error() string {
+	return "no decoder found for " + end.Type.String()
+}
+
+// errNoTypeMapEntry is returned when there wasn't a type available for the provided BSON type.
+type errNoTypeMapEntry struct {
+	Type Type
+}
+
+func (entme errNoTypeMapEntry) Error() string {
+	return "no type map entry found for " + entme.Type.String()
+}
+
+// A Registry is a store for ValueEncoders, ValueDecoders, and a type map. See the Registry type
+// documentation for examples of registering various custom encoders and decoders. A Registry can
+// have four main types of codecs:
+//
+// 1. Type encoders/decoders - These can be registered using the RegisterTypeEncoder and
+// RegisterTypeDecoder methods. The registered codec will be invoked when encoding/decoding a value
+// whose type matches the registered type exactly.
+// If the registered type is an interface, the codec will be invoked when encoding or decoding
+// values whose type is the interface, but not for values with concrete types that implement the
+// interface.
+//
+// 2. Interface encoders/decoders - These can be registered using the RegisterInterfaceEncoder and
+// RegisterInterfaceDecoder methods. These methods only accept interface types and the registered codecs
+// will be invoked when encoding or decoding values whose types implement the interface. An example
+// of an interface defined by the driver is bson.Marshaler. The driver will call the MarshalBSON method
+// for any value whose type implements bson.Marshaler, regardless of the value's concrete type.
+//
+// 3. Type map entries - This can be used to associate a BSON type with a Go type. These type
+// associations are used when decoding into a bson.D/bson.M or a struct field of type interface{}.
+// For example, by default, BSON int32 and int64 values decode as Go int32 and int64 instances,
+// respectively, when decoding into a bson.D. The following code would change the behavior so these
+// values decode as Go int instances instead:
+//
+//	intType := reflect.TypeOf(int(0))
+//	registry.RegisterTypeMapEntry(bson.TypeInt32, intType).RegisterTypeMapEntry(bson.TypeInt64, intType)
+//
+// 4. Kind encoder/decoders - These can be registered using the RegisterDefaultEncoder and
+// RegisterDefaultDecoder methods. The registered codec will be invoked when encoding or decoding
+// values whose reflect.Kind matches the registered reflect.Kind as long as the value's type doesn't
+// match a registered type or interface encoder/decoder first. These methods should be used to change the
+// behavior for all values for a specific kind.
+//
+// Read [Registry.LookupDecoder] and [Registry.LookupEncoder] for Registry lookup procedure.
+type Registry struct {
+	interfaceEncoders []interfaceValueEncoder
+	interfaceDecoders []interfaceValueDecoder
+	typeEncoders      *typeEncoderCache
+	typeDecoders      *typeDecoderCache
+	kindEncoders      *kindEncoderCache
+	kindDecoders      *kindDecoderCache
+	typeMap           sync.Map // map[Type]reflect.Type
+}
+
+// NewRegistry creates a new empty Registry.
+func NewRegistry() *Registry {
+	reg := &Registry{
+		typeEncoders: new(typeEncoderCache),
+		typeDecoders: new(typeDecoderCache),
+		kindEncoders: new(kindEncoderCache),
+		kindDecoders: new(kindDecoderCache),
+	}
+	registerDefaultEncoders(reg)
+	registerDefaultDecoders(reg)
+	registerPrimitiveCodecs(reg)
+	return reg
+}
+
+// RegisterTypeEncoder registers the provided ValueEncoder for the provided type.
+//
+// The type will be used as provided, so an encoder can be registered for a type and a different
+// encoder can be registered for a pointer to that type.
+//
+// If the given type is an interface, the encoder will be called when marshaling a type that is
+// that interface. It will not be called when marshaling a non-interface type that implements the
+// interface. To get the latter behavior, call RegisterHookEncoder instead.
+//
+// RegisterTypeEncoder should not be called concurrently with any other Registry method.
+func (r *Registry) RegisterTypeEncoder(valueType reflect.Type, enc ValueEncoder) {
+	r.typeEncoders.Store(valueType, enc)
+}
+
+// RegisterTypeDecoder registers the provided ValueDecoder for the provided type.
+//
+// The type will be used as provided, so a decoder can be registered for a type and a different
+// decoder can be registered for a pointer to that type.
+//
+// If the given type is an interface, the decoder will be called when unmarshaling into a type that
+// is that interface. It will not be called when unmarshaling into a non-interface type that
+// implements the interface. To get the latter behavior, call RegisterHookDecoder instead.
+//
+// RegisterTypeDecoder should not be called concurrently with any other Registry method.
+func (r *Registry) RegisterTypeDecoder(valueType reflect.Type, dec ValueDecoder) {
+	r.typeDecoders.Store(valueType, dec)
+}
+
+// RegisterKindEncoder registers the provided ValueEncoder for the provided kind.
+//
+// Use RegisterKindEncoder to register an encoder for any type with the same underlying kind. For
+// example, consider the type MyInt defined as
+//
+//	type MyInt int32
+//
+// To define an encoder for MyInt and int32, use RegisterKindEncoder like
+//
+//	reg.RegisterKindEncoder(reflect.Int32, myEncoder)
+//
+// RegisterKindEncoder should not be called concurrently with any other Registry method.
+func (r *Registry) RegisterKindEncoder(kind reflect.Kind, enc ValueEncoder) {
+	r.kindEncoders.Store(kind, enc)
+}
+
+// RegisterKindDecoder registers the provided ValueDecoder for the provided kind.
+//
+// Use RegisterKindDecoder to register a decoder for any type with the same underlying kind. For
+// example, consider the type MyInt defined as
+//
+//	type MyInt int32
+//
+// To define an decoder for MyInt and int32, use RegisterKindDecoder like
+//
+//	reg.RegisterKindDecoder(reflect.Int32, myDecoder)
+//
+// RegisterKindDecoder should not be called concurrently with any other Registry method.
+func (r *Registry) RegisterKindDecoder(kind reflect.Kind, dec ValueDecoder) {
+	r.kindDecoders.Store(kind, dec)
+}
+
+// RegisterInterfaceEncoder registers an encoder for the provided interface type iface. This encoder will
+// be called when marshaling a type if the type implements iface or a pointer to the type
+// implements iface. If the provided type is not an interface
+// (i.e. iface.Kind() != reflect.Interface), this method will panic.
+//
+// RegisterInterfaceEncoder should not be called concurrently with any other Registry method.
+func (r *Registry) RegisterInterfaceEncoder(iface reflect.Type, enc ValueEncoder) {
+	if iface.Kind() != reflect.Interface {
+		panicStr := fmt.Errorf("RegisterInterfaceEncoder expects a type with kind reflect.Interface, "+
+			"got type %s with kind %s", iface, iface.Kind())
+		panic(panicStr)
+	}
+
+	for idx, encoder := range r.interfaceEncoders {
+		if encoder.i == iface {
+			r.interfaceEncoders[idx].ve = enc
+			return
+		}
+	}
+
+	r.interfaceEncoders = append(r.interfaceEncoders, interfaceValueEncoder{i: iface, ve: enc})
+}
+
+// RegisterInterfaceDecoder registers an decoder for the provided interface type iface. This decoder will
+// be called when unmarshaling into a type if the type implements iface or a pointer to the type
+// implements iface. If the provided type is not an interface (i.e. iface.Kind() != reflect.Interface),
+// this method will panic.
+//
+// RegisterInterfaceDecoder should not be called concurrently with any other Registry method.
+func (r *Registry) RegisterInterfaceDecoder(iface reflect.Type, dec ValueDecoder) {
+	if iface.Kind() != reflect.Interface {
+		panicStr := fmt.Errorf("RegisterInterfaceDecoder expects a type with kind reflect.Interface, "+
+			"got type %s with kind %s", iface, iface.Kind())
+		panic(panicStr)
+	}
+
+	for idx, decoder := range r.interfaceDecoders {
+		if decoder.i == iface {
+			r.interfaceDecoders[idx].vd = dec
+			return
+		}
+	}
+
+	r.interfaceDecoders = append(r.interfaceDecoders, interfaceValueDecoder{i: iface, vd: dec})
+}
+
+// RegisterTypeMapEntry will register the provided type to the BSON type. The primary usage for this
+// mapping is decoding situations where an empty interface is used and a default type needs to be
+// created and decoded into.
+//
+// By default, BSON documents will decode into interface{} values as bson.D. To change the default type for BSON
+// documents, a type map entry for TypeEmbeddedDocument should be registered. For example, to force BSON documents
+// to decode to bson.Raw, use the following code:
+//
+//	reg.RegisterTypeMapEntry(TypeEmbeddedDocument, reflect.TypeOf(bson.Raw{}))
+func (r *Registry) RegisterTypeMapEntry(bt Type, rt reflect.Type) {
+	r.typeMap.Store(bt, rt)
+}
+
+// LookupEncoder returns the first matching encoder in the Registry. It uses the following lookup
+// order:
+//
+// 1. An encoder registered for the exact type. If the given type is an interface, an encoder
+// registered using RegisterTypeEncoder for that interface will be selected.
+//
+// 2. An encoder registered using RegisterInterfaceEncoder for an interface implemented by the type
+// or by a pointer to the type. If the value matches multiple interfaces (e.g. the type implements
+// bson.Marshaler and bson.ValueMarshaler), the first one registered will be selected.
+// Note that registries constructed using bson.NewRegistry have driver-defined interfaces registered
+// for the bson.Marshaler, bson.ValueMarshaler, and bson.Proxy interfaces, so those will take
+// precedence over any new interfaces.
+//
+// 3. An encoder registered using RegisterKindEncoder for the kind of value.
+//
+// If no encoder is found, an error of type ErrNoEncoder is returned. LookupEncoder is safe for
+// concurrent use by multiple goroutines after all codecs and encoders are registered.
+func (r *Registry) LookupEncoder(valueType reflect.Type) (ValueEncoder, error) {
+	if valueType == nil {
+		return nil, errNoEncoder{Type: valueType}
+	}
+	enc, found := r.lookupTypeEncoder(valueType)
+	if found {
+		if enc == nil {
+			return nil, errNoEncoder{Type: valueType}
+		}
+		return enc, nil
+	}
+
+	enc, found = r.lookupInterfaceEncoder(valueType, true)
+	if found {
+		return r.typeEncoders.LoadOrStore(valueType, enc), nil
+	}
+
+	if v, ok := r.kindEncoders.Load(valueType.Kind()); ok {
+		return r.storeTypeEncoder(valueType, v), nil
+	}
+	return nil, errNoEncoder{Type: valueType}
+}
+
+func (r *Registry) storeTypeEncoder(rt reflect.Type, enc ValueEncoder) ValueEncoder {
+	return r.typeEncoders.LoadOrStore(rt, enc)
+}
+
+func (r *Registry) lookupTypeEncoder(rt reflect.Type) (ValueEncoder, bool) {
+	return r.typeEncoders.Load(rt)
+}
+
+func (r *Registry) lookupInterfaceEncoder(valueType reflect.Type, allowAddr bool) (ValueEncoder, bool) {
+	if valueType == nil {
+		return nil, false
+	}
+	for _, ienc := range r.interfaceEncoders {
+		if valueType.Implements(ienc.i) {
+			return ienc.ve, true
+		}
+		if allowAddr && valueType.Kind() != reflect.Ptr && reflect.PtrTo(valueType).Implements(ienc.i) {
+			// if *t implements an interface, this will catch if t implements an interface further
+			// ahead in interfaceEncoders
+			defaultEnc, found := r.lookupInterfaceEncoder(valueType, false)
+			if !found {
+				defaultEnc, _ = r.kindEncoders.Load(valueType.Kind())
+			}
+			return newCondAddrEncoder(ienc.ve, defaultEnc), true
+		}
+	}
+	return nil, false
+}
+
+// LookupDecoder returns the first matching decoder in the Registry. It uses the following lookup
+// order:
+//
+// 1. A decoder registered for the exact type. If the given type is an interface, a decoder
+// registered using RegisterTypeDecoder for that interface will be selected.
+//
+// 2. A decoder registered using RegisterInterfaceDecoder for an interface implemented by the type or by
+// a pointer to the type. If the value matches multiple interfaces (e.g. the type implements
+// bson.Unmarshaler and bson.ValueUnmarshaler), the first one registered will be selected.
+// Note that registries constructed using bson.NewRegistry have driver-defined interfaces registered
+// for the bson.Unmarshaler and bson.ValueUnmarshaler interfaces, so those will take
+// precedence over any new interfaces.
+//
+// 3. A decoder registered using RegisterKindDecoder for the kind of value.
+//
+// If no decoder is found, an error of type ErrNoDecoder is returned. LookupDecoder is safe for
+// concurrent use by multiple goroutines after all codecs and decoders are registered.
+func (r *Registry) LookupDecoder(valueType reflect.Type) (ValueDecoder, error) {
+	if valueType == nil {
+		return nil, errors.New("cannot perform a decoder lookup on <nil>")
+	}
+	dec, found := r.lookupTypeDecoder(valueType)
+	if found {
+		if dec == nil {
+			return nil, errNoDecoder{Type: valueType}
+		}
+		return dec, nil
+	}
+
+	dec, found = r.lookupInterfaceDecoder(valueType, true)
+	if found {
+		return r.storeTypeDecoder(valueType, dec), nil
+	}
+
+	if v, ok := r.kindDecoders.Load(valueType.Kind()); ok {
+		return r.storeTypeDecoder(valueType, v), nil
+	}
+	return nil, errNoDecoder{Type: valueType}
+}
+
+func (r *Registry) lookupTypeDecoder(valueType reflect.Type) (ValueDecoder, bool) {
+	return r.typeDecoders.Load(valueType)
+}
+
+func (r *Registry) storeTypeDecoder(typ reflect.Type, dec ValueDecoder) ValueDecoder {
+	return r.typeDecoders.LoadOrStore(typ, dec)
+}
+
+func (r *Registry) lookupInterfaceDecoder(valueType reflect.Type, allowAddr bool) (ValueDecoder, bool) {
+	for _, idec := range r.interfaceDecoders {
+		if valueType.Implements(idec.i) {
+			return idec.vd, true
+		}
+		if allowAddr && valueType.Kind() != reflect.Ptr && reflect.PtrTo(valueType).Implements(idec.i) {
+			// if *t implements an interface, this will catch if t implements an interface further
+			// ahead in interfaceDecoders
+			defaultDec, found := r.lookupInterfaceDecoder(valueType, false)
+			if !found {
+				defaultDec, _ = r.kindDecoders.Load(valueType.Kind())
+			}
+			return newCondAddrDecoder(idec.vd, defaultDec), true
+		}
+	}
+	return nil, false
+}
+
+// LookupTypeMapEntry inspects the registry's type map for a Go type for the corresponding BSON
+// type. If no type is found, ErrNoTypeMapEntry is returned.
+//
+// LookupTypeMapEntry should not be called concurrently with any other Registry method.
+func (r *Registry) LookupTypeMapEntry(bt Type) (reflect.Type, error) {
+	v, ok := r.typeMap.Load(bt)
+	if v == nil || !ok {
+		return nil, errNoTypeMapEntry{Type: bt}
+	}
+	return v.(reflect.Type), nil
+}
+
+type interfaceValueEncoder struct {
+	i  reflect.Type
+	ve ValueEncoder
+}
+
+type interfaceValueDecoder struct {
+	i  reflect.Type
+	vd ValueDecoder
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/slice_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/slice_codec.go
new file mode 100644
index 00000000..c8719dcc
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/slice_codec.go
@@ -0,0 +1,173 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+// sliceCodec is the Codec used for slice values.
+type sliceCodec struct {
+	// encodeNilAsEmpty causes EncodeValue to marshal nil Go slices as empty BSON arrays instead of
+	// BSON null.
+	encodeNilAsEmpty bool
+}
+
+// EncodeValue is the ValueEncoder for slice types.
+func (sc *sliceCodec) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Kind() != reflect.Slice {
+		return ValueEncoderError{Name: "SliceEncodeValue", Kinds: []reflect.Kind{reflect.Slice}, Received: val}
+	}
+
+	if val.IsNil() && !sc.encodeNilAsEmpty && !ec.nilSliceAsEmpty {
+		return vw.WriteNull()
+	}
+
+	// If we have a []byte we want to treat it as a binary instead of as an array.
+	if val.Type().Elem() == tByte {
+		byteSlice := make([]byte, val.Len())
+		reflect.Copy(reflect.ValueOf(byteSlice), val)
+		return vw.WriteBinary(byteSlice)
+	}
+
+	// If we have a []E we want to treat it as a document instead of as an array.
+	if val.Type() == tD || val.Type().ConvertibleTo(tD) {
+		d := val.Convert(tD).Interface().(D)
+
+		dw, err := vw.WriteDocument()
+		if err != nil {
+			return err
+		}
+
+		for _, e := range d {
+			err = encodeElement(ec, dw, e)
+			if err != nil {
+				return err
+			}
+		}
+
+		return dw.WriteDocumentEnd()
+	}
+
+	aw, err := vw.WriteArray()
+	if err != nil {
+		return err
+	}
+
+	elemType := val.Type().Elem()
+	encoder, err := ec.LookupEncoder(elemType)
+	if err != nil && elemType.Kind() != reflect.Interface {
+		return err
+	}
+
+	for idx := 0; idx < val.Len(); idx++ {
+		currEncoder, currVal, lookupErr := lookupElementEncoder(ec, encoder, val.Index(idx))
+		if lookupErr != nil && !errors.Is(lookupErr, errInvalidValue) {
+			return lookupErr
+		}
+
+		vw, err := aw.WriteArrayElement()
+		if err != nil {
+			return err
+		}
+
+		if errors.Is(lookupErr, errInvalidValue) {
+			err = vw.WriteNull()
+			if err != nil {
+				return err
+			}
+			continue
+		}
+
+		err = currEncoder.EncodeValue(ec, vw, currVal)
+		if err != nil {
+			return err
+		}
+	}
+	return aw.WriteArrayEnd()
+}
+
+// DecodeValue is the ValueDecoder for slice types.
+func (sc *sliceCodec) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Kind() != reflect.Slice {
+		return ValueDecoderError{Name: "SliceDecodeValue", Kinds: []reflect.Kind{reflect.Slice}, Received: val}
+	}
+
+	switch vrType := vr.Type(); vrType {
+	case TypeArray:
+	case TypeNull:
+		val.Set(reflect.Zero(val.Type()))
+		return vr.ReadNull()
+	case TypeUndefined:
+		val.Set(reflect.Zero(val.Type()))
+		return vr.ReadUndefined()
+	case Type(0), TypeEmbeddedDocument:
+		if val.Type().Elem() != tE {
+			return fmt.Errorf("cannot decode document into %s", val.Type())
+		}
+	case TypeBinary:
+		if val.Type().Elem() != tByte {
+			return fmt.Errorf("SliceDecodeValue can only decode a binary into a byte array, got %v", vrType)
+		}
+		data, subtype, err := vr.ReadBinary()
+		if err != nil {
+			return err
+		}
+		if subtype != TypeBinaryGeneric && subtype != TypeBinaryBinaryOld {
+			return fmt.Errorf("SliceDecodeValue can only be used to decode subtype 0x00 or 0x02 for %s, got %v", TypeBinary, subtype)
+		}
+
+		if val.IsNil() {
+			val.Set(reflect.MakeSlice(val.Type(), 0, len(data)))
+		}
+		val.SetLen(0)
+		val.Set(reflect.AppendSlice(val, reflect.ValueOf(data)))
+		return nil
+	case TypeString:
+		if sliceType := val.Type().Elem(); sliceType != tByte {
+			return fmt.Errorf("SliceDecodeValue can only decode a string into a byte array, got %v", sliceType)
+		}
+		str, err := vr.ReadString()
+		if err != nil {
+			return err
+		}
+		byteStr := []byte(str)
+
+		if val.IsNil() {
+			val.Set(reflect.MakeSlice(val.Type(), 0, len(byteStr)))
+		}
+		val.SetLen(0)
+		val.Set(reflect.AppendSlice(val, reflect.ValueOf(byteStr)))
+		return nil
+	default:
+		return fmt.Errorf("cannot decode %v into a slice", vrType)
+	}
+
+	var elemsFunc func(DecodeContext, ValueReader, reflect.Value) ([]reflect.Value, error)
+	switch val.Type().Elem() {
+	case tE:
+		elemsFunc = decodeD
+	default:
+		elemsFunc = decodeDefault
+	}
+
+	elems, err := elemsFunc(dc, vr, val)
+	if err != nil {
+		return err
+	}
+
+	if val.IsNil() {
+		val.Set(reflect.MakeSlice(val.Type(), 0, len(elems)))
+	}
+
+	val.SetLen(0)
+	val.Set(reflect.Append(val, elems...))
+
+	return nil
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/string_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/string_codec.go
new file mode 100644
index 00000000..456028c1
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/string_codec.go
@@ -0,0 +1,107 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+// stringCodec is the Codec used for string values.
+type stringCodec struct{}
+
+// Assert that stringCodec satisfies the typeDecoder interface, which allows it to be
+// used by collection type decoders (e.g. map, slice, etc) to set individual values in a
+// collection.
+var _ typeDecoder = &stringCodec{}
+
+// EncodeValue is the ValueEncoder for string types.
+func (sc *stringCodec) EncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if val.Kind() != reflect.String {
+		return ValueEncoderError{
+			Name:     "StringEncodeValue",
+			Kinds:    []reflect.Kind{reflect.String},
+			Received: val,
+		}
+	}
+
+	return vw.WriteString(val.String())
+}
+
+func (sc *stringCodec) decodeType(dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t.Kind() != reflect.String {
+		return emptyValue, ValueDecoderError{
+			Name:     "StringDecodeValue",
+			Kinds:    []reflect.Kind{reflect.String},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	var str string
+	var err error
+	switch vr.Type() {
+	case TypeString:
+		str, err = vr.ReadString()
+		if err != nil {
+			return emptyValue, err
+		}
+	case TypeObjectID:
+		if dc.objectIDAsHexString {
+			oid, err := vr.ReadObjectID()
+			if err != nil {
+				return emptyValue, err
+			}
+			str = oid.Hex()
+		} else {
+			const msg = "decoding an object ID into a string is not supported by default " +
+				"(set Decoder.ObjectIDAsHexString to enable decoding as a hexadecimal string)"
+			return emptyValue, errors.New(msg)
+		}
+	case TypeSymbol:
+		str, err = vr.ReadSymbol()
+		if err != nil {
+			return emptyValue, err
+		}
+	case TypeBinary:
+		data, subtype, err := vr.ReadBinary()
+		if err != nil {
+			return emptyValue, err
+		}
+		if subtype != TypeBinaryGeneric && subtype != TypeBinaryBinaryOld {
+			return emptyValue, decodeBinaryError{subtype: subtype, typeName: "string"}
+		}
+		str = string(data)
+	case TypeNull:
+		if err = vr.ReadNull(); err != nil {
+			return emptyValue, err
+		}
+	case TypeUndefined:
+		if err = vr.ReadUndefined(); err != nil {
+			return emptyValue, err
+		}
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a string type", vr.Type())
+	}
+
+	return reflect.ValueOf(str), nil
+}
+
+// DecodeValue is the ValueDecoder for string types.
+func (sc *stringCodec) DecodeValue(dctx DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Kind() != reflect.String {
+		return ValueDecoderError{Name: "StringDecodeValue", Kinds: []reflect.Kind{reflect.String}, Received: val}
+	}
+
+	elem, err := sc.decodeType(dctx, vr, val.Type())
+	if err != nil {
+		return err
+	}
+
+	val.SetString(elem.String())
+	return nil
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/struct_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/struct_codec.go
new file mode 100644
index 00000000..83b63f5f
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/struct_codec.go
@@ -0,0 +1,695 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+)
+
+// DecodeError represents an error that occurs when unmarshalling BSON bytes into a native Go type.
+type DecodeError struct {
+	keys    []string
+	wrapped error
+}
+
+// Unwrap returns the underlying error
+func (de *DecodeError) Unwrap() error {
+	return de.wrapped
+}
+
+// Error implements the error interface.
+func (de *DecodeError) Error() string {
+	// The keys are stored in reverse order because the de.keys slice is builtup while propagating the error up the
+	// stack of BSON keys, so we call de.Keys(), which reverses them.
+	keyPath := strings.Join(de.Keys(), ".")
+	return fmt.Sprintf("error decoding key %s: %v", keyPath, de.wrapped)
+}
+
+// Keys returns the BSON key path that caused an error as a slice of strings. The keys in the slice are in top-down
+// order. For example, if the document being unmarshalled was {a: {b: {c: 1}}} and the value for c was supposed to be
+// a string, the keys slice will be ["a", "b", "c"].
+func (de *DecodeError) Keys() []string {
+	reversedKeys := make([]string, 0, len(de.keys))
+	for idx := len(de.keys) - 1; idx >= 0; idx-- {
+		reversedKeys = append(reversedKeys, de.keys[idx])
+	}
+
+	return reversedKeys
+}
+
+// mapElementsEncoder handles encoding of the values of an inline  map.
+type mapElementsEncoder interface {
+	encodeMapElements(EncodeContext, DocumentWriter, reflect.Value, func(string) bool) error
+}
+
+// structCodec is the Codec used for struct values.
+type structCodec struct {
+	cache            sync.Map // map[reflect.Type]*structDescription
+	inlineMapEncoder mapElementsEncoder
+
+	// decodeZeroStruct causes DecodeValue to delete any existing values from Go structs in the
+	// destination value passed to Decode before unmarshaling BSON documents into them.
+	decodeZeroStruct bool
+
+	// decodeDeepZeroInline causes DecodeValue to delete any existing values from Go structs in the
+	// destination value passed to Decode before unmarshaling BSON documents into them.
+	decodeDeepZeroInline bool
+
+	// encodeOmitDefaultStruct causes the Encoder to consider the zero value for a struct (e.g.
+	// MyStruct{}) as empty and omit it from the marshaled BSON when the "omitempty" struct tag
+	// option is set.
+	encodeOmitDefaultStruct bool
+
+	// allowUnexportedFields allows encoding and decoding values from un-exported struct fields.
+	allowUnexportedFields bool
+
+	// overwriteDuplicatedInlinedFields, if false, causes EncodeValue to return an error if there is
+	// a duplicate field in the marshaled BSON when the "inline" struct tag option is set. The
+	// default value is true.
+	overwriteDuplicatedInlinedFields bool
+}
+
+var (
+	_ ValueEncoder = &structCodec{}
+	_ ValueDecoder = &structCodec{}
+)
+
+// newStructCodec returns a StructCodec that uses p for struct tag parsing.
+func newStructCodec(elemEncoder mapElementsEncoder) *structCodec {
+	return &structCodec{
+		inlineMapEncoder:                 elemEncoder,
+		overwriteDuplicatedInlinedFields: true,
+	}
+}
+
+// EncodeValue handles encoding generic struct types.
+func (sc *structCodec) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Kind() != reflect.Struct {
+		return ValueEncoderError{Name: "StructCodec.EncodeValue", Kinds: []reflect.Kind{reflect.Struct}, Received: val}
+	}
+
+	sd, err := sc.describeStruct(ec.Registry, val.Type(), ec.useJSONStructTags, ec.errorOnInlineDuplicates)
+	if err != nil {
+		return err
+	}
+
+	dw, err := vw.WriteDocument()
+	if err != nil {
+		return err
+	}
+	var rv reflect.Value
+	for _, desc := range sd.fl {
+		if desc.inline == nil {
+			rv = val.Field(desc.idx)
+		} else {
+			rv, err = fieldByIndexErr(val, desc.inline)
+			if err != nil {
+				continue
+			}
+		}
+
+		if ec.omitEmpty {
+			desc.omitEmpty = true
+		}
+
+		desc.encoder, rv, err = lookupElementEncoder(ec, desc.encoder, rv)
+
+		if err != nil && !errors.Is(err, errInvalidValue) {
+			return err
+		}
+
+		if errors.Is(err, errInvalidValue) {
+			if desc.omitEmpty {
+				continue
+			}
+			vw2, err := dw.WriteDocumentElement(desc.name)
+			if err != nil {
+				return err
+			}
+			err = vw2.WriteNull()
+			if err != nil {
+				return err
+			}
+			continue
+		}
+
+		if desc.encoder == nil {
+			return errNoEncoder{Type: rv.Type()}
+		}
+
+		encoder := desc.encoder
+
+		var empty bool
+		if rv.Kind() == reflect.Interface {
+			// isEmpty will not treat an interface rv as an interface, so we need to check for the
+			// nil interface separately.
+			empty = rv.IsNil()
+		} else {
+			empty = isEmpty(rv, sc.encodeOmitDefaultStruct || ec.omitZeroStruct)
+		}
+		if desc.omitEmpty && empty {
+			continue
+		}
+
+		vw2, err := dw.WriteDocumentElement(desc.name)
+		if err != nil {
+			return err
+		}
+
+		ectx := EncodeContext{
+			Registry:                ec.Registry,
+			minSize:                 desc.minSize || ec.minSize,
+			errorOnInlineDuplicates: ec.errorOnInlineDuplicates,
+			stringifyMapKeysWithFmt: ec.stringifyMapKeysWithFmt,
+			nilMapAsEmpty:           ec.nilMapAsEmpty,
+			nilSliceAsEmpty:         ec.nilSliceAsEmpty,
+			nilByteSliceAsEmpty:     ec.nilByteSliceAsEmpty,
+			omitZeroStruct:          ec.omitZeroStruct,
+			useJSONStructTags:       ec.useJSONStructTags,
+		}
+		err = encoder.EncodeValue(ectx, vw2, rv)
+		if err != nil {
+			return err
+		}
+	}
+
+	if sd.inlineMap >= 0 {
+		rv := val.Field(sd.inlineMap)
+		collisionFn := func(key string) bool {
+			_, exists := sd.fm[key]
+			return exists
+		}
+
+		err = sc.inlineMapEncoder.encodeMapElements(ec, dw, rv, collisionFn)
+		if err != nil {
+			return err
+		}
+	}
+
+	return dw.WriteDocumentEnd()
+}
+
+func newDecodeError(key string, original error) error {
+	var de *DecodeError
+	if !errors.As(original, &de) {
+		return &DecodeError{
+			keys:    []string{key},
+			wrapped: original,
+		}
+	}
+
+	de.keys = append(de.keys, key)
+	return de
+}
+
+// DecodeValue implements the Codec interface.
+// By default, map types in val will not be cleared. If a map has existing key/value pairs, it will be extended with the new ones from vr.
+// For slices, the decoder will set the length of the slice to zero and append all elements. The underlying array will not be cleared.
+func (sc *structCodec) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Kind() != reflect.Struct {
+		return ValueDecoderError{Name: "StructCodec.DecodeValue", Kinds: []reflect.Kind{reflect.Struct}, Received: val}
+	}
+
+	switch vrType := vr.Type(); vrType {
+	case Type(0), TypeEmbeddedDocument:
+	case TypeNull:
+		if err := vr.ReadNull(); err != nil {
+			return err
+		}
+
+		val.Set(reflect.Zero(val.Type()))
+		return nil
+	case TypeUndefined:
+		if err := vr.ReadUndefined(); err != nil {
+			return err
+		}
+
+		val.Set(reflect.Zero(val.Type()))
+		return nil
+	default:
+		return fmt.Errorf("cannot decode %v into a %s", vrType, val.Type())
+	}
+
+	sd, err := sc.describeStruct(dc.Registry, val.Type(), dc.useJSONStructTags, false)
+	if err != nil {
+		return err
+	}
+
+	if sc.decodeZeroStruct || dc.zeroStructs {
+		val.Set(reflect.Zero(val.Type()))
+	}
+	if sc.decodeDeepZeroInline && sd.inline {
+		val.Set(deepZero(val.Type()))
+	}
+
+	var decoder ValueDecoder
+	var inlineMap reflect.Value
+	if sd.inlineMap >= 0 {
+		inlineMap = val.Field(sd.inlineMap)
+		decoder, err = dc.LookupDecoder(inlineMap.Type().Elem())
+		if err != nil {
+			return err
+		}
+	}
+
+	dr, err := vr.ReadDocument()
+	if err != nil {
+		return err
+	}
+
+	for {
+		name, vr, err := dr.ReadElement()
+		if errors.Is(err, ErrEOD) {
+			break
+		}
+		if err != nil {
+			return err
+		}
+
+		fd, exists := sd.fm[name]
+		if !exists {
+			// if the original name isn't found in the struct description, try again with the name in lowercase
+			// this could match if a BSON tag isn't specified because by default, describeStruct lowercases all field
+			// names
+			fd, exists = sd.fm[strings.ToLower(name)]
+		}
+
+		if !exists {
+			if sd.inlineMap < 0 {
+				// The encoding/json package requires a flag to return on error for non-existent fields.
+				// This functionality seems appropriate for the struct codec.
+				err = vr.Skip()
+				if err != nil {
+					return err
+				}
+				continue
+			}
+
+			if inlineMap.IsNil() {
+				inlineMap.Set(reflect.MakeMap(inlineMap.Type()))
+			}
+
+			elem := reflect.New(inlineMap.Type().Elem()).Elem()
+			err = decoder.DecodeValue(dc, vr, elem)
+			if err != nil {
+				return err
+			}
+			inlineMap.SetMapIndex(reflect.ValueOf(name), elem)
+			continue
+		}
+
+		var field reflect.Value
+		if fd.inline == nil {
+			field = val.Field(fd.idx)
+		} else {
+			field, err = getInlineField(val, fd.inline)
+			if err != nil {
+				return err
+			}
+		}
+
+		if field.Kind() == reflect.Interface && !field.IsNil() && field.Elem().Kind() == reflect.Ptr {
+			v := field.Elem().Elem()
+			decoder, err = dc.LookupDecoder(v.Type())
+			if err != nil {
+				return err
+			}
+			err = decoder.DecodeValue(dc, vr, v)
+			if err != nil {
+				return newDecodeError(fd.name, err)
+			}
+			continue
+		}
+
+		if !field.CanSet() { // Being settable is a super set of being addressable.
+			innerErr := fmt.Errorf("field %v is not settable", field)
+			return newDecodeError(fd.name, innerErr)
+		}
+		if field.Kind() == reflect.Ptr && field.IsNil() {
+			field.Set(reflect.New(field.Type().Elem()))
+		}
+		field = field.Addr()
+
+		dctx := DecodeContext{
+			Registry:            dc.Registry,
+			truncate:            fd.truncate || dc.truncate,
+			defaultDocumentType: dc.defaultDocumentType,
+			binaryAsSlice:       dc.binaryAsSlice,
+			objectIDAsHexString: dc.objectIDAsHexString,
+			useJSONStructTags:   dc.useJSONStructTags,
+			useLocalTimeZone:    dc.useLocalTimeZone,
+			zeroMaps:            dc.zeroMaps,
+			zeroStructs:         dc.zeroStructs,
+		}
+
+		if fd.decoder == nil {
+			return newDecodeError(fd.name, errNoDecoder{Type: field.Elem().Type()})
+		}
+
+		err = fd.decoder.DecodeValue(dctx, vr, field.Elem())
+		if err != nil {
+			return newDecodeError(fd.name, err)
+		}
+	}
+
+	return nil
+}
+
+func isEmpty(v reflect.Value, omitZeroStruct bool) bool {
+	kind := v.Kind()
+	if (kind != reflect.Ptr || !v.IsNil()) && v.Type().Implements(tZeroer) {
+		return v.Interface().(Zeroer).IsZero()
+	}
+	switch kind {
+	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+		return v.Len() == 0
+	case reflect.Struct:
+		if !omitZeroStruct {
+			return false
+		}
+		vt := v.Type()
+		if vt == tTime {
+			return v.Interface().(time.Time).IsZero()
+		}
+		numField := vt.NumField()
+		for i := 0; i < numField; i++ {
+			ff := vt.Field(i)
+			if ff.PkgPath != "" && !ff.Anonymous {
+				continue // Private field
+			}
+			if !isEmpty(v.Field(i), omitZeroStruct) {
+				return false
+			}
+		}
+		return true
+	}
+	return !v.IsValid() || v.IsZero()
+}
+
+type structDescription struct {
+	fm        map[string]fieldDescription
+	fl        []fieldDescription
+	inlineMap int
+	inline    bool
+}
+
+type fieldDescription struct {
+	name      string // BSON key name
+	fieldName string // struct field name
+	idx       int
+	omitEmpty bool
+	minSize   bool
+	truncate  bool
+	inline    []int
+	encoder   ValueEncoder
+	decoder   ValueDecoder
+}
+
+type byIndex []fieldDescription
+
+func (bi byIndex) Len() int { return len(bi) }
+
+func (bi byIndex) Swap(i, j int) { bi[i], bi[j] = bi[j], bi[i] }
+
+func (bi byIndex) Less(i, j int) bool {
+	// If a field is inlined, its index in the top level struct is stored at inline[0]
+	iIdx, jIdx := bi[i].idx, bi[j].idx
+	if len(bi[i].inline) > 0 {
+		iIdx = bi[i].inline[0]
+	}
+	if len(bi[j].inline) > 0 {
+		jIdx = bi[j].inline[0]
+	}
+	if iIdx != jIdx {
+		return iIdx < jIdx
+	}
+	for k, biik := range bi[i].inline {
+		if k >= len(bi[j].inline) {
+			return false
+		}
+		if biik != bi[j].inline[k] {
+			return biik < bi[j].inline[k]
+		}
+	}
+	return len(bi[i].inline) < len(bi[j].inline)
+}
+
+func (sc *structCodec) describeStruct(
+	r *Registry,
+	t reflect.Type,
+	useJSONStructTags bool,
+	errorOnDuplicates bool,
+) (*structDescription, error) {
+	// We need to analyze the struct, including getting the tags, collecting
+	// information about inlining, and create a map of the field name to the field.
+	if v, ok := sc.cache.Load(t); ok {
+		return v.(*structDescription), nil
+	}
+	// TODO(charlie): Only describe the struct once when called
+	// concurrently with the same type.
+	ds, err := sc.describeStructSlow(r, t, useJSONStructTags, errorOnDuplicates)
+	if err != nil {
+		return nil, err
+	}
+	if v, loaded := sc.cache.LoadOrStore(t, ds); loaded {
+		ds = v.(*structDescription)
+	}
+	return ds, nil
+}
+
+func (sc *structCodec) describeStructSlow(
+	r *Registry,
+	t reflect.Type,
+	useJSONStructTags bool,
+	errorOnDuplicates bool,
+) (*structDescription, error) {
+	numFields := t.NumField()
+	sd := &structDescription{
+		fm:        make(map[string]fieldDescription, numFields),
+		fl:        make([]fieldDescription, 0, numFields),
+		inlineMap: -1,
+	}
+
+	var fields []fieldDescription
+	for i := 0; i < numFields; i++ {
+		sf := t.Field(i)
+		if sf.PkgPath != "" && (!sc.allowUnexportedFields || !sf.Anonymous) {
+			// field is private or unexported fields aren't allowed, ignore
+			continue
+		}
+
+		sfType := sf.Type
+		encoder, err := r.LookupEncoder(sfType)
+		if err != nil {
+			encoder = nil
+		}
+		decoder, err := r.LookupDecoder(sfType)
+		if err != nil {
+			decoder = nil
+		}
+
+		description := fieldDescription{
+			fieldName: sf.Name,
+			idx:       i,
+			encoder:   encoder,
+			decoder:   decoder,
+		}
+
+		var stags *structTags
+		// If the caller requested that we use JSON struct tags, use the JSONFallbackStructTagParser
+		// instead of the parser defined on the codec.
+		if useJSONStructTags {
+			stags, err = parseJSONStructTags(sf)
+		} else {
+			stags, err = parseStructTags(sf)
+		}
+		if err != nil {
+			return nil, err
+		}
+		if stags.Skip {
+			continue
+		}
+		description.name = stags.Name
+		description.omitEmpty = stags.OmitEmpty
+		description.minSize = stags.MinSize
+		description.truncate = stags.Truncate
+
+		if stags.Inline {
+			sd.inline = true
+			switch sfType.Kind() {
+			case reflect.Map:
+				if sd.inlineMap >= 0 {
+					return nil, errors.New("(struct " + t.String() + ") multiple inline maps")
+				}
+				if sfType.Key() != tString {
+					return nil, errors.New("(struct " + t.String() + ") inline map must have a string keys")
+				}
+				sd.inlineMap = description.idx
+			case reflect.Ptr:
+				sfType = sfType.Elem()
+				if sfType.Kind() != reflect.Struct {
+					return nil, fmt.Errorf("(struct %s) inline fields must be a struct, a struct pointer, or a map", t.String())
+				}
+				fallthrough
+			case reflect.Struct:
+				inlinesf, err := sc.describeStruct(r, sfType, useJSONStructTags, errorOnDuplicates)
+				if err != nil {
+					return nil, err
+				}
+				for _, fd := range inlinesf.fl {
+					if fd.inline == nil {
+						fd.inline = []int{i, fd.idx}
+					} else {
+						fd.inline = append([]int{i}, fd.inline...)
+					}
+					fields = append(fields, fd)
+
+				}
+			default:
+				return nil, fmt.Errorf("(struct %s) inline fields must be a struct, a struct pointer, or a map", t.String())
+			}
+			continue
+		}
+		fields = append(fields, description)
+	}
+
+	// Sort fieldDescriptions by name and use dominance rules to determine which should be added for each name
+	sort.Slice(fields, func(i, j int) bool {
+		x := fields
+		// sort field by name, breaking ties with depth, then
+		// breaking ties with index sequence.
+		if x[i].name != x[j].name {
+			return x[i].name < x[j].name
+		}
+		if len(x[i].inline) != len(x[j].inline) {
+			return len(x[i].inline) < len(x[j].inline)
+		}
+		return byIndex(x).Less(i, j)
+	})
+
+	for advance, i := 0, 0; i < len(fields); i += advance {
+		// One iteration per name.
+		// Find the sequence of fields with the name of this first field.
+		fi := fields[i]
+		name := fi.name
+		for advance = 1; i+advance < len(fields); advance++ {
+			fj := fields[i+advance]
+			if fj.name != name {
+				break
+			}
+		}
+		if advance == 1 { // Only one field with this name
+			sd.fl = append(sd.fl, fi)
+			sd.fm[name] = fi
+			continue
+		}
+		dominant, ok := dominantField(fields[i : i+advance])
+		if !ok || !sc.overwriteDuplicatedInlinedFields || errorOnDuplicates {
+			return nil, fmt.Errorf("struct %s has duplicated key %s", t.String(), name)
+		}
+		sd.fl = append(sd.fl, dominant)
+		sd.fm[name] = dominant
+	}
+
+	sort.Sort(byIndex(sd.fl))
+
+	return sd, nil
+}
+
+// dominantField looks through the fields, all of which are known to
+// have the same name, to find the single field that dominates the
+// others using Go's inlining rules. If there are multiple top-level
+// fields, the boolean will be false: This condition is an error in Go
+// and we skip all the fields.
+func dominantField(fields []fieldDescription) (fieldDescription, bool) {
+	// The fields are sorted in increasing index-length order, then by presence of tag.
+	// That means that the first field is the dominant one. We need only check
+	// for error cases: two fields at top level.
+	if len(fields) > 1 &&
+		len(fields[0].inline) == len(fields[1].inline) {
+		return fieldDescription{}, false
+	}
+	return fields[0], true
+}
+
+func fieldByIndexErr(v reflect.Value, index []int) (result reflect.Value, err error) {
+	defer func() {
+		if recovered := recover(); recovered != nil {
+			switch r := recovered.(type) {
+			case string:
+				err = fmt.Errorf("%s", r)
+			case error:
+				err = r
+			}
+		}
+	}()
+
+	result = v.FieldByIndex(index)
+	return
+}
+
+func getInlineField(val reflect.Value, index []int) (reflect.Value, error) {
+	field, err := fieldByIndexErr(val, index)
+	if err == nil {
+		return field, nil
+	}
+
+	// if parent of this element doesn't exist, fix its parent
+	inlineParent := index[:len(index)-1]
+	var fParent reflect.Value
+	if fParent, err = fieldByIndexErr(val, inlineParent); err != nil {
+		fParent, err = getInlineField(val, inlineParent)
+		if err != nil {
+			return fParent, err
+		}
+	}
+	fParent.Set(reflect.New(fParent.Type().Elem()))
+
+	return fieldByIndexErr(val, index)
+}
+
+// DeepZero returns recursive zero object
+func deepZero(st reflect.Type) (result reflect.Value) {
+	if st.Kind() == reflect.Struct {
+		numField := st.NumField()
+		for i := 0; i < numField; i++ {
+			if result == emptyValue {
+				result = reflect.Indirect(reflect.New(st))
+			}
+			f := result.Field(i)
+			if f.CanInterface() {
+				if f.Type().Kind() == reflect.Struct {
+					result.Field(i).Set(recursivePointerTo(deepZero(f.Type().Elem())))
+				}
+			}
+		}
+	}
+	return result
+}
+
+// recursivePointerTo calls reflect.New(v.Type) but recursively for its fields inside
+func recursivePointerTo(v reflect.Value) reflect.Value {
+	v = reflect.Indirect(v)
+	result := reflect.New(v.Type())
+	if v.Kind() == reflect.Struct {
+		for i := 0; i < v.NumField(); i++ {
+			if f := v.Field(i); f.Kind() == reflect.Ptr {
+				if f.Elem().Kind() == reflect.Struct {
+					result.Elem().Field(i).Set(recursivePointerTo(f))
+				}
+			}
+		}
+	}
+
+	return result
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/struct_tag_parser.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/struct_tag_parser.go
new file mode 100644
index 00000000..47955639
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/struct_tag_parser.go
@@ -0,0 +1,123 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"reflect"
+	"strings"
+)
+
+// structTags represents the struct tag fields that the StructCodec uses during
+// the encoding and decoding process.
+//
+// In the case of a struct, the lowercased field name is used as the key for each exported
+// field but this behavior may be changed using a struct tag. The tag may also contain flags to
+// adjust the marshalling behavior for the field.
+//
+// The properties are defined below:
+//
+//	OmitEmpty  Only include the field if it's not set to the zero value for the type or to
+//	           empty slices or maps.
+//
+//	MinSize    Marshal an integer of a type larger than 32 bits value as an int32, if that's
+//	           feasible while preserving the numeric value.
+//
+//	Truncate   When unmarshaling a BSON double, it is permitted to lose precision to fit within
+//	           a float32.
+//
+//	Inline     Inline the field, which must be a struct or a map, causing all of its fields
+//	           or keys to be processed as if they were part of the outer struct. For maps,
+//	           keys must not conflict with the bson keys of other struct fields.
+//
+//	Skip       This struct field should be skipped. This is usually denoted by parsing a "-"
+//	           for the name.
+type structTags struct {
+	Name      string
+	OmitEmpty bool
+	MinSize   bool
+	Truncate  bool
+	Inline    bool
+	Skip      bool
+}
+
+// DefaultStructTagParser is the StructTagParser used by the StructCodec by default.
+// It will handle the bson struct tag. See the documentation for StructTags to see
+// what each of the returned fields means.
+//
+// If there is no name in the struct tag fields, the struct field name is lowercased.
+// The tag formats accepted are:
+//
+//	"[<key>][,<flag1>[,<flag2>]]"
+//
+//	`(...) bson:"[<key>][,<flag1>[,<flag2>]]" (...)`
+//
+// An example:
+//
+//	type T struct {
+//	    A bool
+//	    B int    "myb"
+//	    C string "myc,omitempty"
+//	    D string `bson:",omitempty" json:"jsonkey"`
+//	    E int64  ",minsize"
+//	    F int64  "myf,omitempty,minsize"
+//	}
+//
+// A struct tag either consisting entirely of '-' or with a bson key with a
+// value consisting entirely of '-' will return a StructTags with Skip true and
+// the remaining fields will be their default values.
+func parseStructTags(sf reflect.StructField) (*structTags, error) {
+	key := strings.ToLower(sf.Name)
+	tag, ok := sf.Tag.Lookup("bson")
+	if !ok && !strings.Contains(string(sf.Tag), ":") && len(sf.Tag) > 0 {
+		tag = string(sf.Tag)
+	}
+	return parseTags(key, tag)
+}
+
+// jsonStructTagParser has the same behavior as DefaultStructTagParser
+// but will also fallback to parsing the json tag instead on a field where the
+// bson tag isn't available.
+func parseJSONStructTags(sf reflect.StructField) (*structTags, error) {
+	key := strings.ToLower(sf.Name)
+	tag, ok := sf.Tag.Lookup("bson")
+	if !ok {
+		tag, ok = sf.Tag.Lookup("json")
+	}
+	if !ok && !strings.Contains(string(sf.Tag), ":") && len(sf.Tag) > 0 {
+		tag = string(sf.Tag)
+	}
+
+	return parseTags(key, tag)
+}
+
+func parseTags(key string, tag string) (*structTags, error) {
+	var st structTags
+	if tag == "-" {
+		st.Skip = true
+		return &st, nil
+	}
+
+	for idx, str := range strings.Split(tag, ",") {
+		if idx == 0 && str != "" {
+			key = str
+		}
+		switch str {
+		case "omitempty":
+			st.OmitEmpty = true
+		case "minsize":
+			st.MinSize = true
+		case "truncate":
+			st.Truncate = true
+		case "inline":
+			st.Inline = true
+		}
+	}
+
+	st.Name = key
+
+	return &st, nil
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/time_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/time_codec.go
new file mode 100644
index 00000000..1c00374c
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/time_codec.go
@@ -0,0 +1,109 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"fmt"
+	"reflect"
+	"time"
+)
+
+const (
+	timeFormatString = "2006-01-02T15:04:05.999Z07:00"
+)
+
+// timeCodec is the Codec used for time.Time values.
+type timeCodec struct {
+	// useLocalTimeZone specifies if we should decode into the local time zone. Defaults to false.
+	useLocalTimeZone bool
+}
+
+// Assert that timeCodec satisfies the typeDecoder interface, which allows it to be used
+// by collection type decoders (e.g. map, slice, etc) to set individual values in a collection.
+var _ typeDecoder = &timeCodec{}
+
+func (tc *timeCodec) decodeType(dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	if t != tTime {
+		return emptyValue, ValueDecoderError{
+			Name:     "TimeDecodeValue",
+			Types:    []reflect.Type{tTime},
+			Received: reflect.Zero(t),
+		}
+	}
+
+	var timeVal time.Time
+	switch vrType := vr.Type(); vrType {
+	case TypeDateTime:
+		dt, err := vr.ReadDateTime()
+		if err != nil {
+			return emptyValue, err
+		}
+		timeVal = time.Unix(dt/1000, dt%1000*1000000)
+	case TypeString:
+		// assume strings are in the isoTimeFormat
+		timeStr, err := vr.ReadString()
+		if err != nil {
+			return emptyValue, err
+		}
+		timeVal, err = time.Parse(timeFormatString, timeStr)
+		if err != nil {
+			return emptyValue, err
+		}
+	case TypeInt64:
+		i64, err := vr.ReadInt64()
+		if err != nil {
+			return emptyValue, err
+		}
+		timeVal = time.Unix(i64/1000, i64%1000*1000000)
+	case TypeTimestamp:
+		t, _, err := vr.ReadTimestamp()
+		if err != nil {
+			return emptyValue, err
+		}
+		timeVal = time.Unix(int64(t), 0)
+	case TypeNull:
+		if err := vr.ReadNull(); err != nil {
+			return emptyValue, err
+		}
+	case TypeUndefined:
+		if err := vr.ReadUndefined(); err != nil {
+			return emptyValue, err
+		}
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into a time.Time", vrType)
+	}
+
+	if !tc.useLocalTimeZone && !dc.useLocalTimeZone {
+		timeVal = timeVal.UTC()
+	}
+	return reflect.ValueOf(timeVal), nil
+}
+
+// DecodeValue is the ValueDecoderFunc for time.Time.
+func (tc *timeCodec) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() || val.Type() != tTime {
+		return ValueDecoderError{Name: "TimeDecodeValue", Types: []reflect.Type{tTime}, Received: val}
+	}
+
+	elem, err := tc.decodeType(dc, vr, tTime)
+	if err != nil {
+		return err
+	}
+
+	val.Set(elem)
+	return nil
+}
+
+// EncodeValue is the ValueEncoderFunc for time.TIme.
+func (tc *timeCodec) EncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Type() != tTime {
+		return ValueEncoderError{Name: "TimeEncodeValue", Types: []reflect.Type{tTime}, Received: val}
+	}
+	tt := val.Interface().(time.Time)
+	dt := NewDateTimeFromTime(tt)
+	return vw.WriteDateTime(int64(dt))
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/types.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/types.go
new file mode 100644
index 00000000..c2883aa4
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/types.go
@@ -0,0 +1,118 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"encoding/json"
+	"net/url"
+	"reflect"
+	"time"
+
+	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
+)
+
+// Type represents a BSON type.
+type Type byte
+
+// String returns the string representation of the BSON type's name.
+func (bt Type) String() string {
+	return bsoncore.Type(bt).String()
+}
+
+// IsValid will return true if the Type is valid.
+func (bt Type) IsValid() bool {
+	switch bt {
+	case TypeDouble, TypeString, TypeEmbeddedDocument, TypeArray, TypeBinary,
+		TypeUndefined, TypeObjectID, TypeBoolean, TypeDateTime, TypeNull, TypeRegex,
+		TypeDBPointer, TypeJavaScript, TypeSymbol, TypeCodeWithScope, TypeInt32,
+		TypeTimestamp, TypeInt64, TypeDecimal128, TypeMinKey, TypeMaxKey:
+		return true
+	default:
+		return false
+	}
+}
+
+// BSON element types as described in https://bsonspec.org/spec.html.
+const (
+	TypeDouble           Type = 0x01
+	TypeString           Type = 0x02
+	TypeEmbeddedDocument Type = 0x03
+	TypeArray            Type = 0x04
+	TypeBinary           Type = 0x05
+	TypeUndefined        Type = 0x06
+	TypeObjectID         Type = 0x07
+	TypeBoolean          Type = 0x08
+	TypeDateTime         Type = 0x09
+	TypeNull             Type = 0x0A
+	TypeRegex            Type = 0x0B
+	TypeDBPointer        Type = 0x0C
+	TypeJavaScript       Type = 0x0D
+	TypeSymbol           Type = 0x0E
+	TypeCodeWithScope    Type = 0x0F
+	TypeInt32            Type = 0x10
+	TypeTimestamp        Type = 0x11
+	TypeInt64            Type = 0x12
+	TypeDecimal128       Type = 0x13
+	TypeMaxKey           Type = 0x7F
+	TypeMinKey           Type = 0xFF
+)
+
+// BSON binary element subtypes as described in https://bsonspec.org/spec.html.
+const (
+	TypeBinaryGeneric     byte = 0x00
+	TypeBinaryFunction    byte = 0x01
+	TypeBinaryBinaryOld   byte = 0x02
+	TypeBinaryUUIDOld     byte = 0x03
+	TypeBinaryUUID        byte = 0x04
+	TypeBinaryMD5         byte = 0x05
+	TypeBinaryEncrypted   byte = 0x06
+	TypeBinaryColumn      byte = 0x07
+	TypeBinarySensitive   byte = 0x08
+	TypeBinaryVector      byte = 0x09
+	TypeBinaryUserDefined byte = 0x80
+)
+
+var tBool = reflect.TypeOf(false)
+var tFloat64 = reflect.TypeOf(float64(0))
+var tInt32 = reflect.TypeOf(int32(0))
+var tInt64 = reflect.TypeOf(int64(0))
+var tString = reflect.TypeOf("")
+var tTime = reflect.TypeOf(time.Time{})
+
+var tEmpty = reflect.TypeOf((*interface{})(nil)).Elem()
+var tByteSlice = reflect.TypeOf([]byte(nil))
+var tByte = reflect.TypeOf(byte(0x00))
+var tURL = reflect.TypeOf(url.URL{})
+var tJSONNumber = reflect.TypeOf(json.Number(""))
+
+var tValueMarshaler = reflect.TypeOf((*ValueMarshaler)(nil)).Elem()
+var tValueUnmarshaler = reflect.TypeOf((*ValueUnmarshaler)(nil)).Elem()
+var tMarshaler = reflect.TypeOf((*Marshaler)(nil)).Elem()
+var tUnmarshaler = reflect.TypeOf((*Unmarshaler)(nil)).Elem()
+var tZeroer = reflect.TypeOf((*Zeroer)(nil)).Elem()
+
+var tBinary = reflect.TypeOf(Binary{})
+var tUndefined = reflect.TypeOf(Undefined{})
+var tOID = reflect.TypeOf(ObjectID{})
+var tDateTime = reflect.TypeOf(DateTime(0))
+var tNull = reflect.TypeOf(Null{})
+var tRegex = reflect.TypeOf(Regex{})
+var tCodeWithScope = reflect.TypeOf(CodeWithScope{})
+var tDBPointer = reflect.TypeOf(DBPointer{})
+var tJavaScript = reflect.TypeOf(JavaScript(""))
+var tSymbol = reflect.TypeOf(Symbol(""))
+var tTimestamp = reflect.TypeOf(Timestamp{})
+var tDecimal = reflect.TypeOf(Decimal128{})
+var tVector = reflect.TypeOf(Vector{})
+var tMinKey = reflect.TypeOf(MinKey{})
+var tMaxKey = reflect.TypeOf(MaxKey{})
+var tD = reflect.TypeOf(D{})
+var tA = reflect.TypeOf(A{})
+var tE = reflect.TypeOf(E{})
+
+var tCoreDocument = reflect.TypeOf(bsoncore.Document{})
+var tCoreArray = reflect.TypeOf(bsoncore.Array{})
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/uint_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/uint_codec.go
new file mode 100644
index 00000000..0cdcc635
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/uint_codec.go
@@ -0,0 +1,161 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"fmt"
+	"math"
+	"reflect"
+)
+
+// uintCodec is the Codec used for uint values.
+type uintCodec struct {
+	// encodeToMinSize causes EncodeValue to marshal Go uint values (excluding uint64) as the
+	// minimum BSON int size (either 32-bit or 64-bit) that can represent the integer value.
+	encodeToMinSize bool
+}
+
+// Assert that uintCodec satisfies the typeDecoder interface, which allows it to be used
+// by collection type decoders (e.g. map, slice, etc) to set individual values in a collection.
+var _ typeDecoder = &uintCodec{}
+
+// EncodeValue is the ValueEncoder for uint types.
+func (uic *uintCodec) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
+	switch val.Kind() {
+	case reflect.Uint8, reflect.Uint16:
+		return vw.WriteInt32(int32(val.Uint()))
+	case reflect.Uint, reflect.Uint32, reflect.Uint64:
+		u64 := val.Uint()
+
+		// If ec.MinSize or if encodeToMinSize is true for a non-uint64 value we should write val as an int32
+		useMinSize := ec.minSize || (uic.encodeToMinSize && val.Kind() != reflect.Uint64)
+
+		if u64 <= math.MaxInt32 && useMinSize {
+			return vw.WriteInt32(int32(u64))
+		}
+		if u64 > math.MaxInt64 {
+			return fmt.Errorf("%d overflows int64", u64)
+		}
+		return vw.WriteInt64(int64(u64))
+	}
+
+	return ValueEncoderError{
+		Name:     "UintEncodeValue",
+		Kinds:    []reflect.Kind{reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint},
+		Received: val,
+	}
+}
+
+func (uic *uintCodec) decodeType(dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
+	var i64 int64
+	var err error
+	switch vrType := vr.Type(); vrType {
+	case TypeInt32:
+		i32, err := vr.ReadInt32()
+		if err != nil {
+			return emptyValue, err
+		}
+		i64 = int64(i32)
+	case TypeInt64:
+		i64, err = vr.ReadInt64()
+		if err != nil {
+			return emptyValue, err
+		}
+	case TypeDouble:
+		f64, err := vr.ReadDouble()
+		if err != nil {
+			return emptyValue, err
+		}
+		if !dc.truncate && math.Floor(f64) != f64 {
+			return emptyValue, errCannotTruncate
+		}
+		if f64 > float64(math.MaxInt64) {
+			return emptyValue, fmt.Errorf("%g overflows int64", f64)
+		}
+		i64 = int64(f64)
+	case TypeBoolean:
+		b, err := vr.ReadBoolean()
+		if err != nil {
+			return emptyValue, err
+		}
+		if b {
+			i64 = 1
+		}
+	case TypeNull:
+		if err = vr.ReadNull(); err != nil {
+			return emptyValue, err
+		}
+	case TypeUndefined:
+		if err = vr.ReadUndefined(); err != nil {
+			return emptyValue, err
+		}
+	default:
+		return emptyValue, fmt.Errorf("cannot decode %v into an integer type", vrType)
+	}
+
+	switch t.Kind() {
+	case reflect.Uint8:
+		if i64 < 0 || i64 > math.MaxUint8 {
+			return emptyValue, fmt.Errorf("%d overflows uint8", i64)
+		}
+
+		return reflect.ValueOf(uint8(i64)), nil
+	case reflect.Uint16:
+		if i64 < 0 || i64 > math.MaxUint16 {
+			return emptyValue, fmt.Errorf("%d overflows uint16", i64)
+		}
+
+		return reflect.ValueOf(uint16(i64)), nil
+	case reflect.Uint32:
+		if i64 < 0 || i64 > math.MaxUint32 {
+			return emptyValue, fmt.Errorf("%d overflows uint32", i64)
+		}
+
+		return reflect.ValueOf(uint32(i64)), nil
+	case reflect.Uint64:
+		if i64 < 0 {
+			return emptyValue, fmt.Errorf("%d overflows uint64", i64)
+		}
+
+		return reflect.ValueOf(uint64(i64)), nil
+	case reflect.Uint:
+		if i64 < 0 {
+			return emptyValue, fmt.Errorf("%d overflows uint", i64)
+		}
+		v := uint64(i64)
+		if v > math.MaxUint { // Can we fit this inside of an uint
+			return emptyValue, fmt.Errorf("%d overflows uint", i64)
+		}
+
+		return reflect.ValueOf(uint(v)), nil
+	default:
+		return emptyValue, ValueDecoderError{
+			Name:     "UintDecodeValue",
+			Kinds:    []reflect.Kind{reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint},
+			Received: reflect.Zero(t),
+		}
+	}
+}
+
+// DecodeValue is the ValueDecoder for uint types.
+func (uic *uintCodec) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
+	if !val.CanSet() {
+		return ValueDecoderError{
+			Name:     "UintDecodeValue",
+			Kinds:    []reflect.Kind{reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint},
+			Received: val,
+		}
+	}
+
+	elem, err := uic.decodeType(dc, vr, val.Type())
+	if err != nil {
+		return err
+	}
+
+	val.SetUint(elem.Uint())
+	return nil
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/unmarshal.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/unmarshal.go
new file mode 100644
index 00000000..52bd94fe
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/unmarshal.go
@@ -0,0 +1,90 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"bytes"
+	"fmt"
+)
+
+// Unmarshaler is the interface implemented by types that can unmarshal a BSON
+// document representation of themselves. The input can be assumed to be a valid
+// encoding of a BSON document. UnmarshalBSON must copy the JSON data if it
+// wishes to retain the data after returning.
+//
+// Unmarshaler is only used to unmarshal full BSON documents. To create custom
+// BSON unmarshaling behavior for individual values in a BSON document,
+// implement the ValueUnmarshaler interface instead.
+type Unmarshaler interface {
+	UnmarshalBSON([]byte) error
+}
+
+// ValueUnmarshaler is the interface implemented by types that can unmarshal a
+// BSON value representation of themselves. The input can be assumed to be a
+// valid encoding of a BSON value. UnmarshalBSONValue must copy the BSON value
+// bytes if it wishes to retain the data after returning.
+//
+// ValueUnmarshaler is only used to unmarshal individual values in a BSON
+// document. To create custom BSON unmarshaling behavior for an entire BSON
+// document, implement the Unmarshaler interface instead.
+type ValueUnmarshaler interface {
+	UnmarshalBSONValue(typ byte, data []byte) error
+}
+
+// Unmarshal parses the BSON-encoded data and stores the result in the value
+// pointed to by val. If val is nil or not a pointer, Unmarshal returns an
+// error.
+//
+// When unmarshaling BSON, if the BSON value is null and the Go value is a
+// pointer, the pointer is set to nil without calling UnmarshalBSONValue.
+func Unmarshal(data []byte, val interface{}) error {
+	vr := getDocumentReader(bytes.NewReader(data))
+	defer putDocumentReader(vr)
+
+	if l, err := vr.peekLength(); err != nil {
+		return err
+	} else if int(l) != len(data) {
+		return fmt.Errorf("invalid document length")
+	}
+	return unmarshalFromReader(DecodeContext{Registry: defaultRegistry}, vr, val)
+}
+
+// UnmarshalValue parses the BSON value of type t with bson.NewRegistry() and
+// stores the result in the value pointed to by val. If val is nil or not a pointer,
+// UnmarshalValue returns an error.
+func UnmarshalValue(t Type, data []byte, val interface{}) error {
+	vr := newValueReader(t, bytes.NewReader(data))
+	return unmarshalFromReader(DecodeContext{Registry: defaultRegistry}, vr, val)
+}
+
+// UnmarshalExtJSON parses the extended JSON-encoded data and stores the result
+// in the value pointed to by val. If val is nil or not a pointer, UnmarshalExtJSON
+// returns an error.
+//
+// If canonicalOnly is true, UnmarshalExtJSON returns an error if the Extended
+// JSON was not marshaled in canonical mode.
+//
+// For more information about Extended JSON, see
+// https://www.mongodb.com/docs/manual/reference/mongodb-extended-json/
+func UnmarshalExtJSON(data []byte, canonicalOnly bool, val interface{}) error {
+	ejvr, err := NewExtJSONValueReader(bytes.NewReader(data), canonicalOnly)
+	if err != nil {
+		return err
+	}
+
+	return unmarshalFromReader(DecodeContext{Registry: defaultRegistry}, ejvr, val)
+}
+
+func unmarshalFromReader(dc DecodeContext, vr ValueReader, val interface{}) error {
+	dec := decPool.Get().(*Decoder)
+	defer decPool.Put(dec)
+
+	dec.Reset(vr)
+	dec.dc = dc
+
+	return dec.Decode(val)
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/value_reader.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/value_reader.go
new file mode 100644
index 00000000..d713e669
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/value_reader.go
@@ -0,0 +1,898 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"bufio"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"sync"
+)
+
+var _ ValueReader = &valueReader{}
+
+// ErrEOA is the error returned when the end of a BSON array has been reached.
+var ErrEOA = errors.New("end of array")
+
+// ErrEOD is the error returned when the end of a BSON document has been reached.
+var ErrEOD = errors.New("end of document")
+
+type vrState struct {
+	mode  mode
+	vType Type
+	end   int64
+}
+
+var bufioReaderPool = sync.Pool{
+	New: func() interface{} {
+		return bufio.NewReader(nil)
+	},
+}
+
+var vrPool = sync.Pool{
+	New: func() interface{} {
+		return &valueReader{
+			stack: make([]vrState, 1, 5),
+		}
+	},
+}
+
+// valueReader is for reading BSON values.
+type valueReader struct {
+	r      *bufio.Reader
+	offset int64
+
+	stack []vrState
+	frame int64
+}
+
+func getDocumentReader(r io.Reader) *valueReader {
+	vr := vrPool.Get().(*valueReader)
+
+	vr.offset = 0
+	vr.frame = 0
+
+	vr.stack = vr.stack[:1]
+	vr.stack[0] = vrState{mode: mTopLevel}
+
+	br := bufioReaderPool.Get().(*bufio.Reader)
+	br.Reset(r)
+	vr.r = br
+
+	return vr
+}
+
+func putDocumentReader(vr *valueReader) {
+	if vr == nil {
+		return
+	}
+
+	bufioReaderPool.Put(vr.r)
+	vr.r = nil
+
+	vrPool.Put(vr)
+}
+
+// NewDocumentReader returns a ValueReader using b for the underlying BSON
+// representation.
+func NewDocumentReader(r io.Reader) ValueReader {
+	return newDocumentReader(r)
+}
+
+// newValueReader returns a ValueReader that starts in the Value mode instead of in top
+// level document mode. This enables the creation of a ValueReader for a single BSON value.
+func newValueReader(t Type, r io.Reader) ValueReader {
+	vr := newDocumentReader(r)
+	if len(vr.stack) == 0 {
+		vr.stack = make([]vrState, 1, 5)
+	}
+	vr.stack[0].mode = mValue
+	vr.stack[0].vType = t
+	return vr
+}
+
+func newDocumentReader(r io.Reader) *valueReader {
+	stack := make([]vrState, 1, 5)
+	stack[0] = vrState{
+		mode: mTopLevel,
+	}
+	return &valueReader{
+		r:     bufio.NewReader(r),
+		stack: stack,
+	}
+}
+
+func (vr *valueReader) advanceFrame() {
+	if vr.frame+1 >= int64(len(vr.stack)) { // We need to grow the stack
+		length := len(vr.stack)
+		if length+1 >= cap(vr.stack) {
+			// double it
+			buf := make([]vrState, 2*cap(vr.stack)+1)
+			copy(buf, vr.stack)
+			vr.stack = buf
+		}
+		vr.stack = vr.stack[:length+1]
+	}
+	vr.frame++
+
+	// Clean the stack
+	vr.stack[vr.frame].mode = 0
+	vr.stack[vr.frame].vType = 0
+	vr.stack[vr.frame].end = 0
+}
+
+func (vr *valueReader) pushDocument() error {
+	vr.advanceFrame()
+
+	vr.stack[vr.frame].mode = mDocument
+
+	length, err := vr.readLength()
+	if err != nil {
+		return err
+	}
+	vr.stack[vr.frame].end = int64(length) + vr.offset - 4
+
+	return nil
+}
+
+func (vr *valueReader) pushArray() error {
+	vr.advanceFrame()
+
+	vr.stack[vr.frame].mode = mArray
+
+	length, err := vr.readLength()
+	if err != nil {
+		return err
+	}
+	vr.stack[vr.frame].end = int64(length) + vr.offset - 4
+
+	return nil
+}
+
+func (vr *valueReader) pushElement(t Type) {
+	vr.advanceFrame()
+
+	vr.stack[vr.frame].mode = mElement
+	vr.stack[vr.frame].vType = t
+}
+
+func (vr *valueReader) pushValue(t Type) {
+	vr.advanceFrame()
+
+	vr.stack[vr.frame].mode = mValue
+	vr.stack[vr.frame].vType = t
+}
+
+func (vr *valueReader) pushCodeWithScope() (int64, error) {
+	vr.advanceFrame()
+
+	vr.stack[vr.frame].mode = mCodeWithScope
+
+	length, err := vr.readLength()
+	if err != nil {
+		return 0, err
+	}
+	vr.stack[vr.frame].end = int64(length) + vr.offset - 4
+
+	return int64(length), nil
+}
+
+func (vr *valueReader) pop() error {
+	var cnt int
+	switch vr.stack[vr.frame].mode {
+	case mElement, mValue:
+		cnt = 1
+	case mDocument, mArray, mCodeWithScope:
+		cnt = 2 // we pop twice to jump over the vrElement: vrDocument -> vrElement -> vrDocument/TopLevel/etc...
+	}
+	for i := 0; i < cnt && vr.frame > 0; i++ {
+		if vr.offset < vr.stack[vr.frame].end {
+			_, err := vr.r.Discard(int(vr.stack[vr.frame].end - vr.offset))
+			if err != nil {
+				return err
+			}
+		}
+		vr.frame--
+	}
+	if vr.frame == 0 {
+		if vr.stack[0].end > vr.offset {
+			vr.stack[0].end -= vr.offset
+		} else {
+			vr.stack[0].end = 0
+		}
+		vr.offset = 0
+	}
+	return nil
+}
+
+func (vr *valueReader) invalidTransitionErr(destination mode, name string, modes []mode) error {
+	te := TransitionError{
+		name:        name,
+		current:     vr.stack[vr.frame].mode,
+		destination: destination,
+		modes:       modes,
+		action:      "read",
+	}
+	if vr.frame != 0 {
+		te.parent = vr.stack[vr.frame-1].mode
+	}
+	return te
+}
+
+func (vr *valueReader) typeError(t Type) error {
+	return fmt.Errorf("positioned on %s, but attempted to read %s", vr.stack[vr.frame].vType, t)
+}
+
+func (vr *valueReader) invalidDocumentLengthError() error {
+	return fmt.Errorf("document is invalid, end byte is at %d, but null byte found at %d", vr.stack[vr.frame].end, vr.offset)
+}
+
+func (vr *valueReader) ensureElementValue(t Type, destination mode, callerName string) error {
+	switch vr.stack[vr.frame].mode {
+	case mElement, mValue:
+		if vr.stack[vr.frame].vType != t {
+			return vr.typeError(t)
+		}
+	default:
+		return vr.invalidTransitionErr(destination, callerName, []mode{mElement, mValue})
+	}
+
+	return nil
+}
+
+func (vr *valueReader) Type() Type {
+	return vr.stack[vr.frame].vType
+}
+
+func (vr *valueReader) appendNextElement(dst []byte) ([]byte, error) {
+	var length int32
+	var err error
+	switch vr.stack[vr.frame].vType {
+	case TypeArray, TypeEmbeddedDocument, TypeCodeWithScope:
+		length, err = vr.peekLength()
+	case TypeBinary:
+		length, err = vr.peekLength()
+		length += 4 + 1 // binary length + subtype byte
+	case TypeBoolean:
+		length = 1
+	case TypeDBPointer:
+		length, err = vr.peekLength()
+		length += 4 + 12 // string length + ObjectID length
+	case TypeDateTime, TypeDouble, TypeInt64, TypeTimestamp:
+		length = 8
+	case TypeDecimal128:
+		length = 16
+	case TypeInt32:
+		length = 4
+	case TypeJavaScript, TypeString, TypeSymbol:
+		length, err = vr.peekLength()
+		length += 4
+	case TypeMaxKey, TypeMinKey, TypeNull, TypeUndefined:
+		length = 0
+	case TypeObjectID:
+		length = 12
+	case TypeRegex:
+		for n := 0; n < 2; n++ { // Read two C strings.
+			str, err := vr.r.ReadBytes(0x00)
+			if err != nil {
+				return nil, err
+			}
+			dst = append(dst, str...)
+			vr.offset += int64(len(str))
+		}
+		return dst, nil
+	default:
+		return nil, fmt.Errorf("attempted to read bytes of unknown BSON type %v", vr.stack[vr.frame].vType)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	buf, err := vr.r.Peek(int(length))
+	if err != nil {
+		if err == bufio.ErrBufferFull {
+			temp := make([]byte, length)
+			if _, err = io.ReadFull(vr.r, temp); err != nil {
+				return nil, err
+			}
+			dst = append(dst, temp...)
+			vr.offset += int64(len(temp))
+			return dst, nil
+		}
+
+		return nil, err
+	}
+
+	dst = append(dst, buf...)
+	if _, err = vr.r.Discard(int(length)); err != nil {
+		return nil, err
+	}
+
+	vr.offset += int64(length)
+	return dst, nil
+}
+
+func (vr *valueReader) readValueBytes(dst []byte) (Type, []byte, error) {
+	switch vr.stack[vr.frame].mode {
+	case mTopLevel:
+		length, err := vr.peekLength()
+		if err != nil {
+			return Type(0), nil, err
+		}
+		dst, err = vr.appendBytes(dst, length)
+		if err != nil {
+			return Type(0), nil, err
+		}
+		return Type(0), dst, nil
+	case mElement, mValue:
+		dst, err := vr.appendNextElement(dst)
+		if err != nil {
+			return Type(0), dst, err
+		}
+
+		t := vr.stack[vr.frame].vType
+		err = vr.pop()
+		if err != nil {
+			return Type(0), nil, err
+		}
+		return t, dst, nil
+	default:
+		return Type(0), nil, vr.invalidTransitionErr(0, "ReadValueBytes", []mode{mElement, mValue})
+	}
+}
+
+func (vr *valueReader) Skip() error {
+	switch vr.stack[vr.frame].mode {
+	case mElement, mValue:
+	default:
+		return vr.invalidTransitionErr(0, "Skip", []mode{mElement, mValue})
+	}
+
+	_, err := vr.appendNextElement(nil)
+	if err != nil {
+		return err
+	}
+
+	return vr.pop()
+}
+
+func (vr *valueReader) ReadArray() (ArrayReader, error) {
+	if err := vr.ensureElementValue(TypeArray, mArray, "ReadArray"); err != nil {
+		return nil, err
+	}
+
+	err := vr.pushArray()
+	if err != nil {
+		return nil, err
+	}
+
+	return vr, nil
+}
+
+func (vr *valueReader) ReadBinary() (b []byte, btype byte, err error) {
+	if err := vr.ensureElementValue(TypeBinary, 0, "ReadBinary"); err != nil {
+		return nil, 0, err
+	}
+
+	length, err := vr.readLength()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	btype, err = vr.readByte()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	// Check length in case it is an old binary without a length.
+	if btype == 0x02 && length > 4 {
+		length, err = vr.readLength()
+		if err != nil {
+			return nil, 0, err
+		}
+	}
+
+	b = make([]byte, length)
+	err = vr.read(b)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	if err := vr.pop(); err != nil {
+		return nil, 0, err
+	}
+	return b, btype, nil
+}
+
+func (vr *valueReader) ReadBoolean() (bool, error) {
+	if err := vr.ensureElementValue(TypeBoolean, 0, "ReadBoolean"); err != nil {
+		return false, err
+	}
+
+	b, err := vr.readByte()
+	if err != nil {
+		return false, err
+	}
+
+	if b > 1 {
+		return false, fmt.Errorf("invalid byte for boolean, %b", b)
+	}
+
+	if err := vr.pop(); err != nil {
+		return false, err
+	}
+	return b == 1, nil
+}
+
+func (vr *valueReader) ReadDocument() (DocumentReader, error) {
+	switch vr.stack[vr.frame].mode {
+	case mTopLevel:
+		length, err := vr.readLength()
+		if err != nil {
+			return nil, err
+		}
+		if length <= 4 {
+			return nil, fmt.Errorf("invalid string length: %d", length)
+		}
+
+		vr.stack[vr.frame].end = int64(length) + vr.offset - 4
+		return vr, nil
+	case mElement, mValue:
+		if vr.stack[vr.frame].vType != TypeEmbeddedDocument {
+			return nil, vr.typeError(TypeEmbeddedDocument)
+		}
+	default:
+		return nil, vr.invalidTransitionErr(mDocument, "ReadDocument", []mode{mTopLevel, mElement, mValue})
+	}
+
+	err := vr.pushDocument()
+	if err != nil {
+		return nil, err
+	}
+
+	return vr, nil
+}
+
+func (vr *valueReader) ReadCodeWithScope() (code string, dr DocumentReader, err error) {
+	if err := vr.ensureElementValue(TypeCodeWithScope, 0, "ReadCodeWithScope"); err != nil {
+		return "", nil, err
+	}
+
+	totalLength, err := vr.readLength()
+	if err != nil {
+		return "", nil, err
+	}
+	strLength, err := vr.readLength()
+	if err != nil {
+		return "", nil, err
+	}
+	if strLength <= 0 {
+		return "", nil, fmt.Errorf("invalid string length: %d", strLength)
+	}
+	strBytes := make([]byte, strLength)
+	err = vr.read(strBytes)
+	if err != nil {
+		return "", nil, err
+	}
+	code = string(strBytes[:len(strBytes)-1])
+
+	size, err := vr.pushCodeWithScope()
+	if err != nil {
+		return "", nil, err
+	}
+
+	// The total length should equal:
+	// 4 (total length) + strLength + 4 (the length of str itself) + (document length)
+	componentsLength := int64(4+strLength+4) + size
+	if int64(totalLength) != componentsLength {
+		return "", nil, fmt.Errorf(
+			"length of CodeWithScope does not match lengths of components; total: %d; components: %d",
+			totalLength, componentsLength,
+		)
+	}
+	return code, vr, nil
+}
+
+func (vr *valueReader) ReadDBPointer() (ns string, oid ObjectID, err error) {
+	if err := vr.ensureElementValue(TypeDBPointer, 0, "ReadDBPointer"); err != nil {
+		return "", oid, err
+	}
+
+	ns, err = vr.readString()
+	if err != nil {
+		return "", oid, err
+	}
+
+	err = vr.read(oid[:])
+	if err != nil {
+		return "", ObjectID{}, err
+	}
+
+	if err := vr.pop(); err != nil {
+		return "", ObjectID{}, err
+	}
+	return ns, oid, nil
+}
+
+func (vr *valueReader) ReadDateTime() (int64, error) {
+	if err := vr.ensureElementValue(TypeDateTime, 0, "ReadDateTime"); err != nil {
+		return 0, err
+	}
+
+	i, err := vr.readi64()
+	if err != nil {
+		return 0, err
+	}
+
+	if err := vr.pop(); err != nil {
+		return 0, err
+	}
+	return i, nil
+}
+
+func (vr *valueReader) ReadDecimal128() (Decimal128, error) {
+	if err := vr.ensureElementValue(TypeDecimal128, 0, "ReadDecimal128"); err != nil {
+		return Decimal128{}, err
+	}
+
+	var b [16]byte
+	err := vr.read(b[:])
+	if err != nil {
+		return Decimal128{}, err
+	}
+
+	l := binary.LittleEndian.Uint64(b[0:8])
+	h := binary.LittleEndian.Uint64(b[8:16])
+
+	if err := vr.pop(); err != nil {
+		return Decimal128{}, err
+	}
+	return NewDecimal128(h, l), nil
+}
+
+func (vr *valueReader) ReadDouble() (float64, error) {
+	if err := vr.ensureElementValue(TypeDouble, 0, "ReadDouble"); err != nil {
+		return 0, err
+	}
+
+	u, err := vr.readu64()
+	if err != nil {
+		return 0, err
+	}
+
+	if err := vr.pop(); err != nil {
+		return 0, err
+	}
+	return math.Float64frombits(u), nil
+}
+
+func (vr *valueReader) ReadInt32() (int32, error) {
+	if err := vr.ensureElementValue(TypeInt32, 0, "ReadInt32"); err != nil {
+		return 0, err
+	}
+
+	if err := vr.pop(); err != nil {
+		return 0, err
+	}
+	return vr.readi32()
+}
+
+func (vr *valueReader) ReadInt64() (int64, error) {
+	if err := vr.ensureElementValue(TypeInt64, 0, "ReadInt64"); err != nil {
+		return 0, err
+	}
+
+	if err := vr.pop(); err != nil {
+		return 0, err
+	}
+	return vr.readi64()
+}
+
+func (vr *valueReader) ReadJavascript() (string, error) {
+	if err := vr.ensureElementValue(TypeJavaScript, 0, "ReadJavascript"); err != nil {
+		return "", err
+	}
+
+	if err := vr.pop(); err != nil {
+		return "", err
+	}
+	return vr.readString()
+}
+
+func (vr *valueReader) ReadMaxKey() error {
+	if err := vr.ensureElementValue(TypeMaxKey, 0, "ReadMaxKey"); err != nil {
+		return err
+	}
+
+	return vr.pop()
+}
+
+func (vr *valueReader) ReadMinKey() error {
+	if err := vr.ensureElementValue(TypeMinKey, 0, "ReadMinKey"); err != nil {
+		return err
+	}
+
+	return vr.pop()
+}
+
+func (vr *valueReader) ReadNull() error {
+	if err := vr.ensureElementValue(TypeNull, 0, "ReadNull"); err != nil {
+		return err
+	}
+
+	return vr.pop()
+}
+
+func (vr *valueReader) ReadObjectID() (ObjectID, error) {
+	if err := vr.ensureElementValue(TypeObjectID, 0, "ReadObjectID"); err != nil {
+		return ObjectID{}, err
+	}
+
+	var oid ObjectID
+	err := vr.read(oid[:])
+	if err != nil {
+		return ObjectID{}, err
+	}
+
+	if err := vr.pop(); err != nil {
+		return ObjectID{}, err
+	}
+	return oid, nil
+}
+
+func (vr *valueReader) ReadRegex() (string, string, error) {
+	if err := vr.ensureElementValue(TypeRegex, 0, "ReadRegex"); err != nil {
+		return "", "", err
+	}
+
+	pattern, err := vr.readCString()
+	if err != nil {
+		return "", "", err
+	}
+
+	options, err := vr.readCString()
+	if err != nil {
+		return "", "", err
+	}
+
+	if err := vr.pop(); err != nil {
+		return "", "", err
+	}
+	return pattern, options, nil
+}
+
+func (vr *valueReader) ReadString() (string, error) {
+	if err := vr.ensureElementValue(TypeString, 0, "ReadString"); err != nil {
+		return "", err
+	}
+
+	if err := vr.pop(); err != nil {
+		return "", err
+	}
+	return vr.readString()
+}
+
+func (vr *valueReader) ReadSymbol() (string, error) {
+	if err := vr.ensureElementValue(TypeSymbol, 0, "ReadSymbol"); err != nil {
+		return "", err
+	}
+
+	if err := vr.pop(); err != nil {
+		return "", err
+	}
+	return vr.readString()
+}
+
+func (vr *valueReader) ReadTimestamp() (t uint32, i uint32, err error) {
+	if err := vr.ensureElementValue(TypeTimestamp, 0, "ReadTimestamp"); err != nil {
+		return 0, 0, err
+	}
+
+	i, err = vr.readu32()
+	if err != nil {
+		return 0, 0, err
+	}
+
+	t, err = vr.readu32()
+	if err != nil {
+		return 0, 0, err
+	}
+
+	if err := vr.pop(); err != nil {
+		return 0, 0, err
+	}
+	return t, i, nil
+}
+
+func (vr *valueReader) ReadUndefined() error {
+	if err := vr.ensureElementValue(TypeUndefined, 0, "ReadUndefined"); err != nil {
+		return err
+	}
+
+	return vr.pop()
+}
+
+func (vr *valueReader) ReadElement() (string, ValueReader, error) {
+	switch vr.stack[vr.frame].mode {
+	case mTopLevel, mDocument, mCodeWithScope:
+	default:
+		return "", nil, vr.invalidTransitionErr(mElement, "ReadElement", []mode{mTopLevel, mDocument, mCodeWithScope})
+	}
+
+	t, err := vr.readByte()
+	if err != nil {
+		return "", nil, err
+	}
+
+	if t == 0 {
+		if vr.offset != vr.stack[vr.frame].end {
+			return "", nil, vr.invalidDocumentLengthError()
+		}
+
+		_ = vr.pop() // Ignore the error because the call here never reads from the underlying reader.
+		return "", nil, ErrEOD
+	}
+
+	name, err := vr.readCString()
+	if err != nil {
+		return "", nil, err
+	}
+
+	vr.pushElement(Type(t))
+	return name, vr, nil
+}
+
+func (vr *valueReader) ReadValue() (ValueReader, error) {
+	switch vr.stack[vr.frame].mode {
+	case mArray:
+	default:
+		return nil, vr.invalidTransitionErr(mValue, "ReadValue", []mode{mArray})
+	}
+
+	t, err := vr.readByte()
+	if err != nil {
+		return nil, err
+	}
+
+	if t == 0 {
+		if vr.offset != vr.stack[vr.frame].end {
+			return nil, vr.invalidDocumentLengthError()
+		}
+
+		_ = vr.pop() // Ignore the error because the call here never reads from the underlying reader.
+		return nil, ErrEOA
+	}
+
+	if _, err := vr.readCString(); err != nil {
+		return nil, err
+	}
+
+	vr.pushValue(Type(t))
+	return vr, nil
+}
+
+func (vr *valueReader) read(p []byte) error {
+	n, err := io.ReadFull(vr.r, p)
+	if err != nil {
+		return err
+	}
+	vr.offset += int64(n)
+	return nil
+}
+
+func (vr *valueReader) appendBytes(dst []byte, length int32) ([]byte, error) {
+	buf := make([]byte, length)
+	err := vr.read(buf)
+	if err != nil {
+		return nil, err
+	}
+	return append(dst, buf...), nil
+}
+
+func (vr *valueReader) readByte() (byte, error) {
+	b, err := vr.r.ReadByte()
+	if err != nil {
+		return 0x0, err
+	}
+	vr.offset++
+	return b, nil
+}
+
+func (vr *valueReader) readCString() (string, error) {
+	str, err := vr.r.ReadString(0x00)
+	if err != nil {
+		return "", err
+	}
+	l := len(str)
+	vr.offset += int64(l)
+	return str[:l-1], nil
+}
+
+func (vr *valueReader) readString() (string, error) {
+	length, err := vr.readLength()
+	if err != nil {
+		return "", err
+	}
+	if length <= 0 {
+		return "", fmt.Errorf("invalid string length: %d", length)
+	}
+
+	buf := make([]byte, length)
+	err = vr.read(buf)
+	if err != nil {
+		return "", err
+	}
+
+	if buf[length-1] != 0x00 {
+		return "", fmt.Errorf("string does not end with null byte, but with %v", buf[length-1])
+	}
+
+	return string(buf[:length-1]), nil
+}
+
+func (vr *valueReader) peekLength() (int32, error) {
+	buf, err := vr.r.Peek(4)
+	if err != nil {
+		return 0, err
+	}
+
+	return int32(binary.LittleEndian.Uint32(buf)), nil
+}
+
+func (vr *valueReader) readLength() (int32, error) {
+	l, err := vr.readi32()
+	if err != nil {
+		return 0, err
+	}
+	if l < 0 {
+		return 0, fmt.Errorf("invalid negative length: %d", l)
+	}
+	return l, nil
+}
+
+func (vr *valueReader) readi32() (int32, error) {
+	var buf [4]byte
+	err := vr.read(buf[:])
+	if err != nil {
+		return 0, err
+	}
+
+	return int32(binary.LittleEndian.Uint32(buf[:])), nil
+}
+
+func (vr *valueReader) readu32() (uint32, error) {
+	var buf [4]byte
+	err := vr.read(buf[:])
+	if err != nil {
+		return 0, err
+	}
+
+	return binary.LittleEndian.Uint32(buf[:]), nil
+}
+
+func (vr *valueReader) readi64() (int64, error) {
+	var buf [8]byte
+	err := vr.read(buf[:])
+	if err != nil {
+		return 0, err
+	}
+
+	return int64(binary.LittleEndian.Uint64(buf[:])), nil
+}
+
+func (vr *valueReader) readu64() (uint64, error) {
+	var buf [8]byte
+	err := vr.read(buf[:])
+	if err != nil {
+		return 0, err
+	}
+
+	return binary.LittleEndian.Uint64(buf[:]), nil
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/value_writer.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/value_writer.go
new file mode 100644
index 00000000..2748696f
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/value_writer.go
@@ -0,0 +1,600 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"strconv"
+	"strings"
+	"sync"
+
+	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
+)
+
+var _ ValueWriter = &valueWriter{}
+
+var vwPool = sync.Pool{
+	New: func() interface{} {
+		return new(valueWriter)
+	},
+}
+
+func putValueWriter(vw *valueWriter) {
+	if vw != nil {
+		vw.w = nil // don't leak the writer
+		vwPool.Put(vw)
+	}
+}
+
+var documentWriterPool = sync.Pool{
+	New: func() interface{} {
+		return newDocumentWriter(nil)
+	},
+}
+
+func getDocumentWriter(w io.Writer) *valueWriter {
+	vw := documentWriterPool.Get().(*valueWriter)
+
+	vw.reset(vw.buf)
+	vw.buf = vw.buf[:0]
+	vw.w = w
+
+	return vw
+}
+
+func putDocumentWriter(vw *valueWriter) {
+	if vw != nil {
+		vw.w = nil // don't leak the writer
+		documentWriterPool.Put(vw)
+	}
+}
+
+// This is here so that during testing we can change it and not require
+// allocating a 4GB slice.
+var maxSize = math.MaxInt32
+
+type errMaxDocumentSizeExceeded struct {
+	size int64
+}
+
+func (mdse errMaxDocumentSizeExceeded) Error() string {
+	return fmt.Sprintf("document size (%d) is larger than the max int32", mdse.size)
+}
+
+type vwMode int
+
+const (
+	_ vwMode = iota
+	vwTopLevel
+	vwDocument
+	vwArray
+	vwValue
+	vwElement
+	vwCodeWithScope
+)
+
+func (vm vwMode) String() string {
+	var str string
+
+	switch vm {
+	case vwTopLevel:
+		str = "TopLevel"
+	case vwDocument:
+		str = "DocumentMode"
+	case vwArray:
+		str = "ArrayMode"
+	case vwValue:
+		str = "ValueMode"
+	case vwElement:
+		str = "ElementMode"
+	case vwCodeWithScope:
+		str = "CodeWithScopeMode"
+	default:
+		str = "UnknownMode"
+	}
+
+	return str
+}
+
+type vwState struct {
+	mode   mode
+	key    string
+	arrkey int
+	start  int32
+}
+
+type valueWriter struct {
+	w   io.Writer
+	buf []byte
+
+	stack []vwState
+	frame int64
+}
+
+func (vw *valueWriter) advanceFrame() {
+	vw.frame++
+	if vw.frame >= int64(len(vw.stack)) {
+		vw.stack = append(vw.stack, vwState{})
+	}
+}
+
+func (vw *valueWriter) push(m mode) {
+	vw.advanceFrame()
+
+	// Clean the stack
+	vw.stack[vw.frame] = vwState{mode: m}
+
+	switch m {
+	case mDocument, mArray, mCodeWithScope:
+		vw.reserveLength() // WARN: this is not needed
+	}
+}
+
+func (vw *valueWriter) reserveLength() {
+	vw.stack[vw.frame].start = int32(len(vw.buf))
+	vw.buf = append(vw.buf, 0x00, 0x00, 0x00, 0x00)
+}
+
+func (vw *valueWriter) pop() {
+	switch vw.stack[vw.frame].mode {
+	case mElement, mValue:
+		vw.frame--
+	case mDocument, mArray, mCodeWithScope:
+		vw.frame -= 2 // we pop twice to jump over the mElement: mDocument -> mElement -> mDocument/mTopLevel/etc...
+	}
+}
+
+// NewDocumentWriter creates a ValueWriter that writes BSON to w.
+//
+// This ValueWriter will only write entire documents to the io.Writer and it
+// will buffer the document as it is built.
+func NewDocumentWriter(w io.Writer) ValueWriter {
+	return newDocumentWriter(w)
+}
+
+func newDocumentWriter(w io.Writer) *valueWriter {
+	vw := new(valueWriter)
+	stack := make([]vwState, 1, 5)
+	stack[0] = vwState{mode: mTopLevel}
+	vw.w = w
+	vw.stack = stack
+
+	return vw
+}
+
+func newValueWriterFromSlice(buf []byte) *valueWriter {
+	vw := new(valueWriter)
+	stack := make([]vwState, 1, 5)
+	stack[0] = vwState{mode: mTopLevel}
+	vw.stack = stack
+	vw.buf = buf
+
+	return vw
+}
+
+func (vw *valueWriter) reset(buf []byte) {
+	if vw.stack == nil {
+		vw.stack = make([]vwState, 1, 5)
+	}
+	vw.stack = vw.stack[:1]
+	vw.stack[0] = vwState{mode: mTopLevel}
+	vw.buf = buf
+	vw.frame = 0
+	vw.w = nil
+}
+
+func (vw *valueWriter) invalidTransitionError(destination mode, name string, modes []mode) error {
+	te := TransitionError{
+		name:        name,
+		current:     vw.stack[vw.frame].mode,
+		destination: destination,
+		modes:       modes,
+		action:      "write",
+	}
+	if vw.frame != 0 {
+		te.parent = vw.stack[vw.frame-1].mode
+	}
+	return te
+}
+
+func (vw *valueWriter) writeElementHeader(t Type, destination mode, callerName string, addmodes ...mode) error {
+	frame := &vw.stack[vw.frame]
+	switch frame.mode {
+	case mElement:
+		key := frame.key
+		if !isValidCString(key) {
+			return errors.New("BSON element key cannot contain null bytes")
+		}
+		vw.appendHeader(t, key)
+	case mValue:
+		vw.appendIntHeader(t, frame.arrkey)
+	default:
+		modes := []mode{mElement, mValue}
+		if addmodes != nil {
+			modes = append(modes, addmodes...)
+		}
+		return vw.invalidTransitionError(destination, callerName, modes)
+	}
+
+	return nil
+}
+
+func (vw *valueWriter) writeValueBytes(t Type, b []byte) error {
+	if err := vw.writeElementHeader(t, mode(0), "WriteValueBytes"); err != nil {
+		return err
+	}
+	vw.buf = append(vw.buf, b...)
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteArray() (ArrayWriter, error) {
+	if err := vw.writeElementHeader(TypeArray, mArray, "WriteArray"); err != nil {
+		return nil, err
+	}
+
+	vw.push(mArray)
+
+	return vw, nil
+}
+
+func (vw *valueWriter) WriteBinary(b []byte) error {
+	return vw.WriteBinaryWithSubtype(b, 0x00)
+}
+
+func (vw *valueWriter) WriteBinaryWithSubtype(b []byte, btype byte) error {
+	if err := vw.writeElementHeader(TypeBinary, mode(0), "WriteBinaryWithSubtype"); err != nil {
+		return err
+	}
+
+	vw.buf = bsoncore.AppendBinary(vw.buf, btype, b)
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteBoolean(b bool) error {
+	if err := vw.writeElementHeader(TypeBoolean, mode(0), "WriteBoolean"); err != nil {
+		return err
+	}
+
+	vw.buf = bsoncore.AppendBoolean(vw.buf, b)
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteCodeWithScope(code string) (DocumentWriter, error) {
+	if err := vw.writeElementHeader(TypeCodeWithScope, mCodeWithScope, "WriteCodeWithScope"); err != nil {
+		return nil, err
+	}
+
+	// CodeWithScope is a different than other types because we need an extra
+	// frame on the stack. In the EndDocument code, we write the document
+	// length, pop, write the code with scope length, and pop. To simplify the
+	// pop code, we push a spacer frame that we'll always jump over.
+	vw.push(mCodeWithScope)
+	vw.buf = bsoncore.AppendString(vw.buf, code)
+	vw.push(mSpacer)
+	vw.push(mDocument)
+
+	return vw, nil
+}
+
+func (vw *valueWriter) WriteDBPointer(ns string, oid ObjectID) error {
+	if err := vw.writeElementHeader(TypeDBPointer, mode(0), "WriteDBPointer"); err != nil {
+		return err
+	}
+
+	vw.buf = bsoncore.AppendDBPointer(vw.buf, ns, oid)
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteDateTime(dt int64) error {
+	if err := vw.writeElementHeader(TypeDateTime, mode(0), "WriteDateTime"); err != nil {
+		return err
+	}
+
+	vw.buf = bsoncore.AppendDateTime(vw.buf, dt)
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteDecimal128(d128 Decimal128) error {
+	if err := vw.writeElementHeader(TypeDecimal128, mode(0), "WriteDecimal128"); err != nil {
+		return err
+	}
+
+	h, l := d128.GetBytes()
+	vw.buf = bsoncore.AppendDecimal128(vw.buf, h, l)
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteDouble(f float64) error {
+	if err := vw.writeElementHeader(TypeDouble, mode(0), "WriteDouble"); err != nil {
+		return err
+	}
+
+	vw.buf = bsoncore.AppendDouble(vw.buf, f)
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteInt32(i32 int32) error {
+	if err := vw.writeElementHeader(TypeInt32, mode(0), "WriteInt32"); err != nil {
+		return err
+	}
+
+	vw.buf = bsoncore.AppendInt32(vw.buf, i32)
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteInt64(i64 int64) error {
+	if err := vw.writeElementHeader(TypeInt64, mode(0), "WriteInt64"); err != nil {
+		return err
+	}
+
+	vw.buf = bsoncore.AppendInt64(vw.buf, i64)
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteJavascript(code string) error {
+	if err := vw.writeElementHeader(TypeJavaScript, mode(0), "WriteJavascript"); err != nil {
+		return err
+	}
+
+	vw.buf = bsoncore.AppendJavaScript(vw.buf, code)
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteMaxKey() error {
+	if err := vw.writeElementHeader(TypeMaxKey, mode(0), "WriteMaxKey"); err != nil {
+		return err
+	}
+
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteMinKey() error {
+	if err := vw.writeElementHeader(TypeMinKey, mode(0), "WriteMinKey"); err != nil {
+		return err
+	}
+
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteNull() error {
+	if err := vw.writeElementHeader(TypeNull, mode(0), "WriteNull"); err != nil {
+		return err
+	}
+
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteObjectID(oid ObjectID) error {
+	if err := vw.writeElementHeader(TypeObjectID, mode(0), "WriteObjectID"); err != nil {
+		return err
+	}
+
+	vw.buf = bsoncore.AppendObjectID(vw.buf, oid)
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteRegex(pattern string, options string) error {
+	if !isValidCString(pattern) || !isValidCString(options) {
+		return errors.New("BSON regex values cannot contain null bytes")
+	}
+	if err := vw.writeElementHeader(TypeRegex, mode(0), "WriteRegex"); err != nil {
+		return err
+	}
+
+	vw.buf = bsoncore.AppendRegex(vw.buf, pattern, sortStringAlphebeticAscending(options))
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteString(s string) error {
+	if err := vw.writeElementHeader(TypeString, mode(0), "WriteString"); err != nil {
+		return err
+	}
+
+	vw.buf = bsoncore.AppendString(vw.buf, s)
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteDocument() (DocumentWriter, error) {
+	if vw.stack[vw.frame].mode == mTopLevel {
+		vw.reserveLength()
+		return vw, nil
+	}
+	if err := vw.writeElementHeader(TypeEmbeddedDocument, mDocument, "WriteDocument", mTopLevel); err != nil {
+		return nil, err
+	}
+
+	vw.push(mDocument)
+	return vw, nil
+}
+
+func (vw *valueWriter) WriteSymbol(symbol string) error {
+	if err := vw.writeElementHeader(TypeSymbol, mode(0), "WriteSymbol"); err != nil {
+		return err
+	}
+
+	vw.buf = bsoncore.AppendSymbol(vw.buf, symbol)
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteTimestamp(t uint32, i uint32) error {
+	if err := vw.writeElementHeader(TypeTimestamp, mode(0), "WriteTimestamp"); err != nil {
+		return err
+	}
+
+	vw.buf = bsoncore.AppendTimestamp(vw.buf, t, i)
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteUndefined() error {
+	if err := vw.writeElementHeader(TypeUndefined, mode(0), "WriteUndefined"); err != nil {
+		return err
+	}
+
+	vw.pop()
+	return nil
+}
+
+func (vw *valueWriter) WriteDocumentElement(key string) (ValueWriter, error) {
+	switch vw.stack[vw.frame].mode {
+	case mTopLevel, mDocument:
+	default:
+		return nil, vw.invalidTransitionError(mElement, "WriteDocumentElement", []mode{mTopLevel, mDocument})
+	}
+
+	vw.push(mElement)
+	vw.stack[vw.frame].key = key
+
+	return vw, nil
+}
+
+func (vw *valueWriter) WriteDocumentEnd() error {
+	switch vw.stack[vw.frame].mode {
+	case mTopLevel, mDocument:
+	default:
+		return fmt.Errorf("incorrect mode to end document: %s", vw.stack[vw.frame].mode)
+	}
+
+	vw.buf = append(vw.buf, 0x00)
+
+	err := vw.writeLength()
+	if err != nil {
+		return err
+	}
+
+	if vw.stack[vw.frame].mode == mTopLevel {
+		if err = vw.Flush(); err != nil {
+			return err
+		}
+	}
+
+	vw.pop()
+
+	if vw.stack[vw.frame].mode == mCodeWithScope {
+		// We ignore the error here because of the guarantee of writeLength.
+		// See the docs for writeLength for more info.
+		_ = vw.writeLength()
+		vw.pop()
+	}
+	return nil
+}
+
+func (vw *valueWriter) Flush() error {
+	if vw.w == nil {
+		return nil
+	}
+
+	if _, err := vw.w.Write(vw.buf); err != nil {
+		return err
+	}
+	// reset buffer
+	vw.buf = vw.buf[:0]
+	return nil
+}
+
+func (vw *valueWriter) WriteArrayElement() (ValueWriter, error) {
+	if vw.stack[vw.frame].mode != mArray {
+		return nil, vw.invalidTransitionError(mValue, "WriteArrayElement", []mode{mArray})
+	}
+
+	arrkey := vw.stack[vw.frame].arrkey
+	vw.stack[vw.frame].arrkey++
+
+	vw.push(mValue)
+	vw.stack[vw.frame].arrkey = arrkey
+
+	return vw, nil
+}
+
+func (vw *valueWriter) WriteArrayEnd() error {
+	if vw.stack[vw.frame].mode != mArray {
+		return fmt.Errorf("incorrect mode to end array: %s", vw.stack[vw.frame].mode)
+	}
+
+	vw.buf = append(vw.buf, 0x00)
+
+	err := vw.writeLength()
+	if err != nil {
+		return err
+	}
+
+	vw.pop()
+	return nil
+}
+
+// NOTE: We assume that if we call writeLength more than once the same function
+// within the same function without altering the vw.buf that this method will
+// not return an error. If this changes ensure that the following methods are
+// updated:
+//
+// - WriteDocumentEnd
+func (vw *valueWriter) writeLength() error {
+	length := len(vw.buf)
+	if length > maxSize {
+		return errMaxDocumentSizeExceeded{size: int64(len(vw.buf))}
+	}
+	frame := &vw.stack[vw.frame]
+	length -= int(frame.start)
+	start := frame.start
+
+	_ = vw.buf[start+3] // BCE
+	vw.buf[start+0] = byte(length)
+	vw.buf[start+1] = byte(length >> 8)
+	vw.buf[start+2] = byte(length >> 16)
+	vw.buf[start+3] = byte(length >> 24)
+	return nil
+}
+
+func isValidCString(cs string) bool {
+	// Disallow the zero byte in a cstring because the zero byte is used as the
+	// terminating character.
+	//
+	// It's safe to check bytes instead of runes because all multibyte UTF-8
+	// code points start with (binary) 11xxxxxx or 10xxxxxx, so 00000000 (i.e.
+	// 0) will never be part of a multibyte UTF-8 code point. This logic is the
+	// same as the "r < utf8.RuneSelf" case in strings.IndexRune but can be
+	// inlined.
+	//
+	// https://cs.opensource.google/go/go/+/refs/tags/go1.21.1:src/strings/strings.go;l=127
+	return strings.IndexByte(cs, 0) == -1
+}
+
+// appendHeader is the same as bsoncore.AppendHeader but does not check if the
+// key is a valid C string since the caller has already checked for that.
+//
+// The caller of this function must check if key is a valid C string.
+func (vw *valueWriter) appendHeader(t Type, key string) {
+	vw.buf = bsoncore.AppendType(vw.buf, bsoncore.Type(t))
+	vw.buf = append(vw.buf, key...)
+	vw.buf = append(vw.buf, 0x00)
+}
+
+func (vw *valueWriter) appendIntHeader(t Type, key int) {
+	vw.buf = bsoncore.AppendType(vw.buf, bsoncore.Type(t))
+	vw.buf = strconv.AppendInt(vw.buf, int64(key), 10)
+	vw.buf = append(vw.buf, 0x00)
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/vector.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/vector.go
new file mode 100644
index 00000000..31a10bd5
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/vector.go
@@ -0,0 +1,268 @@
+// Copyright (C) MongoDB, Inc. 2024-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"math"
+)
+
+// BSON binary vector types as described in https://bsonspec.org/spec.html.
+const (
+	Int8Vector      byte = 0x03
+	Float32Vector   byte = 0x27
+	PackedBitVector byte = 0x10
+)
+
+// These are vector conversion errors.
+var (
+	errInsufficientVectorData = errors.New("insufficient data")
+	errNonZeroVectorPadding   = errors.New("padding must be 0")
+	errVectorPaddingTooLarge  = errors.New("padding cannot be larger than 7")
+)
+
+type vectorTypeError struct {
+	Method string
+	Type   byte
+}
+
+// Error implements the error interface.
+func (vte vectorTypeError) Error() string {
+	t := "invalid"
+	switch vte.Type {
+	case Int8Vector:
+		t = "int8"
+	case Float32Vector:
+		t = "float32"
+	case PackedBitVector:
+		t = "packed bit"
+	}
+	return fmt.Sprintf("cannot call %s, on a type %s vector", vte.Method, t)
+}
+
+// Vector represents a densely packed array of numbers / bits.
+type Vector struct {
+	dType       byte
+	int8Data    []int8
+	float32Data []float32
+	bitData     []byte
+	bitPadding  uint8
+}
+
+// Type returns the vector type.
+func (v Vector) Type() byte {
+	return v.dType
+}
+
+// Int8 returns the int8 slice hold by the vector.
+// It panics if v is not an int8 vector.
+func (v Vector) Int8() []int8 {
+	d, ok := v.Int8OK()
+	if !ok {
+		panic(vectorTypeError{"bson.Vector.Int8", v.dType})
+	}
+	return d
+}
+
+// Int8OK is the same as Int8, but returns a boolean instead of panicking.
+func (v Vector) Int8OK() ([]int8, bool) {
+	if v.dType != Int8Vector {
+		return nil, false
+	}
+	return v.int8Data, true
+}
+
+// Float32 returns the float32 slice hold by the vector.
+// It panics if v is not a float32 vector.
+func (v Vector) Float32() []float32 {
+	d, ok := v.Float32OK()
+	if !ok {
+		panic(vectorTypeError{"bson.Vector.Float32", v.dType})
+	}
+	return d
+}
+
+// Float32OK is the same as Float32, but returns a boolean instead of panicking.
+func (v Vector) Float32OK() ([]float32, bool) {
+	if v.dType != Float32Vector {
+		return nil, false
+	}
+	return v.float32Data, true
+}
+
+// PackedBit returns the byte slice representing the binary quantized (packed bit) vector and the byte padding, which
+// is the number of bits in the final byte that are to be ignored.
+// It panics if v is not a packed bit vector.
+func (v Vector) PackedBit() ([]byte, uint8) {
+	d, p, ok := v.PackedBitOK()
+	if !ok {
+		panic(vectorTypeError{"bson.Vector.PackedBit", v.dType})
+	}
+	return d, p
+}
+
+// PackedBitOK is the same as PackedBit, but returns a boolean instead of panicking.
+func (v Vector) PackedBitOK() ([]byte, uint8, bool) {
+	if v.dType != PackedBitVector {
+		return nil, 0, false
+	}
+	return v.bitData, v.bitPadding, true
+}
+
+// Binary returns the BSON Binary representation of the Vector.
+func (v Vector) Binary() Binary {
+	switch v.Type() {
+	case Int8Vector:
+		return binaryFromInt8Vector(v.Int8())
+	case Float32Vector:
+		return binaryFromFloat32Vector(v.Float32())
+	case PackedBitVector:
+		return binaryFromBitVector(v.PackedBit())
+	default:
+		panic(fmt.Sprintf("invalid Vector data type: %d", v.dType))
+	}
+}
+
+func binaryFromInt8Vector(v []int8) Binary {
+	data := make([]byte, len(v)+2)
+	data[0] = Int8Vector
+	data[1] = 0
+
+	for i, e := range v {
+		data[i+2] = byte(e)
+	}
+
+	return Binary{
+		Subtype: TypeBinaryVector,
+		Data:    data,
+	}
+}
+
+func binaryFromFloat32Vector(v []float32) Binary {
+	data := make([]byte, 2, len(v)*4+2)
+	data[0] = Float32Vector
+	data[1] = 0
+	var a [4]byte
+	for _, e := range v {
+		binary.LittleEndian.PutUint32(a[:], math.Float32bits(e))
+		data = append(data, a[:]...)
+	}
+
+	return Binary{
+		Subtype: TypeBinaryVector,
+		Data:    data,
+	}
+}
+
+func binaryFromBitVector(bits []byte, padding uint8) Binary {
+	data := make([]byte, len(bits)+2)
+	data[0] = PackedBitVector
+	data[1] = padding
+	copy(data[2:], bits)
+	return Binary{
+		Subtype: TypeBinaryVector,
+		Data:    data,
+	}
+}
+
+// NewVector constructs a Vector from a slice of int8 or float32.
+func NewVector[T int8 | float32](data []T) Vector {
+	var v Vector
+	switch a := any(data).(type) {
+	case []int8:
+		v.dType = Int8Vector
+		v.int8Data = make([]int8, len(data))
+		copy(v.int8Data, a)
+	case []float32:
+		v.dType = Float32Vector
+		v.float32Data = make([]float32, len(data))
+		copy(v.float32Data, a)
+	default:
+		panic(fmt.Errorf("unsupported type %T", data))
+	}
+	return v
+}
+
+// NewPackedBitVector constructs a Vector from a byte slice and a value of byte padding.
+func NewPackedBitVector(bits []byte, padding uint8) (Vector, error) {
+	var v Vector
+	if padding > 7 {
+		return v, errVectorPaddingTooLarge
+	}
+	if padding > 0 && len(bits) == 0 {
+		return v, errNonZeroVectorPadding
+	}
+	v.dType = PackedBitVector
+	v.bitData = make([]byte, len(bits))
+	copy(v.bitData, bits)
+	v.bitPadding = padding
+	return v, nil
+}
+
+// NewVectorFromBinary unpacks a BSON Binary into a Vector.
+func NewVectorFromBinary(b Binary) (Vector, error) {
+	var v Vector
+	if b.Subtype != TypeBinaryVector {
+		return v, errors.New("not a vector")
+	}
+	if len(b.Data) < 2 {
+		return v, errInsufficientVectorData
+	}
+	switch t := b.Data[0]; t {
+	case Int8Vector:
+		return newInt8Vector(b.Data[1:])
+	case Float32Vector:
+		return newFloat32Vector(b.Data[1:])
+	case PackedBitVector:
+		return newBitVector(b.Data[1:])
+	default:
+		return v, fmt.Errorf("invalid Vector data type: %d", t)
+	}
+}
+
+func newInt8Vector(b []byte) (Vector, error) {
+	var v Vector
+	if len(b) == 0 {
+		return v, errInsufficientVectorData
+	}
+	if padding := b[0]; padding > 0 {
+		return v, errNonZeroVectorPadding
+	}
+	s := make([]int8, 0, len(b)-1)
+	for i := 1; i < len(b); i++ {
+		s = append(s, int8(b[i]))
+	}
+	return NewVector(s), nil
+}
+
+func newFloat32Vector(b []byte) (Vector, error) {
+	var v Vector
+	if len(b) == 0 {
+		return v, errInsufficientVectorData
+	}
+	if padding := b[0]; padding > 0 {
+		return v, errNonZeroVectorPadding
+	}
+	l := (len(b) - 1) / 4
+	if l*4 != len(b)-1 {
+		return v, errInsufficientVectorData
+	}
+	s := make([]float32, 0, l)
+	for i := 1; i < len(b); i += 4 {
+		s = append(s, math.Float32frombits(binary.LittleEndian.Uint32(b[i:i+4])))
+	}
+	return NewVector(s), nil
+}
+
+func newBitVector(b []byte) (Vector, error) {
+	if len(b) == 0 {
+		return Vector{}, errInsufficientVectorData
+	}
+	return NewPackedBitVector(b[1:], b[0])
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/writer.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/writer.go
new file mode 100644
index 00000000..84cad0dd
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/bson/writer.go
@@ -0,0 +1,61 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+// ArrayWriter is the interface used to create a BSON or BSON adjacent array.
+// Callers must ensure they call WriteArrayEnd when they have finished creating
+// the array.
+type ArrayWriter interface {
+	WriteArrayElement() (ValueWriter, error)
+	WriteArrayEnd() error
+}
+
+// DocumentWriter is the interface used to create a BSON or BSON adjacent
+// document. Callers must ensure they call WriteDocumentEnd when they have
+// finished creating the document.
+type DocumentWriter interface {
+	WriteDocumentElement(string) (ValueWriter, error)
+	WriteDocumentEnd() error
+}
+
+// ValueWriter is the interface used to write BSON values. Implementations of
+// this interface handle creating BSON or BSON adjacent representations of the
+// values.
+type ValueWriter interface {
+	WriteArray() (ArrayWriter, error)
+	WriteBinary(b []byte) error
+	WriteBinaryWithSubtype(b []byte, btype byte) error
+	WriteBoolean(bool) error
+	WriteCodeWithScope(code string) (DocumentWriter, error)
+	WriteDBPointer(ns string, oid ObjectID) error
+	WriteDateTime(dt int64) error
+	WriteDecimal128(Decimal128) error
+	WriteDouble(float64) error
+	WriteInt32(int32) error
+	WriteInt64(int64) error
+	WriteJavascript(code string) error
+	WriteMaxKey() error
+	WriteMinKey() error
+	WriteNull() error
+	WriteObjectID(ObjectID) error
+	WriteRegex(pattern, options string) error
+	WriteString(string) error
+	WriteDocument() (DocumentWriter, error)
+	WriteSymbol(symbol string) error
+	WriteTimestamp(t, i uint32) error
+	WriteUndefined() error
+}
+
+// sliceWriter allows a pointer to a slice of bytes to be used as an io.Writer.
+type sliceWriter []byte
+
+// Write writes the bytes to the underlying slice.
+func (sw *sliceWriter) Write(p []byte) (int, error) {
+	written := len(p)
+	*sw = append(*sw, p...)
+	return written, nil
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/internal/bsoncoreutil/bsoncoreutil.go b/vendor/go.mongodb.org/mongo-driver/v2/internal/bsoncoreutil/bsoncoreutil.go
new file mode 100644
index 00000000..ff0f6493
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/internal/bsoncoreutil/bsoncoreutil.go
@@ -0,0 +1,40 @@
+// Copyright (C) MongoDB, Inc. 2024-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bsoncoreutil
+
+// Truncate truncates a given string for a certain width
+func Truncate(str string, width int) string {
+	if width == 0 {
+		return ""
+	}
+
+	if len(str) <= width {
+		return str
+	}
+
+	// Truncate the byte slice of the string to the given width.
+	newStr := str[:width]
+
+	// Check if the last byte is at the beginning of a multi-byte character.
+	// If it is, then remove the last byte.
+	if newStr[len(newStr)-1]&0xC0 == 0xC0 {
+		return newStr[:len(newStr)-1]
+	}
+
+	// Check if the last byte is a multi-byte character
+	if newStr[len(newStr)-1]&0xC0 == 0x80 {
+		// If it is, step back until you we are at the start of a character
+		for i := len(newStr) - 1; i >= 0; i-- {
+			if newStr[i]&0xC0 == 0xC0 {
+				// Truncate at the end of the character before the character we stepped back to
+				return newStr[:i]
+			}
+		}
+	}
+
+	return newStr
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/internal/decimal128/decinal128.go b/vendor/go.mongodb.org/mongo-driver/v2/internal/decimal128/decinal128.go
new file mode 100644
index 00000000..2767e445
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/internal/decimal128/decinal128.go
@@ -0,0 +1,117 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package decimal128
+
+import (
+	"strconv"
+)
+
+// These constants are the maximum and minimum values for the exponent field in a decimal128 value.
+const (
+	MaxDecimal128Exp = 6111
+	MinDecimal128Exp = -6176
+)
+
+func divmod(h, l uint64, div uint32) (qh, ql uint64, rem uint32) {
+	div64 := uint64(div)
+	a := h >> 32
+	aq := a / div64
+	ar := a % div64
+	b := ar<<32 + h&(1<<32-1)
+	bq := b / div64
+	br := b % div64
+	c := br<<32 + l>>32
+	cq := c / div64
+	cr := c % div64
+	d := cr<<32 + l&(1<<32-1)
+	dq := d / div64
+	dr := d % div64
+	return (aq<<32 | bq), (cq<<32 | dq), uint32(dr)
+}
+
+// String returns a string representation of the decimal value.
+func String(h, l uint64) string {
+	var posSign int      // positive sign
+	var exp int          // exponent
+	var high, low uint64 // significand high/low
+
+	if h>>63&1 == 0 {
+		posSign = 1
+	}
+
+	switch h >> 58 & (1<<5 - 1) {
+	case 0x1F:
+		return "NaN"
+	case 0x1E:
+		return "-Infinity"[posSign:]
+	}
+
+	low = l
+	if h>>61&3 == 3 {
+		// Bits: 1*sign 2*ignored 14*exponent 111*significand.
+		// Implicit 0b100 prefix in significand.
+		exp = int(h >> 47 & (1<<14 - 1))
+		// Spec says all of these values are out of range.
+		high, low = 0, 0
+	} else {
+		// Bits: 1*sign 14*exponent 113*significand
+		exp = int(h >> 49 & (1<<14 - 1))
+		high = h & (1<<49 - 1)
+	}
+	exp += MinDecimal128Exp
+
+	// Would be handled by the logic below, but that's trivial and common.
+	if high == 0 && low == 0 && exp == 0 {
+		return "-0"[posSign:]
+	}
+
+	var repr [48]byte // Loop 5 times over 9 digits plus dot, negative sign, and leading zero.
+	var last = len(repr)
+	var i = len(repr)
+	var dot = len(repr) + exp
+	var rem uint32
+Loop:
+	for d9 := 0; d9 < 5; d9++ {
+		high, low, rem = divmod(high, low, 1e9)
+		for d1 := 0; d1 < 9; d1++ {
+			// Handle "-0.0", "0.00123400", "-1.00E-6", "1.050E+3", etc.
+			if i < len(repr) && (dot == i || low == 0 && high == 0 && rem > 0 && rem < 10 && (dot < i-6 || exp > 0)) {
+				exp += len(repr) - i
+				i--
+				repr[i] = '.'
+				last = i - 1
+				dot = len(repr) // Unmark.
+			}
+			c := '0' + byte(rem%10)
+			rem /= 10
+			i--
+			repr[i] = c
+			// Handle "0E+3", "1E+3", etc.
+			if low == 0 && high == 0 && rem == 0 && i == len(repr)-1 && (dot < i-5 || exp > 0) {
+				last = i
+				break Loop
+			}
+			if c != '0' {
+				last = i
+			}
+			// Break early. Works without it, but why.
+			if dot > i && low == 0 && high == 0 && rem == 0 {
+				break Loop
+			}
+		}
+	}
+	repr[last-1] = '-'
+	last--
+
+	if exp > 0 {
+		return string(repr[last+posSign:]) + "E+" + strconv.Itoa(exp)
+	}
+	if exp < 0 {
+		return string(repr[last+posSign:]) + "E" + strconv.Itoa(exp)
+	}
+	return string(repr[last+posSign:])
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/array.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/array.go
new file mode 100644
index 00000000..0efbdc0f
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/array.go
@@ -0,0 +1,185 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bsoncore
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"strconv"
+	"strings"
+)
+
+// NewArrayLengthError creates and returns an error for when the length of an array exceeds the
+// bytes available.
+func NewArrayLengthError(length, rem int) error {
+	return lengthError("array", length, rem)
+}
+
+// Array is a raw bytes representation of a BSON array.
+type Array []byte
+
+// NewArrayFromReader reads an array from r. This function will only validate the length is
+// correct and that the array ends with a null byte.
+func NewArrayFromReader(r io.Reader) (Array, error) {
+	return newBufferFromReader(r)
+}
+
+// Index searches for and retrieves the value at the given index. This method will panic if
+// the array is invalid or if the index is out of bounds.
+func (a Array) Index(index uint) Value {
+	value, err := a.IndexErr(index)
+	if err != nil {
+		panic(err)
+	}
+	return value
+}
+
+// IndexErr searches for and retrieves the value at the given index.
+func (a Array) IndexErr(index uint) (Value, error) {
+	elem, err := indexErr(a, index)
+	if err != nil {
+		return Value{}, err
+	}
+	return elem.Value(), err
+}
+
+// DebugString outputs a human readable version of Array. It will attempt to stringify the
+// valid components of the array even if the entire array is not valid.
+func (a Array) DebugString() string {
+	if len(a) < 5 {
+		return "<malformed>"
+	}
+	var buf strings.Builder
+	buf.WriteString("Array")
+	length, rem, _ := ReadLength(a) // We know we have enough bytes to read the length
+	buf.WriteByte('(')
+	buf.WriteString(strconv.Itoa(int(length)))
+	length -= 4
+	buf.WriteString(")[")
+	var elem Element
+	var ok bool
+	for length > 1 {
+		elem, rem, ok = ReadElement(rem)
+		length -= int32(len(elem))
+		if !ok {
+			buf.WriteString(fmt.Sprintf("<malformed (%d)>", length))
+			break
+		}
+		buf.WriteString(elem.Value().DebugString())
+		if length != 1 {
+			buf.WriteByte(',')
+		}
+	}
+	buf.WriteByte(']')
+
+	return buf.String()
+}
+
+// String outputs an ExtendedJSON version of Array. If the Array is not valid, this method
+// returns an empty string.
+func (a Array) String() string {
+	return a.StringN(math.MaxInt)
+}
+
+// StringN stringifies an array upto N bytes
+func (a Array) StringN(n int) string {
+	if lens, _, _ := ReadLength(a); lens < 5 || n <= 0 {
+		return ""
+	}
+
+	var buf strings.Builder
+	buf.WriteByte('[')
+
+	length, rem, _ := ReadLength(a) // We know we have enough bytes to read the length
+	length -= 4
+
+	var elem Element
+	var ok bool
+
+	if n > 0 {
+		for length > 1 {
+			elem, rem, ok = ReadElement(rem)
+
+			length -= int32(len(elem))
+			if !ok {
+				return ""
+			}
+
+			str := elem.Value().StringN(n - buf.Len())
+
+			buf.WriteString(str)
+
+			if buf.Len() == n {
+				return buf.String()
+			}
+
+			if length > 1 {
+				buf.WriteByte(',')
+			}
+		}
+		if length != 1 { // Missing final null byte or inaccurate length
+			return ""
+		}
+	}
+
+	if buf.Len()+1 <= n {
+		buf.WriteByte(']')
+	}
+
+	return buf.String()
+}
+
+// Values returns this array as a slice of values. The returned slice will contain valid values.
+// If the array is not valid, the values up to the invalid point will be returned along with an
+// error.
+func (a Array) Values() ([]Value, error) {
+	return values(a)
+}
+
+// Validate validates the array and ensures the elements contained within are valid.
+func (a Array) Validate() error {
+	length, rem, ok := ReadLength(a)
+	if !ok {
+		return NewInsufficientBytesError(a, rem)
+	}
+	if int(length) > len(a) {
+		return NewArrayLengthError(int(length), len(a))
+	}
+	if a[length-1] != 0x00 {
+		return ErrMissingNull
+	}
+
+	length -= 4
+	var elem Element
+
+	var keyNum int64
+	for length > 1 {
+		elem, rem, ok = ReadElement(rem)
+		length -= int32(len(elem))
+		if !ok {
+			return NewInsufficientBytesError(a, rem)
+		}
+
+		// validate element
+		err := elem.Validate()
+		if err != nil {
+			return err
+		}
+
+		// validate keys increase numerically
+		if fmt.Sprint(keyNum) != elem.Key() {
+			return fmt.Errorf("array key %q is out of order or invalid", elem.Key())
+		}
+		keyNum++
+	}
+
+	if len(rem) < 1 || rem[0] != 0x00 {
+		return ErrMissingNull
+	}
+	return nil
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bson_arraybuilder.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bson_arraybuilder.go
new file mode 100644
index 00000000..8856c113
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bson_arraybuilder.go
@@ -0,0 +1,198 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bsoncore
+
+import (
+	"strconv"
+)
+
+// ArrayBuilder builds a bson array
+type ArrayBuilder struct {
+	arr     []byte
+	indexes []int32
+	keys    []int
+}
+
+// NewArrayBuilder creates a new ArrayBuilder
+func NewArrayBuilder() *ArrayBuilder {
+	return (&ArrayBuilder{}).startArray()
+}
+
+// startArray reserves the array's length and sets the index to where the length begins
+func (a *ArrayBuilder) startArray() *ArrayBuilder {
+	var index int32
+	index, a.arr = AppendArrayStart(a.arr)
+	a.indexes = append(a.indexes, index)
+	a.keys = append(a.keys, 0)
+	return a
+}
+
+// Build updates the length of the array and index to the beginning of the documents length
+// bytes, then returns the array (bson bytes)
+func (a *ArrayBuilder) Build() Array {
+	lastIndex := len(a.indexes) - 1
+	lastKey := len(a.keys) - 1
+	a.arr, _ = AppendArrayEnd(a.arr, a.indexes[lastIndex])
+	a.indexes = a.indexes[:lastIndex]
+	a.keys = a.keys[:lastKey]
+	return a.arr
+}
+
+// incrementKey() increments the value keys and returns the key to be used to a.appendArray* functions
+func (a *ArrayBuilder) incrementKey() string {
+	idx := len(a.keys) - 1
+	key := strconv.Itoa(a.keys[idx])
+	a.keys[idx]++
+	return key
+}
+
+// AppendInt32 will append i32 to ArrayBuilder.arr
+func (a *ArrayBuilder) AppendInt32(i32 int32) *ArrayBuilder {
+	a.arr = AppendInt32Element(a.arr, a.incrementKey(), i32)
+	return a
+}
+
+// AppendDocument will append doc to ArrayBuilder.arr
+func (a *ArrayBuilder) AppendDocument(doc []byte) *ArrayBuilder {
+	a.arr = AppendDocumentElement(a.arr, a.incrementKey(), doc)
+	return a
+}
+
+// AppendArray will append arr to ArrayBuilder.arr
+func (a *ArrayBuilder) AppendArray(arr []byte) *ArrayBuilder {
+	a.arr = AppendArrayElement(a.arr, a.incrementKey(), arr)
+	return a
+}
+
+// AppendDouble will append f to ArrayBuilder.doc
+func (a *ArrayBuilder) AppendDouble(f float64) *ArrayBuilder {
+	a.arr = AppendDoubleElement(a.arr, a.incrementKey(), f)
+	return a
+}
+
+// AppendString will append str to ArrayBuilder.doc
+func (a *ArrayBuilder) AppendString(str string) *ArrayBuilder {
+	a.arr = AppendStringElement(a.arr, a.incrementKey(), str)
+	return a
+}
+
+// AppendObjectID will append oid to ArrayBuilder.doc
+func (a *ArrayBuilder) AppendObjectID(oid objectID) *ArrayBuilder {
+	a.arr = AppendObjectIDElement(a.arr, a.incrementKey(), oid)
+	return a
+}
+
+// AppendBinary will append a BSON binary element using subtype, and
+// b to a.arr
+func (a *ArrayBuilder) AppendBinary(subtype byte, b []byte) *ArrayBuilder {
+	a.arr = AppendBinaryElement(a.arr, a.incrementKey(), subtype, b)
+	return a
+}
+
+// AppendUndefined will append a BSON undefined element using key to a.arr
+func (a *ArrayBuilder) AppendUndefined() *ArrayBuilder {
+	a.arr = AppendUndefinedElement(a.arr, a.incrementKey())
+	return a
+}
+
+// AppendBoolean will append a boolean element using b to a.arr
+func (a *ArrayBuilder) AppendBoolean(b bool) *ArrayBuilder {
+	a.arr = AppendBooleanElement(a.arr, a.incrementKey(), b)
+	return a
+}
+
+// AppendDateTime will append datetime element dt to a.arr
+func (a *ArrayBuilder) AppendDateTime(dt int64) *ArrayBuilder {
+	a.arr = AppendDateTimeElement(a.arr, a.incrementKey(), dt)
+	return a
+}
+
+// AppendNull will append a null element to a.arr
+func (a *ArrayBuilder) AppendNull() *ArrayBuilder {
+	a.arr = AppendNullElement(a.arr, a.incrementKey())
+	return a
+}
+
+// AppendRegex will append pattern and options to a.arr
+func (a *ArrayBuilder) AppendRegex(pattern, options string) *ArrayBuilder {
+	a.arr = AppendRegexElement(a.arr, a.incrementKey(), pattern, options)
+	return a
+}
+
+// AppendDBPointer will append ns and oid to a.arr
+func (a *ArrayBuilder) AppendDBPointer(ns string, oid objectID) *ArrayBuilder {
+	a.arr = AppendDBPointerElement(a.arr, a.incrementKey(), ns, oid)
+	return a
+}
+
+// AppendJavaScript will append js to a.arr
+func (a *ArrayBuilder) AppendJavaScript(js string) *ArrayBuilder {
+	a.arr = AppendJavaScriptElement(a.arr, a.incrementKey(), js)
+	return a
+}
+
+// AppendSymbol will append symbol to a.arr
+func (a *ArrayBuilder) AppendSymbol(symbol string) *ArrayBuilder {
+	a.arr = AppendSymbolElement(a.arr, a.incrementKey(), symbol)
+	return a
+}
+
+// AppendCodeWithScope will append code and scope to a.arr
+func (a *ArrayBuilder) AppendCodeWithScope(code string, scope Document) *ArrayBuilder {
+	a.arr = AppendCodeWithScopeElement(a.arr, a.incrementKey(), code, scope)
+	return a
+}
+
+// AppendTimestamp will append t and i to a.arr
+func (a *ArrayBuilder) AppendTimestamp(t, i uint32) *ArrayBuilder {
+	a.arr = AppendTimestampElement(a.arr, a.incrementKey(), t, i)
+	return a
+}
+
+// AppendInt64 will append i64 to a.arr
+func (a *ArrayBuilder) AppendInt64(i64 int64) *ArrayBuilder {
+	a.arr = AppendInt64Element(a.arr, a.incrementKey(), i64)
+	return a
+}
+
+// AppendDecimal128 will append d128 to a.arr
+func (a *ArrayBuilder) AppendDecimal128(high, low uint64) *ArrayBuilder {
+	a.arr = AppendDecimal128Element(a.arr, a.incrementKey(), high, low)
+	return a
+}
+
+// AppendMaxKey will append a max key element to a.arr
+func (a *ArrayBuilder) AppendMaxKey() *ArrayBuilder {
+	a.arr = AppendMaxKeyElement(a.arr, a.incrementKey())
+	return a
+}
+
+// AppendMinKey will append a min key element to a.arr
+func (a *ArrayBuilder) AppendMinKey() *ArrayBuilder {
+	a.arr = AppendMinKeyElement(a.arr, a.incrementKey())
+	return a
+}
+
+// AppendValue appends a BSON value to the array.
+func (a *ArrayBuilder) AppendValue(val Value) *ArrayBuilder {
+	a.arr = AppendValueElement(a.arr, a.incrementKey(), val)
+	return a
+}
+
+// StartArray starts building an inline Array. After this document is completed,
+// the user must call a.FinishArray
+func (a *ArrayBuilder) StartArray() *ArrayBuilder {
+	a.arr = AppendHeader(a.arr, TypeArray, a.incrementKey())
+	a.startArray()
+	return a
+}
+
+// FinishArray builds the most recent array created
+func (a *ArrayBuilder) FinishArray() *ArrayBuilder {
+	a.arr = a.Build()
+	return a
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bson_documentbuilder.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bson_documentbuilder.go
new file mode 100644
index 00000000..931fc6bf
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bson_documentbuilder.go
@@ -0,0 +1,184 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bsoncore
+
+// DocumentBuilder builds a bson document
+type DocumentBuilder struct {
+	doc     []byte
+	indexes []int32
+}
+
+// startDocument reserves the document's length and set the index to where the length begins
+func (db *DocumentBuilder) startDocument() *DocumentBuilder {
+	var index int32
+	index, db.doc = AppendDocumentStart(db.doc)
+	db.indexes = append(db.indexes, index)
+	return db
+}
+
+// NewDocumentBuilder creates a new DocumentBuilder
+func NewDocumentBuilder() *DocumentBuilder {
+	return (&DocumentBuilder{}).startDocument()
+}
+
+// Build updates the length of the document and index to the beginning of the documents length
+// bytes, then returns the document (bson bytes)
+func (db *DocumentBuilder) Build() Document {
+	last := len(db.indexes) - 1
+	db.doc, _ = AppendDocumentEnd(db.doc, db.indexes[last])
+	db.indexes = db.indexes[:last]
+	return db.doc
+}
+
+// AppendInt32 will append an int32 element using key and i32 to DocumentBuilder.doc
+func (db *DocumentBuilder) AppendInt32(key string, i32 int32) *DocumentBuilder {
+	db.doc = AppendInt32Element(db.doc, key, i32)
+	return db
+}
+
+// AppendDocument will append a bson embedded document element using key
+// and doc to DocumentBuilder.doc
+func (db *DocumentBuilder) AppendDocument(key string, doc []byte) *DocumentBuilder {
+	db.doc = AppendDocumentElement(db.doc, key, doc)
+	return db
+}
+
+// AppendArray will append a bson array using key and arr to DocumentBuilder.doc
+func (db *DocumentBuilder) AppendArray(key string, arr []byte) *DocumentBuilder {
+	db.doc = AppendHeader(db.doc, TypeArray, key)
+	db.doc = AppendArray(db.doc, arr)
+	return db
+}
+
+// AppendDouble will append a double element using key and f to DocumentBuilder.doc
+func (db *DocumentBuilder) AppendDouble(key string, f float64) *DocumentBuilder {
+	db.doc = AppendDoubleElement(db.doc, key, f)
+	return db
+}
+
+// AppendString will append str to DocumentBuilder.doc with the given key
+func (db *DocumentBuilder) AppendString(key string, str string) *DocumentBuilder {
+	db.doc = AppendStringElement(db.doc, key, str)
+	return db
+}
+
+// AppendObjectID will append oid to DocumentBuilder.doc with the given key
+func (db *DocumentBuilder) AppendObjectID(key string, oid objectID) *DocumentBuilder {
+	db.doc = AppendObjectIDElement(db.doc, key, oid)
+	return db
+}
+
+// AppendBinary will append a BSON binary element using key, subtype, and
+// b to db.doc
+func (db *DocumentBuilder) AppendBinary(key string, subtype byte, b []byte) *DocumentBuilder {
+	db.doc = AppendBinaryElement(db.doc, key, subtype, b)
+	return db
+}
+
+// AppendUndefined will append a BSON undefined element using key to db.doc
+func (db *DocumentBuilder) AppendUndefined(key string) *DocumentBuilder {
+	db.doc = AppendUndefinedElement(db.doc, key)
+	return db
+}
+
+// AppendBoolean will append a boolean element using key and b to db.doc
+func (db *DocumentBuilder) AppendBoolean(key string, b bool) *DocumentBuilder {
+	db.doc = AppendBooleanElement(db.doc, key, b)
+	return db
+}
+
+// AppendDateTime will append a datetime element using key and dt to db.doc
+func (db *DocumentBuilder) AppendDateTime(key string, dt int64) *DocumentBuilder {
+	db.doc = AppendDateTimeElement(db.doc, key, dt)
+	return db
+}
+
+// AppendNull will append a null element using key to db.doc
+func (db *DocumentBuilder) AppendNull(key string) *DocumentBuilder {
+	db.doc = AppendNullElement(db.doc, key)
+	return db
+}
+
+// AppendRegex will append pattern and options using key to db.doc
+func (db *DocumentBuilder) AppendRegex(key, pattern, options string) *DocumentBuilder {
+	db.doc = AppendRegexElement(db.doc, key, pattern, options)
+	return db
+}
+
+// AppendDBPointer will append ns and oid to using key to db.doc
+func (db *DocumentBuilder) AppendDBPointer(key string, ns string, oid objectID) *DocumentBuilder {
+	db.doc = AppendDBPointerElement(db.doc, key, ns, oid)
+	return db
+}
+
+// AppendJavaScript will append js using the provided key to db.doc
+func (db *DocumentBuilder) AppendJavaScript(key, js string) *DocumentBuilder {
+	db.doc = AppendJavaScriptElement(db.doc, key, js)
+	return db
+}
+
+// AppendSymbol will append a BSON symbol element using key and symbol db.doc
+func (db *DocumentBuilder) AppendSymbol(key, symbol string) *DocumentBuilder {
+	db.doc = AppendSymbolElement(db.doc, key, symbol)
+	return db
+}
+
+// AppendCodeWithScope will append code and scope using key to db.doc
+func (db *DocumentBuilder) AppendCodeWithScope(key string, code string, scope Document) *DocumentBuilder {
+	db.doc = AppendCodeWithScopeElement(db.doc, key, code, scope)
+	return db
+}
+
+// AppendTimestamp will append t and i to db.doc using provided key
+func (db *DocumentBuilder) AppendTimestamp(key string, t, i uint32) *DocumentBuilder {
+	db.doc = AppendTimestampElement(db.doc, key, t, i)
+	return db
+}
+
+// AppendInt64 will append i64 to dst using key to db.doc
+func (db *DocumentBuilder) AppendInt64(key string, i64 int64) *DocumentBuilder {
+	db.doc = AppendInt64Element(db.doc, key, i64)
+	return db
+}
+
+// AppendDecimal128 will append d128 to db.doc using provided key
+func (db *DocumentBuilder) AppendDecimal128(key string, high, low uint64) *DocumentBuilder {
+	db.doc = AppendDecimal128Element(db.doc, key, high, low)
+	return db
+}
+
+// AppendMaxKey will append a max key element using key to db.doc
+func (db *DocumentBuilder) AppendMaxKey(key string) *DocumentBuilder {
+	db.doc = AppendMaxKeyElement(db.doc, key)
+	return db
+}
+
+// AppendMinKey will append a min key element using key to db.doc
+func (db *DocumentBuilder) AppendMinKey(key string) *DocumentBuilder {
+	db.doc = AppendMinKeyElement(db.doc, key)
+	return db
+}
+
+// AppendValue will append a BSON element with the provided key and value to the document.
+func (db *DocumentBuilder) AppendValue(key string, val Value) *DocumentBuilder {
+	db.doc = AppendValueElement(db.doc, key, val)
+	return db
+}
+
+// StartDocument starts building an inline document element with the provided key
+// After this document is completed, the user must call finishDocument
+func (db *DocumentBuilder) StartDocument(key string) *DocumentBuilder {
+	db.doc = AppendHeader(db.doc, TypeEmbeddedDocument, key)
+	db = db.startDocument()
+	return db
+}
+
+// FinishDocument builds the most recent document created
+func (db *DocumentBuilder) FinishDocument() *DocumentBuilder {
+	db.doc = db.Build()
+	return db
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bsoncore.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bsoncore.go
new file mode 100644
index 00000000..13219ee5
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bsoncore.go
@@ -0,0 +1,842 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bsoncore
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+	"time"
+)
+
+const (
+	// EmptyDocumentLength is the length of a document that has been started/ended but has no elements.
+	EmptyDocumentLength = 5
+	// nullTerminator is a string version of the 0 byte that is appended at the end of cstrings.
+	nullTerminator       = string(byte(0))
+	invalidKeyPanicMsg   = "BSON element keys cannot contain null bytes"
+	invalidRegexPanicMsg = "BSON regex values cannot contain null bytes"
+)
+
+type objectID = [12]byte
+
+// AppendType will append t to dst and return the extended buffer.
+func AppendType(dst []byte, t Type) []byte { return append(dst, byte(t)) }
+
+// AppendKey will append key to dst and return the extended buffer.
+func AppendKey(dst []byte, key string) []byte { return append(dst, key+nullTerminator...) }
+
+// AppendHeader will append Type t and key to dst and return the extended
+// buffer.
+func AppendHeader(dst []byte, t Type, key string) []byte {
+	if !isValidCString(key) {
+		panic(invalidKeyPanicMsg)
+	}
+
+	dst = AppendType(dst, t)
+	dst = append(dst, key...)
+	return append(dst, 0x00)
+	// return append(AppendType(dst, t), key+string(0x00)...)
+}
+
+// TODO(skriptble): All of the Read* functions should return src resliced to start just after what was read.
+
+// ReadType will return the first byte of the provided []byte as a type. If
+// there is no available byte, false is returned.
+func ReadType(src []byte) (Type, []byte, bool) {
+	if len(src) < 1 {
+		return 0, src, false
+	}
+	return Type(src[0]), src[1:], true
+}
+
+// ReadKey will read a key from src. The 0x00 byte will not be present
+// in the returned string. If there are not enough bytes available, false is
+// returned.
+func ReadKey(src []byte) (string, []byte, bool) { return readcstring(src) }
+
+// ReadKeyBytes will read a key from src as bytes. The 0x00 byte will
+// not be present in the returned string. If there are not enough bytes
+// available, false is returned.
+func ReadKeyBytes(src []byte) ([]byte, []byte, bool) { return readcstringbytes(src) }
+
+// ReadHeader will read a type byte and a key from src. If both of these
+// values cannot be read, false is returned.
+func ReadHeader(src []byte) (t Type, key string, rem []byte, ok bool) {
+	t, rem, ok = ReadType(src)
+	if !ok {
+		return 0, "", src, false
+	}
+	key, rem, ok = ReadKey(rem)
+	if !ok {
+		return 0, "", src, false
+	}
+
+	return t, key, rem, true
+}
+
+// ReadHeaderBytes will read a type and a key from src and the remainder of the bytes
+// are returned as rem. If either the type or key cannot be red, ok will be false.
+func ReadHeaderBytes(src []byte) (header []byte, rem []byte, ok bool) {
+	if len(src) < 1 {
+		return nil, src, false
+	}
+	idx := bytes.IndexByte(src[1:], 0x00)
+	if idx == -1 {
+		return nil, src, false
+	}
+	return src[:idx], src[idx+1:], true
+}
+
+// ReadElement reads the next full element from src. It returns the element, the remaining bytes in
+// the slice, and a boolean indicating if the read was successful.
+func ReadElement(src []byte) (Element, []byte, bool) {
+	if len(src) < 1 {
+		return nil, src, false
+	}
+	t := Type(src[0])
+	idx := 1
+	for idx < len(src) && src[idx] != 0x00 {
+		idx++
+	}
+	if idx >= len(src) {
+		return nil, src, false
+	}
+	idx++ // Move past the null byte
+	length, ok := valueLength(src[idx:], t)
+	if !ok {
+		return nil, src, false
+	}
+	elemLength := idx + int(length)
+	if elemLength > len(src) {
+		return nil, src, false
+	}
+	return src[:elemLength], src[elemLength:], true
+}
+
+// AppendValueElement appends value to dst as an element using key as the element's key.
+func AppendValueElement(dst []byte, key string, value Value) []byte {
+	dst = AppendHeader(dst, value.Type, key)
+	dst = append(dst, value.Data...)
+	return dst
+}
+
+// ReadValue reads the next value as the provided types and returns a Value, the remaining bytes,
+// and a boolean indicating if the read was successful.
+func ReadValue(src []byte, t Type) (Value, []byte, bool) {
+	data, rem, ok := readValue(src, t)
+	if !ok {
+		return Value{}, src, false
+	}
+	return Value{Type: t, Data: data}, rem, true
+}
+
+// AppendDouble will append f to dst and return the extended buffer.
+func AppendDouble(dst []byte, f float64) []byte {
+	return appendu64(dst, math.Float64bits(f))
+}
+
+// AppendDoubleElement will append a BSON double element using key and f to dst
+// and return the extended buffer.
+func AppendDoubleElement(dst []byte, key string, f float64) []byte {
+	return AppendDouble(AppendHeader(dst, TypeDouble, key), f)
+}
+
+// ReadDouble will read a float64 from src. If there are not enough bytes it
+// will return false.
+func ReadDouble(src []byte) (float64, []byte, bool) {
+	bits, src, ok := readu64(src)
+	if !ok {
+		return 0, src, false
+	}
+	return math.Float64frombits(bits), src, true
+}
+
+// AppendString will append s to dst and return the extended buffer.
+func AppendString(dst []byte, s string) []byte {
+	return appendstring(dst, s)
+}
+
+// AppendStringElement will append a BSON string element using key and val to dst
+// and return the extended buffer.
+func AppendStringElement(dst []byte, key, val string) []byte {
+	return AppendString(AppendHeader(dst, TypeString, key), val)
+}
+
+// ReadString will read a string from src. If there are not enough bytes it
+// will return false.
+func ReadString(src []byte) (string, []byte, bool) {
+	return readstring(src)
+}
+
+// AppendDocumentStart reserves a document's length and returns the index where the length begins.
+// This index can later be used to write the length of the document.
+func AppendDocumentStart(dst []byte) (index int32, b []byte) {
+	// TODO(skriptble): We really need AppendDocumentStart and AppendDocumentEnd.  AppendDocumentStart would handle calling
+	// TODO ReserveLength and providing the index of the start of the document. AppendDocumentEnd would handle taking that
+	// TODO start index, adding the null byte, calculating the length, and filling in the length at the start of the
+	// TODO document.
+	return ReserveLength(dst)
+}
+
+// AppendDocumentStartInline functions the same as AppendDocumentStart but takes a pointer to the
+// index int32 which allows this function to be used inline.
+func AppendDocumentStartInline(dst []byte, index *int32) []byte {
+	idx, doc := AppendDocumentStart(dst)
+	*index = idx
+	return doc
+}
+
+// AppendDocumentElementStart writes a document element header and then reserves the length bytes.
+func AppendDocumentElementStart(dst []byte, key string) (index int32, b []byte) {
+	return AppendDocumentStart(AppendHeader(dst, TypeEmbeddedDocument, key))
+}
+
+// AppendDocumentEnd writes the null byte for a document and updates the length of the document.
+// The index should be the beginning of the document's length bytes.
+func AppendDocumentEnd(dst []byte, index int32) ([]byte, error) {
+	if int(index) > len(dst)-4 {
+		return dst, fmt.Errorf("not enough bytes available after index to write length")
+	}
+	dst = append(dst, 0x00)
+	dst = UpdateLength(dst, index, int32(len(dst[index:])))
+	return dst, nil
+}
+
+// AppendDocument will append doc to dst and return the extended buffer.
+func AppendDocument(dst []byte, doc []byte) []byte { return append(dst, doc...) }
+
+// AppendDocumentElement will append a BSON embedded document element using key
+// and doc to dst and return the extended buffer.
+func AppendDocumentElement(dst []byte, key string, doc []byte) []byte {
+	return AppendDocument(AppendHeader(dst, TypeEmbeddedDocument, key), doc)
+}
+
+// BuildDocument will create a document with the given slice of elements and will append
+// it to dst and return the extended buffer.
+func BuildDocument(dst []byte, elems ...[]byte) []byte {
+	idx, dst := ReserveLength(dst)
+	for _, elem := range elems {
+		dst = append(dst, elem...)
+	}
+	dst = append(dst, 0x00)
+	dst = UpdateLength(dst, idx, int32(len(dst[idx:])))
+	return dst
+}
+
+// BuildDocumentValue creates an Embedded Document value from the given elements.
+func BuildDocumentValue(elems ...[]byte) Value {
+	return Value{Type: TypeEmbeddedDocument, Data: BuildDocument(nil, elems...)}
+}
+
+// BuildDocumentElement will append a BSON embedded document element using key and the provided
+// elements and return the extended buffer.
+func BuildDocumentElement(dst []byte, key string, elems ...[]byte) []byte {
+	return BuildDocument(AppendHeader(dst, TypeEmbeddedDocument, key), elems...)
+}
+
+// BuildDocumentFromElements is an alaias for the BuildDocument function.
+var BuildDocumentFromElements = BuildDocument
+
+// ReadDocument will read a document from src. If there are not enough bytes it
+// will return false.
+func ReadDocument(src []byte) (doc Document, rem []byte, ok bool) { return readLengthBytes(src) }
+
+// AppendArrayStart appends the length bytes to an array and then returns the index of the start
+// of those length bytes.
+func AppendArrayStart(dst []byte) (index int32, b []byte) { return ReserveLength(dst) }
+
+// AppendArrayElementStart appends an array element header and then the length bytes for an array,
+// returning the index where the length starts.
+func AppendArrayElementStart(dst []byte, key string) (index int32, b []byte) {
+	return AppendArrayStart(AppendHeader(dst, TypeArray, key))
+}
+
+// AppendArrayEnd appends the null byte to an array and calculates the length, inserting that
+// calculated length starting at index.
+func AppendArrayEnd(dst []byte, index int32) ([]byte, error) { return AppendDocumentEnd(dst, index) }
+
+// AppendArray will append arr to dst and return the extended buffer.
+func AppendArray(dst []byte, arr []byte) []byte { return append(dst, arr...) }
+
+// AppendArrayElement will append a BSON array element using key and arr to dst
+// and return the extended buffer.
+func AppendArrayElement(dst []byte, key string, arr []byte) []byte {
+	return AppendArray(AppendHeader(dst, TypeArray, key), arr)
+}
+
+// BuildArray will append a BSON array to dst built from values.
+func BuildArray(dst []byte, values ...Value) []byte {
+	idx, dst := ReserveLength(dst)
+	for pos, val := range values {
+		dst = AppendValueElement(dst, strconv.Itoa(pos), val)
+	}
+	dst = append(dst, 0x00)
+	dst = UpdateLength(dst, idx, int32(len(dst[idx:])))
+	return dst
+}
+
+// BuildArrayElement will create an array element using the provided values.
+func BuildArrayElement(dst []byte, key string, values ...Value) []byte {
+	return BuildArray(AppendHeader(dst, TypeArray, key), values...)
+}
+
+// ReadArray will read an array from src. If there are not enough bytes it
+// will return false.
+func ReadArray(src []byte) (arr Array, rem []byte, ok bool) { return readLengthBytes(src) }
+
+// AppendBinary will append subtype and b to dst and return the extended buffer.
+func AppendBinary(dst []byte, subtype byte, b []byte) []byte {
+	if subtype == 0x02 {
+		return appendBinarySubtype2(dst, subtype, b)
+	}
+	dst = append(appendLength(dst, int32(len(b))), subtype)
+	return append(dst, b...)
+}
+
+// AppendBinaryElement will append a BSON binary element using key, subtype, and
+// b to dst and return the extended buffer.
+func AppendBinaryElement(dst []byte, key string, subtype byte, b []byte) []byte {
+	return AppendBinary(AppendHeader(dst, TypeBinary, key), subtype, b)
+}
+
+// ReadBinary will read a subtype and bin from src. If there are not enough bytes it
+// will return false.
+func ReadBinary(src []byte) (subtype byte, bin []byte, rem []byte, ok bool) {
+	length, rem, ok := ReadLength(src)
+	if !ok {
+		return 0x00, nil, src, false
+	}
+	if len(rem) < 1 { // subtype
+		return 0x00, nil, src, false
+	}
+	subtype, rem = rem[0], rem[1:]
+
+	if len(rem) < int(length) {
+		return 0x00, nil, src, false
+	}
+
+	if subtype == 0x02 {
+		length, rem, ok = ReadLength(rem)
+		if !ok || len(rem) < int(length) {
+			return 0x00, nil, src, false
+		}
+	}
+
+	return subtype, rem[:length], rem[length:], true
+}
+
+// AppendUndefinedElement will append a BSON undefined element using key to dst
+// and return the extended buffer.
+func AppendUndefinedElement(dst []byte, key string) []byte {
+	return AppendHeader(dst, TypeUndefined, key)
+}
+
+// AppendObjectID will append oid to dst and return the extended buffer.
+func AppendObjectID(dst []byte, oid objectID) []byte { return append(dst, oid[:]...) }
+
+// AppendObjectIDElement will append a BSON ObjectID element using key and oid to dst
+// and return the extended buffer.
+func AppendObjectIDElement(dst []byte, key string, oid objectID) []byte {
+	return AppendObjectID(AppendHeader(dst, TypeObjectID, key), oid)
+}
+
+// ReadObjectID will read an ObjectID from src. If there are not enough bytes it
+// will return false.
+func ReadObjectID(src []byte) (objectID, []byte, bool) {
+	var oid objectID
+	idLen := cap(oid)
+	if len(src) < idLen {
+		return oid, src, false
+	}
+	copy(oid[:], src[0:idLen])
+	return oid, src[idLen:], true
+}
+
+// AppendBoolean will append b to dst and return the extended buffer.
+func AppendBoolean(dst []byte, b bool) []byte {
+	if b {
+		return append(dst, 0x01)
+	}
+	return append(dst, 0x00)
+}
+
+// AppendBooleanElement will append a BSON boolean element using key and b to dst
+// and return the extended buffer.
+func AppendBooleanElement(dst []byte, key string, b bool) []byte {
+	return AppendBoolean(AppendHeader(dst, TypeBoolean, key), b)
+}
+
+// ReadBoolean will read a bool from src. If there are not enough bytes it
+// will return false.
+func ReadBoolean(src []byte) (bool, []byte, bool) {
+	if len(src) < 1 {
+		return false, src, false
+	}
+
+	return src[0] == 0x01, src[1:], true
+}
+
+// AppendDateTime will append dt to dst and return the extended buffer.
+func AppendDateTime(dst []byte, dt int64) []byte { return appendi64(dst, dt) }
+
+// AppendDateTimeElement will append a BSON datetime element using key and dt to dst
+// and return the extended buffer.
+func AppendDateTimeElement(dst []byte, key string, dt int64) []byte {
+	return AppendDateTime(AppendHeader(dst, TypeDateTime, key), dt)
+}
+
+// ReadDateTime will read an int64 datetime from src. If there are not enough bytes it
+// will return false.
+func ReadDateTime(src []byte) (int64, []byte, bool) { return readi64(src) }
+
+// AppendTime will append time as a BSON DateTime to dst and return the extended buffer.
+func AppendTime(dst []byte, t time.Time) []byte {
+	return AppendDateTime(dst, t.Unix()*1000+int64(t.Nanosecond()/1e6))
+}
+
+// AppendTimeElement will append a BSON datetime element using key and dt to dst
+// and return the extended buffer.
+func AppendTimeElement(dst []byte, key string, t time.Time) []byte {
+	return AppendTime(AppendHeader(dst, TypeDateTime, key), t)
+}
+
+// ReadTime will read an time.Time datetime from src. If there are not enough bytes it
+// will return false.
+func ReadTime(src []byte) (time.Time, []byte, bool) {
+	dt, rem, ok := readi64(src)
+	return time.Unix(dt/1e3, dt%1e3*1e6), rem, ok
+}
+
+// AppendNullElement will append a BSON null element using key to dst
+// and return the extended buffer.
+func AppendNullElement(dst []byte, key string) []byte { return AppendHeader(dst, TypeNull, key) }
+
+// AppendRegex will append pattern and options to dst and return the extended buffer.
+func AppendRegex(dst []byte, pattern, options string) []byte {
+	if !isValidCString(pattern) || !isValidCString(options) {
+		panic(invalidRegexPanicMsg)
+	}
+
+	return append(dst, pattern+nullTerminator+options+nullTerminator...)
+}
+
+// AppendRegexElement will append a BSON regex element using key, pattern, and
+// options to dst and return the extended buffer.
+func AppendRegexElement(dst []byte, key, pattern, options string) []byte {
+	return AppendRegex(AppendHeader(dst, TypeRegex, key), pattern, options)
+}
+
+// ReadRegex will read a pattern and options from src. If there are not enough bytes it
+// will return false.
+func ReadRegex(src []byte) (pattern, options string, rem []byte, ok bool) {
+	pattern, rem, ok = readcstring(src)
+	if !ok {
+		return "", "", src, false
+	}
+	options, rem, ok = readcstring(rem)
+	if !ok {
+		return "", "", src, false
+	}
+	return pattern, options, rem, true
+}
+
+// AppendDBPointer will append ns and oid to dst and return the extended buffer.
+func AppendDBPointer(dst []byte, ns string, oid objectID) []byte {
+	return append(appendstring(dst, ns), oid[:]...)
+}
+
+// AppendDBPointerElement will append a BSON DBPointer element using key, ns,
+// and oid to dst and return the extended buffer.
+func AppendDBPointerElement(dst []byte, key, ns string, oid objectID) []byte {
+	return AppendDBPointer(AppendHeader(dst, TypeDBPointer, key), ns, oid)
+}
+
+// ReadDBPointer will read a ns and oid from src. If there are not enough bytes it
+// will return false.
+func ReadDBPointer(src []byte) (ns string, oid objectID, rem []byte, ok bool) {
+	ns, rem, ok = readstring(src)
+	if !ok {
+		return "", objectID{}, src, false
+	}
+	oid, rem, ok = ReadObjectID(rem)
+	if !ok {
+		return "", objectID{}, src, false
+	}
+	return ns, oid, rem, true
+}
+
+// AppendJavaScript will append js to dst and return the extended buffer.
+func AppendJavaScript(dst []byte, js string) []byte { return appendstring(dst, js) }
+
+// AppendJavaScriptElement will append a BSON JavaScript element using key and
+// js to dst and return the extended buffer.
+func AppendJavaScriptElement(dst []byte, key, js string) []byte {
+	return AppendJavaScript(AppendHeader(dst, TypeJavaScript, key), js)
+}
+
+// ReadJavaScript will read a js string from src. If there are not enough bytes it
+// will return false.
+func ReadJavaScript(src []byte) (js string, rem []byte, ok bool) { return readstring(src) }
+
+// AppendSymbol will append symbol to dst and return the extended buffer.
+func AppendSymbol(dst []byte, symbol string) []byte { return appendstring(dst, symbol) }
+
+// AppendSymbolElement will append a BSON symbol element using key and symbol to dst
+// and return the extended buffer.
+func AppendSymbolElement(dst []byte, key, symbol string) []byte {
+	return AppendSymbol(AppendHeader(dst, TypeSymbol, key), symbol)
+}
+
+// ReadSymbol will read a symbol string from src. If there are not enough bytes it
+// will return false.
+func ReadSymbol(src []byte) (symbol string, rem []byte, ok bool) { return readstring(src) }
+
+// AppendCodeWithScope will append code and scope to dst and return the extended buffer.
+func AppendCodeWithScope(dst []byte, code string, scope []byte) []byte {
+	length := int32(4 + 4 + len(code) + 1 + len(scope)) // length of cws, length of code, code, 0x00, scope
+	dst = appendLength(dst, length)
+
+	return append(appendstring(dst, code), scope...)
+}
+
+// AppendCodeWithScopeElement will append a BSON code with scope element using
+// key, code, and scope to dst
+// and return the extended buffer.
+func AppendCodeWithScopeElement(dst []byte, key, code string, scope []byte) []byte {
+	return AppendCodeWithScope(AppendHeader(dst, TypeCodeWithScope, key), code, scope)
+}
+
+// ReadCodeWithScope will read code and scope from src. If there are not enough bytes it
+// will return false.
+func ReadCodeWithScope(src []byte) (code string, scope []byte, rem []byte, ok bool) {
+	length, rem, ok := ReadLength(src)
+	if !ok || len(src) < int(length) {
+		return "", nil, src, false
+	}
+
+	code, rem, ok = readstring(rem)
+	if !ok {
+		return "", nil, src, false
+	}
+
+	scope, rem, ok = ReadDocument(rem)
+	if !ok {
+		return "", nil, src, false
+	}
+	return code, scope, rem, true
+}
+
+// AppendInt32 will append i32 to dst and return the extended buffer.
+func AppendInt32(dst []byte, i32 int32) []byte { return appendi32(dst, i32) }
+
+// AppendInt32Element will append a BSON int32 element using key and i32 to dst
+// and return the extended buffer.
+func AppendInt32Element(dst []byte, key string, i32 int32) []byte {
+	return AppendInt32(AppendHeader(dst, TypeInt32, key), i32)
+}
+
+// ReadInt32 will read an int32 from src. If there are not enough bytes it
+// will return false.
+func ReadInt32(src []byte) (int32, []byte, bool) { return readi32(src) }
+
+// AppendTimestamp will append t and i to dst and return the extended buffer.
+func AppendTimestamp(dst []byte, t, i uint32) []byte {
+	return appendu32(appendu32(dst, i), t) // i is the lower 4 bytes, t is the higher 4 bytes
+}
+
+// AppendTimestampElement will append a BSON timestamp element using key, t, and
+// i to dst and return the extended buffer.
+func AppendTimestampElement(dst []byte, key string, t, i uint32) []byte {
+	return AppendTimestamp(AppendHeader(dst, TypeTimestamp, key), t, i)
+}
+
+// ReadTimestamp will read t and i from src. If there are not enough bytes it
+// will return false.
+func ReadTimestamp(src []byte) (t, i uint32, rem []byte, ok bool) {
+	i, rem, ok = readu32(src)
+	if !ok {
+		return 0, 0, src, false
+	}
+	t, rem, ok = readu32(rem)
+	if !ok {
+		return 0, 0, src, false
+	}
+	return t, i, rem, true
+}
+
+// AppendInt64 will append i64 to dst and return the extended buffer.
+func AppendInt64(dst []byte, i64 int64) []byte { return appendi64(dst, i64) }
+
+// AppendInt64Element will append a BSON int64 element using key and i64 to dst
+// and return the extended buffer.
+func AppendInt64Element(dst []byte, key string, i64 int64) []byte {
+	return AppendInt64(AppendHeader(dst, TypeInt64, key), i64)
+}
+
+// ReadInt64 will read an int64 from src. If there are not enough bytes it
+// will return false.
+func ReadInt64(src []byte) (int64, []byte, bool) { return readi64(src) }
+
+// AppendDecimal128 will append high and low parts of a d128 to dst and return the extended buffer.
+func AppendDecimal128(dst []byte, high, low uint64) []byte {
+	return appendu64(appendu64(dst, low), high)
+}
+
+// AppendDecimal128Element will append high and low parts of a BSON bson.Decimal128 element using key and
+// d128 to dst and return the extended buffer.
+func AppendDecimal128Element(dst []byte, key string, high, low uint64) []byte {
+	return AppendDecimal128(AppendHeader(dst, TypeDecimal128, key), high, low)
+}
+
+// ReadDecimal128 will read high and low parts of a bson.Decimal128 from src. If there are not enough bytes it
+// will return false.
+func ReadDecimal128(src []byte) (high uint64, low uint64, rem []byte, ok bool) {
+	low, rem, ok = readu64(src)
+	if !ok {
+		return 0, 0, src, false
+	}
+
+	high, rem, ok = readu64(rem)
+	if !ok {
+		return 0, 0, src, false
+	}
+
+	return high, low, rem, true
+}
+
+// AppendMaxKeyElement will append a BSON max key element using key to dst
+// and return the extended buffer.
+func AppendMaxKeyElement(dst []byte, key string) []byte {
+	return AppendHeader(dst, TypeMaxKey, key)
+}
+
+// AppendMinKeyElement will append a BSON min key element using key to dst
+// and return the extended buffer.
+func AppendMinKeyElement(dst []byte, key string) []byte {
+	return AppendHeader(dst, TypeMinKey, key)
+}
+
+// EqualValue will return true if the two values are equal.
+func EqualValue(t1, t2 Type, v1, v2 []byte) bool {
+	if t1 != t2 {
+		return false
+	}
+	v1, _, ok := readValue(v1, t1)
+	if !ok {
+		return false
+	}
+	v2, _, ok = readValue(v2, t2)
+	if !ok {
+		return false
+	}
+	return bytes.Equal(v1, v2)
+}
+
+// valueLength will determine the length of the next value contained in src as if it
+// is type t. The returned bool will be false if there are not enough bytes in src for
+// a value of type t.
+func valueLength(src []byte, t Type) (int32, bool) {
+	var length int32
+	ok := true
+	switch t {
+	case TypeArray, TypeEmbeddedDocument, TypeCodeWithScope:
+		length, _, ok = ReadLength(src)
+	case TypeBinary:
+		length, _, ok = ReadLength(src)
+		length += 4 + 1 // binary length + subtype byte
+	case TypeBoolean:
+		length = 1
+	case TypeDBPointer:
+		length, _, ok = ReadLength(src)
+		length += 4 + 12 // string length + ObjectID length
+	case TypeDateTime, TypeDouble, TypeInt64, TypeTimestamp:
+		length = 8
+	case TypeDecimal128:
+		length = 16
+	case TypeInt32:
+		length = 4
+	case TypeJavaScript, TypeString, TypeSymbol:
+		length, _, ok = ReadLength(src)
+		length += 4
+	case TypeMaxKey, TypeMinKey, TypeNull, TypeUndefined:
+		length = 0
+	case TypeObjectID:
+		length = 12
+	case TypeRegex:
+		regex := bytes.IndexByte(src, 0x00)
+		if regex < 0 {
+			ok = false
+			break
+		}
+		pattern := bytes.IndexByte(src[regex+1:], 0x00)
+		if pattern < 0 {
+			ok = false
+			break
+		}
+		length = int32(int64(regex) + 1 + int64(pattern) + 1)
+	default:
+		ok = false
+	}
+
+	return length, ok
+}
+
+func readValue(src []byte, t Type) ([]byte, []byte, bool) {
+	length, ok := valueLength(src, t)
+	if !ok || int(length) > len(src) {
+		return nil, src, false
+	}
+
+	return src[:length], src[length:], true
+}
+
+// ReserveLength reserves the space required for length and returns the index where to write the length
+// and the []byte with reserved space.
+func ReserveLength(dst []byte) (int32, []byte) {
+	index := len(dst)
+	return int32(index), append(dst, 0x00, 0x00, 0x00, 0x00)
+}
+
+// UpdateLength updates the length at index with length and returns the []byte.
+func UpdateLength(dst []byte, index, length int32) []byte {
+	binary.LittleEndian.PutUint32(dst[index:], uint32(length))
+	return dst
+}
+
+func appendLength(dst []byte, l int32) []byte { return appendi32(dst, l) }
+
+func appendi32(dst []byte, i32 int32) []byte {
+	b := []byte{0, 0, 0, 0}
+	binary.LittleEndian.PutUint32(b, uint32(i32))
+	return append(dst, b...)
+}
+
+// ReadLength reads an int32 length from src and returns the length and the remaining bytes. If
+// there aren't enough bytes to read a valid length, src is returned unomdified and the returned
+// bool will be false.
+func ReadLength(src []byte) (int32, []byte, bool) {
+	ln, src, ok := readi32(src)
+	if ln < 0 {
+		return ln, src, false
+	}
+	return ln, src, ok
+}
+
+func readi32(src []byte) (int32, []byte, bool) {
+	if len(src) < 4 {
+		return 0, src, false
+	}
+	return int32(binary.LittleEndian.Uint32(src)), src[4:], true
+}
+
+func appendi64(dst []byte, i64 int64) []byte {
+	b := []byte{0, 0, 0, 0, 0, 0, 0, 0}
+	binary.LittleEndian.PutUint64(b, uint64(i64))
+	return append(dst, b...)
+}
+
+func readi64(src []byte) (int64, []byte, bool) {
+	if len(src) < 8 {
+		return 0, src, false
+	}
+	return int64(binary.LittleEndian.Uint64(src)), src[8:], true
+}
+
+func appendu32(dst []byte, u32 uint32) []byte {
+	b := []byte{0, 0, 0, 0}
+	binary.LittleEndian.PutUint32(b, u32)
+	return append(dst, b...)
+}
+
+func readu32(src []byte) (uint32, []byte, bool) {
+	if len(src) < 4 {
+		return 0, src, false
+	}
+
+	return binary.LittleEndian.Uint32(src), src[4:], true
+}
+
+func appendu64(dst []byte, u64 uint64) []byte {
+	b := []byte{0, 0, 0, 0, 0, 0, 0, 0}
+	binary.LittleEndian.PutUint64(b, u64)
+	return append(dst, b...)
+}
+
+func readu64(src []byte) (uint64, []byte, bool) {
+	if len(src) < 8 {
+		return 0, src, false
+	}
+	return binary.LittleEndian.Uint64(src), src[8:], true
+}
+
+// keep in sync with readcstringbytes
+func readcstring(src []byte) (string, []byte, bool) {
+	idx := bytes.IndexByte(src, 0x00)
+	if idx < 0 {
+		return "", src, false
+	}
+	return string(src[:idx]), src[idx+1:], true
+}
+
+// keep in sync with readcstring
+func readcstringbytes(src []byte) ([]byte, []byte, bool) {
+	idx := bytes.IndexByte(src, 0x00)
+	if idx < 0 {
+		return nil, src, false
+	}
+	return src[:idx], src[idx+1:], true
+}
+
+func appendstring(dst []byte, s string) []byte {
+	l := int32(len(s) + 1)
+	dst = appendLength(dst, l)
+	dst = append(dst, s...)
+	return append(dst, 0x00)
+}
+
+func readstring(src []byte) (string, []byte, bool) {
+	l, rem, ok := ReadLength(src)
+	if !ok {
+		return "", src, false
+	}
+	if len(src[4:]) < int(l) || l == 0 {
+		return "", src, false
+	}
+
+	return string(rem[:l-1]), rem[l:], true
+}
+
+// readLengthBytes attempts to read a length and that number of bytes. This
+// function requires that the length include the four bytes for itself.
+func readLengthBytes(src []byte) ([]byte, []byte, bool) {
+	l, _, ok := ReadLength(src)
+	if !ok {
+		return nil, src, false
+	}
+	if l < 4 {
+		return nil, src, false
+	}
+	if len(src) < int(l) {
+		return nil, src, false
+	}
+	return src[:l], src[l:], true
+}
+
+func appendBinarySubtype2(dst []byte, subtype byte, b []byte) []byte {
+	dst = appendLength(dst, int32(len(b)+4)) // The bytes we'll encode need to be 4 larger for the length bytes
+	dst = append(dst, subtype)
+	dst = appendLength(dst, int32(len(b)))
+	return append(dst, b...)
+}
+
+func isValidCString(cs string) bool {
+	return !strings.ContainsRune(cs, '\x00')
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/doc.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/doc.go
new file mode 100644
index 00000000..f68e1da1
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/doc.go
@@ -0,0 +1,34 @@
+// Copyright (C) MongoDB, Inc. 2022-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+// Package bsoncore is intended for internal use only. It is made available to
+// facilitate use cases that require access to internal MongoDB driver
+// functionality and state. The API of this package is not stable and there is
+// no backward compatibility guarantee.
+//
+// WARNING: THIS PACKAGE IS EXPERIMENTAL AND MAY BE MODIFIED OR REMOVED WITHOUT
+// NOTICE! USE WITH EXTREME CAUTION!
+//
+// Package bsoncore contains functions that can be used to encode and decode
+// BSON elements and values to or from a slice of bytes. These functions are
+// aimed at allowing low level manipulation of BSON and can be used to build a
+// higher level BSON library.
+//
+// The Read* functions within this package return the values of the element and
+// a boolean indicating if the values are valid. A boolean was used instead of
+// an error because any error that would be returned would be the same: not
+// enough bytes. This library attempts to do no validation, it will only return
+// false if there are not enough bytes for an item to be read. For example, the
+// ReadDocument function checks the length, if that length is larger than the
+// number of bytes available, it will return false, if there are enough bytes,
+// it will return those bytes and true. It is the consumers responsibility to
+// validate those bytes.
+//
+// The Append* functions within this package will append the type value to the
+// given dst slice. If the slice has enough capacity, it will not grow the
+// slice. The Append*Element functions within this package operate in the same
+// way, but additionally append the BSON type and the key before the value.
+package bsoncore
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/document.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/document.go
new file mode 100644
index 00000000..6a59908d
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/document.go
@@ -0,0 +1,411 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bsoncore
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"strconv"
+	"strings"
+
+	"go.mongodb.org/mongo-driver/v2/internal/bsoncoreutil"
+)
+
+// ValidationError is an error type returned when attempting to validate a document or array.
+type ValidationError string
+
+func (ve ValidationError) Error() string { return string(ve) }
+
+// NewDocumentLengthError creates and returns an error for when the length of a document exceeds the
+// bytes available.
+func NewDocumentLengthError(length, rem int) error {
+	return lengthError("document", length, rem)
+}
+
+func lengthError(bufferType string, length, rem int) error {
+	return ValidationError(fmt.Sprintf("%v length exceeds available bytes. length=%d remainingBytes=%d",
+		bufferType, length, rem))
+}
+
+// InsufficientBytesError indicates that there were not enough bytes to read the next component.
+type InsufficientBytesError struct {
+	Source    []byte
+	Remaining []byte
+}
+
+// NewInsufficientBytesError creates a new InsufficientBytesError with the given Document and
+// remaining bytes.
+func NewInsufficientBytesError(src, rem []byte) InsufficientBytesError {
+	return InsufficientBytesError{Source: src, Remaining: rem}
+}
+
+// Error implements the error interface.
+func (ibe InsufficientBytesError) Error() string {
+	return "too few bytes to read next component"
+}
+
+// Equal checks that err2 also is an ErrTooSmall.
+func (ibe InsufficientBytesError) Equal(err2 error) bool {
+	switch err2.(type) {
+	case InsufficientBytesError:
+		return true
+	default:
+		return false
+	}
+}
+
+// InvalidDepthTraversalError is returned when attempting a recursive Lookup when one component of
+// the path is neither an embedded document nor an array.
+type InvalidDepthTraversalError struct {
+	Key  string
+	Type Type
+}
+
+func (idte InvalidDepthTraversalError) Error() string {
+	return fmt.Sprintf(
+		"attempt to traverse into %s, but it's type is %s, not %s nor %s",
+		idte.Key, idte.Type, TypeEmbeddedDocument, TypeArray,
+	)
+}
+
+// ErrMissingNull is returned when a document or array's last byte is not null.
+const ErrMissingNull ValidationError = "document or array end is missing null byte"
+
+// ErrInvalidLength indicates that a length in a binary representation of a BSON document or array
+// is invalid.
+const ErrInvalidLength ValidationError = "document or array length is invalid"
+
+// ErrNilReader indicates that an operation was attempted on a nil io.Reader.
+var ErrNilReader = errors.New("nil reader")
+
+// ErrEmptyKey indicates that no key was provided to a Lookup method.
+var ErrEmptyKey = errors.New("empty key provided")
+
+// ErrElementNotFound indicates that an Element matching a certain condition does not exist.
+var ErrElementNotFound = errors.New("element not found")
+
+// ErrOutOfBounds indicates that an index provided to access something was invalid.
+var ErrOutOfBounds = errors.New("out of bounds")
+
+// Document is a raw bytes representation of a BSON document.
+type Document []byte
+
+// NewDocumentFromReader reads a document from r. This function will only validate the length is
+// correct and that the document ends with a null byte.
+func NewDocumentFromReader(r io.Reader) (Document, error) {
+	return newBufferFromReader(r)
+}
+
+func newBufferFromReader(r io.Reader) ([]byte, error) {
+	if r == nil {
+		return nil, ErrNilReader
+	}
+
+	var lengthBytes [4]byte
+
+	// ReadFull guarantees that we will have read at least len(lengthBytes) if err == nil
+	_, err := io.ReadFull(r, lengthBytes[:])
+	if err != nil {
+		return nil, err
+	}
+
+	length, _, _ := readi32(lengthBytes[:]) // ignore ok since we always have enough bytes to read a length
+	if length < 0 {
+		return nil, ErrInvalidLength
+	}
+	buffer := make([]byte, length)
+
+	copy(buffer, lengthBytes[:])
+
+	_, err = io.ReadFull(r, buffer[4:])
+	if err != nil {
+		return nil, err
+	}
+
+	if buffer[length-1] != 0x00 {
+		return nil, ErrMissingNull
+	}
+
+	return buffer, nil
+}
+
+// Lookup searches the document, potentially recursively, for the given key. If there are multiple
+// keys provided, this method will recurse down, as long as the top and intermediate nodes are
+// either documents or arrays. If an error occurs or if the value doesn't exist, an empty Value is
+// returned.
+func (d Document) Lookup(key ...string) Value {
+	val, _ := d.LookupErr(key...)
+	return val
+}
+
+// LookupErr is the same as Lookup, except it returns an error in addition to an empty Value.
+func (d Document) LookupErr(key ...string) (Value, error) {
+	if len(key) < 1 {
+		return Value{}, ErrEmptyKey
+	}
+	length, rem, ok := ReadLength(d)
+	if !ok {
+		return Value{}, NewInsufficientBytesError(d, rem)
+	}
+
+	length -= 4
+
+	var elem Element
+	for length > 1 {
+		elem, rem, ok = ReadElement(rem)
+		length -= int32(len(elem))
+		if !ok {
+			return Value{}, NewInsufficientBytesError(d, rem)
+		}
+		// We use `KeyBytes` rather than `Key` to avoid a needless string alloc.
+		if string(elem.KeyBytes()) != key[0] {
+			continue
+		}
+		if len(key) > 1 {
+			tt := Type(elem[0])
+			switch tt {
+			case TypeEmbeddedDocument:
+				val, err := elem.Value().Document().LookupErr(key[1:]...)
+				if err != nil {
+					return Value{}, err
+				}
+				return val, nil
+			case TypeArray:
+				// Convert to Document to continue Lookup recursion.
+				val, err := Document(elem.Value().Array()).LookupErr(key[1:]...)
+				if err != nil {
+					return Value{}, err
+				}
+				return val, nil
+			default:
+				return Value{}, InvalidDepthTraversalError{Key: elem.Key(), Type: tt}
+			}
+		}
+		return elem.ValueErr()
+	}
+	return Value{}, ErrElementNotFound
+}
+
+// Index searches for and retrieves the element at the given index. This method will panic if
+// the document is invalid or if the index is out of bounds.
+func (d Document) Index(index uint) Element {
+	elem, err := d.IndexErr(index)
+	if err != nil {
+		panic(err)
+	}
+	return elem
+}
+
+// IndexErr searches for and retrieves the element at the given index.
+func (d Document) IndexErr(index uint) (Element, error) {
+	return indexErr(d, index)
+}
+
+func indexErr(b []byte, index uint) (Element, error) {
+	length, rem, ok := ReadLength(b)
+	if !ok {
+		return nil, NewInsufficientBytesError(b, rem)
+	}
+
+	length -= 4
+
+	var current uint
+	var elem Element
+	for length > 1 {
+		elem, rem, ok = ReadElement(rem)
+		length -= int32(len(elem))
+		if !ok {
+			return nil, NewInsufficientBytesError(b, rem)
+		}
+		if current != index {
+			current++
+			continue
+		}
+		return elem, nil
+	}
+	return nil, ErrOutOfBounds
+}
+
+// DebugString outputs a human readable version of Document. It will attempt to stringify the
+// valid components of the document even if the entire document is not valid.
+func (d Document) DebugString() string {
+	if len(d) < 5 {
+		return "<malformed>"
+	}
+	var buf strings.Builder
+	buf.WriteString("Document")
+	length, rem, _ := ReadLength(d) // We know we have enough bytes to read the length
+	buf.WriteByte('(')
+	buf.WriteString(strconv.Itoa(int(length)))
+	length -= 4
+	buf.WriteString("){")
+	var elem Element
+	var ok bool
+	for length > 1 {
+		elem, rem, ok = ReadElement(rem)
+		length -= int32(len(elem))
+		if !ok {
+			buf.WriteString(fmt.Sprintf("<malformed (%d)>", length))
+			break
+		}
+		buf.WriteString(elem.DebugString())
+	}
+	buf.WriteByte('}')
+
+	return buf.String()
+}
+
+// String outputs an ExtendedJSON version of Document. If the document is not valid, this method
+// returns an empty string.
+func (d Document) String() string {
+	return d.StringN(math.MaxInt)
+}
+
+// StringN stringifies a document upto N bytes
+func (d Document) StringN(n int) string {
+	if len(d) < 5 || n <= 0 {
+		return ""
+	}
+
+	var buf strings.Builder
+
+	buf.WriteByte('{')
+
+	length, rem, _ := ReadLength(d)
+	length -= 4
+
+	var elem Element
+	var ok bool
+
+	first := true
+	truncated := false
+
+	if n > 0 {
+		for length > 1 {
+			if !first {
+				buf.WriteByte(',')
+			}
+			elem, rem, ok = ReadElement(rem)
+			length -= int32(len(elem))
+			if !ok {
+				return ""
+			}
+
+			str := elem.StringN(n)
+			if buf.Len()+len(str) > n {
+				truncatedStr := bsoncoreutil.Truncate(str, n-buf.Len())
+				buf.WriteString(truncatedStr)
+
+				truncated = true
+				break
+			}
+
+			buf.WriteString(str)
+			first = false
+		}
+	}
+
+	if !truncated {
+		buf.WriteByte('}')
+	}
+
+	return buf.String()
+}
+
+// Elements returns this document as a slice of elements. The returned slice will contain valid
+// elements. If the document is not valid, the elements up to the invalid point will be returned
+// along with an error.
+func (d Document) Elements() ([]Element, error) {
+	length, rem, ok := ReadLength(d)
+	if !ok {
+		return nil, NewInsufficientBytesError(d, rem)
+	}
+
+	length -= 4
+
+	var elem Element
+	var elems []Element
+	for length > 1 {
+		elem, rem, ok = ReadElement(rem)
+		length -= int32(len(elem))
+		if !ok {
+			return elems, NewInsufficientBytesError(d, rem)
+		}
+		if err := elem.Validate(); err != nil {
+			return elems, err
+		}
+		elems = append(elems, elem)
+	}
+	return elems, nil
+}
+
+// Values returns this document as a slice of values. The returned slice will contain valid values.
+// If the document is not valid, the values up to the invalid point will be returned along with an
+// error.
+func (d Document) Values() ([]Value, error) {
+	return values(d)
+}
+
+func values(b []byte) ([]Value, error) {
+	length, rem, ok := ReadLength(b)
+	if !ok {
+		return nil, NewInsufficientBytesError(b, rem)
+	}
+
+	length -= 4
+
+	var elem Element
+	var vals []Value
+	for length > 1 {
+		elem, rem, ok = ReadElement(rem)
+		length -= int32(len(elem))
+		if !ok {
+			return vals, NewInsufficientBytesError(b, rem)
+		}
+		if err := elem.Value().Validate(); err != nil {
+			return vals, err
+		}
+		vals = append(vals, elem.Value())
+	}
+	return vals, nil
+}
+
+// Validate validates the document and ensures the elements contained within are valid.
+func (d Document) Validate() error {
+	length, rem, ok := ReadLength(d)
+	if !ok {
+		return NewInsufficientBytesError(d, rem)
+	}
+	if int(length) > len(d) {
+		return NewDocumentLengthError(int(length), len(d))
+	}
+	if d[length-1] != 0x00 {
+		return ErrMissingNull
+	}
+
+	length -= 4
+	var elem Element
+
+	for length > 1 {
+		elem, rem, ok = ReadElement(rem)
+		length -= int32(len(elem))
+		if !ok {
+			return NewInsufficientBytesError(d, rem)
+		}
+		err := elem.Validate()
+		if err != nil {
+			return err
+		}
+	}
+
+	if len(rem) < 1 || rem[0] != 0x00 {
+		return ErrMissingNull
+	}
+	return nil
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/element.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/element.go
new file mode 100644
index 00000000..dcb5e86e
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/element.go
@@ -0,0 +1,166 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bsoncore
+
+import (
+	"bytes"
+	"fmt"
+	"math"
+)
+
+// MalformedElementError represents a class of errors that RawElement methods return.
+type MalformedElementError string
+
+func (mee MalformedElementError) Error() string { return string(mee) }
+
+// ErrElementMissingKey is returned when a RawElement is missing a key.
+const ErrElementMissingKey MalformedElementError = "element is missing key"
+
+// ErrElementMissingType is returned when a RawElement is missing a type.
+const ErrElementMissingType MalformedElementError = "element is missing type"
+
+// Element is a raw bytes representation of a BSON element.
+type Element []byte
+
+// Key returns the key for this element. If the element is not valid, this method returns an empty
+// string. If knowing if the element is valid is important, use KeyErr.
+func (e Element) Key() string {
+	key, _ := e.KeyErr()
+	return key
+}
+
+// KeyBytes returns the key for this element as a []byte. If the element is not valid, this method
+// returns an empty string. If knowing if the element is valid is important, use KeyErr. This method
+// will not include the null byte at the end of the key in the slice of bytes.
+func (e Element) KeyBytes() []byte {
+	key, _ := e.KeyBytesErr()
+	return key
+}
+
+// KeyErr returns the key for this element, returning an error if the element is not valid.
+func (e Element) KeyErr() (string, error) {
+	key, err := e.KeyBytesErr()
+	return string(key), err
+}
+
+// KeyBytesErr returns the key for this element as a []byte, returning an error if the element is
+// not valid.
+func (e Element) KeyBytesErr() ([]byte, error) {
+	if len(e) == 0 {
+		return nil, ErrElementMissingType
+	}
+	idx := bytes.IndexByte(e[1:], 0x00)
+	if idx == -1 {
+		return nil, ErrElementMissingKey
+	}
+	return e[1 : idx+1], nil
+}
+
+// Validate ensures the element is a valid BSON element.
+func (e Element) Validate() error {
+	if len(e) < 1 {
+		return ErrElementMissingType
+	}
+	idx := bytes.IndexByte(e[1:], 0x00)
+	if idx == -1 {
+		return ErrElementMissingKey
+	}
+	return Value{Type: Type(e[0]), Data: e[idx+2:]}.Validate()
+}
+
+// CompareKey will compare this element's key to key. This method makes it easy to compare keys
+// without needing to allocate a string. The key may be null terminated. If a valid key cannot be
+// read this method will return false.
+func (e Element) CompareKey(key []byte) bool {
+	if len(e) < 2 {
+		return false
+	}
+	idx := bytes.IndexByte(e[1:], 0x00)
+	if idx == -1 {
+		return false
+	}
+	if index := bytes.IndexByte(key, 0x00); index > -1 {
+		key = key[:index]
+	}
+	return bytes.Equal(e[1:idx+1], key)
+}
+
+// Value returns the value of this element. If the element is not valid, this method returns an
+// empty Value. If knowing if the element is valid is important, use ValueErr.
+func (e Element) Value() Value {
+	val, _ := e.ValueErr()
+	return val
+}
+
+// ValueErr returns the value for this element, returning an error if the element is not valid.
+func (e Element) ValueErr() (Value, error) {
+	if len(e) == 0 {
+		return Value{}, ErrElementMissingType
+	}
+	idx := bytes.IndexByte(e[1:], 0x00)
+	if idx == -1 {
+		return Value{}, ErrElementMissingKey
+	}
+
+	val, rem, exists := ReadValue(e[idx+2:], Type(e[0]))
+	if !exists {
+		return Value{}, NewInsufficientBytesError(e, rem)
+	}
+	return val, nil
+}
+
+// String implements the fmt.String interface. The output will be in extended JSON format.
+func (e Element) String() string {
+	return e.StringN(math.MaxInt)
+}
+
+// StringN implements the fmt.String interface for upto N bytes. The output will be in extended JSON format.
+func (e Element) StringN(n int) string {
+	if len(e) == 0 {
+		return ""
+	}
+	t := Type(e[0])
+	idx := bytes.IndexByte(e[1:], 0x00)
+	if idx == -1 {
+		return ""
+	}
+	key, valBytes := []byte(e[1:idx+1]), []byte(e[idx+2:])
+	val, _, valid := ReadValue(valBytes, t)
+	if !valid {
+		return ""
+	}
+
+	var str string
+	if _, ok := val.StringValueOK(); ok {
+		str = val.StringN(n)
+	} else if arr, ok := val.ArrayOK(); ok {
+		str = arr.StringN(n)
+	} else {
+		str = val.String()
+	}
+
+	return "\"" + string(key) + "\": " + str
+}
+
+// DebugString outputs a human readable version of RawElement. It will attempt to stringify the
+// valid components of the element even if the entire element is not valid.
+func (e Element) DebugString() string {
+	if len(e) == 0 {
+		return "<malformed>"
+	}
+	t := Type(e[0])
+	idx := bytes.IndexByte(e[1:], 0x00)
+	if idx == -1 {
+		return fmt.Sprintf(`bson.Element{[%s]<malformed>}`, t)
+	}
+	key, valBytes := []byte(e[1:idx+1]), []byte(e[idx+2:])
+	val, _, valid := ReadValue(valBytes, t)
+	if !valid {
+		return fmt.Sprintf(`bson.Element{[%s]"%s": <malformed>}`, t, key)
+	}
+	return fmt.Sprintf(`bson.Element{[%s]"%s": %v}`, t, key, val)
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/iterator.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/iterator.go
new file mode 100644
index 00000000..9c8ea5b8
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/iterator.go
@@ -0,0 +1,113 @@
+// Copyright (C) MongoDB, Inc. 2022-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bsoncore
+
+import (
+	"errors"
+	"fmt"
+	"io"
+)
+
+// errCorruptedDocument is returned when a full document couldn't be read from
+// the sequence.
+var errCorruptedDocument = errors.New("invalid DocumentSequence: corrupted document")
+
+// Iterator maintains a list of BSON values and keeps track of the current
+// position in relation to its Next() method.
+type Iterator struct {
+	List Array // List of BSON values
+	pos  int   // The position of the iterator in the list in reference to Next()
+}
+
+// Count returned the number of elements in the iterator's list.
+func (iter *Iterator) Count() int {
+	if iter == nil {
+		return 0
+	}
+
+	_, rem, ok := ReadLength(iter.List)
+	if !ok {
+		return 0
+	}
+
+	var count int
+	for len(rem) > 1 {
+		_, rem, ok = ReadElement(rem)
+		if !ok {
+			return 0
+		}
+		count++
+	}
+	return count
+}
+
+// Empty returns true if the iterator's list is empty.
+func (iter *Iterator) Empty() bool {
+	return len(iter.List) <= 5
+}
+
+// Reset will reset the iteration point for the Next method to the beginning of
+// the list.
+func (iter *Iterator) Reset() {
+	iter.pos = 0
+}
+
+// Documents traverses the list as documents and returns them. This method
+// assumes that the underlying list is composed of documents and will return
+// an error otherwise.
+func (iter *Iterator) Documents() ([]Document, error) {
+	if iter == nil || len(iter.List) == 0 {
+		return nil, nil
+	}
+
+	vals, err := iter.List.Values()
+	if err != nil {
+		return nil, errCorruptedDocument
+	}
+
+	docs := make([]Document, 0, len(vals))
+	for _, v := range vals {
+		if v.Type != TypeEmbeddedDocument {
+			return nil, fmt.Errorf("invalid DocumentSequence: a non-document value was found in sequence")
+		}
+
+		docs = append(docs, v.Data)
+	}
+
+	return docs, nil
+}
+
+// Next retrieves the next value from the list and returns it. This method will
+// return io.EOF when it has reached the end of the list.
+func (iter *Iterator) Next() (*Value, error) {
+	if iter == nil || iter.pos >= len(iter.List) {
+		return nil, io.EOF
+	}
+
+	if iter.pos < 4 {
+		if len(iter.List) < 4 {
+			return nil, errCorruptedDocument
+		}
+
+		iter.pos = 4 // Skip the length of the document
+	}
+
+	rem := iter.List[iter.pos:]
+	if len(rem) == 1 && rem[0] == 0x00 {
+		return nil, io.EOF // At the end of the document
+	}
+
+	elem, _, ok := ReadElement(rem)
+	if !ok {
+		return nil, errCorruptedDocument
+	}
+
+	iter.pos += len(elem)
+	val := elem.Value()
+
+	return &val, nil
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/tables.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/tables.go
new file mode 100644
index 00000000..9fd903fd
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/tables.go
@@ -0,0 +1,223 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+//
+// Based on github.com/golang/go by The Go Authors
+// See THIRD-PARTY-NOTICES for original license terms.
+
+package bsoncore
+
+import "unicode/utf8"
+
+// safeSet holds the value true if the ASCII character with the given array
+// position can be represented inside a JSON string without any further
+// escaping.
+//
+// All values are true except for the ASCII control characters (0-31), the
+// double quote ("), and the backslash character ("\").
+var safeSet = [utf8.RuneSelf]bool{
+	' ':      true,
+	'!':      true,
+	'"':      false,
+	'#':      true,
+	'$':      true,
+	'%':      true,
+	'&':      true,
+	'\'':     true,
+	'(':      true,
+	')':      true,
+	'*':      true,
+	'+':      true,
+	',':      true,
+	'-':      true,
+	'.':      true,
+	'/':      true,
+	'0':      true,
+	'1':      true,
+	'2':      true,
+	'3':      true,
+	'4':      true,
+	'5':      true,
+	'6':      true,
+	'7':      true,
+	'8':      true,
+	'9':      true,
+	':':      true,
+	';':      true,
+	'<':      true,
+	'=':      true,
+	'>':      true,
+	'?':      true,
+	'@':      true,
+	'A':      true,
+	'B':      true,
+	'C':      true,
+	'D':      true,
+	'E':      true,
+	'F':      true,
+	'G':      true,
+	'H':      true,
+	'I':      true,
+	'J':      true,
+	'K':      true,
+	'L':      true,
+	'M':      true,
+	'N':      true,
+	'O':      true,
+	'P':      true,
+	'Q':      true,
+	'R':      true,
+	'S':      true,
+	'T':      true,
+	'U':      true,
+	'V':      true,
+	'W':      true,
+	'X':      true,
+	'Y':      true,
+	'Z':      true,
+	'[':      true,
+	'\\':     false,
+	']':      true,
+	'^':      true,
+	'_':      true,
+	'`':      true,
+	'a':      true,
+	'b':      true,
+	'c':      true,
+	'd':      true,
+	'e':      true,
+	'f':      true,
+	'g':      true,
+	'h':      true,
+	'i':      true,
+	'j':      true,
+	'k':      true,
+	'l':      true,
+	'm':      true,
+	'n':      true,
+	'o':      true,
+	'p':      true,
+	'q':      true,
+	'r':      true,
+	's':      true,
+	't':      true,
+	'u':      true,
+	'v':      true,
+	'w':      true,
+	'x':      true,
+	'y':      true,
+	'z':      true,
+	'{':      true,
+	'|':      true,
+	'}':      true,
+	'~':      true,
+	'\u007f': true,
+}
+
+// htmlSafeSet holds the value true if the ASCII character with the given
+// array position can be safely represented inside a JSON string, embedded
+// inside of HTML <script> tags, without any additional escaping.
+//
+// All values are true except for the ASCII control characters (0-31), the
+// double quote ("), the backslash character ("\"), HTML opening and closing
+// tags ("<" and ">"), and the ampersand ("&").
+var htmlSafeSet = [utf8.RuneSelf]bool{
+	' ':      true,
+	'!':      true,
+	'"':      false,
+	'#':      true,
+	'$':      true,
+	'%':      true,
+	'&':      false,
+	'\'':     true,
+	'(':      true,
+	')':      true,
+	'*':      true,
+	'+':      true,
+	',':      true,
+	'-':      true,
+	'.':      true,
+	'/':      true,
+	'0':      true,
+	'1':      true,
+	'2':      true,
+	'3':      true,
+	'4':      true,
+	'5':      true,
+	'6':      true,
+	'7':      true,
+	'8':      true,
+	'9':      true,
+	':':      true,
+	';':      true,
+	'<':      false,
+	'=':      true,
+	'>':      false,
+	'?':      true,
+	'@':      true,
+	'A':      true,
+	'B':      true,
+	'C':      true,
+	'D':      true,
+	'E':      true,
+	'F':      true,
+	'G':      true,
+	'H':      true,
+	'I':      true,
+	'J':      true,
+	'K':      true,
+	'L':      true,
+	'M':      true,
+	'N':      true,
+	'O':      true,
+	'P':      true,
+	'Q':      true,
+	'R':      true,
+	'S':      true,
+	'T':      true,
+	'U':      true,
+	'V':      true,
+	'W':      true,
+	'X':      true,
+	'Y':      true,
+	'Z':      true,
+	'[':      true,
+	'\\':     false,
+	']':      true,
+	'^':      true,
+	'_':      true,
+	'`':      true,
+	'a':      true,
+	'b':      true,
+	'c':      true,
+	'd':      true,
+	'e':      true,
+	'f':      true,
+	'g':      true,
+	'h':      true,
+	'i':      true,
+	'j':      true,
+	'k':      true,
+	'l':      true,
+	'm':      true,
+	'n':      true,
+	'o':      true,
+	'p':      true,
+	'q':      true,
+	'r':      true,
+	's':      true,
+	't':      true,
+	'u':      true,
+	'v':      true,
+	'w':      true,
+	'x':      true,
+	'y':      true,
+	'z':      true,
+	'{':      true,
+	'|':      true,
+	'}':      true,
+	'~':      true,
+	'\u007f': true,
+}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/type.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/type.go
new file mode 100644
index 00000000..30b6cc43
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/type.go
@@ -0,0 +1,85 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bsoncore
+
+// Type represents a BSON type.
+type Type byte
+
+// String returns the string representation of the BSON type's name.
+func (bt Type) String() string {
+	switch bt {
+	case '\x01':
+		return "double"
+	case '\x02':
+		return "string"
+	case '\x03':
+		return "embedded document"
+	case '\x04':
+		return "array"
+	case '\x05':
+		return "binary"
+	case '\x06':
+		return "undefined"
+	case '\x07':
+		return "objectID"
+	case '\x08':
+		return "boolean"
+	case '\x09':
+		return "UTC datetime"
+	case '\x0A':
+		return "null"
+	case '\x0B':
+		return "regex"
+	case '\x0C':
+		return "dbPointer"
+	case '\x0D':
+		return "javascript"
+	case '\x0E':
+		return "symbol"
+	case '\x0F':
+		return "code with scope"
+	case '\x10':
+		return "32-bit integer"
+	case '\x11':
+		return "timestamp"
+	case '\x12':
+		return "64-bit integer"
+	case '\x13':
+		return "128-bit decimal"
+	case '\x7F':
+		return "max key"
+	case '\xFF':
+		return "min key"
+	default:
+		return "invalid"
+	}
+}
+
+// BSON element types as described in https://bsonspec.org/spec.html.
+const (
+	TypeDouble           Type = 0x01
+	TypeString           Type = 0x02
+	TypeEmbeddedDocument Type = 0x03
+	TypeArray            Type = 0x04
+	TypeBinary           Type = 0x05
+	TypeUndefined        Type = 0x06
+	TypeObjectID         Type = 0x07
+	TypeBoolean          Type = 0x08
+	TypeDateTime         Type = 0x09
+	TypeNull             Type = 0x0A
+	TypeRegex            Type = 0x0B
+	TypeDBPointer        Type = 0x0C
+	TypeJavaScript       Type = 0x0D
+	TypeSymbol           Type = 0x0E
+	TypeCodeWithScope    Type = 0x0F
+	TypeInt32            Type = 0x10
+	TypeTimestamp        Type = 0x11
+	TypeInt64            Type = 0x12
+	TypeDecimal128       Type = 0x13
+	TypeMaxKey           Type = 0x7F
+	TypeMinKey           Type = 0xFF
+)
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/value.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/value.go
new file mode 100644
index 00000000..b0fd9074
--- /dev/null
+++ b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/value.go
@@ -0,0 +1,986 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bsoncore
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/hex"
+	"fmt"
+	"math"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"go.mongodb.org/mongo-driver/v2/internal/bsoncoreutil"
+	"go.mongodb.org/mongo-driver/v2/internal/decimal128"
+)
+
+// ElementTypeError specifies that a method to obtain a BSON value an incorrect type was called on a bson.Value.
+type ElementTypeError struct {
+	Method string
+	Type   Type
+}
+
+// Error implements the error interface.
+func (ete ElementTypeError) Error() string {
+	return "Call of " + ete.Method + " on " + ete.Type.String() + " type"
+}
+
+// Value represents a BSON value with a type and raw bytes.
+type Value struct {
+	Type Type
+	Data []byte
+}
+
+// Validate ensures the value is a valid BSON value.
+func (v Value) Validate() error {
+	_, _, valid := readValue(v.Data, v.Type)
+	if !valid {
+		return NewInsufficientBytesError(v.Data, v.Data)
+	}
+	return nil
+}
+
+// IsNumber returns true if the type of v is a numeric BSON type.
+func (v Value) IsNumber() bool {
+	switch v.Type {
+	case TypeDouble, TypeInt32, TypeInt64, TypeDecimal128:
+		return true
+	default:
+		return false
+	}
+}
+
+// AsInt32 returns a BSON number as an int32. If the BSON type is not a numeric one, this method
+// will panic.
+func (v Value) AsInt32() int32 {
+	if !v.IsNumber() {
+		panic(ElementTypeError{"bsoncore.Value.AsInt32", v.Type})
+	}
+	var i32 int32
+	switch v.Type {
+	case TypeDouble:
+		f64, _, ok := ReadDouble(v.Data)
+		if !ok {
+			panic(NewInsufficientBytesError(v.Data, v.Data))
+		}
+		i32 = int32(f64)
+	case TypeInt32:
+		var ok bool
+		i32, _, ok = ReadInt32(v.Data)
+		if !ok {
+			panic(NewInsufficientBytesError(v.Data, v.Data))
+		}
+	case TypeInt64:
+		i64, _, ok := ReadInt64(v.Data)
+		if !ok {
+			panic(NewInsufficientBytesError(v.Data, v.Data))
+		}
+		i32 = int32(i64)
+	case TypeDecimal128:
+		panic(ElementTypeError{"bsoncore.Value.AsInt32", v.Type})
+	}
+	return i32
+}
+
+// AsInt32OK functions the same as AsInt32 but returns a boolean instead of panicking. False
+// indicates an error.
+func (v Value) AsInt32OK() (int32, bool) {
+	if !v.IsNumber() {
+		return 0, false
+	}
+	var i32 int32
+	switch v.Type {
+	case TypeDouble:
+		f64, _, ok := ReadDouble(v.Data)
+		if !ok {
+			return 0, false
+		}
+		i32 = int32(f64)
+	case TypeInt32:
+		var ok bool
+		i32, _, ok = ReadInt32(v.Data)
+		if !ok {
+			return 0, false
+		}
+	case TypeInt64:
+		i64, _, ok := ReadInt64(v.Data)
+		if !ok {
+			return 0, false
+		}
+		i32 = int32(i64)
+	case TypeDecimal128:
+		return 0, false
+	}
+	return i32, true
+}
+
+// AsInt64 returns a BSON number as an int64. If the BSON type is not a numeric one, this method
+// will panic.
+func (v Value) AsInt64() int64 {
+	if !v.IsNumber() {
+		panic(ElementTypeError{"bsoncore.Value.AsInt64", v.Type})
+	}
+	var i64 int64
+	switch v.Type {
+	case TypeDouble:
+		f64, _, ok := ReadDouble(v.Data)
+		if !ok {
+			panic(NewInsufficientBytesError(v.Data, v.Data))
+		}
+		i64 = int64(f64)
+	case TypeInt32:
+		var ok bool
+		i32, _, ok := ReadInt32(v.Data)
+		if !ok {
+			panic(NewInsufficientBytesError(v.Data, v.Data))
+		}
+		i64 = int64(i32)
+	case TypeInt64:
+		var ok bool
+		i64, _, ok = ReadInt64(v.Data)
+		if !ok {
+			panic(NewInsufficientBytesError(v.Data, v.Data))
+		}
+	case TypeDecimal128:
+		panic(ElementTypeError{"bsoncore.Value.AsInt64", v.Type})
+	}
+	return i64
+}
+
+// AsInt64OK functions the same as AsInt64 but returns a boolean instead of panicking. False
+// indicates an error.
+func (v Value) AsInt64OK() (int64, bool) {
+	if !v.IsNumber() {
+		return 0, false
+	}
+	var i64 int64
+	switch v.Type {
+	case TypeDouble:
+		f64, _, ok := ReadDouble(v.Data)
+		if !ok {
+			return 0, false
+		}
+		i64 = int64(f64)
+	case TypeInt32:
+		var ok bool
+		i32, _, ok := ReadInt32(v.Data)
+		if !ok {
+			return 0, false
+		}
+		i64 = int64(i32)
+	case TypeInt64:
+		var ok bool
+		i64, _, ok = ReadInt64(v.Data)
+		if !ok {
+			return 0, false
+		}
+	case TypeDecimal128:
+		return 0, false
+	}
+	return i64, true
+}
+
+// AsFloat64 returns a BSON number as an float64. If the BSON type is not a numeric one, this method
+// will panic.
+//
+// TODO(GODRIVER-2751): Implement AsFloat64.
+// func (v Value) AsFloat64() float64
+
+// AsFloat64OK functions the same as AsFloat64 but returns a boolean instead of panicking. False
+// indicates an error.
+//
+// TODO(GODRIVER-2751): Implement AsFloat64OK.
+// func (v Value) AsFloat64OK() (float64, bool)
+
+// Equal compaes v to v2 and returns true if they are equal.
+func (v Value) Equal(v2 Value) bool {
+	if v.Type != v2.Type {
+		return false
+	}
+
+	return bytes.Equal(v.Data, v2.Data)
+}
+
+func idHex(id [12]byte) string {
+	var buf [24]byte
+	hex.Encode(buf[:], id[:])
+	return string(buf[:])
+}
+
+// String implements the fmt.String interface. This method will return values in extended JSON
+// format. If the value is not valid, this returns an empty string
+func (v Value) String() string {
+	return v.StringN(math.MaxInt)
+}
+
+// StringN implements the fmt.String interface. This method will return values in extended JSON
+// format that will stringify a value upto N bytes. If the value is not valid, this returns an empty string
+func (v Value) StringN(n int) string {
+	if n <= 0 {
+		return ""
+	}
+
+	switch v.Type {
+	case TypeString:
+		str, ok := v.StringValueOK()
+		if !ok {
+			return ""
+		}
+		str = escapeString(str)
+		if len(str) > n {
+			truncatedStr := bsoncoreutil.Truncate(str, n)
+			return truncatedStr
+		}
+		return str
+	case TypeEmbeddedDocument:
+		doc, ok := v.DocumentOK()
+		if !ok {
+			return ""
+		}
+		return doc.StringN(n)
+	case TypeArray:
+		arr, ok := v.ArrayOK()
+		if !ok {
+			return ""
+		}
+		return arr.StringN(n)
+	case TypeDouble:
+		f64, ok := v.DoubleOK()
+		if !ok {
+			return ""
+		}
+		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$numberDouble":"%s"}`, formatDouble(f64)), n)
+	case TypeBinary:
+		subtype, data, ok := v.BinaryOK()
+		if !ok {
+			return ""
+		}
+		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$binary":{"base64":"%s","subType":"%02x"}}`, base64.StdEncoding.EncodeToString(data), subtype), n)
+	case TypeUndefined:
+		return bsoncoreutil.Truncate(`{"$undefined":true}`, n)
+	case TypeObjectID:
+		oid, ok := v.ObjectIDOK()
+		if !ok {
+			return ""
+		}
+		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$oid":"%s"}`, idHex(oid)), n)
+	case TypeBoolean:
+		b, ok := v.BooleanOK()
+		if !ok {
+			return ""
+		}
+		return bsoncoreutil.Truncate(strconv.FormatBool(b), n)
+	case TypeDateTime:
+		dt, ok := v.DateTimeOK()
+		if !ok {
+			return ""
+		}
+		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$date":{"$numberLong":"%d"}}`, dt), n)
+	case TypeNull:
+		return bsoncoreutil.Truncate("null", n)
+	case TypeRegex:
+		pattern, options, ok := v.RegexOK()
+		if !ok {
+			return ""
+		}
+		return bsoncoreutil.Truncate(fmt.Sprintf(
+			`{"$regularExpression":{"pattern":%s,"options":"%s"}}`,
+			escapeString(pattern), sortStringAlphebeticAscending(options),
+		), n)
+	case TypeDBPointer:
+		ns, pointer, ok := v.DBPointerOK()
+		if !ok {
+			return ""
+		}
+		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$dbPointer":{"$ref":%s,"$id":{"$oid":"%s"}}}`, escapeString(ns), idHex(pointer)), n)
+	case TypeJavaScript:
+		js, ok := v.JavaScriptOK()
+		if !ok {
+			return ""
+		}
+		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$code":%s}`, escapeString(js)), n)
+	case TypeSymbol:
+		symbol, ok := v.SymbolOK()
+		if !ok {
+			return ""
+		}
+		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$symbol":%s}`, escapeString(symbol)), n)
+	case TypeCodeWithScope:
+		code, scope, ok := v.CodeWithScopeOK()
+		if !ok {
+			return ""
+		}
+		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$code":%s,"$scope":%s}`, code, scope), n)
+	case TypeInt32:
+		i32, ok := v.Int32OK()
+		if !ok {
+			return ""
+		}
+		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$numberInt":"%d"}`, i32), n)
+	case TypeTimestamp:
+		t, i, ok := v.TimestampOK()
+		if !ok {
+			return ""
+		}
+		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$timestamp":{"t":%v,"i":%v}}`, t, i), n)
+	case TypeInt64:
+		i64, ok := v.Int64OK()
+		if !ok {
+			return ""
+		}
+		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$numberLong":"%d"}`, i64), n)
+	case TypeDecimal128:
+		h, l, ok := v.Decimal128OK()
+		if !ok {
+			return ""
+		}
+		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$numberDecimal":"%s"}`, decimal128.String(h, l)), n)
+	case TypeMinKey:
+		return bsoncoreutil.Truncate(`{"$minKey":1}`, n)
+	case TypeMaxKey:
+		return bsoncoreutil.Truncate(`{"$maxKey":1}`, n)
+	default:
+		return ""
+	}
+}
+
+// DebugString outputs a human readable version of Document. It will attempt to stringify the
+// valid components of the document even if the entire document is not valid.
+func (v Value) DebugString() string {
+	switch v.Type {
+	case TypeString:
+		str, ok := v.StringValueOK()
+		if !ok {
+			return "<malformed>"
+		}
+		return escapeString(str)
+	case TypeEmbeddedDocument:
+		doc, ok := v.DocumentOK()
+		if !ok {
+			return "<malformed>"
+		}
+		return doc.DebugString()
+	case TypeArray:
+		arr, ok := v.ArrayOK()
+		if !ok {
+			return "<malformed>"
+		}
+		return arr.DebugString()
+	case TypeCodeWithScope:
+		code, scope, ok := v.CodeWithScopeOK()
+		if !ok {
+			return ""
+		}
+		return fmt.Sprintf(`{"$code":%s,"$scope":%s}`, code, scope.DebugString())
+	default:
+		str := v.String()
+		if str == "" {
+			return "<malformed>"
+		}
+		return str
+	}
+}
+
+// Double returns the float64 value for this element.
+// It panics if e's BSON type is not TypeDouble.
+func (v Value) Double() float64 {
+	if v.Type != TypeDouble {
+		panic(ElementTypeError{"bsoncore.Value.Double", v.Type})
+	}
+	f64, _, ok := ReadDouble(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return f64
+}
+
+// DoubleOK is the same as Double, but returns a boolean instead of panicking.
+func (v Value) DoubleOK() (float64, bool) {
+	if v.Type != TypeDouble {
+		return 0, false
+	}
+	f64, _, ok := ReadDouble(v.Data)
+	if !ok {
+		return 0, false
+	}
+	return f64, true
+}
+
+// StringValue returns the string balue for this element.
+// It panics if e's BSON type is not TypeString.
+//
+// NOTE: This method is called StringValue to avoid a collision with the String method which
+// implements the fmt.Stringer interface.
+func (v Value) StringValue() string {
+	if v.Type != TypeString {
+		panic(ElementTypeError{"bsoncore.Value.StringValue", v.Type})
+	}
+	str, _, ok := ReadString(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return str
+}
+
+// StringValueOK is the same as StringValue, but returns a boolean instead of
+// panicking.
+func (v Value) StringValueOK() (string, bool) {
+	if v.Type != TypeString {
+		return "", false
+	}
+	str, _, ok := ReadString(v.Data)
+	if !ok {
+		return "", false
+	}
+	return str, true
+}
+
+// Document returns the BSON document the Value represents as a Document. It panics if the
+// value is a BSON type other than document.
+func (v Value) Document() Document {
+	if v.Type != TypeEmbeddedDocument {
+		panic(ElementTypeError{"bsoncore.Value.Document", v.Type})
+	}
+	doc, _, ok := ReadDocument(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return doc
+}
+
+// DocumentOK is the same as Document, except it returns a boolean
+// instead of panicking.
+func (v Value) DocumentOK() (Document, bool) {
+	if v.Type != TypeEmbeddedDocument {
+		return nil, false
+	}
+	doc, _, ok := ReadDocument(v.Data)
+	if !ok {
+		return nil, false
+	}
+	return doc, true
+}
+
+// Array returns the BSON array the Value represents as an Array. It panics if the
+// value is a BSON type other than array.
+func (v Value) Array() Array {
+	if v.Type != TypeArray {
+		panic(ElementTypeError{"bsoncore.Value.Array", v.Type})
+	}
+	arr, _, ok := ReadArray(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return arr
+}
+
+// ArrayOK is the same as Array, except it returns a boolean instead
+// of panicking.
+func (v Value) ArrayOK() (Array, bool) {
+	if v.Type != TypeArray {
+		return nil, false
+	}
+	arr, _, ok := ReadArray(v.Data)
+	if !ok {
+		return nil, false
+	}
+	return arr, true
+}
+
+// Binary returns the BSON binary value the Value represents. It panics if the value is a BSON type
+// other than binary.
+func (v Value) Binary() (subtype byte, data []byte) {
+	if v.Type != TypeBinary {
+		panic(ElementTypeError{"bsoncore.Value.Binary", v.Type})
+	}
+	subtype, data, _, ok := ReadBinary(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return subtype, data
+}
+
+// BinaryOK is the same as Binary, except it returns a boolean instead of
+// panicking.
+func (v Value) BinaryOK() (subtype byte, data []byte, ok bool) {
+	if v.Type != TypeBinary {
+		return 0x00, nil, false
+	}
+	subtype, data, _, ok = ReadBinary(v.Data)
+	if !ok {
+		return 0x00, nil, false
+	}
+	return subtype, data, true
+}
+
+// ObjectID returns the BSON objectid value the Value represents. It panics if the value is a BSON
+// type other than objectid.
+func (v Value) ObjectID() objectID {
+	if v.Type != TypeObjectID {
+		panic(ElementTypeError{"bsoncore.Value.ObjectID", v.Type})
+	}
+	oid, _, ok := ReadObjectID(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return oid
+}
+
+// ObjectIDOK is the same as ObjectID, except it returns a boolean instead of
+// panicking.
+func (v Value) ObjectIDOK() (objectID, bool) {
+	if v.Type != TypeObjectID {
+		return objectID{}, false
+	}
+	oid, _, ok := ReadObjectID(v.Data)
+	if !ok {
+		return objectID{}, false
+	}
+	return oid, true
+}
+
+// Boolean returns the boolean value the Value represents. It panics if the
+// value is a BSON type other than boolean.
+func (v Value) Boolean() bool {
+	if v.Type != TypeBoolean {
+		panic(ElementTypeError{"bsoncore.Value.Boolean", v.Type})
+	}
+	b, _, ok := ReadBoolean(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return b
+}
+
+// BooleanOK is the same as Boolean, except it returns a boolean instead of
+// panicking.
+func (v Value) BooleanOK() (bool, bool) {
+	if v.Type != TypeBoolean {
+		return false, false
+	}
+	b, _, ok := ReadBoolean(v.Data)
+	if !ok {
+		return false, false
+	}
+	return b, true
+}
+
+// DateTime returns the BSON datetime value the Value represents as a
+// unix timestamp. It panics if the value is a BSON type other than datetime.
+func (v Value) DateTime() int64 {
+	if v.Type != TypeDateTime {
+		panic(ElementTypeError{"bsoncore.Value.DateTime", v.Type})
+	}
+	dt, _, ok := ReadDateTime(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return dt
+}
+
+// DateTimeOK is the same as DateTime, except it returns a boolean instead of
+// panicking.
+func (v Value) DateTimeOK() (int64, bool) {
+	if v.Type != TypeDateTime {
+		return 0, false
+	}
+	dt, _, ok := ReadDateTime(v.Data)
+	if !ok {
+		return 0, false
+	}
+	return dt, true
+}
+
+// Time returns the BSON datetime value the Value represents. It panics if the value is a BSON
+// type other than datetime.
+func (v Value) Time() time.Time {
+	if v.Type != TypeDateTime {
+		panic(ElementTypeError{"bsoncore.Value.Time", v.Type})
+	}
+	dt, _, ok := ReadDateTime(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return time.Unix(dt/1000, dt%1000*1000000)
+}
+
+// TimeOK is the same as Time, except it returns a boolean instead of
+// panicking.
+func (v Value) TimeOK() (time.Time, bool) {
+	if v.Type != TypeDateTime {
+		return time.Time{}, false
+	}
+	dt, _, ok := ReadDateTime(v.Data)
+	if !ok {
+		return time.Time{}, false
+	}
+	return time.Unix(dt/1000, dt%1000*1000000), true
+}
+
+// Regex returns the BSON regex value the Value represents. It panics if the value is a BSON
+// type other than regex.
+func (v Value) Regex() (pattern, options string) {
+	if v.Type != TypeRegex {
+		panic(ElementTypeError{"bsoncore.Value.Regex", v.Type})
+	}
+	pattern, options, _, ok := ReadRegex(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return pattern, options
+}
+
+// RegexOK is the same as Regex, except it returns a boolean instead of
+// panicking.
+func (v Value) RegexOK() (pattern, options string, ok bool) {
+	if v.Type != TypeRegex {
+		return "", "", false
+	}
+	pattern, options, _, ok = ReadRegex(v.Data)
+	if !ok {
+		return "", "", false
+	}
+	return pattern, options, true
+}
+
+// DBPointer returns the BSON dbpointer value the Value represents. It panics if the value is a BSON
+// type other than DBPointer.
+func (v Value) DBPointer() (string, objectID) {
+	if v.Type != TypeDBPointer {
+		panic(ElementTypeError{"bsoncore.Value.DBPointer", v.Type})
+	}
+	ns, pointer, _, ok := ReadDBPointer(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return ns, pointer
+}
+
+// DBPointerOK is the same as DBPoitner, except that it returns a boolean
+// instead of panicking.
+func (v Value) DBPointerOK() (string, objectID, bool) {
+	if v.Type != TypeDBPointer {
+		return "", objectID{}, false
+	}
+	ns, pointer, _, ok := ReadDBPointer(v.Data)
+	if !ok {
+		return "", objectID{}, false
+	}
+	return ns, pointer, true
+}
+
+// JavaScript returns the BSON JavaScript code value the Value represents. It panics if the value is
+// a BSON type other than JavaScript code.
+func (v Value) JavaScript() string {
+	if v.Type != TypeJavaScript {
+		panic(ElementTypeError{"bsoncore.Value.JavaScript", v.Type})
+	}
+	js, _, ok := ReadJavaScript(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return js
+}
+
+// JavaScriptOK is the same as Javascript, excepti that it returns a boolean
+// instead of panicking.
+func (v Value) JavaScriptOK() (string, bool) {
+	if v.Type != TypeJavaScript {
+		return "", false
+	}
+	js, _, ok := ReadJavaScript(v.Data)
+	if !ok {
+		return "", false
+	}
+	return js, true
+}
+
+// Symbol returns the BSON symbol value the Value represents. It panics if the value is a BSON
+// type other than symbol.
+func (v Value) Symbol() string {
+	if v.Type != TypeSymbol {
+		panic(ElementTypeError{"bsoncore.Value.Symbol", v.Type})
+	}
+	symbol, _, ok := ReadSymbol(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return symbol
+}
+
+// SymbolOK is the same as Symbol, excepti that it returns a boolean
+// instead of panicking.
+func (v Value) SymbolOK() (string, bool) {
+	if v.Type != TypeSymbol {
+		return "", false
+	}
+	symbol, _, ok := ReadSymbol(v.Data)
+	if !ok {
+		return "", false
+	}
+	return symbol, true
+}
+
+// CodeWithScope returns the BSON JavaScript code with scope the Value represents.
+// It panics if the value is a BSON type other than JavaScript code with scope.
+func (v Value) CodeWithScope() (string, Document) {
+	if v.Type != TypeCodeWithScope {
+		panic(ElementTypeError{"bsoncore.Value.CodeWithScope", v.Type})
+	}
+	code, scope, _, ok := ReadCodeWithScope(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return code, scope
+}
+
+// CodeWithScopeOK is the same as CodeWithScope, except that it returns a boolean instead of
+// panicking.
+func (v Value) CodeWithScopeOK() (string, Document, bool) {
+	if v.Type != TypeCodeWithScope {
+		return "", nil, false
+	}
+	code, scope, _, ok := ReadCodeWithScope(v.Data)
+	if !ok {
+		return "", nil, false
+	}
+	return code, scope, true
+}
+
+// Int32 returns the int32 the Value represents. It panics if the value is a BSON type other than
+// int32.
+func (v Value) Int32() int32 {
+	if v.Type != TypeInt32 {
+		panic(ElementTypeError{"bsoncore.Value.Int32", v.Type})
+	}
+	i32, _, ok := ReadInt32(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return i32
+}
+
+// Int32OK is the same as Int32, except that it returns a boolean instead of
+// panicking.
+func (v Value) Int32OK() (int32, bool) {
+	if v.Type != TypeInt32 {
+		return 0, false
+	}
+	i32, _, ok := ReadInt32(v.Data)
+	if !ok {
+		return 0, false
+	}
+	return i32, true
+}
+
+// Timestamp returns the BSON timestamp value the Value represents. It panics if the value is a
+// BSON type other than timestamp.
+func (v Value) Timestamp() (t, i uint32) {
+	if v.Type != TypeTimestamp {
+		panic(ElementTypeError{"bsoncore.Value.Timestamp", v.Type})
+	}
+	t, i, _, ok := ReadTimestamp(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return t, i
+}
+
+// TimestampOK is the same as Timestamp, except that it returns a boolean
+// instead of panicking.
+func (v Value) TimestampOK() (t, i uint32, ok bool) {
+	if v.Type != TypeTimestamp {
+		return 0, 0, false
+	}
+	t, i, _, ok = ReadTimestamp(v.Data)
+	if !ok {
+		return 0, 0, false
+	}
+	return t, i, true
+}
+
+// Int64 returns the int64 the Value represents. It panics if the value is a BSON type other than
+// int64.
+func (v Value) Int64() int64 {
+	if v.Type != TypeInt64 {
+		panic(ElementTypeError{"bsoncore.Value.Int64", v.Type})
+	}
+	i64, _, ok := ReadInt64(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return i64
+}
+
+// Int64OK is the same as Int64, except that it returns a boolean instead of
+// panicking.
+func (v Value) Int64OK() (int64, bool) {
+	if v.Type != TypeInt64 {
+		return 0, false
+	}
+	i64, _, ok := ReadInt64(v.Data)
+	if !ok {
+		return 0, false
+	}
+	return i64, true
+}
+
+// Decimal128 returns the decimal the Value represents. It panics if the value is a BSON type other than
+// decimal.
+func (v Value) Decimal128() (uint64, uint64) {
+	if v.Type != TypeDecimal128 {
+		panic(ElementTypeError{"bsoncore.Value.Decimal128", v.Type})
+	}
+	h, l, _, ok := ReadDecimal128(v.Data)
+	if !ok {
+		panic(NewInsufficientBytesError(v.Data, v.Data))
+	}
+	return h, l
+}
+
+// Decimal128OK is the same as Decimal128, except that it returns a boolean
+// instead of panicking.
+func (v Value) Decimal128OK() (uint64, uint64, bool) {
+	if v.Type != TypeDecimal128 {
+		return 0, 0, false
+	}
+	h, l, _, ok := ReadDecimal128(v.Data)
+	if !ok {
+		return 0, 0, false
+	}
+	return h, l, true
+}
+
+var hexChars = "0123456789abcdef"
+
+func escapeString(s string) string {
+	escapeHTML := true
+	var buf bytes.Buffer
+	buf.WriteByte('"')
+	start := 0
+	for i := 0; i < len(s); {
+		if b := s[i]; b < utf8.RuneSelf {
+			if htmlSafeSet[b] || (!escapeHTML && safeSet[b]) {
+				i++
+				continue
+			}
+			if start < i {
+				buf.WriteString(s[start:i])
+			}
+			switch b {
+			case '\\', '"':
+				buf.WriteByte('\\')
+				buf.WriteByte(b)
+			case '\n':
+				buf.WriteByte('\\')
+				buf.WriteByte('n')
+			case '\r':
+				buf.WriteByte('\\')
+				buf.WriteByte('r')
+			case '\t':
+				buf.WriteByte('\\')
+				buf.WriteByte('t')
+			case '\b':
+				buf.WriteByte('\\')
+				buf.WriteByte('b')
+			case '\f':
+				buf.WriteByte('\\')
+				buf.WriteByte('f')
+			default:
+				// This encodes bytes < 0x20 except for \t, \n and \r.
+				// If escapeHTML is set, it also escapes <, >, and &
+				// because they can lead to security holes when
+				// user-controlled strings are rendered into JSON
+				// and served to some browsers.
+				buf.WriteString(`\u00`)
+				buf.WriteByte(hexChars[b>>4])
+				buf.WriteByte(hexChars[b&0xF])
+			}
+			i++
+			start = i
+			continue
+		}
+		c, size := utf8.DecodeRuneInString(s[i:])
+		if c == utf8.RuneError && size == 1 {
+			if start < i {
+				buf.WriteString(s[start:i])
+			}
+			buf.WriteString(`\ufffd`)
+			i += size
+			start = i
+			continue
+		}
+		// U+2028 is LINE SEPARATOR.
+		// U+2029 is PARAGRAPH SEPARATOR.
+		// They are both technically valid characters in JSON strings,
+		// but don't work in JSONP, which has to be evaluated as JavaScript,
+		// and can lead to security holes there. It is valid JSON to
+		// escape them, so we do so unconditionally.
+		// See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
+		if c == '\u2028' || c == '\u2029' {
+			if start < i {
+				buf.WriteString(s[start:i])
+			}
+			buf.WriteString(`\u202`)
+			buf.WriteByte(hexChars[c&0xF])
+			i += size
+			start = i
+			continue
+		}
+		i += size
+	}
+	if start < len(s) {
+		buf.WriteString(s[start:])
+	}
+	buf.WriteByte('"')
+	return buf.String()
+}
+
+func formatDouble(f float64) string {
+	var s string
+	switch {
+	case math.IsInf(f, 1):
+		s = "Infinity"
+	case math.IsInf(f, -1):
+		s = "-Infinity"
+	case math.IsNaN(f):
+		s = "NaN"
+	default:
+		// Print exactly one decimalType place for integers; otherwise, print as many are necessary to
+		// perfectly represent it.
+		s = strconv.FormatFloat(f, 'G', -1, 64)
+		if !strings.ContainsRune(s, '.') {
+			s += ".0"
+		}
+	}
+
+	return s
+}
+
+type sortableString []rune
+
+func (ss sortableString) Len() int {
+	return len(ss)
+}
+
+func (ss sortableString) Less(i, j int) bool {
+	return ss[i] < ss[j]
+}
+
+func (ss sortableString) Swap(i, j int) {
+	ss[i], ss[j] = ss[j], ss[i]
+}
+
+func sortStringAlphebeticAscending(s string) string {
+	ss := sortableString([]rune(s))
+	sort.Sort(ss)
+	return string([]rune(ss))
+}
diff --git a/vendor/golang.org/x/crypto/sha3/doc.go b/vendor/golang.org/x/crypto/sha3/doc.go
index 7e023090..bbf391fe 100644
--- a/vendor/golang.org/x/crypto/sha3/doc.go
+++ b/vendor/golang.org/x/crypto/sha3/doc.go
@@ -5,6 +5,10 @@
 // Package sha3 implements the SHA-3 fixed-output-length hash functions and
 // the SHAKE variable-output-length hash functions defined by FIPS-202.
 //
+// All types in this package also implement [encoding.BinaryMarshaler],
+// [encoding.BinaryAppender] and [encoding.BinaryUnmarshaler] to marshal and
+// unmarshal the internal state of the hash.
+//
 // Both types of hash function use the "sponge" construction and the Keccak
 // permutation. For a detailed specification see http://keccak.noekeon.org/
 //
diff --git a/vendor/golang.org/x/crypto/sha3/hashes.go b/vendor/golang.org/x/crypto/sha3/hashes.go
index c544b29e..31fffbe0 100644
--- a/vendor/golang.org/x/crypto/sha3/hashes.go
+++ b/vendor/golang.org/x/crypto/sha3/hashes.go
@@ -48,33 +48,52 @@ func init() {
 	crypto.RegisterHash(crypto.SHA3_512, New512)
 }
 
+const (
+	dsbyteSHA3   = 0b00000110
+	dsbyteKeccak = 0b00000001
+	dsbyteShake  = 0b00011111
+	dsbyteCShake = 0b00000100
+
+	// rateK[c] is the rate in bytes for Keccak[c] where c is the capacity in
+	// bits. Given the sponge size is 1600 bits, the rate is 1600 - c bits.
+	rateK256  = (1600 - 256) / 8
+	rateK448  = (1600 - 448) / 8
+	rateK512  = (1600 - 512) / 8
+	rateK768  = (1600 - 768) / 8
+	rateK1024 = (1600 - 1024) / 8
+)
+
 func new224Generic() *state {
-	return &state{rate: 144, outputLen: 28, dsbyte: 0x06}
+	return &state{rate: rateK448, outputLen: 28, dsbyte: dsbyteSHA3}
 }
 
 func new256Generic() *state {
-	return &state{rate: 136, outputLen: 32, dsbyte: 0x06}
+	return &state{rate: rateK512, outputLen: 32, dsbyte: dsbyteSHA3}
 }
 
 func new384Generic() *state {
-	return &state{rate: 104, outputLen: 48, dsbyte: 0x06}
+	return &state{rate: rateK768, outputLen: 48, dsbyte: dsbyteSHA3}
 }
 
 func new512Generic() *state {
-	return &state{rate: 72, outputLen: 64, dsbyte: 0x06}
+	return &state{rate: rateK1024, outputLen: 64, dsbyte: dsbyteSHA3}
 }
 
 // NewLegacyKeccak256 creates a new Keccak-256 hash.
 //
 // Only use this function if you require compatibility with an existing cryptosystem
 // that uses non-standard padding. All other users should use New256 instead.
-func NewLegacyKeccak256() hash.Hash { return &state{rate: 136, outputLen: 32, dsbyte: 0x01} }
+func NewLegacyKeccak256() hash.Hash {
+	return &state{rate: rateK512, outputLen: 32, dsbyte: dsbyteKeccak}
+}
 
 // NewLegacyKeccak512 creates a new Keccak-512 hash.
 //
 // Only use this function if you require compatibility with an existing cryptosystem
 // that uses non-standard padding. All other users should use New512 instead.
-func NewLegacyKeccak512() hash.Hash { return &state{rate: 72, outputLen: 64, dsbyte: 0x01} }
+func NewLegacyKeccak512() hash.Hash {
+	return &state{rate: rateK1024, outputLen: 64, dsbyte: dsbyteKeccak}
+}
 
 // Sum224 returns the SHA3-224 digest of the data.
 func Sum224(data []byte) (digest [28]byte) {
diff --git a/vendor/golang.org/x/crypto/sha3/sha3.go b/vendor/golang.org/x/crypto/sha3/sha3.go
index afedde5a..6658c444 100644
--- a/vendor/golang.org/x/crypto/sha3/sha3.go
+++ b/vendor/golang.org/x/crypto/sha3/sha3.go
@@ -4,6 +4,15 @@
 
 package sha3
 
+import (
+	"crypto/subtle"
+	"encoding/binary"
+	"errors"
+	"unsafe"
+
+	"golang.org/x/sys/cpu"
+)
+
 // spongeDirection indicates the direction bytes are flowing through the sponge.
 type spongeDirection int
 
@@ -14,16 +23,13 @@ const (
 	spongeSqueezing
 )
 
-const (
-	// maxRate is the maximum size of the internal buffer. SHAKE-256
-	// currently needs the largest buffer.
-	maxRate = 168
-)
-
 type state struct {
-	// Generic sponge components.
-	a    [25]uint64 // main state of the hash
-	rate int        // the number of bytes of state to use
+	a [1600 / 8]byte // main state of the hash
+
+	// a[n:rate] is the buffer. If absorbing, it's the remaining space to XOR
+	// into before running the permutation. If squeezing, it's the remaining
+	// output to produce before running the permutation.
+	n, rate int
 
 	// dsbyte contains the "domain separation" bits and the first bit of
 	// the padding. Sections 6.1 and 6.2 of [1] separate the outputs of the
@@ -39,10 +45,6 @@ type state struct {
 	//      Extendable-Output Functions (May 2014)"
 	dsbyte byte
 
-	i, n    int // storage[i:n] is the buffer, i is only used while squeezing
-	storage [maxRate]byte
-
-	// Specific to SHA-3 and SHAKE.
 	outputLen int             // the default output size in bytes
 	state     spongeDirection // whether the sponge is absorbing or squeezing
 }
@@ -61,7 +63,7 @@ func (d *state) Reset() {
 		d.a[i] = 0
 	}
 	d.state = spongeAbsorbing
-	d.i, d.n = 0, 0
+	d.n = 0
 }
 
 func (d *state) clone() *state {
@@ -69,22 +71,25 @@ func (d *state) clone() *state {
 	return &ret
 }
 
-// permute applies the KeccakF-1600 permutation. It handles
-// any input-output buffering.
+// permute applies the KeccakF-1600 permutation.
 func (d *state) permute() {
-	switch d.state {
-	case spongeAbsorbing:
-		// If we're absorbing, we need to xor the input into the state
-		// before applying the permutation.
-		xorIn(d, d.storage[:d.rate])
-		d.n = 0
-		keccakF1600(&d.a)
-	case spongeSqueezing:
-		// If we're squeezing, we need to apply the permutation before
-		// copying more output.
-		keccakF1600(&d.a)
-		d.i = 0
-		copyOut(d, d.storage[:d.rate])
+	var a *[25]uint64
+	if cpu.IsBigEndian {
+		a = new([25]uint64)
+		for i := range a {
+			a[i] = binary.LittleEndian.Uint64(d.a[i*8:])
+		}
+	} else {
+		a = (*[25]uint64)(unsafe.Pointer(&d.a))
+	}
+
+	keccakF1600(a)
+	d.n = 0
+
+	if cpu.IsBigEndian {
+		for i := range a {
+			binary.LittleEndian.PutUint64(d.a[i*8:], a[i])
+		}
 	}
 }
 
@@ -92,53 +97,36 @@ func (d *state) permute() {
 // the multi-bitrate 10..1 padding rule, and permutes the state.
 func (d *state) padAndPermute() {
 	// Pad with this instance's domain-separator bits. We know that there's
-	// at least one byte of space in d.buf because, if it were full,
+	// at least one byte of space in the sponge because, if it were full,
 	// permute would have been called to empty it. dsbyte also contains the
 	// first one bit for the padding. See the comment in the state struct.
-	d.storage[d.n] = d.dsbyte
-	d.n++
-	for d.n < d.rate {
-		d.storage[d.n] = 0
-		d.n++
-	}
+	d.a[d.n] ^= d.dsbyte
 	// This adds the final one bit for the padding. Because of the way that
 	// bits are numbered from the LSB upwards, the final bit is the MSB of
 	// the last byte.
-	d.storage[d.rate-1] ^= 0x80
+	d.a[d.rate-1] ^= 0x80
 	// Apply the permutation
 	d.permute()
 	d.state = spongeSqueezing
-	d.n = d.rate
-	copyOut(d, d.storage[:d.rate])
 }
 
 // Write absorbs more data into the hash's state. It panics if any
 // output has already been read.
-func (d *state) Write(p []byte) (written int, err error) {
+func (d *state) Write(p []byte) (n int, err error) {
 	if d.state != spongeAbsorbing {
 		panic("sha3: Write after Read")
 	}
-	written = len(p)
+
+	n = len(p)
 
 	for len(p) > 0 {
-		if d.n == 0 && len(p) >= d.rate {
-			// The fast path; absorb a full "rate" bytes of input and apply the permutation.
-			xorIn(d, p[:d.rate])
-			p = p[d.rate:]
-			keccakF1600(&d.a)
-		} else {
-			// The slow path; buffer the input until we can fill the sponge, and then xor it in.
-			todo := d.rate - d.n
-			if todo > len(p) {
-				todo = len(p)
-			}
-			d.n += copy(d.storage[d.n:], p[:todo])
-			p = p[todo:]
-
-			// If the sponge is full, apply the permutation.
-			if d.n == d.rate {
-				d.permute()
-			}
+		x := subtle.XORBytes(d.a[d.n:d.rate], d.a[d.n:d.rate], p)
+		d.n += x
+		p = p[x:]
+
+		// If the sponge is full, apply the permutation.
+		if d.n == d.rate {
+			d.permute()
 		}
 	}
 
@@ -156,14 +144,14 @@ func (d *state) Read(out []byte) (n int, err error) {
 
 	// Now, do the squeezing.
 	for len(out) > 0 {
-		n := copy(out, d.storage[d.i:d.n])
-		d.i += n
-		out = out[n:]
-
 		// Apply the permutation if we've squeezed the sponge dry.
-		if d.i == d.rate {
+		if d.n == d.rate {
 			d.permute()
 		}
+
+		x := copy(out, d.a[d.n:d.rate])
+		d.n += x
+		out = out[x:]
 	}
 
 	return
@@ -183,3 +171,74 @@ func (d *state) Sum(in []byte) []byte {
 	dup.Read(hash)
 	return append(in, hash...)
 }
+
+const (
+	magicSHA3   = "sha\x08"
+	magicShake  = "sha\x09"
+	magicCShake = "sha\x0a"
+	magicKeccak = "sha\x0b"
+	// magic || rate || main state || n || sponge direction
+	marshaledSize = len(magicSHA3) + 1 + 200 + 1 + 1
+)
+
+func (d *state) MarshalBinary() ([]byte, error) {
+	return d.AppendBinary(make([]byte, 0, marshaledSize))
+}
+
+func (d *state) AppendBinary(b []byte) ([]byte, error) {
+	switch d.dsbyte {
+	case dsbyteSHA3:
+		b = append(b, magicSHA3...)
+	case dsbyteShake:
+		b = append(b, magicShake...)
+	case dsbyteCShake:
+		b = append(b, magicCShake...)
+	case dsbyteKeccak:
+		b = append(b, magicKeccak...)
+	default:
+		panic("unknown dsbyte")
+	}
+	// rate is at most 168, and n is at most rate.
+	b = append(b, byte(d.rate))
+	b = append(b, d.a[:]...)
+	b = append(b, byte(d.n), byte(d.state))
+	return b, nil
+}
+
+func (d *state) UnmarshalBinary(b []byte) error {
+	if len(b) != marshaledSize {
+		return errors.New("sha3: invalid hash state")
+	}
+
+	magic := string(b[:len(magicSHA3)])
+	b = b[len(magicSHA3):]
+	switch {
+	case magic == magicSHA3 && d.dsbyte == dsbyteSHA3:
+	case magic == magicShake && d.dsbyte == dsbyteShake:
+	case magic == magicCShake && d.dsbyte == dsbyteCShake:
+	case magic == magicKeccak && d.dsbyte == dsbyteKeccak:
+	default:
+		return errors.New("sha3: invalid hash state identifier")
+	}
+
+	rate := int(b[0])
+	b = b[1:]
+	if rate != d.rate {
+		return errors.New("sha3: invalid hash state function")
+	}
+
+	copy(d.a[:], b)
+	b = b[len(d.a):]
+
+	n, state := int(b[0]), spongeDirection(b[1])
+	if n > d.rate {
+		return errors.New("sha3: invalid hash state")
+	}
+	d.n = n
+	if state != spongeAbsorbing && state != spongeSqueezing {
+		return errors.New("sha3: invalid hash state")
+	}
+	d.state = state
+
+	return nil
+}
diff --git a/vendor/golang.org/x/crypto/sha3/shake.go b/vendor/golang.org/x/crypto/sha3/shake.go
index 1ea9275b..a6b3a428 100644
--- a/vendor/golang.org/x/crypto/sha3/shake.go
+++ b/vendor/golang.org/x/crypto/sha3/shake.go
@@ -16,9 +16,12 @@ package sha3
 // [2] https://doi.org/10.6028/NIST.SP.800-185
 
 import (
+	"bytes"
 	"encoding/binary"
+	"errors"
 	"hash"
 	"io"
+	"math/bits"
 )
 
 // ShakeHash defines the interface to hash functions that support
@@ -50,44 +53,36 @@ type cshakeState struct {
 	initBlock []byte
 }
 
-// Consts for configuring initial SHA-3 state
-const (
-	dsbyteShake  = 0x1f
-	dsbyteCShake = 0x04
-	rate128      = 168
-	rate256      = 136
-)
+func bytepad(data []byte, rate int) []byte {
+	out := make([]byte, 0, 9+len(data)+rate-1)
+	out = append(out, leftEncode(uint64(rate))...)
+	out = append(out, data...)
+	if padlen := rate - len(out)%rate; padlen < rate {
+		out = append(out, make([]byte, padlen)...)
+	}
+	return out
+}
 
-func bytepad(input []byte, w int) []byte {
-	// leftEncode always returns max 9 bytes
-	buf := make([]byte, 0, 9+len(input)+w)
-	buf = append(buf, leftEncode(uint64(w))...)
-	buf = append(buf, input...)
-	padlen := w - (len(buf) % w)
-	return append(buf, make([]byte, padlen)...)
-}
-
-func leftEncode(value uint64) []byte {
-	var b [9]byte
-	binary.BigEndian.PutUint64(b[1:], value)
-	// Trim all but last leading zero bytes
-	i := byte(1)
-	for i < 8 && b[i] == 0 {
-		i++
+func leftEncode(x uint64) []byte {
+	// Let n be the smallest positive integer for which 2^(8n) > x.
+	n := (bits.Len64(x) + 7) / 8
+	if n == 0 {
+		n = 1
 	}
-	// Prepend number of encoded bytes
-	b[i-1] = 9 - i
-	return b[i-1:]
+	// Return n || x with n as a byte and x an n bytes in big-endian order.
+	b := make([]byte, 9)
+	binary.BigEndian.PutUint64(b[1:], x)
+	b = b[9-n-1:]
+	b[0] = byte(n)
+	return b
 }
 
 func newCShake(N, S []byte, rate, outputLen int, dsbyte byte) ShakeHash {
 	c := cshakeState{state: &state{rate: rate, outputLen: outputLen, dsbyte: dsbyte}}
-
-	// leftEncode returns max 9 bytes
-	c.initBlock = make([]byte, 0, 9*2+len(N)+len(S))
-	c.initBlock = append(c.initBlock, leftEncode(uint64(len(N)*8))...)
+	c.initBlock = make([]byte, 0, 9+len(N)+9+len(S)) // leftEncode returns max 9 bytes
+	c.initBlock = append(c.initBlock, leftEncode(uint64(len(N))*8)...)
 	c.initBlock = append(c.initBlock, N...)
-	c.initBlock = append(c.initBlock, leftEncode(uint64(len(S)*8))...)
+	c.initBlock = append(c.initBlock, leftEncode(uint64(len(S))*8)...)
 	c.initBlock = append(c.initBlock, S...)
 	c.Write(bytepad(c.initBlock, c.rate))
 	return &c
@@ -111,6 +106,30 @@ func (c *state) Clone() ShakeHash {
 	return c.clone()
 }
 
+func (c *cshakeState) MarshalBinary() ([]byte, error) {
+	return c.AppendBinary(make([]byte, 0, marshaledSize+len(c.initBlock)))
+}
+
+func (c *cshakeState) AppendBinary(b []byte) ([]byte, error) {
+	b, err := c.state.AppendBinary(b)
+	if err != nil {
+		return nil, err
+	}
+	b = append(b, c.initBlock...)
+	return b, nil
+}
+
+func (c *cshakeState) UnmarshalBinary(b []byte) error {
+	if len(b) <= marshaledSize {
+		return errors.New("sha3: invalid hash state")
+	}
+	if err := c.state.UnmarshalBinary(b[:marshaledSize]); err != nil {
+		return err
+	}
+	c.initBlock = bytes.Clone(b[marshaledSize:])
+	return nil
+}
+
 // NewShake128 creates a new SHAKE128 variable-output-length ShakeHash.
 // Its generic security strength is 128 bits against all attacks if at
 // least 32 bytes of its output are used.
@@ -126,11 +145,11 @@ func NewShake256() ShakeHash {
 }
 
 func newShake128Generic() *state {
-	return &state{rate: rate128, outputLen: 32, dsbyte: dsbyteShake}
+	return &state{rate: rateK256, outputLen: 32, dsbyte: dsbyteShake}
 }
 
 func newShake256Generic() *state {
-	return &state{rate: rate256, outputLen: 64, dsbyte: dsbyteShake}
+	return &state{rate: rateK512, outputLen: 64, dsbyte: dsbyteShake}
 }
 
 // NewCShake128 creates a new instance of cSHAKE128 variable-output-length ShakeHash,
@@ -143,7 +162,7 @@ func NewCShake128(N, S []byte) ShakeHash {
 	if len(N) == 0 && len(S) == 0 {
 		return NewShake128()
 	}
-	return newCShake(N, S, rate128, 32, dsbyteCShake)
+	return newCShake(N, S, rateK256, 32, dsbyteCShake)
 }
 
 // NewCShake256 creates a new instance of cSHAKE256 variable-output-length ShakeHash,
@@ -156,7 +175,7 @@ func NewCShake256(N, S []byte) ShakeHash {
 	if len(N) == 0 && len(S) == 0 {
 		return NewShake256()
 	}
-	return newCShake(N, S, rate256, 64, dsbyteCShake)
+	return newCShake(N, S, rateK512, 64, dsbyteCShake)
 }
 
 // ShakeSum128 writes an arbitrary-length digest of data into hash.
diff --git a/vendor/golang.org/x/crypto/sha3/xor.go b/vendor/golang.org/x/crypto/sha3/xor.go
deleted file mode 100644
index 6ada5c95..00000000
--- a/vendor/golang.org/x/crypto/sha3/xor.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package sha3
-
-import (
-	"crypto/subtle"
-	"encoding/binary"
-	"unsafe"
-
-	"golang.org/x/sys/cpu"
-)
-
-// xorIn xors the bytes in buf into the state.
-func xorIn(d *state, buf []byte) {
-	if cpu.IsBigEndian {
-		for i := 0; len(buf) >= 8; i++ {
-			a := binary.LittleEndian.Uint64(buf)
-			d.a[i] ^= a
-			buf = buf[8:]
-		}
-	} else {
-		ab := (*[25 * 64 / 8]byte)(unsafe.Pointer(&d.a))
-		subtle.XORBytes(ab[:], ab[:], buf)
-	}
-}
-
-// copyOut copies uint64s to a byte buffer.
-func copyOut(d *state, b []byte) {
-	if cpu.IsBigEndian {
-		for i := 0; len(b) >= 8; i++ {
-			binary.LittleEndian.PutUint64(b, d.a[i])
-			b = b[8:]
-		}
-	} else {
-		ab := (*[25 * 64 / 8]byte)(unsafe.Pointer(&d.a))
-		copy(b, ab[:])
-	}
-}
diff --git a/vendor/golang.org/x/sync/errgroup/errgroup.go b/vendor/golang.org/x/sync/errgroup/errgroup.go
index 948a3ee6..b8322598 100644
--- a/vendor/golang.org/x/sync/errgroup/errgroup.go
+++ b/vendor/golang.org/x/sync/errgroup/errgroup.go
@@ -118,6 +118,7 @@ func (g *Group) TryGo(f func() error) bool {
 
 // SetLimit limits the number of active goroutines in this group to at most n.
 // A negative value indicates no limit.
+// A limit of zero will prevent any new goroutines from being added.
 //
 // Any subsequent call to the Go method will block until it can add an active
 // goroutine without exceeding the configured limit.
diff --git a/vendor/golang.org/x/sys/cpu/asm_darwin_x86_gc.s b/vendor/golang.org/x/sys/cpu/asm_darwin_x86_gc.s
new file mode 100644
index 00000000..ec2acfe5
--- /dev/null
+++ b/vendor/golang.org/x/sys/cpu/asm_darwin_x86_gc.s
@@ -0,0 +1,17 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build darwin && amd64 && gc
+
+#include "textflag.h"
+
+TEXT libc_sysctl_trampoline<>(SB),NOSPLIT,$0-0
+	JMP	libc_sysctl(SB)
+GLOBL	·libc_sysctl_trampoline_addr(SB), RODATA, $8
+DATA	·libc_sysctl_trampoline_addr(SB)/8, $libc_sysctl_trampoline<>(SB)
+
+TEXT libc_sysctlbyname_trampoline<>(SB),NOSPLIT,$0-0
+	JMP	libc_sysctlbyname(SB)
+GLOBL	·libc_sysctlbyname_trampoline_addr(SB), RODATA, $8
+DATA	·libc_sysctlbyname_trampoline_addr(SB)/8, $libc_sysctlbyname_trampoline<>(SB)
diff --git a/vendor/golang.org/x/sys/cpu/cpu.go b/vendor/golang.org/x/sys/cpu/cpu.go
index ec07aab0..9c105f23 100644
--- a/vendor/golang.org/x/sys/cpu/cpu.go
+++ b/vendor/golang.org/x/sys/cpu/cpu.go
@@ -72,6 +72,9 @@ var X86 struct {
 	HasSSSE3            bool // Supplemental streaming SIMD extension 3
 	HasSSE41            bool // Streaming SIMD extension 4 and 4.1
 	HasSSE42            bool // Streaming SIMD extension 4 and 4.2
+	HasAVXIFMA          bool // Advanced vector extension Integer Fused Multiply Add
+	HasAVXVNNI          bool // Advanced vector extension Vector Neural Network Instructions
+	HasAVXVNNIInt8      bool // Advanced vector extension Vector Neural Network Int8 instructions
 	_                   CacheLinePad
 }
 
@@ -201,6 +204,25 @@ var S390X struct {
 	_         CacheLinePad
 }
 
+// RISCV64 contains the supported CPU features and performance characteristics for riscv64
+// platforms. The booleans in RISCV64, with the exception of HasFastMisaligned, indicate
+// the presence of RISC-V extensions.
+//
+// It is safe to assume that all the RV64G extensions are supported and so they are omitted from
+// this structure. As riscv64 Go programs require at least RV64G, the code that populates
+// this structure cannot run successfully if some of the RV64G extensions are missing.
+// The struct is padded to avoid false sharing.
+var RISCV64 struct {
+	_                 CacheLinePad
+	HasFastMisaligned bool // Fast misaligned accesses
+	HasC              bool // Compressed instruction-set extension
+	HasV              bool // Vector extension compatible with RVV 1.0
+	HasZba            bool // Address generation instructions extension
+	HasZbb            bool // Basic bit-manipulation extension
+	HasZbs            bool // Single-bit instructions extension
+	_                 CacheLinePad
+}
+
 func init() {
 	archInit()
 	initOptions()
diff --git a/vendor/golang.org/x/sys/cpu/cpu_darwin_x86.go b/vendor/golang.org/x/sys/cpu/cpu_darwin_x86.go
new file mode 100644
index 00000000..b838cb9e
--- /dev/null
+++ b/vendor/golang.org/x/sys/cpu/cpu_darwin_x86.go
@@ -0,0 +1,61 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build darwin && amd64 && gc
+
+package cpu
+
+// darwinSupportsAVX512 checks Darwin kernel for AVX512 support via sysctl
+// call (see issue 43089). It also restricts AVX512 support for Darwin to
+// kernel version 21.3.0 (MacOS 12.2.0) or later (see issue 49233).
+//
+// Background:
+// Darwin implements a special mechanism to economize on thread state when
+// AVX512 specific registers are not in use. This scheme minimizes state when
+// preempting threads that haven't yet used any AVX512 instructions, but adds
+// special requirements to check for AVX512 hardware support at runtime (e.g.
+// via sysctl call or commpage inspection). See issue 43089 and link below for
+// full background:
+// https://github.com/apple-oss-distributions/xnu/blob/xnu-11215.1.10/osfmk/i386/fpu.c#L214-L240
+//
+// Additionally, all versions of the Darwin kernel from 19.6.0 through 21.2.0
+// (corresponding to MacOS 10.15.6 - 12.1) have a bug that can cause corruption
+// of the AVX512 mask registers (K0-K7) upon signal return. For this reason
+// AVX512 is considered unsafe to use on Darwin for kernel versions prior to
+// 21.3.0, where a fix has been confirmed. See issue 49233 for full background.
+func darwinSupportsAVX512() bool {
+	return darwinSysctlEnabled([]byte("hw.optional.avx512f\x00")) && darwinKernelVersionCheck(21, 3, 0)
+}
+
+// Ensure Darwin kernel version is at least major.minor.patch, avoiding dependencies
+func darwinKernelVersionCheck(major, minor, patch int) bool {
+	var release [256]byte
+	err := darwinOSRelease(&release)
+	if err != nil {
+		return false
+	}
+
+	var mmp [3]int
+	c := 0
+Loop:
+	for _, b := range release[:] {
+		switch {
+		case b >= '0' && b <= '9':
+			mmp[c] = 10*mmp[c] + int(b-'0')
+		case b == '.':
+			c++
+			if c > 2 {
+				return false
+			}
+		case b == 0:
+			break Loop
+		default:
+			return false
+		}
+	}
+	if c != 2 {
+		return false
+	}
+	return mmp[0] > major || mmp[0] == major && (mmp[1] > minor || mmp[1] == minor && mmp[2] >= patch)
+}
diff --git a/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go b/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go
index 910728fb..32a44514 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go
@@ -6,10 +6,10 @@
 
 package cpu
 
-// cpuid is implemented in cpu_x86.s for gc compiler
+// cpuid is implemented in cpu_gc_x86.s for gc compiler
 // and in cpu_gccgo.c for gccgo.
 func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32)
 
-// xgetbv with ecx = 0 is implemented in cpu_x86.s for gc compiler
+// xgetbv with ecx = 0 is implemented in cpu_gc_x86.s for gc compiler
 // and in cpu_gccgo.c for gccgo.
 func xgetbv() (eax, edx uint32)
diff --git a/vendor/golang.org/x/sys/cpu/cpu_x86.s b/vendor/golang.org/x/sys/cpu/cpu_gc_x86.s
similarity index 94%
rename from vendor/golang.org/x/sys/cpu/cpu_x86.s
rename to vendor/golang.org/x/sys/cpu/cpu_gc_x86.s
index 7d7ba33e..ce208ce6 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_x86.s
+++ b/vendor/golang.org/x/sys/cpu/cpu_gc_x86.s
@@ -18,7 +18,7 @@ TEXT ·cpuid(SB), NOSPLIT, $0-24
 	RET
 
 // func xgetbv() (eax, edx uint32)
-TEXT ·xgetbv(SB),NOSPLIT,$0-8
+TEXT ·xgetbv(SB), NOSPLIT, $0-8
 	MOVL $0, CX
 	XGETBV
 	MOVL AX, eax+0(FP)
diff --git a/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go b/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go
index 99c60fe9..170d21dd 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go
@@ -23,9 +23,3 @@ func xgetbv() (eax, edx uint32) {
 	gccgoXgetbv(&a, &d)
 	return a, d
 }
-
-// gccgo doesn't build on Darwin, per:
-// https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/gcc.rb#L76
-func darwinSupportsAVX512() bool {
-	return false
-}
diff --git a/vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go b/vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go
index 08f35ea1..f1caf0f7 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go
@@ -110,7 +110,6 @@ func doinit() {
 	ARM64.HasASIMDFHM = isSet(hwCap, hwcap_ASIMDFHM)
 	ARM64.HasDIT = isSet(hwCap, hwcap_DIT)
 
-
 	// HWCAP2 feature bits
 	ARM64.HasSVE2 = isSet(hwCap2, hwcap2_SVE2)
 	ARM64.HasI8MM = isSet(hwCap2, hwcap2_I8MM)
diff --git a/vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go b/vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go
index cd63e733..7d902b68 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build linux && !arm && !arm64 && !mips64 && !mips64le && !ppc64 && !ppc64le && !s390x
+//go:build linux && !arm && !arm64 && !mips64 && !mips64le && !ppc64 && !ppc64le && !s390x && !riscv64
 
 package cpu
 
diff --git a/vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go b/vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go
new file mode 100644
index 00000000..cb4a0c57
--- /dev/null
+++ b/vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go
@@ -0,0 +1,137 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package cpu
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+// RISC-V extension discovery code for Linux. The approach here is to first try the riscv_hwprobe
+// syscall falling back to HWCAP to check for the C extension if riscv_hwprobe is not available.
+//
+// A note on detection of the Vector extension using HWCAP.
+//
+// Support for the Vector extension version 1.0 was added to the Linux kernel in release 6.5.
+// Support for the riscv_hwprobe syscall was added in 6.4. It follows that if the riscv_hwprobe
+// syscall is not available then neither is the Vector extension (which needs kernel support).
+// The riscv_hwprobe syscall should then be all we need to detect the Vector extension.
+// However, some RISC-V board manufacturers ship boards with an older kernel on top of which
+// they have back-ported various versions of the Vector extension patches but not the riscv_hwprobe
+// patches. These kernels advertise support for the Vector extension using HWCAP. Falling
+// back to HWCAP to detect the Vector extension, if riscv_hwprobe is not available, or simply not
+// bothering with riscv_hwprobe at all and just using HWCAP may then seem like an attractive option.
+//
+// Unfortunately, simply checking the 'V' bit in AT_HWCAP will not work as this bit is used by
+// RISC-V board and cloud instance providers to mean different things. The Lichee Pi 4A board
+// and the Scaleway RV1 cloud instances use the 'V' bit to advertise their support for the unratified
+// 0.7.1 version of the Vector Specification. The Banana Pi BPI-F3 and the CanMV-K230 board use
+// it to advertise support for 1.0 of the Vector extension. Versions 0.7.1 and 1.0 of the Vector
+// extension are binary incompatible. HWCAP can then not be used in isolation to populate the
+// HasV field as this field indicates that the underlying CPU is compatible with RVV 1.0.
+//
+// There is a way at runtime to distinguish between versions 0.7.1 and 1.0 of the Vector
+// specification by issuing a RVV 1.0 vsetvli instruction and checking the vill bit of the vtype
+// register. This check would allow us to safely detect version 1.0 of the Vector extension
+// with HWCAP, if riscv_hwprobe were not available. However, the check cannot
+// be added until the assembler supports the Vector instructions.
+//
+// Note the riscv_hwprobe syscall does not suffer from these ambiguities by design as all of the
+// extensions it advertises support for are explicitly versioned. It's also worth noting that
+// the riscv_hwprobe syscall is the only way to detect multi-letter RISC-V extensions, e.g., Zba.
+// These cannot be detected using HWCAP and so riscv_hwprobe must be used to detect the majority
+// of RISC-V extensions.
+//
+// Please see https://docs.kernel.org/arch/riscv/hwprobe.html for more information.
+
+// golang.org/x/sys/cpu is not allowed to depend on golang.org/x/sys/unix so we must
+// reproduce the constants, types and functions needed to make the riscv_hwprobe syscall
+// here.
+
+const (
+	// Copied from golang.org/x/sys/unix/ztypes_linux_riscv64.go.
+	riscv_HWPROBE_KEY_IMA_EXT_0   = 0x4
+	riscv_HWPROBE_IMA_C           = 0x2
+	riscv_HWPROBE_IMA_V           = 0x4
+	riscv_HWPROBE_EXT_ZBA         = 0x8
+	riscv_HWPROBE_EXT_ZBB         = 0x10
+	riscv_HWPROBE_EXT_ZBS         = 0x20
+	riscv_HWPROBE_KEY_CPUPERF_0   = 0x5
+	riscv_HWPROBE_MISALIGNED_FAST = 0x3
+	riscv_HWPROBE_MISALIGNED_MASK = 0x7
+)
+
+const (
+	// sys_RISCV_HWPROBE is copied from golang.org/x/sys/unix/zsysnum_linux_riscv64.go.
+	sys_RISCV_HWPROBE = 258
+)
+
+// riscvHWProbePairs is copied from golang.org/x/sys/unix/ztypes_linux_riscv64.go.
+type riscvHWProbePairs struct {
+	key   int64
+	value uint64
+}
+
+const (
+	// CPU features
+	hwcap_RISCV_ISA_C = 1 << ('C' - 'A')
+)
+
+func doinit() {
+	// A slice of key/value pair structures is passed to the RISCVHWProbe syscall. The key
+	// field should be initialised with one of the key constants defined above, e.g.,
+	// RISCV_HWPROBE_KEY_IMA_EXT_0. The syscall will set the value field to the appropriate value.
+	// If the kernel does not recognise a key it will set the key field to -1 and the value field to 0.
+
+	pairs := []riscvHWProbePairs{
+		{riscv_HWPROBE_KEY_IMA_EXT_0, 0},
+		{riscv_HWPROBE_KEY_CPUPERF_0, 0},
+	}
+
+	// This call only indicates that extensions are supported if they are implemented on all cores.
+	if riscvHWProbe(pairs, 0) {
+		if pairs[0].key != -1 {
+			v := uint(pairs[0].value)
+			RISCV64.HasC = isSet(v, riscv_HWPROBE_IMA_C)
+			RISCV64.HasV = isSet(v, riscv_HWPROBE_IMA_V)
+			RISCV64.HasZba = isSet(v, riscv_HWPROBE_EXT_ZBA)
+			RISCV64.HasZbb = isSet(v, riscv_HWPROBE_EXT_ZBB)
+			RISCV64.HasZbs = isSet(v, riscv_HWPROBE_EXT_ZBS)
+		}
+		if pairs[1].key != -1 {
+			v := pairs[1].value & riscv_HWPROBE_MISALIGNED_MASK
+			RISCV64.HasFastMisaligned = v == riscv_HWPROBE_MISALIGNED_FAST
+		}
+	}
+
+	// Let's double check with HWCAP if the C extension does not appear to be supported.
+	// This may happen if we're running on a kernel older than 6.4.
+
+	if !RISCV64.HasC {
+		RISCV64.HasC = isSet(hwCap, hwcap_RISCV_ISA_C)
+	}
+}
+
+func isSet(hwc uint, value uint) bool {
+	return hwc&value != 0
+}
+
+// riscvHWProbe is a simplified version of the generated wrapper function found in
+// golang.org/x/sys/unix/zsyscall_linux_riscv64.go. We simplify it by removing the
+// cpuCount and cpus parameters which we do not need. We always want to pass 0 for
+// these parameters here so the kernel only reports the extensions that are present
+// on all cores.
+func riscvHWProbe(pairs []riscvHWProbePairs, flags uint) bool {
+	var _zero uintptr
+	var p0 unsafe.Pointer
+	if len(pairs) > 0 {
+		p0 = unsafe.Pointer(&pairs[0])
+	} else {
+		p0 = unsafe.Pointer(&_zero)
+	}
+
+	_, _, e1 := syscall.Syscall6(sys_RISCV_HWPROBE, uintptr(p0), uintptr(len(pairs)), uintptr(0), uintptr(0), uintptr(flags), 0)
+	return e1 == 0
+}
diff --git a/vendor/golang.org/x/sys/cpu/cpu_other_x86.go b/vendor/golang.org/x/sys/cpu/cpu_other_x86.go
new file mode 100644
index 00000000..a0fd7e2f
--- /dev/null
+++ b/vendor/golang.org/x/sys/cpu/cpu_other_x86.go
@@ -0,0 +1,11 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build 386 || amd64p32 || (amd64 && (!darwin || !gc))
+
+package cpu
+
+func darwinSupportsAVX512() bool {
+	panic("only implemented for gc && amd64 && darwin")
+}
diff --git a/vendor/golang.org/x/sys/cpu/cpu_riscv64.go b/vendor/golang.org/x/sys/cpu/cpu_riscv64.go
index 7f0c79c0..aca3199c 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_riscv64.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_riscv64.go
@@ -8,4 +8,13 @@ package cpu
 
 const cacheLineSize = 64
 
-func initOptions() {}
+func initOptions() {
+	options = []option{
+		{Name: "fastmisaligned", Feature: &RISCV64.HasFastMisaligned},
+		{Name: "c", Feature: &RISCV64.HasC},
+		{Name: "v", Feature: &RISCV64.HasV},
+		{Name: "zba", Feature: &RISCV64.HasZba},
+		{Name: "zbb", Feature: &RISCV64.HasZbb},
+		{Name: "zbs", Feature: &RISCV64.HasZbs},
+	}
+}
diff --git a/vendor/golang.org/x/sys/cpu/cpu_x86.go b/vendor/golang.org/x/sys/cpu/cpu_x86.go
index c29f5e4c..1e642f33 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_x86.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_x86.go
@@ -53,6 +53,9 @@ func initOptions() {
 		{Name: "sse41", Feature: &X86.HasSSE41},
 		{Name: "sse42", Feature: &X86.HasSSE42},
 		{Name: "ssse3", Feature: &X86.HasSSSE3},
+		{Name: "avxifma", Feature: &X86.HasAVXIFMA},
+		{Name: "avxvnni", Feature: &X86.HasAVXVNNI},
+		{Name: "avxvnniint8", Feature: &X86.HasAVXVNNIInt8},
 
 		// These capabilities should always be enabled on amd64:
 		{Name: "sse2", Feature: &X86.HasSSE2, Required: runtime.GOARCH == "amd64"},
@@ -92,10 +95,8 @@ func archInit() {
 		osSupportsAVX = isSet(1, eax) && isSet(2, eax)
 
 		if runtime.GOOS == "darwin" {
-			// Darwin doesn't save/restore AVX-512 mask registers correctly across signal handlers.
-			// Since users can't rely on mask register contents, let's not advertise AVX-512 support.
-			// See issue 49233.
-			osSupportsAVX512 = false
+			// Darwin requires special AVX512 checks, see cpu_darwin_x86.go
+			osSupportsAVX512 = osSupportsAVX && darwinSupportsAVX512()
 		} else {
 			// Check if OPMASK and ZMM registers have OS support.
 			osSupportsAVX512 = osSupportsAVX && isSet(5, eax) && isSet(6, eax) && isSet(7, eax)
@@ -108,7 +109,7 @@ func archInit() {
 		return
 	}
 
-	_, ebx7, ecx7, edx7 := cpuid(7, 0)
+	eax7, ebx7, ecx7, edx7 := cpuid(7, 0)
 	X86.HasBMI1 = isSet(3, ebx7)
 	X86.HasAVX2 = isSet(5, ebx7) && osSupportsAVX
 	X86.HasBMI2 = isSet(8, ebx7)
@@ -136,14 +137,24 @@ func archInit() {
 		X86.HasAVX512VAES = isSet(9, ecx7)
 		X86.HasAVX512VBMI2 = isSet(6, ecx7)
 		X86.HasAVX512BITALG = isSet(12, ecx7)
-
-		eax71, _, _, _ := cpuid(7, 1)
-		X86.HasAVX512BF16 = isSet(5, eax71)
 	}
 
 	X86.HasAMXTile = isSet(24, edx7)
 	X86.HasAMXInt8 = isSet(25, edx7)
 	X86.HasAMXBF16 = isSet(22, edx7)
+
+	// These features depend on the second level of extended features.
+	if eax7 >= 1 {
+		eax71, _, _, edx71 := cpuid(7, 1)
+		if X86.HasAVX512 {
+			X86.HasAVX512BF16 = isSet(5, eax71)
+		}
+		if X86.HasAVX {
+			X86.HasAVXIFMA = isSet(23, eax71)
+			X86.HasAVXVNNI = isSet(4, eax71)
+			X86.HasAVXVNNIInt8 = isSet(4, edx71)
+		}
+	}
 }
 
 func isSet(bitpos uint, value uint32) bool {
diff --git a/vendor/golang.org/x/sys/cpu/syscall_darwin_x86_gc.go b/vendor/golang.org/x/sys/cpu/syscall_darwin_x86_gc.go
new file mode 100644
index 00000000..4d0888b0
--- /dev/null
+++ b/vendor/golang.org/x/sys/cpu/syscall_darwin_x86_gc.go
@@ -0,0 +1,98 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Minimal copy of x/sys/unix so the cpu package can make a
+// system call on Darwin without depending on x/sys/unix.
+
+//go:build darwin && amd64 && gc
+
+package cpu
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+type _C_int int32
+
+// adapted from unix.Uname() at x/sys/unix/syscall_darwin.go L419
+func darwinOSRelease(release *[256]byte) error {
+	// from x/sys/unix/zerrors_openbsd_amd64.go
+	const (
+		CTL_KERN       = 0x1
+		KERN_OSRELEASE = 0x2
+	)
+
+	mib := []_C_int{CTL_KERN, KERN_OSRELEASE}
+	n := unsafe.Sizeof(*release)
+
+	return sysctl(mib, &release[0], &n, nil, 0)
+}
+
+type Errno = syscall.Errno
+
+var _zero uintptr // Single-word zero for use when we need a valid pointer to 0 bytes.
+
+// from x/sys/unix/zsyscall_darwin_amd64.go L791-807
+func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) error {
+	var _p0 unsafe.Pointer
+	if len(mib) > 0 {
+		_p0 = unsafe.Pointer(&mib[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	if _, _, err := syscall_syscall6(
+		libc_sysctl_trampoline_addr,
+		uintptr(_p0),
+		uintptr(len(mib)),
+		uintptr(unsafe.Pointer(old)),
+		uintptr(unsafe.Pointer(oldlen)),
+		uintptr(unsafe.Pointer(new)),
+		uintptr(newlen),
+	); err != 0 {
+		return err
+	}
+
+	return nil
+}
+
+var libc_sysctl_trampoline_addr uintptr
+
+// adapted from internal/cpu/cpu_arm64_darwin.go
+func darwinSysctlEnabled(name []byte) bool {
+	out := int32(0)
+	nout := unsafe.Sizeof(out)
+	if ret := sysctlbyname(&name[0], (*byte)(unsafe.Pointer(&out)), &nout, nil, 0); ret != nil {
+		return false
+	}
+	return out > 0
+}
+
+//go:cgo_import_dynamic libc_sysctl sysctl "/usr/lib/libSystem.B.dylib"
+
+var libc_sysctlbyname_trampoline_addr uintptr
+
+// adapted from runtime/sys_darwin.go in the pattern of sysctl() above, as defined in x/sys/unix
+func sysctlbyname(name *byte, old *byte, oldlen *uintptr, new *byte, newlen uintptr) error {
+	if _, _, err := syscall_syscall6(
+		libc_sysctlbyname_trampoline_addr,
+		uintptr(unsafe.Pointer(name)),
+		uintptr(unsafe.Pointer(old)),
+		uintptr(unsafe.Pointer(oldlen)),
+		uintptr(unsafe.Pointer(new)),
+		uintptr(newlen),
+		0,
+	); err != 0 {
+		return err
+	}
+
+	return nil
+}
+
+//go:cgo_import_dynamic libc_sysctlbyname sysctlbyname "/usr/lib/libSystem.B.dylib"
+
+// Implemented in the runtime package (runtime/sys_darwin.go)
+func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+
+//go:linkname syscall_syscall6 syscall.syscall6
diff --git a/vendor/golang.org/x/sys/unix/README.md b/vendor/golang.org/x/sys/unix/README.md
index 7d3c060e..6e08a76a 100644
--- a/vendor/golang.org/x/sys/unix/README.md
+++ b/vendor/golang.org/x/sys/unix/README.md
@@ -156,7 +156,7 @@ from the generated architecture-specific files listed below, and merge these
 into a common file for each OS.
 
 The merge is performed in the following steps:
-1. Construct the set of common code that is idential in all architecture-specific files.
+1. Construct the set of common code that is identical in all architecture-specific files.
 2. Write this common code to the merged file.
 3. Remove the common code from all architecture-specific files.
 
diff --git a/vendor/golang.org/x/sys/unix/auxv.go b/vendor/golang.org/x/sys/unix/auxv.go
new file mode 100644
index 00000000..37a82528
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/auxv.go
@@ -0,0 +1,36 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.21 && (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos)
+
+package unix
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+//go:linkname runtime_getAuxv runtime.getAuxv
+func runtime_getAuxv() []uintptr
+
+// Auxv returns the ELF auxiliary vector as a sequence of key/value pairs.
+// The returned slice is always a fresh copy, owned by the caller.
+// It returns an error on non-ELF platforms, or if the auxiliary vector cannot be accessed,
+// which happens in some locked-down environments and build modes.
+func Auxv() ([][2]uintptr, error) {
+	vec := runtime_getAuxv()
+	vecLen := len(vec)
+
+	if vecLen == 0 {
+		return nil, syscall.ENOENT
+	}
+
+	if vecLen%2 != 0 {
+		return nil, syscall.EINVAL
+	}
+
+	result := make([]uintptr, vecLen)
+	copy(result, vec)
+	return unsafe.Slice((*[2]uintptr)(unsafe.Pointer(&result[0])), vecLen/2), nil
+}
diff --git a/vendor/golang.org/x/sys/unix/auxv_unsupported.go b/vendor/golang.org/x/sys/unix/auxv_unsupported.go
new file mode 100644
index 00000000..1200487f
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/auxv_unsupported.go
@@ -0,0 +1,13 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !go1.21 && (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos)
+
+package unix
+
+import "syscall"
+
+func Auxv() ([][2]uintptr, error) {
+	return nil, syscall.ENOTSUP
+}
diff --git a/vendor/golang.org/x/sys/unix/ioctl_linux.go b/vendor/golang.org/x/sys/unix/ioctl_linux.go
index dbe680ea..7ca4fa12 100644
--- a/vendor/golang.org/x/sys/unix/ioctl_linux.go
+++ b/vendor/golang.org/x/sys/unix/ioctl_linux.go
@@ -58,6 +58,102 @@ func IoctlGetEthtoolDrvinfo(fd int, ifname string) (*EthtoolDrvinfo, error) {
 	return &value, err
 }
 
+// IoctlGetEthtoolTsInfo fetches ethtool timestamping and PHC
+// association for the network device specified by ifname.
+func IoctlGetEthtoolTsInfo(fd int, ifname string) (*EthtoolTsInfo, error) {
+	ifr, err := NewIfreq(ifname)
+	if err != nil {
+		return nil, err
+	}
+
+	value := EthtoolTsInfo{Cmd: ETHTOOL_GET_TS_INFO}
+	ifrd := ifr.withData(unsafe.Pointer(&value))
+
+	err = ioctlIfreqData(fd, SIOCETHTOOL, &ifrd)
+	return &value, err
+}
+
+// IoctlGetHwTstamp retrieves the hardware timestamping configuration
+// for the network device specified by ifname.
+func IoctlGetHwTstamp(fd int, ifname string) (*HwTstampConfig, error) {
+	ifr, err := NewIfreq(ifname)
+	if err != nil {
+		return nil, err
+	}
+
+	value := HwTstampConfig{}
+	ifrd := ifr.withData(unsafe.Pointer(&value))
+
+	err = ioctlIfreqData(fd, SIOCGHWTSTAMP, &ifrd)
+	return &value, err
+}
+
+// IoctlSetHwTstamp updates the hardware timestamping configuration for
+// the network device specified by ifname.
+func IoctlSetHwTstamp(fd int, ifname string, cfg *HwTstampConfig) error {
+	ifr, err := NewIfreq(ifname)
+	if err != nil {
+		return err
+	}
+	ifrd := ifr.withData(unsafe.Pointer(cfg))
+	return ioctlIfreqData(fd, SIOCSHWTSTAMP, &ifrd)
+}
+
+// FdToClockID derives the clock ID from the file descriptor number
+// - see clock_gettime(3), FD_TO_CLOCKID macros. The resulting ID is
+// suitable for system calls like ClockGettime.
+func FdToClockID(fd int) int32 { return int32((int(^fd) << 3) | 3) }
+
+// IoctlPtpClockGetcaps returns the description of a given PTP device.
+func IoctlPtpClockGetcaps(fd int) (*PtpClockCaps, error) {
+	var value PtpClockCaps
+	err := ioctlPtr(fd, PTP_CLOCK_GETCAPS2, unsafe.Pointer(&value))
+	return &value, err
+}
+
+// IoctlPtpSysOffsetPrecise returns a description of the clock
+// offset compared to the system clock.
+func IoctlPtpSysOffsetPrecise(fd int) (*PtpSysOffsetPrecise, error) {
+	var value PtpSysOffsetPrecise
+	err := ioctlPtr(fd, PTP_SYS_OFFSET_PRECISE2, unsafe.Pointer(&value))
+	return &value, err
+}
+
+// IoctlPtpSysOffsetExtended returns an extended description of the
+// clock offset compared to the system clock. The samples parameter
+// specifies the desired number of measurements.
+func IoctlPtpSysOffsetExtended(fd int, samples uint) (*PtpSysOffsetExtended, error) {
+	value := PtpSysOffsetExtended{Samples: uint32(samples)}
+	err := ioctlPtr(fd, PTP_SYS_OFFSET_EXTENDED2, unsafe.Pointer(&value))
+	return &value, err
+}
+
+// IoctlPtpPinGetfunc returns the configuration of the specified
+// I/O pin on given PTP device.
+func IoctlPtpPinGetfunc(fd int, index uint) (*PtpPinDesc, error) {
+	value := PtpPinDesc{Index: uint32(index)}
+	err := ioctlPtr(fd, PTP_PIN_GETFUNC2, unsafe.Pointer(&value))
+	return &value, err
+}
+
+// IoctlPtpPinSetfunc updates configuration of the specified PTP
+// I/O pin.
+func IoctlPtpPinSetfunc(fd int, pd *PtpPinDesc) error {
+	return ioctlPtr(fd, PTP_PIN_SETFUNC2, unsafe.Pointer(pd))
+}
+
+// IoctlPtpPeroutRequest configures the periodic output mode of the
+// PTP I/O pins.
+func IoctlPtpPeroutRequest(fd int, r *PtpPeroutRequest) error {
+	return ioctlPtr(fd, PTP_PEROUT_REQUEST2, unsafe.Pointer(r))
+}
+
+// IoctlPtpExttsRequest configures the external timestamping mode
+// of the PTP I/O pins.
+func IoctlPtpExttsRequest(fd int, r *PtpExttsRequest) error {
+	return ioctlPtr(fd, PTP_EXTTS_REQUEST2, unsafe.Pointer(r))
+}
+
 // IoctlGetWatchdogInfo fetches information about a watchdog device from the
 // Linux watchdog API. For more information, see:
 // https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html.
diff --git a/vendor/golang.org/x/sys/unix/mkerrors.sh b/vendor/golang.org/x/sys/unix/mkerrors.sh
index d07dd09e..6ab02b6c 100644
--- a/vendor/golang.org/x/sys/unix/mkerrors.sh
+++ b/vendor/golang.org/x/sys/unix/mkerrors.sh
@@ -158,6 +158,16 @@ includes_Linux='
 #endif
 #define _GNU_SOURCE
 
+// See the description in unix/linux/types.go
+#if defined(__ARM_EABI__) || \
+	(defined(__mips__) && (_MIPS_SIM == _ABIO32)) || \
+	(defined(__powerpc__) && (!defined(__powerpc64__)))
+# ifdef   _TIME_BITS
+#  undef  _TIME_BITS
+# endif
+# define  _TIME_BITS 32
+#endif
+
 // <sys/ioctl.h> is broken on powerpc64, as it fails to include definitions of
 // these structures. We just include them copied from <bits/termios.h>.
 #if defined(__powerpc__)
@@ -256,6 +266,7 @@ struct ltchars {
 #include <linux/nsfs.h>
 #include <linux/perf_event.h>
 #include <linux/pps.h>
+#include <linux/ptp_clock.h>
 #include <linux/ptrace.h>
 #include <linux/random.h>
 #include <linux/reboot.h>
@@ -527,6 +538,7 @@ ccflags="$@"
 		$2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|TCP|MCAST|EVFILT|NOTE|SHUT|PROT|MAP|MREMAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR|LOCAL|TCPOPT|UDP)_/ ||
 		$2 ~ /^NFC_(GENL|PROTO|COMM|RF|SE|DIRECTION|LLCP|SOCKPROTO)_/ ||
 		$2 ~ /^NFC_.*_(MAX)?SIZE$/ ||
+		$2 ~ /^PTP_/ ||
 		$2 ~ /^RAW_PAYLOAD_/ ||
 		$2 ~ /^[US]F_/ ||
 		$2 ~ /^TP_STATUS_/ ||
@@ -552,6 +564,7 @@ ccflags="$@"
 		$2 !~ /^RTC_VL_(ACCURACY|BACKUP|DATA)/ &&
 		$2 ~ /^(NETLINK|NLM|NLMSG|NLA|IFA|IFAN|RT|RTC|RTCF|RTN|RTPROT|RTNH|ARPHRD|ETH_P|NETNSA)_/ ||
 		$2 ~ /^SOCK_|SK_DIAG_|SKNLGRP_$/ ||
+		$2 ~ /^(CONNECT|SAE)_/ ||
 		$2 ~ /^FIORDCHK$/ ||
 		$2 ~ /^SIOC/ ||
 		$2 ~ /^TIOC/ ||
@@ -655,7 +668,7 @@ errors=$(
 signals=$(
 	echo '#include <signal.h>' | $CC -x c - -E -dM $ccflags |
 	awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print $2 }' |
-	grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT\|SIGMAX64' |
+	grep -E -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' |
 	sort
 )
 
@@ -665,7 +678,7 @@ echo '#include <errno.h>' | $CC -x c - -E -dM $ccflags |
 	sort >_error.grep
 echo '#include <signal.h>' | $CC -x c - -E -dM $ccflags |
 	awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print "^\t" $2 "[ \t]*=" }' |
-	grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT\|SIGMAX64' |
+	grep -E -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' |
 	sort >_signal.grep
 
 echo '// mkerrors.sh' "$@"
diff --git a/vendor/golang.org/x/sys/unix/syscall_aix.go b/vendor/golang.org/x/sys/unix/syscall_aix.go
index 67ce6cef..6f15ba1e 100644
--- a/vendor/golang.org/x/sys/unix/syscall_aix.go
+++ b/vendor/golang.org/x/sys/unix/syscall_aix.go
@@ -360,7 +360,7 @@ func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int,
 	var status _C_int
 	var r Pid_t
 	err = ERESTART
-	// AIX wait4 may return with ERESTART errno, while the processus is still
+	// AIX wait4 may return with ERESTART errno, while the process is still
 	// active.
 	for err == ERESTART {
 		r, err = wait4(Pid_t(pid), &status, options, rusage)
diff --git a/vendor/golang.org/x/sys/unix/syscall_darwin.go b/vendor/golang.org/x/sys/unix/syscall_darwin.go
index 2d15200a..099867de 100644
--- a/vendor/golang.org/x/sys/unix/syscall_darwin.go
+++ b/vendor/golang.org/x/sys/unix/syscall_darwin.go
@@ -566,6 +566,43 @@ func PthreadFchdir(fd int) (err error) {
 	return pthread_fchdir_np(fd)
 }
 
+// Connectx calls connectx(2) to initiate a connection on a socket.
+//
+// srcIf, srcAddr, and dstAddr are filled into a [SaEndpoints] struct and passed as the endpoints argument.
+//
+//   - srcIf is the optional source interface index. 0 means unspecified.
+//   - srcAddr is the optional source address. nil means unspecified.
+//   - dstAddr is the destination address.
+//
+// On success, Connectx returns the number of bytes enqueued for transmission.
+func Connectx(fd int, srcIf uint32, srcAddr, dstAddr Sockaddr, associd SaeAssocID, flags uint32, iov []Iovec, connid *SaeConnID) (n uintptr, err error) {
+	endpoints := SaEndpoints{
+		Srcif: srcIf,
+	}
+
+	if srcAddr != nil {
+		addrp, addrlen, err := srcAddr.sockaddr()
+		if err != nil {
+			return 0, err
+		}
+		endpoints.Srcaddr = (*RawSockaddr)(addrp)
+		endpoints.Srcaddrlen = uint32(addrlen)
+	}
+
+	if dstAddr != nil {
+		addrp, addrlen, err := dstAddr.sockaddr()
+		if err != nil {
+			return 0, err
+		}
+		endpoints.Dstaddr = (*RawSockaddr)(addrp)
+		endpoints.Dstaddrlen = uint32(addrlen)
+	}
+
+	err = connectx(fd, &endpoints, associd, flags, iov, &n, connid)
+	return
+}
+
+//sys	connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error)
 //sys	sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error)
 
 //sys	shmat(id int, addr uintptr, flag int) (ret uintptr, err error)
diff --git a/vendor/golang.org/x/sys/unix/syscall_dragonfly.go b/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
index 97cb916f..be8c0020 100644
--- a/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
+++ b/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
@@ -246,6 +246,18 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 	return sendfile(outfd, infd, offset, count)
 }
 
+func Dup3(oldfd, newfd, flags int) error {
+	if oldfd == newfd || flags&^O_CLOEXEC != 0 {
+		return EINVAL
+	}
+	how := F_DUP2FD
+	if flags&O_CLOEXEC != 0 {
+		how = F_DUP2FD_CLOEXEC
+	}
+	_, err := fcntl(oldfd, how, newfd)
+	return err
+}
+
 /*
  * Exposed directly
  */
diff --git a/vendor/golang.org/x/sys/unix/syscall_hurd.go b/vendor/golang.org/x/sys/unix/syscall_hurd.go
index ba46651f..a6a2d2fc 100644
--- a/vendor/golang.org/x/sys/unix/syscall_hurd.go
+++ b/vendor/golang.org/x/sys/unix/syscall_hurd.go
@@ -11,6 +11,7 @@ package unix
 int ioctl(int, unsigned long int, uintptr_t);
 */
 import "C"
+import "unsafe"
 
 func ioctl(fd int, req uint, arg uintptr) (err error) {
 	r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(arg))
diff --git a/vendor/golang.org/x/sys/unix/syscall_linux.go b/vendor/golang.org/x/sys/unix/syscall_linux.go
index 3f1d3d4c..230a9454 100644
--- a/vendor/golang.org/x/sys/unix/syscall_linux.go
+++ b/vendor/golang.org/x/sys/unix/syscall_linux.go
@@ -1295,6 +1295,48 @@ func GetsockoptTCPInfo(fd, level, opt int) (*TCPInfo, error) {
 	return &value, err
 }
 
+// GetsockoptTCPCCVegasInfo returns algorithm specific congestion control information for a socket using the "vegas"
+// algorithm.
+//
+// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option:
+//
+//	algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION)
+func GetsockoptTCPCCVegasInfo(fd, level, opt int) (*TCPVegasInfo, error) {
+	var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment
+	vallen := _Socklen(SizeofTCPCCInfo)
+	err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
+	out := (*TCPVegasInfo)(unsafe.Pointer(&value[0]))
+	return out, err
+}
+
+// GetsockoptTCPCCDCTCPInfo returns algorithm specific congestion control information for a socket using the "dctp"
+// algorithm.
+//
+// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option:
+//
+//	algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION)
+func GetsockoptTCPCCDCTCPInfo(fd, level, opt int) (*TCPDCTCPInfo, error) {
+	var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment
+	vallen := _Socklen(SizeofTCPCCInfo)
+	err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
+	out := (*TCPDCTCPInfo)(unsafe.Pointer(&value[0]))
+	return out, err
+}
+
+// GetsockoptTCPCCBBRInfo returns algorithm specific congestion control information for a socket using the "bbr"
+// algorithm.
+//
+// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option:
+//
+//	algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION)
+func GetsockoptTCPCCBBRInfo(fd, level, opt int) (*TCPBBRInfo, error) {
+	var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment
+	vallen := _Socklen(SizeofTCPCCInfo)
+	err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
+	out := (*TCPBBRInfo)(unsafe.Pointer(&value[0]))
+	return out, err
+}
+
 // GetsockoptString returns the string value of the socket option opt for the
 // socket associated with fd at the given socket level.
 func GetsockoptString(fd, level, opt int) (string, error) {
@@ -1818,6 +1860,7 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 //sys	ClockAdjtime(clockid int32, buf *Timex) (state int, err error)
 //sys	ClockGetres(clockid int32, res *Timespec) (err error)
 //sys	ClockGettime(clockid int32, time *Timespec) (err error)
+//sys	ClockSettime(clockid int32, time *Timespec) (err error)
 //sys	ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error)
 //sys	Close(fd int) (err error)
 //sys	CloseRange(first uint, last uint, flags uint) (err error)
@@ -1959,7 +2002,26 @@ func Getpgrp() (pid int) {
 //sysnb	Getpid() (pid int)
 //sysnb	Getppid() (ppid int)
 //sys	Getpriority(which int, who int) (prio int, err error)
-//sys	Getrandom(buf []byte, flags int) (n int, err error)
+
+func Getrandom(buf []byte, flags int) (n int, err error) {
+	vdsoRet, supported := vgetrandom(buf, uint32(flags))
+	if supported {
+		if vdsoRet < 0 {
+			return 0, errnoErr(syscall.Errno(-vdsoRet))
+		}
+		return vdsoRet, nil
+	}
+	var p *byte
+	if len(buf) > 0 {
+		p = &buf[0]
+	}
+	r, _, e := Syscall(SYS_GETRANDOM, uintptr(unsafe.Pointer(p)), uintptr(len(buf)), uintptr(flags))
+	if e != 0 {
+		return 0, errnoErr(e)
+	}
+	return int(r), nil
+}
+
 //sysnb	Getrusage(who int, rusage *Rusage) (err error)
 //sysnb	Getsid(pid int) (sid int, err error)
 //sysnb	Gettid() (tid int)
diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go b/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
index cf2ee6c7..745e5c7e 100644
--- a/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
@@ -182,3 +182,5 @@ func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error
 	}
 	return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags)
 }
+
+const SYS_FSTATAT = SYS_NEWFSTATAT
diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go b/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go
index 3d0e9845..dd2262a4 100644
--- a/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go
+++ b/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go
@@ -214,3 +214,5 @@ func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error
 	}
 	return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags)
 }
+
+const SYS_FSTATAT = SYS_NEWFSTATAT
diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go b/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
index 6f5a2889..8cf3670b 100644
--- a/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
@@ -187,3 +187,5 @@ func RISCVHWProbe(pairs []RISCVHWProbePairs, set *CPUSet, flags uint) (err error
 	}
 	return riscvHWProbe(pairs, setSize, set, flags)
 }
+
+const SYS_FSTATAT = SYS_NEWFSTATAT
diff --git a/vendor/golang.org/x/sys/unix/syscall_solaris.go b/vendor/golang.org/x/sys/unix/syscall_solaris.go
index 21974af0..abc39554 100644
--- a/vendor/golang.org/x/sys/unix/syscall_solaris.go
+++ b/vendor/golang.org/x/sys/unix/syscall_solaris.go
@@ -1102,3 +1102,90 @@ func (s *Strioctl) SetInt(i int) {
 func IoctlSetStrioctlRetInt(fd int, req int, s *Strioctl) (int, error) {
 	return ioctlPtrRet(fd, req, unsafe.Pointer(s))
 }
+
+// Ucred Helpers
+// See ucred(3c) and getpeerucred(3c)
+
+//sys	getpeerucred(fd uintptr, ucred *uintptr) (err error)
+//sys	ucredFree(ucred uintptr) = ucred_free
+//sys	ucredGet(pid int) (ucred uintptr, err error) = ucred_get
+//sys	ucredGeteuid(ucred uintptr) (uid int) = ucred_geteuid
+//sys	ucredGetegid(ucred uintptr) (gid int) = ucred_getegid
+//sys	ucredGetruid(ucred uintptr) (uid int) = ucred_getruid
+//sys	ucredGetrgid(ucred uintptr) (gid int) = ucred_getrgid
+//sys	ucredGetsuid(ucred uintptr) (uid int) = ucred_getsuid
+//sys	ucredGetsgid(ucred uintptr) (gid int) = ucred_getsgid
+//sys	ucredGetpid(ucred uintptr) (pid int) = ucred_getpid
+
+// Ucred is an opaque struct that holds user credentials.
+type Ucred struct {
+	ucred uintptr
+}
+
+// We need to ensure that ucredFree is called on the underlying ucred
+// when the Ucred is garbage collected.
+func ucredFinalizer(u *Ucred) {
+	ucredFree(u.ucred)
+}
+
+func GetPeerUcred(fd uintptr) (*Ucred, error) {
+	var ucred uintptr
+	err := getpeerucred(fd, &ucred)
+	if err != nil {
+		return nil, err
+	}
+	result := &Ucred{
+		ucred: ucred,
+	}
+	// set the finalizer on the result so that the ucred will be freed
+	runtime.SetFinalizer(result, ucredFinalizer)
+	return result, nil
+}
+
+func UcredGet(pid int) (*Ucred, error) {
+	ucred, err := ucredGet(pid)
+	if err != nil {
+		return nil, err
+	}
+	result := &Ucred{
+		ucred: ucred,
+	}
+	// set the finalizer on the result so that the ucred will be freed
+	runtime.SetFinalizer(result, ucredFinalizer)
+	return result, nil
+}
+
+func (u *Ucred) Geteuid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGeteuid(u.ucred)
+}
+
+func (u *Ucred) Getruid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetruid(u.ucred)
+}
+
+func (u *Ucred) Getsuid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetsuid(u.ucred)
+}
+
+func (u *Ucred) Getegid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetegid(u.ucred)
+}
+
+func (u *Ucred) Getrgid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetrgid(u.ucred)
+}
+
+func (u *Ucred) Getsgid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetsgid(u.ucred)
+}
+
+func (u *Ucred) Getpid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetpid(u.ucred)
+}
diff --git a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
index 312ae6ac..7bf5c04b 100644
--- a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
+++ b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
@@ -768,6 +768,15 @@ func Munmap(b []byte) (err error) {
 	return mapper.Munmap(b)
 }
 
+func MmapPtr(fd int, offset int64, addr unsafe.Pointer, length uintptr, prot int, flags int) (ret unsafe.Pointer, err error) {
+	xaddr, err := mapper.mmap(uintptr(addr), length, prot, flags, fd, offset)
+	return unsafe.Pointer(xaddr), err
+}
+
+func MunmapPtr(addr unsafe.Pointer, length uintptr) (err error) {
+	return mapper.munmap(uintptr(addr), length)
+}
+
 //sys   Gethostname(buf []byte) (err error) = SYS___GETHOSTNAME_A
 //sysnb	Getgid() (gid int)
 //sysnb	Getpid() (pid int)
@@ -816,10 +825,10 @@ func Lstat(path string, stat *Stat_t) (err error) {
 // for checking symlinks begins with $VERSION/ $SYSNAME/ $SYSSYMR/ $SYSSYMA/
 func isSpecialPath(path []byte) (v bool) {
 	var special = [4][8]byte{
-		[8]byte{'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'},
-		[8]byte{'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'},
-		[8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'},
-		[8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}}
+		{'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'},
+		{'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'},
+		{'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'},
+		{'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}}
 
 	var i, j int
 	for i = 0; i < len(special); i++ {
@@ -3115,3 +3124,90 @@ func legacy_Mkfifoat(dirfd int, path string, mode uint32) (err error) {
 //sys	Posix_openpt(oflag int) (fd int, err error) = SYS_POSIX_OPENPT
 //sys	Grantpt(fildes int) (rc int, err error) = SYS_GRANTPT
 //sys	Unlockpt(fildes int) (rc int, err error) = SYS_UNLOCKPT
+
+func fcntlAsIs(fd uintptr, cmd int, arg uintptr) (val int, err error) {
+	runtime.EnterSyscall()
+	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCNTL<<4, uintptr(fd), uintptr(cmd), arg)
+	runtime.ExitSyscall()
+	val = int(r0)
+	if int64(r0) == -1 {
+		err = errnoErr2(e1, e2)
+	}
+	return
+}
+
+func Fcntl(fd uintptr, cmd int, op interface{}) (ret int, err error) {
+	switch op.(type) {
+	case *Flock_t:
+		err = FcntlFlock(fd, cmd, op.(*Flock_t))
+		if err != nil {
+			ret = -1
+		}
+		return
+	case int:
+		return FcntlInt(fd, cmd, op.(int))
+	case *F_cnvrt:
+		return fcntlAsIs(fd, cmd, uintptr(unsafe.Pointer(op.(*F_cnvrt))))
+	case unsafe.Pointer:
+		return fcntlAsIs(fd, cmd, uintptr(op.(unsafe.Pointer)))
+	default:
+		return -1, EINVAL
+	}
+	return
+}
+
+func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
+	if raceenabled {
+		raceReleaseMerge(unsafe.Pointer(&ioSync))
+	}
+	return sendfile(outfd, infd, offset, count)
+}
+
+func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
+	// TODO: use LE call instead if the call is implemented
+	originalOffset, err := Seek(infd, 0, SEEK_CUR)
+	if err != nil {
+		return -1, err
+	}
+	//start reading data from in_fd
+	if offset != nil {
+		_, err := Seek(infd, *offset, SEEK_SET)
+		if err != nil {
+			return -1, err
+		}
+	}
+
+	buf := make([]byte, count)
+	readBuf := make([]byte, 0)
+	var n int = 0
+	for i := 0; i < count; i += n {
+		n, err := Read(infd, buf)
+		if n == 0 {
+			if err != nil {
+				return -1, err
+			} else { // EOF
+				break
+			}
+		}
+		readBuf = append(readBuf, buf...)
+		buf = buf[0:0]
+	}
+
+	n2, err := Write(outfd, readBuf)
+	if err != nil {
+		return -1, err
+	}
+
+	//When sendfile() returns, this variable will be set to the
+	// offset of the byte following the last byte that was read.
+	if offset != nil {
+		*offset = *offset + int64(n)
+		// If offset is not NULL, then sendfile() does not modify the file
+		// offset of in_fd
+		_, err := Seek(infd, originalOffset, SEEK_SET)
+		if err != nil {
+			return -1, err
+		}
+	}
+	return n2, nil
+}
diff --git a/vendor/golang.org/x/sys/unix/vgetrandom_linux.go b/vendor/golang.org/x/sys/unix/vgetrandom_linux.go
new file mode 100644
index 00000000..07ac8e09
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/vgetrandom_linux.go
@@ -0,0 +1,13 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build linux && go1.24
+
+package unix
+
+import _ "unsafe"
+
+//go:linkname vgetrandom runtime.vgetrandom
+//go:noescape
+func vgetrandom(p []byte, flags uint32) (ret int, supported bool)
diff --git a/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go b/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go
new file mode 100644
index 00000000..297e97bc
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go
@@ -0,0 +1,11 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !linux || !go1.24
+
+package unix
+
+func vgetrandom(p []byte, flags uint32) (ret int, supported bool) {
+	return -1, false
+}
diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
index 4308ac17..d73c4652 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
@@ -237,6 +237,9 @@ const (
 	CLOCK_UPTIME_RAW_APPROX                 = 0x9
 	CLONE_NOFOLLOW                          = 0x1
 	CLONE_NOOWNERCOPY                       = 0x2
+	CONNECT_DATA_AUTHENTICATED              = 0x4
+	CONNECT_DATA_IDEMPOTENT                 = 0x2
+	CONNECT_RESUME_ON_READ_WRITE            = 0x1
 	CR0                                     = 0x0
 	CR1                                     = 0x1000
 	CR2                                     = 0x2000
@@ -1265,6 +1268,10 @@ const (
 	RTV_SSTHRESH                            = 0x20
 	RUSAGE_CHILDREN                         = -0x1
 	RUSAGE_SELF                             = 0x0
+	SAE_ASSOCID_ALL                         = 0xffffffff
+	SAE_ASSOCID_ANY                         = 0x0
+	SAE_CONNID_ALL                          = 0xffffffff
+	SAE_CONNID_ANY                          = 0x0
 	SCM_CREDS                               = 0x3
 	SCM_RIGHTS                              = 0x1
 	SCM_TIMESTAMP                           = 0x2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
index c8068a7a..4a55a400 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
@@ -237,6 +237,9 @@ const (
 	CLOCK_UPTIME_RAW_APPROX                 = 0x9
 	CLONE_NOFOLLOW                          = 0x1
 	CLONE_NOOWNERCOPY                       = 0x2
+	CONNECT_DATA_AUTHENTICATED              = 0x4
+	CONNECT_DATA_IDEMPOTENT                 = 0x2
+	CONNECT_RESUME_ON_READ_WRITE            = 0x1
 	CR0                                     = 0x0
 	CR1                                     = 0x1000
 	CR2                                     = 0x2000
@@ -1265,6 +1268,10 @@ const (
 	RTV_SSTHRESH                            = 0x20
 	RUSAGE_CHILDREN                         = -0x1
 	RUSAGE_SELF                             = 0x0
+	SAE_ASSOCID_ALL                         = 0xffffffff
+	SAE_ASSOCID_ANY                         = 0x0
+	SAE_CONNID_ALL                          = 0xffffffff
+	SAE_CONNID_ANY                          = 0x0
 	SCM_CREDS                               = 0x3
 	SCM_RIGHTS                              = 0x1
 	SCM_TIMESTAMP                           = 0x2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux.go b/vendor/golang.org/x/sys/unix/zerrors_linux.go
index 01a70b24..4f432bfe 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux.go
@@ -321,6 +321,9 @@ const (
 	AUDIT_INTEGRITY_STATUS                      = 0x70a
 	AUDIT_IPC                                   = 0x517
 	AUDIT_IPC_SET_PERM                          = 0x51f
+	AUDIT_IPE_ACCESS                            = 0x58c
+	AUDIT_IPE_CONFIG_CHANGE                     = 0x58d
+	AUDIT_IPE_POLICY_LOAD                       = 0x58e
 	AUDIT_KERNEL                                = 0x7d0
 	AUDIT_KERNEL_OTHER                          = 0x524
 	AUDIT_KERN_MODULE                           = 0x532
@@ -489,12 +492,14 @@ const (
 	BPF_F_ID                                    = 0x20
 	BPF_F_NETFILTER_IP_DEFRAG                   = 0x1
 	BPF_F_QUERY_EFFECTIVE                       = 0x1
+	BPF_F_REDIRECT_FLAGS                        = 0x19
 	BPF_F_REPLACE                               = 0x4
 	BPF_F_SLEEPABLE                             = 0x10
 	BPF_F_STRICT_ALIGNMENT                      = 0x1
 	BPF_F_TEST_REG_INVARIANTS                   = 0x80
 	BPF_F_TEST_RND_HI32                         = 0x4
 	BPF_F_TEST_RUN_ON_CPU                       = 0x1
+	BPF_F_TEST_SKB_CHECKSUM_COMPLETE            = 0x4
 	BPF_F_TEST_STATE_FREQ                       = 0x8
 	BPF_F_TEST_XDP_LIVE_FRAMES                  = 0x2
 	BPF_F_XDP_DEV_BOUND_ONLY                    = 0x40
@@ -1165,6 +1170,7 @@ const (
 	EXTA                                        = 0xe
 	EXTB                                        = 0xf
 	F2FS_SUPER_MAGIC                            = 0xf2f52010
+	FALLOC_FL_ALLOCATE_RANGE                    = 0x0
 	FALLOC_FL_COLLAPSE_RANGE                    = 0x8
 	FALLOC_FL_INSERT_RANGE                      = 0x20
 	FALLOC_FL_KEEP_SIZE                         = 0x1
@@ -1239,6 +1245,7 @@ const (
 	FAN_REPORT_DFID_NAME                        = 0xc00
 	FAN_REPORT_DFID_NAME_TARGET                 = 0x1e00
 	FAN_REPORT_DIR_FID                          = 0x400
+	FAN_REPORT_FD_ERROR                         = 0x2000
 	FAN_REPORT_FID                              = 0x200
 	FAN_REPORT_NAME                             = 0x800
 	FAN_REPORT_PIDFD                            = 0x80
@@ -1324,8 +1331,10 @@ const (
 	FUSE_SUPER_MAGIC                            = 0x65735546
 	FUTEXFS_SUPER_MAGIC                         = 0xbad1dea
 	F_ADD_SEALS                                 = 0x409
+	F_CREATED_QUERY                             = 0x404
 	F_DUPFD                                     = 0x0
 	F_DUPFD_CLOEXEC                             = 0x406
+	F_DUPFD_QUERY                               = 0x403
 	F_EXLCK                                     = 0x4
 	F_GETFD                                     = 0x1
 	F_GETFL                                     = 0x3
@@ -1545,6 +1554,7 @@ const (
 	IPPROTO_ROUTING                             = 0x2b
 	IPPROTO_RSVP                                = 0x2e
 	IPPROTO_SCTP                                = 0x84
+	IPPROTO_SMC                                 = 0x100
 	IPPROTO_TCP                                 = 0x6
 	IPPROTO_TP                                  = 0x1d
 	IPPROTO_UDP                                 = 0x11
@@ -1617,6 +1627,8 @@ const (
 	IPV6_UNICAST_IF                             = 0x4c
 	IPV6_USER_FLOW                              = 0xe
 	IPV6_V6ONLY                                 = 0x1a
+	IPV6_VERSION                                = 0x60
+	IPV6_VERSION_MASK                           = 0xf0
 	IPV6_XFRM_POLICY                            = 0x23
 	IP_ADD_MEMBERSHIP                           = 0x23
 	IP_ADD_SOURCE_MEMBERSHIP                    = 0x27
@@ -1798,6 +1810,8 @@ const (
 	LANDLOCK_ACCESS_NET_BIND_TCP                = 0x1
 	LANDLOCK_ACCESS_NET_CONNECT_TCP             = 0x2
 	LANDLOCK_CREATE_RULESET_VERSION             = 0x1
+	LANDLOCK_SCOPE_ABSTRACT_UNIX_SOCKET         = 0x1
+	LANDLOCK_SCOPE_SIGNAL                       = 0x2
 	LINUX_REBOOT_CMD_CAD_OFF                    = 0x0
 	LINUX_REBOOT_CMD_CAD_ON                     = 0x89abcdef
 	LINUX_REBOOT_CMD_HALT                       = 0xcdef0123
@@ -1859,6 +1873,7 @@ const (
 	MADV_UNMERGEABLE                            = 0xd
 	MADV_WILLNEED                               = 0x3
 	MADV_WIPEONFORK                             = 0x12
+	MAP_DROPPABLE                               = 0x8
 	MAP_FILE                                    = 0x0
 	MAP_FIXED                                   = 0x10
 	MAP_FIXED_NOREPLACE                         = 0x100000
@@ -1922,6 +1937,8 @@ const (
 	MNT_EXPIRE                                  = 0x4
 	MNT_FORCE                                   = 0x1
 	MNT_ID_REQ_SIZE_VER0                        = 0x18
+	MNT_ID_REQ_SIZE_VER1                        = 0x20
+	MNT_NS_INFO_SIZE_VER0                       = 0x10
 	MODULE_INIT_COMPRESSED_FILE                 = 0x4
 	MODULE_INIT_IGNORE_MODVERSIONS              = 0x1
 	MODULE_INIT_IGNORE_VERMAGIC                 = 0x2
@@ -1957,6 +1974,7 @@ const (
 	MSG_PEEK                                    = 0x2
 	MSG_PROXY                                   = 0x10
 	MSG_RST                                     = 0x1000
+	MSG_SOCK_DEVMEM                             = 0x2000000
 	MSG_SYN                                     = 0x400
 	MSG_TRUNC                                   = 0x20
 	MSG_TRYHARD                                 = 0x4
@@ -2073,6 +2091,7 @@ const (
 	NFC_ATR_REQ_MAXSIZE                         = 0x40
 	NFC_ATR_RES_GB_MAXSIZE                      = 0x2f
 	NFC_ATR_RES_MAXSIZE                         = 0x40
+	NFC_ATS_MAXSIZE                             = 0x14
 	NFC_COMM_ACTIVE                             = 0x0
 	NFC_COMM_PASSIVE                            = 0x1
 	NFC_DEVICE_NAME_MAXSIZE                     = 0x8
@@ -2153,6 +2172,7 @@ const (
 	NFNL_SUBSYS_QUEUE                           = 0x3
 	NFNL_SUBSYS_ULOG                            = 0x4
 	NFS_SUPER_MAGIC                             = 0x6969
+	NFT_BITWISE_BOOL                            = 0x0
 	NFT_CHAIN_FLAGS                             = 0x7
 	NFT_CHAIN_MAXNAMELEN                        = 0x100
 	NFT_CT_MAX                                  = 0x17
@@ -2187,7 +2207,7 @@ const (
 	NFT_REG_SIZE                                = 0x10
 	NFT_REJECT_ICMPX_MAX                        = 0x3
 	NFT_RT_MAX                                  = 0x4
-	NFT_SECMARK_CTX_MAXLEN                      = 0x100
+	NFT_SECMARK_CTX_MAXLEN                      = 0x1000
 	NFT_SET_MAXNAMELEN                          = 0x100
 	NFT_SOCKET_MAX                              = 0x3
 	NFT_TABLE_F_MASK                            = 0x7
@@ -2356,9 +2376,11 @@ const (
 	PERF_MEM_LVLNUM_IO                          = 0xa
 	PERF_MEM_LVLNUM_L1                          = 0x1
 	PERF_MEM_LVLNUM_L2                          = 0x2
+	PERF_MEM_LVLNUM_L2_MHB                      = 0x5
 	PERF_MEM_LVLNUM_L3                          = 0x3
 	PERF_MEM_LVLNUM_L4                          = 0x4
 	PERF_MEM_LVLNUM_LFB                         = 0xc
+	PERF_MEM_LVLNUM_MSC                         = 0x6
 	PERF_MEM_LVLNUM_NA                          = 0xf
 	PERF_MEM_LVLNUM_PMEM                        = 0xe
 	PERF_MEM_LVLNUM_RAM                         = 0xd
@@ -2431,6 +2453,7 @@ const (
 	PRIO_PGRP                                   = 0x1
 	PRIO_PROCESS                                = 0x0
 	PRIO_USER                                   = 0x2
+	PROCFS_IOCTL_MAGIC                          = 'f'
 	PROC_SUPER_MAGIC                            = 0x9fa0
 	PROT_EXEC                                   = 0x4
 	PROT_GROWSDOWN                              = 0x1000000
@@ -2478,6 +2501,7 @@ const (
 	PR_GET_PDEATHSIG                            = 0x2
 	PR_GET_SECCOMP                              = 0x15
 	PR_GET_SECUREBITS                           = 0x1b
+	PR_GET_SHADOW_STACK_STATUS                  = 0x4a
 	PR_GET_SPECULATION_CTRL                     = 0x34
 	PR_GET_TAGGED_ADDR_CTRL                     = 0x38
 	PR_GET_THP_DISABLE                          = 0x2a
@@ -2486,6 +2510,7 @@ const (
 	PR_GET_TIMING                               = 0xd
 	PR_GET_TSC                                  = 0x19
 	PR_GET_UNALIGN                              = 0x5
+	PR_LOCK_SHADOW_STACK_STATUS                 = 0x4c
 	PR_MCE_KILL                                 = 0x21
 	PR_MCE_KILL_CLEAR                           = 0x0
 	PR_MCE_KILL_DEFAULT                         = 0x2
@@ -2512,6 +2537,8 @@ const (
 	PR_PAC_GET_ENABLED_KEYS                     = 0x3d
 	PR_PAC_RESET_KEYS                           = 0x36
 	PR_PAC_SET_ENABLED_KEYS                     = 0x3c
+	PR_PMLEN_MASK                               = 0x7f000000
+	PR_PMLEN_SHIFT                              = 0x18
 	PR_PPC_DEXCR_CTRL_CLEAR                     = 0x4
 	PR_PPC_DEXCR_CTRL_CLEAR_ONEXEC              = 0x10
 	PR_PPC_DEXCR_CTRL_EDITABLE                  = 0x1
@@ -2579,6 +2606,7 @@ const (
 	PR_SET_PTRACER                              = 0x59616d61
 	PR_SET_SECCOMP                              = 0x16
 	PR_SET_SECUREBITS                           = 0x1c
+	PR_SET_SHADOW_STACK_STATUS                  = 0x4b
 	PR_SET_SPECULATION_CTRL                     = 0x35
 	PR_SET_SYSCALL_USER_DISPATCH                = 0x3b
 	PR_SET_TAGGED_ADDR_CTRL                     = 0x37
@@ -2589,6 +2617,9 @@ const (
 	PR_SET_UNALIGN                              = 0x6
 	PR_SET_VMA                                  = 0x53564d41
 	PR_SET_VMA_ANON_NAME                        = 0x0
+	PR_SHADOW_STACK_ENABLE                      = 0x1
+	PR_SHADOW_STACK_PUSH                        = 0x4
+	PR_SHADOW_STACK_WRITE                       = 0x2
 	PR_SME_GET_VL                               = 0x40
 	PR_SME_SET_VL                               = 0x3f
 	PR_SME_SET_VL_ONEXEC                        = 0x40000
@@ -2620,6 +2651,28 @@ const (
 	PR_UNALIGN_NOPRINT                          = 0x1
 	PR_UNALIGN_SIGBUS                           = 0x2
 	PSTOREFS_MAGIC                              = 0x6165676c
+	PTP_CLK_MAGIC                               = '='
+	PTP_ENABLE_FEATURE                          = 0x1
+	PTP_EXTTS_EDGES                             = 0x6
+	PTP_EXTTS_EVENT_VALID                       = 0x1
+	PTP_EXTTS_V1_VALID_FLAGS                    = 0x7
+	PTP_EXTTS_VALID_FLAGS                       = 0x1f
+	PTP_EXT_OFFSET                              = 0x10
+	PTP_FALLING_EDGE                            = 0x4
+	PTP_MAX_SAMPLES                             = 0x19
+	PTP_PEROUT_DUTY_CYCLE                       = 0x2
+	PTP_PEROUT_ONE_SHOT                         = 0x1
+	PTP_PEROUT_PHASE                            = 0x4
+	PTP_PEROUT_V1_VALID_FLAGS                   = 0x0
+	PTP_PEROUT_VALID_FLAGS                      = 0x7
+	PTP_PIN_GETFUNC                             = 0xc0603d06
+	PTP_PIN_GETFUNC2                            = 0xc0603d0f
+	PTP_RISING_EDGE                             = 0x2
+	PTP_STRICT_FLAGS                            = 0x8
+	PTP_SYS_OFFSET_EXTENDED                     = 0xc4c03d09
+	PTP_SYS_OFFSET_EXTENDED2                    = 0xc4c03d12
+	PTP_SYS_OFFSET_PRECISE                      = 0xc0403d08
+	PTP_SYS_OFFSET_PRECISE2                     = 0xc0403d11
 	PTRACE_ATTACH                               = 0x10
 	PTRACE_CONT                                 = 0x7
 	PTRACE_DETACH                               = 0x11
@@ -2876,7 +2929,6 @@ const (
 	RTM_NEWNEXTHOP                              = 0x68
 	RTM_NEWNEXTHOPBUCKET                        = 0x74
 	RTM_NEWNSID                                 = 0x58
-	RTM_NEWNVLAN                                = 0x70
 	RTM_NEWPREFIX                               = 0x34
 	RTM_NEWQDISC                                = 0x24
 	RTM_NEWROUTE                                = 0x18
@@ -2885,6 +2937,7 @@ const (
 	RTM_NEWTCLASS                               = 0x28
 	RTM_NEWTFILTER                              = 0x2c
 	RTM_NEWTUNNEL                               = 0x78
+	RTM_NEWVLAN                                 = 0x70
 	RTM_NR_FAMILIES                             = 0x1b
 	RTM_NR_MSGTYPES                             = 0x6c
 	RTM_SETDCB                                  = 0x4f
@@ -2933,15 +2986,17 @@ const (
 	RUSAGE_SELF                                 = 0x0
 	RUSAGE_THREAD                               = 0x1
 	RWF_APPEND                                  = 0x10
+	RWF_ATOMIC                                  = 0x40
 	RWF_DSYNC                                   = 0x2
 	RWF_HIPRI                                   = 0x1
 	RWF_NOAPPEND                                = 0x20
 	RWF_NOWAIT                                  = 0x8
-	RWF_SUPPORTED                               = 0x3f
+	RWF_SUPPORTED                               = 0x7f
 	RWF_SYNC                                    = 0x4
 	RWF_WRITE_LIFE_NOT_SET                      = 0x0
 	SCHED_BATCH                                 = 0x3
 	SCHED_DEADLINE                              = 0x6
+	SCHED_EXT                                   = 0x7
 	SCHED_FIFO                                  = 0x1
 	SCHED_FLAG_ALL                              = 0x7f
 	SCHED_FLAG_DL_OVERRUN                       = 0x4
@@ -3210,6 +3265,7 @@ const (
 	STATX_ATTR_MOUNT_ROOT                       = 0x2000
 	STATX_ATTR_NODUMP                           = 0x40
 	STATX_ATTR_VERITY                           = 0x100000
+	STATX_ATTR_WRITE_ATOMIC                     = 0x400000
 	STATX_BASIC_STATS                           = 0x7ff
 	STATX_BLOCKS                                = 0x400
 	STATX_BTIME                                 = 0x800
@@ -3226,6 +3282,7 @@ const (
 	STATX_SUBVOL                                = 0x8000
 	STATX_TYPE                                  = 0x1
 	STATX_UID                                   = 0x8
+	STATX_WRITE_ATOMIC                          = 0x10000
 	STATX__RESERVED                             = 0x80000000
 	SYNC_FILE_RANGE_WAIT_AFTER                  = 0x4
 	SYNC_FILE_RANGE_WAIT_BEFORE                 = 0x1
@@ -3624,6 +3681,7 @@ const (
 	XDP_UMEM_PGOFF_COMPLETION_RING              = 0x180000000
 	XDP_UMEM_PGOFF_FILL_RING                    = 0x100000000
 	XDP_UMEM_REG                                = 0x4
+	XDP_UMEM_TX_METADATA_LEN                    = 0x4
 	XDP_UMEM_TX_SW_CSUM                         = 0x2
 	XDP_UMEM_UNALIGNED_CHUNK_FLAG               = 0x1
 	XDP_USE_NEED_WAKEUP                         = 0x8
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
index 684a5168..75207613 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
@@ -109,12 +109,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
+	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -153,9 +156,14 @@ const (
 	NFDBITS                          = 0x20
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
+	NS_GET_PID_FROM_PIDNS            = 0x8004b706
+	NS_GET_PID_IN_PIDNS              = 0x8004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
+	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -232,6 +240,20 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffff
+	PTP_CLOCK_GETCAPS                = 0x80503d01
+	PTP_CLOCK_GETCAPS2               = 0x80503d0a
+	PTP_ENABLE_PPS                   = 0x40043d04
+	PTP_ENABLE_PPS2                  = 0x40043d0d
+	PTP_EXTTS_REQUEST                = 0x40103d02
+	PTP_EXTTS_REQUEST2               = 0x40103d0b
+	PTP_MASK_CLEAR_ALL               = 0x3d13
+	PTP_MASK_EN_SINGLE               = 0x40043d14
+	PTP_PEROUT_REQUEST               = 0x40383d03
+	PTP_PEROUT_REQUEST2              = 0x40383d0c
+	PTP_PIN_SETFUNC                  = 0x40603d07
+	PTP_PIN_SETFUNC2                 = 0x40603d10
+	PTP_SYS_OFFSET                   = 0x43403d05
+	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GETFPXREGS                = 0x12
 	PTRACE_GET_THREAD_AREA           = 0x19
@@ -278,10 +300,13 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -316,6 +341,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
index 61d74b59..c68acda5 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
@@ -109,12 +109,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
+	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -153,9 +156,14 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
+	NS_GET_PID_FROM_PIDNS            = 0x8004b706
+	NS_GET_PID_IN_PIDNS              = 0x8004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
+	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -232,6 +240,20 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
+	PTP_CLOCK_GETCAPS                = 0x80503d01
+	PTP_CLOCK_GETCAPS2               = 0x80503d0a
+	PTP_ENABLE_PPS                   = 0x40043d04
+	PTP_ENABLE_PPS2                  = 0x40043d0d
+	PTP_EXTTS_REQUEST                = 0x40103d02
+	PTP_EXTTS_REQUEST2               = 0x40103d0b
+	PTP_MASK_CLEAR_ALL               = 0x3d13
+	PTP_MASK_EN_SINGLE               = 0x40043d14
+	PTP_PEROUT_REQUEST               = 0x40383d03
+	PTP_PEROUT_REQUEST2              = 0x40383d0c
+	PTP_PIN_SETFUNC                  = 0x40603d07
+	PTP_PIN_SETFUNC2                 = 0x40603d10
+	PTP_SYS_OFFSET                   = 0x43403d05
+	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_ARCH_PRCTL                = 0x1e
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GETFPXREGS                = 0x12
@@ -279,10 +301,13 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -317,6 +342,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
index a28c9e3e..a8c607ab 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
@@ -108,12 +108,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
+	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -150,9 +153,14 @@ const (
 	NFDBITS                          = 0x20
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
+	NS_GET_PID_FROM_PIDNS            = 0x8004b706
+	NS_GET_PID_IN_PIDNS              = 0x8004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
+	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -229,6 +237,20 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffff
+	PTP_CLOCK_GETCAPS                = 0x80503d01
+	PTP_CLOCK_GETCAPS2               = 0x80503d0a
+	PTP_ENABLE_PPS                   = 0x40043d04
+	PTP_ENABLE_PPS2                  = 0x40043d0d
+	PTP_EXTTS_REQUEST                = 0x40103d02
+	PTP_EXTTS_REQUEST2               = 0x40103d0b
+	PTP_MASK_CLEAR_ALL               = 0x3d13
+	PTP_MASK_EN_SINGLE               = 0x40043d14
+	PTP_PEROUT_REQUEST               = 0x40383d03
+	PTP_PEROUT_REQUEST2              = 0x40383d0c
+	PTP_PIN_SETFUNC                  = 0x40603d07
+	PTP_PIN_SETFUNC2                 = 0x40603d10
+	PTP_SYS_OFFSET                   = 0x43403d05
+	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_GETCRUNCHREGS             = 0x19
 	PTRACE_GETFDPIC                  = 0x1f
 	PTRACE_GETFDPIC_EXEC             = 0x0
@@ -284,10 +306,13 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -322,6 +347,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
index ab5d1fe8..18563dd8 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
@@ -109,15 +109,19 @@ const (
 	F_SETOWN                         = 0x8
 	F_UNLCK                          = 0x2
 	F_WRLCK                          = 0x1
+	GCS_MAGIC                        = 0x47435300
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
+	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -154,9 +158,14 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
+	NS_GET_PID_FROM_PIDNS            = 0x8004b706
+	NS_GET_PID_IN_PIDNS              = 0x8004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
+	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -200,6 +209,7 @@ const (
 	PERF_EVENT_IOC_SET_BPF           = 0x40042408
 	PERF_EVENT_IOC_SET_FILTER        = 0x40082406
 	PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
+	POE_MAGIC                        = 0x504f4530
 	PPPIOCATTACH                     = 0x4004743d
 	PPPIOCATTCHAN                    = 0x40047438
 	PPPIOCBRIDGECHAN                 = 0x40047435
@@ -235,6 +245,20 @@ const (
 	PROT_BTI                         = 0x10
 	PROT_MTE                         = 0x20
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
+	PTP_CLOCK_GETCAPS                = 0x80503d01
+	PTP_CLOCK_GETCAPS2               = 0x80503d0a
+	PTP_ENABLE_PPS                   = 0x40043d04
+	PTP_ENABLE_PPS2                  = 0x40043d0d
+	PTP_EXTTS_REQUEST                = 0x40103d02
+	PTP_EXTTS_REQUEST2               = 0x40103d0b
+	PTP_MASK_CLEAR_ALL               = 0x3d13
+	PTP_MASK_EN_SINGLE               = 0x40043d14
+	PTP_PEROUT_REQUEST               = 0x40383d03
+	PTP_PEROUT_REQUEST2              = 0x40383d0c
+	PTP_PIN_SETFUNC                  = 0x40603d07
+	PTP_PIN_SETFUNC2                 = 0x40603d10
+	PTP_SYS_OFFSET                   = 0x43403d05
+	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_PEEKMTETAGS               = 0x21
 	PTRACE_POKEMTETAGS               = 0x22
 	PTRACE_SYSEMU                    = 0x1f
@@ -275,10 +299,13 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -313,6 +340,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
index c523090e..22912cda 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
@@ -109,12 +109,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
+	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -154,9 +157,14 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
+	NS_GET_PID_FROM_PIDNS            = 0x8004b706
+	NS_GET_PID_IN_PIDNS              = 0x8004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
+	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -233,6 +241,20 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
+	PTP_CLOCK_GETCAPS                = 0x80503d01
+	PTP_CLOCK_GETCAPS2               = 0x80503d0a
+	PTP_ENABLE_PPS                   = 0x40043d04
+	PTP_ENABLE_PPS2                  = 0x40043d0d
+	PTP_EXTTS_REQUEST                = 0x40103d02
+	PTP_EXTTS_REQUEST2               = 0x40103d0b
+	PTP_MASK_CLEAR_ALL               = 0x3d13
+	PTP_MASK_EN_SINGLE               = 0x40043d14
+	PTP_PEROUT_REQUEST               = 0x40383d03
+	PTP_PEROUT_REQUEST2              = 0x40383d0c
+	PTP_PIN_SETFUNC                  = 0x40603d07
+	PTP_PIN_SETFUNC2                 = 0x40603d10
+	PTP_SYS_OFFSET                   = 0x43403d05
+	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_SYSEMU                    = 0x1f
 	PTRACE_SYSEMU_SINGLESTEP         = 0x20
 	RLIMIT_AS                        = 0x9
@@ -271,10 +293,13 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -309,6 +334,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
index 01e6ea78..29344eb3 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
@@ -108,12 +108,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
+	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x100
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x80
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xfffffff
+	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -150,9 +153,14 @@ const (
 	NFDBITS                          = 0x20
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
+	NS_GET_PID_FROM_PIDNS            = 0x4004b706
+	NS_GET_PID_IN_PIDNS              = 0x4004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
+	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -229,6 +237,20 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PR_SET_PTRACER_ANY               = 0xffffffff
+	PTP_CLOCK_GETCAPS                = 0x40503d01
+	PTP_CLOCK_GETCAPS2               = 0x40503d0a
+	PTP_ENABLE_PPS                   = 0x80043d04
+	PTP_ENABLE_PPS2                  = 0x80043d0d
+	PTP_EXTTS_REQUEST                = 0x80103d02
+	PTP_EXTTS_REQUEST2               = 0x80103d0b
+	PTP_MASK_CLEAR_ALL               = 0x20003d13
+	PTP_MASK_EN_SINGLE               = 0x80043d14
+	PTP_PEROUT_REQUEST               = 0x80383d03
+	PTP_PEROUT_REQUEST2              = 0x80383d0c
+	PTP_PIN_SETFUNC                  = 0x80603d07
+	PTP_PIN_SETFUNC2                 = 0x80603d10
+	PTP_SYS_OFFSET                   = 0x83403d05
+	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GET_THREAD_AREA           = 0x19
 	PTRACE_GET_THREAD_AREA_3264      = 0xc4
@@ -277,10 +299,13 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -315,6 +340,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x1029
 	SO_DONTROUTE                     = 0x10
 	SO_ERROR                         = 0x1007
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
index 7aa610b1..20d51fb9 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
@@ -108,12 +108,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
+	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x100
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x80
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xfffffff
+	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -150,9 +153,14 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
+	NS_GET_PID_FROM_PIDNS            = 0x4004b706
+	NS_GET_PID_IN_PIDNS              = 0x4004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
+	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -229,6 +237,20 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
+	PTP_CLOCK_GETCAPS                = 0x40503d01
+	PTP_CLOCK_GETCAPS2               = 0x40503d0a
+	PTP_ENABLE_PPS                   = 0x80043d04
+	PTP_ENABLE_PPS2                  = 0x80043d0d
+	PTP_EXTTS_REQUEST                = 0x80103d02
+	PTP_EXTTS_REQUEST2               = 0x80103d0b
+	PTP_MASK_CLEAR_ALL               = 0x20003d13
+	PTP_MASK_EN_SINGLE               = 0x80043d14
+	PTP_PEROUT_REQUEST               = 0x80383d03
+	PTP_PEROUT_REQUEST2              = 0x80383d0c
+	PTP_PIN_SETFUNC                  = 0x80603d07
+	PTP_PIN_SETFUNC2                 = 0x80603d10
+	PTP_SYS_OFFSET                   = 0x83403d05
+	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GET_THREAD_AREA           = 0x19
 	PTRACE_GET_THREAD_AREA_3264      = 0xc4
@@ -277,10 +299,13 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -315,6 +340,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x1029
 	SO_DONTROUTE                     = 0x10
 	SO_ERROR                         = 0x1007
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
index 92af771b..321b6090 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
@@ -108,12 +108,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
+	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x100
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x80
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -150,9 +153,14 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
+	NS_GET_PID_FROM_PIDNS            = 0x4004b706
+	NS_GET_PID_IN_PIDNS              = 0x4004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
+	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -229,6 +237,20 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
+	PTP_CLOCK_GETCAPS                = 0x40503d01
+	PTP_CLOCK_GETCAPS2               = 0x40503d0a
+	PTP_ENABLE_PPS                   = 0x80043d04
+	PTP_ENABLE_PPS2                  = 0x80043d0d
+	PTP_EXTTS_REQUEST                = 0x80103d02
+	PTP_EXTTS_REQUEST2               = 0x80103d0b
+	PTP_MASK_CLEAR_ALL               = 0x20003d13
+	PTP_MASK_EN_SINGLE               = 0x80043d14
+	PTP_PEROUT_REQUEST               = 0x80383d03
+	PTP_PEROUT_REQUEST2              = 0x80383d0c
+	PTP_PIN_SETFUNC                  = 0x80603d07
+	PTP_PIN_SETFUNC2                 = 0x80603d10
+	PTP_SYS_OFFSET                   = 0x83403d05
+	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GET_THREAD_AREA           = 0x19
 	PTRACE_GET_THREAD_AREA_3264      = 0xc4
@@ -277,10 +299,13 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -315,6 +340,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x1029
 	SO_DONTROUTE                     = 0x10
 	SO_ERROR                         = 0x1007
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
index b27ef5e6..9bacdf1e 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
@@ -108,12 +108,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
+	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x100
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x80
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -150,9 +153,14 @@ const (
 	NFDBITS                          = 0x20
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
+	NS_GET_PID_FROM_PIDNS            = 0x4004b706
+	NS_GET_PID_IN_PIDNS              = 0x4004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
+	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -229,6 +237,20 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PR_SET_PTRACER_ANY               = 0xffffffff
+	PTP_CLOCK_GETCAPS                = 0x40503d01
+	PTP_CLOCK_GETCAPS2               = 0x40503d0a
+	PTP_ENABLE_PPS                   = 0x80043d04
+	PTP_ENABLE_PPS2                  = 0x80043d0d
+	PTP_EXTTS_REQUEST                = 0x80103d02
+	PTP_EXTTS_REQUEST2               = 0x80103d0b
+	PTP_MASK_CLEAR_ALL               = 0x20003d13
+	PTP_MASK_EN_SINGLE               = 0x80043d14
+	PTP_PEROUT_REQUEST               = 0x80383d03
+	PTP_PEROUT_REQUEST2              = 0x80383d0c
+	PTP_PIN_SETFUNC                  = 0x80603d07
+	PTP_PIN_SETFUNC2                 = 0x80603d10
+	PTP_SYS_OFFSET                   = 0x83403d05
+	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GET_THREAD_AREA           = 0x19
 	PTRACE_GET_THREAD_AREA_3264      = 0xc4
@@ -277,10 +299,13 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -315,6 +340,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x1029
 	SO_DONTROUTE                     = 0x10
 	SO_ERROR                         = 0x1007
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
index 237a2cef..c2242726 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
@@ -108,12 +108,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
+	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x4000
 	ICANON                           = 0x100
 	IEXTEN                           = 0x400
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xfffffff
+	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x80
 	IUCLC                            = 0x1000
 	IXOFF                            = 0x400
@@ -152,9 +155,14 @@ const (
 	NL3                              = 0x300
 	NLDLY                            = 0x300
 	NOFLSH                           = 0x80000000
+	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
+	NS_GET_PID_FROM_PIDNS            = 0x4004b706
+	NS_GET_PID_IN_PIDNS              = 0x4004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
+	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x4
 	ONLCR                            = 0x2
@@ -232,6 +240,20 @@ const (
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PROT_SAO                         = 0x10
 	PR_SET_PTRACER_ANY               = 0xffffffff
+	PTP_CLOCK_GETCAPS                = 0x40503d01
+	PTP_CLOCK_GETCAPS2               = 0x40503d0a
+	PTP_ENABLE_PPS                   = 0x80043d04
+	PTP_ENABLE_PPS2                  = 0x80043d0d
+	PTP_EXTTS_REQUEST                = 0x80103d02
+	PTP_EXTTS_REQUEST2               = 0x80103d0b
+	PTP_MASK_CLEAR_ALL               = 0x20003d13
+	PTP_MASK_EN_SINGLE               = 0x80043d14
+	PTP_PEROUT_REQUEST               = 0x80383d03
+	PTP_PEROUT_REQUEST2              = 0x80383d0c
+	PTP_PIN_SETFUNC                  = 0x80603d07
+	PTP_PIN_SETFUNC2                 = 0x80603d10
+	PTP_SYS_OFFSET                   = 0x83403d05
+	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETEVRREGS                = 0x14
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GETREGS64                 = 0x16
@@ -332,10 +354,13 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -370,6 +395,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
index 4a5c555a..6270c8ee 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
@@ -108,12 +108,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
+	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x4000
 	ICANON                           = 0x100
 	IEXTEN                           = 0x400
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xfffffff
+	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x80
 	IUCLC                            = 0x1000
 	IXOFF                            = 0x400
@@ -152,9 +155,14 @@ const (
 	NL3                              = 0x300
 	NLDLY                            = 0x300
 	NOFLSH                           = 0x80000000
+	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
+	NS_GET_PID_FROM_PIDNS            = 0x4004b706
+	NS_GET_PID_IN_PIDNS              = 0x4004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
+	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x4
 	ONLCR                            = 0x2
@@ -232,6 +240,20 @@ const (
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PROT_SAO                         = 0x10
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
+	PTP_CLOCK_GETCAPS                = 0x40503d01
+	PTP_CLOCK_GETCAPS2               = 0x40503d0a
+	PTP_ENABLE_PPS                   = 0x80043d04
+	PTP_ENABLE_PPS2                  = 0x80043d0d
+	PTP_EXTTS_REQUEST                = 0x80103d02
+	PTP_EXTTS_REQUEST2               = 0x80103d0b
+	PTP_MASK_CLEAR_ALL               = 0x20003d13
+	PTP_MASK_EN_SINGLE               = 0x80043d14
+	PTP_PEROUT_REQUEST               = 0x80383d03
+	PTP_PEROUT_REQUEST2              = 0x80383d0c
+	PTP_PIN_SETFUNC                  = 0x80603d07
+	PTP_PIN_SETFUNC2                 = 0x80603d10
+	PTP_SYS_OFFSET                   = 0x83403d05
+	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETEVRREGS                = 0x14
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GETREGS64                 = 0x16
@@ -336,10 +358,13 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -374,6 +399,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
index a02fb49a..9966c194 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
@@ -108,12 +108,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
+	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x4000
 	ICANON                           = 0x100
 	IEXTEN                           = 0x400
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x80
 	IUCLC                            = 0x1000
 	IXOFF                            = 0x400
@@ -152,9 +155,14 @@ const (
 	NL3                              = 0x300
 	NLDLY                            = 0x300
 	NOFLSH                           = 0x80000000
+	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
+	NS_GET_PID_FROM_PIDNS            = 0x4004b706
+	NS_GET_PID_IN_PIDNS              = 0x4004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
+	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x4
 	ONLCR                            = 0x2
@@ -232,6 +240,20 @@ const (
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PROT_SAO                         = 0x10
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
+	PTP_CLOCK_GETCAPS                = 0x40503d01
+	PTP_CLOCK_GETCAPS2               = 0x40503d0a
+	PTP_ENABLE_PPS                   = 0x80043d04
+	PTP_ENABLE_PPS2                  = 0x80043d0d
+	PTP_EXTTS_REQUEST                = 0x80103d02
+	PTP_EXTTS_REQUEST2               = 0x80103d0b
+	PTP_MASK_CLEAR_ALL               = 0x20003d13
+	PTP_MASK_EN_SINGLE               = 0x80043d14
+	PTP_PEROUT_REQUEST               = 0x80383d03
+	PTP_PEROUT_REQUEST2              = 0x80383d0c
+	PTP_PIN_SETFUNC                  = 0x80603d07
+	PTP_PIN_SETFUNC2                 = 0x80603d10
+	PTP_SYS_OFFSET                   = 0x83403d05
+	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETEVRREGS                = 0x14
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GETREGS64                 = 0x16
@@ -336,10 +358,13 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -374,6 +399,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
index e26a7c61..848e5fcc 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
@@ -108,12 +108,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
+	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -150,9 +153,14 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
+	NS_GET_PID_FROM_PIDNS            = 0x8004b706
+	NS_GET_PID_IN_PIDNS              = 0x8004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
+	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -229,6 +237,20 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
+	PTP_CLOCK_GETCAPS                = 0x80503d01
+	PTP_CLOCK_GETCAPS2               = 0x80503d0a
+	PTP_ENABLE_PPS                   = 0x40043d04
+	PTP_ENABLE_PPS2                  = 0x40043d0d
+	PTP_EXTTS_REQUEST                = 0x40103d02
+	PTP_EXTTS_REQUEST2               = 0x40103d0b
+	PTP_MASK_CLEAR_ALL               = 0x3d13
+	PTP_MASK_EN_SINGLE               = 0x40043d14
+	PTP_PEROUT_REQUEST               = 0x40383d03
+	PTP_PEROUT_REQUEST2              = 0x40383d0c
+	PTP_PIN_SETFUNC                  = 0x40603d07
+	PTP_PIN_SETFUNC2                 = 0x40603d10
+	PTP_SYS_OFFSET                   = 0x43403d05
+	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_GETFDPIC                  = 0x21
 	PTRACE_GETFDPIC_EXEC             = 0x0
 	PTRACE_GETFDPIC_INTERP           = 0x1
@@ -268,10 +290,13 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -306,6 +331,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
index c48f7c21..669b2adb 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
@@ -108,12 +108,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
+	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xfffffff
+	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -150,9 +153,14 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
+	NS_GET_PID_FROM_PIDNS            = 0x8004b706
+	NS_GET_PID_IN_PIDNS              = 0x8004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
+	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -229,6 +237,20 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
+	PTP_CLOCK_GETCAPS                = 0x80503d01
+	PTP_CLOCK_GETCAPS2               = 0x80503d0a
+	PTP_ENABLE_PPS                   = 0x40043d04
+	PTP_ENABLE_PPS2                  = 0x40043d0d
+	PTP_EXTTS_REQUEST                = 0x40103d02
+	PTP_EXTTS_REQUEST2               = 0x40103d0b
+	PTP_MASK_CLEAR_ALL               = 0x3d13
+	PTP_MASK_EN_SINGLE               = 0x40043d14
+	PTP_PEROUT_REQUEST               = 0x40383d03
+	PTP_PEROUT_REQUEST2              = 0x40383d0c
+	PTP_PIN_SETFUNC                  = 0x40603d07
+	PTP_PIN_SETFUNC2                 = 0x40603d10
+	PTP_SYS_OFFSET                   = 0x43403d05
+	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_DISABLE_TE                = 0x5010
 	PTRACE_ENABLE_TE                 = 0x5009
 	PTRACE_GET_LAST_BREAK            = 0x5006
@@ -340,10 +362,13 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -378,6 +403,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
index ad4b9aac..4834e575 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
@@ -112,12 +112,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
+	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x400000
 	IN_NONBLOCK                      = 0x4000
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xfffffff
+	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -155,9 +158,14 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
+	NS_GET_PID_FROM_PIDNS            = 0x4004b706
+	NS_GET_PID_IN_PIDNS              = 0x4004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
+	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -234,6 +242,20 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
+	PTP_CLOCK_GETCAPS                = 0x40503d01
+	PTP_CLOCK_GETCAPS2               = 0x40503d0a
+	PTP_ENABLE_PPS                   = 0x80043d04
+	PTP_ENABLE_PPS2                  = 0x80043d0d
+	PTP_EXTTS_REQUEST                = 0x80103d02
+	PTP_EXTTS_REQUEST2               = 0x80103d0b
+	PTP_MASK_CLEAR_ALL               = 0x20003d13
+	PTP_MASK_EN_SINGLE               = 0x80043d14
+	PTP_PEROUT_REQUEST               = 0x80383d03
+	PTP_PEROUT_REQUEST2              = 0x80383d0c
+	PTP_PIN_SETFUNC                  = 0x80603d07
+	PTP_PIN_SETFUNC2                 = 0x80603d10
+	PTP_SYS_OFFSET                   = 0x83403d05
+	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETFPAREGS                = 0x14
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GETFPREGS64               = 0x19
@@ -331,10 +353,13 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
+	SCM_DEVMEM_DMABUF                = 0x58
+	SCM_DEVMEM_LINEAR                = 0x57
 	SCM_TIMESTAMPING                 = 0x23
 	SCM_TIMESTAMPING_OPT_STATS       = 0x38
 	SCM_TIMESTAMPING_PKTINFO         = 0x3c
 	SCM_TIMESTAMPNS                  = 0x21
+	SCM_TS_OPT_ID                    = 0x5a
 	SCM_TXTIME                       = 0x3f
 	SCM_WIFI_STATUS                  = 0x25
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -417,6 +442,9 @@ const (
 	SO_CNX_ADVICE                    = 0x37
 	SO_COOKIE                        = 0x3b
 	SO_DETACH_REUSEPORT_BPF          = 0x47
+	SO_DEVMEM_DMABUF                 = 0x58
+	SO_DEVMEM_DONTNEED               = 0x59
+	SO_DEVMEM_LINEAR                 = 0x57
 	SO_DOMAIN                        = 0x1029
 	SO_DONTROUTE                     = 0x10
 	SO_ERROR                         = 0x1007
diff --git a/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
index da08b2ab..1ec2b140 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
@@ -581,6 +581,8 @@ const (
 	AT_EMPTY_PATH                   = 0x1000
 	AT_REMOVEDIR                    = 0x200
 	RENAME_NOREPLACE                = 1 << 0
+	ST_RDONLY                       = 1
+	ST_NOSUID                       = 2
 )
 
 const (
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
index b622533e..24b346e1 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
@@ -841,6 +841,26 @@ var libc_pthread_fchdir_np_trampoline_addr uintptr
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) {
+	var _p0 unsafe.Pointer
+	if len(iov) > 0 {
+		_p0 = unsafe.Pointer(&iov[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	_, _, e1 := syscall_syscall9(libc_connectx_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(endpoints)), uintptr(associd), uintptr(flags), uintptr(_p0), uintptr(len(iov)), uintptr(unsafe.Pointer(n)), uintptr(unsafe.Pointer(connid)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+var libc_connectx_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_connectx connectx "/usr/lib/libSystem.B.dylib"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
 	_, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags))
 	if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s
index cfe6646b..ebd21310 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s
+++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s
@@ -248,6 +248,11 @@ TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0
 GLOBL	·libc_pthread_fchdir_np_trampoline_addr(SB), RODATA, $8
 DATA	·libc_pthread_fchdir_np_trampoline_addr(SB)/8, $libc_pthread_fchdir_np_trampoline<>(SB)
 
+TEXT libc_connectx_trampoline<>(SB),NOSPLIT,$0-0
+	JMP	libc_connectx(SB)
+GLOBL	·libc_connectx_trampoline_addr(SB), RODATA, $8
+DATA	·libc_connectx_trampoline_addr(SB)/8, $libc_connectx_trampoline<>(SB)
+
 TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_sendfile(SB)
 GLOBL	·libc_sendfile_trampoline_addr(SB), RODATA, $8
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
index 13f624f6..824b9c2d 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
@@ -841,6 +841,26 @@ var libc_pthread_fchdir_np_trampoline_addr uintptr
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) {
+	var _p0 unsafe.Pointer
+	if len(iov) > 0 {
+		_p0 = unsafe.Pointer(&iov[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	_, _, e1 := syscall_syscall9(libc_connectx_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(endpoints)), uintptr(associd), uintptr(flags), uintptr(_p0), uintptr(len(iov)), uintptr(unsafe.Pointer(n)), uintptr(unsafe.Pointer(connid)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+var libc_connectx_trampoline_addr uintptr
+
+//go:cgo_import_dynamic libc_connectx connectx "/usr/lib/libSystem.B.dylib"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
 	_, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags))
 	if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s
index fe222b75..4f178a22 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s
+++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s
@@ -248,6 +248,11 @@ TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0
 GLOBL	·libc_pthread_fchdir_np_trampoline_addr(SB), RODATA, $8
 DATA	·libc_pthread_fchdir_np_trampoline_addr(SB)/8, $libc_pthread_fchdir_np_trampoline<>(SB)
 
+TEXT libc_connectx_trampoline<>(SB),NOSPLIT,$0-0
+	JMP	libc_connectx(SB)
+GLOBL	·libc_connectx_trampoline_addr(SB), RODATA, $8
+DATA	·libc_connectx_trampoline_addr(SB)/8, $libc_connectx_trampoline<>(SB)
+
 TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_sendfile(SB)
 GLOBL	·libc_sendfile_trampoline_addr(SB), RODATA, $8
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux.go b/vendor/golang.org/x/sys/unix/zsyscall_linux.go
index 1bc1a5ad..5cc1e8eb 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_linux.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_linux.go
@@ -592,6 +592,16 @@ func ClockGettime(clockid int32, time *Timespec) (err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func ClockSettime(clockid int32, time *Timespec) (err error) {
+	_, _, e1 := Syscall(SYS_CLOCK_SETTIME, uintptr(clockid), uintptr(unsafe.Pointer(time)), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error) {
 	_, _, e1 := Syscall6(SYS_CLOCK_NANOSLEEP, uintptr(clockid), uintptr(flags), uintptr(unsafe.Pointer(request)), uintptr(unsafe.Pointer(remain)), 0, 0)
 	if e1 != 0 {
@@ -971,23 +981,6 @@ func Getpriority(which int, who int) (prio int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func Getrandom(buf []byte, flags int) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(buf) > 0 {
-		_p0 = unsafe.Pointer(&buf[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(SYS_GETRANDOM, uintptr(_p0), uintptr(len(buf)), uintptr(flags))
-	n = int(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
 func Getrusage(who int, rusage *Rusage) (err error) {
 	_, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
 	if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
index 829b87fe..c6545413 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
@@ -141,6 +141,16 @@ import (
 //go:cgo_import_dynamic libc_getpeername getpeername "libsocket.so"
 //go:cgo_import_dynamic libc_setsockopt setsockopt "libsocket.so"
 //go:cgo_import_dynamic libc_recvfrom recvfrom "libsocket.so"
+//go:cgo_import_dynamic libc_getpeerucred getpeerucred "libc.so"
+//go:cgo_import_dynamic libc_ucred_get ucred_get "libc.so"
+//go:cgo_import_dynamic libc_ucred_geteuid ucred_geteuid "libc.so"
+//go:cgo_import_dynamic libc_ucred_getegid ucred_getegid "libc.so"
+//go:cgo_import_dynamic libc_ucred_getruid ucred_getruid "libc.so"
+//go:cgo_import_dynamic libc_ucred_getrgid ucred_getrgid "libc.so"
+//go:cgo_import_dynamic libc_ucred_getsuid ucred_getsuid "libc.so"
+//go:cgo_import_dynamic libc_ucred_getsgid ucred_getsgid "libc.so"
+//go:cgo_import_dynamic libc_ucred_getpid ucred_getpid "libc.so"
+//go:cgo_import_dynamic libc_ucred_free ucred_free "libc.so"
 //go:cgo_import_dynamic libc_port_create port_create "libc.so"
 //go:cgo_import_dynamic libc_port_associate port_associate "libc.so"
 //go:cgo_import_dynamic libc_port_dissociate port_dissociate "libc.so"
@@ -280,6 +290,16 @@ import (
 //go:linkname procgetpeername libc_getpeername
 //go:linkname procsetsockopt libc_setsockopt
 //go:linkname procrecvfrom libc_recvfrom
+//go:linkname procgetpeerucred libc_getpeerucred
+//go:linkname procucred_get libc_ucred_get
+//go:linkname procucred_geteuid libc_ucred_geteuid
+//go:linkname procucred_getegid libc_ucred_getegid
+//go:linkname procucred_getruid libc_ucred_getruid
+//go:linkname procucred_getrgid libc_ucred_getrgid
+//go:linkname procucred_getsuid libc_ucred_getsuid
+//go:linkname procucred_getsgid libc_ucred_getsgid
+//go:linkname procucred_getpid libc_ucred_getpid
+//go:linkname procucred_free libc_ucred_free
 //go:linkname procport_create libc_port_create
 //go:linkname procport_associate libc_port_associate
 //go:linkname procport_dissociate libc_port_dissociate
@@ -420,6 +440,16 @@ var (
 	procgetpeername,
 	procsetsockopt,
 	procrecvfrom,
+	procgetpeerucred,
+	procucred_get,
+	procucred_geteuid,
+	procucred_getegid,
+	procucred_getruid,
+	procucred_getrgid,
+	procucred_getsuid,
+	procucred_getsgid,
+	procucred_getpid,
+	procucred_free,
 	procport_create,
 	procport_associate,
 	procport_dissociate,
@@ -2029,6 +2059,90 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func getpeerucred(fd uintptr, ucred *uintptr) (err error) {
+	_, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procgetpeerucred)), 2, uintptr(fd), uintptr(unsafe.Pointer(ucred)), 0, 0, 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredGet(pid int) (ucred uintptr, err error) {
+	r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procucred_get)), 1, uintptr(pid), 0, 0, 0, 0, 0)
+	ucred = uintptr(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredGeteuid(ucred uintptr) (uid int) {
+	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_geteuid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
+	uid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredGetegid(ucred uintptr) (gid int) {
+	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getegid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
+	gid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredGetruid(ucred uintptr) (uid int) {
+	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getruid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
+	uid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredGetrgid(ucred uintptr) (gid int) {
+	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getrgid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
+	gid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredGetsuid(ucred uintptr) (uid int) {
+	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getsuid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
+	uid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredGetsgid(ucred uintptr) (gid int) {
+	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getsgid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
+	gid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredGetpid(ucred uintptr) (pid int) {
+	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getpid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
+	pid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredFree(ucred uintptr) {
+	sysvicall6(uintptr(unsafe.Pointer(&procucred_free)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func port_create() (n int, err error) {
 	r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procport_create)), 0, 0, 0, 0, 0, 0, 0)
 	n = int(r0)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
index 524b0820..c79aaff3 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
@@ -458,4 +458,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR            = 460
 	SYS_LSM_LIST_MODULES             = 461
 	SYS_MSEAL                        = 462
+	SYS_SETXATTRAT                   = 463
+	SYS_GETXATTRAT                   = 464
+	SYS_LISTXATTRAT                  = 465
+	SYS_REMOVEXATTRAT                = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
index d3e38f68..5eb45069 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
@@ -341,6 +341,7 @@ const (
 	SYS_STATX                   = 332
 	SYS_IO_PGETEVENTS           = 333
 	SYS_RSEQ                    = 334
+	SYS_URETPROBE               = 335
 	SYS_PIDFD_SEND_SIGNAL       = 424
 	SYS_IO_URING_SETUP          = 425
 	SYS_IO_URING_ENTER          = 426
@@ -380,4 +381,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
+	SYS_SETXATTRAT              = 463
+	SYS_GETXATTRAT              = 464
+	SYS_LISTXATTRAT             = 465
+	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
index 70b35bf3..05e50297 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
@@ -422,4 +422,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR            = 460
 	SYS_LSM_LIST_MODULES             = 461
 	SYS_MSEAL                        = 462
+	SYS_SETXATTRAT                   = 463
+	SYS_GETXATTRAT                   = 464
+	SYS_LISTXATTRAT                  = 465
+	SYS_REMOVEXATTRAT                = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
index 6c778c23..38c53ec5 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
@@ -85,7 +85,7 @@ const (
 	SYS_SPLICE                  = 76
 	SYS_TEE                     = 77
 	SYS_READLINKAT              = 78
-	SYS_FSTATAT                 = 79
+	SYS_NEWFSTATAT              = 79
 	SYS_FSTAT                   = 80
 	SYS_SYNC                    = 81
 	SYS_FSYNC                   = 82
@@ -325,4 +325,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
+	SYS_SETXATTRAT              = 463
+	SYS_GETXATTRAT              = 464
+	SYS_LISTXATTRAT             = 465
+	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go
index 37281cf5..31d2e71a 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go
@@ -84,6 +84,8 @@ const (
 	SYS_SPLICE                  = 76
 	SYS_TEE                     = 77
 	SYS_READLINKAT              = 78
+	SYS_NEWFSTATAT              = 79
+	SYS_FSTAT                   = 80
 	SYS_SYNC                    = 81
 	SYS_FSYNC                   = 82
 	SYS_FDATASYNC               = 83
@@ -319,4 +321,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
+	SYS_SETXATTRAT              = 463
+	SYS_GETXATTRAT              = 464
+	SYS_LISTXATTRAT             = 465
+	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
index 7e567f1e..f4184a33 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
@@ -442,4 +442,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR            = 4460
 	SYS_LSM_LIST_MODULES             = 4461
 	SYS_MSEAL                        = 4462
+	SYS_SETXATTRAT                   = 4463
+	SYS_GETXATTRAT                   = 4464
+	SYS_LISTXATTRAT                  = 4465
+	SYS_REMOVEXATTRAT                = 4466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
index 38ae55e5..05b99622 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
@@ -372,4 +372,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 5460
 	SYS_LSM_LIST_MODULES        = 5461
 	SYS_MSEAL                   = 5462
+	SYS_SETXATTRAT              = 5463
+	SYS_GETXATTRAT              = 5464
+	SYS_LISTXATTRAT             = 5465
+	SYS_REMOVEXATTRAT           = 5466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
index 55e92e60..43a256e9 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
@@ -372,4 +372,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 5460
 	SYS_LSM_LIST_MODULES        = 5461
 	SYS_MSEAL                   = 5462
+	SYS_SETXATTRAT              = 5463
+	SYS_GETXATTRAT              = 5464
+	SYS_LISTXATTRAT             = 5465
+	SYS_REMOVEXATTRAT           = 5466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
index 60658d6a..eea5ddfc 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
@@ -442,4 +442,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR            = 4460
 	SYS_LSM_LIST_MODULES             = 4461
 	SYS_MSEAL                        = 4462
+	SYS_SETXATTRAT                   = 4463
+	SYS_GETXATTRAT                   = 4464
+	SYS_LISTXATTRAT                  = 4465
+	SYS_REMOVEXATTRAT                = 4466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
index e203e8a7..0d777bfb 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
@@ -449,4 +449,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR            = 460
 	SYS_LSM_LIST_MODULES             = 461
 	SYS_MSEAL                        = 462
+	SYS_SETXATTRAT                   = 463
+	SYS_GETXATTRAT                   = 464
+	SYS_LISTXATTRAT                  = 465
+	SYS_REMOVEXATTRAT                = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
index 5944b97d..b4463650 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
@@ -421,4 +421,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
+	SYS_SETXATTRAT              = 463
+	SYS_GETXATTRAT              = 464
+	SYS_LISTXATTRAT             = 465
+	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
index c66d416d..0c7d21c1 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
@@ -421,4 +421,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
+	SYS_SETXATTRAT              = 463
+	SYS_GETXATTRAT              = 464
+	SYS_LISTXATTRAT             = 465
+	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
index 9889f6a5..84053916 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
@@ -84,7 +84,7 @@ const (
 	SYS_SPLICE                  = 76
 	SYS_TEE                     = 77
 	SYS_READLINKAT              = 78
-	SYS_FSTATAT                 = 79
+	SYS_NEWFSTATAT              = 79
 	SYS_FSTAT                   = 80
 	SYS_SYNC                    = 81
 	SYS_FSYNC                   = 82
@@ -326,4 +326,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
+	SYS_SETXATTRAT              = 463
+	SYS_GETXATTRAT              = 464
+	SYS_LISTXATTRAT             = 465
+	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
index 01d86825..fcf1b790 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
@@ -387,4 +387,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
+	SYS_SETXATTRAT              = 463
+	SYS_GETXATTRAT              = 464
+	SYS_LISTXATTRAT             = 465
+	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
index 7b703e77..52d15b5f 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
@@ -400,4 +400,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
+	SYS_SETXATTRAT              = 463
+	SYS_GETXATTRAT              = 464
+	SYS_LISTXATTRAT             = 465
+	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
index 091d107f..17c53bd9 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
@@ -306,6 +306,19 @@ type XVSockPgen struct {
 
 type _Socklen uint32
 
+type SaeAssocID uint32
+
+type SaeConnID uint32
+
+type SaEndpoints struct {
+	Srcif      uint32
+	Srcaddr    *RawSockaddr
+	Srcaddrlen uint32
+	Dstaddr    *RawSockaddr
+	Dstaddrlen uint32
+	_          [4]byte
+}
+
 type Xucred struct {
 	Version uint32
 	Uid     uint32
@@ -449,11 +462,14 @@ type FdSet struct {
 
 const (
 	SizeofIfMsghdr    = 0x70
+	SizeofIfMsghdr2   = 0xa0
 	SizeofIfData      = 0x60
+	SizeofIfData64    = 0x80
 	SizeofIfaMsghdr   = 0x14
 	SizeofIfmaMsghdr  = 0x10
 	SizeofIfmaMsghdr2 = 0x14
 	SizeofRtMsghdr    = 0x5c
+	SizeofRtMsghdr2   = 0x5c
 	SizeofRtMetrics   = 0x38
 )
 
@@ -467,6 +483,20 @@ type IfMsghdr struct {
 	Data    IfData
 }
 
+type IfMsghdr2 struct {
+	Msglen     uint16
+	Version    uint8
+	Type       uint8
+	Addrs      int32
+	Flags      int32
+	Index      uint16
+	Snd_len    int32
+	Snd_maxlen int32
+	Snd_drops  int32
+	Timer      int32
+	Data       IfData64
+}
+
 type IfData struct {
 	Type       uint8
 	Typelen    uint8
@@ -499,6 +529,34 @@ type IfData struct {
 	Reserved2  uint32
 }
 
+type IfData64 struct {
+	Type       uint8
+	Typelen    uint8
+	Physical   uint8
+	Addrlen    uint8
+	Hdrlen     uint8
+	Recvquota  uint8
+	Xmitquota  uint8
+	Unused1    uint8
+	Mtu        uint32
+	Metric     uint32
+	Baudrate   uint64
+	Ipackets   uint64
+	Ierrors    uint64
+	Opackets   uint64
+	Oerrors    uint64
+	Collisions uint64
+	Ibytes     uint64
+	Obytes     uint64
+	Imcasts    uint64
+	Omcasts    uint64
+	Iqdrops    uint64
+	Noproto    uint64
+	Recvtiming uint32
+	Xmittiming uint32
+	Lastchange Timeval32
+}
+
 type IfaMsghdr struct {
 	Msglen  uint16
 	Version uint8
@@ -544,6 +602,21 @@ type RtMsghdr struct {
 	Rmx     RtMetrics
 }
 
+type RtMsghdr2 struct {
+	Msglen      uint16
+	Version     uint8
+	Type        uint8
+	Index       uint16
+	Flags       int32
+	Addrs       int32
+	Refcnt      int32
+	Parentflags int32
+	Reserved    int32
+	Use         int32
+	Inits       uint32
+	Rmx         RtMetrics
+}
+
 type RtMetrics struct {
 	Locks    uint32
 	Mtu      uint32
diff --git a/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
index 28ff4ef7..2392226a 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
@@ -306,6 +306,19 @@ type XVSockPgen struct {
 
 type _Socklen uint32
 
+type SaeAssocID uint32
+
+type SaeConnID uint32
+
+type SaEndpoints struct {
+	Srcif      uint32
+	Srcaddr    *RawSockaddr
+	Srcaddrlen uint32
+	Dstaddr    *RawSockaddr
+	Dstaddrlen uint32
+	_          [4]byte
+}
+
 type Xucred struct {
 	Version uint32
 	Uid     uint32
@@ -449,11 +462,14 @@ type FdSet struct {
 
 const (
 	SizeofIfMsghdr    = 0x70
+	SizeofIfMsghdr2   = 0xa0
 	SizeofIfData      = 0x60
+	SizeofIfData64    = 0x80
 	SizeofIfaMsghdr   = 0x14
 	SizeofIfmaMsghdr  = 0x10
 	SizeofIfmaMsghdr2 = 0x14
 	SizeofRtMsghdr    = 0x5c
+	SizeofRtMsghdr2   = 0x5c
 	SizeofRtMetrics   = 0x38
 )
 
@@ -467,6 +483,20 @@ type IfMsghdr struct {
 	Data    IfData
 }
 
+type IfMsghdr2 struct {
+	Msglen     uint16
+	Version    uint8
+	Type       uint8
+	Addrs      int32
+	Flags      int32
+	Index      uint16
+	Snd_len    int32
+	Snd_maxlen int32
+	Snd_drops  int32
+	Timer      int32
+	Data       IfData64
+}
+
 type IfData struct {
 	Type       uint8
 	Typelen    uint8
@@ -499,6 +529,34 @@ type IfData struct {
 	Reserved2  uint32
 }
 
+type IfData64 struct {
+	Type       uint8
+	Typelen    uint8
+	Physical   uint8
+	Addrlen    uint8
+	Hdrlen     uint8
+	Recvquota  uint8
+	Xmitquota  uint8
+	Unused1    uint8
+	Mtu        uint32
+	Metric     uint32
+	Baudrate   uint64
+	Ipackets   uint64
+	Ierrors    uint64
+	Opackets   uint64
+	Oerrors    uint64
+	Collisions uint64
+	Ibytes     uint64
+	Obytes     uint64
+	Imcasts    uint64
+	Omcasts    uint64
+	Iqdrops    uint64
+	Noproto    uint64
+	Recvtiming uint32
+	Xmittiming uint32
+	Lastchange Timeval32
+}
+
 type IfaMsghdr struct {
 	Msglen  uint16
 	Version uint8
@@ -544,6 +602,21 @@ type RtMsghdr struct {
 	Rmx     RtMetrics
 }
 
+type RtMsghdr2 struct {
+	Msglen      uint16
+	Version     uint8
+	Type        uint8
+	Index       uint16
+	Flags       int32
+	Addrs       int32
+	Refcnt      int32
+	Parentflags int32
+	Reserved    int32
+	Use         int32
+	Inits       uint32
+	Rmx         RtMetrics
+}
+
 type RtMetrics struct {
 	Locks    uint32
 	Mtu      uint32
diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
index 6cbd094a..51e13eb0 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
@@ -625,6 +625,7 @@ const (
 	POLLRDNORM   = 0x40
 	POLLWRBAND   = 0x100
 	POLLWRNORM   = 0x4
+	POLLRDHUP    = 0x4000
 )
 
 type CapRights struct {
diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
index 7c03b6ee..d002d8ef 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
@@ -630,6 +630,7 @@ const (
 	POLLRDNORM   = 0x40
 	POLLWRBAND   = 0x100
 	POLLWRNORM   = 0x4
+	POLLRDHUP    = 0x4000
 )
 
 type CapRights struct {
diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
index 422107ee..3f863d89 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
@@ -616,6 +616,7 @@ const (
 	POLLRDNORM   = 0x40
 	POLLWRBAND   = 0x100
 	POLLWRNORM   = 0x4
+	POLLRDHUP    = 0x4000
 )
 
 type CapRights struct {
diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
index 505a12ac..61c72931 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
@@ -610,6 +610,7 @@ const (
 	POLLRDNORM   = 0x40
 	POLLWRBAND   = 0x100
 	POLLWRNORM   = 0x4
+	POLLRDHUP    = 0x4000
 )
 
 type CapRights struct {
diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go
index cc986c79..b5d17414 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go
@@ -612,6 +612,7 @@ const (
 	POLLRDNORM   = 0x40
 	POLLWRBAND   = 0x100
 	POLLWRNORM   = 0x4
+	POLLRDHUP    = 0x4000
 )
 
 type CapRights struct {
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux.go b/vendor/golang.org/x/sys/unix/ztypes_linux.go
index b102b95a..a46abe64 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux.go
@@ -87,31 +87,35 @@ type StatxTimestamp struct {
 }
 
 type Statx_t struct {
-	Mask             uint32
-	Blksize          uint32
-	Attributes       uint64
-	Nlink            uint32
-	Uid              uint32
-	Gid              uint32
-	Mode             uint16
-	_                [1]uint16
-	Ino              uint64
-	Size             uint64
-	Blocks           uint64
-	Attributes_mask  uint64
-	Atime            StatxTimestamp
-	Btime            StatxTimestamp
-	Ctime            StatxTimestamp
-	Mtime            StatxTimestamp
-	Rdev_major       uint32
-	Rdev_minor       uint32
-	Dev_major        uint32
-	Dev_minor        uint32
-	Mnt_id           uint64
-	Dio_mem_align    uint32
-	Dio_offset_align uint32
-	Subvol           uint64
-	_                [11]uint64
+	Mask                      uint32
+	Blksize                   uint32
+	Attributes                uint64
+	Nlink                     uint32
+	Uid                       uint32
+	Gid                       uint32
+	Mode                      uint16
+	_                         [1]uint16
+	Ino                       uint64
+	Size                      uint64
+	Blocks                    uint64
+	Attributes_mask           uint64
+	Atime                     StatxTimestamp
+	Btime                     StatxTimestamp
+	Ctime                     StatxTimestamp
+	Mtime                     StatxTimestamp
+	Rdev_major                uint32
+	Rdev_minor                uint32
+	Dev_major                 uint32
+	Dev_minor                 uint32
+	Mnt_id                    uint64
+	Dio_mem_align             uint32
+	Dio_offset_align          uint32
+	Subvol                    uint64
+	Atomic_write_unit_min     uint32
+	Atomic_write_unit_max     uint32
+	Atomic_write_segments_max uint32
+	_                         [1]uint32
+	_                         [9]uint64
 }
 
 type Fsid struct {
@@ -516,6 +520,29 @@ type TCPInfo struct {
 	Total_rto_time       uint32
 }
 
+type TCPVegasInfo struct {
+	Enabled uint32
+	Rttcnt  uint32
+	Rtt     uint32
+	Minrtt  uint32
+}
+
+type TCPDCTCPInfo struct {
+	Enabled  uint16
+	Ce_state uint16
+	Alpha    uint32
+	Ab_ecn   uint32
+	Ab_tot   uint32
+}
+
+type TCPBBRInfo struct {
+	Bw_lo       uint32
+	Bw_hi       uint32
+	Min_rtt     uint32
+	Pacing_gain uint32
+	Cwnd_gain   uint32
+}
+
 type CanFilter struct {
 	Id   uint32
 	Mask uint32
@@ -557,6 +584,7 @@ const (
 	SizeofICMPv6Filter      = 0x20
 	SizeofUcred             = 0xc
 	SizeofTCPInfo           = 0xf8
+	SizeofTCPCCInfo         = 0x14
 	SizeofCanFilter         = 0x8
 	SizeofTCPRepairOpt      = 0x8
 )
@@ -1724,12 +1752,6 @@ const (
 	IFLA_IPVLAN_UNSPEC                         = 0x0
 	IFLA_IPVLAN_MODE                           = 0x1
 	IFLA_IPVLAN_FLAGS                          = 0x2
-	NETKIT_NEXT                                = -0x1
-	NETKIT_PASS                                = 0x0
-	NETKIT_DROP                                = 0x2
-	NETKIT_REDIRECT                            = 0x7
-	NETKIT_L2                                  = 0x0
-	NETKIT_L3                                  = 0x1
 	IFLA_NETKIT_UNSPEC                         = 0x0
 	IFLA_NETKIT_PEER_INFO                      = 0x1
 	IFLA_NETKIT_PRIMARY                        = 0x2
@@ -1768,6 +1790,7 @@ const (
 	IFLA_VXLAN_DF                              = 0x1d
 	IFLA_VXLAN_VNIFILTER                       = 0x1e
 	IFLA_VXLAN_LOCALBYPASS                     = 0x1f
+	IFLA_VXLAN_LABEL_POLICY                    = 0x20
 	IFLA_GENEVE_UNSPEC                         = 0x0
 	IFLA_GENEVE_ID                             = 0x1
 	IFLA_GENEVE_REMOTE                         = 0x2
@@ -1797,6 +1820,8 @@ const (
 	IFLA_GTP_ROLE                              = 0x4
 	IFLA_GTP_CREATE_SOCKETS                    = 0x5
 	IFLA_GTP_RESTART_COUNT                     = 0x6
+	IFLA_GTP_LOCAL                             = 0x7
+	IFLA_GTP_LOCAL6                            = 0x8
 	IFLA_BOND_UNSPEC                           = 0x0
 	IFLA_BOND_MODE                             = 0x1
 	IFLA_BOND_ACTIVE_SLAVE                     = 0x2
@@ -1829,6 +1854,7 @@ const (
 	IFLA_BOND_AD_LACP_ACTIVE                   = 0x1d
 	IFLA_BOND_MISSED_MAX                       = 0x1e
 	IFLA_BOND_NS_IP6_TARGET                    = 0x1f
+	IFLA_BOND_COUPLED_CONTROL                  = 0x20
 	IFLA_BOND_AD_INFO_UNSPEC                   = 0x0
 	IFLA_BOND_AD_INFO_AGGREGATOR               = 0x1
 	IFLA_BOND_AD_INFO_NUM_PORTS                = 0x2
@@ -1897,6 +1923,7 @@ const (
 	IFLA_HSR_SEQ_NR                            = 0x5
 	IFLA_HSR_VERSION                           = 0x6
 	IFLA_HSR_PROTOCOL                          = 0x7
+	IFLA_HSR_INTERLINK                         = 0x8
 	IFLA_STATS_UNSPEC                          = 0x0
 	IFLA_STATS_LINK_64                         = 0x1
 	IFLA_STATS_LINK_XSTATS                     = 0x2
@@ -1949,6 +1976,15 @@ const (
 	IFLA_DSA_MASTER                            = 0x1
 )
 
+const (
+	NETKIT_NEXT     = -0x1
+	NETKIT_PASS     = 0x0
+	NETKIT_DROP     = 0x2
+	NETKIT_REDIRECT = 0x7
+	NETKIT_L2       = 0x0
+	NETKIT_L3       = 0x1
+)
+
 const (
 	NF_INET_PRE_ROUTING  = 0x0
 	NF_INET_LOCAL_IN     = 0x1
@@ -2486,7 +2522,7 @@ type XDPMmapOffsets struct {
 type XDPUmemReg struct {
 	Addr            uint64
 	Len             uint64
-	Chunk_size      uint32
+	Size            uint32
 	Headroom        uint32
 	Flags           uint32
 	Tx_metadata_len uint32
@@ -2558,8 +2594,8 @@ const (
 	SOF_TIMESTAMPING_BIND_PHC     = 0x8000
 	SOF_TIMESTAMPING_OPT_ID_TCP   = 0x10000
 
-	SOF_TIMESTAMPING_LAST = 0x10000
-	SOF_TIMESTAMPING_MASK = 0x1ffff
+	SOF_TIMESTAMPING_LAST = 0x20000
+	SOF_TIMESTAMPING_MASK = 0x3ffff
 
 	SCM_TSTAMP_SND   = 0x0
 	SCM_TSTAMP_SCHED = 0x1
@@ -3505,7 +3541,7 @@ type Nhmsg struct {
 type NexthopGrp struct {
 	Id     uint32
 	Weight uint8
-	Resvd1 uint8
+	High   uint8
 	Resvd2 uint16
 }
 
@@ -3766,7 +3802,7 @@ const (
 	ETHTOOL_MSG_PSE_GET                       = 0x24
 	ETHTOOL_MSG_PSE_SET                       = 0x25
 	ETHTOOL_MSG_RSS_GET                       = 0x26
-	ETHTOOL_MSG_USER_MAX                      = 0x2b
+	ETHTOOL_MSG_USER_MAX                      = 0x2d
 	ETHTOOL_MSG_KERNEL_NONE                   = 0x0
 	ETHTOOL_MSG_STRSET_GET_REPLY              = 0x1
 	ETHTOOL_MSG_LINKINFO_GET_REPLY            = 0x2
@@ -3806,12 +3842,15 @@ const (
 	ETHTOOL_MSG_MODULE_NTF                    = 0x24
 	ETHTOOL_MSG_PSE_GET_REPLY                 = 0x25
 	ETHTOOL_MSG_RSS_GET_REPLY                 = 0x26
-	ETHTOOL_MSG_KERNEL_MAX                    = 0x2b
+	ETHTOOL_MSG_KERNEL_MAX                    = 0x2e
+	ETHTOOL_FLAG_COMPACT_BITSETS              = 0x1
+	ETHTOOL_FLAG_OMIT_REPLY                   = 0x2
+	ETHTOOL_FLAG_STATS                        = 0x4
 	ETHTOOL_A_HEADER_UNSPEC                   = 0x0
 	ETHTOOL_A_HEADER_DEV_INDEX                = 0x1
 	ETHTOOL_A_HEADER_DEV_NAME                 = 0x2
 	ETHTOOL_A_HEADER_FLAGS                    = 0x3
-	ETHTOOL_A_HEADER_MAX                      = 0x3
+	ETHTOOL_A_HEADER_MAX                      = 0x4
 	ETHTOOL_A_BITSET_BIT_UNSPEC               = 0x0
 	ETHTOOL_A_BITSET_BIT_INDEX                = 0x1
 	ETHTOOL_A_BITSET_BIT_NAME                 = 0x2
@@ -3948,7 +3987,7 @@ const (
 	ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL   = 0x17
 	ETHTOOL_A_COALESCE_USE_CQE_MODE_TX        = 0x18
 	ETHTOOL_A_COALESCE_USE_CQE_MODE_RX        = 0x19
-	ETHTOOL_A_COALESCE_MAX                    = 0x1c
+	ETHTOOL_A_COALESCE_MAX                    = 0x1e
 	ETHTOOL_A_PAUSE_UNSPEC                    = 0x0
 	ETHTOOL_A_PAUSE_HEADER                    = 0x1
 	ETHTOOL_A_PAUSE_AUTONEG                   = 0x2
@@ -3992,11 +4031,11 @@ const (
 	ETHTOOL_A_CABLE_RESULT_UNSPEC             = 0x0
 	ETHTOOL_A_CABLE_RESULT_PAIR               = 0x1
 	ETHTOOL_A_CABLE_RESULT_CODE               = 0x2
-	ETHTOOL_A_CABLE_RESULT_MAX                = 0x2
+	ETHTOOL_A_CABLE_RESULT_MAX                = 0x3
 	ETHTOOL_A_CABLE_FAULT_LENGTH_UNSPEC       = 0x0
 	ETHTOOL_A_CABLE_FAULT_LENGTH_PAIR         = 0x1
 	ETHTOOL_A_CABLE_FAULT_LENGTH_CM           = 0x2
-	ETHTOOL_A_CABLE_FAULT_LENGTH_MAX          = 0x2
+	ETHTOOL_A_CABLE_FAULT_LENGTH_MAX          = 0x3
 	ETHTOOL_A_CABLE_TEST_NTF_STATUS_UNSPEC    = 0x0
 	ETHTOOL_A_CABLE_TEST_NTF_STATUS_STARTED   = 0x1
 	ETHTOOL_A_CABLE_TEST_NTF_STATUS_COMPLETED = 0x2
@@ -4079,6 +4118,107 @@ type EthtoolDrvinfo struct {
 	Regdump_len  uint32
 }
 
+type EthtoolTsInfo struct {
+	Cmd             uint32
+	So_timestamping uint32
+	Phc_index       int32
+	Tx_types        uint32
+	Tx_reserved     [3]uint32
+	Rx_filters      uint32
+	Rx_reserved     [3]uint32
+}
+
+type HwTstampConfig struct {
+	Flags     int32
+	Tx_type   int32
+	Rx_filter int32
+}
+
+const (
+	HWTSTAMP_FILTER_NONE            = 0x0
+	HWTSTAMP_FILTER_ALL             = 0x1
+	HWTSTAMP_FILTER_SOME            = 0x2
+	HWTSTAMP_FILTER_PTP_V1_L4_EVENT = 0x3
+	HWTSTAMP_FILTER_PTP_V2_L4_EVENT = 0x6
+	HWTSTAMP_FILTER_PTP_V2_L2_EVENT = 0x9
+	HWTSTAMP_FILTER_PTP_V2_EVENT    = 0xc
+)
+
+const (
+	HWTSTAMP_TX_OFF          = 0x0
+	HWTSTAMP_TX_ON           = 0x1
+	HWTSTAMP_TX_ONESTEP_SYNC = 0x2
+)
+
+type (
+	PtpClockCaps struct {
+		Max_adj            int32
+		N_alarm            int32
+		N_ext_ts           int32
+		N_per_out          int32
+		Pps                int32
+		N_pins             int32
+		Cross_timestamping int32
+		Adjust_phase       int32
+		Max_phase_adj      int32
+		Rsv                [11]int32
+	}
+	PtpClockTime struct {
+		Sec      int64
+		Nsec     uint32
+		Reserved uint32
+	}
+	PtpExttsEvent struct {
+		T     PtpClockTime
+		Index uint32
+		Flags uint32
+		Rsv   [2]uint32
+	}
+	PtpExttsRequest struct {
+		Index uint32
+		Flags uint32
+		Rsv   [2]uint32
+	}
+	PtpPeroutRequest struct {
+		StartOrPhase PtpClockTime
+		Period       PtpClockTime
+		Index        uint32
+		Flags        uint32
+		On           PtpClockTime
+	}
+	PtpPinDesc struct {
+		Name  [64]byte
+		Index uint32
+		Func  uint32
+		Chan  uint32
+		Rsv   [5]uint32
+	}
+	PtpSysOffset struct {
+		Samples uint32
+		Rsv     [3]uint32
+		Ts      [51]PtpClockTime
+	}
+	PtpSysOffsetExtended struct {
+		Samples uint32
+		Clockid int32
+		Rsv     [2]uint32
+		Ts      [25][3]PtpClockTime
+	}
+	PtpSysOffsetPrecise struct {
+		Device   PtpClockTime
+		Realtime PtpClockTime
+		Monoraw  PtpClockTime
+		Rsv      [4]uint32
+	}
+)
+
+const (
+	PTP_PF_NONE    = 0x0
+	PTP_PF_EXTTS   = 0x1
+	PTP_PF_PEROUT  = 0x2
+	PTP_PF_PHYSYNC = 0x3
+)
+
 type (
 	HIDRawReportDescriptor struct {
 		Size  uint32
@@ -4260,6 +4400,7 @@ const (
 type LandlockRulesetAttr struct {
 	Access_fs  uint64
 	Access_net uint64
+	Scoped     uint64
 }
 
 type LandlockPathBeneathAttr struct {
@@ -4606,7 +4747,7 @@ const (
 	NL80211_ATTR_MAC_HINT                                   = 0xc8
 	NL80211_ATTR_MAC_MASK                                   = 0xd7
 	NL80211_ATTR_MAX_AP_ASSOC_STA                           = 0xca
-	NL80211_ATTR_MAX                                        = 0x14a
+	NL80211_ATTR_MAX                                        = 0x14d
 	NL80211_ATTR_MAX_CRIT_PROT_DURATION                     = 0xb4
 	NL80211_ATTR_MAX_CSA_COUNTERS                           = 0xce
 	NL80211_ATTR_MAX_MATCH_SETS                             = 0x85
@@ -5210,7 +5351,7 @@ const (
 	NL80211_FREQUENCY_ATTR_GO_CONCURRENT                    = 0xf
 	NL80211_FREQUENCY_ATTR_INDOOR_ONLY                      = 0xe
 	NL80211_FREQUENCY_ATTR_IR_CONCURRENT                    = 0xf
-	NL80211_FREQUENCY_ATTR_MAX                              = 0x20
+	NL80211_FREQUENCY_ATTR_MAX                              = 0x21
 	NL80211_FREQUENCY_ATTR_MAX_TX_POWER                     = 0x6
 	NL80211_FREQUENCY_ATTR_NO_10MHZ                         = 0x11
 	NL80211_FREQUENCY_ATTR_NO_160MHZ                        = 0xc
@@ -5378,7 +5519,7 @@ const (
 	NL80211_MNTR_FLAG_CONTROL                               = 0x3
 	NL80211_MNTR_FLAG_COOK_FRAMES                           = 0x5
 	NL80211_MNTR_FLAG_FCSFAIL                               = 0x1
-	NL80211_MNTR_FLAG_MAX                                   = 0x6
+	NL80211_MNTR_FLAG_MAX                                   = 0x7
 	NL80211_MNTR_FLAG_OTHER_BSS                             = 0x4
 	NL80211_MNTR_FLAG_PLCPFAIL                              = 0x2
 	NL80211_MPATH_FLAG_ACTIVE                               = 0x1
@@ -6033,3 +6174,5 @@ type SockDiagReq struct {
 	Family   uint8
 	Protocol uint8
 }
+
+const RTM_NEWNVLAN = 0x70
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
index 15adc041..ad05b51a 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
@@ -727,6 +727,37 @@ const (
 	RISCV_HWPROBE_EXT_ZBA                = 0x8
 	RISCV_HWPROBE_EXT_ZBB                = 0x10
 	RISCV_HWPROBE_EXT_ZBS                = 0x20
+	RISCV_HWPROBE_EXT_ZICBOZ             = 0x40
+	RISCV_HWPROBE_EXT_ZBC                = 0x80
+	RISCV_HWPROBE_EXT_ZBKB               = 0x100
+	RISCV_HWPROBE_EXT_ZBKC               = 0x200
+	RISCV_HWPROBE_EXT_ZBKX               = 0x400
+	RISCV_HWPROBE_EXT_ZKND               = 0x800
+	RISCV_HWPROBE_EXT_ZKNE               = 0x1000
+	RISCV_HWPROBE_EXT_ZKNH               = 0x2000
+	RISCV_HWPROBE_EXT_ZKSED              = 0x4000
+	RISCV_HWPROBE_EXT_ZKSH               = 0x8000
+	RISCV_HWPROBE_EXT_ZKT                = 0x10000
+	RISCV_HWPROBE_EXT_ZVBB               = 0x20000
+	RISCV_HWPROBE_EXT_ZVBC               = 0x40000
+	RISCV_HWPROBE_EXT_ZVKB               = 0x80000
+	RISCV_HWPROBE_EXT_ZVKG               = 0x100000
+	RISCV_HWPROBE_EXT_ZVKNED             = 0x200000
+	RISCV_HWPROBE_EXT_ZVKNHA             = 0x400000
+	RISCV_HWPROBE_EXT_ZVKNHB             = 0x800000
+	RISCV_HWPROBE_EXT_ZVKSED             = 0x1000000
+	RISCV_HWPROBE_EXT_ZVKSH              = 0x2000000
+	RISCV_HWPROBE_EXT_ZVKT               = 0x4000000
+	RISCV_HWPROBE_EXT_ZFH                = 0x8000000
+	RISCV_HWPROBE_EXT_ZFHMIN             = 0x10000000
+	RISCV_HWPROBE_EXT_ZIHINTNTL          = 0x20000000
+	RISCV_HWPROBE_EXT_ZVFH               = 0x40000000
+	RISCV_HWPROBE_EXT_ZVFHMIN            = 0x80000000
+	RISCV_HWPROBE_EXT_ZFA                = 0x100000000
+	RISCV_HWPROBE_EXT_ZTSO               = 0x200000000
+	RISCV_HWPROBE_EXT_ZACAS              = 0x400000000
+	RISCV_HWPROBE_EXT_ZICOND             = 0x800000000
+	RISCV_HWPROBE_EXT_ZIHINTPAUSE        = 0x1000000000
 	RISCV_HWPROBE_KEY_CPUPERF_0          = 0x5
 	RISCV_HWPROBE_MISALIGNED_UNKNOWN     = 0x0
 	RISCV_HWPROBE_MISALIGNED_EMULATED    = 0x1
@@ -734,4 +765,6 @@ const (
 	RISCV_HWPROBE_MISALIGNED_FAST        = 0x3
 	RISCV_HWPROBE_MISALIGNED_UNSUPPORTED = 0x4
 	RISCV_HWPROBE_MISALIGNED_MASK        = 0x7
+	RISCV_HWPROBE_KEY_ZICBOZ_BLOCK_SIZE  = 0x6
+	RISCV_HWPROBE_WHICH_CPUS             = 0x1
 )
diff --git a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
index d9a13af4..2e5d5a44 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
@@ -377,6 +377,12 @@ type Flock_t struct {
 	Pid    int32
 }
 
+type F_cnvrt struct {
+	Cvtcmd int32
+	Pccsid int16
+	Fccsid int16
+}
+
 type Termios struct {
 	Cflag uint32
 	Iflag uint32
diff --git a/vendor/modules.txt b/vendor/modules.txt
index ec17340e..b5929859 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -47,7 +47,7 @@ github.com/goccy/go-json/internal/encoder/vm_color_indent
 github.com/goccy/go-json/internal/encoder/vm_indent
 github.com/goccy/go-json/internal/errors
 github.com/goccy/go-json/internal/runtime
-# github.com/golang/snappy v0.0.4
+# github.com/golang/snappy v1.0.0
 ## explicit
 github.com/golang/snappy
 # github.com/google/uuid v1.3.0
@@ -62,11 +62,12 @@ github.com/huandu/go-clone/generic
 # github.com/json-iterator/go v1.1.12
 ## explicit; go 1.12
 github.com/json-iterator/go
-# github.com/klauspost/compress v1.13.6
-## explicit; go 1.15
+# github.com/klauspost/compress v1.16.7
+## explicit; go 1.18
 github.com/klauspost/compress
 github.com/klauspost/compress/fse
 github.com/klauspost/compress/huff0
+github.com/klauspost/compress/internal/cpuinfo
 github.com/klauspost/compress/internal/snapref
 github.com/klauspost/compress/zstd
 github.com/klauspost/compress/zstd/internal/xxhash
@@ -201,7 +202,13 @@ go.mongodb.org/mongo-driver/x/mongo/driver/operation
 go.mongodb.org/mongo-driver/x/mongo/driver/session
 go.mongodb.org/mongo-driver/x/mongo/driver/topology
 go.mongodb.org/mongo-driver/x/mongo/driver/wiremessage
-# golang.org/x/crypto v0.26.0
+# go.mongodb.org/mongo-driver/v2 v2.2.3
+## explicit; go 1.18
+go.mongodb.org/mongo-driver/v2/bson
+go.mongodb.org/mongo-driver/v2/internal/bsoncoreutil
+go.mongodb.org/mongo-driver/v2/internal/decimal128
+go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore
+# golang.org/x/crypto v0.33.0
 ## explicit; go 1.20
 golang.org/x/crypto/ocsp
 golang.org/x/crypto/pbkdf2
@@ -219,16 +226,16 @@ golang.org/x/net/http2
 golang.org/x/net/http2/h2c
 golang.org/x/net/http2/hpack
 golang.org/x/net/idna
-# golang.org/x/sync v0.8.0
+# golang.org/x/sync v0.11.0
 ## explicit; go 1.18
 golang.org/x/sync/errgroup
 golang.org/x/sync/semaphore
 golang.org/x/sync/singleflight
-# golang.org/x/sys v0.23.0
+# golang.org/x/sys v0.30.0
 ## explicit; go 1.18
 golang.org/x/sys/cpu
 golang.org/x/sys/unix
-# golang.org/x/text v0.17.0
+# golang.org/x/text v0.22.0
 ## explicit; go 1.18
 golang.org/x/text/cases
 golang.org/x/text/internal

From 2d6ca57c966d0d6d64c56fad20a0ed41c68e2e15 Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Wed, 13 Aug 2025 13:09:34 -0400
Subject: [PATCH 06/32] add error check

---
 dockey/agg_test.go | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/dockey/agg_test.go b/dockey/agg_test.go
index a95385fc..d5051b47 100644
--- a/dockey/agg_test.go
+++ b/dockey/agg_test.go
@@ -95,7 +95,12 @@ func TestExtractDocKeyAgg(t *testing.T) {
 	}
 
 	db := client.Database(t.Name())
-	defer db.Drop(ctx)
+	defer func() {
+		err := db.Drop(ctx)
+		if err != nil {
+			t.Logf("WARNING: Failed to drop DB %#q: %v", db.Name(), err)
+		}
+	}()
 
 	coll := db.Collection("Stuff")
 	require.NoError(client.Database("admin").RunCommand(

From b137e998d3165e847a282893bb9866685d045b04 Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Wed, 13 Aug 2025 13:17:55 -0400
Subject: [PATCH 07/32] precreate

---
 dockey/agg_test.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/dockey/agg_test.go b/dockey/agg_test.go
index d5051b47..10c7d037 100644
--- a/dockey/agg_test.go
+++ b/dockey/agg_test.go
@@ -103,6 +103,10 @@ func TestExtractDocKeyAgg(t *testing.T) {
 	}()
 
 	coll := db.Collection("Stuff")
+
+	// For sharded, pre-v8 clusters we need to create the collection first.
+	require.NoError(db.CreateCollection(ctx, coll.Name()))
+
 	require.NoError(client.Database("admin").RunCommand(
 		ctx,
 		bson.D{

From 1f255622dde1eea815e81687538c552fd8815dcb Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Wed, 13 Aug 2025 13:25:55 -0400
Subject: [PATCH 08/32] try older versions

---
 dockey/agg.go                |  7 +++++--
 internal/verifier/compare.go | 22 ++++++++++++----------
 2 files changed, 17 insertions(+), 12 deletions(-)

diff --git a/dockey/agg.go b/dockey/agg.go
index dc62fe8e..96155a80 100644
--- a/dockey/agg.go
+++ b/dockey/agg.go
@@ -56,19 +56,22 @@ func mapObjectKeysAgg(expr any, mapping map[string]string) bson.D {
 				{"input", bson.D{
 					{"$objectToArray", expr},
 				}},
+				{"as", "pair"},
 				{"in", bson.D{
 					{"$let", bson.D{
 						{"vars", bson.D{
 							{"keyLookup", mapping},
+							{"numericKey", "$$pair.k"},
+							{"value", "$$pair.v"},
 						}},
 						{"in", bson.D{
 							{"k", bson.D{
 								{"$getField", bson.D{
-									{"field", "$$this.k"},
+									{"field", "$$numericKey"},
 									{"input", "$$keyLookup"},
 								}},
 							}},
-							{"v", "$$this.v"},
+							{"v", "$$value"},
 						}},
 					}},
 				}},
diff --git a/internal/verifier/compare.go b/internal/verifier/compare.go
index 81081e6f..16016f72 100644
--- a/internal/verifier/compare.go
+++ b/internal/verifier/compare.go
@@ -16,7 +16,6 @@ import (
 	"github.com/10gen/migration-verifier/internal/util"
 	"github.com/10gen/migration-verifier/option"
 	"github.com/pkg/errors"
-	"github.com/samber/lo"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
@@ -660,15 +659,18 @@ func (verifier *Verifier) getDocumentsCursor(ctx mongo.SessionContext, collectio
 	// Suppress this log for recheck tasks because the list of IDs can be
 	// quite long.
 	if !task.IsRecheck() {
-		extJSON, _ := bson.MarshalExtJSON(cmd, true, false)
-
-		verifier.logger.Debug().
-			Any("task", task.PrimaryKey).
-			Str("cmd", lo.Ternary(
-				extJSON == nil,
-				fmt.Sprintf("%s", cmd),
-				string(extJSON),
-			)).
+
+		evt := verifier.logger.Debug().
+			Any("task", task.PrimaryKey)
+
+		extJSON, err := bson.MarshalExtJSON(cmd, true, false)
+		if err != nil {
+			evt = evt.Str("cmd", fmt.Sprintf("%s", cmd))
+		} else {
+			evt = evt.RawJSON("cmd", extJSON)
+		}
+
+		evt.
 			Str("options", fmt.Sprintf("%v", *runCommandOptions)).
 			Msg("getDocuments command.")
 	}

From fc6b8c6a916fa3ff10ead643dec373d8f2863f78 Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Wed, 13 Aug 2025 13:47:08 -0400
Subject: [PATCH 09/32] back-compat

---
 dockey/agg.go | 38 ++++++++++++++++++++++++++++----------
 1 file changed, 28 insertions(+), 10 deletions(-)

diff --git a/dockey/agg.go b/dockey/agg.go
index 96155a80..52d692f2 100644
--- a/dockey/agg.go
+++ b/dockey/agg.go
@@ -3,9 +3,12 @@
 package dockey
 
 import (
+	"maps"
+	"slices"
 	"strconv"
 	"strings"
 
+	"github.com/samber/lo"
 	"go.mongodb.org/mongo-driver/bson"
 )
 
@@ -50,27 +53,42 @@ func ExtractDocKeyAgg(fieldNames []string, docExpr any) bson.D {
 
 // Potentially reusable:
 func mapObjectKeysAgg(expr any, mapping map[string]string) bson.D {
+	// We would ideally pass mapping into the aggregation and $getField
+	// to get the mapped key, but pre-v8 server versions required $getField’s
+	// field parameter to be a constant. So we use a $switch instead.
+	mapAgg := bson.D{
+		{"$switch", bson.D{
+			{"branches", lo.Map(
+				slices.Collect(maps.Keys(mapping)),
+				func(key string, _ int) bson.D {
+					return bson.D{
+						{"case", bson.D{
+							{"$eq", bson.A{
+								key,
+								"$$numericKey",
+							}},
+						}},
+						{"then", mapping[key]},
+					}
+				},
+			)},
+		}},
+	}
+
 	return bson.D{
 		{"$arrayToObject", bson.D{
 			{"$map", bson.D{
 				{"input", bson.D{
 					{"$objectToArray", expr},
 				}},
-				{"as", "pair"},
 				{"in", bson.D{
 					{"$let", bson.D{
 						{"vars", bson.D{
-							{"keyLookup", mapping},
-							{"numericKey", "$$pair.k"},
-							{"value", "$$pair.v"},
+							{"numericKey", "$$this.k"},
+							{"value", "$$this.v"},
 						}},
 						{"in", bson.D{
-							{"k", bson.D{
-								{"$getField", bson.D{
-									{"field", "$$numericKey"},
-									{"input", "$$keyLookup"},
-								}},
-							}},
+							{"k", mapAgg},
 							{"v", "$$value"},
 						}},
 					}},

From c3121d4f2e31c33f2d5abd8d27c3a6e47b67f78f Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Wed, 13 Aug 2025 14:09:16 -0400
Subject: [PATCH 10/32] maybe fix 5

---
 dockey/agg.go      | 45 ++++++++++++++++++++++++++++++++-------------
 dockey/agg_test.go |  4 ++++
 2 files changed, 36 insertions(+), 13 deletions(-)

diff --git a/dockey/agg.go b/dockey/agg.go
index 52d692f2..09a54dde 100644
--- a/dockey/agg.go
+++ b/dockey/agg.go
@@ -55,7 +55,8 @@ func ExtractDocKeyAgg(fieldNames []string, docExpr any) bson.D {
 func mapObjectKeysAgg(expr any, mapping map[string]string) bson.D {
 	// We would ideally pass mapping into the aggregation and $getField
 	// to get the mapped key, but pre-v8 server versions required $getField’s
-	// field parameter to be a constant. So we use a $switch instead.
+	// field parameter to be a constant. (And pre-v5 didn’t have $getField
+	// at all.) So we use a $switch instead.
 	mapAgg := bson.D{
 		{"$switch", bson.D{
 			{"branches", lo.Map(
@@ -98,26 +99,44 @@ func mapObjectKeysAgg(expr any, mapping map[string]string) bson.D {
 	}
 }
 
+func getFieldPolyfillAgg(docExpr, fieldExpr any) bson.D {
+	return bson.D{
+		{"$arrayElemAt", bson.A{
+			bson.D{
+				{"$map", bson.D{
+					{"input", bson.D{
+						{"$filter", bson.D{
+							{"input", bson.D{
+								{"$objectToArray", docExpr},
+							}},
+							{"as", "pair"},
+							{"cond", bson.D{
+								{"$eq", bson.A{
+									"$$pair.k",
+									fieldExpr,
+								}},
+							}},
+						}},
+					}},
+					{"as", "pair"},
+					{"in", "$$pair.v"},
+				}},
+			},
+			0,
+		}},
+	}
+}
+
 func extractKeyValueAgg(fieldName string, baseDocExpr any) any {
 	base, remainder, hasDot := strings.Cut(fieldName, ".")
 
-	fieldExpr := bson.D{
-		{"$getField", bson.D{
-			{"field", fieldName},
-			{"input", baseDocExpr},
-		}},
-	}
+	fieldExpr := getFieldPolyfillAgg(baseDocExpr, fieldName)
 
 	if !hasDot {
 		return fieldExpr
 	}
 
-	embDocExpr := bson.D{
-		{"$getField", bson.D{
-			{"field", base},
-			{"input", baseDocExpr},
-		}},
-	}
+	embDocExpr := getFieldPolyfillAgg(baseDocExpr, base)
 
 	return bson.D{
 		{"$cond", bson.D{
diff --git a/dockey/agg_test.go b/dockey/agg_test.go
index 10c7d037..f8b2b1d9 100644
--- a/dockey/agg_test.go
+++ b/dockey/agg_test.go
@@ -106,6 +106,10 @@ func TestExtractDocKeyAgg(t *testing.T) {
 
 	// For sharded, pre-v8 clusters we need to create the collection first.
 	require.NoError(db.CreateCollection(ctx, coll.Name()))
+	require.NoError(client.Database("admin").RunCommand(
+		ctx,
+		bson.D{{"enableSharding", db.Name()}},
+	).Err())
 
 	require.NoError(client.Database("admin").RunCommand(
 		ctx,

From 32563c9cb0a561908322be6bab8c2a13f32c85fd Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Wed, 13 Aug 2025 14:26:24 -0400
Subject: [PATCH 11/32] avoid pre-v6 wonkiness

---
 dockey/agg_test.go | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/dockey/agg_test.go b/dockey/agg_test.go
index f8b2b1d9..2c93e47a 100644
--- a/dockey/agg_test.go
+++ b/dockey/agg_test.go
@@ -94,6 +94,12 @@ func TestExtractDocKeyAgg(t *testing.T) {
 		t.Skip("Skipping against unsharded cluster.")
 	}
 
+	// Pre-v6 clusters’ `documentKey` in the change stream is unreliable.
+	// See SERVER-61892.
+	if clusterInfo.VersionArray[0] < 6 {
+		t.Skip("Skipping against pre-v6 cluster.")
+	}
+
 	db := client.Database(t.Name())
 	defer func() {
 		err := db.Drop(ctx)

From 8b6d91b4880928ab89b9821707a53fff4dd27ec6 Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Wed, 13 Aug 2025 14:42:22 -0400
Subject: [PATCH 12/32] comment

---
 dockey/agg.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/dockey/agg.go b/dockey/agg.go
index 09a54dde..2ba6cd20 100644
--- a/dockey/agg.go
+++ b/dockey/agg.go
@@ -99,6 +99,9 @@ func mapObjectKeysAgg(expr any, mapping map[string]string) bson.D {
 	}
 }
 
+// Potentially reusable: a polyfill for $getField. This is useful even with
+// server versions that have $getField because that operator required a
+// constant for the field reference prior to v8.
 func getFieldPolyfillAgg(docExpr, fieldExpr any) bson.D {
 	return bson.D{
 		{"$arrayElemAt", bson.A{

From 5460ac843f06d8ee65de2cef94f4c52cbe4f9a04 Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Wed, 13 Aug 2025 15:58:14 -0400
Subject: [PATCH 13/32] =?UTF-8?q?rename=20DB=20=E2=80=A6=20=3F=3F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 dockey/agg_test.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/dockey/agg_test.go b/dockey/agg_test.go
index 2c93e47a..6082140e 100644
--- a/dockey/agg_test.go
+++ b/dockey/agg_test.go
@@ -105,10 +105,12 @@ func TestExtractDocKeyAgg(t *testing.T) {
 		err := db.Drop(ctx)
 		if err != nil {
 			t.Logf("WARNING: Failed to drop DB %#q: %v", db.Name(), err)
+		} else {
+			t.Logf("Dropped DB %#q", db.Name())
 		}
 	}()
 
-	coll := db.Collection("Stuff")
+	coll := db.Collection("stuff")
 
 	// For sharded, pre-v8 clusters we need to create the collection first.
 	require.NoError(db.CreateCollection(ctx, coll.Name()))

From e23adabc7659dc416252b3d29608f440fb36a63e Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Thu, 14 Aug 2025 12:36:38 -0400
Subject: [PATCH 14/32] move test

---
 dockey/agg.go                                              | 1 +
 dockey/agg_test.go => internal/verifier/dockey_agg_test.go | 5 +++--
 2 files changed, 4 insertions(+), 2 deletions(-)
 rename dockey/agg_test.go => internal/verifier/dockey_agg_test.go (97%)

diff --git a/dockey/agg.go b/dockey/agg.go
index 2ba6cd20..e8f57484 100644
--- a/dockey/agg.go
+++ b/dockey/agg.go
@@ -1,4 +1,5 @@
 // Package dockey contains logic related to document key determination.
+// Its tests use a cluster and thus are stored in internal/verifier.
 
 package dockey
 
diff --git a/dockey/agg_test.go b/internal/verifier/dockey_agg_test.go
similarity index 97%
rename from dockey/agg_test.go
rename to internal/verifier/dockey_agg_test.go
index 6082140e..3d675b0f 100644
--- a/dockey/agg_test.go
+++ b/internal/verifier/dockey_agg_test.go
@@ -1,9 +1,10 @@
-package dockey
+package verifier
 
 import (
 	"os"
 	"testing"
 
+	"github.com/10gen/migration-verifier/dockey"
 	"github.com/10gen/migration-verifier/internal/logger"
 	"github.com/10gen/migration-verifier/internal/util"
 	"github.com/10gen/migration-verifier/mslices"
@@ -130,7 +131,7 @@ func TestExtractDocKeyAgg(t *testing.T) {
 	).Err(),
 	)
 
-	computedDocKeyAgg := ExtractDocKeyAgg(
+	computedDocKeyAgg := dockey.ExtractDocKeyAgg(
 		mslices.Of("foo.bar.baz", "_id"),
 		"$$ROOT.fullDocument",
 	)

From c9b78f5a14288304d9eb6e693f4bc50dbbf1ac08 Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Thu, 14 Aug 2025 13:58:54 -0400
Subject: [PATCH 15/32] more

---
 internal/verifier/migration_verifier_test.go | 118 +++++++++++++++++++
 1 file changed, 118 insertions(+)

diff --git a/internal/verifier/migration_verifier_test.go b/internal/verifier/migration_verifier_test.go
index 7eadb93e..b9ffd686 100644
--- a/internal/verifier/migration_verifier_test.go
+++ b/internal/verifier/migration_verifier_test.go
@@ -99,6 +99,124 @@ func (suite *IntegrationTestSuite) TestProcessVerifyTask_Failure() {
 	assert.ErrorContains(t, err, expectedIDHex)
 }
 
+func (suite *IntegrationTestSuite) TestVerifier_Dotted_Shard_Key() {
+	ctx := suite.T().Context()
+	require := require.New(suite.T())
+
+	for _, client := range mslices.Of(suite.srcMongoClient, suite.dstMongoClient) {
+		if suite.GetTopology(client) != util.TopologySharded {
+			suite.T().Skip("sharded clusters required")
+		}
+	}
+
+	dbName := suite.DBNameForTest()
+	collName := "coll"
+
+	verifier := suite.BuildVerifier()
+	srcColl := verifier.srcClient.Database(dbName).Collection(collName)
+	dstColl := verifier.dstClient.Database(dbName).Collection(collName)
+
+	docs := []bson.D{
+		// NB: It’s not possible to test with /foo.bar.baz or /foo/bar.baz
+		// because the server (as of v8) will route those to the same shard.
+		// Only /foo/bar/baz actually gets routed as per the shard key, so
+		// only that value can create a duplicate ID.
+		{{"_id", 33}, {"foo", bson.D{{"bar", bson.D{{"baz", 100}}}}}},
+		{{"_id", 33}, {"foo", bson.D{{"bar", bson.D{{"baz", 200}}}}}},
+	}
+
+	for _, coll := range mslices.Of(srcColl, dstColl) {
+		db := coll.Database()
+		client := db.Client()
+
+		// For sharded, pre-v8 clusters we need to create the collection first.
+		require.NoError(db.CreateCollection(ctx, coll.Name()))
+		require.NoError(client.Database("admin").RunCommand(
+			ctx,
+			bson.D{{"enableSharding", db.Name()}},
+		).Err())
+
+		require.NoError(client.Database("admin").RunCommand(
+			ctx,
+			bson.D{
+				{"shardCollection", db.Name() + "." + coll.Name()},
+				{"key", bson.D{
+					{"foo.bar.baz", 1},
+				}},
+			},
+		).Err(),
+		)
+
+		shardIds := getShardIds(suite.T(), client)
+
+		admin := client.Database("admin")
+		splitKey := bson.D{{"foo.bar.baz", 150}}
+		require.NoError(
+			admin.RunCommand(ctx, bson.D{
+				{"moveRange", db.Name() + "." + coll.Name()},
+				{"toShard", shardIds[0]},
+				{"max", splitKey},
+			}).Err(),
+		)
+
+		require.NoError(
+			admin.RunCommand(ctx, bson.D{
+				{"moveRange", db.Name() + "." + coll.Name()},
+				{"toShard", shardIds[1]},
+				{"min", splitKey},
+			}).Err(),
+		)
+
+		fmt.Printf("inserting: %v\n\n", docs)
+
+		//fmt.Printf("-------- apused\n")
+		//time.Sleep(15 * time.Second)
+
+		_, err := coll.InsertMany(ctx, lo.ToAnySlice(lo.Shuffle(docs)))
+		require.NoError(err, "should insert all docs")
+	}
+
+	task := &VerificationTask{
+		PrimaryKey: primitive.NewObjectID(),
+		QueryFilter: QueryFilter{
+			Namespace: dbName + "." + collName,
+			To:        dbName + "." + collName,
+			Partition: &partitions.Partition{
+				Key: partitions.PartitionKey{
+					Lower: primitive.MinKey{},
+				},
+				Upper: primitive.MaxKey{},
+			},
+		},
+	}
+
+	results, docCount, _, err := verifier.FetchAndCompareDocuments(ctx, 0, task)
+	require.NoError(err, "should fetch & compare")
+	assert.EqualValues(suite.T(), len(docs), docCount, "expected # of docs")
+	assert.Empty(suite.T(), results, "should find no problem")
+}
+
+func getShardIds(t *testing.T, client *mongo.Client) []string {
+	res, err := runListShards(t.Context(), logger.NewDefaultLogger(), client)
+	require.NoError(t, err)
+
+	type shardData struct {
+		Id string `bson:"_id"`
+	}
+	var parsed struct {
+		Shards []shardData
+	}
+
+	require.NoError(t, res.Decode(&parsed))
+
+	return lo.Map(
+		parsed.Shards,
+		func(sd shardData, _ int) string {
+			return sd.Id
+		},
+	)
+}
+
 func (suite *IntegrationTestSuite) TestVerifier_DocFilter_ObjectID() {
 	verifier := suite.BuildVerifier()
 	ctx := suite.Context()

From 34c63cf29829e2b2a34f67c6687b711ca489bc2f Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Fri, 15 Aug 2025 10:18:26 -0400
Subject: [PATCH 16/32] fix test

---
 internal/verifier/migration_verifier_test.go | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/internal/verifier/migration_verifier_test.go b/internal/verifier/migration_verifier_test.go
index b9ffd686..2793e8e2 100644
--- a/internal/verifier/migration_verifier_test.go
+++ b/internal/verifier/migration_verifier_test.go
@@ -125,6 +125,10 @@ func (suite *IntegrationTestSuite) TestVerifier_Dotted_Shard_Key() {
 		{{"_id", 33}, {"foo", bson.D{{"bar", bson.D{{"baz", 200}}}}}},
 	}
 
+	shardKey := bson.D{
+		{"foo.bar.baz", 1},
+	}
+
 	for _, coll := range mslices.Of(srcColl, dstColl) {
 		db := coll.Database()
 		client := db.Client()
@@ -140,9 +144,7 @@ func (suite *IntegrationTestSuite) TestVerifier_Dotted_Shard_Key() {
 			ctx,
 			bson.D{
 				{"shardCollection", db.Name() + "." + coll.Name()},
-				{"key", bson.D{
-					{"foo.bar.baz", 1},
-				}},
+				{"key", shardKey},
 			},
 		).Err(),
 		)
@@ -181,6 +183,12 @@ func (suite *IntegrationTestSuite) TestVerifier_Dotted_Shard_Key() {
 		QueryFilter: QueryFilter{
 			Namespace: dbName + "." + collName,
 			To:        dbName + "." + collName,
+			ShardKeys: lo.Map(
+				shardKey,
+				func(el bson.E, _ int) string {
+					return el.Key
+				},
+			),
 			Partition: &partitions.Partition{
 				Key: partitions.PartitionKey{
 					Lower: primitive.MinKey{},

From 9d90009f71d1666d13faed81be100d349ea90ab0 Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Fri, 15 Aug 2025 10:50:43 -0400
Subject: [PATCH 17/32] Use the simpler logic that routing actually uses.

---
 dockey/agg.go                        |  91 +----------------
 dockeys/README.md                    |  22 -----
 dockeys/document_keys.go             | 141 ---------------------------
 internal/verifier/compare.go         |  55 ++++++++---
 internal/verifier/dockey_agg_test.go |  23 ++---
 5 files changed, 56 insertions(+), 276 deletions(-)
 delete mode 100644 dockeys/README.md
 delete mode 100644 dockeys/document_keys.go

diff --git a/dockey/agg.go b/dockey/agg.go
index e8f57484..9db17a0c 100644
--- a/dockey/agg.go
+++ b/dockey/agg.go
@@ -7,7 +7,6 @@ import (
 	"maps"
 	"slices"
 	"strconv"
-	"strings"
 
 	"github.com/samber/lo"
 	"go.mongodb.org/mongo-driver/bson"
@@ -16,28 +15,15 @@ import (
 // ExtractDocKeyAgg returns an aggregation expression that extracts the
 // document key from the document to which the `docExpr` refers.
 //
-// For example, if the doc key field names are [`_id`, `lastName`], this
-// function’s returned expression will yield the same document that shows
-// as `documentKey` in the change stream if that document is inserted.
-// Any fields missing in the document will be excluded from the document key.
-//
-// This correctly reproduces the server’s behavior when field names
-// contain dots: it tries the full field name, then pops a “level” off
-// the name & checks a level further in the document (again privileging
-// the full field name’s remainder), and so on. For example, if the field
-// name is `foo.bar.baz`, this will look for these fields in this order
-// (JSON pointer notation):
-//   - `/foo.bar.baz`
-//   - `/foo/bar.baz`
-//   - `/foo/bar/baz`
-//
-// Note that the above DOES NOT include `/foo.bar/baz`.
-func ExtractDocKeyAgg(fieldNames []string, docExpr any) bson.D {
+// NB: This avoids the problem documented in SERVER-109340; as a result,
+// the returned key may not always match the change stream’s `documentKey`
+// (because the server misreports its own sharding logic).
+func ExtractDocKeyAgg(fieldNames []string, docExpr string) bson.D {
 	var docKeyNumKeys bson.D
 	numToKeyLookup := map[string]string{}
 
 	for n, name := range fieldNames {
-		var valExpr = extractKeyValueAgg(name, docExpr)
+		var valExpr = docExpr + "." + name
 
 		// Aggregation forbids direct creation of an object with dotted keys.
 		// So here we create an object with numeric keys, then below we’ll
@@ -99,70 +85,3 @@ func mapObjectKeysAgg(expr any, mapping map[string]string) bson.D {
 		}},
 	}
 }
-
-// Potentially reusable: a polyfill for $getField. This is useful even with
-// server versions that have $getField because that operator required a
-// constant for the field reference prior to v8.
-func getFieldPolyfillAgg(docExpr, fieldExpr any) bson.D {
-	return bson.D{
-		{"$arrayElemAt", bson.A{
-			bson.D{
-				{"$map", bson.D{
-					{"input", bson.D{
-						{"$filter", bson.D{
-							{"input", bson.D{
-								{"$objectToArray", docExpr},
-							}},
-							{"as", "pair"},
-							{"cond", bson.D{
-								{"$eq", bson.A{
-									"$$pair.k",
-									fieldExpr,
-								}},
-							}},
-						}},
-					}},
-					{"as", "pair"},
-					{"in", "$$pair.v"},
-				}},
-			},
-			0,
-		}},
-	}
-}
-
-func extractKeyValueAgg(fieldName string, baseDocExpr any) any {
-	base, remainder, hasDot := strings.Cut(fieldName, ".")
-
-	fieldExpr := getFieldPolyfillAgg(baseDocExpr, fieldName)
-
-	if !hasDot {
-		return fieldExpr
-	}
-
-	embDocExpr := getFieldPolyfillAgg(baseDocExpr, base)
-
-	return bson.D{
-		{"$cond", bson.D{
-			{"if", bson.D{
-				{"$ne", bson.A{
-					"missing",
-					bson.D{{"$type", fieldExpr}},
-				}},
-			}},
-			{"then", fieldExpr},
-			{"else", bson.D{
-				{"$cond", bson.D{
-					{"if", bson.D{
-						{"$eq", bson.A{
-							"object",
-							bson.D{{"$type", embDocExpr}},
-						}},
-					}},
-					{"then", extractKeyValueAgg(remainder, embDocExpr)},
-					{"else", "$$REMOVE"},
-				}},
-			}},
-		}},
-	}
-}
diff --git a/dockeys/README.md b/dockeys/README.md
deleted file mode 100644
index 49f8d4a1..00000000
--- a/dockeys/README.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# The `dockeys` package
-
-This package is responsible for computing document keys from full documents. A _document key_
-uniquely identifies a document: for replica sets, the document key is always just the `_id`, and in
-sharded clusters, it is the `_id` + shard key. The verifier uses document keys to key the maps in
-the aggregator: we need to do this because keying by `_id` is not sufficient, since the same `_id`
-can exist on multiple shards with different shard keys. (This is not merely academic: mongosync
-creates these transient duplicate `_id`s as part of its normal operation.)
-
-The logic in this package duplicates the server's logic for generating document keys. Ideally we
-_wouldn't_ do this, and could rely on the server to generate them for us in all cases, but right now
-there is no way to do that. (The verifier must generate document keys from documents at rest during
-the initial collection scan.)
-
-To generate the document key for a document, pass the shard key pattern and the full document to
-`ExtractDocumentKey`. That function will first iterate through the shard key and extract all of the
-relevant field values from the document, if they are present. If the `_id` is not a part of the
-shard key pattern, it also appends the `_id` field.
-
-**Important:** the tests for this package are in `verifier/dockeys_test`. They use all of the
-verifier's test abstractions, and so it's easier for now to keep them there. (When mongosync and the
-verifier share more test abstractions, it might be useful to move them.)
diff --git a/dockeys/document_keys.go b/dockeys/document_keys.go
deleted file mode 100644
index b3dba3d4..00000000
--- a/dockeys/document_keys.go
+++ /dev/null
@@ -1,141 +0,0 @@
-// Package dockeys was copied from mongosync@5b99bac58405b and tweaked
-// not to depend on mongosync’s shardkeys package but instead just to take
-// a slice of field names.
-package dockeys
-
-import (
-	"fmt"
-	"slices"
-	"strings"
-
-	"github.com/pkg/errors"
-	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
-)
-
-// DocumentKey represents a document key from the change stream.
-type DocumentKey bson.Raw
-
-// NewDocumentKey returns a document key from a bson.Raw, like you might get
-// from the change stream.
-func NewDocumentKey(raw bson.Raw) DocumentKey {
-	return DocumentKey(raw)
-}
-
-// ExtractDocumentKey takes a slice of shard key fields and a document and returns its
-// DocumentKey. This is a reimplementation of the same method in the server,
-// so that we can reliably generate document keys even without a change
-// stream.
-func ExtractDocumentKey(fields []string, inputBytes []byte) (DocumentKey, error) {
-	input := bson.Raw(inputBytes)
-
-	builder, err := extractShardKey(fields, input)
-	if err != nil {
-		return nil, err
-	}
-
-	if !slices.Contains(fields, "_id") {
-		id, err := input.LookupErr("_id")
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to get document _id")
-		}
-
-		val := bsoncore.Value{Type: bsoncore.Type(id.Type), Data: id.Value}
-		builder.AppendValue("_id", val)
-	}
-
-	return DocumentKey(builder.Build()), nil
-}
-
-// extractShardKey does the shard-key part of the document key extraction. This code is a
-// reimplementation of the server's extractElementsBasedOnTemplate function (in
-// dotted_path_support.cpp), which is called from getDocumentKey in op_observer_util.cpp (which is
-// used by the change stream to generate document keys).
-func extractShardKey(fields []string, input bson.Raw) (*bsoncore.DocumentBuilder, error) {
-	db := bsoncore.NewDocumentBuilder()
-
-	if len(fields) == 0 {
-		return db, nil
-	}
-
-	// For every element of the shard key pattern:
-	for _, key := range fields {
-		rv, err := extractElementAtDottedPath(key, input)
-
-		switch {
-		case errors.Is(err, bsoncore.ErrElementNotFound),
-			errors.As(err, &bsoncore.InvalidDepthTraversalError{}):
-			// This key doesn't exist, do nothing. The server treats these in some
-			// cases as though an explicit null were present, but when generating
-			// document keys, it always omits the field entirely.
-
-		case err != nil:
-			// Something deeply weird went wrong. Try to grab the ID from the
-			// document so this error is plausibly useful.
-			id := input.Lookup("_id")
-			return nil, errors.Wrapf(err, "failed to lookup path for %s (_id: %#q)", key, id)
-
-		default:
-			// We found the element; add it to the result.
-			val := bsoncore.Value{Type: bsoncore.Type(rv.Type), Data: rv.Value}
-			db.AppendValue(key, val)
-		}
-	}
-
-	// We're done: return the whole document.
-	return db, nil
-}
-
-// This code is a reimplementation of the server's extractElementAtDottedPath function in
-// dotted_path_support.cpp.
-func extractElementAtDottedPath(path string, input bson.Raw) (bson.RawValue, error) {
-	// First, try to look up the field verbatim. We must do this because field
-	// names can have dots in them: a shard key pattern like {"a.b": 1} will
-	// first match the literal field "a.b", and then the nested lookup for "b"
-	// in the embedded document "a".
-	rv, err := input.LookupErr(path)
-
-	// If it's not there, and it's a dotted path (like a.b.c), try a nested lookup.
-	if errors.Is(err, bsoncore.ErrElementNotFound) && strings.Contains(path, ".") {
-		left, right, ok := strings.Cut(path, ".")
-		if !ok {
-			panic(fmt.Sprintf("Could not cut %#q on dot", path))
-		}
-
-		el, err := input.LookupErr(left)
-		if err != nil {
-			return el, err
-		}
-
-		doc, ok := el.DocumentOK()
-		if !ok {
-			return rv, bsoncore.InvalidDepthTraversalError{
-				Key:  left,
-				Type: bsoncore.Type(el.Type),
-			}
-		}
-
-		return extractElementAtDottedPath(right, doc)
-	}
-
-	return rv, err
-}
-
-func (dk DocumentKey) String() string {
-	return bson.Raw(dk).String()
-}
-
-// Raw provides access to the document key as a bson.Raw value.
-func (dk DocumentKey) Raw() bson.Raw {
-	return bson.Raw(dk)
-}
-
-// Bytes provides access to the underlying bytes of the document key.
-func (dk DocumentKey) Bytes() []byte {
-	return []byte(dk)
-}
-
-// ID returns the _id portion of the document key as a bson.RawValue.
-func (dk DocumentKey) ID() bson.RawValue {
-	return dk.Raw().Lookup("_id")
-}
diff --git a/internal/verifier/compare.go b/internal/verifier/compare.go
index 16016f72..1b595d00 100644
--- a/internal/verifier/compare.go
+++ b/internal/verifier/compare.go
@@ -4,12 +4,12 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"strings"
 	"time"
 
 	"github.com/10gen/migration-verifier/chanutil"
 	"github.com/10gen/migration-verifier/contextplus"
 	"github.com/10gen/migration-verifier/dockey"
-	"github.com/10gen/migration-verifier/dockeys"
 	"github.com/10gen/migration-verifier/internal/reportutils"
 	"github.com/10gen/migration-verifier/internal/retry"
 	"github.com/10gen/migration-verifier/internal/types"
@@ -21,6 +21,7 @@ import (
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
 	"go.mongodb.org/mongo-driver/mongo/readpref"
+	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
 	"golang.org/x/exp/slices"
 )
 
@@ -321,10 +322,9 @@ func (verifier *Verifier) compareDocsFromChannels(
 		results = append(
 			results,
 			VerificationResult{
-				ID: getDocKeyFieldFromComparison(
+				ID: getDocIdFromComparison(
 					verifier.docCompareMethod,
 					docWithTs.doc,
-					"_id",
 				),
 				Details:      Missing,
 				Cluster:      ClusterTarget,
@@ -339,10 +339,9 @@ func (verifier *Verifier) compareDocsFromChannels(
 		results = append(
 			results,
 			VerificationResult{
-				ID: getDocKeyFieldFromComparison(
+				ID: getDocIdFromComparison(
 					verifier.docCompareMethod,
 					docWithTs.doc,
-					"_id",
 				),
 				Details:      Missing,
 				Cluster:      ClusterSource,
@@ -356,16 +355,15 @@ func (verifier *Verifier) compareDocsFromChannels(
 	return results, srcDocCount, srcByteCount, nil
 }
 
-func getDocKeyFieldFromComparison(
+func getDocIdFromComparison(
 	docCompareMethod DocCompareMethod,
 	doc bson.Raw,
-	fieldName string,
 ) bson.RawValue {
 	switch docCompareMethod {
 	case DocCompareBinary, DocCompareIgnoreOrder:
-		return doc.Lookup(fieldName)
+		return doc.Lookup("_id")
 	case DocCompareToHashedIndexKey:
-		return doc.Lookup(docKeyInHashedCompare, fieldName)
+		return doc.Lookup(docKeyInHashedCompare, "_id")
 	default:
 		panic("bad doc compare method: " + docCompareMethod)
 	}
@@ -380,12 +378,11 @@ func getDocKeyValues(
 
 	switch docCompareMethod {
 	case DocCompareBinary, DocCompareIgnoreOrder:
-		dk, err := dockeys.ExtractDocumentKey(fieldNames, doc)
+		var err error
+		docKey, err = extractDocKeyFromDoc(fieldNames, doc)
 		if err != nil {
-			return nil, errors.Wrapf(err, "extracting doc key (fields: %v) from doc %+v", fieldNames, doc)
+			return nil, err
 		}
-
-		docKey = bson.Raw(dk.Bytes())
 	case DocCompareToHashedIndexKey:
 		docKeyVal, err := doc.LookupErr(docKeyInHashedCompare)
 		if err != nil {
@@ -423,6 +420,36 @@ func getDocKeyValues(
 	return values, nil
 }
 
+// This extracts the document key from a document gets its field names.
+//
+// NB: This avoids the problem documented in SERVER-109340; as a result,
+// the returned key may not always match the change stream’s `documentKey`
+// (because the server misreports its own sharding logic).
+func extractDocKeyFromDoc(
+	fieldNames []string,
+	doc bson.Raw,
+) (bson.Raw, error) {
+	var dk bson.D
+	for _, field := range fieldNames {
+		parts := strings.Split(field, ".")
+		val, err := doc.LookupErr(parts...)
+		if errors.Is(err, bsoncore.ErrElementNotFound) {
+			continue
+		} else if err == nil {
+			dk = append(dk, bson.E{field, val})
+		} else {
+			return nil, errors.Wrapf(err, "extracting doc key field %#q from doc %+v", field, doc)
+		}
+	}
+
+	docKey, err := bson.Marshal(dk)
+	if err != nil {
+		return nil, errors.Wrapf(err, "marshaling doc key %v from doc %v", dk, docKey)
+	}
+
+	return docKey, nil
+}
+
 func simpleTimerReset(t *time.Timer, dur time.Duration) {
 	if !t.Stop() {
 		<-t.C
@@ -711,7 +738,7 @@ func (verifier *Verifier) compareOneDocument(srcClientDoc, dstClientDoc bson.Raw
 	if verifier.docCompareMethod == DocCompareToHashedIndexKey {
 		// With hash comparison, mismatches are opaque.
 		return []VerificationResult{{
-			ID:        getDocKeyFieldFromComparison(verifier.docCompareMethod, srcClientDoc, "_id"),
+			ID:        getDocIdFromComparison(verifier.docCompareMethod, srcClientDoc),
 			Details:   Mismatch,
 			Cluster:   ClusterTarget,
 			NameSpace: namespace,
diff --git a/internal/verifier/dockey_agg_test.go b/internal/verifier/dockey_agg_test.go
index 3d675b0f..26d719c3 100644
--- a/internal/verifier/dockey_agg_test.go
+++ b/internal/verifier/dockey_agg_test.go
@@ -2,7 +2,6 @@ package verifier
 
 import (
 	"os"
-	"testing"
 
 	"github.com/10gen/migration-verifier/dockey"
 	"github.com/10gen/migration-verifier/internal/logger"
@@ -29,7 +28,7 @@ var testCases = []struct {
 			{"foo.bar.baz", 4},
 		},
 		docKey: bson.D{
-			{"foo.bar.baz", int32(4)},
+			{"foo.bar.baz", int32(1)},
 		},
 	},
 	{
@@ -41,29 +40,25 @@ var testCases = []struct {
 			{"foo.bar", bson.D{{"baz", 3}}},
 		},
 		docKey: bson.D{
-			{"foo.bar.baz", int32(2)},
+			{"foo.bar.baz", int32(1)},
 		},
 	},
 	{
 		doc: bson.D{
 			{"foo", bson.D{
-				{"bar", bson.D{{"baz", 1}}},
+				{"bar.baz", 2},
 			}},
 			{"foo.bar", bson.D{{"baz", 3}}},
 		},
 		docKey: bson.D{
-			{"foo.bar.baz", int32(1)},
+			{}, // _id only
 		},
 	},
 	{
 		doc: bson.D{
-			{"foo.bar", bson.D{{"baz", 3}}},
-		},
-		docKey: bson.D{}, // _id only
-	},
-	{
-		doc: bson.D{
-			{"foo", bson.D{{"bar.baz", nil}}},
+			{"foo", bson.D{
+				{"bar", bson.D{{"baz", nil}}},
+			}},
 		},
 		docKey: bson.D{
 			{"foo.bar.baz", nil},
@@ -71,7 +66,9 @@ var testCases = []struct {
 	},
 }
 
-func TestExtractDocKeyAgg(t *testing.T) {
+func (suite *IntegrationTestSuite) TestExtractDocKeyAgg() {
+	t := suite.T()
+
 	ctx := t.Context()
 
 	require := require.New(t)

From a7c0de9436be3b838493b600077b73cb1f363671 Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Tue, 19 Aug 2025 13:54:45 -0400
Subject: [PATCH 18/32] rollback

---
 go.mod                                        |  13 +-
 go.sum                                        |  14 -
 vendor/github.com/golang/snappy/README        |   7 +-
 .../github.com/golang/snappy/encode_arm64.s   |   4 +-
 .../github.com/klauspost/compress/.gitignore  |   7 -
 .../klauspost/compress/.goreleaser.yml        |   4 -
 .../github.com/klauspost/compress/README.md   | 220 +-----
 .../klauspost/compress/fse/compress.go        |  31 +-
 .../klauspost/compress/fse/decompress.go      |   4 +-
 .../klauspost/compress/huff0/bitreader.go     | 130 ++-
 .../klauspost/compress/huff0/bitwriter.go     | 133 +++-
 .../klauspost/compress/huff0/bytereader.go    |  10 +
 .../klauspost/compress/huff0/compress.go      | 127 ++-
 .../klauspost/compress/huff0/decompress.go    | 744 +++++++++++-------
 .../klauspost/compress/huff0/huff0.go         |   2 -
 .../compress/internal/snapref/encode_other.go |  38 +-
 .../klauspost/compress/zstd/README.md         | 172 ++--
 .../klauspost/compress/zstd/bitreader.go      |  12 +-
 .../klauspost/compress/zstd/bitwriter.go      |  98 ++-
 .../klauspost/compress/zstd/blockdec.go       | 526 +++++++------
 .../klauspost/compress/zstd/blockenc.go       | 117 ++-
 .../klauspost/compress/zstd/bytebuf.go        |  27 +-
 .../klauspost/compress/zstd/bytereader.go     |   6 +
 .../klauspost/compress/zstd/decodeheader.go   |  93 +--
 .../klauspost/compress/zstd/decoder.go        | 685 ++++------------
 .../compress/zstd/decoder_options.go          | 103 +--
 .../klauspost/compress/zstd/dict.go           |  51 +-
 .../klauspost/compress/zstd/enc_base.go       |  17 +-
 .../klauspost/compress/zstd/enc_best.go       | 264 ++++---
 .../klauspost/compress/zstd/enc_better.go     |  43 +-
 .../klauspost/compress/zstd/enc_dfast.go      |  35 +-
 .../klauspost/compress/zstd/enc_fast.go       | 176 ++++-
 .../klauspost/compress/zstd/encoder.go        | 151 ++--
 .../compress/zstd/encoder_options.go          |  55 +-
 .../klauspost/compress/zstd/framedec.go       | 342 +++++---
 .../klauspost/compress/zstd/fse_decoder.go    | 128 ++-
 .../klauspost/compress/zstd/fse_encoder.go    |  28 +-
 .../klauspost/compress/zstd/hash.go           |   6 +
 .../klauspost/compress/zstd/history.go        |  67 +-
 .../compress/zstd/internal/xxhash/README.md   |  49 +-
 .../compress/zstd/internal/xxhash/xxhash.go   |  47 +-
 .../zstd/internal/xxhash/xxhash_amd64.go      |  12 +
 .../zstd/internal/xxhash/xxhash_amd64.s       | 337 ++++----
 .../zstd/internal/xxhash/xxhash_other.go      |  23 +-
 .../klauspost/compress/zstd/seqdec.go         | 328 ++++----
 .../github.com/klauspost/compress/zstd/zip.go |  69 +-
 .../klauspost/compress/zstd/zstd.go           |  55 +-
 vendor/golang.org/x/crypto/sha3/doc.go        |   4 -
 vendor/golang.org/x/crypto/sha3/hashes.go     |  31 +-
 vendor/golang.org/x/crypto/sha3/sha3.go       | 187 ++---
 vendor/golang.org/x/crypto/sha3/shake.go      |  89 +--
 vendor/golang.org/x/crypto/sha3/xor.go        |  40 +
 vendor/golang.org/x/sync/errgroup/errgroup.go |   1 -
 vendor/golang.org/x/sys/cpu/cpu.go            |  22 -
 vendor/golang.org/x/sys/cpu/cpu_gc_x86.go     |   4 +-
 vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go  |   6 +
 .../golang.org/x/sys/cpu/cpu_linux_arm64.go   |   1 +
 .../golang.org/x/sys/cpu/cpu_linux_noinit.go  |   2 +-
 vendor/golang.org/x/sys/cpu/cpu_riscv64.go    |  11 +-
 vendor/golang.org/x/sys/cpu/cpu_x86.go        |  27 +-
 vendor/golang.org/x/sys/cpu/cpu_x86.s         |  26 +
 vendor/golang.org/x/sys/unix/README.md        |   2 +-
 vendor/golang.org/x/sys/unix/ioctl_linux.go   |  96 ---
 vendor/golang.org/x/sys/unix/mkerrors.sh      |  17 +-
 vendor/golang.org/x/sys/unix/syscall_aix.go   |   2 +-
 .../golang.org/x/sys/unix/syscall_darwin.go   |  37 -
 .../x/sys/unix/syscall_dragonfly.go           |  12 -
 vendor/golang.org/x/sys/unix/syscall_hurd.go  |   1 -
 vendor/golang.org/x/sys/unix/syscall_linux.go |  64 +-
 .../x/sys/unix/syscall_linux_arm64.go         |   2 -
 .../x/sys/unix/syscall_linux_loong64.go       |   2 -
 .../x/sys/unix/syscall_linux_riscv64.go       |   2 -
 .../golang.org/x/sys/unix/syscall_solaris.go  |  87 --
 .../x/sys/unix/syscall_zos_s390x.go           | 104 +--
 .../x/sys/unix/zerrors_darwin_amd64.go        |   7 -
 .../x/sys/unix/zerrors_darwin_arm64.go        |   7 -
 vendor/golang.org/x/sys/unix/zerrors_linux.go |  64 +-
 .../x/sys/unix/zerrors_linux_386.go           |  28 -
 .../x/sys/unix/zerrors_linux_amd64.go         |  28 -
 .../x/sys/unix/zerrors_linux_arm.go           |  28 -
 .../x/sys/unix/zerrors_linux_arm64.go         |  30 -
 .../x/sys/unix/zerrors_linux_loong64.go       |  28 -
 .../x/sys/unix/zerrors_linux_mips.go          |  28 -
 .../x/sys/unix/zerrors_linux_mips64.go        |  28 -
 .../x/sys/unix/zerrors_linux_mips64le.go      |  28 -
 .../x/sys/unix/zerrors_linux_mipsle.go        |  28 -
 .../x/sys/unix/zerrors_linux_ppc.go           |  28 -
 .../x/sys/unix/zerrors_linux_ppc64.go         |  28 -
 .../x/sys/unix/zerrors_linux_ppc64le.go       |  28 -
 .../x/sys/unix/zerrors_linux_riscv64.go       |  28 -
 .../x/sys/unix/zerrors_linux_s390x.go         |  28 -
 .../x/sys/unix/zerrors_linux_sparc64.go       |  28 -
 .../x/sys/unix/zerrors_zos_s390x.go           |   2 -
 .../x/sys/unix/zsyscall_darwin_amd64.go       |  20 -
 .../x/sys/unix/zsyscall_darwin_amd64.s        |   5 -
 .../x/sys/unix/zsyscall_darwin_arm64.go       |  20 -
 .../x/sys/unix/zsyscall_darwin_arm64.s        |   5 -
 .../golang.org/x/sys/unix/zsyscall_linux.go   |  27 +-
 .../x/sys/unix/zsyscall_solaris_amd64.go      | 114 ---
 .../x/sys/unix/zsysnum_linux_386.go           |   4 -
 .../x/sys/unix/zsysnum_linux_amd64.go         |   5 -
 .../x/sys/unix/zsysnum_linux_arm.go           |   4 -
 .../x/sys/unix/zsysnum_linux_arm64.go         |   6 +-
 .../x/sys/unix/zsysnum_linux_loong64.go       |   6 -
 .../x/sys/unix/zsysnum_linux_mips.go          |   4 -
 .../x/sys/unix/zsysnum_linux_mips64.go        |   4 -
 .../x/sys/unix/zsysnum_linux_mips64le.go      |   4 -
 .../x/sys/unix/zsysnum_linux_mipsle.go        |   4 -
 .../x/sys/unix/zsysnum_linux_ppc.go           |   4 -
 .../x/sys/unix/zsysnum_linux_ppc64.go         |   4 -
 .../x/sys/unix/zsysnum_linux_ppc64le.go       |   4 -
 .../x/sys/unix/zsysnum_linux_riscv64.go       |   6 +-
 .../x/sys/unix/zsysnum_linux_s390x.go         |   4 -
 .../x/sys/unix/zsysnum_linux_sparc64.go       |   4 -
 .../x/sys/unix/ztypes_darwin_amd64.go         |  73 --
 .../x/sys/unix/ztypes_darwin_arm64.go         |  73 --
 .../x/sys/unix/ztypes_freebsd_386.go          |   1 -
 .../x/sys/unix/ztypes_freebsd_amd64.go        |   1 -
 .../x/sys/unix/ztypes_freebsd_arm.go          |   1 -
 .../x/sys/unix/ztypes_freebsd_arm64.go        |   1 -
 .../x/sys/unix/ztypes_freebsd_riscv64.go      |   1 -
 vendor/golang.org/x/sys/unix/ztypes_linux.go  | 231 ++----
 .../x/sys/unix/ztypes_linux_riscv64.go        |  33 -
 .../golang.org/x/sys/unix/ztypes_zos_s390x.go |   6 -
 vendor/modules.txt                            |  21 +-
 125 files changed, 3067 insertions(+), 4624 deletions(-)
 create mode 100644 vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_amd64.go
 create mode 100644 vendor/golang.org/x/crypto/sha3/xor.go
 create mode 100644 vendor/golang.org/x/sys/cpu/cpu_x86.s

diff --git a/go.mod b/go.mod
index 0b24d036..7edebef8 100644
--- a/go.mod
+++ b/go.mod
@@ -19,7 +19,7 @@ require (
 	github.com/urfave/cli v1.22.9
 	go.mongodb.org/mongo-driver v1.17.1
 	golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56
-	golang.org/x/sync v0.11.0
+	golang.org/x/sync v0.8.0
 	gopkg.in/natefinch/lumberjack.v2 v2.0.0
 )
 
@@ -32,10 +32,10 @@ require (
 	github.com/go-playground/universal-translator v0.18.0 // indirect
 	github.com/go-playground/validator/v10 v10.10.0 // indirect
 	github.com/goccy/go-json v0.9.7 // indirect
-	github.com/golang/snappy v1.0.0 // indirect
+	github.com/golang/snappy v0.0.4 // indirect
 	github.com/huandu/go-clone v1.6.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/compress v1.16.7 // indirect
+	github.com/klauspost/compress v1.13.6 // indirect
 	github.com/leodido/go-urn v1.2.1 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.19 // indirect
@@ -51,11 +51,10 @@ require (
 	github.com/xdg-go/scram v1.1.2 // indirect
 	github.com/xdg-go/stringprep v1.0.4 // indirect
 	github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
-	go.mongodb.org/mongo-driver/v2 v2.2.3 // indirect
-	golang.org/x/crypto v0.33.0 // indirect
+	golang.org/x/crypto v0.26.0 // indirect
 	golang.org/x/net v0.21.0 // indirect
-	golang.org/x/sys v0.30.0 // indirect
-	golang.org/x/text v0.22.0 // indirect
+	golang.org/x/sys v0.23.0 // indirect
+	golang.org/x/text v0.17.0 // indirect
 	google.golang.org/protobuf v1.28.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
diff --git a/go.sum b/go.sum
index dabb3b87..918591a6 100644
--- a/go.sum
+++ b/go.sum
@@ -32,8 +32,6 @@ github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5x
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/golang/snappy v1.0.0 h1:Oy607GVXHs7RtbggtPBnr2RmDArIsAefDwvrdWvRhGs=
-github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
@@ -50,8 +48,6 @@ github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnr
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/klauspost/compress v1.13.6 h1:P76CopJELS0TiO2mebmnzgWaajssP/EszplttgQxcgc=
 github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
-github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGCFR9I=
-github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
@@ -125,15 +121,11 @@ github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78/go.mod h1:aL8wCCfTfS
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 go.mongodb.org/mongo-driver v1.17.1 h1:Wic5cJIwJgSpBhe3lx3+/RybR5PiYRMpVFgO7cOHyIM=
 go.mongodb.org/mongo-driver v1.17.1/go.mod h1:wwWm/+BuOddhcq3n68LKRmgk2wXzmF6s0SFOa0GINL4=
-go.mongodb.org/mongo-driver/v2 v2.2.3 h1:72uiGYXeSnUEQk37xvV9r067xzFQod4SOeAoOuq3+GM=
-go.mongodb.org/mongo-driver/v2 v2.2.3/go.mod h1:qQkDMhCGWl3FN509DfdPd4GRBLU/41zqF/k8eTRceps=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw=
 golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54=
-golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
-golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
 golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
 golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
@@ -146,8 +138,6 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
 golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
-golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -159,8 +149,6 @@ golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.23.0 h1:YfKFowiIMvtgl1UERQoTPPToxltDeZfbj4H7dVUCwmM=
 golang.org/x/sys v0.23.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
-golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -170,8 +158,6 @@ golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
 golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc=
 golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
-golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
-golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
diff --git a/vendor/github.com/golang/snappy/README b/vendor/github.com/golang/snappy/README
index fd191f78..cea12879 100644
--- a/vendor/github.com/golang/snappy/README
+++ b/vendor/github.com/golang/snappy/README
@@ -1,13 +1,8 @@
 The Snappy compression format in the Go programming language.
 
-To use as a library:
+To download and install from source:
 $ go get github.com/golang/snappy
 
-To use as a binary:
-$ go install github.com/golang/snappy/cmd/snappytool@latest
-$ cat decoded | ~/go/bin/snappytool -e > encoded
-$ cat encoded | ~/go/bin/snappytool -d > decoded
-
 Unless otherwise noted, the Snappy-Go source files are distributed
 under the BSD-style license found in the LICENSE file.
 
diff --git a/vendor/github.com/golang/snappy/encode_arm64.s b/vendor/github.com/golang/snappy/encode_arm64.s
index f0c876a2..f8d54adf 100644
--- a/vendor/github.com/golang/snappy/encode_arm64.s
+++ b/vendor/github.com/golang/snappy/encode_arm64.s
@@ -27,7 +27,7 @@
 // The unusual register allocation of local variables, such as R10 for the
 // source pointer, matches the allocation used at the call site in encodeBlock,
 // which makes it easier to manually inline this function.
-TEXT ·emitLiteral(SB), NOSPLIT, $40-56
+TEXT ·emitLiteral(SB), NOSPLIT, $32-56
 	MOVD dst_base+0(FP), R8
 	MOVD lit_base+24(FP), R10
 	MOVD lit_len+32(FP), R3
@@ -261,7 +261,7 @@ extendMatchEnd:
 // "var table [maxTableSize]uint16" takes up 32768 bytes of stack space. An
 // extra 64 bytes, to call other functions, and an extra 64 bytes, to spill
 // local variables (registers) during calls gives 32768 + 64 + 64 = 32896.
-TEXT ·encodeBlock(SB), 0, $32904-56
+TEXT ·encodeBlock(SB), 0, $32896-56
 	MOVD dst_base+0(FP), R8
 	MOVD src_base+24(FP), R7
 	MOVD src_len+32(FP), R14
diff --git a/vendor/github.com/klauspost/compress/.gitignore b/vendor/github.com/klauspost/compress/.gitignore
index d31b3781..b35f8449 100644
--- a/vendor/github.com/klauspost/compress/.gitignore
+++ b/vendor/github.com/klauspost/compress/.gitignore
@@ -23,10 +23,3 @@ _testmain.go
 *.test
 *.prof
 /s2/cmd/_s2sx/sfx-exe
-
-# Linux perf files
-perf.data
-perf.data.old
-
-# gdb history
-.gdb_history
diff --git a/vendor/github.com/klauspost/compress/.goreleaser.yml b/vendor/github.com/klauspost/compress/.goreleaser.yml
index 7a008a4d..c9014ce1 100644
--- a/vendor/github.com/klauspost/compress/.goreleaser.yml
+++ b/vendor/github.com/klauspost/compress/.goreleaser.yml
@@ -3,7 +3,6 @@
 before:
   hooks:
     - ./gen.sh
-    - go install mvdan.cc/garble@v0.9.3
 
 builds:
   -
@@ -32,7 +31,6 @@ builds:
       - mips64le
     goarm:
       - 7
-    gobinary: garble
   -
     id: "s2d"
     binary: s2d
@@ -59,7 +57,6 @@ builds:
       - mips64le
     goarm:
       - 7
-    gobinary: garble
   -
     id: "s2sx"
     binary: s2sx
@@ -87,7 +84,6 @@ builds:
       - mips64le
     goarm:
       - 7
-    gobinary: garble
 
 archives:
   -
diff --git a/vendor/github.com/klauspost/compress/README.md b/vendor/github.com/klauspost/compress/README.md
index 4002a16a..3429879e 100644
--- a/vendor/github.com/klauspost/compress/README.md
+++ b/vendor/github.com/klauspost/compress/README.md
@@ -9,6 +9,7 @@ This package provides various compression algorithms.
 * [huff0](https://github.com/klauspost/compress/tree/master/huff0) and [FSE](https://github.com/klauspost/compress/tree/master/fse) implementations for raw entropy encoding.
 * [gzhttp](https://github.com/klauspost/compress/tree/master/gzhttp) Provides client and server wrappers for handling gzipped requests efficiently.
 * [pgzip](https://github.com/klauspost/pgzip) is a separate package that provides a very fast parallel gzip implementation.
+* [fuzz package](https://github.com/klauspost/compress-fuzz) for fuzz testing all compressors/decompressors here.
 
 [![Go Reference](https://pkg.go.dev/badge/klauspost/compress.svg)](https://pkg.go.dev/github.com/klauspost/compress?tab=subdirectories)
 [![Go](https://github.com/klauspost/compress/actions/workflows/go.yml/badge.svg)](https://github.com/klauspost/compress/actions/workflows/go.yml)
@@ -16,199 +17,6 @@ This package provides various compression algorithms.
 
 # changelog
 
-* June 13, 2023 - [v1.16.6](https://github.com/klauspost/compress/releases/tag/v1.16.6)
-	* zstd: correctly ignore WithEncoderPadding(1) by @ianlancetaylor in https://github.com/klauspost/compress/pull/806
-	* zstd: Add amd64 match length assembly https://github.com/klauspost/compress/pull/824
-	* gzhttp: Handle informational headers by @rtribotte in https://github.com/klauspost/compress/pull/815
-	* s2: Improve Better compression slightly https://github.com/klauspost/compress/pull/663
-
-* Apr 16, 2023 - [v1.16.5](https://github.com/klauspost/compress/releases/tag/v1.16.5)
-	* zstd: readByte needs to use io.ReadFull by @jnoxon in https://github.com/klauspost/compress/pull/802
-	* gzip: Fix WriterTo after initial read https://github.com/klauspost/compress/pull/804
-
-* Apr 5, 2023 - [v1.16.4](https://github.com/klauspost/compress/releases/tag/v1.16.4)
-	* zstd: Improve zstd best efficiency by @greatroar and @klauspost in https://github.com/klauspost/compress/pull/784
-	* zstd: Respect WithAllLitEntropyCompression https://github.com/klauspost/compress/pull/792
-	* zstd: Fix amd64 not always detecting corrupt data https://github.com/klauspost/compress/pull/785
-	* zstd: Various minor improvements by @greatroar in https://github.com/klauspost/compress/pull/788 https://github.com/klauspost/compress/pull/794 https://github.com/klauspost/compress/pull/795
-	* s2: Fix huge block overflow https://github.com/klauspost/compress/pull/779
-	* s2: Allow CustomEncoder fallback https://github.com/klauspost/compress/pull/780
-	* gzhttp: Suppport ResponseWriter Unwrap() in gzhttp handler by @jgimenez in https://github.com/klauspost/compress/pull/799
-
-* Mar 13, 2023 - [v1.16.1](https://github.com/klauspost/compress/releases/tag/v1.16.1)
-	* zstd: Speed up + improve best encoder by @greatroar in https://github.com/klauspost/compress/pull/776
-	* gzhttp: Add optional [BREACH mitigation](https://github.com/klauspost/compress/tree/master/gzhttp#breach-mitigation). https://github.com/klauspost/compress/pull/762 https://github.com/klauspost/compress/pull/768 https://github.com/klauspost/compress/pull/769 https://github.com/klauspost/compress/pull/770 https://github.com/klauspost/compress/pull/767
-	* s2: Add Intel LZ4s converter https://github.com/klauspost/compress/pull/766
-	* zstd: Minor bug fixes https://github.com/klauspost/compress/pull/771 https://github.com/klauspost/compress/pull/772 https://github.com/klauspost/compress/pull/773
-	* huff0: Speed up compress1xDo by @greatroar in https://github.com/klauspost/compress/pull/774
-
-* Feb 26, 2023 - [v1.16.0](https://github.com/klauspost/compress/releases/tag/v1.16.0)
-	* s2: Add [Dictionary](https://github.com/klauspost/compress/tree/master/s2#dictionaries) support.  https://github.com/klauspost/compress/pull/685
-	* s2: Add Compression Size Estimate.  https://github.com/klauspost/compress/pull/752
-	* s2: Add support for custom stream encoder. https://github.com/klauspost/compress/pull/755
-	* s2: Add LZ4 block converter. https://github.com/klauspost/compress/pull/748
-	* s2: Support io.ReaderAt in ReadSeeker. https://github.com/klauspost/compress/pull/747
-	* s2c/s2sx: Use concurrent decoding. https://github.com/klauspost/compress/pull/746
-
-* Jan 21st, 2023 (v1.15.15)
-	* deflate: Improve level 7-9 by @klauspost in https://github.com/klauspost/compress/pull/739
-	* zstd: Add delta encoding support by @greatroar in https://github.com/klauspost/compress/pull/728
-	* zstd: Various speed improvements by @greatroar https://github.com/klauspost/compress/pull/741 https://github.com/klauspost/compress/pull/734 https://github.com/klauspost/compress/pull/736 https://github.com/klauspost/compress/pull/744 https://github.com/klauspost/compress/pull/743 https://github.com/klauspost/compress/pull/745
-	* gzhttp: Add SuffixETag() and DropETag() options to prevent ETag collisions on compressed responses by @willbicks in https://github.com/klauspost/compress/pull/740
-
-* Jan 3rd, 2023 (v1.15.14)
-
-	* flate: Improve speed in big stateless blocks https://github.com/klauspost/compress/pull/718
-	* zstd: Minor speed tweaks by @greatroar in https://github.com/klauspost/compress/pull/716 https://github.com/klauspost/compress/pull/720
-	* export NoGzipResponseWriter for custom ResponseWriter wrappers by @harshavardhana in https://github.com/klauspost/compress/pull/722
-	* s2: Add example for indexing and existing stream https://github.com/klauspost/compress/pull/723
-
-* Dec 11, 2022 (v1.15.13)
-	* zstd: Add [MaxEncodedSize](https://pkg.go.dev/github.com/klauspost/compress@v1.15.13/zstd#Encoder.MaxEncodedSize) to encoder  https://github.com/klauspost/compress/pull/691
-	* zstd: Various tweaks and improvements https://github.com/klauspost/compress/pull/693 https://github.com/klauspost/compress/pull/695 https://github.com/klauspost/compress/pull/696 https://github.com/klauspost/compress/pull/701 https://github.com/klauspost/compress/pull/702 https://github.com/klauspost/compress/pull/703 https://github.com/klauspost/compress/pull/704 https://github.com/klauspost/compress/pull/705 https://github.com/klauspost/compress/pull/706 https://github.com/klauspost/compress/pull/707 https://github.com/klauspost/compress/pull/708
-
-* Oct 26, 2022 (v1.15.12)
-
-	* zstd: Tweak decoder allocs. https://github.com/klauspost/compress/pull/680
-	* gzhttp: Always delete `HeaderNoCompression` https://github.com/klauspost/compress/pull/683
-
-* Sept 26, 2022 (v1.15.11)
-
-	* flate: Improve level 1-3 compression  https://github.com/klauspost/compress/pull/678
-	* zstd: Improve "best" compression by @nightwolfz in https://github.com/klauspost/compress/pull/677
-	* zstd: Fix+reduce decompression allocations https://github.com/klauspost/compress/pull/668
-	* zstd: Fix non-effective noescape tag https://github.com/klauspost/compress/pull/667
-
-* Sept 16, 2022 (v1.15.10)
-
-	* zstd: Add [WithDecodeAllCapLimit](https://pkg.go.dev/github.com/klauspost/compress@v1.15.10/zstd#WithDecodeAllCapLimit) https://github.com/klauspost/compress/pull/649
-	* Add Go 1.19 - deprecate Go 1.16  https://github.com/klauspost/compress/pull/651
-	* flate: Improve level 5+6 compression https://github.com/klauspost/compress/pull/656
-	* zstd: Improve "better" compresssion  https://github.com/klauspost/compress/pull/657
-	* s2: Improve "best" compression https://github.com/klauspost/compress/pull/658
-	* s2: Improve "better" compression. https://github.com/klauspost/compress/pull/635
-	* s2: Slightly faster non-assembly decompression https://github.com/klauspost/compress/pull/646
-	* Use arrays for constant size copies https://github.com/klauspost/compress/pull/659
-
-* July 21, 2022 (v1.15.9)
-
-	* zstd: Fix decoder crash on amd64 (no BMI) on invalid input https://github.com/klauspost/compress/pull/645
-	* zstd: Disable decoder extended memory copies (amd64) due to possible crashes https://github.com/klauspost/compress/pull/644
-	* zstd: Allow single segments up to "max decoded size" by @klauspost in https://github.com/klauspost/compress/pull/643
-
-* July 13, 2022 (v1.15.8)
-
-	* gzip: fix stack exhaustion bug in Reader.Read https://github.com/klauspost/compress/pull/641
-	* s2: Add Index header trim/restore https://github.com/klauspost/compress/pull/638
-	* zstd: Optimize seqdeq amd64 asm by @greatroar in https://github.com/klauspost/compress/pull/636
-	* zstd: Improve decoder memcopy https://github.com/klauspost/compress/pull/637
-	* huff0: Pass a single bitReader pointer to asm by @greatroar in https://github.com/klauspost/compress/pull/634
-	* zstd: Branchless getBits for amd64 w/o BMI2 by @greatroar in https://github.com/klauspost/compress/pull/640
-	* gzhttp: Remove header before writing https://github.com/klauspost/compress/pull/639
-
-* June 29, 2022 (v1.15.7)
-
-	* s2: Fix absolute forward seeks  https://github.com/klauspost/compress/pull/633
-	* zip: Merge upstream  https://github.com/klauspost/compress/pull/631
-	* zip: Re-add zip64 fix https://github.com/klauspost/compress/pull/624
-	* zstd: translate fseDecoder.buildDtable into asm by @WojciechMula in https://github.com/klauspost/compress/pull/598
-	* flate: Faster histograms  https://github.com/klauspost/compress/pull/620
-	* deflate: Use compound hcode  https://github.com/klauspost/compress/pull/622
-
-* June 3, 2022 (v1.15.6)
-	* s2: Improve coding for long, close matches https://github.com/klauspost/compress/pull/613
-	* s2c: Add Snappy/S2 stream recompression https://github.com/klauspost/compress/pull/611
-	* zstd: Always use configured block size https://github.com/klauspost/compress/pull/605
-	* zstd: Fix incorrect hash table placement for dict encoding in default https://github.com/klauspost/compress/pull/606
-	* zstd: Apply default config to ZipDecompressor without options https://github.com/klauspost/compress/pull/608
-	* gzhttp: Exclude more common archive formats https://github.com/klauspost/compress/pull/612
-	* s2: Add ReaderIgnoreCRC https://github.com/klauspost/compress/pull/609
-	* s2: Remove sanity load on index creation https://github.com/klauspost/compress/pull/607
-	* snappy: Use dedicated function for scoring https://github.com/klauspost/compress/pull/614
-	* s2c+s2d: Use official snappy framed extension https://github.com/klauspost/compress/pull/610
-
-* May 25, 2022 (v1.15.5)
-	* s2: Add concurrent stream decompression https://github.com/klauspost/compress/pull/602
-	* s2: Fix final emit oob read crash on amd64 https://github.com/klauspost/compress/pull/601
-	* huff0: asm implementation of Decompress1X by @WojciechMula https://github.com/klauspost/compress/pull/596
-	* zstd: Use 1 less goroutine for stream decoding https://github.com/klauspost/compress/pull/588
-	* zstd: Copy literal in 16 byte blocks when possible https://github.com/klauspost/compress/pull/592
-	* zstd: Speed up when WithDecoderLowmem(false) https://github.com/klauspost/compress/pull/599
-	* zstd: faster next state update in BMI2 version of decode by @WojciechMula in https://github.com/klauspost/compress/pull/593
-	* huff0: Do not check max size when reading table. https://github.com/klauspost/compress/pull/586
-	* flate: Inplace hashing for level 7-9 by @klauspost in https://github.com/klauspost/compress/pull/590
-
-
-* May 11, 2022 (v1.15.4)
-	* huff0: decompress directly into output by @WojciechMula in [#577](https://github.com/klauspost/compress/pull/577)
-	* inflate: Keep dict on stack [#581](https://github.com/klauspost/compress/pull/581)
-	* zstd: Faster decoding memcopy in asm [#583](https://github.com/klauspost/compress/pull/583)
-	* zstd: Fix ignored crc [#580](https://github.com/klauspost/compress/pull/580)
-
-* May 5, 2022 (v1.15.3)
-	* zstd: Allow to ignore checksum checking by @WojciechMula [#572](https://github.com/klauspost/compress/pull/572)
-	* s2: Fix incorrect seek for io.SeekEnd in [#575](https://github.com/klauspost/compress/pull/575)
-
-* Apr 26, 2022 (v1.15.2)
-	* zstd: Add x86-64 assembly for decompression on streams and blocks. Contributed by [@WojciechMula](https://github.com/WojciechMula). Typically 2x faster.  [#528](https://github.com/klauspost/compress/pull/528) [#531](https://github.com/klauspost/compress/pull/531) [#545](https://github.com/klauspost/compress/pull/545) [#537](https://github.com/klauspost/compress/pull/537)
-	* zstd: Add options to ZipDecompressor and fixes [#539](https://github.com/klauspost/compress/pull/539)
-	* s2: Use sorted search for index [#555](https://github.com/klauspost/compress/pull/555)
-	* Minimum version is Go 1.16, added CI test on 1.18.
-
-* Mar 11, 2022 (v1.15.1)
-	* huff0: Add x86 assembly of Decode4X by @WojciechMula in [#512](https://github.com/klauspost/compress/pull/512)
-	* zstd: Reuse zip decoders in [#514](https://github.com/klauspost/compress/pull/514)
-	* zstd: Detect extra block data and report as corrupted in [#520](https://github.com/klauspost/compress/pull/520)
-	* zstd: Handle zero sized frame content size stricter in [#521](https://github.com/klauspost/compress/pull/521)
-	* zstd: Add stricter block size checks in [#523](https://github.com/klauspost/compress/pull/523)
-
-* Mar 3, 2022 (v1.15.0)
-	* zstd: Refactor decoder by @klauspost in [#498](https://github.com/klauspost/compress/pull/498)
-	* zstd: Add stream encoding without goroutines by @klauspost in [#505](https://github.com/klauspost/compress/pull/505)
-	* huff0: Prevent single blocks exceeding 16 bits by @klauspost in[#507](https://github.com/klauspost/compress/pull/507)
-	* flate: Inline literal emission by @klauspost in [#509](https://github.com/klauspost/compress/pull/509)
-	* gzhttp: Add zstd to transport by @klauspost in [#400](https://github.com/klauspost/compress/pull/400)
-	* gzhttp: Make content-type optional by @klauspost in [#510](https://github.com/klauspost/compress/pull/510)
-
-Both compression and decompression now supports "synchronous" stream operations. This means that whenever "concurrency" is set to 1, they will operate without spawning goroutines.
-
-Stream decompression is now faster on asynchronous, since the goroutine allocation much more effectively splits the workload. On typical streams this will typically use 2 cores fully for decompression. When a stream has finished decoding no goroutines will be left over, so decoders can now safely be pooled and still be garbage collected.
-
-While the release has been extensively tested, it is recommended to testing when upgrading.
-
-<details>
-	<summary>See changes to v1.14.x</summary>
-	
-* Feb 22, 2022 (v1.14.4)
-	* flate: Fix rare huffman only (-2) corruption. [#503](https://github.com/klauspost/compress/pull/503)
-	* zip: Update deprecated CreateHeaderRaw to correctly call CreateRaw by @saracen in [#502](https://github.com/klauspost/compress/pull/502)
-	* zip: don't read data descriptor early by @saracen in [#501](https://github.com/klauspost/compress/pull/501)  #501
-	* huff0: Use static decompression buffer up to 30% faster by @klauspost in [#499](https://github.com/klauspost/compress/pull/499) [#500](https://github.com/klauspost/compress/pull/500)
-
-* Feb 17, 2022 (v1.14.3)
-	* flate: Improve fastest levels compression speed ~10% more throughput. [#482](https://github.com/klauspost/compress/pull/482) [#489](https://github.com/klauspost/compress/pull/489) [#490](https://github.com/klauspost/compress/pull/490) [#491](https://github.com/klauspost/compress/pull/491) [#494](https://github.com/klauspost/compress/pull/494)  [#478](https://github.com/klauspost/compress/pull/478)
-	* flate: Faster decompression speed, ~5-10%. [#483](https://github.com/klauspost/compress/pull/483)
-	* s2: Faster compression with Go v1.18 and amd64 microarch level 3+. [#484](https://github.com/klauspost/compress/pull/484) [#486](https://github.com/klauspost/compress/pull/486)
-
-* Jan 25, 2022 (v1.14.2)
-	* zstd: improve header decoder by @dsnet  [#476](https://github.com/klauspost/compress/pull/476)
-	* zstd: Add bigger default blocks  [#469](https://github.com/klauspost/compress/pull/469)
-	* zstd: Remove unused decompression buffer [#470](https://github.com/klauspost/compress/pull/470)
-	* zstd: Fix logically dead code by @ningmingxiao [#472](https://github.com/klauspost/compress/pull/472)
-	* flate: Improve level 7-9 [#471](https://github.com/klauspost/compress/pull/471) [#473](https://github.com/klauspost/compress/pull/473)
-	* zstd: Add noasm tag for xxhash [#475](https://github.com/klauspost/compress/pull/475)
-
-* Jan 11, 2022 (v1.14.1)
-	* s2: Add stream index in [#462](https://github.com/klauspost/compress/pull/462)
-	* flate: Speed and efficiency improvements in [#439](https://github.com/klauspost/compress/pull/439) [#461](https://github.com/klauspost/compress/pull/461) [#455](https://github.com/klauspost/compress/pull/455) [#452](https://github.com/klauspost/compress/pull/452) [#458](https://github.com/klauspost/compress/pull/458)
-	* zstd: Performance improvement in [#420]( https://github.com/klauspost/compress/pull/420) [#456](https://github.com/klauspost/compress/pull/456) [#437](https://github.com/klauspost/compress/pull/437) [#467](https://github.com/klauspost/compress/pull/467) [#468](https://github.com/klauspost/compress/pull/468)
-	* zstd: add arm64 xxhash assembly in [#464](https://github.com/klauspost/compress/pull/464)
-	* Add garbled for binaries for s2 in [#445](https://github.com/klauspost/compress/pull/445)
-</details>
-
-<details>
-	<summary>See changes to v1.13.x</summary>
-	
 * Aug 30, 2021 (v1.13.5)
 	* gz/zlib/flate: Alias stdlib errors [#425](https://github.com/klauspost/compress/pull/425)
 	* s2: Add block support to commandline tools [#413](https://github.com/klauspost/compress/pull/413)
@@ -237,12 +45,7 @@ While the release has been extensively tested, it is recommended to testing when
 	* Added [gzhttp](https://github.com/klauspost/compress/tree/master/gzhttp#gzip-handler) which allows wrapping HTTP servers and clients with GZIP compressors.
 	* zstd: Detect short invalid signatures [#382](https://github.com/klauspost/compress/pull/382)
 	* zstd: Spawn decoder goroutine only if needed. [#380](https://github.com/klauspost/compress/pull/380)
-</details>
 
-
-<details>
-	<summary>See changes to v1.12.x</summary>
-	
 * May 25, 2021 (v1.12.3)
 	* deflate: Better/faster Huffman encoding [#374](https://github.com/klauspost/compress/pull/374)
 	* deflate: Allocate less for history. [#375](https://github.com/klauspost/compress/pull/375)
@@ -264,10 +67,9 @@ While the release has been extensively tested, it is recommended to testing when
 	* s2c/s2d/s2sx: Always truncate when writing files [#352](https://github.com/klauspost/compress/pull/352)
 	* zstd: Reduce memory usage further when using [WithLowerEncoderMem](https://pkg.go.dev/github.com/klauspost/compress/zstd#WithLowerEncoderMem) [#346](https://github.com/klauspost/compress/pull/346)
 	* s2: Fix potential problem with amd64 assembly and profilers [#349](https://github.com/klauspost/compress/pull/349)
-</details>
 
 <details>
-	<summary>See changes to v1.11.x</summary>
+	<summary>See changes prior to v1.12.1</summary>
 	
 * Mar 26, 2021 (v1.11.13)
 	* zstd: Big speedup on small dictionary encodes [#344](https://github.com/klauspost/compress/pull/344) [#345](https://github.com/klauspost/compress/pull/345)
@@ -326,7 +128,7 @@ While the release has been extensively tested, it is recommended to testing when
 </details>
 
 <details>
-	<summary>See changes to v1.10.x</summary>
+	<summary>See changes prior to v1.11.0</summary>
  
 * July 8, 2020 (v1.10.11) 
 	* zstd: Fix extra block when compressing with ReadFrom. [#278](https://github.com/klauspost/compress/pull/278)
@@ -488,6 +290,11 @@ While the release has been extensively tested, it is recommended to testing when
 
 # deflate usage
 
+* [High Throughput Benchmark](http://blog.klauspost.com/go-gzipdeflate-benchmarks/).
+* [Small Payload/Webserver Benchmarks](http://blog.klauspost.com/gzip-performance-for-go-webservers/).
+* [Linear Time Compression](http://blog.klauspost.com/constant-time-gzipzip-compression/).
+* [Re-balancing Deflate Compression Levels](https://blog.klauspost.com/rebalancing-deflate-compression-levels/)
+
 The packages are drop-in replacements for standard libraries. Simply replace the import path to use them:
 
 | old import         | new import                              | Documentation
@@ -509,8 +316,6 @@ Memory usage is typically 1MB for a Writer. stdlib is in the same range.
 If you expect to have a lot of concurrently allocated Writers consider using 
 the stateless compress described below.
 
-For compression performance, see: [this spreadsheet](https://docs.google.com/spreadsheets/d/1nuNE2nPfuINCZJRMt6wFWhKpToF95I47XjSsc-1rbPQ/edit?usp=sharing).
-
 # Stateless compression
 
 This package offers stateless compression as a special option for gzip/deflate. 
@@ -627,15 +432,6 @@ For more information see my blog post on [Fast Linear Time Compression](http://b
 
 This is implemented on Go 1.7 as "Huffman Only" mode, though not exposed for gzip.
 
-# Other packages
-
-Here are other packages of good quality and pure Go (no cgo wrappers or autoconverted code):
-
-* [github.com/pierrec/lz4](https://github.com/pierrec/lz4) - strong multithreaded LZ4 compression.
-* [github.com/cosnicolaou/pbzip2](https://github.com/cosnicolaou/pbzip2) - multithreaded bzip2 decompression.
-* [github.com/dsnet/compress](https://github.com/dsnet/compress) - brotli decompression, bzip2 writer.
-* [github.com/ronanh/intcomp](https://github.com/ronanh/intcomp) - Integer compression.
-* [github.com/spenczar/fpc](https://github.com/spenczar/fpc) - Float compression.
 
 # license
 
diff --git a/vendor/github.com/klauspost/compress/fse/compress.go b/vendor/github.com/klauspost/compress/fse/compress.go
index dac97e58..6f341914 100644
--- a/vendor/github.com/klauspost/compress/fse/compress.go
+++ b/vendor/github.com/klauspost/compress/fse/compress.go
@@ -146,51 +146,54 @@ func (s *Scratch) compress(src []byte) error {
 		c1.encodeZero(tt[src[ip-2]])
 		ip -= 2
 	}
-	src = src[:ip]
 
 	// Main compression loop.
 	switch {
 	case !s.zeroBits && s.actualTableLog <= 8:
 		// We can encode 4 symbols without requiring a flush.
 		// We do not need to check if any output is 0 bits.
-		for ; len(src) >= 4; src = src[:len(src)-4] {
+		for ip >= 4 {
 			s.bw.flush32()
-			v3, v2, v1, v0 := src[len(src)-4], src[len(src)-3], src[len(src)-2], src[len(src)-1]
+			v3, v2, v1, v0 := src[ip-4], src[ip-3], src[ip-2], src[ip-1]
 			c2.encode(tt[v0])
 			c1.encode(tt[v1])
 			c2.encode(tt[v2])
 			c1.encode(tt[v3])
+			ip -= 4
 		}
 	case !s.zeroBits:
 		// We do not need to check if any output is 0 bits.
-		for ; len(src) >= 4; src = src[:len(src)-4] {
+		for ip >= 4 {
 			s.bw.flush32()
-			v3, v2, v1, v0 := src[len(src)-4], src[len(src)-3], src[len(src)-2], src[len(src)-1]
+			v3, v2, v1, v0 := src[ip-4], src[ip-3], src[ip-2], src[ip-1]
 			c2.encode(tt[v0])
 			c1.encode(tt[v1])
 			s.bw.flush32()
 			c2.encode(tt[v2])
 			c1.encode(tt[v3])
+			ip -= 4
 		}
 	case s.actualTableLog <= 8:
 		// We can encode 4 symbols without requiring a flush
-		for ; len(src) >= 4; src = src[:len(src)-4] {
+		for ip >= 4 {
 			s.bw.flush32()
-			v3, v2, v1, v0 := src[len(src)-4], src[len(src)-3], src[len(src)-2], src[len(src)-1]
+			v3, v2, v1, v0 := src[ip-4], src[ip-3], src[ip-2], src[ip-1]
 			c2.encodeZero(tt[v0])
 			c1.encodeZero(tt[v1])
 			c2.encodeZero(tt[v2])
 			c1.encodeZero(tt[v3])
+			ip -= 4
 		}
 	default:
-		for ; len(src) >= 4; src = src[:len(src)-4] {
+		for ip >= 4 {
 			s.bw.flush32()
-			v3, v2, v1, v0 := src[len(src)-4], src[len(src)-3], src[len(src)-2], src[len(src)-1]
+			v3, v2, v1, v0 := src[ip-4], src[ip-3], src[ip-2], src[ip-1]
 			c2.encodeZero(tt[v0])
 			c1.encodeZero(tt[v1])
 			s.bw.flush32()
 			c2.encodeZero(tt[v2])
 			c1.encodeZero(tt[v3])
+			ip -= 4
 		}
 	}
 
@@ -456,17 +459,15 @@ func (s *Scratch) countSimple(in []byte) (max int) {
 	for _, v := range in {
 		s.count[v]++
 	}
-	m, symlen := uint32(0), s.symbolLen
+	m := uint32(0)
 	for i, v := range s.count[:] {
-		if v == 0 {
-			continue
-		}
 		if v > m {
 			m = v
 		}
-		symlen = uint16(i) + 1
+		if v > 0 {
+			s.symbolLen = uint16(i) + 1
+		}
 	}
-	s.symbolLen = symlen
 	return int(m)
 }
 
diff --git a/vendor/github.com/klauspost/compress/fse/decompress.go b/vendor/github.com/klauspost/compress/fse/decompress.go
index cc05d0f7..926f5f15 100644
--- a/vendor/github.com/klauspost/compress/fse/decompress.go
+++ b/vendor/github.com/klauspost/compress/fse/decompress.go
@@ -260,9 +260,7 @@ func (s *Scratch) buildDtable() error {
 // If the buffer is over-read an error is returned.
 func (s *Scratch) decompress() error {
 	br := &s.bits
-	if err := br.init(s.br.unread()); err != nil {
-		return err
-	}
+	br.init(s.br.unread())
 
 	var s1, s2 decoder
 	// Initialize and decode first state and symbol.
diff --git a/vendor/github.com/klauspost/compress/huff0/bitreader.go b/vendor/github.com/klauspost/compress/huff0/bitreader.go
index e36d9742..a4979e88 100644
--- a/vendor/github.com/klauspost/compress/huff0/bitreader.go
+++ b/vendor/github.com/klauspost/compress/huff0/bitreader.go
@@ -8,10 +8,115 @@ package huff0
 import (
 	"encoding/binary"
 	"errors"
-	"fmt"
 	"io"
 )
 
+// bitReader reads a bitstream in reverse.
+// The last set bit indicates the start of the stream and is used
+// for aligning the input.
+type bitReader struct {
+	in       []byte
+	off      uint // next byte to read is at in[off - 1]
+	value    uint64
+	bitsRead uint8
+}
+
+// init initializes and resets the bit reader.
+func (b *bitReader) init(in []byte) error {
+	if len(in) < 1 {
+		return errors.New("corrupt stream: too short")
+	}
+	b.in = in
+	b.off = uint(len(in))
+	// The highest bit of the last byte indicates where to start
+	v := in[len(in)-1]
+	if v == 0 {
+		return errors.New("corrupt stream, did not find end of stream")
+	}
+	b.bitsRead = 64
+	b.value = 0
+	if len(in) >= 8 {
+		b.fillFastStart()
+	} else {
+		b.fill()
+		b.fill()
+	}
+	b.bitsRead += 8 - uint8(highBit32(uint32(v)))
+	return nil
+}
+
+// peekBitsFast requires that at least one bit is requested every time.
+// There are no checks if the buffer is filled.
+func (b *bitReader) peekBitsFast(n uint8) uint16 {
+	const regMask = 64 - 1
+	v := uint16((b.value << (b.bitsRead & regMask)) >> ((regMask + 1 - n) & regMask))
+	return v
+}
+
+// fillFast() will make sure at least 32 bits are available.
+// There must be at least 4 bytes available.
+func (b *bitReader) fillFast() {
+	if b.bitsRead < 32 {
+		return
+	}
+
+	// 2 bounds checks.
+	v := b.in[b.off-4 : b.off]
+	v = v[:4]
+	low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
+	b.value = (b.value << 32) | uint64(low)
+	b.bitsRead -= 32
+	b.off -= 4
+}
+
+func (b *bitReader) advance(n uint8) {
+	b.bitsRead += n
+}
+
+// fillFastStart() assumes the bitreader is empty and there is at least 8 bytes to read.
+func (b *bitReader) fillFastStart() {
+	// Do single re-slice to avoid bounds checks.
+	b.value = binary.LittleEndian.Uint64(b.in[b.off-8:])
+	b.bitsRead = 0
+	b.off -= 8
+}
+
+// fill() will make sure at least 32 bits are available.
+func (b *bitReader) fill() {
+	if b.bitsRead < 32 {
+		return
+	}
+	if b.off > 4 {
+		v := b.in[b.off-4:]
+		v = v[:4]
+		low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
+		b.value = (b.value << 32) | uint64(low)
+		b.bitsRead -= 32
+		b.off -= 4
+		return
+	}
+	for b.off > 0 {
+		b.value = (b.value << 8) | uint64(b.in[b.off-1])
+		b.bitsRead -= 8
+		b.off--
+	}
+}
+
+// finished returns true if all bits have been read from the bit stream.
+func (b *bitReader) finished() bool {
+	return b.off == 0 && b.bitsRead >= 64
+}
+
+// close the bitstream and returns an error if out-of-buffer reads occurred.
+func (b *bitReader) close() error {
+	// Release reference.
+	b.in = nil
+	if b.bitsRead > 64 {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+
 // bitReader reads a bitstream in reverse.
 // The last set bit indicates the start of the stream and is used
 // for aligning the input.
@@ -67,6 +172,7 @@ func (b *bitReaderBytes) fillFast() {
 
 	// 2 bounds checks.
 	v := b.in[b.off-4 : b.off]
+	v = v[:4]
 	low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
 	b.value |= uint64(low) << (b.bitsRead - 32)
 	b.bitsRead -= 32
@@ -87,7 +193,8 @@ func (b *bitReaderBytes) fill() {
 		return
 	}
 	if b.off > 4 {
-		v := b.in[b.off-4 : b.off]
+		v := b.in[b.off-4:]
+		v = v[:4]
 		low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
 		b.value |= uint64(low) << (b.bitsRead - 32)
 		b.bitsRead -= 32
@@ -106,17 +213,10 @@ func (b *bitReaderBytes) finished() bool {
 	return b.off == 0 && b.bitsRead >= 64
 }
 
-func (b *bitReaderBytes) remaining() uint {
-	return b.off*8 + uint(64-b.bitsRead)
-}
-
 // close the bitstream and returns an error if out-of-buffer reads occurred.
 func (b *bitReaderBytes) close() error {
 	// Release reference.
 	b.in = nil
-	if b.remaining() > 0 {
-		return fmt.Errorf("corrupt input: %d bits remain on stream", b.remaining())
-	}
 	if b.bitsRead > 64 {
 		return io.ErrUnexpectedEOF
 	}
@@ -177,6 +277,7 @@ func (b *bitReaderShifted) fillFast() {
 
 	// 2 bounds checks.
 	v := b.in[b.off-4 : b.off]
+	v = v[:4]
 	low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
 	b.value |= uint64(low) << ((b.bitsRead - 32) & 63)
 	b.bitsRead -= 32
@@ -197,7 +298,8 @@ func (b *bitReaderShifted) fill() {
 		return
 	}
 	if b.off > 4 {
-		v := b.in[b.off-4 : b.off]
+		v := b.in[b.off-4:]
+		v = v[:4]
 		low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
 		b.value |= uint64(low) << ((b.bitsRead - 32) & 63)
 		b.bitsRead -= 32
@@ -211,17 +313,15 @@ func (b *bitReaderShifted) fill() {
 	}
 }
 
-func (b *bitReaderShifted) remaining() uint {
-	return b.off*8 + uint(64-b.bitsRead)
+// finished returns true if all bits have been read from the bit stream.
+func (b *bitReaderShifted) finished() bool {
+	return b.off == 0 && b.bitsRead >= 64
 }
 
 // close the bitstream and returns an error if out-of-buffer reads occurred.
 func (b *bitReaderShifted) close() error {
 	// Release reference.
 	b.in = nil
-	if b.remaining() > 0 {
-		return fmt.Errorf("corrupt input: %d bits remain on stream", b.remaining())
-	}
 	if b.bitsRead > 64 {
 		return io.ErrUnexpectedEOF
 	}
diff --git a/vendor/github.com/klauspost/compress/huff0/bitwriter.go b/vendor/github.com/klauspost/compress/huff0/bitwriter.go
index b4d7164e..6bce4e87 100644
--- a/vendor/github.com/klauspost/compress/huff0/bitwriter.go
+++ b/vendor/github.com/klauspost/compress/huff0/bitwriter.go
@@ -5,6 +5,8 @@
 
 package huff0
 
+import "fmt"
+
 // bitWriter will write bits.
 // First bit will be LSB of the first byte of output.
 type bitWriter struct {
@@ -13,6 +15,22 @@ type bitWriter struct {
 	out          []byte
 }
 
+// bitMask16 is bitmasks. Has extra to avoid bounds check.
+var bitMask16 = [32]uint16{
+	0, 1, 3, 7, 0xF, 0x1F,
+	0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF,
+	0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF, 0xFFFF,
+	0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+	0xFFFF, 0xFFFF} /* up to 16 bits */
+
+// addBits16NC will add up to 16 bits.
+// It will not check if there is space for them,
+// so the caller must ensure that it has flushed recently.
+func (b *bitWriter) addBits16NC(value uint16, bits uint8) {
+	b.bitContainer |= uint64(value&bitMask16[bits&31]) << (b.nBits & 63)
+	b.nBits += bits
+}
+
 // addBits16Clean will add up to 16 bits. value may not contain more set bits than indicated.
 // It will not check if there is space for them, so the caller must ensure that it has flushed recently.
 func (b *bitWriter) addBits16Clean(value uint16, bits uint8) {
@@ -52,20 +70,102 @@ func (b *bitWriter) encTwoSymbols(ct cTable, av, bv byte) {
 	b.nBits += encA.nBits + encB.nBits
 }
 
-// encFourSymbols adds up to 32 bits from four symbols.
+// addBits16ZeroNC will add up to 16 bits.
 // It will not check if there is space for them,
-// so the caller must ensure that b has been flushed recently.
-func (b *bitWriter) encFourSymbols(encA, encB, encC, encD cTableEntry) {
-	bitsA := encA.nBits
-	bitsB := bitsA + encB.nBits
-	bitsC := bitsB + encC.nBits
-	bitsD := bitsC + encD.nBits
-	combined := uint64(encA.val) |
-		(uint64(encB.val) << (bitsA & 63)) |
-		(uint64(encC.val) << (bitsB & 63)) |
-		(uint64(encD.val) << (bitsC & 63))
-	b.bitContainer |= combined << (b.nBits & 63)
-	b.nBits += bitsD
+// so the caller must ensure that it has flushed recently.
+// This is fastest if bits can be zero.
+func (b *bitWriter) addBits16ZeroNC(value uint16, bits uint8) {
+	if bits == 0 {
+		return
+	}
+	value <<= (16 - bits) & 15
+	value >>= (16 - bits) & 15
+	b.bitContainer |= uint64(value) << (b.nBits & 63)
+	b.nBits += bits
+}
+
+// flush will flush all pending full bytes.
+// There will be at least 56 bits available for writing when this has been called.
+// Using flush32 is faster, but leaves less space for writing.
+func (b *bitWriter) flush() {
+	v := b.nBits >> 3
+	switch v {
+	case 0:
+		return
+	case 1:
+		b.out = append(b.out,
+			byte(b.bitContainer),
+		)
+		b.bitContainer >>= 1 << 3
+	case 2:
+		b.out = append(b.out,
+			byte(b.bitContainer),
+			byte(b.bitContainer>>8),
+		)
+		b.bitContainer >>= 2 << 3
+	case 3:
+		b.out = append(b.out,
+			byte(b.bitContainer),
+			byte(b.bitContainer>>8),
+			byte(b.bitContainer>>16),
+		)
+		b.bitContainer >>= 3 << 3
+	case 4:
+		b.out = append(b.out,
+			byte(b.bitContainer),
+			byte(b.bitContainer>>8),
+			byte(b.bitContainer>>16),
+			byte(b.bitContainer>>24),
+		)
+		b.bitContainer >>= 4 << 3
+	case 5:
+		b.out = append(b.out,
+			byte(b.bitContainer),
+			byte(b.bitContainer>>8),
+			byte(b.bitContainer>>16),
+			byte(b.bitContainer>>24),
+			byte(b.bitContainer>>32),
+		)
+		b.bitContainer >>= 5 << 3
+	case 6:
+		b.out = append(b.out,
+			byte(b.bitContainer),
+			byte(b.bitContainer>>8),
+			byte(b.bitContainer>>16),
+			byte(b.bitContainer>>24),
+			byte(b.bitContainer>>32),
+			byte(b.bitContainer>>40),
+		)
+		b.bitContainer >>= 6 << 3
+	case 7:
+		b.out = append(b.out,
+			byte(b.bitContainer),
+			byte(b.bitContainer>>8),
+			byte(b.bitContainer>>16),
+			byte(b.bitContainer>>24),
+			byte(b.bitContainer>>32),
+			byte(b.bitContainer>>40),
+			byte(b.bitContainer>>48),
+		)
+		b.bitContainer >>= 7 << 3
+	case 8:
+		b.out = append(b.out,
+			byte(b.bitContainer),
+			byte(b.bitContainer>>8),
+			byte(b.bitContainer>>16),
+			byte(b.bitContainer>>24),
+			byte(b.bitContainer>>32),
+			byte(b.bitContainer>>40),
+			byte(b.bitContainer>>48),
+			byte(b.bitContainer>>56),
+		)
+		b.bitContainer = 0
+		b.nBits = 0
+		return
+	default:
+		panic(fmt.Errorf("bits (%d) > 64", b.nBits))
+	}
+	b.nBits &= 7
 }
 
 // flush32 will flush out, so there are at least 32 bits available for writing.
@@ -101,3 +201,10 @@ func (b *bitWriter) close() error {
 	b.flushAlign()
 	return nil
 }
+
+// reset and continue writing by appending to out.
+func (b *bitWriter) reset(out []byte) {
+	b.bitContainer = 0
+	b.nBits = 0
+	b.out = out
+}
diff --git a/vendor/github.com/klauspost/compress/huff0/bytereader.go b/vendor/github.com/klauspost/compress/huff0/bytereader.go
index 4dcab8d2..50bcdf6e 100644
--- a/vendor/github.com/klauspost/compress/huff0/bytereader.go
+++ b/vendor/github.com/klauspost/compress/huff0/bytereader.go
@@ -20,6 +20,11 @@ func (b *byteReader) init(in []byte) {
 	b.off = 0
 }
 
+// advance the stream b n bytes.
+func (b *byteReader) advance(n uint) {
+	b.off += int(n)
+}
+
 // Int32 returns a little endian int32 starting at current offset.
 func (b byteReader) Int32() int32 {
 	v3 := int32(b.b[b.off+3])
@@ -38,6 +43,11 @@ func (b byteReader) Uint32() uint32 {
 	return (v3 << 24) | (v2 << 16) | (v1 << 8) | v0
 }
 
+// unread returns the unread portion of the input.
+func (b byteReader) unread() []byte {
+	return b.b[b.off:]
+}
+
 // remain will return the number of bytes remaining.
 func (b byteReader) remain() int {
 	return len(b.b) - b.off
diff --git a/vendor/github.com/klauspost/compress/huff0/compress.go b/vendor/github.com/klauspost/compress/huff0/compress.go
index 4ee4fa18..8323dc05 100644
--- a/vendor/github.com/klauspost/compress/huff0/compress.go
+++ b/vendor/github.com/klauspost/compress/huff0/compress.go
@@ -2,7 +2,6 @@ package huff0
 
 import (
 	"fmt"
-	"math"
 	"runtime"
 	"sync"
 )
@@ -248,7 +247,8 @@ func (s *Scratch) compress1xDo(dst, src []byte) ([]byte, error) {
 			tmp := src[n : n+4]
 			// tmp should be len 4
 			bw.flush32()
-			bw.encFourSymbols(cTable[tmp[3]], cTable[tmp[2]], cTable[tmp[1]], cTable[tmp[0]])
+			bw.encTwoSymbols(cTable, tmp[3], tmp[2])
+			bw.encTwoSymbols(cTable, tmp[1], tmp[0])
 		}
 	} else {
 		for ; n >= 0; n -= 4 {
@@ -289,10 +289,6 @@ func (s *Scratch) compress4X(src []byte) ([]byte, error) {
 		if err != nil {
 			return nil, err
 		}
-		if len(s.Out)-idx > math.MaxUint16 {
-			// We cannot store the size in the jump table
-			return nil, ErrIncompressible
-		}
 		// Write compressed length as little endian before block.
 		if i < 3 {
 			// Last length is not written.
@@ -336,10 +332,6 @@ func (s *Scratch) compress4Xp(src []byte) ([]byte, error) {
 			return nil, errs[i]
 		}
 		o := s.tmpOut[i]
-		if len(o) > math.MaxUint16 {
-			// We cannot store the size in the jump table
-			return nil, ErrIncompressible
-		}
 		// Write compressed length as little endian before block.
 		if i < 3 {
 			// Last length is not written.
@@ -364,29 +356,29 @@ func (s *Scratch) countSimple(in []byte) (max int, reuse bool) {
 	m := uint32(0)
 	if len(s.prevTable) > 0 {
 		for i, v := range s.count[:] {
-			if v == 0 {
-				continue
-			}
 			if v > m {
 				m = v
 			}
-			s.symbolLen = uint16(i) + 1
-			if i >= len(s.prevTable) {
-				reuse = false
-			} else if s.prevTable[i].nBits == 0 {
-				reuse = false
+			if v > 0 {
+				s.symbolLen = uint16(i) + 1
+				if i >= len(s.prevTable) {
+					reuse = false
+				} else {
+					if s.prevTable[i].nBits == 0 {
+						reuse = false
+					}
+				}
 			}
 		}
 		return int(m), reuse
 	}
 	for i, v := range s.count[:] {
-		if v == 0 {
-			continue
-		}
 		if v > m {
 			m = v
 		}
-		s.symbolLen = uint16(i) + 1
+		if v > 0 {
+			s.symbolLen = uint16(i) + 1
+		}
 	}
 	return int(m), false
 }
@@ -403,7 +395,6 @@ func (s *Scratch) canUseTable(c cTable) bool {
 	return true
 }
 
-//lint:ignore U1000 used for debugging
 func (s *Scratch) validateTable(c cTable) bool {
 	if len(c) < int(s.symbolLen) {
 		return false
@@ -483,35 +474,34 @@ func (s *Scratch) buildCTable() error {
 	// Different from reference implementation.
 	huffNode0 := s.nodes[0 : huffNodesLen+1]
 
-	for huffNode[nonNullRank].count() == 0 {
+	for huffNode[nonNullRank].count == 0 {
 		nonNullRank--
 	}
 
 	lowS := int16(nonNullRank)
 	nodeRoot := nodeNb + lowS - 1
 	lowN := nodeNb
-	huffNode[nodeNb].setCount(huffNode[lowS].count() + huffNode[lowS-1].count())
-	huffNode[lowS].setParent(nodeNb)
-	huffNode[lowS-1].setParent(nodeNb)
+	huffNode[nodeNb].count = huffNode[lowS].count + huffNode[lowS-1].count
+	huffNode[lowS].parent, huffNode[lowS-1].parent = uint16(nodeNb), uint16(nodeNb)
 	nodeNb++
 	lowS -= 2
 	for n := nodeNb; n <= nodeRoot; n++ {
-		huffNode[n].setCount(1 << 30)
+		huffNode[n].count = 1 << 30
 	}
 	// fake entry, strong barrier
-	huffNode0[0].setCount(1 << 31)
+	huffNode0[0].count = 1 << 31
 
 	// create parents
 	for nodeNb <= nodeRoot {
 		var n1, n2 int16
-		if huffNode0[lowS+1].count() < huffNode0[lowN+1].count() {
+		if huffNode0[lowS+1].count < huffNode0[lowN+1].count {
 			n1 = lowS
 			lowS--
 		} else {
 			n1 = lowN
 			lowN++
 		}
-		if huffNode0[lowS+1].count() < huffNode0[lowN+1].count() {
+		if huffNode0[lowS+1].count < huffNode0[lowN+1].count {
 			n2 = lowS
 			lowS--
 		} else {
@@ -519,19 +509,18 @@ func (s *Scratch) buildCTable() error {
 			lowN++
 		}
 
-		huffNode[nodeNb].setCount(huffNode0[n1+1].count() + huffNode0[n2+1].count())
-		huffNode0[n1+1].setParent(nodeNb)
-		huffNode0[n2+1].setParent(nodeNb)
+		huffNode[nodeNb].count = huffNode0[n1+1].count + huffNode0[n2+1].count
+		huffNode0[n1+1].parent, huffNode0[n2+1].parent = uint16(nodeNb), uint16(nodeNb)
 		nodeNb++
 	}
 
 	// distribute weights (unlimited tree height)
-	huffNode[nodeRoot].setNbBits(0)
+	huffNode[nodeRoot].nbBits = 0
 	for n := nodeRoot - 1; n >= startNode; n-- {
-		huffNode[n].setNbBits(huffNode[huffNode[n].parent()].nbBits() + 1)
+		huffNode[n].nbBits = huffNode[huffNode[n].parent].nbBits + 1
 	}
 	for n := uint16(0); n <= nonNullRank; n++ {
-		huffNode[n].setNbBits(huffNode[huffNode[n].parent()].nbBits() + 1)
+		huffNode[n].nbBits = huffNode[huffNode[n].parent].nbBits + 1
 	}
 	s.actualTableLog = s.setMaxHeight(int(nonNullRank))
 	maxNbBits := s.actualTableLog
@@ -543,7 +532,7 @@ func (s *Scratch) buildCTable() error {
 	var nbPerRank [tableLogMax + 1]uint16
 	var valPerRank [16]uint16
 	for _, v := range huffNode[:nonNullRank+1] {
-		nbPerRank[v.nbBits()]++
+		nbPerRank[v.nbBits]++
 	}
 	// determine stating value per rank
 	{
@@ -558,7 +547,7 @@ func (s *Scratch) buildCTable() error {
 
 	// push nbBits per symbol, symbol order
 	for _, v := range huffNode[:nonNullRank+1] {
-		s.cTable[v.symbol()].nBits = v.nbBits()
+		s.cTable[v.symbol].nBits = v.nbBits
 	}
 
 	// assign value within rank, symbol order
@@ -604,12 +593,12 @@ func (s *Scratch) huffSort() {
 		pos := rank[r].current
 		rank[r].current++
 		prev := nodes[(pos-1)&huffNodesMask]
-		for pos > rank[r].base && c > prev.count() {
+		for pos > rank[r].base && c > prev.count {
 			nodes[pos&huffNodesMask] = prev
 			pos--
 			prev = nodes[(pos-1)&huffNodesMask]
 		}
-		nodes[pos&huffNodesMask] = makeNodeElt(c, byte(n))
+		nodes[pos&huffNodesMask] = nodeElt{count: c, symbol: byte(n)}
 	}
 }
 
@@ -618,7 +607,7 @@ func (s *Scratch) setMaxHeight(lastNonNull int) uint8 {
 	huffNode := s.nodes[1 : huffNodesLen+1]
 	//huffNode = huffNode[: huffNodesLen]
 
-	largestBits := huffNode[lastNonNull].nbBits()
+	largestBits := huffNode[lastNonNull].nbBits
 
 	// early exit : no elt > maxNbBits
 	if largestBits <= maxNbBits {
@@ -628,14 +617,14 @@ func (s *Scratch) setMaxHeight(lastNonNull int) uint8 {
 	baseCost := int(1) << (largestBits - maxNbBits)
 	n := uint32(lastNonNull)
 
-	for huffNode[n].nbBits() > maxNbBits {
-		totalCost += baseCost - (1 << (largestBits - huffNode[n].nbBits()))
-		huffNode[n].setNbBits(maxNbBits)
+	for huffNode[n].nbBits > maxNbBits {
+		totalCost += baseCost - (1 << (largestBits - huffNode[n].nbBits))
+		huffNode[n].nbBits = maxNbBits
 		n--
 	}
 	// n stops at huffNode[n].nbBits <= maxNbBits
 
-	for huffNode[n].nbBits() == maxNbBits {
+	for huffNode[n].nbBits == maxNbBits {
 		n--
 	}
 	// n end at index of smallest symbol using < maxNbBits
@@ -656,10 +645,10 @@ func (s *Scratch) setMaxHeight(lastNonNull int) uint8 {
 		{
 			currentNbBits := maxNbBits
 			for pos := int(n); pos >= 0; pos-- {
-				if huffNode[pos].nbBits() >= currentNbBits {
+				if huffNode[pos].nbBits >= currentNbBits {
 					continue
 				}
-				currentNbBits = huffNode[pos].nbBits() // < maxNbBits
+				currentNbBits = huffNode[pos].nbBits // < maxNbBits
 				rankLast[maxNbBits-currentNbBits] = uint32(pos)
 			}
 		}
@@ -676,8 +665,8 @@ func (s *Scratch) setMaxHeight(lastNonNull int) uint8 {
 				if lowPos == noSymbol {
 					break
 				}
-				highTotal := huffNode[highPos].count()
-				lowTotal := 2 * huffNode[lowPos].count()
+				highTotal := huffNode[highPos].count
+				lowTotal := 2 * huffNode[lowPos].count
 				if highTotal <= lowTotal {
 					break
 				}
@@ -693,14 +682,13 @@ func (s *Scratch) setMaxHeight(lastNonNull int) uint8 {
 				// this rank is no longer empty
 				rankLast[nBitsToDecrease-1] = rankLast[nBitsToDecrease]
 			}
-			huffNode[rankLast[nBitsToDecrease]].setNbBits(1 +
-				huffNode[rankLast[nBitsToDecrease]].nbBits())
+			huffNode[rankLast[nBitsToDecrease]].nbBits++
 			if rankLast[nBitsToDecrease] == 0 {
 				/* special case, reached largest symbol */
 				rankLast[nBitsToDecrease] = noSymbol
 			} else {
 				rankLast[nBitsToDecrease]--
-				if huffNode[rankLast[nBitsToDecrease]].nbBits() != maxNbBits-nBitsToDecrease {
+				if huffNode[rankLast[nBitsToDecrease]].nbBits != maxNbBits-nBitsToDecrease {
 					rankLast[nBitsToDecrease] = noSymbol /* this rank is now empty */
 				}
 			}
@@ -708,15 +696,15 @@ func (s *Scratch) setMaxHeight(lastNonNull int) uint8 {
 
 		for totalCost < 0 { /* Sometimes, cost correction overshoot */
 			if rankLast[1] == noSymbol { /* special case : no rank 1 symbol (using maxNbBits-1); let's create one from largest rank 0 (using maxNbBits) */
-				for huffNode[n].nbBits() == maxNbBits {
+				for huffNode[n].nbBits == maxNbBits {
 					n--
 				}
-				huffNode[n+1].setNbBits(huffNode[n+1].nbBits() - 1)
+				huffNode[n+1].nbBits--
 				rankLast[1] = n + 1
 				totalCost++
 				continue
 			}
-			huffNode[rankLast[1]+1].setNbBits(huffNode[rankLast[1]+1].nbBits() - 1)
+			huffNode[rankLast[1]+1].nbBits--
 			rankLast[1]++
 			totalCost++
 		}
@@ -724,26 +712,9 @@ func (s *Scratch) setMaxHeight(lastNonNull int) uint8 {
 	return maxNbBits
 }
 
-// A nodeElt is the fields
-//
-//	count  uint32
-//	parent uint16
-//	symbol byte
-//	nbBits uint8
-//
-// in some order, all squashed into an integer so that the compiler
-// always loads and stores entire nodeElts instead of separate fields.
-type nodeElt uint64
-
-func makeNodeElt(count uint32, symbol byte) nodeElt {
-	return nodeElt(count) | nodeElt(symbol)<<48
+type nodeElt struct {
+	count  uint32
+	parent uint16
+	symbol byte
+	nbBits uint8
 }
-
-func (e *nodeElt) count() uint32  { return uint32(*e) }
-func (e *nodeElt) parent() uint16 { return uint16(*e >> 32) }
-func (e *nodeElt) symbol() byte   { return byte(*e >> 48) }
-func (e *nodeElt) nbBits() uint8  { return uint8(*e >> 56) }
-
-func (e *nodeElt) setCount(c uint32) { *e = (*e)&0xffffffff00000000 | nodeElt(c) }
-func (e *nodeElt) setParent(p int16) { *e = (*e)&0xffff0000ffffffff | nodeElt(uint16(p))<<32 }
-func (e *nodeElt) setNbBits(n uint8) { *e = (*e)&0x00ffffffffffffff | nodeElt(n)<<56 }
diff --git a/vendor/github.com/klauspost/compress/huff0/decompress.go b/vendor/github.com/klauspost/compress/huff0/decompress.go
index 54bd08b2..9b7cc8e9 100644
--- a/vendor/github.com/klauspost/compress/huff0/decompress.go
+++ b/vendor/github.com/klauspost/compress/huff0/decompress.go
@@ -4,13 +4,13 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"sync"
 
 	"github.com/klauspost/compress/fse"
 )
 
 type dTable struct {
 	single []dEntrySingle
+	double []dEntryDouble
 }
 
 // single-symbols decoding
@@ -18,6 +18,13 @@ type dEntrySingle struct {
 	entry uint16
 }
 
+// double-symbols decoding
+type dEntryDouble struct {
+	seq   uint16
+	nBits uint8
+	len   uint8
+}
+
 // Uses special code for all tables that are < 8 bits.
 const use8BitTables = true
 
@@ -27,7 +34,7 @@ const use8BitTables = true
 // If no Scratch is provided a new one is allocated.
 // The returned Scratch can be used for encoding or decoding input using this table.
 func ReadTable(in []byte, s *Scratch) (s2 *Scratch, remain []byte, err error) {
-	s, err = s.prepare(nil)
+	s, err = s.prepare(in)
 	if err != nil {
 		return s, nil, err
 	}
@@ -61,7 +68,7 @@ func ReadTable(in []byte, s *Scratch) (s2 *Scratch, remain []byte, err error) {
 		b, err := fse.Decompress(in[:iSize], s.fse)
 		s.fse.Out = nil
 		if err != nil {
-			return s, nil, fmt.Errorf("fse decompress returned: %w", err)
+			return s, nil, err
 		}
 		if len(b) > 255 {
 			return s, nil, errors.New("corrupt input: output table too large")
@@ -209,7 +216,6 @@ func (s *Scratch) Decoder() *Decoder {
 	return &Decoder{
 		dt:             s.dt,
 		actualTableLog: s.actualTableLog,
-		bufs:           &s.decPool,
 	}
 }
 
@@ -217,15 +223,103 @@ func (s *Scratch) Decoder() *Decoder {
 type Decoder struct {
 	dt             dTable
 	actualTableLog uint8
-	bufs           *sync.Pool
 }
 
-func (d *Decoder) buffer() *[4][256]byte {
-	buf, ok := d.bufs.Get().(*[4][256]byte)
-	if ok {
-		return buf
+// Decompress1X will decompress a 1X encoded stream.
+// The cap of the output buffer will be the maximum decompressed size.
+// The length of the supplied input must match the end of a block exactly.
+func (d *Decoder) Decompress1X(dst, src []byte) ([]byte, error) {
+	if len(d.dt.single) == 0 {
+		return nil, errors.New("no table loaded")
+	}
+	if use8BitTables && d.actualTableLog <= 8 {
+		return d.decompress1X8Bit(dst, src)
+	}
+	var br bitReaderShifted
+	err := br.init(src)
+	if err != nil {
+		return dst, err
+	}
+	maxDecodedSize := cap(dst)
+	dst = dst[:0]
+
+	// Avoid bounds check by always having full sized table.
+	const tlSize = 1 << tableLogMax
+	const tlMask = tlSize - 1
+	dt := d.dt.single[:tlSize]
+
+	// Use temp table to avoid bound checks/append penalty.
+	var buf [256]byte
+	var off uint8
+
+	for br.off >= 8 {
+		br.fillFast()
+		v := dt[br.peekBitsFast(d.actualTableLog)&tlMask]
+		br.advance(uint8(v.entry))
+		buf[off+0] = uint8(v.entry >> 8)
+
+		v = dt[br.peekBitsFast(d.actualTableLog)&tlMask]
+		br.advance(uint8(v.entry))
+		buf[off+1] = uint8(v.entry >> 8)
+
+		// Refill
+		br.fillFast()
+
+		v = dt[br.peekBitsFast(d.actualTableLog)&tlMask]
+		br.advance(uint8(v.entry))
+		buf[off+2] = uint8(v.entry >> 8)
+
+		v = dt[br.peekBitsFast(d.actualTableLog)&tlMask]
+		br.advance(uint8(v.entry))
+		buf[off+3] = uint8(v.entry >> 8)
+
+		off += 4
+		if off == 0 {
+			if len(dst)+256 > maxDecodedSize {
+				br.close()
+				return nil, ErrMaxDecodedSizeExceeded
+			}
+			dst = append(dst, buf[:]...)
+		}
+	}
+
+	if len(dst)+int(off) > maxDecodedSize {
+		br.close()
+		return nil, ErrMaxDecodedSizeExceeded
+	}
+	dst = append(dst, buf[:off]...)
+
+	// br < 8, so uint8 is fine
+	bitsLeft := uint8(br.off)*8 + 64 - br.bitsRead
+	for bitsLeft > 0 {
+		br.fill()
+		if false && br.bitsRead >= 32 {
+			if br.off >= 4 {
+				v := br.in[br.off-4:]
+				v = v[:4]
+				low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
+				br.value = (br.value << 32) | uint64(low)
+				br.bitsRead -= 32
+				br.off -= 4
+			} else {
+				for br.off > 0 {
+					br.value = (br.value << 8) | uint64(br.in[br.off-1])
+					br.bitsRead -= 8
+					br.off--
+				}
+			}
+		}
+		if len(dst) >= maxDecodedSize {
+			br.close()
+			return nil, ErrMaxDecodedSizeExceeded
+		}
+		v := d.dt.single[br.peekBitsFast(d.actualTableLog)&tlMask]
+		nBits := uint8(v.entry)
+		br.advance(nBits)
+		bitsLeft -= nBits
+		dst = append(dst, uint8(v.entry>>8))
 	}
-	return &[4][256]byte{}
+	return dst, br.close()
 }
 
 // decompress1X8Bit will decompress a 1X encoded stream with tablelog <= 8.
@@ -247,13 +341,12 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 	dt := d.dt.single[:256]
 
 	// Use temp table to avoid bound checks/append penalty.
-	bufs := d.buffer()
-	buf := &bufs[0]
+	var buf [256]byte
 	var off uint8
 
 	switch d.actualTableLog {
 	case 8:
-		const shift = 0
+		const shift = 8 - 8
 		for br.off >= 4 {
 			br.fillFast()
 			v := dt[uint8(br.value>>(56+shift))]
@@ -276,7 +369,6 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			if off == 0 {
 				if len(dst)+256 > maxDecodedSize {
 					br.close()
-					d.bufs.Put(bufs)
 					return nil, ErrMaxDecodedSizeExceeded
 				}
 				dst = append(dst, buf[:]...)
@@ -306,7 +398,6 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			if off == 0 {
 				if len(dst)+256 > maxDecodedSize {
 					br.close()
-					d.bufs.Put(bufs)
 					return nil, ErrMaxDecodedSizeExceeded
 				}
 				dst = append(dst, buf[:]...)
@@ -335,7 +426,6 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			off += 4
 			if off == 0 {
 				if len(dst)+256 > maxDecodedSize {
-					d.bufs.Put(bufs)
 					br.close()
 					return nil, ErrMaxDecodedSizeExceeded
 				}
@@ -365,7 +455,6 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			off += 4
 			if off == 0 {
 				if len(dst)+256 > maxDecodedSize {
-					d.bufs.Put(bufs)
 					br.close()
 					return nil, ErrMaxDecodedSizeExceeded
 				}
@@ -395,7 +484,6 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			off += 4
 			if off == 0 {
 				if len(dst)+256 > maxDecodedSize {
-					d.bufs.Put(bufs)
 					br.close()
 					return nil, ErrMaxDecodedSizeExceeded
 				}
@@ -425,7 +513,6 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			off += 4
 			if off == 0 {
 				if len(dst)+256 > maxDecodedSize {
-					d.bufs.Put(bufs)
 					br.close()
 					return nil, ErrMaxDecodedSizeExceeded
 				}
@@ -455,7 +542,6 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			off += 4
 			if off == 0 {
 				if len(dst)+256 > maxDecodedSize {
-					d.bufs.Put(bufs)
 					br.close()
 					return nil, ErrMaxDecodedSizeExceeded
 				}
@@ -485,7 +571,6 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			off += 4
 			if off == 0 {
 				if len(dst)+256 > maxDecodedSize {
-					d.bufs.Put(bufs)
 					br.close()
 					return nil, ErrMaxDecodedSizeExceeded
 				}
@@ -493,12 +578,10 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 			}
 		}
 	default:
-		d.bufs.Put(bufs)
 		return nil, fmt.Errorf("invalid tablelog: %d", d.actualTableLog)
 	}
 
 	if len(dst)+int(off) > maxDecodedSize {
-		d.bufs.Put(bufs)
 		br.close()
 		return nil, ErrMaxDecodedSizeExceeded
 	}
@@ -518,7 +601,6 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 		}
 		if len(dst) >= maxDecodedSize {
 			br.close()
-			d.bufs.Put(bufs)
 			return nil, ErrMaxDecodedSizeExceeded
 		}
 		v := dt[br.peekByteFast()>>shift]
@@ -527,7 +609,6 @@ func (d *Decoder) decompress1X8Bit(dst, src []byte) ([]byte, error) {
 		bitsLeft -= int8(nBits)
 		dst = append(dst, uint8(v.entry>>8))
 	}
-	d.bufs.Put(bufs)
 	return dst, br.close()
 }
 
@@ -547,8 +628,7 @@ func (d *Decoder) decompress1X8BitExactly(dst, src []byte) ([]byte, error) {
 	dt := d.dt.single[:256]
 
 	// Use temp table to avoid bound checks/append penalty.
-	bufs := d.buffer()
-	buf := &bufs[0]
+	var buf [256]byte
 	var off uint8
 
 	const shift = 56
@@ -575,7 +655,6 @@ func (d *Decoder) decompress1X8BitExactly(dst, src []byte) ([]byte, error) {
 		off += 4
 		if off == 0 {
 			if len(dst)+256 > maxDecodedSize {
-				d.bufs.Put(bufs)
 				br.close()
 				return nil, ErrMaxDecodedSizeExceeded
 			}
@@ -584,7 +663,6 @@ func (d *Decoder) decompress1X8BitExactly(dst, src []byte) ([]byte, error) {
 	}
 
 	if len(dst)+int(off) > maxDecodedSize {
-		d.bufs.Put(bufs)
 		br.close()
 		return nil, ErrMaxDecodedSizeExceeded
 	}
@@ -601,7 +679,6 @@ func (d *Decoder) decompress1X8BitExactly(dst, src []byte) ([]byte, error) {
 			}
 		}
 		if len(dst) >= maxDecodedSize {
-			d.bufs.Put(bufs)
 			br.close()
 			return nil, ErrMaxDecodedSizeExceeded
 		}
@@ -611,10 +688,199 @@ func (d *Decoder) decompress1X8BitExactly(dst, src []byte) ([]byte, error) {
 		bitsLeft -= int8(nBits)
 		dst = append(dst, uint8(v.entry>>8))
 	}
-	d.bufs.Put(bufs)
 	return dst, br.close()
 }
 
+// Decompress4X will decompress a 4X encoded stream.
+// The length of the supplied input must match the end of a block exactly.
+// The *capacity* of the dst slice must match the destination size of
+// the uncompressed data exactly.
+func (d *Decoder) Decompress4X(dst, src []byte) ([]byte, error) {
+	if len(d.dt.single) == 0 {
+		return nil, errors.New("no table loaded")
+	}
+	if len(src) < 6+(4*1) {
+		return nil, errors.New("input too small")
+	}
+	if use8BitTables && d.actualTableLog <= 8 {
+		return d.decompress4X8bit(dst, src)
+	}
+
+	var br [4]bitReaderShifted
+	start := 6
+	for i := 0; i < 3; i++ {
+		length := int(src[i*2]) | (int(src[i*2+1]) << 8)
+		if start+length >= len(src) {
+			return nil, errors.New("truncated input (or invalid offset)")
+		}
+		err := br[i].init(src[start : start+length])
+		if err != nil {
+			return nil, err
+		}
+		start += length
+	}
+	err := br[3].init(src[start:])
+	if err != nil {
+		return nil, err
+	}
+
+	// destination, offset to match first output
+	dstSize := cap(dst)
+	dst = dst[:dstSize]
+	out := dst
+	dstEvery := (dstSize + 3) / 4
+
+	const tlSize = 1 << tableLogMax
+	const tlMask = tlSize - 1
+	single := d.dt.single[:tlSize]
+
+	// Use temp table to avoid bound checks/append penalty.
+	var buf [256]byte
+	var off uint8
+	var decoded int
+
+	// Decode 2 values from each decoder/loop.
+	const bufoff = 256 / 4
+	for {
+		if br[0].off < 4 || br[1].off < 4 || br[2].off < 4 || br[3].off < 4 {
+			break
+		}
+
+		{
+			const stream = 0
+			const stream2 = 1
+			br[stream].fillFast()
+			br[stream2].fillFast()
+
+			val := br[stream].peekBitsFast(d.actualTableLog)
+			v := single[val&tlMask]
+			br[stream].advance(uint8(v.entry))
+			buf[off+bufoff*stream] = uint8(v.entry >> 8)
+
+			val2 := br[stream2].peekBitsFast(d.actualTableLog)
+			v2 := single[val2&tlMask]
+			br[stream2].advance(uint8(v2.entry))
+			buf[off+bufoff*stream2] = uint8(v2.entry >> 8)
+
+			val = br[stream].peekBitsFast(d.actualTableLog)
+			v = single[val&tlMask]
+			br[stream].advance(uint8(v.entry))
+			buf[off+bufoff*stream+1] = uint8(v.entry >> 8)
+
+			val2 = br[stream2].peekBitsFast(d.actualTableLog)
+			v2 = single[val2&tlMask]
+			br[stream2].advance(uint8(v2.entry))
+			buf[off+bufoff*stream2+1] = uint8(v2.entry >> 8)
+		}
+
+		{
+			const stream = 2
+			const stream2 = 3
+			br[stream].fillFast()
+			br[stream2].fillFast()
+
+			val := br[stream].peekBitsFast(d.actualTableLog)
+			v := single[val&tlMask]
+			br[stream].advance(uint8(v.entry))
+			buf[off+bufoff*stream] = uint8(v.entry >> 8)
+
+			val2 := br[stream2].peekBitsFast(d.actualTableLog)
+			v2 := single[val2&tlMask]
+			br[stream2].advance(uint8(v2.entry))
+			buf[off+bufoff*stream2] = uint8(v2.entry >> 8)
+
+			val = br[stream].peekBitsFast(d.actualTableLog)
+			v = single[val&tlMask]
+			br[stream].advance(uint8(v.entry))
+			buf[off+bufoff*stream+1] = uint8(v.entry >> 8)
+
+			val2 = br[stream2].peekBitsFast(d.actualTableLog)
+			v2 = single[val2&tlMask]
+			br[stream2].advance(uint8(v2.entry))
+			buf[off+bufoff*stream2+1] = uint8(v2.entry >> 8)
+		}
+
+		off += 2
+
+		if off == bufoff {
+			if bufoff > dstEvery {
+				return nil, errors.New("corruption detected: stream overrun 1")
+			}
+			copy(out, buf[:bufoff])
+			copy(out[dstEvery:], buf[bufoff:bufoff*2])
+			copy(out[dstEvery*2:], buf[bufoff*2:bufoff*3])
+			copy(out[dstEvery*3:], buf[bufoff*3:bufoff*4])
+			off = 0
+			out = out[bufoff:]
+			decoded += 256
+			// There must at least be 3 buffers left.
+			if len(out) < dstEvery*3 {
+				return nil, errors.New("corruption detected: stream overrun 2")
+			}
+		}
+	}
+	if off > 0 {
+		ioff := int(off)
+		if len(out) < dstEvery*3+ioff {
+			return nil, errors.New("corruption detected: stream overrun 3")
+		}
+		copy(out, buf[:off])
+		copy(out[dstEvery:dstEvery+ioff], buf[bufoff:bufoff*2])
+		copy(out[dstEvery*2:dstEvery*2+ioff], buf[bufoff*2:bufoff*3])
+		copy(out[dstEvery*3:dstEvery*3+ioff], buf[bufoff*3:bufoff*4])
+		decoded += int(off) * 4
+		out = out[off:]
+	}
+
+	// Decode remaining.
+	for i := range br {
+		offset := dstEvery * i
+		br := &br[i]
+		bitsLeft := br.off*8 + uint(64-br.bitsRead)
+		for bitsLeft > 0 {
+			br.fill()
+			if false && br.bitsRead >= 32 {
+				if br.off >= 4 {
+					v := br.in[br.off-4:]
+					v = v[:4]
+					low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
+					br.value = (br.value << 32) | uint64(low)
+					br.bitsRead -= 32
+					br.off -= 4
+				} else {
+					for br.off > 0 {
+						br.value = (br.value << 8) | uint64(br.in[br.off-1])
+						br.bitsRead -= 8
+						br.off--
+					}
+				}
+			}
+			// end inline...
+			if offset >= len(out) {
+				return nil, errors.New("corruption detected: stream overrun 4")
+			}
+
+			// Read value and increment offset.
+			val := br.peekBitsFast(d.actualTableLog)
+			v := single[val&tlMask].entry
+			nBits := uint8(v)
+			br.advance(nBits)
+			bitsLeft -= uint(nBits)
+			out[offset] = uint8(v >> 8)
+			offset++
+		}
+		decoded += offset - dstEvery*i
+		err = br.close()
+		if err != nil {
+			return nil, err
+		}
+	}
+	if dstSize != decoded {
+		return nil, errors.New("corruption detected: short output block")
+	}
+	return dst, nil
+}
+
 // Decompress4X will decompress a 4X encoded stream.
 // The length of the supplied input must match the end of a block exactly.
 // The *capacity* of the dst slice must match the destination size of
@@ -648,18 +914,18 @@ func (d *Decoder) decompress4X8bit(dst, src []byte) ([]byte, error) {
 	out := dst
 	dstEvery := (dstSize + 3) / 4
 
-	shift := (56 + (8 - d.actualTableLog)) & 63
+	shift := (8 - d.actualTableLog) & 7
 
 	const tlSize = 1 << 8
 	single := d.dt.single[:tlSize]
 
 	// Use temp table to avoid bound checks/append penalty.
-	buf := d.buffer()
+	var buf [256]byte
 	var off uint8
 	var decoded int
 
 	// Decode 4 values from each decoder/loop.
-	const bufoff = 256
+	const bufoff = 256 / 4
 	for {
 		if br[0].off < 4 || br[1].off < 4 || br[2].off < 4 || br[3].off < 4 {
 			break
@@ -669,144 +935,120 @@ func (d *Decoder) decompress4X8bit(dst, src []byte) ([]byte, error) {
 			// Interleave 2 decodes.
 			const stream = 0
 			const stream2 = 1
-			br1 := &br[stream]
-			br2 := &br[stream2]
-			br1.fillFast()
-			br2.fillFast()
-
-			v := single[uint8(br1.value>>shift)].entry
-			v2 := single[uint8(br2.value>>shift)].entry
-			br1.bitsRead += uint8(v)
-			br1.value <<= v & 63
-			br2.bitsRead += uint8(v2)
-			br2.value <<= v2 & 63
-			buf[stream][off] = uint8(v >> 8)
-			buf[stream2][off] = uint8(v2 >> 8)
-
-			v = single[uint8(br1.value>>shift)].entry
-			v2 = single[uint8(br2.value>>shift)].entry
-			br1.bitsRead += uint8(v)
-			br1.value <<= v & 63
-			br2.bitsRead += uint8(v2)
-			br2.value <<= v2 & 63
-			buf[stream][off+1] = uint8(v >> 8)
-			buf[stream2][off+1] = uint8(v2 >> 8)
-
-			v = single[uint8(br1.value>>shift)].entry
-			v2 = single[uint8(br2.value>>shift)].entry
-			br1.bitsRead += uint8(v)
-			br1.value <<= v & 63
-			br2.bitsRead += uint8(v2)
-			br2.value <<= v2 & 63
-			buf[stream][off+2] = uint8(v >> 8)
-			buf[stream2][off+2] = uint8(v2 >> 8)
-
-			v = single[uint8(br1.value>>shift)].entry
-			v2 = single[uint8(br2.value>>shift)].entry
-			br1.bitsRead += uint8(v)
-			br1.value <<= v & 63
-			br2.bitsRead += uint8(v2)
-			br2.value <<= v2 & 63
-			buf[stream][off+3] = uint8(v >> 8)
-			buf[stream2][off+3] = uint8(v2 >> 8)
+			br[stream].fillFast()
+			br[stream2].fillFast()
+
+			v := single[br[stream].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream] = uint8(v >> 8)
+			br[stream].advance(uint8(v))
+
+			v2 := single[br[stream2].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream2] = uint8(v2 >> 8)
+			br[stream2].advance(uint8(v2))
+
+			v = single[br[stream].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream+1] = uint8(v >> 8)
+			br[stream].advance(uint8(v))
+
+			v2 = single[br[stream2].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream2+1] = uint8(v2 >> 8)
+			br[stream2].advance(uint8(v2))
+
+			v = single[br[stream].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream+2] = uint8(v >> 8)
+			br[stream].advance(uint8(v))
+
+			v2 = single[br[stream2].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream2+2] = uint8(v2 >> 8)
+			br[stream2].advance(uint8(v2))
+
+			v = single[br[stream].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream+3] = uint8(v >> 8)
+			br[stream].advance(uint8(v))
+
+			v2 = single[br[stream2].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream2+3] = uint8(v2 >> 8)
+			br[stream2].advance(uint8(v2))
 		}
 
 		{
 			const stream = 2
 			const stream2 = 3
-			br1 := &br[stream]
-			br2 := &br[stream2]
-			br1.fillFast()
-			br2.fillFast()
-
-			v := single[uint8(br1.value>>shift)].entry
-			v2 := single[uint8(br2.value>>shift)].entry
-			br1.bitsRead += uint8(v)
-			br1.value <<= v & 63
-			br2.bitsRead += uint8(v2)
-			br2.value <<= v2 & 63
-			buf[stream][off] = uint8(v >> 8)
-			buf[stream2][off] = uint8(v2 >> 8)
-
-			v = single[uint8(br1.value>>shift)].entry
-			v2 = single[uint8(br2.value>>shift)].entry
-			br1.bitsRead += uint8(v)
-			br1.value <<= v & 63
-			br2.bitsRead += uint8(v2)
-			br2.value <<= v2 & 63
-			buf[stream][off+1] = uint8(v >> 8)
-			buf[stream2][off+1] = uint8(v2 >> 8)
-
-			v = single[uint8(br1.value>>shift)].entry
-			v2 = single[uint8(br2.value>>shift)].entry
-			br1.bitsRead += uint8(v)
-			br1.value <<= v & 63
-			br2.bitsRead += uint8(v2)
-			br2.value <<= v2 & 63
-			buf[stream][off+2] = uint8(v >> 8)
-			buf[stream2][off+2] = uint8(v2 >> 8)
-
-			v = single[uint8(br1.value>>shift)].entry
-			v2 = single[uint8(br2.value>>shift)].entry
-			br1.bitsRead += uint8(v)
-			br1.value <<= v & 63
-			br2.bitsRead += uint8(v2)
-			br2.value <<= v2 & 63
-			buf[stream][off+3] = uint8(v >> 8)
-			buf[stream2][off+3] = uint8(v2 >> 8)
+			br[stream].fillFast()
+			br[stream2].fillFast()
+
+			v := single[br[stream].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream] = uint8(v >> 8)
+			br[stream].advance(uint8(v))
+
+			v2 := single[br[stream2].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream2] = uint8(v2 >> 8)
+			br[stream2].advance(uint8(v2))
+
+			v = single[br[stream].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream+1] = uint8(v >> 8)
+			br[stream].advance(uint8(v))
+
+			v2 = single[br[stream2].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream2+1] = uint8(v2 >> 8)
+			br[stream2].advance(uint8(v2))
+
+			v = single[br[stream].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream+2] = uint8(v >> 8)
+			br[stream].advance(uint8(v))
+
+			v2 = single[br[stream2].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream2+2] = uint8(v2 >> 8)
+			br[stream2].advance(uint8(v2))
+
+			v = single[br[stream].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream+3] = uint8(v >> 8)
+			br[stream].advance(uint8(v))
+
+			v2 = single[br[stream2].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream2+3] = uint8(v2 >> 8)
+			br[stream2].advance(uint8(v2))
 		}
 
 		off += 4
 
-		if off == 0 {
+		if off == bufoff {
 			if bufoff > dstEvery {
-				d.bufs.Put(buf)
 				return nil, errors.New("corruption detected: stream overrun 1")
 			}
+			copy(out, buf[:bufoff])
+			copy(out[dstEvery:], buf[bufoff:bufoff*2])
+			copy(out[dstEvery*2:], buf[bufoff*2:bufoff*3])
+			copy(out[dstEvery*3:], buf[bufoff*3:bufoff*4])
+			off = 0
+			out = out[bufoff:]
+			decoded += 256
 			// There must at least be 3 buffers left.
-			if len(out)-bufoff < dstEvery*3 {
-				d.bufs.Put(buf)
+			if len(out) < dstEvery*3 {
 				return nil, errors.New("corruption detected: stream overrun 2")
 			}
-			//copy(out, buf[0][:])
-			//copy(out[dstEvery:], buf[1][:])
-			//copy(out[dstEvery*2:], buf[2][:])
-			*(*[bufoff]byte)(out) = buf[0]
-			*(*[bufoff]byte)(out[dstEvery:]) = buf[1]
-			*(*[bufoff]byte)(out[dstEvery*2:]) = buf[2]
-			*(*[bufoff]byte)(out[dstEvery*3:]) = buf[3]
-			out = out[bufoff:]
-			decoded += bufoff * 4
 		}
 	}
 	if off > 0 {
 		ioff := int(off)
 		if len(out) < dstEvery*3+ioff {
-			d.bufs.Put(buf)
 			return nil, errors.New("corruption detected: stream overrun 3")
 		}
-		copy(out, buf[0][:off])
-		copy(out[dstEvery:], buf[1][:off])
-		copy(out[dstEvery*2:], buf[2][:off])
-		copy(out[dstEvery*3:], buf[3][:off])
+		copy(out, buf[:off])
+		copy(out[dstEvery:dstEvery+ioff], buf[bufoff:bufoff*2])
+		copy(out[dstEvery*2:dstEvery*2+ioff], buf[bufoff*2:bufoff*3])
+		copy(out[dstEvery*3:dstEvery*3+ioff], buf[bufoff*3:bufoff*4])
 		decoded += int(off) * 4
 		out = out[off:]
 	}
 
 	// Decode remaining.
-	// Decode remaining.
-	remainBytes := dstEvery - (decoded / 4)
 	for i := range br {
 		offset := dstEvery * i
-		endsAt := offset + remainBytes
-		if endsAt > len(out) {
-			endsAt = len(out)
-		}
 		br := &br[i]
-		bitsLeft := br.remaining()
+		bitsLeft := int(br.off*8) + int(64-br.bitsRead)
 		for bitsLeft > 0 {
 			if br.finished() {
-				d.bufs.Put(buf)
 				return nil, io.ErrUnexpectedEOF
 			}
 			if br.bitsRead >= 56 {
@@ -826,31 +1068,24 @@ func (d *Decoder) decompress4X8bit(dst, src []byte) ([]byte, error) {
 				}
 			}
 			// end inline...
-			if offset >= endsAt {
-				d.bufs.Put(buf)
+			if offset >= len(out) {
 				return nil, errors.New("corruption detected: stream overrun 4")
 			}
 
 			// Read value and increment offset.
-			v := single[uint8(br.value>>shift)].entry
+			v := single[br.peekByteFast()>>shift].entry
 			nBits := uint8(v)
 			br.advance(nBits)
-			bitsLeft -= uint(nBits)
+			bitsLeft -= int(nBits)
 			out[offset] = uint8(v >> 8)
 			offset++
 		}
-		if offset != endsAt {
-			d.bufs.Put(buf)
-			return nil, fmt.Errorf("corruption detected: short output block %d, end %d != %d", i, offset, endsAt)
-		}
 		decoded += offset - dstEvery*i
 		err = br.close()
 		if err != nil {
-			d.bufs.Put(buf)
 			return nil, err
 		}
 	}
-	d.bufs.Put(buf)
 	if dstSize != decoded {
 		return nil, errors.New("corruption detected: short output block")
 	}
@@ -886,17 +1121,18 @@ func (d *Decoder) decompress4X8bitExactly(dst, src []byte) ([]byte, error) {
 	out := dst
 	dstEvery := (dstSize + 3) / 4
 
-	const shift = 56
+	const shift = 0
 	const tlSize = 1 << 8
+	const tlMask = tlSize - 1
 	single := d.dt.single[:tlSize]
 
 	// Use temp table to avoid bound checks/append penalty.
-	buf := d.buffer()
+	var buf [256]byte
 	var off uint8
 	var decoded int
 
 	// Decode 4 values from each decoder/loop.
-	const bufoff = 256
+	const bufoff = 256 / 4
 	for {
 		if br[0].off < 4 || br[1].off < 4 || br[2].off < 4 || br[3].off < 4 {
 			break
@@ -906,116 +1142,98 @@ func (d *Decoder) decompress4X8bitExactly(dst, src []byte) ([]byte, error) {
 			// Interleave 2 decodes.
 			const stream = 0
 			const stream2 = 1
-			br1 := &br[stream]
-			br2 := &br[stream2]
-			br1.fillFast()
-			br2.fillFast()
-
-			v := single[uint8(br1.value>>shift)].entry
-			v2 := single[uint8(br2.value>>shift)].entry
-			br1.bitsRead += uint8(v)
-			br1.value <<= v & 63
-			br2.bitsRead += uint8(v2)
-			br2.value <<= v2 & 63
-			buf[stream][off] = uint8(v >> 8)
-			buf[stream2][off] = uint8(v2 >> 8)
-
-			v = single[uint8(br1.value>>shift)].entry
-			v2 = single[uint8(br2.value>>shift)].entry
-			br1.bitsRead += uint8(v)
-			br1.value <<= v & 63
-			br2.bitsRead += uint8(v2)
-			br2.value <<= v2 & 63
-			buf[stream][off+1] = uint8(v >> 8)
-			buf[stream2][off+1] = uint8(v2 >> 8)
-
-			v = single[uint8(br1.value>>shift)].entry
-			v2 = single[uint8(br2.value>>shift)].entry
-			br1.bitsRead += uint8(v)
-			br1.value <<= v & 63
-			br2.bitsRead += uint8(v2)
-			br2.value <<= v2 & 63
-			buf[stream][off+2] = uint8(v >> 8)
-			buf[stream2][off+2] = uint8(v2 >> 8)
-
-			v = single[uint8(br1.value>>shift)].entry
-			v2 = single[uint8(br2.value>>shift)].entry
-			br1.bitsRead += uint8(v)
-			br1.value <<= v & 63
-			br2.bitsRead += uint8(v2)
-			br2.value <<= v2 & 63
-			buf[stream][off+3] = uint8(v >> 8)
-			buf[stream2][off+3] = uint8(v2 >> 8)
+			br[stream].fillFast()
+			br[stream2].fillFast()
+
+			v := single[br[stream].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream] = uint8(v >> 8)
+			br[stream].advance(uint8(v))
+
+			v2 := single[br[stream2].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream2] = uint8(v2 >> 8)
+			br[stream2].advance(uint8(v2))
+
+			v = single[br[stream].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream+1] = uint8(v >> 8)
+			br[stream].advance(uint8(v))
+
+			v2 = single[br[stream2].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream2+1] = uint8(v2 >> 8)
+			br[stream2].advance(uint8(v2))
+
+			v = single[br[stream].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream+2] = uint8(v >> 8)
+			br[stream].advance(uint8(v))
+
+			v2 = single[br[stream2].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream2+2] = uint8(v2 >> 8)
+			br[stream2].advance(uint8(v2))
+
+			v = single[br[stream].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream+3] = uint8(v >> 8)
+			br[stream].advance(uint8(v))
+
+			v2 = single[br[stream2].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream2+3] = uint8(v2 >> 8)
+			br[stream2].advance(uint8(v2))
 		}
 
 		{
 			const stream = 2
 			const stream2 = 3
-			br1 := &br[stream]
-			br2 := &br[stream2]
-			br1.fillFast()
-			br2.fillFast()
-
-			v := single[uint8(br1.value>>shift)].entry
-			v2 := single[uint8(br2.value>>shift)].entry
-			br1.bitsRead += uint8(v)
-			br1.value <<= v & 63
-			br2.bitsRead += uint8(v2)
-			br2.value <<= v2 & 63
-			buf[stream][off] = uint8(v >> 8)
-			buf[stream2][off] = uint8(v2 >> 8)
-
-			v = single[uint8(br1.value>>shift)].entry
-			v2 = single[uint8(br2.value>>shift)].entry
-			br1.bitsRead += uint8(v)
-			br1.value <<= v & 63
-			br2.bitsRead += uint8(v2)
-			br2.value <<= v2 & 63
-			buf[stream][off+1] = uint8(v >> 8)
-			buf[stream2][off+1] = uint8(v2 >> 8)
-
-			v = single[uint8(br1.value>>shift)].entry
-			v2 = single[uint8(br2.value>>shift)].entry
-			br1.bitsRead += uint8(v)
-			br1.value <<= v & 63
-			br2.bitsRead += uint8(v2)
-			br2.value <<= v2 & 63
-			buf[stream][off+2] = uint8(v >> 8)
-			buf[stream2][off+2] = uint8(v2 >> 8)
-
-			v = single[uint8(br1.value>>shift)].entry
-			v2 = single[uint8(br2.value>>shift)].entry
-			br1.bitsRead += uint8(v)
-			br1.value <<= v & 63
-			br2.bitsRead += uint8(v2)
-			br2.value <<= v2 & 63
-			buf[stream][off+3] = uint8(v >> 8)
-			buf[stream2][off+3] = uint8(v2 >> 8)
+			br[stream].fillFast()
+			br[stream2].fillFast()
+
+			v := single[br[stream].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream] = uint8(v >> 8)
+			br[stream].advance(uint8(v))
+
+			v2 := single[br[stream2].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream2] = uint8(v2 >> 8)
+			br[stream2].advance(uint8(v2))
+
+			v = single[br[stream].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream+1] = uint8(v >> 8)
+			br[stream].advance(uint8(v))
+
+			v2 = single[br[stream2].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream2+1] = uint8(v2 >> 8)
+			br[stream2].advance(uint8(v2))
+
+			v = single[br[stream].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream+2] = uint8(v >> 8)
+			br[stream].advance(uint8(v))
+
+			v2 = single[br[stream2].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream2+2] = uint8(v2 >> 8)
+			br[stream2].advance(uint8(v2))
+
+			v = single[br[stream].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream+3] = uint8(v >> 8)
+			br[stream].advance(uint8(v))
+
+			v2 = single[br[stream2].peekByteFast()>>shift].entry
+			buf[off+bufoff*stream2+3] = uint8(v2 >> 8)
+			br[stream2].advance(uint8(v2))
 		}
 
 		off += 4
 
-		if off == 0 {
+		if off == bufoff {
 			if bufoff > dstEvery {
-				d.bufs.Put(buf)
 				return nil, errors.New("corruption detected: stream overrun 1")
 			}
+			copy(out, buf[:bufoff])
+			copy(out[dstEvery:], buf[bufoff:bufoff*2])
+			copy(out[dstEvery*2:], buf[bufoff*2:bufoff*3])
+			copy(out[dstEvery*3:], buf[bufoff*3:bufoff*4])
+			off = 0
+			out = out[bufoff:]
+			decoded += 256
 			// There must at least be 3 buffers left.
-			if len(out)-bufoff < dstEvery*3 {
-				d.bufs.Put(buf)
+			if len(out) < dstEvery*3 {
 				return nil, errors.New("corruption detected: stream overrun 2")
 			}
-
-			//copy(out, buf[0][:])
-			//copy(out[dstEvery:], buf[1][:])
-			//copy(out[dstEvery*2:], buf[2][:])
-			// copy(out[dstEvery*3:], buf[3][:])
-			*(*[bufoff]byte)(out) = buf[0]
-			*(*[bufoff]byte)(out[dstEvery:]) = buf[1]
-			*(*[bufoff]byte)(out[dstEvery*2:]) = buf[2]
-			*(*[bufoff]byte)(out[dstEvery*3:]) = buf[3]
-			out = out[bufoff:]
-			decoded += bufoff * 4
 		}
 	}
 	if off > 0 {
@@ -1023,27 +1241,21 @@ func (d *Decoder) decompress4X8bitExactly(dst, src []byte) ([]byte, error) {
 		if len(out) < dstEvery*3+ioff {
 			return nil, errors.New("corruption detected: stream overrun 3")
 		}
-		copy(out, buf[0][:off])
-		copy(out[dstEvery:], buf[1][:off])
-		copy(out[dstEvery*2:], buf[2][:off])
-		copy(out[dstEvery*3:], buf[3][:off])
+		copy(out, buf[:off])
+		copy(out[dstEvery:dstEvery+ioff], buf[bufoff:bufoff*2])
+		copy(out[dstEvery*2:dstEvery*2+ioff], buf[bufoff*2:bufoff*3])
+		copy(out[dstEvery*3:dstEvery*3+ioff], buf[bufoff*3:bufoff*4])
 		decoded += int(off) * 4
 		out = out[off:]
 	}
 
 	// Decode remaining.
-	remainBytes := dstEvery - (decoded / 4)
 	for i := range br {
 		offset := dstEvery * i
-		endsAt := offset + remainBytes
-		if endsAt > len(out) {
-			endsAt = len(out)
-		}
 		br := &br[i]
-		bitsLeft := br.remaining()
+		bitsLeft := int(br.off*8) + int(64-br.bitsRead)
 		for bitsLeft > 0 {
 			if br.finished() {
-				d.bufs.Put(buf)
 				return nil, io.ErrUnexpectedEOF
 			}
 			if br.bitsRead >= 56 {
@@ -1063,32 +1275,24 @@ func (d *Decoder) decompress4X8bitExactly(dst, src []byte) ([]byte, error) {
 				}
 			}
 			// end inline...
-			if offset >= endsAt {
-				d.bufs.Put(buf)
+			if offset >= len(out) {
 				return nil, errors.New("corruption detected: stream overrun 4")
 			}
 
 			// Read value and increment offset.
-			v := single[br.peekByteFast()].entry
+			v := single[br.peekByteFast()>>shift].entry
 			nBits := uint8(v)
 			br.advance(nBits)
-			bitsLeft -= uint(nBits)
+			bitsLeft -= int(nBits)
 			out[offset] = uint8(v >> 8)
 			offset++
 		}
-		if offset != endsAt {
-			d.bufs.Put(buf)
-			return nil, fmt.Errorf("corruption detected: short output block %d, end %d != %d", i, offset, endsAt)
-		}
-
 		decoded += offset - dstEvery*i
 		err = br.close()
 		if err != nil {
-			d.bufs.Put(buf)
 			return nil, err
 		}
 	}
-	d.bufs.Put(buf)
 	if dstSize != decoded {
 		return nil, errors.New("corruption detected: short output block")
 	}
diff --git a/vendor/github.com/klauspost/compress/huff0/huff0.go b/vendor/github.com/klauspost/compress/huff0/huff0.go
index e8ad17ad..3ee00ecb 100644
--- a/vendor/github.com/klauspost/compress/huff0/huff0.go
+++ b/vendor/github.com/klauspost/compress/huff0/huff0.go
@@ -8,7 +8,6 @@ import (
 	"fmt"
 	"math"
 	"math/bits"
-	"sync"
 
 	"github.com/klauspost/compress/fse"
 )
@@ -117,7 +116,6 @@ type Scratch struct {
 	nodes          []nodeElt
 	tmpOut         [4][]byte
 	fse            *fse.Scratch
-	decPool        sync.Pool // *[4][256]byte buffers.
 	huffWeight     [maxSymbolValue + 1]byte
 }
 
diff --git a/vendor/github.com/klauspost/compress/internal/snapref/encode_other.go b/vendor/github.com/klauspost/compress/internal/snapref/encode_other.go
index 2aa6a95a..511bba65 100644
--- a/vendor/github.com/klauspost/compress/internal/snapref/encode_other.go
+++ b/vendor/github.com/klauspost/compress/internal/snapref/encode_other.go
@@ -18,7 +18,6 @@ func load64(b []byte, i int) uint64 {
 // emitLiteral writes a literal chunk and returns the number of bytes written.
 //
 // It assumes that:
-//
 //	dst is long enough to hold the encoded bytes
 //	1 <= len(lit) && len(lit) <= 65536
 func emitLiteral(dst, lit []byte) int {
@@ -43,7 +42,6 @@ func emitLiteral(dst, lit []byte) int {
 // emitCopy writes a copy chunk and returns the number of bytes written.
 //
 // It assumes that:
-//
 //	dst is long enough to hold the encoded bytes
 //	1 <= offset && offset <= 65535
 //	4 <= length && length <= 65535
@@ -87,30 +85,19 @@ func emitCopy(dst []byte, offset, length int) int {
 	return i + 2
 }
 
-func hash(u, shift uint32) uint32 {
-	return (u * 0x1e35a7bd) >> shift
-}
-
-// EncodeBlockInto exposes encodeBlock but checks dst size.
-func EncodeBlockInto(dst, src []byte) (d int) {
-	if MaxEncodedLen(len(src)) > len(dst) {
-		return 0
+// 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 {
+	for ; j < len(src) && src[i] == src[j]; i, j = i+1, j+1 {
 	}
+	return j
+}
 
-	// encodeBlock breaks on too big blocks, so split.
-	for len(src) > 0 {
-		p := src
-		src = nil
-		if len(p) > maxBlockSize {
-			p, src = p[:maxBlockSize], p[maxBlockSize:]
-		}
-		if len(p) < minNonLiteralBlockSize {
-			d += emitLiteral(dst[d:], p)
-		} else {
-			d += encodeBlock(dst[d:], p)
-		}
-	}
-	return d
+func hash(u, shift uint32) uint32 {
+	return (u * 0x1e35a7bd) >> shift
 }
 
 // encodeBlock encodes a non-empty src to a guaranteed-large-enough dst. It
@@ -118,9 +105,8 @@ func EncodeBlockInto(dst, src []byte) (d int) {
 // been written.
 //
 // It also assumes that:
-//
 //	len(dst) >= MaxEncodedLen(len(src)) &&
-//	minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSize
+// 	minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSize
 func encodeBlock(dst, src []byte) (d int) {
 	// Initialize the hash table. Its size ranges from 1<<8 to 1<<14 inclusive.
 	// The table element type is uint16, as s < sLimit and sLimit < len(src)
diff --git a/vendor/github.com/klauspost/compress/zstd/README.md b/vendor/github.com/klauspost/compress/zstd/README.md
index bdd49c8b..c8f0f16f 100644
--- a/vendor/github.com/klauspost/compress/zstd/README.md
+++ b/vendor/github.com/klauspost/compress/zstd/README.md
@@ -12,8 +12,6 @@ The `zstd` package is provided as open source software using a Go standard licen
 
 Currently the package is heavily optimized for 64 bit processors and will be significantly slower on 32 bit processors.
 
-For seekable zstd streams, see [this excellent package](https://github.com/SaveTheRbtz/zstd-seekable-format-go).
-
 ## Installation
 
 Install using `go get -u github.com/klauspost/compress`. The package is located in `github.com/klauspost/compress/zstd`.
@@ -80,9 +78,6 @@ of a stream. This is independent of the `WithEncoderConcurrency(n)`, but that is
 in the future. So if you want to limit concurrency for future updates, specify the concurrency
 you would like.
 
-If you would like stream encoding to be done without spawning async goroutines, use `WithEncoderConcurrency(1)`
-which will compress input as each block is completed, blocking on writes until each has completed.
-
 You can specify your desired compression level using `WithEncoderLevel()` option. Currently only pre-defined 
 compression settings can be specified.
 
@@ -109,8 +104,7 @@ and seems to ignore concatenated streams, even though [it is part of the spec](h
 For compressing small blocks, the returned encoder has a function called `EncodeAll(src, dst []byte) []byte`.
 
 `EncodeAll` will encode all input in src and append it to dst.
-This function can be called concurrently. 
-Each call will only run on a same goroutine as the caller.
+This function can be called concurrently, but each call will only run on a single goroutine.
 
 Encoded blocks can be concatenated and the result will be the combined input stream.
 Data compressed with EncodeAll can be decoded with the Decoder, using either a stream or `DecodeAll`.
@@ -155,10 +149,10 @@ http://sun.aei.polsl.pl/~sdeor/corpus/silesia.zip
 
 This package:
 file    out     level   insize      outsize     millis  mb/s
-silesia.tar zskp    1   211947520   73821326    634     318.47
-silesia.tar zskp    2   211947520   67655404    1508    133.96
-silesia.tar zskp    3   211947520   64746933    3000    67.37
-silesia.tar zskp    4   211947520   60073508    16926   11.94
+silesia.tar zskp    1   211947520   73101992    643     313.87
+silesia.tar zskp    2   211947520   67504318    969     208.38
+silesia.tar zskp    3   211947520   64595893    2007    100.68
+silesia.tar zskp    4   211947520   60995370    8825    22.90
 
 cgo zstd:
 silesia.tar zstd    1   211947520   73605392    543     371.56
@@ -167,94 +161,94 @@ silesia.tar zstd    6   211947520   62916450    1913    105.66
 silesia.tar zstd    9   211947520   60212393    5063    39.92
 
 gzip, stdlib/this package:
-silesia.tar gzstd   1   211947520   80007735    1498    134.87
-silesia.tar gzkp    1   211947520   80088272    1009    200.31
+silesia.tar gzstd   1   211947520   80007735    1654    122.21
+silesia.tar gzkp    1   211947520   80136201    1152    175.45
 
 GOB stream of binary data. Highly compressible.
 https://files.klauspost.com/compress/gob-stream.7z
 
 file        out     level   insize  outsize     millis  mb/s
-gob-stream  zskp    1   1911399616  233948096   3230    564.34
-gob-stream  zskp    2   1911399616  203997694   4997    364.73
-gob-stream  zskp    3   1911399616  173526523   13435   135.68
-gob-stream  zskp    4   1911399616  162195235   47559   38.33
+gob-stream  zskp    1   1911399616  235022249   3088    590.30
+gob-stream  zskp    2   1911399616  205669791   3786    481.34
+gob-stream  zskp    3   1911399616  175034659   9636    189.17
+gob-stream  zskp    4   1911399616  165609838   50369   36.19
 
 gob-stream  zstd    1   1911399616  249810424   2637    691.26
 gob-stream  zstd    3   1911399616  208192146   3490    522.31
 gob-stream  zstd    6   1911399616  193632038   6687    272.56
 gob-stream  zstd    9   1911399616  177620386   16175   112.70
 
-gob-stream  gzstd   1   1911399616  357382013   9046    201.49
-gob-stream  gzkp    1   1911399616  359136669   4885    373.08
+gob-stream  gzstd   1   1911399616  357382641   10251   177.82
+gob-stream  gzkp    1   1911399616  359753026   5438    335.20
 
 The test data for the Large Text Compression Benchmark is the first
 10^9 bytes of the English Wikipedia dump on Mar. 3, 2006.
 http://mattmahoney.net/dc/textdata.html
 
 file    out level   insize      outsize     millis  mb/s
-enwik9  zskp    1   1000000000  343833605   3687    258.64
-enwik9  zskp    2   1000000000  317001237   7672    124.29
-enwik9  zskp    3   1000000000  291915823   15923   59.89
-enwik9  zskp    4   1000000000  261710291   77697   12.27
+enwik9  zskp    1   1000000000  343848582   3609    264.18
+enwik9  zskp    2   1000000000  317276632   5746    165.97
+enwik9  zskp    3   1000000000  292243069   12162   78.41
+enwik9  zskp    4   1000000000  262183768   82837   11.51
 
 enwik9  zstd    1   1000000000  358072021   3110    306.65
 enwik9  zstd    3   1000000000  313734672   4784    199.35
 enwik9  zstd    6   1000000000  295138875   10290   92.68
 enwik9  zstd    9   1000000000  278348700   28549   33.40
 
-enwik9  gzstd   1   1000000000  382578136   8608    110.78
-enwik9  gzkp    1   1000000000  382781160   5628    169.45
+enwik9  gzstd   1   1000000000  382578136   9604    99.30
+enwik9  gzkp    1   1000000000  383825945   6544    145.73
 
 Highly compressible JSON file.
 https://files.klauspost.com/compress/github-june-2days-2019.json.zst
 
 file                        out level   insize      outsize     millis  mb/s
-github-june-2days-2019.json zskp    1   6273951764  697439532   9789    611.17
-github-june-2days-2019.json zskp    2   6273951764  610876538   18553   322.49
-github-june-2days-2019.json zskp    3   6273951764  517662858   44186   135.41
-github-june-2days-2019.json zskp    4   6273951764  464617114   165373  36.18
+github-june-2days-2019.json zskp    1   6273951764  699045015   10620   563.40
+github-june-2days-2019.json zskp    2   6273951764  617881763   11687   511.96
+github-june-2days-2019.json zskp    3   6273951764  524340691   34043   175.75
+github-june-2days-2019.json zskp    4   6273951764  470320075   170190  35.16
 
 github-june-2days-2019.json zstd    1   6273951764  766284037   8450    708.00
 github-june-2days-2019.json zstd    3   6273951764  661889476   10927   547.57
 github-june-2days-2019.json zstd    6   6273951764  642756859   22996   260.18
 github-june-2days-2019.json zstd    9   6273951764  601974523   52413   114.16
 
-github-june-2days-2019.json gzstd   1   6273951764  1164397768  26793   223.32
-github-june-2days-2019.json gzkp    1   6273951764  1120631856  17693   338.16
+github-june-2days-2019.json gzstd   1   6273951764  1164400847  29948   199.79
+github-june-2days-2019.json gzkp    1   6273951764  1125417694  21788   274.61
 
 VM Image, Linux mint with a few installed applications:
 https://files.klauspost.com/compress/rawstudio-mint14.7z
 
 file                    out level   insize      outsize     millis  mb/s
-rawstudio-mint14.tar    zskp    1   8558382592  3718400221  18206   448.29
-rawstudio-mint14.tar    zskp    2   8558382592  3326118337  37074   220.15
-rawstudio-mint14.tar    zskp    3   8558382592  3163842361  87306   93.49
-rawstudio-mint14.tar    zskp    4   8558382592  2970480650  783862  10.41
+rawstudio-mint14.tar    zskp    1   8558382592  3667489370  20210   403.84
+rawstudio-mint14.tar    zskp    2   8558382592  3364592300  31873   256.07
+rawstudio-mint14.tar    zskp    3   8558382592  3158085214  77675   105.08
+rawstudio-mint14.tar    zskp    4   8558382592  2965110639  857750  9.52
 
 rawstudio-mint14.tar    zstd    1   8558382592  3609250104  17136   476.27
 rawstudio-mint14.tar    zstd    3   8558382592  3341679997  29262   278.92
 rawstudio-mint14.tar    zstd    6   8558382592  3235846406  77904   104.77
 rawstudio-mint14.tar    zstd    9   8558382592  3160778861  140946  57.91
 
-rawstudio-mint14.tar    gzstd   1   8558382592  3926234992  51345   158.96
-rawstudio-mint14.tar    gzkp    1   8558382592  3960117298  36722   222.26
+rawstudio-mint14.tar    gzstd   1   8558382592  3926257486  57722   141.40
+rawstudio-mint14.tar    gzkp    1   8558382592  3962605659  45113   180.92
 
 CSV data:
 https://files.klauspost.com/compress/nyc-taxi-data-10M.csv.zst
 
 file                    out level   insize      outsize     millis  mb/s
-nyc-taxi-data-10M.csv   zskp    1   3325605752  641319332   9462    335.17
-nyc-taxi-data-10M.csv   zskp    2   3325605752  588976126   17570   180.50
-nyc-taxi-data-10M.csv   zskp    3   3325605752  529329260   32432   97.79
-nyc-taxi-data-10M.csv   zskp    4   3325605752  474949772   138025  22.98
+nyc-taxi-data-10M.csv   zskp    1   3325605752  641339945   8925    355.35
+nyc-taxi-data-10M.csv   zskp    2   3325605752  591748091   11268   281.44
+nyc-taxi-data-10M.csv   zskp    3   3325605752  530289687   25239   125.66
+nyc-taxi-data-10M.csv   zskp    4   3325605752  476268884   135958  23.33
 
 nyc-taxi-data-10M.csv   zstd    1   3325605752  687399637   8233    385.18
 nyc-taxi-data-10M.csv   zstd    3   3325605752  598514411   10065   315.07
 nyc-taxi-data-10M.csv   zstd    6   3325605752  570522953   20038   158.27
 nyc-taxi-data-10M.csv   zstd    9   3325605752  517554797   64565   49.12
 
-nyc-taxi-data-10M.csv   gzstd   1   3325605752  928654908   21270   149.11
-nyc-taxi-data-10M.csv   gzkp    1   3325605752  922273214   13929   227.68
+nyc-taxi-data-10M.csv   gzstd   1   3325605752  928656485   23876   132.83
+nyc-taxi-data-10M.csv   gzkp    1   3325605752  922257165   16780   189.00
 ```
 
 ## Decompressor
@@ -289,13 +283,8 @@ func Decompress(in io.Reader, out io.Writer) error {
 }
 ```
 
-It is important to use the "Close" function when you no longer need the Reader to stop running goroutines, 
-when running with default settings.
-Goroutines will exit once an error has been returned, including `io.EOF` at the end of a stream.
-
-Streams are decoded concurrently in 4 asynchronous stages to give the best possible throughput.
-However, if you prefer synchronous decompression, use `WithDecoderConcurrency(1)` which will decompress data 
-as it is being requested only.
+It is important to use the "Close" function when you no longer need the Reader to stop running goroutines. 
+See "Allocation-less operation" below.
 
 For decoding buffers, it could look something like this:
 
@@ -304,7 +293,7 @@ import "github.com/klauspost/compress/zstd"
 
 // Create a reader that caches decompressors.
 // For this operation type we supply a nil Reader.
-var decoder, _ = zstd.NewReader(nil, zstd.WithDecoderConcurrency(0))
+var decoder, _ = zstd.NewReader(nil)
 
 // Decompress a buffer. We don't supply a destination buffer,
 // so it will be allocated by the decoder.
@@ -314,12 +303,9 @@ func Decompress(src []byte) ([]byte, error) {
 ```
 
 Both of these cases should provide the functionality needed. 
-The decoder can be used for *concurrent* decompression of multiple buffers.
-By default 4 decompressors will be created. 
-
+The decoder can be used for *concurrent* decompression of multiple buffers. 
 It will only allow a certain number of concurrent operations to run. 
-To tweak that yourself use the `WithDecoderConcurrency(n)` option when creating the decoder.
-It is possible to use `WithDecoderConcurrency(0)` to create GOMAXPROCS decoders.
+To tweak that yourself use the `WithDecoderConcurrency(n)` option when creating the decoder.   
 
 ### Dictionaries
 
@@ -371,48 +357,62 @@ In this case no unneeded allocations should be made.
 The buffer decoder does everything on the same goroutine and does nothing concurrently.
 It can however decode several buffers concurrently. Use `WithDecoderConcurrency(n)` to limit that.
 
-The stream decoder will create goroutines that:
+The stream decoder operates on
 
-1) Reads input and splits the input into blocks.
-2) Decompression of literals.
-3) Decompression of sequences.
-4) Reconstruction of output stream.
+* One goroutine reads input and splits the input to several block decoders.
+* A number of decoders will decode blocks.
+* A goroutine coordinates these blocks and sends history from one to the next.
 
 So effectively this also means the decoder will "read ahead" and prepare data to always be available for output.
 
-The concurrency level will, for streams, determine how many blocks ahead the compression will start.
-
 Since "blocks" are quite dependent on the output of the previous block stream decoding will only have limited concurrency.
 
-In practice this means that concurrency is often limited to utilizing about 3 cores effectively.
-  
+In practice this means that concurrency is often limited to utilizing about 2 cores effectively.
+ 
+ 
 ### Benchmarks
 
-The first two are streaming decodes and the last are smaller inputs. 
-
-Running on AMD Ryzen 9 3950X 16-Core Processor. AMD64 assembly used.
+These are some examples of performance compared to [datadog cgo library](https://github.com/DataDog/zstd).
 
+The first two are streaming decodes and the last are smaller inputs. 
+ 
 ```
-BenchmarkDecoderSilesia-32    	                   5	 206878840 ns/op	1024.50 MB/s	   49808 B/op	      43 allocs/op
-BenchmarkDecoderEnwik9-32                          1	1271809000 ns/op	 786.28 MB/s	   72048 B/op	      52 allocs/op
-
-Concurrent blocks, performance:
-
-BenchmarkDecoder_DecodeAllParallel/kppkn.gtb.zst-32         	   67356	     17857 ns/op	10321.96 MB/s	        22.48 pct	     102 B/op	       0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/geo.protodata.zst-32     	  266656	      4421 ns/op	26823.21 MB/s	        11.89 pct	      19 B/op	       0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/plrabn12.txt.zst-32      	   20992	     56842 ns/op	8477.17 MB/s	        39.90 pct	     754 B/op	       0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/lcet10.txt.zst-32        	   27456	     43932 ns/op	9714.01 MB/s	        33.27 pct	     524 B/op	       0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/asyoulik.txt.zst-32      	   78432	     15047 ns/op	8319.15 MB/s	        40.34 pct	      66 B/op	       0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/alice29.txt.zst-32       	   65800	     18436 ns/op	8249.63 MB/s	        37.75 pct	      88 B/op	       0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/html_x_4.zst-32          	  102993	     11523 ns/op	35546.09 MB/s	         3.637 pct	     143 B/op	       0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/paper-100k.pdf.zst-32    	 1000000	      1070 ns/op	95720.98 MB/s	        80.53 pct	       3 B/op	       0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/fireworks.jpeg.zst-32    	  749802	      1752 ns/op	70272.35 MB/s	       100.0 pct	       5 B/op	       0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/urls.10K.zst-32          	   22640	     52934 ns/op	13263.37 MB/s	        26.25 pct	    1014 B/op	       0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/html.zst-32              	  226412	      5232 ns/op	19572.27 MB/s	        14.49 pct	      20 B/op	       0 allocs/op
-BenchmarkDecoder_DecodeAllParallel/comp-data.bin.zst-32     	  923041	      1276 ns/op	3194.71 MB/s	        31.26 pct	       0 B/op	       0 allocs/op
+BenchmarkDecoderSilesia-8                          3     385000067 ns/op     550.51 MB/s        5498 B/op          8 allocs/op
+BenchmarkDecoderSilesiaCgo-8                       6     197666567 ns/op    1072.25 MB/s      270672 B/op          8 allocs/op
+
+BenchmarkDecoderEnwik9-8                           1    2027001600 ns/op     493.34 MB/s       10496 B/op         18 allocs/op
+BenchmarkDecoderEnwik9Cgo-8                        2     979499200 ns/op    1020.93 MB/s      270672 B/op          8 allocs/op
+
+Concurrent performance:
+
+BenchmarkDecoder_DecodeAllParallel/kppkn.gtb.zst-16                28915         42469 ns/op    4340.07 MB/s         114 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/geo.protodata.zst-16           116505          9965 ns/op    11900.16 MB/s         16 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/plrabn12.txt.zst-16              8952        134272 ns/op    3588.70 MB/s         915 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/lcet10.txt.zst-16               11820        102538 ns/op    4161.90 MB/s         594 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/asyoulik.txt.zst-16             34782         34184 ns/op    3661.88 MB/s          60 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/alice29.txt.zst-16              27712         43447 ns/op    3500.58 MB/s          99 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/html_x_4.zst-16                 62826         18750 ns/op    21845.10 MB/s        104 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/paper-100k.pdf.zst-16          631545          1794 ns/op    57078.74 MB/s          2 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/fireworks.jpeg.zst-16         1690140           712 ns/op    172938.13 MB/s         1 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/urls.10K.zst-16                 10432        113593 ns/op    6180.73 MB/s        1143 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/html.zst-16                    113206         10671 ns/op    9596.27 MB/s          15 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallel/comp-data.bin.zst-16          1530615           779 ns/op    5229.49 MB/s           0 B/op          0 allocs/op
+
+BenchmarkDecoder_DecodeAllParallelCgo/kppkn.gtb.zst-16             65217         16192 ns/op    11383.34 MB/s         46 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallelCgo/geo.protodata.zst-16        292671          4039 ns/op    29363.19 MB/s          6 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallelCgo/plrabn12.txt.zst-16          26314         46021 ns/op    10470.43 MB/s        293 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallelCgo/lcet10.txt.zst-16            33897         34900 ns/op    12227.96 MB/s        205 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallelCgo/asyoulik.txt.zst-16         104348         11433 ns/op    10949.01 MB/s         20 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallelCgo/alice29.txt.zst-16           75949         15510 ns/op    9805.60 MB/s          32 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallelCgo/html_x_4.zst-16             173910          6756 ns/op    60624.29 MB/s         37 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallelCgo/paper-100k.pdf.zst-16       923076          1339 ns/op    76474.87 MB/s          1 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallelCgo/fireworks.jpeg.zst-16       922920          1351 ns/op    91102.57 MB/s          2 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallelCgo/urls.10K.zst-16              27649         43618 ns/op    16096.19 MB/s        407 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallelCgo/html.zst-16                 279073          4160 ns/op    24614.18 MB/s          6 B/op          0 allocs/op
+BenchmarkDecoder_DecodeAllParallelCgo/comp-data.bin.zst-16        749938          1579 ns/op    2581.71 MB/s           0 B/op          0 allocs/op
 ```
 
-This reflects the performance around May 2022, but this may be out of date.
+This reflects the performance around May 2020, but this may be out of date.
 
 ## Zstd inside ZIP files
 
diff --git a/vendor/github.com/klauspost/compress/zstd/bitreader.go b/vendor/github.com/klauspost/compress/zstd/bitreader.go
index 97299d49..85445853 100644
--- a/vendor/github.com/klauspost/compress/zstd/bitreader.go
+++ b/vendor/github.com/klauspost/compress/zstd/bitreader.go
@@ -7,7 +7,6 @@ package zstd
 import (
 	"encoding/binary"
 	"errors"
-	"fmt"
 	"io"
 	"math/bits"
 )
@@ -51,16 +50,16 @@ func (b *bitReader) getBits(n uint8) int {
 	if n == 0 /*|| b.bitsRead >= 64 */ {
 		return 0
 	}
-	return int(b.get32BitsFast(n))
+	return b.getBitsFast(n)
 }
 
-// get32BitsFast requires that at least one bit is requested every time.
+// getBitsFast requires that at least one bit is requested every time.
 // There are no checks if the buffer is filled.
-func (b *bitReader) get32BitsFast(n uint8) uint32 {
+func (b *bitReader) getBitsFast(n uint8) int {
 	const regMask = 64 - 1
 	v := uint32((b.value << (b.bitsRead & regMask)) >> ((regMask + 1 - n) & regMask))
 	b.bitsRead += n
-	return v
+	return int(v)
 }
 
 // fillFast() will make sure at least 32 bits are available.
@@ -126,9 +125,6 @@ func (b *bitReader) remain() uint {
 func (b *bitReader) close() error {
 	// Release reference.
 	b.in = nil
-	if !b.finished() {
-		return fmt.Errorf("%d extra bits on block, should be 0", b.remain())
-	}
 	if b.bitsRead > 64 {
 		return io.ErrUnexpectedEOF
 	}
diff --git a/vendor/github.com/klauspost/compress/zstd/bitwriter.go b/vendor/github.com/klauspost/compress/zstd/bitwriter.go
index 78b3c61b..303ae90f 100644
--- a/vendor/github.com/klauspost/compress/zstd/bitwriter.go
+++ b/vendor/github.com/klauspost/compress/zstd/bitwriter.go
@@ -5,6 +5,8 @@
 
 package zstd
 
+import "fmt"
+
 // bitWriter will write bits.
 // First bit will be LSB of the first byte of output.
 type bitWriter struct {
@@ -36,7 +38,7 @@ func (b *bitWriter) addBits16NC(value uint16, bits uint8) {
 	b.nBits += bits
 }
 
-// addBits32NC will add up to 31 bits.
+// addBits32NC will add up to 32 bits.
 // It will not check if there is space for them,
 // so the caller must ensure that it has flushed recently.
 func (b *bitWriter) addBits32NC(value uint32, bits uint8) {
@@ -44,26 +46,6 @@ func (b *bitWriter) addBits32NC(value uint32, bits uint8) {
 	b.nBits += bits
 }
 
-// addBits64NC will add up to 64 bits.
-// There must be space for 32 bits.
-func (b *bitWriter) addBits64NC(value uint64, bits uint8) {
-	if bits <= 31 {
-		b.addBits32Clean(uint32(value), bits)
-		return
-	}
-	b.addBits32Clean(uint32(value), 32)
-	b.flush32()
-	b.addBits32Clean(uint32(value>>32), bits-32)
-}
-
-// addBits32Clean will add up to 32 bits.
-// It will not check if there is space for them.
-// The input must not contain more bits than specified.
-func (b *bitWriter) addBits32Clean(value uint32, bits uint8) {
-	b.bitContainer |= uint64(value) << (b.nBits & 63)
-	b.nBits += bits
-}
-
 // addBits16Clean will add up to 16 bits. value may not contain more set bits than indicated.
 // It will not check if there is space for them, so the caller must ensure that it has flushed recently.
 func (b *bitWriter) addBits16Clean(value uint16, bits uint8) {
@@ -71,6 +53,80 @@ func (b *bitWriter) addBits16Clean(value uint16, bits uint8) {
 	b.nBits += bits
 }
 
+// flush will flush all pending full bytes.
+// There will be at least 56 bits available for writing when this has been called.
+// Using flush32 is faster, but leaves less space for writing.
+func (b *bitWriter) flush() {
+	v := b.nBits >> 3
+	switch v {
+	case 0:
+	case 1:
+		b.out = append(b.out,
+			byte(b.bitContainer),
+		)
+	case 2:
+		b.out = append(b.out,
+			byte(b.bitContainer),
+			byte(b.bitContainer>>8),
+		)
+	case 3:
+		b.out = append(b.out,
+			byte(b.bitContainer),
+			byte(b.bitContainer>>8),
+			byte(b.bitContainer>>16),
+		)
+	case 4:
+		b.out = append(b.out,
+			byte(b.bitContainer),
+			byte(b.bitContainer>>8),
+			byte(b.bitContainer>>16),
+			byte(b.bitContainer>>24),
+		)
+	case 5:
+		b.out = append(b.out,
+			byte(b.bitContainer),
+			byte(b.bitContainer>>8),
+			byte(b.bitContainer>>16),
+			byte(b.bitContainer>>24),
+			byte(b.bitContainer>>32),
+		)
+	case 6:
+		b.out = append(b.out,
+			byte(b.bitContainer),
+			byte(b.bitContainer>>8),
+			byte(b.bitContainer>>16),
+			byte(b.bitContainer>>24),
+			byte(b.bitContainer>>32),
+			byte(b.bitContainer>>40),
+		)
+	case 7:
+		b.out = append(b.out,
+			byte(b.bitContainer),
+			byte(b.bitContainer>>8),
+			byte(b.bitContainer>>16),
+			byte(b.bitContainer>>24),
+			byte(b.bitContainer>>32),
+			byte(b.bitContainer>>40),
+			byte(b.bitContainer>>48),
+		)
+	case 8:
+		b.out = append(b.out,
+			byte(b.bitContainer),
+			byte(b.bitContainer>>8),
+			byte(b.bitContainer>>16),
+			byte(b.bitContainer>>24),
+			byte(b.bitContainer>>32),
+			byte(b.bitContainer>>40),
+			byte(b.bitContainer>>48),
+			byte(b.bitContainer>>56),
+		)
+	default:
+		panic(fmt.Errorf("bits (%d) > 64", b.nBits))
+	}
+	b.bitContainer >>= v << 3
+	b.nBits &= 7
+}
+
 // flush32 will flush out, so there are at least 32 bits available for writing.
 func (b *bitWriter) flush32() {
 	if b.nBits < 32 {
diff --git a/vendor/github.com/klauspost/compress/zstd/blockdec.go b/vendor/github.com/klauspost/compress/zstd/blockdec.go
index 9f17ce60..8a98c456 100644
--- a/vendor/github.com/klauspost/compress/zstd/blockdec.go
+++ b/vendor/github.com/klauspost/compress/zstd/blockdec.go
@@ -5,14 +5,9 @@
 package zstd
 
 import (
-	"bytes"
-	"encoding/binary"
 	"errors"
 	"fmt"
-	"hash/crc32"
 	"io"
-	"os"
-	"path/filepath"
 	"sync"
 
 	"github.com/klauspost/compress/huff0"
@@ -43,14 +38,14 @@ const (
 	// maxCompressedBlockSize is the biggest allowed compressed block size (128KB)
 	maxCompressedBlockSize = 128 << 10
 
-	compressedBlockOverAlloc    = 16
-	maxCompressedBlockSizeAlloc = 128<<10 + compressedBlockOverAlloc
-
 	// Maximum possible block size (all Raw+Uncompressed).
 	maxBlockSize = (1 << 21) - 1
 
-	maxMatchLen  = 131074
-	maxSequences = 0x7f00 + 0xffff
+	// https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#literals_section_header
+	maxCompressedLiteralSize = 1 << 18
+	maxRLELiteralSize        = 1 << 20
+	maxMatchLen              = 131074
+	maxSequences             = 0x7f00 + 0xffff
 
 	// We support slightly less than the reference decoder to be able to
 	// use ints on 32 bit archs.
@@ -81,28 +76,20 @@ type blockDec struct {
 	// Window size of the block.
 	WindowSize uint64
 
-	err error
-
-	// Check against this crc, if hasCRC is true.
-	checkCRC uint32
-	hasCRC   bool
+	history     chan *history
+	input       chan struct{}
+	result      chan decodeOutput
+	sequenceBuf []seq
+	err         error
+	decWG       sync.WaitGroup
 
 	// Frame to use for singlethreaded decoding.
 	// Should not be used by the decoder itself since parent may be another frame.
 	localFrame *frameDec
 
-	sequence []seqVals
-
-	async struct {
-		newHist  *history
-		literals []byte
-		seqData  []byte
-		seqSize  int // Size of uncompressed sequences
-		fcs      uint64
-	}
-
 	// Block is RLE, this is the size.
 	RLESize uint32
+	tmp     [4]byte
 
 	Type blockType
 
@@ -122,8 +109,13 @@ func (b *blockDec) String() string {
 
 func newBlockDec(lowMem bool) *blockDec {
 	b := blockDec{
-		lowMem: lowMem,
+		lowMem:  lowMem,
+		result:  make(chan decodeOutput, 1),
+		input:   make(chan struct{}, 1),
+		history: make(chan *history, 1),
 	}
+	b.decWG.Add(1)
+	go b.startDecoder()
 	return &b
 }
 
@@ -141,17 +133,11 @@ func (b *blockDec) reset(br byteBuffer, windowSize uint64) error {
 	b.Type = blockType((bh >> 1) & 3)
 	// find size.
 	cSize := int(bh >> 3)
-	maxSize := maxCompressedBlockSizeAlloc
+	maxSize := maxBlockSize
 	switch b.Type {
 	case blockTypeReserved:
 		return ErrReservedBlockType
 	case blockTypeRLE:
-		if cSize > maxCompressedBlockSize || cSize > int(b.WindowSize) {
-			if debugDecoder {
-				printf("rle block too big: csize:%d block: %+v\n", uint64(cSize), b)
-			}
-			return ErrWindowSizeExceeded
-		}
 		b.RLESize = uint32(cSize)
 		if b.lowMem {
 			maxSize = cSize
@@ -162,9 +148,9 @@ func (b *blockDec) reset(br byteBuffer, windowSize uint64) error {
 			println("Data size on stream:", cSize)
 		}
 		b.RLESize = 0
-		maxSize = maxCompressedBlockSizeAlloc
+		maxSize = maxCompressedBlockSize
 		if windowSize < maxCompressedBlockSize && b.lowMem {
-			maxSize = int(windowSize) + compressedBlockOverAlloc
+			maxSize = int(windowSize)
 		}
 		if cSize > maxCompressedBlockSize || uint64(cSize) > b.WindowSize {
 			if debugDecoder {
@@ -172,19 +158,7 @@ func (b *blockDec) reset(br byteBuffer, windowSize uint64) error {
 			}
 			return ErrCompressedSizeTooBig
 		}
-		// Empty compressed blocks must at least be 2 bytes
-		// for Literals_Block_Type and one for Sequences_Section_Header.
-		if cSize < 2 {
-			return ErrBlockTooSmall
-		}
 	case blockTypeRaw:
-		if cSize > maxCompressedBlockSize || cSize > int(b.WindowSize) {
-			if debugDecoder {
-				printf("rle block too big: csize:%d block: %+v\n", uint64(cSize), b)
-			}
-			return ErrWindowSizeExceeded
-		}
-
 		b.RLESize = 0
 		// We do not need a destination for raw blocks.
 		maxSize = -1
@@ -193,14 +167,16 @@ func (b *blockDec) reset(br byteBuffer, windowSize uint64) error {
 	}
 
 	// Read block data.
-	if _, ok := br.(*byteBuf); !ok && cap(b.dataStorage) < cSize {
-		// byteBuf doesn't need a destination buffer.
+	if cap(b.dataStorage) < cSize {
 		if b.lowMem || cSize > maxCompressedBlockSize {
-			b.dataStorage = make([]byte, 0, cSize+compressedBlockOverAlloc)
+			b.dataStorage = make([]byte, 0, cSize)
 		} else {
-			b.dataStorage = make([]byte, 0, maxCompressedBlockSizeAlloc)
+			b.dataStorage = make([]byte, 0, maxCompressedBlockSize)
 		}
 	}
+	if cap(b.dst) <= maxSize {
+		b.dst = make([]byte, 0, maxSize+1)
+	}
 	b.data, err = br.readBig(cSize, b.dataStorage)
 	if err != nil {
 		if debugDecoder {
@@ -209,9 +185,6 @@ func (b *blockDec) reset(br byteBuffer, windowSize uint64) error {
 		}
 		return err
 	}
-	if cap(b.dst) <= maxSize {
-		b.dst = make([]byte, 0, maxSize+1)
-	}
 	return nil
 }
 
@@ -220,14 +193,85 @@ func (b *blockDec) sendErr(err error) {
 	b.Last = true
 	b.Type = blockTypeReserved
 	b.err = err
+	b.input <- struct{}{}
 }
 
 // Close will release resources.
 // Closed blockDec cannot be reset.
 func (b *blockDec) Close() {
+	close(b.input)
+	close(b.history)
+	close(b.result)
+	b.decWG.Wait()
 }
 
-// decodeBuf
+// decodeAsync will prepare decoding the block when it receives input.
+// This will separate output and history.
+func (b *blockDec) startDecoder() {
+	defer b.decWG.Done()
+	for range b.input {
+		//println("blockDec: Got block input")
+		switch b.Type {
+		case blockTypeRLE:
+			if cap(b.dst) < int(b.RLESize) {
+				if b.lowMem {
+					b.dst = make([]byte, b.RLESize)
+				} else {
+					b.dst = make([]byte, maxBlockSize)
+				}
+			}
+			o := decodeOutput{
+				d:   b,
+				b:   b.dst[:b.RLESize],
+				err: nil,
+			}
+			v := b.data[0]
+			for i := range o.b {
+				o.b[i] = v
+			}
+			hist := <-b.history
+			hist.append(o.b)
+			b.result <- o
+		case blockTypeRaw:
+			o := decodeOutput{
+				d:   b,
+				b:   b.data,
+				err: nil,
+			}
+			hist := <-b.history
+			hist.append(o.b)
+			b.result <- o
+		case blockTypeCompressed:
+			b.dst = b.dst[:0]
+			err := b.decodeCompressed(nil)
+			o := decodeOutput{
+				d:   b,
+				b:   b.dst,
+				err: err,
+			}
+			if debugDecoder {
+				println("Decompressed to", len(b.dst), "bytes, error:", err)
+			}
+			b.result <- o
+		case blockTypeReserved:
+			// Used for returning errors.
+			<-b.history
+			b.result <- decodeOutput{
+				d:   b,
+				b:   nil,
+				err: b.err,
+			}
+		default:
+			panic("Invalid block type")
+		}
+		if debugDecoder {
+			println("blockDec: Finished block")
+		}
+	}
+}
+
+// decodeAsync will prepare decoding the block when it receives the history.
+// If history is provided, it will not fetch it from the channel.
 func (b *blockDec) decodeBuf(hist *history) error {
 	switch b.Type {
 	case blockTypeRLE:
@@ -235,7 +279,7 @@ func (b *blockDec) decodeBuf(hist *history) error {
 			if b.lowMem {
 				b.dst = make([]byte, b.RLESize)
 			} else {
-				b.dst = make([]byte, maxCompressedBlockSize)
+				b.dst = make([]byte, maxBlockSize)
 			}
 		}
 		b.dst = b.dst[:b.RLESize]
@@ -250,23 +294,14 @@ func (b *blockDec) decodeBuf(hist *history) error {
 		return nil
 	case blockTypeCompressed:
 		saved := b.dst
-		// Append directly to history
-		if hist.ignoreBuffer == 0 {
-			b.dst = hist.b
-			hist.b = nil
-		} else {
-			b.dst = b.dst[:0]
-		}
+		b.dst = hist.b
+		hist.b = nil
 		err := b.decodeCompressed(hist)
 		if debugDecoder {
 			println("Decompressed to total", len(b.dst), "bytes, hash:", xxhash.Sum64(b.dst), "error:", err)
 		}
-		if hist.ignoreBuffer == 0 {
-			hist.b = b.dst
-			b.dst = saved
-		} else {
-			hist.appendKeep(b.dst)
-		}
+		hist.b = b.dst
+		b.dst = saved
 		return err
 	case blockTypeReserved:
 		// Used for returning errors.
@@ -276,18 +311,30 @@ func (b *blockDec) decodeBuf(hist *history) error {
 	}
 }
 
-func (b *blockDec) decodeLiterals(in []byte, hist *history) (remain []byte, err error) {
+// decodeCompressed will start decompressing a block.
+// If no history is supplied the decoder will decodeAsync as much as possible
+// before fetching from blockDec.history
+func (b *blockDec) decodeCompressed(hist *history) error {
+	in := b.data
+	delayedHistory := hist == nil
+
+	if delayedHistory {
+		// We must always grab history.
+		defer func() {
+			if hist == nil {
+				<-b.history
+			}
+		}()
+	}
 	// There must be at least one byte for Literals_Block_Type and one for Sequences_Section_Header
 	if len(in) < 2 {
-		return in, ErrBlockTooSmall
+		return ErrBlockTooSmall
 	}
-
 	litType := literalsBlockType(in[0] & 3)
 	var litRegenSize int
 	var litCompSize int
 	sizeFormat := (in[0] >> 2) & 3
 	var fourStreams bool
-	var literals []byte
 	switch litType {
 	case literalsBlockRaw, literalsBlockRLE:
 		switch sizeFormat {
@@ -303,7 +350,7 @@ func (b *blockDec) decodeLiterals(in []byte, hist *history) (remain []byte, err
 			//  Regenerated_Size uses 20 bits (0-1048575). Literals_Section_Header uses 3 bytes.
 			if len(in) < 3 {
 				println("too small: litType:", litType, " sizeFormat", sizeFormat, len(in))
-				return in, ErrBlockTooSmall
+				return ErrBlockTooSmall
 			}
 			litRegenSize = int(in[0]>>4) + (int(in[1]) << 4) + (int(in[2]) << 12)
 			in = in[3:]
@@ -314,7 +361,7 @@ func (b *blockDec) decodeLiterals(in []byte, hist *history) (remain []byte, err
 			// Both Regenerated_Size and Compressed_Size use 10 bits (0-1023).
 			if len(in) < 3 {
 				println("too small: litType:", litType, " sizeFormat", sizeFormat, len(in))
-				return in, ErrBlockTooSmall
+				return ErrBlockTooSmall
 			}
 			n := uint64(in[0]>>4) + (uint64(in[1]) << 4) + (uint64(in[2]) << 12)
 			litRegenSize = int(n & 1023)
@@ -325,7 +372,7 @@ func (b *blockDec) decodeLiterals(in []byte, hist *history) (remain []byte, err
 			fourStreams = true
 			if len(in) < 4 {
 				println("too small: litType:", litType, " sizeFormat", sizeFormat, len(in))
-				return in, ErrBlockTooSmall
+				return ErrBlockTooSmall
 			}
 			n := uint64(in[0]>>4) + (uint64(in[1]) << 4) + (uint64(in[2]) << 12) + (uint64(in[3]) << 20)
 			litRegenSize = int(n & 16383)
@@ -335,7 +382,7 @@ func (b *blockDec) decodeLiterals(in []byte, hist *history) (remain []byte, err
 			fourStreams = true
 			if len(in) < 5 {
 				println("too small: litType:", litType, " sizeFormat", sizeFormat, len(in))
-				return in, ErrBlockTooSmall
+				return ErrBlockTooSmall
 			}
 			n := uint64(in[0]>>4) + (uint64(in[1]) << 4) + (uint64(in[2]) << 12) + (uint64(in[3]) << 20) + (uint64(in[4]) << 28)
 			litRegenSize = int(n & 262143)
@@ -346,15 +393,13 @@ func (b *blockDec) decodeLiterals(in []byte, hist *history) (remain []byte, err
 	if debugDecoder {
 		println("literals type:", litType, "litRegenSize:", litRegenSize, "litCompSize:", litCompSize, "sizeFormat:", sizeFormat, "4X:", fourStreams)
 	}
-	if litRegenSize > int(b.WindowSize) || litRegenSize > maxCompressedBlockSize {
-		return in, ErrWindowSizeExceeded
-	}
-
+	var literals []byte
+	var huff *huff0.Scratch
 	switch litType {
 	case literalsBlockRaw:
 		if len(in) < litRegenSize {
 			println("too small: litType:", litType, " sizeFormat", sizeFormat, "remain:", len(in), "want:", litRegenSize)
-			return in, ErrBlockTooSmall
+			return ErrBlockTooSmall
 		}
 		literals = in[:litRegenSize]
 		in = in[litRegenSize:]
@@ -362,13 +407,19 @@ func (b *blockDec) decodeLiterals(in []byte, hist *history) (remain []byte, err
 	case literalsBlockRLE:
 		if len(in) < 1 {
 			println("too small: litType:", litType, " sizeFormat", sizeFormat, "remain:", len(in), "want:", 1)
-			return in, ErrBlockTooSmall
+			return ErrBlockTooSmall
 		}
 		if cap(b.literalBuf) < litRegenSize {
 			if b.lowMem {
-				b.literalBuf = make([]byte, litRegenSize, litRegenSize+compressedBlockOverAlloc)
+				b.literalBuf = make([]byte, litRegenSize)
 			} else {
-				b.literalBuf = make([]byte, litRegenSize, maxCompressedBlockSize+compressedBlockOverAlloc)
+				if litRegenSize > maxCompressedLiteralSize {
+					// Exceptional
+					b.literalBuf = make([]byte, litRegenSize)
+				} else {
+					b.literalBuf = make([]byte, litRegenSize, maxCompressedLiteralSize)
+
+				}
 			}
 		}
 		literals = b.literalBuf[:litRegenSize]
@@ -383,7 +434,7 @@ func (b *blockDec) decodeLiterals(in []byte, hist *history) (remain []byte, err
 	case literalsBlockTreeless:
 		if len(in) < litCompSize {
 			println("too small: litType:", litType, " sizeFormat", sizeFormat, "remain:", len(in), "want:", litCompSize)
-			return in, ErrBlockTooSmall
+			return ErrBlockTooSmall
 		}
 		// Store compressed literals, so we defer decoding until we get history.
 		literals = in[:litCompSize]
@@ -391,68 +442,31 @@ func (b *blockDec) decodeLiterals(in []byte, hist *history) (remain []byte, err
 		if debugDecoder {
 			printf("Found %d compressed literals\n", litCompSize)
 		}
-		huff := hist.huffTree
-		if huff == nil {
-			return in, errors.New("literal block was treeless, but no history was defined")
-		}
-		// Ensure we have space to store it.
-		if cap(b.literalBuf) < litRegenSize {
-			if b.lowMem {
-				b.literalBuf = make([]byte, 0, litRegenSize+compressedBlockOverAlloc)
-			} else {
-				b.literalBuf = make([]byte, 0, maxCompressedBlockSize+compressedBlockOverAlloc)
-			}
-		}
-		var err error
-		// Use our out buffer.
-		huff.MaxDecodedSize = litRegenSize
-		if fourStreams {
-			literals, err = huff.Decoder().Decompress4X(b.literalBuf[:0:litRegenSize], literals)
-		} else {
-			literals, err = huff.Decoder().Decompress1X(b.literalBuf[:0:litRegenSize], literals)
-		}
-		// Make sure we don't leak our literals buffer
-		if err != nil {
-			println("decompressing literals:", err)
-			return in, err
-		}
-		if len(literals) != litRegenSize {
-			return in, fmt.Errorf("literal output size mismatch want %d, got %d", litRegenSize, len(literals))
-		}
-
 	case literalsBlockCompressed:
 		if len(in) < litCompSize {
 			println("too small: litType:", litType, " sizeFormat", sizeFormat, "remain:", len(in), "want:", litCompSize)
-			return in, ErrBlockTooSmall
+			return ErrBlockTooSmall
 		}
 		literals = in[:litCompSize]
 		in = in[litCompSize:]
+		huff = huffDecoderPool.Get().(*huff0.Scratch)
+		var err error
 		// Ensure we have space to store it.
 		if cap(b.literalBuf) < litRegenSize {
 			if b.lowMem {
-				b.literalBuf = make([]byte, 0, litRegenSize+compressedBlockOverAlloc)
+				b.literalBuf = make([]byte, 0, litRegenSize)
 			} else {
-				b.literalBuf = make([]byte, 0, maxCompressedBlockSize+compressedBlockOverAlloc)
+				b.literalBuf = make([]byte, 0, maxCompressedLiteralSize)
 			}
 		}
-		huff := hist.huffTree
-		if huff == nil || (hist.dict != nil && huff == hist.dict.litEnc) {
-			huff = huffDecoderPool.Get().(*huff0.Scratch)
-			if huff == nil {
-				huff = &huff0.Scratch{}
-			}
-		}
-		var err error
-		if debugDecoder {
-			println("huff table input:", len(literals), "CRC:", crc32.ChecksumIEEE(literals))
+		if huff == nil {
+			huff = &huff0.Scratch{}
 		}
 		huff, literals, err = huff0.ReadTable(literals, huff)
 		if err != nil {
 			println("reading huffman table:", err)
-			return in, err
+			return err
 		}
-		hist.huffTree = huff
-		huff.MaxDecodedSize = litRegenSize
 		// Use our out buffer.
 		if fourStreams {
 			literals, err = huff.Decoder().Decompress4X(b.literalBuf[:0:litRegenSize], literals)
@@ -461,63 +475,27 @@ func (b *blockDec) decodeLiterals(in []byte, hist *history) (remain []byte, err
 		}
 		if err != nil {
 			println("decoding compressed literals:", err)
-			return in, err
+			return err
 		}
 		// Make sure we don't leak our literals buffer
 		if len(literals) != litRegenSize {
-			return in, fmt.Errorf("literal output size mismatch want %d, got %d", litRegenSize, len(literals))
+			return fmt.Errorf("literal output size mismatch want %d, got %d", litRegenSize, len(literals))
 		}
-		// Re-cap to get extra size.
-		literals = b.literalBuf[:len(literals)]
 		if debugDecoder {
 			printf("Decompressed %d literals into %d bytes\n", litCompSize, litRegenSize)
 		}
 	}
-	hist.decoders.literals = literals
-	return in, nil
-}
-
-// decodeCompressed will start decompressing a block.
-func (b *blockDec) decodeCompressed(hist *history) error {
-	in := b.data
-	in, err := b.decodeLiterals(in, hist)
-	if err != nil {
-		return err
-	}
-	err = b.prepareSequences(in, hist)
-	if err != nil {
-		return err
-	}
-	if hist.decoders.nSeqs == 0 {
-		b.dst = append(b.dst, hist.decoders.literals...)
-		return nil
-	}
-	before := len(hist.decoders.out)
-	err = hist.decoders.decodeSync(hist.b[hist.ignoreBuffer:])
-	if err != nil {
-		return err
-	}
-	if hist.decoders.maxSyncLen > 0 {
-		hist.decoders.maxSyncLen += uint64(before)
-		hist.decoders.maxSyncLen -= uint64(len(hist.decoders.out))
-	}
-	b.dst = hist.decoders.out
-	hist.recentOffsets = hist.decoders.prevOffset
-	return nil
-}
 
-func (b *blockDec) prepareSequences(in []byte, hist *history) (err error) {
-	if debugDecoder {
-		printf("prepareSequences: %d byte(s) input\n", len(in))
-	}
 	// Decode Sequences
 	// https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#sequences-section
 	if len(in) < 1 {
 		return ErrBlockTooSmall
 	}
-	var nSeqs int
 	seqHeader := in[0]
+	nSeqs := 0
 	switch {
+	case seqHeader == 0:
+		in = in[1:]
 	case seqHeader < 128:
 		nSeqs = int(seqHeader)
 		in = in[1:]
@@ -534,16 +512,19 @@ func (b *blockDec) prepareSequences(in []byte, hist *history) (err error) {
 		nSeqs = 0x7f00 + int(in[1]) + (int(in[2]) << 8)
 		in = in[3:]
 	}
-	if nSeqs == 0 && len(in) != 0 {
-		// When no sequences, there should not be any more data...
-		if debugDecoder {
-			printf("prepareSequences: 0 sequences, but %d byte(s) left on stream\n", len(in))
+	// Allocate sequences
+	if cap(b.sequenceBuf) < nSeqs {
+		if b.lowMem {
+			b.sequenceBuf = make([]seq, nSeqs)
+		} else {
+			// Allocate max
+			b.sequenceBuf = make([]seq, nSeqs, maxSequences)
 		}
-		return ErrUnexpectedBlockSize
+	} else {
+		// Reuse buffer
+		b.sequenceBuf = b.sequenceBuf[:nSeqs]
 	}
-
-	var seqs = &hist.decoders
-	seqs.nSeqs = nSeqs
+	var seqs = &sequenceDecs{}
 	if nSeqs > 0 {
 		if len(in) < 1 {
 			return ErrBlockTooSmall
@@ -572,9 +553,6 @@ func (b *blockDec) prepareSequences(in []byte, hist *history) (err error) {
 			}
 			switch mode {
 			case compModePredefined:
-				if seq.fse != nil && !seq.fse.preDefined {
-					fseDecoderPool.Put(seq.fse)
-				}
 				seq.fse = &fsePredef[i]
 			case compModeRLE:
 				if br.remain() < 1 {
@@ -582,36 +560,34 @@ func (b *blockDec) prepareSequences(in []byte, hist *history) (err error) {
 				}
 				v := br.Uint8()
 				br.advance(1)
-				if seq.fse == nil || seq.fse.preDefined {
-					seq.fse = fseDecoderPool.Get().(*fseDecoder)
-				}
+				dec := fseDecoderPool.Get().(*fseDecoder)
 				symb, err := decSymbolValue(v, symbolTableX[i])
 				if err != nil {
 					printf("RLE Transform table (%v) error: %v", tableIndex(i), err)
 					return err
 				}
-				seq.fse.setRLE(symb)
+				dec.setRLE(symb)
+				seq.fse = dec
 				if debugDecoder {
-					printf("RLE set to 0x%x, code: %v", symb, v)
+					printf("RLE set to %+v, code: %v", symb, v)
 				}
 			case compModeFSE:
 				println("Reading table for", tableIndex(i))
-				if seq.fse == nil || seq.fse.preDefined {
-					seq.fse = fseDecoderPool.Get().(*fseDecoder)
-				}
-				err := seq.fse.readNCount(&br, uint16(maxTableSymbol[i]))
+				dec := fseDecoderPool.Get().(*fseDecoder)
+				err := dec.readNCount(&br, uint16(maxTableSymbol[i]))
 				if err != nil {
 					println("Read table error:", err)
 					return err
 				}
-				err = seq.fse.transform(symbolTableX[i])
+				err = dec.transform(symbolTableX[i])
 				if err != nil {
 					println("Transform table error:", err)
 					return err
 				}
 				if debugDecoder {
-					println("Read table ok", "symbolLen:", seq.fse.symbolLen)
+					println("Read table ok", "symbolLen:", dec.symbolLen)
 				}
+				seq.fse = dec
 			case compModeRepeat:
 				seq.repeat = true
 			}
@@ -621,106 +597,140 @@ func (b *blockDec) prepareSequences(in []byte, hist *history) (err error) {
 		}
 		in = br.unread()
 	}
-	if debugDecoder {
-		println("Literals:", len(seqs.literals), "hash:", xxhash.Sum64(seqs.literals), "and", seqs.nSeqs, "sequences.")
+
+	// Wait for history.
+	// All time spent after this is critical since it is strictly sequential.
+	if hist == nil {
+		hist = <-b.history
+		if hist.error {
+			return ErrDecoderClosed
+		}
 	}
 
-	if nSeqs == 0 {
-		if len(b.sequence) > 0 {
-			b.sequence = b.sequence[:0]
+	// Decode treeless literal block.
+	if litType == literalsBlockTreeless {
+		// TODO: We could send the history early WITHOUT the stream history.
+		//   This would allow decoding treeless literals before the byte history is available.
+		//   Silencia stats: Treeless 4393, with: 32775, total: 37168, 11% treeless.
+		//   So not much obvious gain here.
+
+		if hist.huffTree == nil {
+			return errors.New("literal block was treeless, but no history was defined")
+		}
+		// Ensure we have space to store it.
+		if cap(b.literalBuf) < litRegenSize {
+			if b.lowMem {
+				b.literalBuf = make([]byte, 0, litRegenSize)
+			} else {
+				b.literalBuf = make([]byte, 0, maxCompressedLiteralSize)
+			}
+		}
+		var err error
+		// Use our out buffer.
+		huff = hist.huffTree
+		if fourStreams {
+			literals, err = huff.Decoder().Decompress4X(b.literalBuf[:0:litRegenSize], literals)
+		} else {
+			literals, err = huff.Decoder().Decompress1X(b.literalBuf[:0:litRegenSize], literals)
+		}
+		// Make sure we don't leak our literals buffer
+		if err != nil {
+			println("decompressing literals:", err)
+			return err
+		}
+		if len(literals) != litRegenSize {
+			return fmt.Errorf("literal output size mismatch want %d, got %d", litRegenSize, len(literals))
+		}
+	} else {
+		if hist.huffTree != nil && huff != nil {
+			if hist.dict == nil || hist.dict.litEnc != hist.huffTree {
+				huffDecoderPool.Put(hist.huffTree)
+			}
+			hist.huffTree = nil
 		}
-		return nil
 	}
-	br := seqs.br
-	if br == nil {
-		br = &bitReader{}
+	if huff != nil {
+		hist.huffTree = huff
 	}
-	if err := br.init(in); err != nil {
-		return err
+	if debugDecoder {
+		println("Final literals:", len(literals), "hash:", xxhash.Sum64(literals), "and", nSeqs, "sequences.")
 	}
 
-	if err := seqs.initialize(br, hist, b.dst); err != nil {
-		println("initializing sequences:", err)
-		return err
-	}
-	// Extract blocks...
-	if false && hist.dict == nil {
-		fatalErr := func(err error) {
-			if err != nil {
-				panic(err)
-			}
+	if nSeqs == 0 {
+		// Decompressed content is defined entirely as Literals Section content.
+		b.dst = append(b.dst, literals...)
+		if delayedHistory {
+			hist.append(literals)
 		}
-		fn := fmt.Sprintf("n-%d-lits-%d-prev-%d-%d-%d-win-%d.blk", hist.decoders.nSeqs, len(hist.decoders.literals), hist.recentOffsets[0], hist.recentOffsets[1], hist.recentOffsets[2], hist.windowSize)
-		var buf bytes.Buffer
-		fatalErr(binary.Write(&buf, binary.LittleEndian, hist.decoders.litLengths.fse))
-		fatalErr(binary.Write(&buf, binary.LittleEndian, hist.decoders.matchLengths.fse))
-		fatalErr(binary.Write(&buf, binary.LittleEndian, hist.decoders.offsets.fse))
-		buf.Write(in)
-		os.WriteFile(filepath.Join("testdata", "seqs", fn), buf.Bytes(), os.ModePerm)
+		return nil
 	}
 
-	return nil
-}
-
-func (b *blockDec) decodeSequences(hist *history) error {
-	if cap(b.sequence) < hist.decoders.nSeqs {
-		if b.lowMem {
-			b.sequence = make([]seqVals, 0, hist.decoders.nSeqs)
-		} else {
-			b.sequence = make([]seqVals, 0, 0x7F00+0xffff)
-		}
+	seqs, err := seqs.mergeHistory(&hist.decoders)
+	if err != nil {
+		return err
 	}
-	b.sequence = b.sequence[:hist.decoders.nSeqs]
-	if hist.decoders.nSeqs == 0 {
-		hist.decoders.seqSize = len(hist.decoders.literals)
-		return nil
+	if debugDecoder {
+		println("History merged ok")
+	}
+	br := &bitReader{}
+	if err := br.init(in); err != nil {
+		return err
 	}
-	hist.decoders.windowSize = hist.windowSize
-	hist.decoders.prevOffset = hist.recentOffsets
 
-	err := hist.decoders.decode(b.sequence)
-	hist.recentOffsets = hist.decoders.prevOffset
-	return err
-}
+	// TODO: Investigate if sending history without decoders are faster.
+	//   This would allow the sequences to be decoded async and only have to construct stream history.
+	//   If only recent offsets were not transferred, this would be an obvious win.
+	// 	 Also, if first 3 sequences don't reference recent offsets, all sequences can be decoded.
 
-func (b *blockDec) executeSequences(hist *history) error {
 	hbytes := hist.b
 	if len(hbytes) > hist.windowSize {
 		hbytes = hbytes[len(hbytes)-hist.windowSize:]
-		// We do not need history anymore.
+		// We do not need history any more.
 		if hist.dict != nil {
 			hist.dict.content = nil
 		}
 	}
-	hist.decoders.windowSize = hist.windowSize
-	hist.decoders.out = b.dst[:0]
-	err := hist.decoders.execute(b.sequence, hbytes)
+
+	if err := seqs.initialize(br, hist, literals, b.dst); err != nil {
+		println("initializing sequences:", err)
+		return err
+	}
+
+	err = seqs.decode(nSeqs, br, hbytes)
 	if err != nil {
 		return err
 	}
-	return b.updateHistory(hist)
-}
+	if !br.finished() {
+		return fmt.Errorf("%d extra bits on block, should be 0", br.remain())
+	}
 
-func (b *blockDec) updateHistory(hist *history) error {
+	err = br.close()
+	if err != nil {
+		printf("Closing sequences: %v, %+v\n", err, *br)
+	}
 	if len(b.data) > maxCompressedBlockSize {
 		return fmt.Errorf("compressed block size too large (%d)", len(b.data))
 	}
 	// Set output and release references.
-	b.dst = hist.decoders.out
-	hist.recentOffsets = hist.decoders.prevOffset
+	b.dst = seqs.out
+	seqs.out, seqs.literals, seqs.hist = nil, nil, nil
 
+	if !delayedHistory {
+		// If we don't have delayed history, no need to update.
+		hist.recentOffsets = seqs.prevOffset
+		return nil
+	}
 	if b.Last {
 		// if last block we don't care about history.
 		println("Last block, no history returned")
 		hist.b = hist.b[:0]
 		return nil
-	} else {
-		hist.append(b.dst)
-		if debugDecoder {
-			println("Finished block with ", len(b.sequence), "sequences. Added", len(b.dst), "to history, now length", len(hist.b))
-		}
 	}
-	hist.decoders.out, hist.decoders.literals = nil, nil
+	hist.append(b.dst)
+	hist.recentOffsets = seqs.prevOffset
+	if debugDecoder {
+		println("Finished block with literals:", len(literals), "and", nSeqs, "sequences.")
+	}
 
 	return nil
 }
diff --git a/vendor/github.com/klauspost/compress/zstd/blockenc.go b/vendor/github.com/klauspost/compress/zstd/blockenc.go
index fd4a36f7..3df185ee 100644
--- a/vendor/github.com/klauspost/compress/zstd/blockenc.go
+++ b/vendor/github.com/klauspost/compress/zstd/blockenc.go
@@ -51,7 +51,7 @@ func (b *blockEnc) init() {
 		if cap(b.literals) < maxCompressedBlockSize {
 			b.literals = make([]byte, 0, maxCompressedBlockSize)
 		}
-		const defSeqs = 2000
+		const defSeqs = 200
 		if cap(b.sequences) < defSeqs {
 			b.sequences = make([]seq, 0, defSeqs)
 		}
@@ -426,7 +426,7 @@ func fuzzFseEncoder(data []byte) int {
 		return 0
 	}
 	enc := fseEncoder{}
-	hist := enc.Histogram()
+	hist := enc.Histogram()[:256]
 	maxSym := uint8(0)
 	for i, v := range data {
 		v = v & 63
@@ -473,7 +473,7 @@ func (b *blockEnc) encode(org []byte, raw, rawAllLits bool) error {
 		return b.encodeLits(b.literals, rawAllLits)
 	}
 	// We want some difference to at least account for the headers.
-	saved := b.size - len(b.literals) - (b.size >> 6)
+	saved := b.size - len(b.literals) - (b.size >> 5)
 	if saved < 16 {
 		if org == nil {
 			return errIncompressible
@@ -722,53 +722,52 @@ func (b *blockEnc) encode(org []byte, raw, rawAllLits bool) error {
 		println("Encoded seq", seq, s, "codes:", s.llCode, s.mlCode, s.ofCode, "states:", ll.state, ml.state, of.state, "bits:", llB, mlB, ofB)
 	}
 	seq--
-	// Store sequences in reverse...
-	for seq >= 0 {
-		s = b.sequences[seq]
-
-		ofB := ofTT[s.ofCode]
-		wr.flush32() // tablelog max is below 8 for each, so it will fill max 24 bits.
-		//of.encode(ofB)
-		nbBitsOut := (uint32(of.state) + ofB.deltaNbBits) >> 16
-		dstState := int32(of.state>>(nbBitsOut&15)) + int32(ofB.deltaFindState)
-		wr.addBits16NC(of.state, uint8(nbBitsOut))
-		of.state = of.stateTable[dstState]
-
-		// Accumulate extra bits.
-		outBits := ofB.outBits & 31
-		extraBits := uint64(s.offset & bitMask32[outBits])
-		extraBitsN := outBits
-
-		mlB := mlTT[s.mlCode]
-		//ml.encode(mlB)
-		nbBitsOut = (uint32(ml.state) + mlB.deltaNbBits) >> 16
-		dstState = int32(ml.state>>(nbBitsOut&15)) + int32(mlB.deltaFindState)
-		wr.addBits16NC(ml.state, uint8(nbBitsOut))
-		ml.state = ml.stateTable[dstState]
-
-		outBits = mlB.outBits & 31
-		extraBits = extraBits<<outBits | uint64(s.matchLen&bitMask32[outBits])
-		extraBitsN += outBits
-
-		llB := llTT[s.llCode]
-		//ll.encode(llB)
-		nbBitsOut = (uint32(ll.state) + llB.deltaNbBits) >> 16
-		dstState = int32(ll.state>>(nbBitsOut&15)) + int32(llB.deltaFindState)
-		wr.addBits16NC(ll.state, uint8(nbBitsOut))
-		ll.state = ll.stateTable[dstState]
-
-		outBits = llB.outBits & 31
-		extraBits = extraBits<<outBits | uint64(s.litLen&bitMask32[outBits])
-		extraBitsN += outBits
-
-		wr.flush32()
-		wr.addBits64NC(extraBits, extraBitsN)
-
-		if debugSequences {
-			println("Encoded seq", seq, s)
-		}
-
-		seq--
+	if llEnc.maxBits+mlEnc.maxBits+ofEnc.maxBits <= 32 {
+		// No need to flush (common)
+		for seq >= 0 {
+			s = b.sequences[seq]
+			wr.flush32()
+			llB, ofB, mlB := llTT[s.llCode], ofTT[s.ofCode], mlTT[s.mlCode]
+			// tabelog max is 8 for all.
+			of.encode(ofB)
+			ml.encode(mlB)
+			ll.encode(llB)
+			wr.flush32()
+
+			// We checked that all can stay within 32 bits
+			wr.addBits32NC(s.litLen, llB.outBits)
+			wr.addBits32NC(s.matchLen, mlB.outBits)
+			wr.addBits32NC(s.offset, ofB.outBits)
+
+			if debugSequences {
+				println("Encoded seq", seq, s)
+			}
+
+			seq--
+		}
+	} else {
+		for seq >= 0 {
+			s = b.sequences[seq]
+			wr.flush32()
+			llB, ofB, mlB := llTT[s.llCode], ofTT[s.ofCode], mlTT[s.mlCode]
+			// tabelog max is below 8 for each.
+			of.encode(ofB)
+			ml.encode(mlB)
+			ll.encode(llB)
+			wr.flush32()
+
+			// ml+ll = max 32 bits total
+			wr.addBits32NC(s.litLen, llB.outBits)
+			wr.addBits32NC(s.matchLen, mlB.outBits)
+			wr.flush32()
+			wr.addBits32NC(s.offset, ofB.outBits)
+
+			if debugSequences {
+				println("Encoded seq", seq, s)
+			}
+
+			seq--
+		}
 	}
 	ml.flush(mlEnc.actualTableLog)
 	of.flush(ofEnc.actualTableLog)
@@ -779,13 +778,10 @@ func (b *blockEnc) encode(org []byte, raw, rawAllLits bool) error {
 	}
 	b.output = wr.out
 
-	// Maybe even add a bigger margin.
 	if len(b.output)-3-bhOffset >= b.size {
-		// Discard and encode as raw block.
-		b.output = b.encodeRawTo(b.output[:bhOffset], org)
-		b.popOffsets()
+		// Maybe even add a bigger margin.
 		b.litEnc.Reuse = huff0.ReusePolicyNone
-		return nil
+		return errIncompressible
 	}
 
 	// Size is output minus block header.
@@ -805,13 +801,14 @@ func (b *blockEnc) genCodes() {
 		// nothing to do
 		return
 	}
+
 	if len(b.sequences) > math.MaxUint16 {
 		panic("can only encode up to 64K sequences")
 	}
 	// No bounds checks after here:
-	llH := b.coders.llEnc.Histogram()
-	ofH := b.coders.ofEnc.Histogram()
-	mlH := b.coders.mlEnc.Histogram()
+	llH := b.coders.llEnc.Histogram()[:256]
+	ofH := b.coders.ofEnc.Histogram()[:256]
+	mlH := b.coders.mlEnc.Histogram()[:256]
 	for i := range llH {
 		llH[i] = 0
 	}
@@ -823,8 +820,7 @@ func (b *blockEnc) genCodes() {
 	}
 
 	var llMax, ofMax, mlMax uint8
-	for i := range b.sequences {
-		seq := &b.sequences[i]
+	for i, seq := range b.sequences {
 		v := llCode(seq.litLen)
 		seq.llCode = v
 		llH[v]++
@@ -848,6 +844,7 @@ func (b *blockEnc) genCodes() {
 				panic(fmt.Errorf("mlMax > maxMatchLengthSymbol (%d), matchlen: %d", mlMax, seq.matchLen))
 			}
 		}
+		b.sequences[i] = seq
 	}
 	maxCount := func(a []uint32) int {
 		var max uint32
diff --git a/vendor/github.com/klauspost/compress/zstd/bytebuf.go b/vendor/github.com/klauspost/compress/zstd/bytebuf.go
index 55a38855..aab71c6c 100644
--- a/vendor/github.com/klauspost/compress/zstd/bytebuf.go
+++ b/vendor/github.com/klauspost/compress/zstd/bytebuf.go
@@ -7,6 +7,7 @@ package zstd
 import (
 	"fmt"
 	"io"
+	"io/ioutil"
 )
 
 type byteBuffer interface {
@@ -22,7 +23,7 @@ type byteBuffer interface {
 	readByte() (byte, error)
 
 	// Skip n bytes.
-	skipN(n int64) error
+	skipN(n int) error
 }
 
 // in-memory buffer
@@ -51,22 +52,23 @@ func (b *byteBuf) readBig(n int, dst []byte) ([]byte, error) {
 	return r, nil
 }
 
+func (b *byteBuf) remain() []byte {
+	return *b
+}
+
 func (b *byteBuf) readByte() (byte, error) {
 	bb := *b
 	if len(bb) < 1 {
-		return 0, io.ErrUnexpectedEOF
+		return 0, nil
 	}
 	r := bb[0]
 	*b = bb[1:]
 	return r, nil
 }
 
-func (b *byteBuf) skipN(n int64) error {
+func (b *byteBuf) skipN(n int) error {
 	bb := *b
-	if n < 0 {
-		return fmt.Errorf("negative skip (%d) requested", n)
-	}
-	if int64(len(bb)) < n {
+	if len(bb) < n {
 		return io.ErrUnexpectedEOF
 	}
 	*b = bb[n:]
@@ -109,11 +111,8 @@ func (r *readerWrapper) readBig(n int, dst []byte) ([]byte, error) {
 }
 
 func (r *readerWrapper) readByte() (byte, error) {
-	n2, err := io.ReadFull(r.r, r.tmp[:1])
+	n2, err := r.r.Read(r.tmp[:1])
 	if err != nil {
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		}
 		return 0, err
 	}
 	if n2 != 1 {
@@ -122,9 +121,9 @@ func (r *readerWrapper) readByte() (byte, error) {
 	return r.tmp[0], nil
 }
 
-func (r *readerWrapper) skipN(n int64) error {
-	n2, err := io.CopyN(io.Discard, r.r, n)
-	if n2 != n {
+func (r *readerWrapper) skipN(n int) error {
+	n2, err := io.CopyN(ioutil.Discard, r.r, int64(n))
+	if n2 != int64(n) {
 		err = io.ErrUnexpectedEOF
 	}
 	return err
diff --git a/vendor/github.com/klauspost/compress/zstd/bytereader.go b/vendor/github.com/klauspost/compress/zstd/bytereader.go
index 0e59a242..2c4fca17 100644
--- a/vendor/github.com/klauspost/compress/zstd/bytereader.go
+++ b/vendor/github.com/klauspost/compress/zstd/bytereader.go
@@ -13,6 +13,12 @@ type byteReader struct {
 	off int
 }
 
+// init will initialize the reader and set the input.
+func (b *byteReader) init(in []byte) {
+	b.b = in
+	b.off = 0
+}
+
 // advance the stream b n bytes.
 func (b *byteReader) advance(n uint) {
 	b.off += int(n)
diff --git a/vendor/github.com/klauspost/compress/zstd/decodeheader.go b/vendor/github.com/klauspost/compress/zstd/decodeheader.go
index f6a24097..69736e8d 100644
--- a/vendor/github.com/klauspost/compress/zstd/decodeheader.go
+++ b/vendor/github.com/klauspost/compress/zstd/decodeheader.go
@@ -4,7 +4,7 @@
 package zstd
 
 import (
-	"encoding/binary"
+	"bytes"
 	"errors"
 	"io"
 )
@@ -15,50 +15,18 @@ const HeaderMaxSize = 14 + 3
 
 // Header contains information about the first frame and block within that.
 type Header struct {
-	// SingleSegment specifies whether the data is to be decompressed into a
-	// single contiguous memory segment.
-	// It implies that WindowSize is invalid and that FrameContentSize is valid.
-	SingleSegment bool
-
-	// WindowSize is the window of data to keep while decoding.
-	// Will only be set if SingleSegment is false.
+	// Window Size the window of data to keep while decoding.
+	// Will only be set if HasFCS is false.
 	WindowSize uint64
 
+	// Frame content size.
+	// Expected size of the entire frame.
+	FrameContentSize uint64
+
 	// Dictionary ID.
 	// If 0, no dictionary.
 	DictionaryID uint32
 
-	// HasFCS specifies whether FrameContentSize has a valid value.
-	HasFCS bool
-
-	// FrameContentSize is the expected uncompressed size of the entire frame.
-	FrameContentSize uint64
-
-	// Skippable will be true if the frame is meant to be skipped.
-	// This implies that FirstBlock.OK is false.
-	Skippable bool
-
-	// SkippableID is the user-specific ID for the skippable frame.
-	// Valid values are between 0 to 15, inclusive.
-	SkippableID int
-
-	// SkippableSize is the length of the user data to skip following
-	// the header.
-	SkippableSize uint32
-
-	// HeaderSize is the raw size of the frame header.
-	//
-	// For normal frames, it includes the size of the magic number and
-	// the size of the header (per section 3.1.1.1).
-	// It does not include the size for any data blocks (section 3.1.1.2) nor
-	// the size for the trailing content checksum.
-	//
-	// For skippable frames, this counts the size of the magic number
-	// along with the size of the size field of the payload.
-	// It does not include the size of the skippable payload itself.
-	// The total frame size is the HeaderSize plus the SkippableSize.
-	HeaderSize int
-
 	// First block information.
 	FirstBlock struct {
 		// OK will be set if first block could be decoded.
@@ -83,9 +51,17 @@ type Header struct {
 		CompressedSize int
 	}
 
+	// Skippable will be true if the frame is meant to be skipped.
+	// No other information will be populated.
+	Skippable bool
+
 	// If set there is a checksum present for the block content.
-	// The checksum field at the end is always 4 bytes long.
 	HasCheckSum bool
+
+	// If this is true FrameContentSize will have a valid value
+	HasFCS bool
+
+	SingleSegment bool
 }
 
 // Decode the header from the beginning of the stream.
@@ -95,46 +71,39 @@ type Header struct {
 // If there isn't enough input, io.ErrUnexpectedEOF is returned.
 // The FirstBlock.OK will indicate if enough information was available to decode the first block header.
 func (h *Header) Decode(in []byte) error {
-	*h = Header{}
 	if len(in) < 4 {
 		return io.ErrUnexpectedEOF
 	}
-	h.HeaderSize += 4
 	b, in := in[:4], in[4:]
-	if string(b) != frameMagic {
-		if string(b[1:4]) != skippableFrameMagic || b[0]&0xf0 != 0x50 {
+	if !bytes.Equal(b, frameMagic) {
+		if !bytes.Equal(b[1:4], skippableFrameMagic) || b[0]&0xf0 != 0x50 {
 			return ErrMagicMismatch
 		}
-		if len(in) < 4 {
-			return io.ErrUnexpectedEOF
-		}
-		h.HeaderSize += 4
-		h.Skippable = true
-		h.SkippableID = int(b[0] & 0xf)
-		h.SkippableSize = binary.LittleEndian.Uint32(in)
+		*h = Header{Skippable: true}
 		return nil
 	}
-
-	// Read Window_Descriptor
-	// https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#window_descriptor
 	if len(in) < 1 {
 		return io.ErrUnexpectedEOF
 	}
+
+	// Clear output
+	*h = Header{}
 	fhd, in := in[0], in[1:]
-	h.HeaderSize++
 	h.SingleSegment = fhd&(1<<5) != 0
 	h.HasCheckSum = fhd&(1<<2) != 0
+
 	if fhd&(1<<3) != 0 {
 		return errors.New("reserved bit set on frame header")
 	}
 
+	// Read Window_Descriptor
+	// https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#window_descriptor
 	if !h.SingleSegment {
 		if len(in) < 1 {
 			return io.ErrUnexpectedEOF
 		}
 		var wd byte
 		wd, in = in[0], in[1:]
-		h.HeaderSize++
 		windowLog := 10 + (wd >> 3)
 		windowBase := uint64(1) << windowLog
 		windowAdd := (windowBase / 8) * uint64(wd&0x7)
@@ -151,8 +120,10 @@ func (h *Header) Decode(in []byte) error {
 			return io.ErrUnexpectedEOF
 		}
 		b, in = in[:size], in[size:]
-		h.HeaderSize += int(size)
-		switch len(b) {
+		if b == nil {
+			return io.ErrUnexpectedEOF
+		}
+		switch size {
 		case 1:
 			h.DictionaryID = uint32(b[0])
 		case 2:
@@ -181,8 +152,10 @@ func (h *Header) Decode(in []byte) error {
 			return io.ErrUnexpectedEOF
 		}
 		b, in = in[:fcsSize], in[fcsSize:]
-		h.HeaderSize += int(fcsSize)
-		switch len(b) {
+		if b == nil {
+			return io.ErrUnexpectedEOF
+		}
+		switch fcsSize {
 		case 1:
 			h.FrameContentSize = uint64(b[0])
 		case 2:
diff --git a/vendor/github.com/klauspost/compress/zstd/decoder.go b/vendor/github.com/klauspost/compress/zstd/decoder.go
index f04aaa21..f430f58b 100644
--- a/vendor/github.com/klauspost/compress/zstd/decoder.go
+++ b/vendor/github.com/klauspost/compress/zstd/decoder.go
@@ -5,12 +5,9 @@
 package zstd
 
 import (
-	"context"
-	"encoding/binary"
+	"errors"
 	"io"
 	"sync"
-
-	"github.com/klauspost/compress/zstd/internal/xxhash"
 )
 
 // Decoder provides decoding of zstandard streams.
@@ -25,22 +22,15 @@ type Decoder struct {
 	// Unreferenced decoders, ready for use.
 	decoders chan *blockDec
 
+	// Streams ready to be decoded.
+	stream chan decodeStream
+
 	// Current read position used for Reader functionality.
 	current decoderState
 
-	// sync stream decoding
-	syncStream struct {
-		decodedFrame uint64
-		br           readerWrapper
-		enabled      bool
-		inFrame      bool
-		dstBuf       []byte
-	}
-
-	frame *frameDec
-
 	// Custom dictionaries.
-	dicts map[uint32]*dict
+	// Always uses copies.
+	dicts map[uint32]dict
 
 	// streamWg is the waitgroup for all streams
 	streamWg sync.WaitGroup
@@ -56,10 +46,7 @@ type decoderState struct {
 	output chan decodeOutput
 
 	// cancel remaining output.
-	cancel context.CancelFunc
-
-	// crc of current frame
-	crc *xxhash.Digest
+	cancel chan struct{}
 
 	flushed bool
 }
@@ -94,7 +81,7 @@ func NewReader(r io.Reader, opts ...DOption) (*Decoder, error) {
 			return nil, err
 		}
 	}
-	d.current.crc = xxhash.New()
+	d.current.output = make(chan decodeOutput, d.o.concurrent)
 	d.current.flushed = true
 
 	if r == nil {
@@ -102,7 +89,7 @@ func NewReader(r io.Reader, opts ...DOption) (*Decoder, error) {
 	}
 
 	// Transfer option dicts.
-	d.dicts = make(map[uint32]*dict, len(d.o.dicts))
+	d.dicts = make(map[uint32]dict, len(d.o.dicts))
 	for _, dc := range d.o.dicts {
 		d.dicts[dc.id] = dc
 	}
@@ -143,7 +130,7 @@ func (d *Decoder) Read(p []byte) (int, error) {
 				break
 			}
 			if !d.nextBlock(n == 0) {
-				return n, d.current.err
+				return n, nil
 			}
 		}
 	}
@@ -175,7 +162,6 @@ func (d *Decoder) Reset(r io.Reader) error {
 
 	d.drainOutput()
 
-	d.syncStream.br.r = nil
 	if r == nil {
 		d.current.err = ErrDecoderNilInput
 		if len(d.current.b) > 0 {
@@ -186,23 +172,21 @@ func (d *Decoder) Reset(r io.Reader) error {
 	}
 
 	// If bytes buffer and < 5MB, do sync decoding anyway.
-	if bb, ok := r.(byter); ok && bb.Len() < d.o.decodeBufsBelow && !d.o.limitToCap {
+	if bb, ok := r.(byter); ok && bb.Len() < 5<<20 {
 		bb2 := bb
 		if debugDecoder {
 			println("*bytes.Buffer detected, doing sync decode, len:", bb.Len())
 		}
 		b := bb2.Bytes()
 		var dst []byte
-		if cap(d.syncStream.dstBuf) > 0 {
-			dst = d.syncStream.dstBuf[:0]
+		if cap(d.current.b) > 0 {
+			dst = d.current.b
 		}
 
-		dst, err := d.DecodeAll(b, dst)
+		dst, err := d.DecodeAll(b, dst[:0])
 		if err == nil {
 			err = io.EOF
 		}
-		// Save output buffer
-		d.syncStream.dstBuf = dst
 		d.current.b = dst
 		d.current.err = err
 		d.current.flushed = true
@@ -211,40 +195,33 @@ func (d *Decoder) Reset(r io.Reader) error {
 		}
 		return nil
 	}
+
+	if d.stream == nil {
+		d.stream = make(chan decodeStream, 1)
+		d.streamWg.Add(1)
+		go d.startStreamDecoder(d.stream)
+	}
+
 	// Remove current block.
-	d.stashDecoder()
 	d.current.decodeOutput = decodeOutput{}
 	d.current.err = nil
+	d.current.cancel = make(chan struct{})
 	d.current.flushed = false
 	d.current.d = nil
-	d.syncStream.dstBuf = nil
 
-	// Ensure no-one else is still running...
-	d.streamWg.Wait()
-	if d.frame == nil {
-		d.frame = newFrameDec(d.o)
+	d.stream <- decodeStream{
+		r:      r,
+		output: d.current.output,
+		cancel: d.current.cancel,
 	}
-
-	if d.o.concurrent == 1 {
-		return d.startSyncDecoder(r)
-	}
-
-	d.current.output = make(chan decodeOutput, d.o.concurrent)
-	ctx, cancel := context.WithCancel(context.Background())
-	d.current.cancel = cancel
-	d.streamWg.Add(1)
-	go d.startStreamDecoder(ctx, r, d.current.output)
-
 	return nil
 }
 
 // drainOutput will drain the output until errEndOfStream is sent.
 func (d *Decoder) drainOutput() {
 	if d.current.cancel != nil {
-		if debugDecoder {
-			println("cancelling current")
-		}
-		d.current.cancel()
+		println("cancelling current")
+		close(d.current.cancel)
 		d.current.cancel = nil
 	}
 	if d.current.d != nil {
@@ -266,9 +243,12 @@ func (d *Decoder) drainOutput() {
 			}
 			d.decoders <- v.d
 		}
+		if v.err == errEndOfStream {
+			println("current flushed")
+			d.current.flushed = true
+			return
+		}
 	}
-	d.current.output = nil
-	d.current.flushed = true
 }
 
 // WriteTo writes data to w until there's no more data to write or when an error occurs.
@@ -307,23 +287,19 @@ func (d *Decoder) WriteTo(w io.Writer) (int64, error) {
 // DecodeAll can be used concurrently.
 // The Decoder concurrency limits will be respected.
 func (d *Decoder) DecodeAll(input, dst []byte) ([]byte, error) {
-	if d.decoders == nil {
+	if d.current.err == ErrDecoderClosed {
 		return dst, ErrDecoderClosed
 	}
 
 	// Grab a block decoder and frame decoder.
 	block := <-d.decoders
 	frame := block.localFrame
-	initialSize := len(dst)
 	defer func() {
 		if debugDecoder {
 			printf("re-adding decoder: %p", block)
 		}
 		frame.rawInput = nil
 		frame.bBuf = nil
-		if frame.history.decoders.br != nil {
-			frame.history.decoders.br.in = nil
-		}
 		d.decoders <- block
 	}()
 	frame.bBuf = input
@@ -331,45 +307,34 @@ func (d *Decoder) DecodeAll(input, dst []byte) ([]byte, error) {
 	for {
 		frame.history.reset()
 		err := frame.reset(&frame.bBuf)
-		if err != nil {
-			if err == io.EOF {
-				if debugDecoder {
-					println("frame reset return EOF")
-				}
-				return dst, nil
-			}
-			return dst, err
-		}
-		if err = d.setDict(frame); err != nil {
-			return nil, err
-		}
-		if frame.WindowSize > d.o.maxWindowSize {
+		if err == io.EOF {
 			if debugDecoder {
-				println("window size exceeded:", frame.WindowSize, ">", d.o.maxWindowSize)
+				println("frame reset return EOF")
 			}
-			return dst, ErrWindowSizeExceeded
+			return dst, nil
 		}
-		if frame.FrameContentSize != fcsUnknown {
-			if frame.FrameContentSize > d.o.maxDecodedSize-uint64(len(dst)-initialSize) {
-				if debugDecoder {
-					println("decoder size exceeded; fcs:", frame.FrameContentSize, "> mcs:", d.o.maxDecodedSize-uint64(len(dst)-initialSize), "len:", len(dst))
-				}
-				return dst, ErrDecoderSizeExceeded
-			}
-			if d.o.limitToCap && frame.FrameContentSize > uint64(cap(dst)-len(dst)) {
-				if debugDecoder {
-					println("decoder size exceeded; fcs:", frame.FrameContentSize, "> (cap-len)", cap(dst)-len(dst))
-				}
-				return dst, ErrDecoderSizeExceeded
+		if frame.DictionaryID != nil {
+			dict, ok := d.dicts[*frame.DictionaryID]
+			if !ok {
+				return nil, ErrUnknownDictionary
 			}
+			frame.history.setDict(&dict)
+		}
+		if err != nil {
+			return dst, err
+		}
+		if frame.FrameContentSize > d.o.maxDecodedSize-uint64(len(dst)) {
+			return dst, ErrDecoderSizeExceeded
+		}
+		if frame.FrameContentSize > 0 && frame.FrameContentSize < 1<<30 {
+			// Never preallocate moe than 1 GB up front.
 			if cap(dst)-len(dst) < int(frame.FrameContentSize) {
-				dst2 := make([]byte, len(dst), len(dst)+int(frame.FrameContentSize)+compressedBlockOverAlloc)
+				dst2 := make([]byte, len(dst), len(dst)+int(frame.FrameContentSize))
 				copy(dst2, dst)
 				dst = dst2
 			}
 		}
-
-		if cap(dst) == 0 && !d.o.limitToCap {
+		if cap(dst) == 0 {
 			// Allocate len(input) * 2 by default if nothing is provided
 			// and we didn't get frame content size.
 			size := len(input) * 2
@@ -387,9 +352,6 @@ func (d *Decoder) DecodeAll(input, dst []byte) ([]byte, error) {
 		if err != nil {
 			return dst, err
 		}
-		if uint64(len(dst)-initialSize) > d.o.maxDecodedSize {
-			return dst, ErrDecoderSizeExceeded
-		}
 		if len(frame.bBuf) == 0 {
 			if debugDecoder {
 				println("frame dbuf empty")
@@ -406,167 +368,33 @@ func (d *Decoder) DecodeAll(input, dst []byte) ([]byte, error) {
 // If non-blocking mode is used the returned boolean will be false
 // if no data was available without blocking.
 func (d *Decoder) nextBlock(blocking bool) (ok bool) {
+	if d.current.d != nil {
+		if debugDecoder {
+			printf("re-adding current decoder %p", d.current.d)
+		}
+		d.decoders <- d.current.d
+		d.current.d = nil
+	}
 	if d.current.err != nil {
 		// Keep error state.
-		return false
+		return blocking
 	}
-	d.current.b = d.current.b[:0]
 
-	// SYNC:
-	if d.syncStream.enabled {
-		if !blocking {
-			return false
-		}
-		ok = d.nextBlockSync()
-		if !ok {
-			d.stashDecoder()
-		}
-		return ok
-	}
-
-	//ASYNC:
-	d.stashDecoder()
 	if blocking {
-		d.current.decodeOutput, ok = <-d.current.output
+		d.current.decodeOutput = <-d.current.output
 	} else {
 		select {
-		case d.current.decodeOutput, ok = <-d.current.output:
+		case d.current.decodeOutput = <-d.current.output:
 		default:
 			return false
 		}
 	}
-	if !ok {
-		// This should not happen, so signal error state...
-		d.current.err = io.ErrUnexpectedEOF
-		return false
-	}
-	next := d.current.decodeOutput
-	if next.d != nil && next.d.async.newHist != nil {
-		d.current.crc.Reset()
-	}
 	if debugDecoder {
-		var tmp [4]byte
-		binary.LittleEndian.PutUint32(tmp[:], uint32(xxhash.Sum64(next.b)))
-		println("got", len(d.current.b), "bytes, error:", d.current.err, "data crc:", tmp)
-	}
-
-	if d.o.ignoreChecksum {
-		return true
-	}
-
-	if len(next.b) > 0 {
-		d.current.crc.Write(next.b)
-	}
-	if next.err == nil && next.d != nil && next.d.hasCRC {
-		got := uint32(d.current.crc.Sum64())
-		if got != next.d.checkCRC {
-			if debugDecoder {
-				printf("CRC Check Failed: %08x (got) != %08x (on stream)\n", got, next.d.checkCRC)
-			}
-			d.current.err = ErrCRCMismatch
-		} else {
-			if debugDecoder {
-				printf("CRC ok %08x\n", got)
-			}
-		}
-	}
-
-	return true
-}
-
-func (d *Decoder) nextBlockSync() (ok bool) {
-	if d.current.d == nil {
-		d.current.d = <-d.decoders
-	}
-	for len(d.current.b) == 0 {
-		if !d.syncStream.inFrame {
-			d.frame.history.reset()
-			d.current.err = d.frame.reset(&d.syncStream.br)
-			if d.current.err == nil {
-				d.current.err = d.setDict(d.frame)
-			}
-			if d.current.err != nil {
-				return false
-			}
-			if d.frame.WindowSize > d.o.maxDecodedSize || d.frame.WindowSize > d.o.maxWindowSize {
-				d.current.err = ErrDecoderSizeExceeded
-				return false
-			}
-
-			d.syncStream.decodedFrame = 0
-			d.syncStream.inFrame = true
-		}
-		d.current.err = d.frame.next(d.current.d)
-		if d.current.err != nil {
-			return false
-		}
-		d.frame.history.ensureBlock()
-		if debugDecoder {
-			println("History trimmed:", len(d.frame.history.b), "decoded already:", d.syncStream.decodedFrame)
-		}
-		histBefore := len(d.frame.history.b)
-		d.current.err = d.current.d.decodeBuf(&d.frame.history)
-
-		if d.current.err != nil {
-			println("error after:", d.current.err)
-			return false
-		}
-		d.current.b = d.frame.history.b[histBefore:]
-		if debugDecoder {
-			println("history after:", len(d.frame.history.b))
-		}
-
-		// Check frame size (before CRC)
-		d.syncStream.decodedFrame += uint64(len(d.current.b))
-		if d.syncStream.decodedFrame > d.frame.FrameContentSize {
-			if debugDecoder {
-				printf("DecodedFrame (%d) > FrameContentSize (%d)\n", d.syncStream.decodedFrame, d.frame.FrameContentSize)
-			}
-			d.current.err = ErrFrameSizeExceeded
-			return false
-		}
-
-		// Check FCS
-		if d.current.d.Last && d.frame.FrameContentSize != fcsUnknown && d.syncStream.decodedFrame != d.frame.FrameContentSize {
-			if debugDecoder {
-				printf("DecodedFrame (%d) != FrameContentSize (%d)\n", d.syncStream.decodedFrame, d.frame.FrameContentSize)
-			}
-			d.current.err = ErrFrameSizeMismatch
-			return false
-		}
-
-		// Update/Check CRC
-		if d.frame.HasCheckSum {
-			if !d.o.ignoreChecksum {
-				d.frame.crc.Write(d.current.b)
-			}
-			if d.current.d.Last {
-				if !d.o.ignoreChecksum {
-					d.current.err = d.frame.checkCRC()
-				} else {
-					d.current.err = d.frame.consumeCRC()
-				}
-				if d.current.err != nil {
-					println("CRC error:", d.current.err)
-					return false
-				}
-			}
-		}
-		d.syncStream.inFrame = !d.current.d.Last
+		println("got", len(d.current.b), "bytes, error:", d.current.err)
 	}
 	return true
 }
 
-func (d *Decoder) stashDecoder() {
-	if d.current.d != nil {
-		if debugDecoder {
-			printf("re-adding current decoder %p", d.current.d)
-		}
-		d.decoders <- d.current.d
-		d.current.d = nil
-	}
-}
-
 // Close will release all resources.
 // It is NOT possible to reuse the decoder after this.
 func (d *Decoder) Close() {
@@ -574,10 +402,10 @@ func (d *Decoder) Close() {
 		return
 	}
 	d.drainOutput()
-	if d.current.cancel != nil {
-		d.current.cancel()
+	if d.stream != nil {
+		close(d.stream)
 		d.streamWg.Wait()
-		d.current.cancel = nil
+		d.stream = nil
 	}
 	if d.decoders != nil {
 		close(d.decoders)
@@ -628,321 +456,100 @@ type decodeOutput struct {
 	err error
 }
 
-func (d *Decoder) startSyncDecoder(r io.Reader) error {
-	d.frame.history.reset()
-	d.syncStream.br = readerWrapper{r: r}
-	d.syncStream.inFrame = false
-	d.syncStream.enabled = true
-	d.syncStream.decodedFrame = 0
-	return nil
-}
-
-// Create Decoder:
-// ASYNC:
-// Spawn 3 go routines.
-// 0: Read frames and decode block literals.
-// 1: Decode sequences.
-// 2: Execute sequences, send to output.
-func (d *Decoder) startStreamDecoder(ctx context.Context, r io.Reader, output chan decodeOutput) {
-	defer d.streamWg.Done()
-	br := readerWrapper{r: r}
-
-	var seqDecode = make(chan *blockDec, d.o.concurrent)
-	var seqExecute = make(chan *blockDec, d.o.concurrent)
-
-	// Async 1: Decode sequences...
-	go func() {
-		var hist history
-		var hasErr bool
-
-		for block := range seqDecode {
-			if hasErr {
-				if block != nil {
-					seqExecute <- block
-				}
-				continue
-			}
-			if block.async.newHist != nil {
-				if debugDecoder {
-					println("Async 1: new history, recent:", block.async.newHist.recentOffsets)
-				}
-				hist.reset()
-				hist.decoders = block.async.newHist.decoders
-				hist.recentOffsets = block.async.newHist.recentOffsets
-				hist.windowSize = block.async.newHist.windowSize
-				if block.async.newHist.dict != nil {
-					hist.setDict(block.async.newHist.dict)
-				}
-			}
-			if block.err != nil || block.Type != blockTypeCompressed {
-				hasErr = block.err != nil
-				seqExecute <- block
-				continue
-			}
-
-			hist.decoders.literals = block.async.literals
-			block.err = block.prepareSequences(block.async.seqData, &hist)
-			if debugDecoder && block.err != nil {
-				println("prepareSequences returned:", block.err)
-			}
-			hasErr = block.err != nil
-			if block.err == nil {
-				block.err = block.decodeSequences(&hist)
-				if debugDecoder && block.err != nil {
-					println("decodeSequences returned:", block.err)
-				}
-				hasErr = block.err != nil
-				//				block.async.sequence = hist.decoders.seq[:hist.decoders.nSeqs]
-				block.async.seqSize = hist.decoders.seqSize
-			}
-			seqExecute <- block
-		}
-		close(seqExecute)
-		hist.reset()
-	}()
+type decodeStream struct {
+	r io.Reader
 
-	var wg sync.WaitGroup
-	wg.Add(1)
-
-	// Async 3: Execute sequences...
-	frameHistCache := d.frame.history.b
-	go func() {
-		var hist history
-		var decodedFrame uint64
-		var fcs uint64
-		var hasErr bool
-		for block := range seqExecute {
-			out := decodeOutput{err: block.err, d: block}
-			if block.err != nil || hasErr {
-				hasErr = true
-				output <- out
-				continue
-			}
-			if block.async.newHist != nil {
-				if debugDecoder {
-					println("Async 2: new history")
-				}
-				hist.reset()
-				hist.windowSize = block.async.newHist.windowSize
-				hist.allocFrameBuffer = block.async.newHist.allocFrameBuffer
-				if block.async.newHist.dict != nil {
-					hist.setDict(block.async.newHist.dict)
-				}
-
-				if cap(hist.b) < hist.allocFrameBuffer {
-					if cap(frameHistCache) >= hist.allocFrameBuffer {
-						hist.b = frameHistCache
-					} else {
-						hist.b = make([]byte, 0, hist.allocFrameBuffer)
-						println("Alloc history sized", hist.allocFrameBuffer)
-					}
-				}
-				hist.b = hist.b[:0]
-				fcs = block.async.fcs
-				decodedFrame = 0
-			}
-			do := decodeOutput{err: block.err, d: block}
-			switch block.Type {
-			case blockTypeRLE:
-				if debugDecoder {
-					println("add rle block length:", block.RLESize)
-				}
+	// Blocks ready to be written to output.
+	output chan decodeOutput
 
-				if cap(block.dst) < int(block.RLESize) {
-					if block.lowMem {
-						block.dst = make([]byte, block.RLESize)
-					} else {
-						block.dst = make([]byte, maxCompressedBlockSize)
-					}
-				}
-				block.dst = block.dst[:block.RLESize]
-				v := block.data[0]
-				for i := range block.dst {
-					block.dst[i] = v
-				}
-				hist.append(block.dst)
-				do.b = block.dst
-			case blockTypeRaw:
-				if debugDecoder {
-					println("add raw block length:", len(block.data))
-				}
-				hist.append(block.data)
-				do.b = block.data
-			case blockTypeCompressed:
-				if debugDecoder {
-					println("execute with history length:", len(hist.b), "window:", hist.windowSize)
-				}
-				hist.decoders.seqSize = block.async.seqSize
-				hist.decoders.literals = block.async.literals
-				do.err = block.executeSequences(&hist)
-				hasErr = do.err != nil
-				if debugDecoder && hasErr {
-					println("executeSequences returned:", do.err)
-				}
-				do.b = block.dst
-			}
-			if !hasErr {
-				decodedFrame += uint64(len(do.b))
-				if decodedFrame > fcs {
-					println("fcs exceeded", block.Last, fcs, decodedFrame)
-					do.err = ErrFrameSizeExceeded
-					hasErr = true
-				} else if block.Last && fcs != fcsUnknown && decodedFrame != fcs {
-					do.err = ErrFrameSizeMismatch
-					hasErr = true
-				} else {
-					if debugDecoder {
-						println("fcs ok", block.Last, fcs, decodedFrame)
-					}
-				}
-			}
-			output <- do
-		}
-		close(output)
-		frameHistCache = hist.b
-		wg.Done()
-		if debugDecoder {
-			println("decoder goroutines finished")
-		}
-		hist.reset()
-	}()
+	// cancel reading from the input
+	cancel chan struct{}
+}
 
-	var hist history
-decodeStream:
-	for {
-		var hasErr bool
-		hist.reset()
-		decodeBlock := func(block *blockDec) {
-			if hasErr {
-				if block != nil {
-					seqDecode <- block
-				}
-				return
-			}
-			if block.err != nil || block.Type != blockTypeCompressed {
-				hasErr = block.err != nil
-				seqDecode <- block
-				return
-			}
+// errEndOfStream indicates that everything from the stream was read.
+var errEndOfStream = errors.New("end-of-stream")
 
-			remain, err := block.decodeLiterals(block.data, &hist)
-			block.err = err
-			hasErr = block.err != nil
-			if err == nil {
-				block.async.literals = hist.decoders.literals
-				block.async.seqData = remain
-			} else if debugDecoder {
-				println("decodeLiterals error:", err)
-			}
-			seqDecode <- block
-		}
-		frame := d.frame
+// Create Decoder:
+// Spawn n block decoders. These accept tasks to decode a block.
+// Create goroutine that handles stream processing, this will send history to decoders as they are available.
+// Decoders update the history as they decode.
+// When a block is returned:
+// 		a) history is sent to the next decoder,
+// 		b) content written to CRC.
+// 		c) return data to WRITER.
+// 		d) wait for next block to return data.
+// Once WRITTEN, the decoders reused by the writer frame decoder for re-use.
+func (d *Decoder) startStreamDecoder(inStream chan decodeStream) {
+	defer d.streamWg.Done()
+	frame := newFrameDec(d.o)
+	for stream := range inStream {
 		if debugDecoder {
-			println("New frame...")
+			println("got new stream")
 		}
-		var historySent bool
-		frame.history.reset()
-		err := frame.reset(&br)
-		if debugDecoder && err != nil {
-			println("Frame decoder returned", err)
-		}
-		if err == nil {
-			err = d.setDict(frame)
-		}
-		if err == nil && d.frame.WindowSize > d.o.maxWindowSize {
-			if debugDecoder {
-				println("decoder size exceeded, fws:", d.frame.WindowSize, "> mws:", d.o.maxWindowSize)
-			}
-
-			err = ErrDecoderSizeExceeded
-		}
-		if err != nil {
-			select {
-			case <-ctx.Done():
-			case dec := <-d.decoders:
-				dec.sendErr(err)
-				decodeBlock(dec)
-			}
-			break decodeStream
-		}
-
-		// Go through all blocks of the frame.
+		br := readerWrapper{r: stream.r}
+	decodeStream:
 		for {
-			var dec *blockDec
-			select {
-			case <-ctx.Done():
-				break decodeStream
-			case dec = <-d.decoders:
-				// Once we have a decoder, we MUST return it.
-			}
-			err := frame.next(dec)
-			if !historySent {
-				h := frame.history
-				if debugDecoder {
-					println("Alloc History:", h.allocFrameBuffer)
-				}
-				hist.reset()
-				if h.dict != nil {
-					hist.setDict(h.dict)
-				}
-				dec.async.newHist = &h
-				dec.async.fcs = frame.FrameContentSize
-				historySent = true
-			} else {
-				dec.async.newHist = nil
-			}
+			frame.history.reset()
+			err := frame.reset(&br)
 			if debugDecoder && err != nil {
-				println("next block returned error:", err)
+				println("Frame decoder returned", err)
 			}
-			dec.err = err
-			dec.hasCRC = false
-			if dec.Last && frame.HasCheckSum && err == nil {
-				crc, err := frame.rawInput.readSmall(4)
-				if len(crc) < 4 {
-					if err == nil {
-						err = io.ErrUnexpectedEOF
-
-					}
-					println("CRC missing?", err)
-					dec.err = err
+			if err == nil && frame.DictionaryID != nil {
+				dict, ok := d.dicts[*frame.DictionaryID]
+				if !ok {
+					err = ErrUnknownDictionary
 				} else {
-					dec.checkCRC = binary.LittleEndian.Uint32(crc)
-					dec.hasCRC = true
-					if debugDecoder {
-						printf("found crc to check: %08x\n", dec.checkCRC)
-					}
+					frame.history.setDict(&dict)
 				}
 			}
-			err = dec.err
-			last := dec.Last
-			decodeBlock(dec)
 			if err != nil {
-				break decodeStream
-			}
-			if last {
+				stream.output <- decodeOutput{
+					err: err,
+				}
 				break
 			}
+			if debugDecoder {
+				println("starting frame decoder")
+			}
+
+			// This goroutine will forward history between frames.
+			frame.frameDone.Add(1)
+			frame.initAsync()
+
+			go frame.startDecoder(stream.output)
+		decodeFrame:
+			// Go through all blocks of the frame.
+			for {
+				dec := <-d.decoders
+				select {
+				case <-stream.cancel:
+					if !frame.sendErr(dec, io.EOF) {
+						// To not let the decoder dangle, send it back.
+						stream.output <- decodeOutput{d: dec}
+					}
+					break decodeStream
+				default:
+				}
+				err := frame.next(dec)
+				switch err {
+				case io.EOF:
+					// End of current frame, no error
+					println("EOF on next block")
+					break decodeFrame
+				case nil:
+					continue
+				default:
+					println("block decoder returned", err)
+					break decodeStream
+				}
+			}
+			// All blocks have started decoding, check if there are more frames.
+			println("waiting for done")
+			frame.frameDone.Wait()
+			println("done waiting...")
 		}
+		frame.frameDone.Wait()
+		println("Sending EOS")
+		stream.output <- decodeOutput{err: errEndOfStream}
 	}
-	close(seqDecode)
-	wg.Wait()
-	hist.reset()
-	d.frame.history.b = frameHistCache
-}
-
-func (d *Decoder) setDict(frame *frameDec) (err error) {
-	dict, ok := d.dicts[frame.DictionaryID]
-	if ok {
-		if debugDecoder {
-			println("setting dict", frame.DictionaryID)
-		}
-		frame.history.setDict(dict)
-	} else if frame.DictionaryID != 0 {
-		// A zero or missing dictionary id is ambiguous:
-		// either dictionary zero, or no dictionary. In particular,
-		// zstd --patch-from uses this id for the source file,
-		// so only return an error if the dictionary id is not zero.
-		err = ErrUnknownDictionary
-	}
-	return err
 }
diff --git a/vendor/github.com/klauspost/compress/zstd/decoder_options.go b/vendor/github.com/klauspost/compress/zstd/decoder_options.go
index 774c5f00..95cc9b8b 100644
--- a/vendor/github.com/klauspost/compress/zstd/decoder_options.go
+++ b/vendor/github.com/klauspost/compress/zstd/decoder_options.go
@@ -6,8 +6,6 @@ package zstd
 
 import (
 	"errors"
-	"fmt"
-	"math/bits"
 	"runtime"
 )
 
@@ -16,28 +14,21 @@ type DOption func(*decoderOptions) error
 
 // options retains accumulated state of multiple options.
 type decoderOptions struct {
-	lowMem          bool
-	concurrent      int
-	maxDecodedSize  uint64
-	maxWindowSize   uint64
-	dicts           []*dict
-	ignoreChecksum  bool
-	limitToCap      bool
-	decodeBufsBelow int
+	lowMem         bool
+	concurrent     int
+	maxDecodedSize uint64
+	maxWindowSize  uint64
+	dicts          []dict
 }
 
 func (o *decoderOptions) setDefault() {
 	*o = decoderOptions{
 		// use less ram: true for now, but may change.
-		lowMem:          true,
-		concurrent:      runtime.GOMAXPROCS(0),
-		maxWindowSize:   MaxWindowSize,
-		decodeBufsBelow: 128 << 10,
+		lowMem:        true,
+		concurrent:    runtime.GOMAXPROCS(0),
+		maxWindowSize: MaxWindowSize,
 	}
-	if o.concurrent > 4 {
-		o.concurrent = 4
-	}
-	o.maxDecodedSize = 64 << 30
+	o.maxDecodedSize = 1 << 63
 }
 
 // WithDecoderLowmem will set whether to use a lower amount of memory,
@@ -46,25 +37,16 @@ func WithDecoderLowmem(b bool) DOption {
 	return func(o *decoderOptions) error { o.lowMem = b; return nil }
 }
 
-// WithDecoderConcurrency sets the number of created decoders.
-// When decoding block with DecodeAll, this will limit the number
-// of possible concurrently running decodes.
-// When decoding streams, this will limit the number of
-// inflight blocks.
-// When decoding streams and setting maximum to 1,
-// no async decoding will be done.
-// When a value of 0 is provided GOMAXPROCS will be used.
-// By default this will be set to 4 or GOMAXPROCS, whatever is lower.
+// WithDecoderConcurrency will set the concurrency,
+// meaning the maximum number of decoders to run concurrently.
+// The value supplied must be at least 1.
+// By default this will be set to GOMAXPROCS.
 func WithDecoderConcurrency(n int) DOption {
 	return func(o *decoderOptions) error {
-		if n < 0 {
+		if n <= 0 {
 			return errors.New("concurrency must be at least 1")
 		}
-		if n == 0 {
-			o.concurrent = runtime.GOMAXPROCS(0)
-		} else {
-			o.concurrent = n
-		}
+		o.concurrent = n
 		return nil
 	}
 }
@@ -72,7 +54,7 @@ func WithDecoderConcurrency(n int) DOption {
 // WithDecoderMaxMemory allows to set a maximum decoded size for in-memory
 // non-streaming operations or maximum window size for streaming operations.
 // This can be used to control memory usage of potentially hostile content.
-// Maximum is 1 << 63 bytes. Default is 64GiB.
+// Maximum and default is 1 << 63 bytes.
 func WithDecoderMaxMemory(n uint64) DOption {
 	return func(o *decoderOptions) error {
 		if n == 0 {
@@ -87,13 +69,7 @@ func WithDecoderMaxMemory(n uint64) DOption {
 }
 
 // WithDecoderDicts allows to register one or more dictionaries for the decoder.
-//
-// Each slice in dict must be in the [dictionary format] produced by
-// "zstd --train" from the Zstandard reference implementation.
-//
-// If several dictionaries with the same ID are provided, the last one will be used.
-//
-// [dictionary format]: https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#dictionary-format
+// If several dictionaries with the same ID is provided the last one will be used.
 func WithDecoderDicts(dicts ...[]byte) DOption {
 	return func(o *decoderOptions) error {
 		for _, b := range dicts {
@@ -101,20 +77,8 @@ func WithDecoderDicts(dicts ...[]byte) DOption {
 			if err != nil {
 				return err
 			}
-			o.dicts = append(o.dicts, d)
-		}
-		return nil
-	}
-}
-
-// WithDecoderDictRaw registers a dictionary that may be used by the decoder.
-// The slice content can be arbitrary data.
-func WithDecoderDictRaw(id uint32, content []byte) DOption {
-	return func(o *decoderOptions) error {
-		if bits.UintSize > 32 && uint(len(content)) > dictMaxLength {
-			return fmt.Errorf("dictionary of size %d > 2GiB too large", len(content))
+			o.dicts = append(o.dicts, *d)
 		}
-		o.dicts = append(o.dicts, &dict{id: id, content: content, offsets: [3]int{1, 4, 8}})
 		return nil
 	}
 }
@@ -136,34 +100,3 @@ func WithDecoderMaxWindow(size uint64) DOption {
 		return nil
 	}
 }
-
-// WithDecodeAllCapLimit will limit DecodeAll to decoding cap(dst)-len(dst) bytes,
-// or any size set in WithDecoderMaxMemory.
-// This can be used to limit decoding to a specific maximum output size.
-// Disabled by default.
-func WithDecodeAllCapLimit(b bool) DOption {
-	return func(o *decoderOptions) error {
-		o.limitToCap = b
-		return nil
-	}
-}
-
-// WithDecodeBuffersBelow will fully decode readers that have a
-// `Bytes() []byte` and `Len() int` interface similar to bytes.Buffer.
-// This typically uses less allocations but will have the full decompressed object in memory.
-// Note that DecodeAllCapLimit will disable this, as well as giving a size of 0 or less.
-// Default is 128KiB.
-func WithDecodeBuffersBelow(size int) DOption {
-	return func(o *decoderOptions) error {
-		o.decodeBufsBelow = size
-		return nil
-	}
-}
-
-// IgnoreChecksum allows to forcibly ignore checksum checking.
-func IgnoreChecksum(b bool) DOption {
-	return func(o *decoderOptions) error {
-		o.ignoreChecksum = b
-		return nil
-	}
-}
diff --git a/vendor/github.com/klauspost/compress/zstd/dict.go b/vendor/github.com/klauspost/compress/zstd/dict.go
index ca095145..a36ae83e 100644
--- a/vendor/github.com/klauspost/compress/zstd/dict.go
+++ b/vendor/github.com/klauspost/compress/zstd/dict.go
@@ -1,6 +1,7 @@
 package zstd
 
 import (
+	"bytes"
 	"encoding/binary"
 	"errors"
 	"fmt"
@@ -19,10 +20,7 @@ type dict struct {
 	content []byte
 }
 
-const dictMagic = "\x37\xa4\x30\xec"
-
-// Maximum dictionary size for the reference implementation (1.5.3) is 2 GiB.
-const dictMaxLength = 1 << 31
+var dictMagic = [4]byte{0x37, 0xa4, 0x30, 0xec}
 
 // ID returns the dictionary id or 0 if d is nil.
 func (d *dict) ID() uint32 {
@@ -32,38 +30,14 @@ func (d *dict) ID() uint32 {
 	return d.id
 }
 
-// ContentSize returns the dictionary content size or 0 if d is nil.
-func (d *dict) ContentSize() int {
+// DictContentSize returns the dictionary content size or 0 if d is nil.
+func (d *dict) DictContentSize() int {
 	if d == nil {
 		return 0
 	}
 	return len(d.content)
 }
 
-// Content returns the dictionary content.
-func (d *dict) Content() []byte {
-	if d == nil {
-		return nil
-	}
-	return d.content
-}
-
-// Offsets returns the initial offsets.
-func (d *dict) Offsets() [3]int {
-	if d == nil {
-		return [3]int{}
-	}
-	return d.offsets
-}
-
-// LitEncoder returns the literal encoder.
-func (d *dict) LitEncoder() *huff0.Scratch {
-	if d == nil {
-		return nil
-	}
-	return d.litEnc
-}
-
 // Load a dictionary as described in
 // https://github.com/facebook/zstd/blob/master/doc/zstd_compression_format.md#dictionary-format
 func loadDict(b []byte) (*dict, error) {
@@ -76,7 +50,7 @@ func loadDict(b []byte) (*dict, error) {
 		ofDec: sequenceDec{fse: &fseDecoder{}},
 		mlDec: sequenceDec{fse: &fseDecoder{}},
 	}
-	if string(b[:4]) != dictMagic {
+	if !bytes.Equal(b[:4], dictMagic[:]) {
 		return nil, ErrMagicMismatch
 	}
 	d.id = binary.LittleEndian.Uint32(b[4:8])
@@ -88,7 +62,7 @@ func loadDict(b []byte) (*dict, error) {
 	var err error
 	d.litEnc, b, err = huff0.ReadTable(b[8:], nil)
 	if err != nil {
-		return nil, fmt.Errorf("loading literal table: %w", err)
+		return nil, err
 	}
 	d.litEnc.Reuse = huff0.ReusePolicyMust
 
@@ -146,16 +120,3 @@ func loadDict(b []byte) (*dict, error) {
 
 	return &d, nil
 }
-
-// InspectDictionary loads a zstd dictionary and provides functions to inspect the content.
-func InspectDictionary(b []byte) (interface {
-	ID() uint32
-	ContentSize() int
-	Content() []byte
-	Offsets() [3]int
-	LitEncoder() *huff0.Scratch
-}, error) {
-	initPredefined()
-	d, err := loadDict(b)
-	return d, err
-}
diff --git a/vendor/github.com/klauspost/compress/zstd/enc_base.go b/vendor/github.com/klauspost/compress/zstd/enc_base.go
index 5ca46038..295cd602 100644
--- a/vendor/github.com/klauspost/compress/zstd/enc_base.go
+++ b/vendor/github.com/klauspost/compress/zstd/enc_base.go
@@ -16,7 +16,6 @@ type fastBase struct {
 	cur int32
 	// maximum offset. Should be at least 2x block size.
 	maxMatchOff int32
-	bufferReset int32
 	hist        []byte
 	crc         *xxhash.Digest
 	tmp         [8]byte
@@ -57,8 +56,8 @@ func (e *fastBase) Block() *blockEnc {
 }
 
 func (e *fastBase) addBlock(src []byte) int32 {
-	if debugAsserts && e.cur > e.bufferReset {
-		panic(fmt.Sprintf("ecur (%d) > buffer reset (%d)", e.cur, e.bufferReset))
+	if debugAsserts && e.cur > bufferReset {
+		panic(fmt.Sprintf("ecur (%d) > buffer reset (%d)", e.cur, bufferReset))
 	}
 	// check if we have space already
 	if len(e.hist)+len(src) > cap(e.hist) {
@@ -109,6 +108,11 @@ func (e *fastBase) UseBlock(enc *blockEnc) {
 	e.blk = enc
 }
 
+func (e *fastBase) matchlenNoHist(s, t int32, src []byte) int32 {
+	// Extend the match to be as long as possible.
+	return int32(matchLen(src[s:], src[t:]))
+}
+
 func (e *fastBase) matchlen(s, t int32, src []byte) int32 {
 	if debugAsserts {
 		if s < 0 {
@@ -127,6 +131,8 @@ func (e *fastBase) matchlen(s, t int32, src []byte) int32 {
 			panic(fmt.Sprintf("len(src)-s (%d) > maxCompressedBlockSize (%d)", len(src)-int(s), maxCompressedBlockSize))
 		}
 	}
+
+	// Extend the match to be as long as possible.
 	return int32(matchLen(src[s:], src[t:]))
 }
 
@@ -144,19 +150,18 @@ func (e *fastBase) resetBase(d *dict, singleBlock bool) {
 	} else {
 		e.crc.Reset()
 	}
-	e.blk.dictLitEnc = nil
 	if d != nil {
 		low := e.lowMem
 		if singleBlock {
 			e.lowMem = true
 		}
-		e.ensureHist(d.ContentSize() + maxCompressedBlockSize)
+		e.ensureHist(d.DictContentSize() + maxCompressedBlockSize)
 		e.lowMem = low
 	}
 
 	// We offset current position so everything will be out of reach.
 	// If above reset line, history will be purged.
-	if e.cur < e.bufferReset {
+	if e.cur < bufferReset {
 		e.cur += e.maxMatchOff + int32(len(e.hist))
 	}
 	e.hist = e.hist[:0]
diff --git a/vendor/github.com/klauspost/compress/zstd/enc_best.go b/vendor/github.com/klauspost/compress/zstd/enc_best.go
index 9819d414..96028ecd 100644
--- a/vendor/github.com/klauspost/compress/zstd/enc_best.go
+++ b/vendor/github.com/klauspost/compress/zstd/enc_best.go
@@ -34,7 +34,7 @@ type match struct {
 	est    int32
 }
 
-const highScore = maxMatchLen * 8
+const highScore = 25000
 
 // estBits will estimate output bits from predefined tables.
 func (m *match) estBits(bitsPerByte int32) {
@@ -84,10 +84,14 @@ func (e *bestFastEncoder) Encode(blk *blockEnc, src []byte) {
 	)
 
 	// Protect against e.cur wraparound.
-	for e.cur >= e.bufferReset-int32(len(e.hist)) {
+	for e.cur >= bufferReset {
 		if len(e.hist) == 0 {
-			e.table = [bestShortTableSize]prevEntry{}
-			e.longTable = [bestLongTableSize]prevEntry{}
+			for i := range e.table[:] {
+				e.table[i] = prevEntry{}
+			}
+			for i := range e.longTable[:] {
+				e.longTable[i] = prevEntry{}
+			}
 			e.cur = e.maxMatchOff
 			break
 		}
@@ -159,6 +163,7 @@ func (e *bestFastEncoder) Encode(blk *blockEnc, src []byte) {
 
 	// nextEmit is where in src the next emitLiteral should start from.
 	nextEmit := s
+	cv := load6432(src, s)
 
 	// Relative offsets
 	offset1 := int32(blk.recentOffsets[0])
@@ -172,6 +177,7 @@ func (e *bestFastEncoder) Encode(blk *blockEnc, src []byte) {
 		blk.literals = append(blk.literals, src[nextEmit:until]...)
 		s.litLen = uint32(until - nextEmit)
 	}
+	_ = addLiterals
 
 	if debugEncoder {
 		println("recent offsets:", blk.recentOffsets)
@@ -186,96 +192,49 @@ encodeLoop:
 			panic("offset0 was 0")
 		}
 
-		const goodEnough = 250
-
-		cv := load6432(src, s)
+		bestOf := func(a, b match) match {
+			if a.est+(a.s-b.s)*bitsPerByte>>10 < b.est+(b.s-a.s)*bitsPerByte>>10 {
+				return a
+			}
+			return b
+		}
+		const goodEnough = 100
 
 		nextHashL := hashLen(cv, bestLongTableBits, bestLongLen)
 		nextHashS := hashLen(cv, bestShortTableBits, bestShortLen)
 		candidateL := e.longTable[nextHashL]
 		candidateS := e.table[nextHashS]
 
-		// Set m to a match at offset if it looks like that will improve compression.
-		improve := func(m *match, offset int32, s int32, first uint32, rep int32) {
+		matchAt := func(offset int32, s int32, first uint32, rep int32) match {
 			if s-offset >= e.maxMatchOff || load3232(src, offset) != first {
-				return
+				return match{s: s, est: highScore}
 			}
 			if debugAsserts {
-				if offset <= 0 {
-					panic(offset)
-				}
 				if !bytes.Equal(src[s:s+4], src[offset:offset+4]) {
 					panic(fmt.Sprintf("first match mismatch: %v != %v, first: %08x", src[s:s+4], src[offset:offset+4], first))
 				}
 			}
-			// Try to quick reject if we already have a long match.
-			if m.length > 16 {
-				left := len(src) - int(m.s+m.length)
-				// If we are too close to the end, keep as is.
-				if left <= 0 {
-					return
-				}
-				checkLen := m.length - (s - m.s) - 8
-				if left > 2 && checkLen > 4 {
-					// Check 4 bytes, 4 bytes from the end of the current match.
-					a := load3232(src, offset+checkLen)
-					b := load3232(src, s+checkLen)
-					if a != b {
-						return
-					}
-				}
-			}
-			l := 4 + e.matchlen(s+4, offset+4, src)
-			if rep < 0 {
-				// Extend candidate match backwards as far as possible.
-				tMin := s - e.maxMatchOff
-				if tMin < 0 {
-					tMin = 0
-				}
-				for offset > tMin && s > nextEmit && src[offset-1] == src[s-1] && l < maxMatchLength {
-					s--
-					offset--
-					l++
-				}
-			}
-
-			cand := match{offset: offset, s: s, length: l, rep: rep}
-			cand.estBits(bitsPerByte)
-			if m.est >= highScore || cand.est-m.est+(cand.s-m.s)*bitsPerByte>>10 < 0 {
-				*m = cand
-			}
+			m := match{offset: offset, s: s, length: 4 + e.matchlen(s+4, offset+4, src), rep: rep}
+			m.estBits(bitsPerByte)
+			return m
 		}
 
-		best := match{s: s, est: highScore}
-		improve(&best, candidateL.offset-e.cur, s, uint32(cv), -1)
-		improve(&best, candidateL.prev-e.cur, s, uint32(cv), -1)
-		improve(&best, candidateS.offset-e.cur, s, uint32(cv), -1)
-		improve(&best, candidateS.prev-e.cur, s, uint32(cv), -1)
+		best := bestOf(matchAt(candidateL.offset-e.cur, s, uint32(cv), -1), matchAt(candidateL.prev-e.cur, s, uint32(cv), -1))
+		best = bestOf(best, matchAt(candidateS.offset-e.cur, s, uint32(cv), -1))
+		best = bestOf(best, matchAt(candidateS.prev-e.cur, s, uint32(cv), -1))
 
 		if canRepeat && best.length < goodEnough {
-			if s == nextEmit {
-				// Check repeats straight after a match.
-				improve(&best, s-offset2, s, uint32(cv), 1|4)
-				improve(&best, s-offset3, s, uint32(cv), 2|4)
-				if offset1 > 1 {
-					improve(&best, s-(offset1-1), s, uint32(cv), 3|4)
-				}
-			}
-
-			// If either no match or a non-repeat match, check at + 1
-			if best.rep <= 0 {
-				cv32 := uint32(cv >> 8)
-				spp := s + 1
-				improve(&best, spp-offset1, spp, cv32, 1)
-				improve(&best, spp-offset2, spp, cv32, 2)
-				improve(&best, spp-offset3, spp, cv32, 3)
-				if best.rep < 0 {
-					cv32 = uint32(cv >> 24)
-					spp += 2
-					improve(&best, spp-offset1, spp, cv32, 1)
-					improve(&best, spp-offset2, spp, cv32, 2)
-					improve(&best, spp-offset3, spp, cv32, 3)
-				}
+			cv32 := uint32(cv >> 8)
+			spp := s + 1
+			best = bestOf(best, matchAt(spp-offset1, spp, cv32, 1))
+			best = bestOf(best, matchAt(spp-offset2, spp, cv32, 2))
+			best = bestOf(best, matchAt(spp-offset3, spp, cv32, 3))
+			if best.length > 0 {
+				cv32 = uint32(cv >> 24)
+				spp += 2
+				best = bestOf(best, matchAt(spp-offset1, spp, cv32, 1))
+				best = bestOf(best, matchAt(spp-offset2, spp, cv32, 2))
+				best = bestOf(best, matchAt(spp-offset3, spp, cv32, 3))
 			}
 		}
 		// Load next and check...
@@ -290,45 +249,40 @@ encodeLoop:
 				if s >= sLimit {
 					break encodeLoop
 				}
+				cv = load6432(src, s)
 				continue
 			}
 
+			s++
 			candidateS = e.table[hashLen(cv>>8, bestShortTableBits, bestShortLen)]
-			cv = load6432(src, s+1)
-			cv2 := load6432(src, s+2)
+			cv = load6432(src, s)
+			cv2 := load6432(src, s+1)
 			candidateL = e.longTable[hashLen(cv, bestLongTableBits, bestLongLen)]
 			candidateL2 := e.longTable[hashLen(cv2, bestLongTableBits, bestLongLen)]
 
 			// Short at s+1
-			improve(&best, candidateS.offset-e.cur, s+1, uint32(cv), -1)
+			best = bestOf(best, matchAt(candidateS.offset-e.cur, s, uint32(cv), -1))
 			// Long at s+1, s+2
-			improve(&best, candidateL.offset-e.cur, s+1, uint32(cv), -1)
-			improve(&best, candidateL.prev-e.cur, s+1, uint32(cv), -1)
-			improve(&best, candidateL2.offset-e.cur, s+2, uint32(cv2), -1)
-			improve(&best, candidateL2.prev-e.cur, s+2, uint32(cv2), -1)
+			best = bestOf(best, matchAt(candidateL.offset-e.cur, s, uint32(cv), -1))
+			best = bestOf(best, matchAt(candidateL.prev-e.cur, s, uint32(cv), -1))
+			best = bestOf(best, matchAt(candidateL2.offset-e.cur, s+1, uint32(cv2), -1))
+			best = bestOf(best, matchAt(candidateL2.prev-e.cur, s+1, uint32(cv2), -1))
 			if false {
 				// Short at s+3.
 				// Too often worse...
-				improve(&best, e.table[hashLen(cv2>>8, bestShortTableBits, bestShortLen)].offset-e.cur, s+3, uint32(cv2>>8), -1)
+				best = bestOf(best, matchAt(e.table[hashLen(cv2>>8, bestShortTableBits, bestShortLen)].offset-e.cur, s+2, uint32(cv2>>8), -1))
 			}
-
-			// Start check at a fixed offset to allow for a few mismatches.
-			// For this compression level 2 yields the best results.
-			// We cannot do this if we have already indexed this position.
-			const skipBeginning = 2
-			if best.s > s-skipBeginning {
-				// See if we can find a better match by checking where the current best ends.
-				// Use that offset to see if we can find a better full match.
-				if sAt := best.s + best.length; sAt < sLimit {
-					nextHashL := hashLen(load6432(src, sAt), bestLongTableBits, bestLongLen)
-					candidateEnd := e.longTable[nextHashL]
-
-					if off := candidateEnd.offset - e.cur - best.length + skipBeginning; off >= 0 {
-						improve(&best, off, best.s+skipBeginning, load3232(src, best.s+skipBeginning), -1)
-						if off := candidateEnd.prev - e.cur - best.length + skipBeginning; off >= 0 {
-							improve(&best, off, best.s+skipBeginning, load3232(src, best.s+skipBeginning), -1)
-						}
+			// See if we can find a better match by checking where the current best ends.
+			// Use that offset to see if we can find a better full match.
+			if sAt := best.s + best.length; sAt < sLimit {
+				nextHashL := hashLen(load6432(src, sAt), bestLongTableBits, bestLongLen)
+				candidateEnd := e.longTable[nextHashL]
+				if pos := candidateEnd.offset - e.cur - best.length; pos >= 0 {
+					bestEnd := bestOf(best, matchAt(pos, best.s, load3232(src, best.s), -1))
+					if pos := candidateEnd.prev - e.cur - best.length; pos >= 0 {
+						bestEnd = bestOf(bestEnd, matchAt(pos, best.s, load3232(src, best.s), -1))
 					}
+					best = bestEnd
 				}
 			}
 		}
@@ -341,34 +295,51 @@ encodeLoop:
 
 		// We have a match, we can store the forward value
 		if best.rep > 0 {
+			s = best.s
 			var seq seq
 			seq.matchLen = uint32(best.length - zstdMinMatch)
-			if debugAsserts && s <= nextEmit {
-				panic("s <= nextEmit")
+
+			// We might be able to match backwards.
+			// Extend as long as we can.
+			start := best.s
+			// We end the search early, so we don't risk 0 literals
+			// and have to do special offset treatment.
+			startLimit := nextEmit + 1
+
+			tMin := s - e.maxMatchOff
+			if tMin < 0 {
+				tMin = 0
+			}
+			repIndex := best.offset
+			for repIndex > tMin && start > startLimit && src[repIndex-1] == src[start-1] && seq.matchLen < maxMatchLength-zstdMinMatch-1 {
+				repIndex--
+				start--
+				seq.matchLen++
 			}
-			addLiterals(&seq, best.s)
+			addLiterals(&seq, start)
 
-			// Repeat. If bit 4 is set, this is a non-lit repeat.
-			seq.offset = uint32(best.rep & 3)
+			// rep 0
+			seq.offset = uint32(best.rep)
 			if debugSequences {
 				println("repeat sequence", seq, "next s:", s)
 			}
 			blk.sequences = append(blk.sequences, seq)
 
-			// Index old s + 1 -> s - 1
-			index0 := s + 1
+			// Index match start+1 (long) -> s - 1
+			index0 := s
 			s = best.s + best.length
 
 			nextEmit = s
 			if s >= sLimit {
 				if debugEncoder {
 					println("repeat ended", s, best.length)
+
 				}
 				break encodeLoop
 			}
 			// Index skipped...
 			off := index0 + e.cur
-			for index0 < s {
+			for index0 < s-1 {
 				cv0 := load6432(src, index0)
 				h0 := hashLen(cv0, bestLongTableBits, bestLongLen)
 				h1 := hashLen(cv0, bestShortTableBits, bestShortLen)
@@ -378,19 +349,17 @@ encodeLoop:
 				index0++
 			}
 			switch best.rep {
-			case 2, 4 | 1:
+			case 2:
 				offset1, offset2 = offset2, offset1
-			case 3, 4 | 2:
+			case 3:
 				offset1, offset2, offset3 = offset3, offset1, offset2
-			case 4 | 3:
-				offset1, offset2, offset3 = offset1-1, offset1, offset2
 			}
+			cv = load6432(src, s)
 			continue
 		}
 
 		// A 4-byte match has been found. Update recent offsets.
 		// We'll later see if more than 4 bytes.
-		index0 := s + 1
 		s = best.s
 		t := best.offset
 		offset1, offset2, offset3 = s-t, offset1, offset2
@@ -403,9 +372,22 @@ encodeLoop:
 			panic("invalid offset")
 		}
 
+		// Extend the n-byte match as long as possible.
+		l := best.length
+
+		// Extend backwards
+		tMin := s - e.maxMatchOff
+		if tMin < 0 {
+			tMin = 0
+		}
+		for t > tMin && s > nextEmit && src[t-1] == src[s-1] && l < maxMatchLength {
+			s--
+			t--
+			l++
+		}
+
 		// Write our sequence
 		var seq seq
-		l := best.length
 		seq.litLen = uint32(s - nextEmit)
 		seq.matchLen = uint32(l - zstdMinMatch)
 		if seq.litLen > 0 {
@@ -422,8 +404,10 @@ encodeLoop:
 			break encodeLoop
 		}
 
-		// Index old s + 1 -> s - 1
-		for index0 < s {
+		// Index match start+1 (long) -> s - 1
+		index0 := s - l + 1
+		// every entry
+		for index0 < s-1 {
 			cv0 := load6432(src, index0)
 			h0 := hashLen(cv0, bestLongTableBits, bestLongLen)
 			h1 := hashLen(cv0, bestShortTableBits, bestShortLen)
@@ -432,6 +416,50 @@ encodeLoop:
 			e.table[h1] = prevEntry{offset: off, prev: e.table[h1].offset}
 			index0++
 		}
+
+		cv = load6432(src, s)
+		if !canRepeat {
+			continue
+		}
+
+		// Check offset 2
+		for {
+			o2 := s - offset2
+			if load3232(src, o2) != uint32(cv) {
+				// Do regular search
+				break
+			}
+
+			// Store this, since we have it.
+			nextHashS := hashLen(cv, bestShortTableBits, bestShortLen)
+			nextHashL := hashLen(cv, bestLongTableBits, bestLongLen)
+
+			// We have at least 4 byte match.
+			// No need to check backwards. We come straight from a match
+			l := 4 + e.matchlen(s+4, o2+4, src)
+
+			e.longTable[nextHashL] = prevEntry{offset: s + e.cur, prev: e.longTable[nextHashL].offset}
+			e.table[nextHashS] = prevEntry{offset: s + e.cur, prev: e.table[nextHashS].offset}
+			seq.matchLen = uint32(l) - zstdMinMatch
+			seq.litLen = 0
+
+			// Since litlen is always 0, this is offset 1.
+			seq.offset = 1
+			s += l
+			nextEmit = s
+			if debugSequences {
+				println("sequence", seq, "next s:", s)
+			}
+			blk.sequences = append(blk.sequences, seq)
+
+			// Swap offset 1 and 2.
+			offset1, offset2 = offset2, offset1
+			if s >= sLimit {
+				// Finished
+				break encodeLoop
+			}
+			cv = load6432(src, s)
+		}
 	}
 
 	if int(nextEmit) < len(src) {
diff --git a/vendor/github.com/klauspost/compress/zstd/enc_better.go b/vendor/github.com/klauspost/compress/zstd/enc_better.go
index 8582f31a..602c05ee 100644
--- a/vendor/github.com/klauspost/compress/zstd/enc_better.go
+++ b/vendor/github.com/klauspost/compress/zstd/enc_better.go
@@ -62,10 +62,14 @@ func (e *betterFastEncoder) Encode(blk *blockEnc, src []byte) {
 	)
 
 	// Protect against e.cur wraparound.
-	for e.cur >= e.bufferReset-int32(len(e.hist)) {
+	for e.cur >= bufferReset {
 		if len(e.hist) == 0 {
-			e.table = [betterShortTableSize]tableEntry{}
-			e.longTable = [betterLongTableSize]prevEntry{}
+			for i := range e.table[:] {
+				e.table[i] = tableEntry{}
+			}
+			for i := range e.longTable[:] {
+				e.longTable[i] = prevEntry{}
+			}
 			e.cur = e.maxMatchOff
 			break
 		}
@@ -152,8 +156,8 @@ encodeLoop:
 				panic("offset0 was 0")
 			}
 
-			nextHashL := hashLen(cv, betterLongTableBits, betterLongLen)
 			nextHashS := hashLen(cv, betterShortTableBits, betterShortLen)
+			nextHashL := hashLen(cv, betterLongTableBits, betterLongLen)
 			candidateL := e.longTable[nextHashL]
 			candidateS := e.table[nextHashS]
 
@@ -412,23 +416,15 @@ encodeLoop:
 
 		// Try to find a better match by searching for a long match at the end of the current best match
 		if s+matched < sLimit {
-			// Allow some bytes at the beginning to mismatch.
-			// Sweet spot is around 3 bytes, but depends on input.
-			// The skipped bytes are tested in Extend backwards,
-			// and still picked up as part of the match if they do.
-			const skipBeginning = 3
-
 			nextHashL := hashLen(load6432(src, s+matched), betterLongTableBits, betterLongLen)
-			s2 := s + skipBeginning
-			cv := load3232(src, s2)
+			cv := load3232(src, s)
 			candidateL := e.longTable[nextHashL]
-			coffsetL := candidateL.offset - e.cur - matched + skipBeginning
-			if coffsetL >= 0 && coffsetL < s2 && s2-coffsetL < e.maxMatchOff && cv == load3232(src, coffsetL) {
+			coffsetL := candidateL.offset - e.cur - matched
+			if coffsetL >= 0 && coffsetL < s && s-coffsetL < e.maxMatchOff && cv == load3232(src, coffsetL) {
 				// Found a long match, at least 4 bytes.
-				matchedNext := e.matchlen(s2+4, coffsetL+4, src) + 4
+				matchedNext := e.matchlen(s+4, coffsetL+4, src) + 4
 				if matchedNext > matched {
 					t = coffsetL
-					s = s2
 					matched = matchedNext
 					if debugMatches {
 						println("long match at end-of-match")
@@ -438,13 +434,12 @@ encodeLoop:
 
 			// Check prev long...
 			if true {
-				coffsetL = candidateL.prev - e.cur - matched + skipBeginning
-				if coffsetL >= 0 && coffsetL < s2 && s2-coffsetL < e.maxMatchOff && cv == load3232(src, coffsetL) {
+				coffsetL = candidateL.prev - e.cur - matched
+				if coffsetL >= 0 && coffsetL < s && s-coffsetL < e.maxMatchOff && cv == load3232(src, coffsetL) {
 					// Found a long match, at least 4 bytes.
-					matchedNext := e.matchlen(s2+4, coffsetL+4, src) + 4
+					matchedNext := e.matchlen(s+4, coffsetL+4, src) + 4
 					if matchedNext > matched {
 						t = coffsetL
-						s = s2
 						matched = matchedNext
 						if debugMatches {
 							println("prev long match at end-of-match")
@@ -523,8 +518,8 @@ encodeLoop:
 			}
 
 			// Store this, since we have it.
-			nextHashL := hashLen(cv, betterLongTableBits, betterLongLen)
 			nextHashS := hashLen(cv, betterShortTableBits, betterShortLen)
+			nextHashL := hashLen(cv, betterLongTableBits, betterLongLen)
 
 			// We have at least 4 byte match.
 			// No need to check backwards. We come straight from a match
@@ -583,7 +578,7 @@ func (e *betterFastEncoderDict) Encode(blk *blockEnc, src []byte) {
 	)
 
 	// Protect against e.cur wraparound.
-	for e.cur >= e.bufferReset-int32(len(e.hist)) {
+	for e.cur >= bufferReset {
 		if len(e.hist) == 0 {
 			for i := range e.table[:] {
 				e.table[i] = tableEntry{}
@@ -679,8 +674,8 @@ encodeLoop:
 				panic("offset0 was 0")
 			}
 
-			nextHashL := hashLen(cv, betterLongTableBits, betterLongLen)
 			nextHashS := hashLen(cv, betterShortTableBits, betterShortLen)
+			nextHashL := hashLen(cv, betterLongTableBits, betterLongLen)
 			candidateL := e.longTable[nextHashL]
 			candidateS := e.table[nextHashS]
 
@@ -1052,8 +1047,8 @@ encodeLoop:
 			}
 
 			// Store this, since we have it.
-			nextHashL := hashLen(cv, betterLongTableBits, betterLongLen)
 			nextHashS := hashLen(cv, betterShortTableBits, betterShortLen)
+			nextHashL := hashLen(cv, betterLongTableBits, betterLongLen)
 
 			// We have at least 4 byte match.
 			// No need to check backwards. We come straight from a match
diff --git a/vendor/github.com/klauspost/compress/zstd/enc_dfast.go b/vendor/github.com/klauspost/compress/zstd/enc_dfast.go
index a154c18f..d6b31042 100644
--- a/vendor/github.com/klauspost/compress/zstd/enc_dfast.go
+++ b/vendor/github.com/klauspost/compress/zstd/enc_dfast.go
@@ -44,10 +44,14 @@ func (e *doubleFastEncoder) Encode(blk *blockEnc, src []byte) {
 	)
 
 	// Protect against e.cur wraparound.
-	for e.cur >= e.bufferReset-int32(len(e.hist)) {
+	for e.cur >= bufferReset {
 		if len(e.hist) == 0 {
-			e.table = [dFastShortTableSize]tableEntry{}
-			e.longTable = [dFastLongTableSize]tableEntry{}
+			for i := range e.table[:] {
+				e.table[i] = tableEntry{}
+			}
+			for i := range e.longTable[:] {
+				e.longTable[i] = tableEntry{}
+			}
 			e.cur = e.maxMatchOff
 			break
 		}
@@ -123,8 +127,8 @@ encodeLoop:
 				panic("offset0 was 0")
 			}
 
-			nextHashL := hashLen(cv, dFastLongTableBits, dFastLongLen)
 			nextHashS := hashLen(cv, dFastShortTableBits, dFastShortLen)
+			nextHashL := hashLen(cv, dFastLongTableBits, dFastLongLen)
 			candidateL := e.longTable[nextHashL]
 			candidateS := e.table[nextHashS]
 
@@ -384,7 +388,7 @@ func (e *doubleFastEncoder) EncodeNoHist(blk *blockEnc, src []byte) {
 	)
 
 	// Protect against e.cur wraparound.
-	if e.cur >= e.bufferReset {
+	if e.cur >= bufferReset {
 		for i := range e.table[:] {
 			e.table[i] = tableEntry{}
 		}
@@ -435,8 +439,8 @@ encodeLoop:
 		var t int32
 		for {
 
-			nextHashL := hashLen(cv, dFastLongTableBits, dFastLongLen)
 			nextHashS := hashLen(cv, dFastShortTableBits, dFastShortLen)
+			nextHashL := hashLen(cv, dFastLongTableBits, dFastLongLen)
 			candidateL := e.longTable[nextHashL]
 			candidateS := e.table[nextHashS]
 
@@ -681,7 +685,7 @@ encodeLoop:
 	}
 
 	// We do not store history, so we must offset e.cur to avoid false matches for next user.
-	if e.cur < e.bufferReset {
+	if e.cur < bufferReset {
 		e.cur += int32(len(src))
 	}
 }
@@ -696,7 +700,7 @@ func (e *doubleFastEncoderDict) Encode(blk *blockEnc, src []byte) {
 	)
 
 	// Protect against e.cur wraparound.
-	for e.cur >= e.bufferReset-int32(len(e.hist)) {
+	for e.cur >= bufferReset {
 		if len(e.hist) == 0 {
 			for i := range e.table[:] {
 				e.table[i] = tableEntry{}
@@ -781,8 +785,8 @@ encodeLoop:
 				panic("offset0 was 0")
 			}
 
-			nextHashL := hashLen(cv, dFastLongTableBits, dFastLongLen)
 			nextHashS := hashLen(cv, dFastShortTableBits, dFastShortLen)
+			nextHashL := hashLen(cv, dFastLongTableBits, dFastLongLen)
 			candidateL := e.longTable[nextHashL]
 			candidateS := e.table[nextHashS]
 
@@ -965,7 +969,7 @@ encodeLoop:
 		te0 := tableEntry{offset: index0 + e.cur, val: uint32(cv0)}
 		te1 := tableEntry{offset: index1 + e.cur, val: uint32(cv1)}
 		longHash1 := hashLen(cv0, dFastLongTableBits, dFastLongLen)
-		longHash2 := hashLen(cv1, dFastLongTableBits, dFastLongLen)
+		longHash2 := hashLen(cv0, dFastLongTableBits, dFastLongLen)
 		e.longTable[longHash1] = te0
 		e.longTable[longHash2] = te1
 		e.markLongShardDirty(longHash1)
@@ -998,8 +1002,8 @@ encodeLoop:
 			}
 
 			// Store this, since we have it.
-			nextHashL := hashLen(cv, dFastLongTableBits, dFastLongLen)
 			nextHashS := hashLen(cv, dFastShortTableBits, dFastShortLen)
+			nextHashL := hashLen(cv, dFastLongTableBits, dFastLongLen)
 
 			// We have at least 4 byte match.
 			// No need to check backwards. We come straight from a match
@@ -1084,7 +1088,7 @@ func (e *doubleFastEncoderDict) Reset(d *dict, singleBlock bool) {
 			}
 		}
 		e.lastDictID = d.id
-		allDirty = true
+		e.allDirty = true
 	}
 	// Reset table to initial state
 	e.cur = e.maxMatchOff
@@ -1099,8 +1103,7 @@ func (e *doubleFastEncoderDict) Reset(d *dict, singleBlock bool) {
 	}
 
 	if allDirty || dirtyShardCnt > dLongTableShardCnt/2 {
-		//copy(e.longTable[:], e.dictLongTable)
-		e.longTable = *(*[dFastLongTableSize]tableEntry)(e.dictLongTable)
+		copy(e.longTable[:], e.dictLongTable)
 		for i := range e.longTableShardDirty {
 			e.longTableShardDirty[i] = false
 		}
@@ -1111,9 +1114,7 @@ func (e *doubleFastEncoderDict) Reset(d *dict, singleBlock bool) {
 			continue
 		}
 
-		// copy(e.longTable[i*dLongTableShardSize:(i+1)*dLongTableShardSize], e.dictLongTable[i*dLongTableShardSize:(i+1)*dLongTableShardSize])
-		*(*[dLongTableShardSize]tableEntry)(e.longTable[i*dLongTableShardSize:]) = *(*[dLongTableShardSize]tableEntry)(e.dictLongTable[i*dLongTableShardSize:])
-
+		copy(e.longTable[i*dLongTableShardSize:(i+1)*dLongTableShardSize], e.dictLongTable[i*dLongTableShardSize:(i+1)*dLongTableShardSize])
 		e.longTableShardDirty[i] = false
 	}
 }
diff --git a/vendor/github.com/klauspost/compress/zstd/enc_fast.go b/vendor/github.com/klauspost/compress/zstd/enc_fast.go
index f45a3da7..f2502629 100644
--- a/vendor/github.com/klauspost/compress/zstd/enc_fast.go
+++ b/vendor/github.com/klauspost/compress/zstd/enc_fast.go
@@ -6,6 +6,8 @@ package zstd
 
 import (
 	"fmt"
+	"math"
+	"math/bits"
 )
 
 const (
@@ -43,7 +45,7 @@ func (e *fastEncoder) Encode(blk *blockEnc, src []byte) {
 	)
 
 	// Protect against e.cur wraparound.
-	for e.cur >= e.bufferReset-int32(len(e.hist)) {
+	for e.cur >= bufferReset {
 		if len(e.hist) == 0 {
 			for i := range e.table[:] {
 				e.table[i] = tableEntry{}
@@ -85,7 +87,7 @@ func (e *fastEncoder) Encode(blk *blockEnc, src []byte) {
 	// TEMPLATE
 	const hashLog = tableBits
 	// seems global, but would be nice to tweak.
-	const kSearchStrength = 6
+	const kSearchStrength = 7
 
 	// nextEmit is where in src the next emitLiteral should start from.
 	nextEmit := s
@@ -133,7 +135,21 @@ encodeLoop:
 			if canRepeat && repIndex >= 0 && load3232(src, repIndex) == uint32(cv>>16) {
 				// Consider history as well.
 				var seq seq
-				length := 4 + e.matchlen(s+6, repIndex+4, src)
+				var length int32
+				// length = 4 + e.matchlen(s+6, repIndex+4, src)
+				{
+					a := src[s+6:]
+					b := src[repIndex+4:]
+					endI := len(a) & (math.MaxInt32 - 7)
+					length = int32(endI) + 4
+					for i := 0; i < endI; i += 8 {
+						if diff := load64(a, i) ^ load64(b, i); diff != 0 {
+							length = int32(i+bits.TrailingZeros64(diff)>>3) + 4
+							break
+						}
+					}
+				}
+
 				seq.matchLen = uint32(length - zstdMinMatch)
 
 				// We might be able to match backwards.
@@ -220,7 +236,20 @@ encodeLoop:
 		}
 
 		// Extend the 4-byte match as long as possible.
-		l := e.matchlen(s+4, t+4, src) + 4
+		//l := e.matchlen(s+4, t+4, src) + 4
+		var l int32
+		{
+			a := src[s+4:]
+			b := src[t+4:]
+			endI := len(a) & (math.MaxInt32 - 7)
+			l = int32(endI) + 4
+			for i := 0; i < endI; i += 8 {
+				if diff := load64(a, i) ^ load64(b, i); diff != 0 {
+					l = int32(i+bits.TrailingZeros64(diff)>>3) + 4
+					break
+				}
+			}
+		}
 
 		// Extend backwards
 		tMin := s - e.maxMatchOff
@@ -257,7 +286,20 @@ encodeLoop:
 		if o2 := s - offset2; canRepeat && load3232(src, o2) == uint32(cv) {
 			// We have at least 4 byte match.
 			// No need to check backwards. We come straight from a match
-			l := 4 + e.matchlen(s+4, o2+4, src)
+			//l := 4 + e.matchlen(s+4, o2+4, src)
+			var l int32
+			{
+				a := src[s+4:]
+				b := src[o2+4:]
+				endI := len(a) & (math.MaxInt32 - 7)
+				l = int32(endI) + 4
+				for i := 0; i < endI; i += 8 {
+					if diff := load64(a, i) ^ load64(b, i); diff != 0 {
+						l = int32(i+bits.TrailingZeros64(diff)>>3) + 4
+						break
+					}
+				}
+			}
 
 			// Store this, since we have it.
 			nextHash := hashLen(cv, hashLog, tableFastHashLen)
@@ -303,13 +345,13 @@ func (e *fastEncoder) EncodeNoHist(blk *blockEnc, src []byte) {
 		minNonLiteralBlockSize = 1 + 1 + inputMargin
 	)
 	if debugEncoder {
-		if len(src) > maxCompressedBlockSize {
+		if len(src) > maxBlockSize {
 			panic("src too big")
 		}
 	}
 
 	// Protect against e.cur wraparound.
-	if e.cur >= e.bufferReset {
+	if e.cur >= bufferReset {
 		for i := range e.table[:] {
 			e.table[i] = tableEntry{}
 		}
@@ -333,7 +375,7 @@ func (e *fastEncoder) EncodeNoHist(blk *blockEnc, src []byte) {
 	// TEMPLATE
 	const hashLog = tableBits
 	// seems global, but would be nice to tweak.
-	const kSearchStrength = 6
+	const kSearchStrength = 8
 
 	// nextEmit is where in src the next emitLiteral should start from.
 	nextEmit := s
@@ -376,7 +418,21 @@ encodeLoop:
 			if len(blk.sequences) > 2 && load3232(src, repIndex) == uint32(cv>>16) {
 				// Consider history as well.
 				var seq seq
-				length := 4 + e.matchlen(s+6, repIndex+4, src)
+				// length := 4 + e.matchlen(s+6, repIndex+4, src)
+				// length := 4 + int32(matchLen(src[s+6:], src[repIndex+4:]))
+				var length int32
+				{
+					a := src[s+6:]
+					b := src[repIndex+4:]
+					endI := len(a) & (math.MaxInt32 - 7)
+					length = int32(endI) + 4
+					for i := 0; i < endI; i += 8 {
+						if diff := load64(a, i) ^ load64(b, i); diff != 0 {
+							length = int32(i+bits.TrailingZeros64(diff)>>3) + 4
+							break
+						}
+					}
+				}
 
 				seq.matchLen = uint32(length - zstdMinMatch)
 
@@ -466,7 +522,21 @@ encodeLoop:
 			panic(fmt.Sprintf("t (%d) < 0 ", t))
 		}
 		// Extend the 4-byte match as long as possible.
-		l := e.matchlen(s+4, t+4, src) + 4
+		//l := e.matchlenNoHist(s+4, t+4, src) + 4
+		// l := int32(matchLen(src[s+4:], src[t+4:])) + 4
+		var l int32
+		{
+			a := src[s+4:]
+			b := src[t+4:]
+			endI := len(a) & (math.MaxInt32 - 7)
+			l = int32(endI) + 4
+			for i := 0; i < endI; i += 8 {
+				if diff := load64(a, i) ^ load64(b, i); diff != 0 {
+					l = int32(i+bits.TrailingZeros64(diff)>>3) + 4
+					break
+				}
+			}
+		}
 
 		// Extend backwards
 		tMin := s - e.maxMatchOff
@@ -503,7 +573,21 @@ encodeLoop:
 		if o2 := s - offset2; len(blk.sequences) > 2 && load3232(src, o2) == uint32(cv) {
 			// We have at least 4 byte match.
 			// No need to check backwards. We come straight from a match
-			l := 4 + e.matchlen(s+4, o2+4, src)
+			//l := 4 + e.matchlenNoHist(s+4, o2+4, src)
+			// l := 4 + int32(matchLen(src[s+4:], src[o2+4:]))
+			var l int32
+			{
+				a := src[s+4:]
+				b := src[o2+4:]
+				endI := len(a) & (math.MaxInt32 - 7)
+				l = int32(endI) + 4
+				for i := 0; i < endI; i += 8 {
+					if diff := load64(a, i) ^ load64(b, i); diff != 0 {
+						l = int32(i+bits.TrailingZeros64(diff)>>3) + 4
+						break
+					}
+				}
+			}
 
 			// Store this, since we have it.
 			nextHash := hashLen(cv, hashLog, tableFastHashLen)
@@ -537,7 +621,7 @@ encodeLoop:
 		println("returning, recent offsets:", blk.recentOffsets, "extra literals:", blk.extraLits)
 	}
 	// We do not store history, so we must offset e.cur to avoid false matches for next user.
-	if e.cur < e.bufferReset {
+	if e.cur < bufferReset {
 		e.cur += int32(len(src))
 	}
 }
@@ -554,9 +638,11 @@ func (e *fastEncoderDict) Encode(blk *blockEnc, src []byte) {
 		return
 	}
 	// Protect against e.cur wraparound.
-	for e.cur >= e.bufferReset-int32(len(e.hist)) {
+	for e.cur >= bufferReset {
 		if len(e.hist) == 0 {
-			e.table = [tableSize]tableEntry{}
+			for i := range e.table[:] {
+				e.table[i] = tableEntry{}
+			}
 			e.cur = e.maxMatchOff
 			break
 		}
@@ -644,7 +730,20 @@ encodeLoop:
 			if canRepeat && repIndex >= 0 && load3232(src, repIndex) == uint32(cv>>16) {
 				// Consider history as well.
 				var seq seq
-				length := 4 + e.matchlen(s+6, repIndex+4, src)
+				var length int32
+				// length = 4 + e.matchlen(s+6, repIndex+4, src)
+				{
+					a := src[s+6:]
+					b := src[repIndex+4:]
+					endI := len(a) & (math.MaxInt32 - 7)
+					length = int32(endI) + 4
+					for i := 0; i < endI; i += 8 {
+						if diff := load64(a, i) ^ load64(b, i); diff != 0 {
+							length = int32(i+bits.TrailingZeros64(diff)>>3) + 4
+							break
+						}
+					}
+				}
 
 				seq.matchLen = uint32(length - zstdMinMatch)
 
@@ -732,7 +831,20 @@ encodeLoop:
 		}
 
 		// Extend the 4-byte match as long as possible.
-		l := e.matchlen(s+4, t+4, src) + 4
+		//l := e.matchlen(s+4, t+4, src) + 4
+		var l int32
+		{
+			a := src[s+4:]
+			b := src[t+4:]
+			endI := len(a) & (math.MaxInt32 - 7)
+			l = int32(endI) + 4
+			for i := 0; i < endI; i += 8 {
+				if diff := load64(a, i) ^ load64(b, i); diff != 0 {
+					l = int32(i+bits.TrailingZeros64(diff)>>3) + 4
+					break
+				}
+			}
+		}
 
 		// Extend backwards
 		tMin := s - e.maxMatchOff
@@ -769,7 +881,20 @@ encodeLoop:
 		if o2 := s - offset2; canRepeat && load3232(src, o2) == uint32(cv) {
 			// We have at least 4 byte match.
 			// No need to check backwards. We come straight from a match
-			l := 4 + e.matchlen(s+4, o2+4, src)
+			//l := 4 + e.matchlen(s+4, o2+4, src)
+			var l int32
+			{
+				a := src[s+4:]
+				b := src[o2+4:]
+				endI := len(a) & (math.MaxInt32 - 7)
+				l = int32(endI) + 4
+				for i := 0; i < endI; i += 8 {
+					if diff := load64(a, i) ^ load64(b, i); diff != 0 {
+						l = int32(i+bits.TrailingZeros64(diff)>>3) + 4
+						break
+					}
+				}
+			}
 
 			// Store this, since we have it.
 			nextHash := hashLen(cv, hashLog, tableFastHashLen)
@@ -829,12 +954,13 @@ func (e *fastEncoderDict) Reset(d *dict, singleBlock bool) {
 		}
 		if true {
 			end := e.maxMatchOff + int32(len(d.content)) - 8
-			for i := e.maxMatchOff; i < end; i += 2 {
+			for i := e.maxMatchOff; i < end; i += 3 {
 				const hashLog = tableBits
 
 				cv := load6432(d.content, i-e.maxMatchOff)
-				nextHash := hashLen(cv, hashLog, tableFastHashLen)     // 0 -> 6
-				nextHash1 := hashLen(cv>>8, hashLog, tableFastHashLen) // 1 -> 7
+				nextHash := hashLen(cv, hashLog, tableFastHashLen)      // 0 -> 5
+				nextHash1 := hashLen(cv>>8, hashLog, tableFastHashLen)  // 1 -> 6
+				nextHash2 := hashLen(cv>>16, hashLog, tableFastHashLen) // 2 -> 7
 				e.dictTable[nextHash] = tableEntry{
 					val:    uint32(cv),
 					offset: i,
@@ -843,6 +969,10 @@ func (e *fastEncoderDict) Reset(d *dict, singleBlock bool) {
 					val:    uint32(cv >> 8),
 					offset: i + 1,
 				}
+				e.dictTable[nextHash2] = tableEntry{
+					val:    uint32(cv >> 16),
+					offset: i + 2,
+				}
 			}
 		}
 		e.lastDictID = d.id
@@ -862,8 +992,7 @@ func (e *fastEncoderDict) Reset(d *dict, singleBlock bool) {
 	const shardCnt = tableShardCnt
 	const shardSize = tableShardSize
 	if e.allDirty || dirtyShardCnt > shardCnt*4/6 {
-		//copy(e.table[:], e.dictTable)
-		e.table = *(*[tableSize]tableEntry)(e.dictTable)
+		copy(e.table[:], e.dictTable)
 		for i := range e.tableShardDirty {
 			e.tableShardDirty[i] = false
 		}
@@ -875,8 +1004,7 @@ func (e *fastEncoderDict) Reset(d *dict, singleBlock bool) {
 			continue
 		}
 
-		//copy(e.table[i*shardSize:(i+1)*shardSize], e.dictTable[i*shardSize:(i+1)*shardSize])
-		*(*[shardSize]tableEntry)(e.table[i*shardSize:]) = *(*[shardSize]tableEntry)(e.dictTable[i*shardSize:])
+		copy(e.table[i*shardSize:(i+1)*shardSize], e.dictTable[i*shardSize:(i+1)*shardSize])
 		e.tableShardDirty[i] = false
 	}
 	e.allDirty = false
diff --git a/vendor/github.com/klauspost/compress/zstd/encoder.go b/vendor/github.com/klauspost/compress/zstd/encoder.go
index 4de0aed0..e6e31596 100644
--- a/vendor/github.com/klauspost/compress/zstd/encoder.go
+++ b/vendor/github.com/klauspost/compress/zstd/encoder.go
@@ -8,7 +8,6 @@ import (
 	"crypto/rand"
 	"fmt"
 	"io"
-	"math"
 	rdebug "runtime/debug"
 	"sync"
 
@@ -99,25 +98,23 @@ func (e *Encoder) Reset(w io.Writer) {
 	if cap(s.filling) == 0 {
 		s.filling = make([]byte, 0, e.o.blockSize)
 	}
-	if e.o.concurrent > 1 {
-		if cap(s.current) == 0 {
-			s.current = make([]byte, 0, e.o.blockSize)
-		}
-		if cap(s.previous) == 0 {
-			s.previous = make([]byte, 0, e.o.blockSize)
-		}
-		s.current = s.current[:0]
-		s.previous = s.previous[:0]
-		if s.writing == nil {
-			s.writing = &blockEnc{lowMem: e.o.lowMem}
-			s.writing.init()
-		}
-		s.writing.initNewEncode()
+	if cap(s.current) == 0 {
+		s.current = make([]byte, 0, e.o.blockSize)
+	}
+	if cap(s.previous) == 0 {
+		s.previous = make([]byte, 0, e.o.blockSize)
 	}
 	if s.encoder == nil {
 		s.encoder = e.o.encoder()
 	}
+	if s.writing == nil {
+		s.writing = &blockEnc{lowMem: e.o.lowMem}
+		s.writing.init()
+	}
+	s.writing.initNewEncode()
 	s.filling = s.filling[:0]
+	s.current = s.current[:0]
+	s.previous = s.previous[:0]
 	s.encoder.Reset(e.o.dict, false)
 	s.headerWritten = false
 	s.eofWritten = false
@@ -261,32 +258,6 @@ func (e *Encoder) nextBlock(final bool) error {
 		return s.err
 	}
 
-	// SYNC:
-	if e.o.concurrent == 1 {
-		src := s.filling
-		s.nInput += int64(len(s.filling))
-		if debugEncoder {
-			println("Adding sync block,", len(src), "bytes, final:", final)
-		}
-		enc := s.encoder
-		blk := enc.Block()
-		blk.reset(nil)
-		enc.Encode(blk, src)
-		blk.last = final
-		if final {
-			s.eofWritten = true
-		}
-
-		s.err = blk.encode(src, e.o.noEntropy, !e.o.allLitEntropy)
-		if s.err != nil {
-			return s.err
-		}
-		_, s.err = s.w.Write(blk.output)
-		s.nWritten += int64(len(blk.output))
-		s.filling = s.filling[:0]
-		return s.err
-	}
-
 	// Move blocks forward.
 	s.filling, s.current, s.previous = s.previous[:0], s.filling, s.current
 	s.nInput += int64(len(s.current))
@@ -329,8 +300,22 @@ func (e *Encoder) nextBlock(final bool) error {
 				}
 				s.wWg.Done()
 			}()
-			s.writeErr = blk.encode(src, e.o.noEntropy, !e.o.allLitEntropy)
-			if s.writeErr != nil {
+			err := errIncompressible
+			// If we got the exact same number of literals as input,
+			// assume the literals cannot be compressed.
+			if len(src) != len(blk.literals) || len(src) != e.o.blockSize {
+				err = blk.encode(src, e.o.noEntropy, !e.o.allLitEntropy)
+			}
+			switch err {
+			case errIncompressible:
+				if debugEncoder {
+					println("Storing incompressible block as raw")
+				}
+				blk.encodeRaw(src)
+				// In fast mode, we do not transfer offsets, so we don't have to deal with changing the.
+			case nil:
+			default:
+				s.writeErr = err
 				return
 			}
 			_, s.writeErr = s.w.Write(blk.output)
@@ -501,8 +486,8 @@ func (e *Encoder) EncodeAll(src, dst []byte) []byte {
 		// If a non-single block is needed the encoder will reset again.
 		e.encoders <- enc
 	}()
-	// Use single segments when above minimum window and below window size.
-	single := len(src) <= e.o.windowSize && len(src) > MinWindowSize
+	// Use single segments when above minimum window and below 1MB.
+	single := len(src) < 1<<20 && len(src) > MinWindowSize
 	if e.o.single != nil {
 		single = *e.o.single
 	}
@@ -524,7 +509,7 @@ func (e *Encoder) EncodeAll(src, dst []byte) []byte {
 	}
 
 	// If we can do everything in one block, prefer that.
-	if len(src) <= e.o.blockSize {
+	if len(src) <= maxCompressedBlockSize {
 		enc.Reset(e.o.dict, true)
 		// Slightly faster with no history and everything in one block.
 		if e.o.crc {
@@ -540,15 +525,25 @@ func (e *Encoder) EncodeAll(src, dst []byte) []byte {
 
 		// If we got the exact same number of literals as input,
 		// assume the literals cannot be compressed.
+		err := errIncompressible
 		oldout := blk.output
-		// Output directly to dst
-		blk.output = dst
+		if len(blk.literals) != len(src) || len(src) != e.o.blockSize {
+			// Output directly to dst
+			blk.output = dst
+			err = blk.encode(src, e.o.noEntropy, !e.o.allLitEntropy)
+		}
 
-		err := blk.encode(src, e.o.noEntropy, !e.o.allLitEntropy)
-		if err != nil {
+		switch err {
+		case errIncompressible:
+			if debugEncoder {
+				println("Storing incompressible block as raw")
+			}
+			dst = blk.encodeRawTo(dst, src)
+		case nil:
+			dst = blk.output
+		default:
 			panic(err)
 		}
-		dst = blk.output
 		blk.output = oldout
 	} else {
 		enc.Reset(e.o.dict, false)
@@ -567,11 +562,25 @@ func (e *Encoder) EncodeAll(src, dst []byte) []byte {
 			if len(src) == 0 {
 				blk.last = true
 			}
-			err := blk.encode(todo, e.o.noEntropy, !e.o.allLitEntropy)
-			if err != nil {
+			err := errIncompressible
+			// If we got the exact same number of literals as input,
+			// assume the literals cannot be compressed.
+			if len(blk.literals) != len(todo) || len(todo) != e.o.blockSize {
+				err = blk.encode(todo, e.o.noEntropy, !e.o.allLitEntropy)
+			}
+
+			switch err {
+			case errIncompressible:
+				if debugEncoder {
+					println("Storing incompressible block as raw")
+				}
+				dst = blk.encodeRawTo(dst, todo)
+				blk.popOffsets()
+			case nil:
+				dst = append(dst, blk.output...)
+			default:
 				panic(err)
 			}
-			dst = append(dst, blk.output...)
 			blk.reset(nil)
 		}
 	}
@@ -588,37 +597,3 @@ func (e *Encoder) EncodeAll(src, dst []byte) []byte {
 	}
 	return dst
 }
-
-// MaxEncodedSize returns the expected maximum
-// size of an encoded block or stream.
-func (e *Encoder) MaxEncodedSize(size int) int {
-	frameHeader := 4 + 2 // magic + frame header & window descriptor
-	if e.o.dict != nil {
-		frameHeader += 4
-	}
-	// Frame content size:
-	if size < 256 {
-		frameHeader++
-	} else if size < 65536+256 {
-		frameHeader += 2
-	} else if size < math.MaxInt32 {
-		frameHeader += 4
-	} else {
-		frameHeader += 8
-	}
-	// Final crc
-	if e.o.crc {
-		frameHeader += 4
-	}
-
-	// Max overhead is 3 bytes/block.
-	// There cannot be 0 blocks.
-	blocks := (size + e.o.blockSize) / e.o.blockSize
-
-	// Combine, add padding.
-	maxSz := frameHeader + 3*blocks + size
-	if e.o.pad > 1 {
-		maxSz += calcSkippableFrame(int64(maxSz), int64(e.o.pad))
-	}
-	return maxSz
-}
diff --git a/vendor/github.com/klauspost/compress/zstd/encoder_options.go b/vendor/github.com/klauspost/compress/zstd/encoder_options.go
index faaf8192..7d29e1d6 100644
--- a/vendor/github.com/klauspost/compress/zstd/encoder_options.go
+++ b/vendor/github.com/klauspost/compress/zstd/encoder_options.go
@@ -3,8 +3,6 @@ package zstd
 import (
 	"errors"
 	"fmt"
-	"math"
-	"math/bits"
 	"runtime"
 	"strings"
 )
@@ -26,7 +24,6 @@ type encoderOptions struct {
 	allLitEntropy   bool
 	customWindow    bool
 	customALEntropy bool
-	customBlockSize bool
 	lowMem          bool
 	dict            *dict
 }
@@ -36,10 +33,10 @@ func (o *encoderOptions) setDefault() {
 		concurrent:    runtime.GOMAXPROCS(0),
 		crc:           true,
 		single:        nil,
-		blockSize:     maxCompressedBlockSize,
+		blockSize:     1 << 16,
 		windowSize:    8 << 20,
 		level:         SpeedDefault,
-		allLitEntropy: false,
+		allLitEntropy: true,
 		lowMem:        false,
 	}
 }
@@ -49,22 +46,22 @@ func (o encoderOptions) encoder() encoder {
 	switch o.level {
 	case SpeedFastest:
 		if o.dict != nil {
-			return &fastEncoderDict{fastEncoder: fastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), bufferReset: math.MaxInt32 - int32(o.windowSize*2), lowMem: o.lowMem}}}
+			return &fastEncoderDict{fastEncoder: fastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), lowMem: o.lowMem}}}
 		}
-		return &fastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), bufferReset: math.MaxInt32 - int32(o.windowSize*2), lowMem: o.lowMem}}
+		return &fastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), lowMem: o.lowMem}}
 
 	case SpeedDefault:
 		if o.dict != nil {
-			return &doubleFastEncoderDict{fastEncoderDict: fastEncoderDict{fastEncoder: fastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), bufferReset: math.MaxInt32 - int32(o.windowSize*2), lowMem: o.lowMem}}}}
+			return &doubleFastEncoderDict{fastEncoderDict: fastEncoderDict{fastEncoder: fastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), lowMem: o.lowMem}}}}
 		}
-		return &doubleFastEncoder{fastEncoder: fastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), bufferReset: math.MaxInt32 - int32(o.windowSize*2), lowMem: o.lowMem}}}
+		return &doubleFastEncoder{fastEncoder: fastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), lowMem: o.lowMem}}}
 	case SpeedBetterCompression:
 		if o.dict != nil {
-			return &betterFastEncoderDict{betterFastEncoder: betterFastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), bufferReset: math.MaxInt32 - int32(o.windowSize*2), lowMem: o.lowMem}}}
+			return &betterFastEncoderDict{betterFastEncoder: betterFastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), lowMem: o.lowMem}}}
 		}
-		return &betterFastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), bufferReset: math.MaxInt32 - int32(o.windowSize*2), lowMem: o.lowMem}}
+		return &betterFastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), lowMem: o.lowMem}}
 	case SpeedBestCompression:
-		return &bestFastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), bufferReset: math.MaxInt32 - int32(o.windowSize*2), lowMem: o.lowMem}}
+		return &bestFastEncoder{fastBase: fastBase{maxMatchOff: int32(o.windowSize), lowMem: o.lowMem}}
 	}
 	panic("unknown compression level")
 }
@@ -78,7 +75,6 @@ func WithEncoderCRC(b bool) EOption {
 // WithEncoderConcurrency will set the concurrency,
 // meaning the maximum number of encoders to run concurrently.
 // The value supplied must be at least 1.
-// For streams, setting a value of 1 will disable async compression.
 // By default this will be set to GOMAXPROCS.
 func WithEncoderConcurrency(n int) EOption {
 	return func(o *encoderOptions) error {
@@ -110,7 +106,6 @@ func WithWindowSize(n int) EOption {
 		o.customWindow = true
 		if o.blockSize > o.windowSize {
 			o.blockSize = o.windowSize
-			o.customBlockSize = true
 		}
 		return nil
 	}
@@ -129,7 +124,7 @@ func WithEncoderPadding(n int) EOption {
 		}
 		// No need to waste our time.
 		if n == 1 {
-			n = 0
+			o.pad = 0
 		}
 		if n > 1<<30 {
 			return fmt.Errorf("padding must less than 1GB (1<<30 bytes) ")
@@ -193,9 +188,10 @@ func EncoderLevelFromZstd(level int) EncoderLevel {
 		return SpeedDefault
 	case level >= 6 && level < 10:
 		return SpeedBetterCompression
-	default:
+	case level >= 10:
 		return SpeedBestCompression
 	}
+	return SpeedDefault
 }
 
 // String provides a string representation of the compression level.
@@ -226,9 +222,6 @@ func WithEncoderLevel(l EncoderLevel) EOption {
 			switch o.level {
 			case SpeedFastest:
 				o.windowSize = 4 << 20
-				if !o.customBlockSize {
-					o.blockSize = 1 << 16
-				}
 			case SpeedDefault:
 				o.windowSize = 8 << 20
 			case SpeedBetterCompression:
@@ -238,7 +231,7 @@ func WithEncoderLevel(l EncoderLevel) EOption {
 			}
 		}
 		if !o.customALEntropy {
-			o.allLitEntropy = l > SpeedDefault
+			o.allLitEntropy = l > SpeedFastest
 		}
 
 		return nil
@@ -285,7 +278,7 @@ func WithNoEntropyCompression(b bool) EOption {
 // a decoder is allowed to reject a compressed frame which requests a memory size beyond decoder's authorized range.
 // For broader compatibility, decoders are recommended to support memory sizes of at least 8 MB.
 // This is only a recommendation, each decoder is free to support higher or lower limits, depending on local limitations.
-// If this is not specified, block encodes will automatically choose this based on the input size and the window size.
+// If this is not specified, block encodes will automatically choose this based on the input size.
 // This setting has no effect on streamed encodes.
 func WithSingleSegment(b bool) EOption {
 	return func(o *encoderOptions) error {
@@ -306,13 +299,7 @@ func WithLowerEncoderMem(b bool) EOption {
 }
 
 // WithEncoderDict allows to register a dictionary that will be used for the encode.
-//
-// The slice dict must be in the [dictionary format] produced by
-// "zstd --train" from the Zstandard reference implementation.
-//
 // The encoder *may* choose to use no dictionary instead for certain payloads.
-//
-// [dictionary format]: https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#dictionary-format
 func WithEncoderDict(dict []byte) EOption {
 	return func(o *encoderOptions) error {
 		d, err := loadDict(dict)
@@ -323,17 +310,3 @@ func WithEncoderDict(dict []byte) EOption {
 		return nil
 	}
 }
-
-// WithEncoderDictRaw registers a dictionary that may be used by the encoder.
-//
-// The slice content may contain arbitrary data. It will be used as an initial
-// history.
-func WithEncoderDictRaw(id uint32, content []byte) EOption {
-	return func(o *encoderOptions) error {
-		if bits.UintSize > 32 && uint(len(content)) > dictMaxLength {
-			return fmt.Errorf("dictionary of size %d > 2GiB too large", len(content))
-		}
-		o.dict = &dict{id: id, content: content, offsets: [3]int{1, 4, 8}}
-		return nil
-	}
-}
diff --git a/vendor/github.com/klauspost/compress/zstd/framedec.go b/vendor/github.com/klauspost/compress/zstd/framedec.go
index 53e160f7..989c79f8 100644
--- a/vendor/github.com/klauspost/compress/zstd/framedec.go
+++ b/vendor/github.com/klauspost/compress/zstd/framedec.go
@@ -5,20 +5,26 @@
 package zstd
 
 import (
-	"encoding/binary"
+	"bytes"
 	"encoding/hex"
 	"errors"
+	"hash"
 	"io"
+	"sync"
 
 	"github.com/klauspost/compress/zstd/internal/xxhash"
 )
 
 type frameDec struct {
-	o   decoderOptions
-	crc *xxhash.Digest
+	o      decoderOptions
+	crc    hash.Hash64
+	offset int64
 
 	WindowSize uint64
 
+	// In order queue of blocks being decoded.
+	decoding chan *blockDec
+
 	// Frame history passed between blocks
 	history history
 
@@ -28,10 +34,15 @@ type frameDec struct {
 	bBuf byteBuf
 
 	FrameContentSize uint64
+	frameDone        sync.WaitGroup
 
-	DictionaryID  uint32
+	DictionaryID  *uint32
 	HasCheckSum   bool
 	SingleSegment bool
+
+	// asyncRunning indicates whether the async routine processes input on 'decoding'.
+	asyncRunningMu sync.Mutex
+	asyncRunning   bool
 }
 
 const (
@@ -43,9 +54,9 @@ const (
 	MaxWindowSize = 1 << 29
 )
 
-const (
-	frameMagic          = "\x28\xb5\x2f\xfd"
-	skippableFrameMagic = "\x2a\x4d\x18"
+var (
+	frameMagic          = []byte{0x28, 0xb5, 0x2f, 0xfd}
+	skippableFrameMagic = []byte{0x2a, 0x4d, 0x18}
 )
 
 func newFrameDec(o decoderOptions) *frameDec {
@@ -73,25 +84,25 @@ func (d *frameDec) reset(br byteBuffer) error {
 		switch err {
 		case io.EOF, io.ErrUnexpectedEOF:
 			return io.EOF
-		case nil:
-			signature[0] = b[0]
 		default:
 			return err
+		case nil:
+			signature[0] = b[0]
 		}
 		// Read the rest, don't allow io.ErrUnexpectedEOF
 		b, err = br.readSmall(3)
 		switch err {
 		case io.EOF:
 			return io.EOF
-		case nil:
-			copy(signature[1:], b)
 		default:
 			return err
+		case nil:
+			copy(signature[1:], b)
 		}
 
-		if string(signature[1:4]) != skippableFrameMagic || signature[0]&0xf0 != 0x50 {
+		if !bytes.Equal(signature[1:4], skippableFrameMagic) || signature[0]&0xf0 != 0x50 {
 			if debugDecoder {
-				println("Not skippable", hex.EncodeToString(signature[:]), hex.EncodeToString([]byte(skippableFrameMagic)))
+				println("Not skippable", hex.EncodeToString(signature[:]), hex.EncodeToString(skippableFrameMagic))
 			}
 			// Break if not skippable frame.
 			break
@@ -106,7 +117,7 @@ func (d *frameDec) reset(br byteBuffer) error {
 		}
 		n := uint32(b[0]) | (uint32(b[1]) << 8) | (uint32(b[2]) << 16) | (uint32(b[3]) << 24)
 		println("Skipping frame with", n, "bytes.")
-		err = br.skipN(int64(n))
+		err = br.skipN(int(n))
 		if err != nil {
 			if debugDecoder {
 				println("Reading discarded frame", err)
@@ -114,9 +125,9 @@ func (d *frameDec) reset(br byteBuffer) error {
 			return err
 		}
 	}
-	if string(signature[:]) != frameMagic {
+	if !bytes.Equal(signature[:], frameMagic) {
 		if debugDecoder {
-			println("Got magic numbers: ", signature, "want:", []byte(frameMagic))
+			println("Got magic numbers: ", signature, "want:", frameMagic)
 		}
 		return ErrMagicMismatch
 	}
@@ -155,7 +166,7 @@ func (d *frameDec) reset(br byteBuffer) error {
 
 	// Read Dictionary_ID
 	// https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#dictionary_id
-	d.DictionaryID = 0
+	d.DictionaryID = nil
 	if size := fhd & 3; size != 0 {
 		if size == 3 {
 			size = 4
@@ -167,7 +178,7 @@ func (d *frameDec) reset(br byteBuffer) error {
 			return err
 		}
 		var id uint32
-		switch len(b) {
+		switch size {
 		case 1:
 			id = uint32(b[0])
 		case 2:
@@ -178,7 +189,11 @@ func (d *frameDec) reset(br byteBuffer) error {
 		if debugDecoder {
 			println("Dict size", size, "ID:", id)
 		}
-		d.DictionaryID = id
+		if id > 0 {
+			// ID 0 means "sorry, no dictionary anyway".
+			// https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#dictionary-format
+			d.DictionaryID = &id
+		}
 	}
 
 	// Read Frame_Content_Size
@@ -193,14 +208,14 @@ func (d *frameDec) reset(br byteBuffer) error {
 	default:
 		fcsSize = 1 << v
 	}
-	d.FrameContentSize = fcsUnknown
+	d.FrameContentSize = 0
 	if fcsSize > 0 {
 		b, err := br.readSmall(fcsSize)
 		if err != nil {
 			println("Reading Frame content", err)
 			return err
 		}
-		switch len(b) {
+		switch fcsSize {
 		case 1:
 			d.FrameContentSize = uint64(b[0])
 		case 2:
@@ -214,10 +229,9 @@ func (d *frameDec) reset(br byteBuffer) error {
 			d.FrameContentSize = uint64(d1) | (uint64(d2) << 32)
 		}
 		if debugDecoder {
-			println("Read FCS:", d.FrameContentSize)
+			println("field size bits:", v, "fcsSize:", fcsSize, "FrameContentSize:", d.FrameContentSize, hex.EncodeToString(b[:fcsSize]), "singleseg:", d.SingleSegment, "window:", d.WindowSize)
 		}
 	}
-
 	// Move this to shared.
 	d.HasCheckSum = fhd&(1<<2) != 0
 	if d.HasCheckSum {
@@ -227,27 +241,20 @@ func (d *frameDec) reset(br byteBuffer) error {
 		d.crc.Reset()
 	}
 
-	if d.WindowSize > d.o.maxWindowSize {
-		if debugDecoder {
-			printf("window size %d > max %d\n", d.WindowSize, d.o.maxWindowSize)
-		}
-		return ErrWindowSizeExceeded
-	}
-
 	if d.WindowSize == 0 && d.SingleSegment {
 		// We may not need window in this case.
 		d.WindowSize = d.FrameContentSize
 		if d.WindowSize < MinWindowSize {
 			d.WindowSize = MinWindowSize
 		}
-		if d.WindowSize > d.o.maxDecodedSize {
-			if debugDecoder {
-				printf("window size %d > max %d\n", d.WindowSize, d.o.maxWindowSize)
-			}
-			return ErrDecoderSizeExceeded
-		}
 	}
 
+	if d.WindowSize > uint64(d.o.maxWindowSize) {
+		if debugDecoder {
+			printf("window size %d > max %d\n", d.WindowSize, d.o.maxWindowSize)
+		}
+		return ErrWindowSizeExceeded
+	}
 	// The minimum Window_Size is 1 KB.
 	if d.WindowSize < MinWindowSize {
 		if debugDecoder {
@@ -256,23 +263,11 @@ func (d *frameDec) reset(br byteBuffer) error {
 		return ErrWindowSizeTooSmall
 	}
 	d.history.windowSize = int(d.WindowSize)
-	if !d.o.lowMem || d.history.windowSize < maxBlockSize {
-		// Alloc 2x window size if not low-mem, or window size below 2MB.
-		d.history.allocFrameBuffer = d.history.windowSize * 2
+	if d.o.lowMem && d.history.windowSize < maxBlockSize {
+		d.history.maxSize = d.history.windowSize * 2
 	} else {
-		if d.o.lowMem {
-			// Alloc with 1MB extra.
-			d.history.allocFrameBuffer = d.history.windowSize + maxBlockSize/2
-		} else {
-			// Alloc with 2MB extra.
-			d.history.allocFrameBuffer = d.history.windowSize + maxBlockSize
-		}
+		d.history.maxSize = d.history.windowSize + maxBlockSize
 	}
-
-	if debugDecoder {
-		println("Frame: Dict:", d.DictionaryID, "FrameContentSize:", d.FrameContentSize, "singleseg:", d.SingleSegment, "window:", d.WindowSize, "crc:", d.HasCheckSum)
-	}
-
 	// history contains input - maybe we do something
 	d.rawInput = br
 	return nil
@@ -281,85 +276,209 @@ func (d *frameDec) reset(br byteBuffer) error {
 // next will start decoding the next block from stream.
 func (d *frameDec) next(block *blockDec) error {
 	if debugDecoder {
-		println("decoding new block")
+		printf("decoding new block %p:%p", block, block.data)
 	}
 	err := block.reset(d.rawInput, d.WindowSize)
 	if err != nil {
 		println("block error:", err)
 		// Signal the frame decoder we have a problem.
-		block.sendErr(err)
+		d.sendErr(block, err)
 		return err
 	}
+	block.input <- struct{}{}
+	if debugDecoder {
+		println("next block:", block)
+	}
+	d.asyncRunningMu.Lock()
+	defer d.asyncRunningMu.Unlock()
+	if !d.asyncRunning {
+		return nil
+	}
+	if block.Last {
+		// We indicate the frame is done by sending io.EOF
+		d.decoding <- block
+		return io.EOF
+	}
+	d.decoding <- block
 	return nil
 }
 
-// checkCRC will check the checksum, assuming the frame has one.
+// sendEOF will queue an error block on the frame.
+// This will cause the frame decoder to return when it encounters the block.
+// Returns true if the decoder was added.
+func (d *frameDec) sendErr(block *blockDec, err error) bool {
+	d.asyncRunningMu.Lock()
+	defer d.asyncRunningMu.Unlock()
+	if !d.asyncRunning {
+		return false
+	}
+
+	println("sending error", err.Error())
+	block.sendErr(err)
+	d.decoding <- block
+	return true
+}
+
+// checkCRC will check the checksum if the frame has one.
 // Will return ErrCRCMismatch if crc check failed, otherwise nil.
 func (d *frameDec) checkCRC() error {
+	if !d.HasCheckSum {
+		return nil
+	}
+	var tmp [4]byte
+	got := d.crc.Sum64()
+	// Flip to match file order.
+	tmp[0] = byte(got >> 0)
+	tmp[1] = byte(got >> 8)
+	tmp[2] = byte(got >> 16)
+	tmp[3] = byte(got >> 24)
+
 	// We can overwrite upper tmp now
-	buf, err := d.rawInput.readSmall(4)
+	want, err := d.rawInput.readSmall(4)
 	if err != nil {
 		println("CRC missing?", err)
 		return err
 	}
 
-	want := binary.LittleEndian.Uint32(buf[:4])
-	got := uint32(d.crc.Sum64())
-
-	if got != want {
+	if !bytes.Equal(tmp[:], want) {
 		if debugDecoder {
-			printf("CRC check failed: got %08x, want %08x\n", got, want)
+			println("CRC Check Failed:", tmp[:], "!=", want)
 		}
 		return ErrCRCMismatch
 	}
 	if debugDecoder {
-		printf("CRC ok %08x\n", got)
+		println("CRC ok", tmp[:])
 	}
 	return nil
 }
 
-// consumeCRC skips over the checksum, assuming the frame has one.
-func (d *frameDec) consumeCRC() error {
-	_, err := d.rawInput.readSmall(4)
-	if err != nil {
-		println("CRC missing?", err)
+func (d *frameDec) initAsync() {
+	if !d.o.lowMem && !d.SingleSegment {
+		// set max extra size history to 2MB.
+		d.history.maxSize = d.history.windowSize + maxBlockSize
+	}
+	// re-alloc if more than one extra block size.
+	if d.o.lowMem && cap(d.history.b) > d.history.maxSize+maxBlockSize {
+		d.history.b = make([]byte, 0, d.history.maxSize)
+	}
+	if cap(d.history.b) < d.history.maxSize {
+		d.history.b = make([]byte, 0, d.history.maxSize)
+	}
+	if cap(d.decoding) < d.o.concurrent {
+		d.decoding = make(chan *blockDec, d.o.concurrent)
 	}
-	return err
+	if debugDecoder {
+		h := d.history
+		printf("history init. len: %d, cap: %d", len(h.b), cap(h.b))
+	}
+	d.asyncRunningMu.Lock()
+	d.asyncRunning = true
+	d.asyncRunningMu.Unlock()
 }
 
-// runDecoder will run the decoder for the remainder of the frame.
+// startDecoder will start decoding blocks and write them to the writer.
+// The decoder will stop as soon as an error occurs or at end of frame.
+// When the frame has finished decoding the *bufio.Reader
+// containing the remaining input will be sent on frameDec.frameDone.
+func (d *frameDec) startDecoder(output chan decodeOutput) {
+	written := int64(0)
+
+	defer func() {
+		d.asyncRunningMu.Lock()
+		d.asyncRunning = false
+		d.asyncRunningMu.Unlock()
+
+		// Drain the currently decoding.
+		d.history.error = true
+	flushdone:
+		for {
+			select {
+			case b := <-d.decoding:
+				b.history <- &d.history
+				output <- <-b.result
+			default:
+				break flushdone
+			}
+		}
+		println("frame decoder done, signalling done")
+		d.frameDone.Done()
+	}()
+	// Get decoder for first block.
+	block := <-d.decoding
+	block.history <- &d.history
+	for {
+		var next *blockDec
+		// Get result
+		r := <-block.result
+		if r.err != nil {
+			println("Result contained error", r.err)
+			output <- r
+			return
+		}
+		if debugDecoder {
+			println("got result, from ", d.offset, "to", d.offset+int64(len(r.b)))
+			d.offset += int64(len(r.b))
+		}
+		if !block.Last {
+			// Send history to next block
+			select {
+			case next = <-d.decoding:
+				if debugDecoder {
+					println("Sending ", len(d.history.b), "bytes as history")
+				}
+				next.history <- &d.history
+			default:
+				// Wait until we have sent the block, so
+				// other decoders can potentially get the decoder.
+				next = nil
+			}
+		}
+
+		// Add checksum, async to decoding.
+		if d.HasCheckSum {
+			n, err := d.crc.Write(r.b)
+			if err != nil {
+				r.err = err
+				if n != len(r.b) {
+					r.err = io.ErrShortWrite
+				}
+				output <- r
+				return
+			}
+		}
+		written += int64(len(r.b))
+		if d.SingleSegment && uint64(written) > d.FrameContentSize {
+			println("runDecoder: single segment and", uint64(written), ">", d.FrameContentSize)
+			r.err = ErrFrameSizeExceeded
+			output <- r
+			return
+		}
+		if block.Last {
+			r.err = d.checkCRC()
+			output <- r
+			return
+		}
+		output <- r
+		if next == nil {
+			// There was no decoder available, we wait for one now that we have sent to the writer.
+			if debugDecoder {
+				println("Sending ", len(d.history.b), " bytes as history")
+			}
+			next = <-d.decoding
+			next.history <- &d.history
+		}
+		block = next
+	}
+}
+
+// runDecoder will create a sync decoder that will decode a block of data.
 func (d *frameDec) runDecoder(dst []byte, dec *blockDec) ([]byte, error) {
 	saved := d.history.b
 
 	// We use the history for output to avoid copying it.
 	d.history.b = dst
-	d.history.ignoreBuffer = len(dst)
 	// Store input length, so we only check new data.
 	crcStart := len(dst)
-	d.history.decoders.maxSyncLen = 0
-	if d.o.limitToCap {
-		d.history.decoders.maxSyncLen = uint64(cap(dst) - len(dst))
-	}
-	if d.FrameContentSize != fcsUnknown {
-		if !d.o.limitToCap || d.FrameContentSize+uint64(len(dst)) < d.history.decoders.maxSyncLen {
-			d.history.decoders.maxSyncLen = d.FrameContentSize + uint64(len(dst))
-		}
-		if d.history.decoders.maxSyncLen > d.o.maxDecodedSize {
-			if debugDecoder {
-				println("maxSyncLen:", d.history.decoders.maxSyncLen, "> maxDecodedSize:", d.o.maxDecodedSize)
-			}
-			return dst, ErrDecoderSizeExceeded
-		}
-		if debugDecoder {
-			println("maxSyncLen:", d.history.decoders.maxSyncLen)
-		}
-		if !d.o.limitToCap && uint64(cap(dst)) < d.history.decoders.maxSyncLen {
-			// Alloc for output
-			dst2 := make([]byte, len(dst), d.history.decoders.maxSyncLen+compressedBlockOverAlloc)
-			copy(dst2, dst)
-			dst = dst2
-		}
-	}
 	var err error
 	for {
 		err = dec.reset(d.rawInput, d.WindowSize)
@@ -370,41 +489,30 @@ func (d *frameDec) runDecoder(dst []byte, dec *blockDec) ([]byte, error) {
 			println("next block:", dec)
 		}
 		err = dec.decodeBuf(&d.history)
-		if err != nil {
-			break
-		}
-		if uint64(len(d.history.b)-crcStart) > d.o.maxDecodedSize {
-			println("runDecoder: maxDecodedSize exceeded", uint64(len(d.history.b)-crcStart), ">", d.o.maxDecodedSize)
-			err = ErrDecoderSizeExceeded
+		if err != nil || dec.Last {
 			break
 		}
-		if d.o.limitToCap && len(d.history.b) > cap(dst) {
-			println("runDecoder: cap exceeded", uint64(len(d.history.b)), ">", cap(dst))
+		if uint64(len(d.history.b)) > d.o.maxDecodedSize {
 			err = ErrDecoderSizeExceeded
 			break
 		}
-		if uint64(len(d.history.b)-crcStart) > d.FrameContentSize {
-			println("runDecoder: FrameContentSize exceeded", uint64(len(d.history.b)-crcStart), ">", d.FrameContentSize)
+		if d.SingleSegment && uint64(len(d.history.b)) > d.o.maxDecodedSize {
+			println("runDecoder: single segment and", uint64(len(d.history.b)), ">", d.o.maxDecodedSize)
 			err = ErrFrameSizeExceeded
 			break
 		}
-		if dec.Last {
-			break
-		}
-		if debugDecoder {
-			println("runDecoder: FrameContentSize", uint64(len(d.history.b)-crcStart), "<=", d.FrameContentSize)
-		}
 	}
 	dst = d.history.b
 	if err == nil {
-		if d.FrameContentSize != fcsUnknown && uint64(len(d.history.b)-crcStart) != d.FrameContentSize {
-			err = ErrFrameSizeMismatch
-		} else if d.HasCheckSum {
-			if d.o.ignoreChecksum {
-				err = d.consumeCRC()
-			} else {
-				d.crc.Write(dst[crcStart:])
-				err = d.checkCRC()
+		if d.HasCheckSum {
+			var n int
+			n, err = d.crc.Write(dst[crcStart:])
+			if err == nil {
+				if n != len(dst)-crcStart {
+					err = io.ErrShortWrite
+				} else {
+					err = d.checkCRC()
+				}
 			}
 		}
 	}
diff --git a/vendor/github.com/klauspost/compress/zstd/fse_decoder.go b/vendor/github.com/klauspost/compress/zstd/fse_decoder.go
index 2f8860a7..e6d3d49b 100644
--- a/vendor/github.com/klauspost/compress/zstd/fse_decoder.go
+++ b/vendor/github.com/klauspost/compress/zstd/fse_decoder.go
@@ -5,10 +5,8 @@
 package zstd
 
 import (
-	"encoding/binary"
 	"errors"
 	"fmt"
-	"io"
 )
 
 const (
@@ -180,32 +178,10 @@ func (s *fseDecoder) readNCount(b *byteReader, maxSymbol uint16) error {
 		return fmt.Errorf("corruption detected (total %d != %d)", gotTotal, 1<<s.actualTableLog)
 	}
 	b.advance((bitCount + 7) >> 3)
+	// println(s.norm[:s.symbolLen], s.symbolLen)
 	return s.buildDtable()
 }
 
-func (s *fseDecoder) mustReadFrom(r io.Reader) {
-	fatalErr := func(err error) {
-		if err != nil {
-			panic(err)
-		}
-	}
-	// 	dt             [maxTablesize]decSymbol // Decompression table.
-	//	symbolLen      uint16                  // Length of active part of the symbol table.
-	//	actualTableLog uint8                   // Selected tablelog.
-	//	maxBits        uint8                   // Maximum number of additional bits
-	//	// used for table creation to avoid allocations.
-	//	stateTable [256]uint16
-	//	norm       [maxSymbolValue + 1]int16
-	//	preDefined bool
-	fatalErr(binary.Read(r, binary.LittleEndian, &s.dt))
-	fatalErr(binary.Read(r, binary.LittleEndian, &s.symbolLen))
-	fatalErr(binary.Read(r, binary.LittleEndian, &s.actualTableLog))
-	fatalErr(binary.Read(r, binary.LittleEndian, &s.maxBits))
-	fatalErr(binary.Read(r, binary.LittleEndian, &s.stateTable))
-	fatalErr(binary.Read(r, binary.LittleEndian, &s.norm))
-	fatalErr(binary.Read(r, binary.LittleEndian, &s.preDefined))
-}
-
 // decSymbol contains information about a state entry,
 // Including the state offset base, the output symbol and
 // the number of bits to read for the low part of the destination state.
@@ -228,10 +204,18 @@ func (d decSymbol) newState() uint16 {
 	return uint16(d >> 16)
 }
 
+func (d decSymbol) baseline() uint32 {
+	return uint32(d >> 32)
+}
+
 func (d decSymbol) baselineInt() int {
 	return int(d >> 32)
 }
 
+func (d *decSymbol) set(nbits, addBits uint8, newState uint16, baseline uint32) {
+	*d = decSymbol(nbits) | (decSymbol(addBits) << 8) | (decSymbol(newState) << 16) | (decSymbol(baseline) << 32)
+}
+
 func (d *decSymbol) setNBits(nBits uint8) {
 	const mask = 0xffffffffffffff00
 	*d = (*d & mask) | decSymbol(nBits)
@@ -247,6 +231,11 @@ func (d *decSymbol) setNewState(state uint16) {
 	*d = (*d & mask) | decSymbol(state)<<16
 }
 
+func (d *decSymbol) setBaseline(baseline uint32) {
+	const mask = 0xffffffff
+	*d = (*d & mask) | decSymbol(baseline)<<32
+}
+
 func (d *decSymbol) setExt(addBits uint8, baseline uint32) {
 	const mask = 0xffff00ff
 	*d = (*d & mask) | (decSymbol(addBits) << 8) | (decSymbol(baseline) << 32)
@@ -268,6 +257,68 @@ func (s *fseDecoder) setRLE(symbol decSymbol) {
 	s.dt[0] = symbol
 }
 
+// buildDtable will build the decoding table.
+func (s *fseDecoder) buildDtable() error {
+	tableSize := uint32(1 << s.actualTableLog)
+	highThreshold := tableSize - 1
+	symbolNext := s.stateTable[:256]
+
+	// Init, lay down lowprob symbols
+	{
+		for i, v := range s.norm[:s.symbolLen] {
+			if v == -1 {
+				s.dt[highThreshold].setAddBits(uint8(i))
+				highThreshold--
+				symbolNext[i] = 1
+			} else {
+				symbolNext[i] = uint16(v)
+			}
+		}
+	}
+	// Spread symbols
+	{
+		tableMask := tableSize - 1
+		step := tableStep(tableSize)
+		position := uint32(0)
+		for ss, v := range s.norm[:s.symbolLen] {
+			for i := 0; i < int(v); i++ {
+				s.dt[position].setAddBits(uint8(ss))
+				position = (position + step) & tableMask
+				for position > highThreshold {
+					// lowprob area
+					position = (position + step) & tableMask
+				}
+			}
+		}
+		if position != 0 {
+			// position must reach all cells once, otherwise normalizedCounter is incorrect
+			return errors.New("corrupted input (position != 0)")
+		}
+	}
+
+	// Build Decoding table
+	{
+		tableSize := uint16(1 << s.actualTableLog)
+		for u, v := range s.dt[:tableSize] {
+			symbol := v.addBits()
+			nextState := symbolNext[symbol]
+			symbolNext[symbol] = nextState + 1
+			nBits := s.actualTableLog - byte(highBits(uint32(nextState)))
+			s.dt[u&maxTableMask].setNBits(nBits)
+			newState := (nextState << nBits) - tableSize
+			if newState > tableSize {
+				return fmt.Errorf("newState (%d) outside table size (%d)", newState, tableSize)
+			}
+			if newState == uint16(u) && nBits == 0 {
+				// Seems weird that this is possible with nbits > 0.
+				return fmt.Errorf("newState (%d) == oldState (%d) and no bits", newState, u)
+			}
+			s.dt[u&maxTableMask].setNewState(newState)
+		}
+	}
+	return nil
+}
+
 // transform will transform the decoder table into a table usable for
 // decoding without having to apply the transformation while decoding.
 // The state will contain the base value and the number of bits to read.
@@ -301,7 +352,34 @@ func (s *fseState) init(br *bitReader, tableLog uint8, dt []decSymbol) {
 	s.state = dt[br.getBits(tableLog)]
 }
 
+// next returns the current symbol and sets the next state.
+// At least tablelog bits must be available in the bit reader.
+func (s *fseState) next(br *bitReader) {
+	lowBits := uint16(br.getBits(s.state.nbBits()))
+	s.state = s.dt[s.state.newState()+lowBits]
+}
+
+// finished returns true if all bits have been read from the bitstream
+// and the next state would require reading bits from the input.
+func (s *fseState) finished(br *bitReader) bool {
+	return br.finished() && s.state.nbBits() > 0
+}
+
+// final returns the current state symbol without decoding the next.
+func (s *fseState) final() (int, uint8) {
+	return s.state.baselineInt(), s.state.addBits()
+}
+
 // final returns the current state symbol without decoding the next.
 func (s decSymbol) final() (int, uint8) {
 	return s.baselineInt(), s.addBits()
 }
+
+// nextFast returns the next symbol and sets the next state.
+// This can only be used if no symbols are 0 bits.
+// At least tablelog bits must be available in the bit reader.
+func (s *fseState) nextFast(br *bitReader) (uint32, uint8) {
+	lowBits := uint16(br.getBitsFast(s.state.nbBits()))
+	s.state = s.dt[s.state.newState()+lowBits]
+	return s.state.baseline(), s.state.addBits()
+}
diff --git a/vendor/github.com/klauspost/compress/zstd/fse_encoder.go b/vendor/github.com/klauspost/compress/zstd/fse_encoder.go
index ab26326a..b4757ee3 100644
--- a/vendor/github.com/klauspost/compress/zstd/fse_encoder.go
+++ b/vendor/github.com/klauspost/compress/zstd/fse_encoder.go
@@ -62,8 +62,9 @@ func (s symbolTransform) String() string {
 // To indicate that you have populated the histogram call HistogramFinished
 // with the value of the highest populated symbol, as well as the number of entries
 // in the most populated entry. These are accepted at face value.
-func (s *fseEncoder) Histogram() *[256]uint32 {
-	return &s.count
+// The returned slice will always be length 256.
+func (s *fseEncoder) Histogram() []uint32 {
+	return s.count[:]
 }
 
 // HistogramFinished can be called to indicate that the histogram has been populated.
@@ -76,6 +77,21 @@ func (s *fseEncoder) HistogramFinished(maxSymbol uint8, maxCount int) {
 	s.clearCount = maxCount != 0
 }
 
+// prepare will prepare and allocate scratch tables used for both compression and decompression.
+func (s *fseEncoder) prepare() (*fseEncoder, error) {
+	if s == nil {
+		s = &fseEncoder{}
+	}
+	s.useRLE = false
+	if s.clearCount && s.maxCount == 0 {
+		for i := range s.count {
+			s.count[i] = 0
+		}
+		s.clearCount = false
+	}
+	return s, nil
+}
+
 // allocCtable will allocate tables needed for compression.
 // If existing tables a re big enough, they are simply re-used.
 func (s *fseEncoder) allocCtable() {
@@ -694,6 +710,14 @@ func (c *cState) init(bw *bitWriter, ct *cTable, first symbolTransform) {
 	c.state = c.stateTable[lu]
 }
 
+// encode the output symbol provided and write it to the bitstream.
+func (c *cState) encode(symbolTT symbolTransform) {
+	nbBitsOut := (uint32(c.state) + symbolTT.deltaNbBits) >> 16
+	dstState := int32(c.state>>(nbBitsOut&15)) + int32(symbolTT.deltaFindState)
+	c.bw.addBits16NC(c.state, uint8(nbBitsOut))
+	c.state = c.stateTable[dstState]
+}
+
 // flush will write the tablelog to the output and flush the remaining full bytes.
 func (c *cState) flush(tableLog uint8) {
 	c.bw.flush32()
diff --git a/vendor/github.com/klauspost/compress/zstd/hash.go b/vendor/github.com/klauspost/compress/zstd/hash.go
index 5d73c21e..cf33f29a 100644
--- a/vendor/github.com/klauspost/compress/zstd/hash.go
+++ b/vendor/github.com/klauspost/compress/zstd/hash.go
@@ -33,3 +33,9 @@ func hashLen(u uint64, length, mls uint8) uint32 {
 		return (uint32(u) * prime4bytes) >> (32 - length)
 	}
 }
+
+// hash3 returns the hash of the lower 3 bytes of u to fit in a hash table with h bits.
+// Preferably h should be a constant and should always be <32.
+func hash3(u uint32, h uint8) uint32 {
+	return ((u << (32 - 24)) * prime3bytes) >> ((32 - h) & 31)
+}
diff --git a/vendor/github.com/klauspost/compress/zstd/history.go b/vendor/github.com/klauspost/compress/zstd/history.go
index 09164856..f783e32d 100644
--- a/vendor/github.com/klauspost/compress/zstd/history.go
+++ b/vendor/github.com/klauspost/compress/zstd/history.go
@@ -10,48 +10,40 @@ import (
 
 // history contains the information transferred between blocks.
 type history struct {
-	// Literal decompression
-	huffTree *huff0.Scratch
-
-	// Sequence decompression
-	decoders      sequenceDecs
+	b             []byte
+	huffTree      *huff0.Scratch
 	recentOffsets [3]int
-
-	// History buffer...
-	b []byte
-
-	// ignoreBuffer is meant to ignore a number of bytes
-	// when checking for matches in history
-	ignoreBuffer int
-
-	windowSize       int
-	allocFrameBuffer int // needed?
-	error            bool
-	dict             *dict
+	decoders      sequenceDecs
+	windowSize    int
+	maxSize       int
+	error         bool
+	dict          *dict
 }
 
 // reset will reset the history to initial state of a frame.
 // The history must already have been initialized to the desired size.
 func (h *history) reset() {
 	h.b = h.b[:0]
-	h.ignoreBuffer = 0
 	h.error = false
 	h.recentOffsets = [3]int{1, 4, 8}
-	h.decoders.freeDecoders()
-	h.decoders = sequenceDecs{br: h.decoders.br}
-	h.freeHuffDecoder()
-	h.huffTree = nil
-	h.dict = nil
-	//printf("history created: %+v (l: %d, c: %d)", *h, len(h.b), cap(h.b))
-}
-
-func (h *history) freeHuffDecoder() {
+	if f := h.decoders.litLengths.fse; f != nil && !f.preDefined {
+		fseDecoderPool.Put(f)
+	}
+	if f := h.decoders.offsets.fse; f != nil && !f.preDefined {
+		fseDecoderPool.Put(f)
+	}
+	if f := h.decoders.matchLengths.fse; f != nil && !f.preDefined {
+		fseDecoderPool.Put(f)
+	}
+	h.decoders = sequenceDecs{}
 	if h.huffTree != nil {
 		if h.dict == nil || h.dict.litEnc != h.huffTree {
 			huffDecoderPool.Put(h.huffTree)
-			h.huffTree = nil
 		}
 	}
+	h.huffTree = nil
+	h.dict = nil
+	//printf("history created: %+v (l: %d, c: %d)", *h, len(h.b), cap(h.b))
 }
 
 func (h *history) setDict(dict *dict) {
@@ -62,7 +54,6 @@ func (h *history) setDict(dict *dict) {
 	h.decoders.litLengths = dict.llDec
 	h.decoders.offsets = dict.ofDec
 	h.decoders.matchLengths = dict.mlDec
-	h.decoders.dict = dict.content
 	h.recentOffsets = dict.offsets
 	h.huffTree = dict.litEnc
 }
@@ -92,24 +83,6 @@ func (h *history) append(b []byte) {
 	copy(h.b[h.windowSize-len(b):], b)
 }
 
-// ensureBlock will ensure there is space for at least one block...
-func (h *history) ensureBlock() {
-	if cap(h.b) < h.allocFrameBuffer {
-		h.b = make([]byte, 0, h.allocFrameBuffer)
-		return
-	}
-
-	avail := cap(h.b) - len(h.b)
-	if avail >= h.windowSize || avail > maxCompressedBlockSize {
-		return
-	}
-	// Move data down so we only have window size left.
-	// We know we have less than window size in b at this point.
-	discard := len(h.b) - h.windowSize
-	copy(h.b, h.b[discard:])
-	h.b = h.b[:h.windowSize]
-}
-
 // append bytes to history without ever discarding anything.
 func (h *history) appendKeep(b []byte) {
 	h.b = append(h.b, b...)
diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/README.md b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/README.md
index 777290d4..69aa3bb5 100644
--- a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/README.md
+++ b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/README.md
@@ -2,7 +2,12 @@
 
 VENDORED: Go to [github.com/cespare/xxhash](https://github.com/cespare/xxhash) for original package.
 
-xxhash is a Go implementation of the 64-bit [xxHash] algorithm, XXH64. This is a
+
+[![GoDoc](https://godoc.org/github.com/cespare/xxhash?status.svg)](https://godoc.org/github.com/cespare/xxhash)
+[![Build Status](https://travis-ci.org/cespare/xxhash.svg?branch=master)](https://travis-ci.org/cespare/xxhash)
+
+xxhash is a Go implementation of the 64-bit
+[xxHash](http://cyan4973.github.io/xxHash/) algorithm, XXH64. This is a
 high-quality hashing algorithm that is much faster than anything in the Go
 standard library.
 
@@ -23,49 +28,31 @@ func (*Digest) WriteString(string) (int, error)
 func (*Digest) Sum64() uint64
 ```
 
-The package is written with optimized pure Go and also contains even faster
-assembly implementations for amd64 and arm64. If desired, the `purego` build tag
-opts into using the Go code even on those architectures.
-
-[xxHash]: http://cyan4973.github.io/xxHash/
-
-## Compatibility
-
-This package is in a module and the latest code is in version 2 of the module.
-You need a version of Go with at least "minimal module compatibility" to use
-github.com/cespare/xxhash/v2:
-
-* 1.9.7+ for Go 1.9
-* 1.10.3+ for Go 1.10
-* Go 1.11 or later
-
-I recommend using the latest release of Go.
+This implementation provides a fast pure-Go implementation and an even faster
+assembly implementation for amd64.
 
 ## Benchmarks
 
 Here are some quick benchmarks comparing the pure-Go and assembly
 implementations of Sum64.
 
-| input size | purego    | asm       |
-| ---------- | --------- | --------- |
-| 4 B        |  1.3 GB/s |  1.2 GB/s |
-| 16 B       |  2.9 GB/s |  3.5 GB/s |
-| 100 B      |  6.9 GB/s |  8.1 GB/s |
-| 4 KB       | 11.7 GB/s | 16.7 GB/s |
-| 10 MB      | 12.0 GB/s | 17.3 GB/s |
+| input size | purego | asm |
+| --- | --- | --- |
+| 5 B   |  979.66 MB/s |  1291.17 MB/s  |
+| 100 B | 7475.26 MB/s | 7973.40 MB/s  |
+| 4 KB  | 17573.46 MB/s | 17602.65 MB/s |
+| 10 MB | 17131.46 MB/s | 17142.16 MB/s |
 
-These numbers were generated on Ubuntu 20.04 with an Intel Xeon Platinum 8252C
-CPU using the following commands under Go 1.19.2:
+These numbers were generated on Ubuntu 18.04 with an Intel i7-8700K CPU using
+the following commands under Go 1.11.2:
 
 ```
-benchstat <(go test -tags purego -benchtime 500ms -count 15 -bench 'Sum64$')
-benchstat <(go test -benchtime 500ms -count 15 -bench 'Sum64$')
+$ go test -tags purego -benchtime 10s -bench '/xxhash,direct,bytes'
+$ go test -benchtime 10s -bench '/xxhash,direct,bytes'
 ```
 
 ## Projects using this package
 
 - [InfluxDB](https://github.com/influxdata/influxdb)
 - [Prometheus](https://github.com/prometheus/prometheus)
-- [VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics)
 - [FreeCache](https://github.com/coocood/freecache)
-- [FastCache](https://github.com/VictoriaMetrics/fastcache)
diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash.go b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash.go
index fc40c820..2c112a0a 100644
--- a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash.go
+++ b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash.go
@@ -18,11 +18,19 @@ const (
 	prime5 uint64 = 2870177450012600261
 )
 
-// Store the primes in an array as well.
-//
-// The consts are used when possible in Go code to avoid MOVs but we need a
-// contiguous array of the assembly code.
-var primes = [...]uint64{prime1, prime2, prime3, prime4, prime5}
+// NOTE(caleb): I'm using both consts and vars of the primes. Using consts where
+// possible in the Go code is worth a small (but measurable) performance boost
+// by avoiding some MOVQs. Vars are needed for the asm and also are useful for
+// convenience in the Go code in a few places where we need to intentionally
+// avoid constant arithmetic (e.g., v1 := prime1 + prime2 fails because the
+// result overflows a uint64).
+var (
+	prime1v = prime1
+	prime2v = prime2
+	prime3v = prime3
+	prime4v = prime4
+	prime5v = prime5
+)
 
 // Digest implements hash.Hash64.
 type Digest struct {
@@ -44,10 +52,10 @@ func New() *Digest {
 
 // Reset clears the Digest's state so that it can be reused.
 func (d *Digest) Reset() {
-	d.v1 = primes[0] + prime2
+	d.v1 = prime1v + prime2
 	d.v2 = prime2
 	d.v3 = 0
-	d.v4 = -primes[0]
+	d.v4 = -prime1v
 	d.total = 0
 	d.n = 0
 }
@@ -63,23 +71,21 @@ func (d *Digest) Write(b []byte) (n int, err error) {
 	n = len(b)
 	d.total += uint64(n)
 
-	memleft := d.mem[d.n&(len(d.mem)-1):]
-
 	if d.n+n < 32 {
 		// This new data doesn't even fill the current block.
-		copy(memleft, b)
+		copy(d.mem[d.n:], b)
 		d.n += n
 		return
 	}
 
 	if d.n > 0 {
 		// Finish off the partial block.
-		c := copy(memleft, b)
+		copy(d.mem[d.n:], b)
 		d.v1 = round(d.v1, u64(d.mem[0:8]))
 		d.v2 = round(d.v2, u64(d.mem[8:16]))
 		d.v3 = round(d.v3, u64(d.mem[16:24]))
 		d.v4 = round(d.v4, u64(d.mem[24:32]))
-		b = b[c:]
+		b = b[32-d.n:]
 		d.n = 0
 	}
 
@@ -129,20 +135,21 @@ func (d *Digest) Sum64() uint64 {
 
 	h += d.total
 
-	b := d.mem[:d.n&(len(d.mem)-1)]
-	for ; len(b) >= 8; b = b[8:] {
-		k1 := round(0, u64(b[:8]))
+	i, end := 0, d.n
+	for ; i+8 <= end; i += 8 {
+		k1 := round(0, u64(d.mem[i:i+8]))
 		h ^= k1
 		h = rol27(h)*prime1 + prime4
 	}
-	if len(b) >= 4 {
-		h ^= uint64(u32(b[:4])) * prime1
+	if i+4 <= end {
+		h ^= uint64(u32(d.mem[i:i+4])) * prime1
 		h = rol23(h)*prime2 + prime3
-		b = b[4:]
+		i += 4
 	}
-	for ; len(b) > 0; b = b[1:] {
-		h ^= uint64(b[0]) * prime5
+	for i < end {
+		h ^= uint64(d.mem[i]) * prime5
 		h = rol11(h) * prime1
+		i++
 	}
 
 	h ^= h >> 33
diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_amd64.go b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_amd64.go
new file mode 100644
index 00000000..0ae847f7
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_amd64.go
@@ -0,0 +1,12 @@
+//go:build !appengine && gc && !purego
+// +build !appengine,gc,!purego
+
+package xxhash
+
+// Sum64 computes the 64-bit xxHash digest of b.
+//
+//go:noescape
+func Sum64(b []byte) uint64
+
+//go:noescape
+func writeBlocks(d *Digest, b []byte) int
diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_amd64.s b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_amd64.s
index ddb63aa9..be8db5bf 100644
--- a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_amd64.s
+++ b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_amd64.s
@@ -1,210 +1,215 @@
-//go:build !appengine && gc && !purego && !noasm
 // +build !appengine
 // +build gc
 // +build !purego
-// +build !noasm
 
 #include "textflag.h"
 
-// Registers:
-#define h      AX
-#define d      AX
-#define p      SI // pointer to advance through b
-#define n      DX
-#define end    BX // loop end
-#define v1     R8
-#define v2     R9
-#define v3     R10
-#define v4     R11
-#define x      R12
-#define prime1 R13
-#define prime2 R14
-#define prime4 DI
-
-#define round(acc, x) \
-	IMULQ prime2, x   \
-	ADDQ  x, acc      \
-	ROLQ  $31, acc    \
-	IMULQ prime1, acc
-
-// round0 performs the operation x = round(0, x).
-#define round0(x) \
-	IMULQ prime2, x \
-	ROLQ  $31, x    \
-	IMULQ prime1, x
-
-// mergeRound applies a merge round on the two registers acc and x.
-// It assumes that prime1, prime2, and prime4 have been loaded.
-#define mergeRound(acc, x) \
-	round0(x)         \
-	XORQ  x, acc      \
-	IMULQ prime1, acc \
-	ADDQ  prime4, acc
-
-// blockLoop processes as many 32-byte blocks as possible,
-// updating v1, v2, v3, and v4. It assumes that there is at least one block
-// to process.
-#define blockLoop() \
-loop:  \
-	MOVQ +0(p), x  \
-	round(v1, x)   \
-	MOVQ +8(p), x  \
-	round(v2, x)   \
-	MOVQ +16(p), x \
-	round(v3, x)   \
-	MOVQ +24(p), x \
-	round(v4, x)   \
-	ADDQ $32, p    \
-	CMPQ p, end    \
-	JLE  loop
+// Register allocation:
+// AX	h
+// SI	pointer to advance through b
+// DX	n
+// BX	loop end
+// R8	v1, k1
+// R9	v2
+// R10	v3
+// R11	v4
+// R12	tmp
+// R13	prime1v
+// R14	prime2v
+// DI	prime4v
+
+// round reads from and advances the buffer pointer in SI.
+// It assumes that R13 has prime1v and R14 has prime2v.
+#define round(r) \
+	MOVQ  (SI), R12 \
+	ADDQ  $8, SI    \
+	IMULQ R14, R12  \
+	ADDQ  R12, r    \
+	ROLQ  $31, r    \
+	IMULQ R13, r
+
+// mergeRound applies a merge round on the two registers acc and val.
+// It assumes that R13 has prime1v, R14 has prime2v, and DI has prime4v.
+#define mergeRound(acc, val) \
+	IMULQ R14, val \
+	ROLQ  $31, val \
+	IMULQ R13, val \
+	XORQ  val, acc \
+	IMULQ R13, acc \
+	ADDQ  DI, acc
 
 // func Sum64(b []byte) uint64
-TEXT ·Sum64(SB), NOSPLIT|NOFRAME, $0-32
+TEXT ·Sum64(SB), NOSPLIT, $0-32
 	// Load fixed primes.
-	MOVQ ·primes+0(SB), prime1
-	MOVQ ·primes+8(SB), prime2
-	MOVQ ·primes+24(SB), prime4
+	MOVQ ·prime1v(SB), R13
+	MOVQ ·prime2v(SB), R14
+	MOVQ ·prime4v(SB), DI
 
 	// Load slice.
-	MOVQ b_base+0(FP), p
-	MOVQ b_len+8(FP), n
-	LEAQ (p)(n*1), end
+	MOVQ b_base+0(FP), SI
+	MOVQ b_len+8(FP), DX
+	LEAQ (SI)(DX*1), BX
 
 	// The first loop limit will be len(b)-32.
-	SUBQ $32, end
+	SUBQ $32, BX
 
 	// Check whether we have at least one block.
-	CMPQ n, $32
+	CMPQ DX, $32
 	JLT  noBlocks
 
 	// Set up initial state (v1, v2, v3, v4).
-	MOVQ prime1, v1
-	ADDQ prime2, v1
-	MOVQ prime2, v2
-	XORQ v3, v3
-	XORQ v4, v4
-	SUBQ prime1, v4
-
-	blockLoop()
-
-	MOVQ v1, h
-	ROLQ $1, h
-	MOVQ v2, x
-	ROLQ $7, x
-	ADDQ x, h
-	MOVQ v3, x
-	ROLQ $12, x
-	ADDQ x, h
-	MOVQ v4, x
-	ROLQ $18, x
-	ADDQ x, h
-
-	mergeRound(h, v1)
-	mergeRound(h, v2)
-	mergeRound(h, v3)
-	mergeRound(h, v4)
+	MOVQ R13, R8
+	ADDQ R14, R8
+	MOVQ R14, R9
+	XORQ R10, R10
+	XORQ R11, R11
+	SUBQ R13, R11
+
+	// Loop until SI > BX.
+blockLoop:
+	round(R8)
+	round(R9)
+	round(R10)
+	round(R11)
+
+	CMPQ SI, BX
+	JLE  blockLoop
+
+	MOVQ R8, AX
+	ROLQ $1, AX
+	MOVQ R9, R12
+	ROLQ $7, R12
+	ADDQ R12, AX
+	MOVQ R10, R12
+	ROLQ $12, R12
+	ADDQ R12, AX
+	MOVQ R11, R12
+	ROLQ $18, R12
+	ADDQ R12, AX
+
+	mergeRound(AX, R8)
+	mergeRound(AX, R9)
+	mergeRound(AX, R10)
+	mergeRound(AX, R11)
 
 	JMP afterBlocks
 
 noBlocks:
-	MOVQ ·primes+32(SB), h
+	MOVQ ·prime5v(SB), AX
 
 afterBlocks:
-	ADDQ n, h
-
-	ADDQ $24, end
-	CMPQ p, end
-	JG   try4
-
-loop8:
-	MOVQ  (p), x
-	ADDQ  $8, p
-	round0(x)
-	XORQ  x, h
-	ROLQ  $27, h
-	IMULQ prime1, h
-	ADDQ  prime4, h
-
-	CMPQ p, end
-	JLE  loop8
-
-try4:
-	ADDQ $4, end
-	CMPQ p, end
-	JG   try1
-
-	MOVL  (p), x
-	ADDQ  $4, p
-	IMULQ prime1, x
-	XORQ  x, h
-
-	ROLQ  $23, h
-	IMULQ prime2, h
-	ADDQ  ·primes+16(SB), h
-
-try1:
-	ADDQ $4, end
-	CMPQ p, end
+	ADDQ DX, AX
+
+	// Right now BX has len(b)-32, and we want to loop until SI > len(b)-8.
+	ADDQ $24, BX
+
+	CMPQ SI, BX
+	JG   fourByte
+
+wordLoop:
+	// Calculate k1.
+	MOVQ  (SI), R8
+	ADDQ  $8, SI
+	IMULQ R14, R8
+	ROLQ  $31, R8
+	IMULQ R13, R8
+
+	XORQ  R8, AX
+	ROLQ  $27, AX
+	IMULQ R13, AX
+	ADDQ  DI, AX
+
+	CMPQ SI, BX
+	JLE  wordLoop
+
+fourByte:
+	ADDQ $4, BX
+	CMPQ SI, BX
+	JG   singles
+
+	MOVL  (SI), R8
+	ADDQ  $4, SI
+	IMULQ R13, R8
+	XORQ  R8, AX
+
+	ROLQ  $23, AX
+	IMULQ R14, AX
+	ADDQ  ·prime3v(SB), AX
+
+singles:
+	ADDQ $4, BX
+	CMPQ SI, BX
 	JGE  finalize
 
-loop1:
-	MOVBQZX (p), x
-	ADDQ    $1, p
-	IMULQ   ·primes+32(SB), x
-	XORQ    x, h
-	ROLQ    $11, h
-	IMULQ   prime1, h
+singlesLoop:
+	MOVBQZX (SI), R12
+	ADDQ    $1, SI
+	IMULQ   ·prime5v(SB), R12
+	XORQ    R12, AX
 
-	CMPQ p, end
-	JL   loop1
+	ROLQ  $11, AX
+	IMULQ R13, AX
+
+	CMPQ SI, BX
+	JL   singlesLoop
 
 finalize:
-	MOVQ  h, x
-	SHRQ  $33, x
-	XORQ  x, h
-	IMULQ prime2, h
-	MOVQ  h, x
-	SHRQ  $29, x
-	XORQ  x, h
-	IMULQ ·primes+16(SB), h
-	MOVQ  h, x
-	SHRQ  $32, x
-	XORQ  x, h
-
-	MOVQ h, ret+24(FP)
+	MOVQ  AX, R12
+	SHRQ  $33, R12
+	XORQ  R12, AX
+	IMULQ R14, AX
+	MOVQ  AX, R12
+	SHRQ  $29, R12
+	XORQ  R12, AX
+	IMULQ ·prime3v(SB), AX
+	MOVQ  AX, R12
+	SHRQ  $32, R12
+	XORQ  R12, AX
+
+	MOVQ AX, ret+24(FP)
 	RET
 
+// writeBlocks uses the same registers as above except that it uses AX to store
+// the d pointer.
+
 // func writeBlocks(d *Digest, b []byte) int
-TEXT ·writeBlocks(SB), NOSPLIT|NOFRAME, $0-40
+TEXT ·writeBlocks(SB), NOSPLIT, $0-40
 	// Load fixed primes needed for round.
-	MOVQ ·primes+0(SB), prime1
-	MOVQ ·primes+8(SB), prime2
+	MOVQ ·prime1v(SB), R13
+	MOVQ ·prime2v(SB), R14
 
 	// Load slice.
-	MOVQ b_base+8(FP), p
-	MOVQ b_len+16(FP), n
-	LEAQ (p)(n*1), end
-	SUBQ $32, end
+	MOVQ b_base+8(FP), SI
+	MOVQ b_len+16(FP), DX
+	LEAQ (SI)(DX*1), BX
+	SUBQ $32, BX
 
 	// Load vN from d.
-	MOVQ s+0(FP), d
-	MOVQ 0(d), v1
-	MOVQ 8(d), v2
-	MOVQ 16(d), v3
-	MOVQ 24(d), v4
+	MOVQ d+0(FP), AX
+	MOVQ 0(AX), R8   // v1
+	MOVQ 8(AX), R9   // v2
+	MOVQ 16(AX), R10 // v3
+	MOVQ 24(AX), R11 // v4
 
 	// We don't need to check the loop condition here; this function is
 	// always called with at least one block of data to process.
-	blockLoop()
+blockLoop:
+	round(R8)
+	round(R9)
+	round(R10)
+	round(R11)
+
+	CMPQ SI, BX
+	JLE  blockLoop
 
 	// Copy vN back to d.
-	MOVQ v1, 0(d)
-	MOVQ v2, 8(d)
-	MOVQ v3, 16(d)
-	MOVQ v4, 24(d)
-
-	// The number of bytes written is p minus the old base pointer.
-	SUBQ b_base+8(FP), p
-	MOVQ p, ret+32(FP)
+	MOVQ R8, 0(AX)
+	MOVQ R9, 8(AX)
+	MOVQ R10, 16(AX)
+	MOVQ R11, 24(AX)
+
+	// The number of bytes written is SI minus the old base pointer.
+	SUBQ b_base+8(FP), SI
+	MOVQ SI, ret+32(FP)
 
 	RET
diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_other.go b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_other.go
index 0be16cef..1f52f296 100644
--- a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_other.go
+++ b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_other.go
@@ -1,5 +1,5 @@
-//go:build (!amd64 && !arm64) || appengine || !gc || purego || noasm
-// +build !amd64,!arm64 appengine !gc purego noasm
+//go:build !amd64 || appengine || !gc || purego
+// +build !amd64 appengine !gc purego
 
 package xxhash
 
@@ -15,10 +15,10 @@ func Sum64(b []byte) uint64 {
 	var h uint64
 
 	if n >= 32 {
-		v1 := primes[0] + prime2
+		v1 := prime1v + prime2
 		v2 := prime2
 		v3 := uint64(0)
-		v4 := -primes[0]
+		v4 := -prime1v
 		for len(b) >= 32 {
 			v1 = round(v1, u64(b[0:8:len(b)]))
 			v2 = round(v2, u64(b[8:16:len(b)]))
@@ -37,18 +37,19 @@ func Sum64(b []byte) uint64 {
 
 	h += uint64(n)
 
-	for ; len(b) >= 8; b = b[8:] {
-		k1 := round(0, u64(b[:8]))
+	i, end := 0, len(b)
+	for ; i+8 <= end; i += 8 {
+		k1 := round(0, u64(b[i:i+8:len(b)]))
 		h ^= k1
 		h = rol27(h)*prime1 + prime4
 	}
-	if len(b) >= 4 {
-		h ^= uint64(u32(b[:4])) * prime1
+	if i+4 <= end {
+		h ^= uint64(u32(b[i:i+4:len(b)])) * prime1
 		h = rol23(h)*prime2 + prime3
-		b = b[4:]
+		i += 4
 	}
-	for ; len(b) > 0; b = b[1:] {
-		h ^= uint64(b[0]) * prime5
+	for ; i < end; i++ {
+		h ^= uint64(b[i]) * prime5
 		h = rol11(h) * prime1
 	}
 
diff --git a/vendor/github.com/klauspost/compress/zstd/seqdec.go b/vendor/github.com/klauspost/compress/zstd/seqdec.go
index 9405fcf1..1dd39e63 100644
--- a/vendor/github.com/klauspost/compress/zstd/seqdec.go
+++ b/vendor/github.com/klauspost/compress/zstd/seqdec.go
@@ -20,10 +20,6 @@ type seq struct {
 	llCode, mlCode, ofCode uint8
 }
 
-type seqVals struct {
-	ll, ml, mo int
-}
-
 func (s seq) String() string {
 	if s.offset <= 3 {
 		if s.offset == 0 {
@@ -65,19 +61,16 @@ type sequenceDecs struct {
 	offsets      sequenceDec
 	matchLengths sequenceDec
 	prevOffset   [3]int
+	hist         []byte
 	dict         []byte
 	literals     []byte
 	out          []byte
-	nSeqs        int
-	br           *bitReader
-	seqSize      int
 	windowSize   int
 	maxBits      uint8
-	maxSyncLen   uint64
 }
 
 // initialize all 3 decoders from the stream input.
-func (s *sequenceDecs) initialize(br *bitReader, hist *history, out []byte) error {
+func (s *sequenceDecs) initialize(br *bitReader, hist *history, literals, out []byte) error {
 	if err := s.litLengths.init(br); err != nil {
 		return errors.New("litLengths:" + err.Error())
 	}
@@ -87,7 +80,8 @@ func (s *sequenceDecs) initialize(br *bitReader, hist *history, out []byte) erro
 	if err := s.matchLengths.init(br); err != nil {
 		return errors.New("matchLengths:" + err.Error())
 	}
-	s.br = br
+	s.literals = literals
+	s.hist = hist.b
 	s.prevOffset = hist.recentOffsets
 	s.maxBits = s.litLengths.fse.maxBits + s.offsets.fse.maxBits + s.matchLengths.fse.maxBits
 	s.windowSize = hist.windowSize
@@ -99,149 +93,16 @@ func (s *sequenceDecs) initialize(br *bitReader, hist *history, out []byte) erro
 	return nil
 }
 
-func (s *sequenceDecs) freeDecoders() {
-	if f := s.litLengths.fse; f != nil && !f.preDefined {
-		fseDecoderPool.Put(f)
-		s.litLengths.fse = nil
-	}
-	if f := s.offsets.fse; f != nil && !f.preDefined {
-		fseDecoderPool.Put(f)
-		s.offsets.fse = nil
-	}
-	if f := s.matchLengths.fse; f != nil && !f.preDefined {
-		fseDecoderPool.Put(f)
-		s.matchLengths.fse = nil
-	}
-}
-
-// execute will execute the decoded sequence with the provided history.
-// The sequence must be evaluated before being sent.
-func (s *sequenceDecs) execute(seqs []seqVals, hist []byte) error {
-	if len(s.dict) == 0 {
-		return s.executeSimple(seqs, hist)
-	}
-
-	// Ensure we have enough output size...
-	if len(s.out)+s.seqSize > cap(s.out) {
-		addBytes := s.seqSize + len(s.out)
-		s.out = append(s.out, make([]byte, addBytes)...)
-		s.out = s.out[:len(s.out)-addBytes]
-	}
-
-	if debugDecoder {
-		printf("Execute %d seqs with hist %d, dict %d, literals: %d into %d bytes\n", len(seqs), len(hist), len(s.dict), len(s.literals), s.seqSize)
-	}
-
-	var t = len(s.out)
-	out := s.out[:t+s.seqSize]
-
-	for _, seq := range seqs {
-		// Add literals
-		copy(out[t:], s.literals[:seq.ll])
-		t += seq.ll
-		s.literals = s.literals[seq.ll:]
-
-		// Copy from dictionary...
-		if seq.mo > t+len(hist) || seq.mo > s.windowSize {
-			if len(s.dict) == 0 {
-				return fmt.Errorf("match offset (%d) bigger than current history (%d)", seq.mo, t+len(hist))
-			}
-
-			// we may be in dictionary.
-			dictO := len(s.dict) - (seq.mo - (t + len(hist)))
-			if dictO < 0 || dictO >= len(s.dict) {
-				return fmt.Errorf("match offset (%d) bigger than current history+dict (%d)", seq.mo, t+len(hist)+len(s.dict))
-			}
-			end := dictO + seq.ml
-			if end > len(s.dict) {
-				n := len(s.dict) - dictO
-				copy(out[t:], s.dict[dictO:])
-				t += n
-				seq.ml -= n
-			} else {
-				copy(out[t:], s.dict[dictO:end])
-				t += end - dictO
-				continue
-			}
-		}
-
-		// Copy from history.
-		if v := seq.mo - t; v > 0 {
-			// v is the start position in history from end.
-			start := len(hist) - v
-			if seq.ml > v {
-				// Some goes into current block.
-				// Copy remainder of history
-				copy(out[t:], hist[start:])
-				t += v
-				seq.ml -= v
-			} else {
-				copy(out[t:], hist[start:start+seq.ml])
-				t += seq.ml
-				continue
-			}
-		}
-		// We must be in current buffer now
-		if seq.ml > 0 {
-			start := t - seq.mo
-			if seq.ml <= t-start {
-				// No overlap
-				copy(out[t:], out[start:start+seq.ml])
-				t += seq.ml
-				continue
-			} else {
-				// Overlapping copy
-				// Extend destination slice and copy one byte at the time.
-				src := out[start : start+seq.ml]
-				dst := out[t:]
-				dst = dst[:len(src)]
-				t += len(src)
-				// Destination is the space we just added.
-				for i := range src {
-					dst[i] = src[i]
-				}
-			}
-		}
-	}
-
-	// Add final literals
-	copy(out[t:], s.literals)
-	if debugDecoder {
-		t += len(s.literals)
-		if t != len(out) {
-			panic(fmt.Errorf("length mismatch, want %d, got %d, ss: %d", len(out), t, s.seqSize))
-		}
-	}
-	s.out = out
-
-	return nil
-}
-
 // decode sequences from the stream with the provided history.
-func (s *sequenceDecs) decodeSync(hist []byte) error {
-	supported, err := s.decodeSyncSimple(hist)
-	if supported {
-		return err
-	}
-
-	br := s.br
-	seqs := s.nSeqs
+func (s *sequenceDecs) decode(seqs int, br *bitReader, hist []byte) error {
 	startSize := len(s.out)
 	// Grab full sizes tables, to avoid bounds checks.
 	llTable, mlTable, ofTable := s.litLengths.fse.dt[:maxTablesize], s.matchLengths.fse.dt[:maxTablesize], s.offsets.fse.dt[:maxTablesize]
 	llState, mlState, ofState := s.litLengths.state.state, s.matchLengths.state.state, s.offsets.state.state
-	out := s.out
-	maxBlockSize := maxCompressedBlockSize
-	if s.windowSize < maxBlockSize {
-		maxBlockSize = s.windowSize
-	}
 
-	if debugDecoder {
-		println("decodeSync: decoding", seqs, "sequences", br.remain(), "bits remain on stream")
-	}
 	for i := seqs - 1; i >= 0; i-- {
 		if br.overread() {
-			printf("reading sequence %d, exceeded available data. Overread by %d\n", seqs-i, -br.remain())
+			printf("reading sequence %d, exceeded available data\n", seqs-i)
 			return io.ErrUnexpectedEOF
 		}
 		var ll, mo, ml int
@@ -290,7 +151,7 @@ func (s *sequenceDecs) decodeSync(hist []byte) error {
 
 					if temp == 0 {
 						// 0 is not valid; input is corrupted; force offset to 1
-						println("WARNING: temp was 0")
+						println("temp was 0")
 						temp = 1
 					}
 
@@ -315,49 +176,51 @@ func (s *sequenceDecs) decodeSync(hist []byte) error {
 		if ll > len(s.literals) {
 			return fmt.Errorf("unexpected literal count, want %d bytes, but only %d is available", ll, len(s.literals))
 		}
-		size := ll + ml + len(out)
+		size := ll + ml + len(s.out)
 		if size-startSize > maxBlockSize {
-			return fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
+			return fmt.Errorf("output (%d) bigger than max block size", size)
 		}
-		if size > cap(out) {
+		if size > cap(s.out) {
 			// Not enough size, which can happen under high volume block streaming conditions
 			// but could be if destination slice is too small for sync operations.
 			// over-allocating here can create a large amount of GC pressure so we try to keep
 			// it as contained as possible
-			used := len(out) - startSize
+			used := len(s.out) - startSize
 			addBytes := 256 + ll + ml + used>>2
 			// Clamp to max block size.
 			if used+addBytes > maxBlockSize {
 				addBytes = maxBlockSize - used
 			}
-			out = append(out, make([]byte, addBytes)...)
-			out = out[:len(out)-addBytes]
+			s.out = append(s.out, make([]byte, addBytes)...)
+			s.out = s.out[:len(s.out)-addBytes]
 		}
 		if ml > maxMatchLen {
 			return fmt.Errorf("match len (%d) bigger than max allowed length", ml)
 		}
 
 		// Add literals
-		out = append(out, s.literals[:ll]...)
+		s.out = append(s.out, s.literals[:ll]...)
 		s.literals = s.literals[ll:]
+		out := s.out
 
 		if mo == 0 && ml > 0 {
 			return fmt.Errorf("zero matchoff and matchlen (%d) > 0", ml)
 		}
 
-		if mo > len(out)+len(hist) || mo > s.windowSize {
+		if mo > len(s.out)+len(hist) || mo > s.windowSize {
 			if len(s.dict) == 0 {
-				return fmt.Errorf("match offset (%d) bigger than current history (%d)", mo, len(out)+len(hist)-startSize)
+				return fmt.Errorf("match offset (%d) bigger than current history (%d)", mo, len(s.out)+len(hist))
 			}
 
 			// we may be in dictionary.
-			dictO := len(s.dict) - (mo - (len(out) + len(hist)))
+			dictO := len(s.dict) - (mo - (len(s.out) + len(hist)))
 			if dictO < 0 || dictO >= len(s.dict) {
-				return fmt.Errorf("match offset (%d) bigger than current history (%d)", mo, len(out)+len(hist)-startSize)
+				return fmt.Errorf("match offset (%d) bigger than current history (%d)", mo, len(s.out)+len(hist))
 			}
 			end := dictO + ml
 			if end > len(s.dict) {
 				out = append(out, s.dict[dictO:]...)
+				mo -= len(s.dict) - dictO
 				ml -= len(s.dict) - dictO
 			} else {
 				out = append(out, s.dict[dictO:end]...)
@@ -368,25 +231,26 @@ func (s *sequenceDecs) decodeSync(hist []byte) error {
 
 		// Copy from history.
 		// TODO: Blocks without history could be made to ignore this completely.
-		if v := mo - len(out); v > 0 {
+		if v := mo - len(s.out); v > 0 {
 			// v is the start position in history from end.
-			start := len(hist) - v
+			start := len(s.hist) - v
 			if ml > v {
 				// Some goes into current block.
 				// Copy remainder of history
-				out = append(out, hist[start:]...)
+				out = append(out, s.hist[start:]...)
+				mo -= v
 				ml -= v
 			} else {
-				out = append(out, hist[start:start+ml]...)
+				out = append(out, s.hist[start:start+ml]...)
 				ml = 0
 			}
 		}
 		// We must be in current buffer now
 		if ml > 0 {
-			start := len(out) - mo
-			if ml <= len(out)-start {
+			start := len(s.out) - mo
+			if ml <= len(s.out)-start {
 				// No overlap
-				out = append(out, out[start:start+ml]...)
+				out = append(out, s.out[start:start+ml]...)
 			} else {
 				// Overlapping copy
 				// Extend destination slice and copy one byte at the time.
@@ -400,6 +264,7 @@ func (s *sequenceDecs) decodeSync(hist []byte) error {
 				}
 			}
 		}
+		s.out = out
 		if i == 0 {
 			// This is the last sequence, so we shouldn't update state.
 			break
@@ -413,8 +278,7 @@ func (s *sequenceDecs) decodeSync(hist []byte) error {
 			mlState = mlTable[mlState.newState()&maxTableMask]
 			ofState = ofTable[ofState.newState()&maxTableMask]
 		} else {
-			bits := br.get32BitsFast(nBits)
-
+			bits := br.getBitsFast(nBits)
 			lowBits := uint16(bits >> ((ofState.nbBits() + mlState.nbBits()) & 31))
 			llState = llTable[(llState.newState()+lowBits)&maxTableMask]
 
@@ -427,13 +291,19 @@ func (s *sequenceDecs) decodeSync(hist []byte) error {
 		}
 	}
 
-	if size := len(s.literals) + len(out) - startSize; size > maxBlockSize {
-		return fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
-	}
-
 	// Add final literals
-	s.out = append(out, s.literals...)
-	return br.close()
+	s.out = append(s.out, s.literals...)
+	return nil
+}
+
+// update states, at least 27 bits must be available.
+func (s *sequenceDecs) update(br *bitReader) {
+	// Max 8 bits
+	s.litLengths.state.next(br)
+	// Max 9 bits
+	s.matchLengths.state.next(br)
+	// Max 8 bits
+	s.offsets.state.next(br)
 }
 
 var bitMask [16]uint16
@@ -444,6 +314,87 @@ func init() {
 	}
 }
 
+// update states, at least 27 bits must be available.
+func (s *sequenceDecs) updateAlt(br *bitReader) {
+	// Update all 3 states at once. Approx 20% faster.
+	a, b, c := s.litLengths.state.state, s.matchLengths.state.state, s.offsets.state.state
+
+	nBits := a.nbBits() + b.nbBits() + c.nbBits()
+	if nBits == 0 {
+		s.litLengths.state.state = s.litLengths.state.dt[a.newState()]
+		s.matchLengths.state.state = s.matchLengths.state.dt[b.newState()]
+		s.offsets.state.state = s.offsets.state.dt[c.newState()]
+		return
+	}
+	bits := br.getBitsFast(nBits)
+	lowBits := uint16(bits >> ((c.nbBits() + b.nbBits()) & 31))
+	s.litLengths.state.state = s.litLengths.state.dt[a.newState()+lowBits]
+
+	lowBits = uint16(bits >> (c.nbBits() & 31))
+	lowBits &= bitMask[b.nbBits()&15]
+	s.matchLengths.state.state = s.matchLengths.state.dt[b.newState()+lowBits]
+
+	lowBits = uint16(bits) & bitMask[c.nbBits()&15]
+	s.offsets.state.state = s.offsets.state.dt[c.newState()+lowBits]
+}
+
+// nextFast will return new states when there are at least 4 unused bytes left on the stream when done.
+func (s *sequenceDecs) nextFast(br *bitReader, llState, mlState, ofState decSymbol) (ll, mo, ml int) {
+	// Final will not read from stream.
+	ll, llB := llState.final()
+	ml, mlB := mlState.final()
+	mo, moB := ofState.final()
+
+	// extra bits are stored in reverse order.
+	br.fillFast()
+	mo += br.getBits(moB)
+	if s.maxBits > 32 {
+		br.fillFast()
+	}
+	ml += br.getBits(mlB)
+	ll += br.getBits(llB)
+
+	if moB > 1 {
+		s.prevOffset[2] = s.prevOffset[1]
+		s.prevOffset[1] = s.prevOffset[0]
+		s.prevOffset[0] = mo
+		return
+	}
+	// mo = s.adjustOffset(mo, ll, moB)
+	// Inlined for rather big speedup
+	if ll == 0 {
+		// There is an exception though, when current sequence's literals_length = 0.
+		// In this case, repeated offsets are shifted by one, so an offset_value of 1 means Repeated_Offset2,
+		// an offset_value of 2 means Repeated_Offset3, and an offset_value of 3 means Repeated_Offset1 - 1_byte.
+		mo++
+	}
+
+	if mo == 0 {
+		mo = s.prevOffset[0]
+		return
+	}
+	var temp int
+	if mo == 3 {
+		temp = s.prevOffset[0] - 1
+	} else {
+		temp = s.prevOffset[mo]
+	}
+
+	if temp == 0 {
+		// 0 is not valid; input is corrupted; force offset to 1
+		println("temp was 0")
+		temp = 1
+	}
+
+	if mo != 1 {
+		s.prevOffset[2] = s.prevOffset[1]
+	}
+	s.prevOffset[1] = s.prevOffset[0]
+	s.prevOffset[0] = temp
+	mo = temp
+	return
+}
+
 func (s *sequenceDecs) next(br *bitReader, llState, mlState, ofState decSymbol) (ll, mo, ml int) {
 	// Final will not read from stream.
 	ll, llB := llState.final()
@@ -506,3 +457,36 @@ func (s *sequenceDecs) adjustOffset(offset, litLen int, offsetB uint8) int {
 	s.prevOffset[0] = temp
 	return temp
 }
+
+// mergeHistory will merge history.
+func (s *sequenceDecs) mergeHistory(hist *sequenceDecs) (*sequenceDecs, error) {
+	for i := uint(0); i < 3; i++ {
+		var sNew, sHist *sequenceDec
+		switch i {
+		default:
+			// same as "case 0":
+			sNew = &s.litLengths
+			sHist = &hist.litLengths
+		case 1:
+			sNew = &s.offsets
+			sHist = &hist.offsets
+		case 2:
+			sNew = &s.matchLengths
+			sHist = &hist.matchLengths
+		}
+		if sNew.repeat {
+			if sHist.fse == nil {
+				return nil, fmt.Errorf("sequence stream %d, repeat requested, but no history", i)
+			}
+			continue
+		}
+		if sNew.fse == nil {
+			return nil, fmt.Errorf("sequence stream %d, no fse found", i)
+		}
+		if sHist.fse != nil && !sHist.fse.preDefined {
+			fseDecoderPool.Put(sHist.fse)
+		}
+		sHist.fse = sNew.fse
+	}
+	return hist, nil
+}
diff --git a/vendor/github.com/klauspost/compress/zstd/zip.go b/vendor/github.com/klauspost/compress/zstd/zip.go
index 29c15c8c..967f29b3 100644
--- a/vendor/github.com/klauspost/compress/zstd/zip.go
+++ b/vendor/github.com/klauspost/compress/zstd/zip.go
@@ -18,58 +18,36 @@ const ZipMethodWinZip = 93
 // See https://pkware.cachefly.net/webdocs/APPNOTE/APPNOTE-6.3.9.TXT
 const ZipMethodPKWare = 20
 
-// zipReaderPool is the default reader pool.
-var zipReaderPool = sync.Pool{New: func() interface{} {
-	z, err := NewReader(nil, WithDecoderLowmem(true), WithDecoderMaxWindow(128<<20), WithDecoderConcurrency(1))
-	if err != nil {
-		panic(err)
-	}
-	return z
-}}
+var zipReaderPool sync.Pool
 
-// newZipReader creates a pooled zip decompressor.
-func newZipReader(opts ...DOption) func(r io.Reader) io.ReadCloser {
-	pool := &zipReaderPool
-	if len(opts) > 0 {
-		opts = append([]DOption{WithDecoderLowmem(true), WithDecoderMaxWindow(128 << 20)}, opts...)
-		// Force concurrency 1
-		opts = append(opts, WithDecoderConcurrency(1))
-		// Create our own pool
-		pool = &sync.Pool{}
-	}
-	return func(r io.Reader) io.ReadCloser {
-		dec, ok := pool.Get().(*Decoder)
-		if ok {
-			dec.Reset(r)
-		} else {
-			d, err := NewReader(r, opts...)
-			if err != nil {
-				panic(err)
-			}
-			dec = d
+// newZipReader cannot be used since we would leak goroutines...
+func newZipReader(r io.Reader) io.ReadCloser {
+	dec, ok := zipReaderPool.Get().(*Decoder)
+	if ok {
+		dec.Reset(r)
+	} else {
+		d, err := NewReader(r, WithDecoderConcurrency(1), WithDecoderLowmem(true))
+		if err != nil {
+			panic(err)
 		}
-		return &pooledZipReader{dec: dec, pool: pool}
+		dec = d
 	}
+	return &pooledZipReader{dec: dec}
 }
 
 type pooledZipReader struct {
-	mu   sync.Mutex // guards Close and Read
-	pool *sync.Pool
-	dec  *Decoder
+	mu  sync.Mutex // guards Close and Read
+	dec *Decoder
 }
 
 func (r *pooledZipReader) Read(p []byte) (n int, err error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	if r.dec == nil {
-		return 0, errors.New("read after close or EOF")
+		return 0, errors.New("Read after Close")
 	}
 	dec, err := r.dec.Read(p)
-	if err == io.EOF {
-		r.dec.Reset(nil)
-		r.pool.Put(r.dec)
-		r.dec = nil
-	}
+
 	return dec, err
 }
 
@@ -79,7 +57,7 @@ func (r *pooledZipReader) Close() error {
 	var err error
 	if r.dec != nil {
 		err = r.dec.Reset(nil)
-		r.pool.Put(r.dec)
+		zipReaderPool.Put(r.dec)
 		r.dec = nil
 	}
 	return err
@@ -133,9 +111,12 @@ func ZipCompressor(opts ...EOption) func(w io.Writer) (io.WriteCloser, error) {
 
 // ZipDecompressor returns a decompressor that can be registered with zip libraries.
 // See ZipCompressor for example.
-// Options can be specified. WithDecoderConcurrency(1) is forced,
-// and by default a 128MB maximum decompression window is specified.
-// The window size can be overridden if required.
-func ZipDecompressor(opts ...DOption) func(r io.Reader) io.ReadCloser {
-	return newZipReader(opts...)
+func ZipDecompressor() func(r io.Reader) io.ReadCloser {
+	return func(r io.Reader) io.ReadCloser {
+		d, err := NewReader(r, WithDecoderConcurrency(1), WithDecoderLowmem(true))
+		if err != nil {
+			panic(err)
+		}
+		return d.IOReadCloser()
+	}
 }
diff --git a/vendor/github.com/klauspost/compress/zstd/zstd.go b/vendor/github.com/klauspost/compress/zstd/zstd.go
index 4be7cc73..ef1d49a0 100644
--- a/vendor/github.com/klauspost/compress/zstd/zstd.go
+++ b/vendor/github.com/klauspost/compress/zstd/zstd.go
@@ -9,6 +9,7 @@ import (
 	"errors"
 	"log"
 	"math"
+	"math/bits"
 )
 
 // enable debug printing
@@ -35,8 +36,8 @@ const forcePreDef = false
 // zstdMinMatch is the minimum zstd match length.
 const zstdMinMatch = 3
 
-// fcsUnknown is used for unknown frame content size.
-const fcsUnknown = math.MaxUint64
+// Reset the buffer offset when reaching this.
+const bufferReset = math.MaxInt32 - MaxWindowSize
 
 var (
 	// ErrReservedBlockType is returned when a reserved block type is found.
@@ -51,10 +52,6 @@ var (
 	// Typically returned on invalid input.
 	ErrBlockTooSmall = errors.New("block too small")
 
-	// ErrUnexpectedBlockSize is returned when a block has unexpected size.
-	// Typically returned on invalid input.
-	ErrUnexpectedBlockSize = errors.New("unexpected block size")
-
 	// ErrMagicMismatch is returned when a "magic" number isn't what is expected.
 	// Typically this indicates wrong or corrupted input.
 	ErrMagicMismatch = errors.New("invalid input: magic number mismatch")
@@ -71,16 +68,13 @@ var (
 	ErrDecoderSizeExceeded = errors.New("decompressed size exceeds configured limit")
 
 	// ErrUnknownDictionary is returned if the dictionary ID is unknown.
+	// For the time being dictionaries are not supported.
 	ErrUnknownDictionary = errors.New("unknown dictionary")
 
 	// ErrFrameSizeExceeded is returned if the stated frame size is exceeded.
 	// This is only returned if SingleSegment is specified on the frame.
 	ErrFrameSizeExceeded = errors.New("frame size exceeded")
 
-	// ErrFrameSizeMismatch is returned if the stated frame size does not match the expected size.
-	// This is only returned if SingleSegment is specified on the frame.
-	ErrFrameSizeMismatch = errors.New("frame size does not match size on stream")
-
 	// ErrCRCMismatch is returned if CRC mismatches.
 	ErrCRCMismatch = errors.New("CRC check failed")
 
@@ -105,12 +99,49 @@ func printf(format string, a ...interface{}) {
 	}
 }
 
+// matchLenFast does matching, but will not match the last up to 7 bytes.
+func matchLenFast(a, b []byte) int {
+	endI := len(a) & (math.MaxInt32 - 7)
+	for i := 0; i < endI; i += 8 {
+		if diff := load64(a, i) ^ load64(b, i); diff != 0 {
+			return i + bits.TrailingZeros64(diff)>>3
+		}
+	}
+	return endI
+}
+
+// matchLen returns the maximum length.
+// a must be the shortest of the two.
+// The function also returns whether all bytes matched.
+func matchLen(a, b []byte) int {
+	b = b[:len(a)]
+	for i := 0; i < len(a)-7; i += 8 {
+		if diff := load64(a, i) ^ load64(b, i); diff != 0 {
+			return i + (bits.TrailingZeros64(diff) >> 3)
+		}
+	}
+
+	checked := (len(a) >> 3) << 3
+	a = a[checked:]
+	b = b[checked:]
+	for i := range a {
+		if a[i] != b[i] {
+			return i + checked
+		}
+	}
+	return len(a) + checked
+}
+
 func load3232(b []byte, i int32) uint32 {
-	return binary.LittleEndian.Uint32(b[:len(b):len(b)][i:])
+	return binary.LittleEndian.Uint32(b[i:])
 }
 
 func load6432(b []byte, i int32) uint64 {
-	return binary.LittleEndian.Uint64(b[:len(b):len(b)][i:])
+	return binary.LittleEndian.Uint64(b[i:])
+}
+
+func load64(b []byte, i int) uint64 {
+	return binary.LittleEndian.Uint64(b[i:])
 }
 
 type byter interface {
diff --git a/vendor/golang.org/x/crypto/sha3/doc.go b/vendor/golang.org/x/crypto/sha3/doc.go
index bbf391fe..7e023090 100644
--- a/vendor/golang.org/x/crypto/sha3/doc.go
+++ b/vendor/golang.org/x/crypto/sha3/doc.go
@@ -5,10 +5,6 @@
 // Package sha3 implements the SHA-3 fixed-output-length hash functions and
 // the SHAKE variable-output-length hash functions defined by FIPS-202.
 //
-// All types in this package also implement [encoding.BinaryMarshaler],
-// [encoding.BinaryAppender] and [encoding.BinaryUnmarshaler] to marshal and
-// unmarshal the internal state of the hash.
-//
 // Both types of hash function use the "sponge" construction and the Keccak
 // permutation. For a detailed specification see http://keccak.noekeon.org/
 //
diff --git a/vendor/golang.org/x/crypto/sha3/hashes.go b/vendor/golang.org/x/crypto/sha3/hashes.go
index 31fffbe0..c544b29e 100644
--- a/vendor/golang.org/x/crypto/sha3/hashes.go
+++ b/vendor/golang.org/x/crypto/sha3/hashes.go
@@ -48,52 +48,33 @@ func init() {
 	crypto.RegisterHash(crypto.SHA3_512, New512)
 }
 
-const (
-	dsbyteSHA3   = 0b00000110
-	dsbyteKeccak = 0b00000001
-	dsbyteShake  = 0b00011111
-	dsbyteCShake = 0b00000100
-
-	// rateK[c] is the rate in bytes for Keccak[c] where c is the capacity in
-	// bits. Given the sponge size is 1600 bits, the rate is 1600 - c bits.
-	rateK256  = (1600 - 256) / 8
-	rateK448  = (1600 - 448) / 8
-	rateK512  = (1600 - 512) / 8
-	rateK768  = (1600 - 768) / 8
-	rateK1024 = (1600 - 1024) / 8
-)
-
 func new224Generic() *state {
-	return &state{rate: rateK448, outputLen: 28, dsbyte: dsbyteSHA3}
+	return &state{rate: 144, outputLen: 28, dsbyte: 0x06}
 }
 
 func new256Generic() *state {
-	return &state{rate: rateK512, outputLen: 32, dsbyte: dsbyteSHA3}
+	return &state{rate: 136, outputLen: 32, dsbyte: 0x06}
 }
 
 func new384Generic() *state {
-	return &state{rate: rateK768, outputLen: 48, dsbyte: dsbyteSHA3}
+	return &state{rate: 104, outputLen: 48, dsbyte: 0x06}
 }
 
 func new512Generic() *state {
-	return &state{rate: rateK1024, outputLen: 64, dsbyte: dsbyteSHA3}
+	return &state{rate: 72, outputLen: 64, dsbyte: 0x06}
 }
 
 // NewLegacyKeccak256 creates a new Keccak-256 hash.
 //
 // Only use this function if you require compatibility with an existing cryptosystem
 // that uses non-standard padding. All other users should use New256 instead.
-func NewLegacyKeccak256() hash.Hash {
-	return &state{rate: rateK512, outputLen: 32, dsbyte: dsbyteKeccak}
-}
+func NewLegacyKeccak256() hash.Hash { return &state{rate: 136, outputLen: 32, dsbyte: 0x01} }
 
 // NewLegacyKeccak512 creates a new Keccak-512 hash.
 //
 // Only use this function if you require compatibility with an existing cryptosystem
 // that uses non-standard padding. All other users should use New512 instead.
-func NewLegacyKeccak512() hash.Hash {
-	return &state{rate: rateK1024, outputLen: 64, dsbyte: dsbyteKeccak}
-}
+func NewLegacyKeccak512() hash.Hash { return &state{rate: 72, outputLen: 64, dsbyte: 0x01} }
 
 // Sum224 returns the SHA3-224 digest of the data.
 func Sum224(data []byte) (digest [28]byte) {
diff --git a/vendor/golang.org/x/crypto/sha3/sha3.go b/vendor/golang.org/x/crypto/sha3/sha3.go
index 6658c444..afedde5a 100644
--- a/vendor/golang.org/x/crypto/sha3/sha3.go
+++ b/vendor/golang.org/x/crypto/sha3/sha3.go
@@ -4,15 +4,6 @@
 
 package sha3
 
-import (
-	"crypto/subtle"
-	"encoding/binary"
-	"errors"
-	"unsafe"
-
-	"golang.org/x/sys/cpu"
-)
-
 // spongeDirection indicates the direction bytes are flowing through the sponge.
 type spongeDirection int
 
@@ -23,13 +14,16 @@ const (
 	spongeSqueezing
 )
 
-type state struct {
-	a [1600 / 8]byte // main state of the hash
+const (
+	// maxRate is the maximum size of the internal buffer. SHAKE-256
+	// currently needs the largest buffer.
+	maxRate = 168
+)
 
-	// a[n:rate] is the buffer. If absorbing, it's the remaining space to XOR
-	// into before running the permutation. If squeezing, it's the remaining
-	// output to produce before running the permutation.
-	n, rate int
+type state struct {
+	// Generic sponge components.
+	a    [25]uint64 // main state of the hash
+	rate int        // the number of bytes of state to use
 
 	// dsbyte contains the "domain separation" bits and the first bit of
 	// the padding. Sections 6.1 and 6.2 of [1] separate the outputs of the
@@ -45,6 +39,10 @@ type state struct {
 	//      Extendable-Output Functions (May 2014)"
 	dsbyte byte
 
+	i, n    int // storage[i:n] is the buffer, i is only used while squeezing
+	storage [maxRate]byte
+
+	// Specific to SHA-3 and SHAKE.
 	outputLen int             // the default output size in bytes
 	state     spongeDirection // whether the sponge is absorbing or squeezing
 }
@@ -63,7 +61,7 @@ func (d *state) Reset() {
 		d.a[i] = 0
 	}
 	d.state = spongeAbsorbing
-	d.n = 0
+	d.i, d.n = 0, 0
 }
 
 func (d *state) clone() *state {
@@ -71,25 +69,22 @@ func (d *state) clone() *state {
 	return &ret
 }
 
-// permute applies the KeccakF-1600 permutation.
+// permute applies the KeccakF-1600 permutation. It handles
+// any input-output buffering.
 func (d *state) permute() {
-	var a *[25]uint64
-	if cpu.IsBigEndian {
-		a = new([25]uint64)
-		for i := range a {
-			a[i] = binary.LittleEndian.Uint64(d.a[i*8:])
-		}
-	} else {
-		a = (*[25]uint64)(unsafe.Pointer(&d.a))
-	}
-
-	keccakF1600(a)
-	d.n = 0
-
-	if cpu.IsBigEndian {
-		for i := range a {
-			binary.LittleEndian.PutUint64(d.a[i*8:], a[i])
-		}
+	switch d.state {
+	case spongeAbsorbing:
+		// If we're absorbing, we need to xor the input into the state
+		// before applying the permutation.
+		xorIn(d, d.storage[:d.rate])
+		d.n = 0
+		keccakF1600(&d.a)
+	case spongeSqueezing:
+		// If we're squeezing, we need to apply the permutation before
+		// copying more output.
+		keccakF1600(&d.a)
+		d.i = 0
+		copyOut(d, d.storage[:d.rate])
 	}
 }
 
@@ -97,36 +92,53 @@ func (d *state) permute() {
 // the multi-bitrate 10..1 padding rule, and permutes the state.
 func (d *state) padAndPermute() {
 	// Pad with this instance's domain-separator bits. We know that there's
-	// at least one byte of space in the sponge because, if it were full,
+	// at least one byte of space in d.buf because, if it were full,
 	// permute would have been called to empty it. dsbyte also contains the
 	// first one bit for the padding. See the comment in the state struct.
-	d.a[d.n] ^= d.dsbyte
+	d.storage[d.n] = d.dsbyte
+	d.n++
+	for d.n < d.rate {
+		d.storage[d.n] = 0
+		d.n++
+	}
 	// This adds the final one bit for the padding. Because of the way that
 	// bits are numbered from the LSB upwards, the final bit is the MSB of
 	// the last byte.
-	d.a[d.rate-1] ^= 0x80
+	d.storage[d.rate-1] ^= 0x80
 	// Apply the permutation
 	d.permute()
 	d.state = spongeSqueezing
+	d.n = d.rate
+	copyOut(d, d.storage[:d.rate])
 }
 
 // Write absorbs more data into the hash's state. It panics if any
 // output has already been read.
-func (d *state) Write(p []byte) (n int, err error) {
+func (d *state) Write(p []byte) (written int, err error) {
 	if d.state != spongeAbsorbing {
 		panic("sha3: Write after Read")
 	}
-
-	n = len(p)
+	written = len(p)
 
 	for len(p) > 0 {
-		x := subtle.XORBytes(d.a[d.n:d.rate], d.a[d.n:d.rate], p)
-		d.n += x
-		p = p[x:]
-
-		// If the sponge is full, apply the permutation.
-		if d.n == d.rate {
-			d.permute()
+		if d.n == 0 && len(p) >= d.rate {
+			// The fast path; absorb a full "rate" bytes of input and apply the permutation.
+			xorIn(d, p[:d.rate])
+			p = p[d.rate:]
+			keccakF1600(&d.a)
+		} else {
+			// The slow path; buffer the input until we can fill the sponge, and then xor it in.
+			todo := d.rate - d.n
+			if todo > len(p) {
+				todo = len(p)
+			}
+			d.n += copy(d.storage[d.n:], p[:todo])
+			p = p[todo:]
+
+			// If the sponge is full, apply the permutation.
+			if d.n == d.rate {
+				d.permute()
+			}
 		}
 	}
 
@@ -144,14 +156,14 @@ func (d *state) Read(out []byte) (n int, err error) {
 
 	// Now, do the squeezing.
 	for len(out) > 0 {
+		n := copy(out, d.storage[d.i:d.n])
+		d.i += n
+		out = out[n:]
+
 		// Apply the permutation if we've squeezed the sponge dry.
-		if d.n == d.rate {
+		if d.i == d.rate {
 			d.permute()
 		}
-
-		x := copy(out, d.a[d.n:d.rate])
-		d.n += x
-		out = out[x:]
 	}
 
 	return
@@ -171,74 +183,3 @@ func (d *state) Sum(in []byte) []byte {
 	dup.Read(hash)
 	return append(in, hash...)
 }
-
-const (
-	magicSHA3   = "sha\x08"
-	magicShake  = "sha\x09"
-	magicCShake = "sha\x0a"
-	magicKeccak = "sha\x0b"
-	// magic || rate || main state || n || sponge direction
-	marshaledSize = len(magicSHA3) + 1 + 200 + 1 + 1
-)
-
-func (d *state) MarshalBinary() ([]byte, error) {
-	return d.AppendBinary(make([]byte, 0, marshaledSize))
-}
-
-func (d *state) AppendBinary(b []byte) ([]byte, error) {
-	switch d.dsbyte {
-	case dsbyteSHA3:
-		b = append(b, magicSHA3...)
-	case dsbyteShake:
-		b = append(b, magicShake...)
-	case dsbyteCShake:
-		b = append(b, magicCShake...)
-	case dsbyteKeccak:
-		b = append(b, magicKeccak...)
-	default:
-		panic("unknown dsbyte")
-	}
-	// rate is at most 168, and n is at most rate.
-	b = append(b, byte(d.rate))
-	b = append(b, d.a[:]...)
-	b = append(b, byte(d.n), byte(d.state))
-	return b, nil
-}
-
-func (d *state) UnmarshalBinary(b []byte) error {
-	if len(b) != marshaledSize {
-		return errors.New("sha3: invalid hash state")
-	}
-
-	magic := string(b[:len(magicSHA3)])
-	b = b[len(magicSHA3):]
-	switch {
-	case magic == magicSHA3 && d.dsbyte == dsbyteSHA3:
-	case magic == magicShake && d.dsbyte == dsbyteShake:
-	case magic == magicCShake && d.dsbyte == dsbyteCShake:
-	case magic == magicKeccak && d.dsbyte == dsbyteKeccak:
-	default:
-		return errors.New("sha3: invalid hash state identifier")
-	}
-
-	rate := int(b[0])
-	b = b[1:]
-	if rate != d.rate {
-		return errors.New("sha3: invalid hash state function")
-	}
-
-	copy(d.a[:], b)
-	b = b[len(d.a):]
-
-	n, state := int(b[0]), spongeDirection(b[1])
-	if n > d.rate {
-		return errors.New("sha3: invalid hash state")
-	}
-	d.n = n
-	if state != spongeAbsorbing && state != spongeSqueezing {
-		return errors.New("sha3: invalid hash state")
-	}
-	d.state = state
-
-	return nil
-}
diff --git a/vendor/golang.org/x/crypto/sha3/shake.go b/vendor/golang.org/x/crypto/sha3/shake.go
index a6b3a428..1ea9275b 100644
--- a/vendor/golang.org/x/crypto/sha3/shake.go
+++ b/vendor/golang.org/x/crypto/sha3/shake.go
@@ -16,12 +16,9 @@ package sha3
 // [2] https://doi.org/10.6028/NIST.SP.800-185
 
 import (
-	"bytes"
 	"encoding/binary"
-	"errors"
 	"hash"
 	"io"
-	"math/bits"
 )
 
 // ShakeHash defines the interface to hash functions that support
@@ -53,36 +50,44 @@ type cshakeState struct {
 	initBlock []byte
 }
 
-func bytepad(data []byte, rate int) []byte {
-	out := make([]byte, 0, 9+len(data)+rate-1)
-	out = append(out, leftEncode(uint64(rate))...)
-	out = append(out, data...)
-	if padlen := rate - len(out)%rate; padlen < rate {
-		out = append(out, make([]byte, padlen)...)
-	}
-	return out
-}
+// Consts for configuring initial SHA-3 state
+const (
+	dsbyteShake  = 0x1f
+	dsbyteCShake = 0x04
+	rate128      = 168
+	rate256      = 136
+)
 
-func leftEncode(x uint64) []byte {
-	// Let n be the smallest positive integer for which 2^(8n) > x.
-	n := (bits.Len64(x) + 7) / 8
-	if n == 0 {
-		n = 1
+func bytepad(input []byte, w int) []byte {
+	// leftEncode always returns max 9 bytes
+	buf := make([]byte, 0, 9+len(input)+w)
+	buf = append(buf, leftEncode(uint64(w))...)
+	buf = append(buf, input...)
+	padlen := w - (len(buf) % w)
+	return append(buf, make([]byte, padlen)...)
+}
+
+func leftEncode(value uint64) []byte {
+	var b [9]byte
+	binary.BigEndian.PutUint64(b[1:], value)
+	// Trim all but last leading zero bytes
+	i := byte(1)
+	for i < 8 && b[i] == 0 {
+		i++
 	}
-	// Return n || x with n as a byte and x an n bytes in big-endian order.
-	b := make([]byte, 9)
-	binary.BigEndian.PutUint64(b[1:], x)
-	b = b[9-n-1:]
-	b[0] = byte(n)
-	return b
+	// Prepend number of encoded bytes
+	b[i-1] = 9 - i
+	return b[i-1:]
 }
 
 func newCShake(N, S []byte, rate, outputLen int, dsbyte byte) ShakeHash {
 	c := cshakeState{state: &state{rate: rate, outputLen: outputLen, dsbyte: dsbyte}}
-	c.initBlock = make([]byte, 0, 9+len(N)+9+len(S)) // leftEncode returns max 9 bytes
-	c.initBlock = append(c.initBlock, leftEncode(uint64(len(N))*8)...)
+
+	// leftEncode returns max 9 bytes
+	c.initBlock = make([]byte, 0, 9*2+len(N)+len(S))
+	c.initBlock = append(c.initBlock, leftEncode(uint64(len(N)*8))...)
 	c.initBlock = append(c.initBlock, N...)
-	c.initBlock = append(c.initBlock, leftEncode(uint64(len(S))*8)...)
+	c.initBlock = append(c.initBlock, leftEncode(uint64(len(S)*8))...)
 	c.initBlock = append(c.initBlock, S...)
 	c.Write(bytepad(c.initBlock, c.rate))
 	return &c
@@ -106,30 +111,6 @@ func (c *state) Clone() ShakeHash {
 	return c.clone()
 }
 
-func (c *cshakeState) MarshalBinary() ([]byte, error) {
-	return c.AppendBinary(make([]byte, 0, marshaledSize+len(c.initBlock)))
-}
-
-func (c *cshakeState) AppendBinary(b []byte) ([]byte, error) {
-	b, err := c.state.AppendBinary(b)
-	if err != nil {
-		return nil, err
-	}
-	b = append(b, c.initBlock...)
-	return b, nil
-}
-
-func (c *cshakeState) UnmarshalBinary(b []byte) error {
-	if len(b) <= marshaledSize {
-		return errors.New("sha3: invalid hash state")
-	}
-	if err := c.state.UnmarshalBinary(b[:marshaledSize]); err != nil {
-		return err
-	}
-	c.initBlock = bytes.Clone(b[marshaledSize:])
-	return nil
-}
-
 // NewShake128 creates a new SHAKE128 variable-output-length ShakeHash.
 // Its generic security strength is 128 bits against all attacks if at
 // least 32 bytes of its output are used.
@@ -145,11 +126,11 @@ func NewShake256() ShakeHash {
 }
 
 func newShake128Generic() *state {
-	return &state{rate: rateK256, outputLen: 32, dsbyte: dsbyteShake}
+	return &state{rate: rate128, outputLen: 32, dsbyte: dsbyteShake}
 }
 
 func newShake256Generic() *state {
-	return &state{rate: rateK512, outputLen: 64, dsbyte: dsbyteShake}
+	return &state{rate: rate256, outputLen: 64, dsbyte: dsbyteShake}
 }
 
 // NewCShake128 creates a new instance of cSHAKE128 variable-output-length ShakeHash,
@@ -162,7 +143,7 @@ func NewCShake128(N, S []byte) ShakeHash {
 	if len(N) == 0 && len(S) == 0 {
 		return NewShake128()
 	}
-	return newCShake(N, S, rateK256, 32, dsbyteCShake)
+	return newCShake(N, S, rate128, 32, dsbyteCShake)
 }
 
 // NewCShake256 creates a new instance of cSHAKE256 variable-output-length ShakeHash,
@@ -175,7 +156,7 @@ func NewCShake256(N, S []byte) ShakeHash {
 	if len(N) == 0 && len(S) == 0 {
 		return NewShake256()
 	}
-	return newCShake(N, S, rateK512, 64, dsbyteCShake)
+	return newCShake(N, S, rate256, 64, dsbyteCShake)
 }
 
 // ShakeSum128 writes an arbitrary-length digest of data into hash.
diff --git a/vendor/golang.org/x/crypto/sha3/xor.go b/vendor/golang.org/x/crypto/sha3/xor.go
new file mode 100644
index 00000000..6ada5c95
--- /dev/null
+++ b/vendor/golang.org/x/crypto/sha3/xor.go
@@ -0,0 +1,40 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package sha3
+
+import (
+	"crypto/subtle"
+	"encoding/binary"
+	"unsafe"
+
+	"golang.org/x/sys/cpu"
+)
+
+// xorIn xors the bytes in buf into the state.
+func xorIn(d *state, buf []byte) {
+	if cpu.IsBigEndian {
+		for i := 0; len(buf) >= 8; i++ {
+			a := binary.LittleEndian.Uint64(buf)
+			d.a[i] ^= a
+			buf = buf[8:]
+		}
+	} else {
+		ab := (*[25 * 64 / 8]byte)(unsafe.Pointer(&d.a))
+		subtle.XORBytes(ab[:], ab[:], buf)
+	}
+}
+
+// copyOut copies uint64s to a byte buffer.
+func copyOut(d *state, b []byte) {
+	if cpu.IsBigEndian {
+		for i := 0; len(b) >= 8; i++ {
+			binary.LittleEndian.PutUint64(b, d.a[i])
+			b = b[8:]
+		}
+	} else {
+		ab := (*[25 * 64 / 8]byte)(unsafe.Pointer(&d.a))
+		copy(b, ab[:])
+	}
+}
diff --git a/vendor/golang.org/x/sync/errgroup/errgroup.go b/vendor/golang.org/x/sync/errgroup/errgroup.go
index b8322598..948a3ee6 100644
--- a/vendor/golang.org/x/sync/errgroup/errgroup.go
+++ b/vendor/golang.org/x/sync/errgroup/errgroup.go
@@ -118,7 +118,6 @@ func (g *Group) TryGo(f func() error) bool {
 
 // SetLimit limits the number of active goroutines in this group to at most n.
 // A negative value indicates no limit.
-// A limit of zero will prevent any new goroutines from being added.
 //
 // Any subsequent call to the Go method will block until it can add an active
 // goroutine without exceeding the configured limit.
diff --git a/vendor/golang.org/x/sys/cpu/cpu.go b/vendor/golang.org/x/sys/cpu/cpu.go
index 9c105f23..ec07aab0 100644
--- a/vendor/golang.org/x/sys/cpu/cpu.go
+++ b/vendor/golang.org/x/sys/cpu/cpu.go
@@ -72,9 +72,6 @@ var X86 struct {
 	HasSSSE3            bool // Supplemental streaming SIMD extension 3
 	HasSSE41            bool // Streaming SIMD extension 4 and 4.1
 	HasSSE42            bool // Streaming SIMD extension 4 and 4.2
-	HasAVXIFMA          bool // Advanced vector extension Integer Fused Multiply Add
-	HasAVXVNNI          bool // Advanced vector extension Vector Neural Network Instructions
-	HasAVXVNNIInt8      bool // Advanced vector extension Vector Neural Network Int8 instructions
 	_                   CacheLinePad
 }
 
@@ -204,25 +201,6 @@ var S390X struct {
 	_         CacheLinePad
 }
 
-// RISCV64 contains the supported CPU features and performance characteristics for riscv64
-// platforms. The booleans in RISCV64, with the exception of HasFastMisaligned, indicate
-// the presence of RISC-V extensions.
-//
-// It is safe to assume that all the RV64G extensions are supported and so they are omitted from
-// this structure. As riscv64 Go programs require at least RV64G, the code that populates
-// this structure cannot run successfully if some of the RV64G extensions are missing.
-// The struct is padded to avoid false sharing.
-var RISCV64 struct {
-	_                 CacheLinePad
-	HasFastMisaligned bool // Fast misaligned accesses
-	HasC              bool // Compressed instruction-set extension
-	HasV              bool // Vector extension compatible with RVV 1.0
-	HasZba            bool // Address generation instructions extension
-	HasZbb            bool // Basic bit-manipulation extension
-	HasZbs            bool // Single-bit instructions extension
-	_                 CacheLinePad
-}
-
 func init() {
 	archInit()
 	initOptions()
diff --git a/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go b/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go
index 32a44514..910728fb 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go
@@ -6,10 +6,10 @@
 
 package cpu
 
-// cpuid is implemented in cpu_gc_x86.s for gc compiler
+// cpuid is implemented in cpu_x86.s for gc compiler
 // and in cpu_gccgo.c for gccgo.
 func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32)
 
-// xgetbv with ecx = 0 is implemented in cpu_gc_x86.s for gc compiler
+// xgetbv with ecx = 0 is implemented in cpu_x86.s for gc compiler
 // and in cpu_gccgo.c for gccgo.
 func xgetbv() (eax, edx uint32)
diff --git a/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go b/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go
index 170d21dd..99c60fe9 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go
@@ -23,3 +23,9 @@ func xgetbv() (eax, edx uint32) {
 	gccgoXgetbv(&a, &d)
 	return a, d
 }
+
+// gccgo doesn't build on Darwin, per:
+// https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/gcc.rb#L76
+func darwinSupportsAVX512() bool {
+	return false
+}
diff --git a/vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go b/vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go
index f1caf0f7..08f35ea1 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_linux_arm64.go
@@ -110,6 +110,7 @@ func doinit() {
 	ARM64.HasASIMDFHM = isSet(hwCap, hwcap_ASIMDFHM)
 	ARM64.HasDIT = isSet(hwCap, hwcap_DIT)
 
+
 	// HWCAP2 feature bits
 	ARM64.HasSVE2 = isSet(hwCap2, hwcap2_SVE2)
 	ARM64.HasI8MM = isSet(hwCap2, hwcap2_I8MM)
diff --git a/vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go b/vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go
index 7d902b68..cd63e733 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build linux && !arm && !arm64 && !mips64 && !mips64le && !ppc64 && !ppc64le && !s390x && !riscv64
+//go:build linux && !arm && !arm64 && !mips64 && !mips64le && !ppc64 && !ppc64le && !s390x
 
 package cpu
 
diff --git a/vendor/golang.org/x/sys/cpu/cpu_riscv64.go b/vendor/golang.org/x/sys/cpu/cpu_riscv64.go
index aca3199c..7f0c79c0 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_riscv64.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_riscv64.go
@@ -8,13 +8,4 @@ package cpu
 
 const cacheLineSize = 64
 
-func initOptions() {
-	options = []option{
-		{Name: "fastmisaligned", Feature: &RISCV64.HasFastMisaligned},
-		{Name: "c", Feature: &RISCV64.HasC},
-		{Name: "v", Feature: &RISCV64.HasV},
-		{Name: "zba", Feature: &RISCV64.HasZba},
-		{Name: "zbb", Feature: &RISCV64.HasZbb},
-		{Name: "zbs", Feature: &RISCV64.HasZbs},
-	}
-}
+func initOptions() {}
diff --git a/vendor/golang.org/x/sys/cpu/cpu_x86.go b/vendor/golang.org/x/sys/cpu/cpu_x86.go
index 1e642f33..c29f5e4c 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_x86.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_x86.go
@@ -53,9 +53,6 @@ func initOptions() {
 		{Name: "sse41", Feature: &X86.HasSSE41},
 		{Name: "sse42", Feature: &X86.HasSSE42},
 		{Name: "ssse3", Feature: &X86.HasSSSE3},
-		{Name: "avxifma", Feature: &X86.HasAVXIFMA},
-		{Name: "avxvnni", Feature: &X86.HasAVXVNNI},
-		{Name: "avxvnniint8", Feature: &X86.HasAVXVNNIInt8},
 
 		// These capabilities should always be enabled on amd64:
 		{Name: "sse2", Feature: &X86.HasSSE2, Required: runtime.GOARCH == "amd64"},
@@ -95,8 +92,10 @@ func archInit() {
 		osSupportsAVX = isSet(1, eax) && isSet(2, eax)
 
 		if runtime.GOOS == "darwin" {
-			// Darwin requires special AVX512 checks, see cpu_darwin_x86.go
-			osSupportsAVX512 = osSupportsAVX && darwinSupportsAVX512()
+			// Darwin doesn't save/restore AVX-512 mask registers correctly across signal handlers.
+			// Since users can't rely on mask register contents, let's not advertise AVX-512 support.
+			// See issue 49233.
+			osSupportsAVX512 = false
 		} else {
 			// Check if OPMASK and ZMM registers have OS support.
 			osSupportsAVX512 = osSupportsAVX && isSet(5, eax) && isSet(6, eax) && isSet(7, eax)
@@ -109,7 +108,7 @@ func archInit() {
 		return
 	}
 
-	eax7, ebx7, ecx7, edx7 := cpuid(7, 0)
+	_, ebx7, ecx7, edx7 := cpuid(7, 0)
 	X86.HasBMI1 = isSet(3, ebx7)
 	X86.HasAVX2 = isSet(5, ebx7) && osSupportsAVX
 	X86.HasBMI2 = isSet(8, ebx7)
@@ -137,24 +136,14 @@ func archInit() {
 		X86.HasAVX512VAES = isSet(9, ecx7)
 		X86.HasAVX512VBMI2 = isSet(6, ecx7)
 		X86.HasAVX512BITALG = isSet(12, ecx7)
+
+		eax71, _, _, _ := cpuid(7, 1)
+		X86.HasAVX512BF16 = isSet(5, eax71)
 	}
 
 	X86.HasAMXTile = isSet(24, edx7)
 	X86.HasAMXInt8 = isSet(25, edx7)
 	X86.HasAMXBF16 = isSet(22, edx7)
-
-	// These features depend on the second level of extended features.
-	if eax7 >= 1 {
-		eax71, _, _, edx71 := cpuid(7, 1)
-		if X86.HasAVX512 {
-			X86.HasAVX512BF16 = isSet(5, eax71)
-		}
-		if X86.HasAVX {
-			X86.HasAVXIFMA = isSet(23, eax71)
-			X86.HasAVXVNNI = isSet(4, eax71)
-			X86.HasAVXVNNIInt8 = isSet(4, edx71)
-		}
-	}
 }
 
 func isSet(bitpos uint, value uint32) bool {
diff --git a/vendor/golang.org/x/sys/cpu/cpu_x86.s b/vendor/golang.org/x/sys/cpu/cpu_x86.s
new file mode 100644
index 00000000..7d7ba33e
--- /dev/null
+++ b/vendor/golang.org/x/sys/cpu/cpu_x86.s
@@ -0,0 +1,26 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build (386 || amd64 || amd64p32) && gc
+
+#include "textflag.h"
+
+// func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuid(SB), NOSPLIT, $0-24
+	MOVL eaxArg+0(FP), AX
+	MOVL ecxArg+4(FP), CX
+	CPUID
+	MOVL AX, eax+8(FP)
+	MOVL BX, ebx+12(FP)
+	MOVL CX, ecx+16(FP)
+	MOVL DX, edx+20(FP)
+	RET
+
+// func xgetbv() (eax, edx uint32)
+TEXT ·xgetbv(SB),NOSPLIT,$0-8
+	MOVL $0, CX
+	XGETBV
+	MOVL AX, eax+0(FP)
+	MOVL DX, edx+4(FP)
+	RET
diff --git a/vendor/golang.org/x/sys/unix/README.md b/vendor/golang.org/x/sys/unix/README.md
index 6e08a76a..7d3c060e 100644
--- a/vendor/golang.org/x/sys/unix/README.md
+++ b/vendor/golang.org/x/sys/unix/README.md
@@ -156,7 +156,7 @@ from the generated architecture-specific files listed below, and merge these
 into a common file for each OS.
 
 The merge is performed in the following steps:
-1. Construct the set of common code that is identical in all architecture-specific files.
+1. Construct the set of common code that is idential in all architecture-specific files.
 2. Write this common code to the merged file.
 3. Remove the common code from all architecture-specific files.
 
diff --git a/vendor/golang.org/x/sys/unix/ioctl_linux.go b/vendor/golang.org/x/sys/unix/ioctl_linux.go
index 7ca4fa12..dbe680ea 100644
--- a/vendor/golang.org/x/sys/unix/ioctl_linux.go
+++ b/vendor/golang.org/x/sys/unix/ioctl_linux.go
@@ -58,102 +58,6 @@ func IoctlGetEthtoolDrvinfo(fd int, ifname string) (*EthtoolDrvinfo, error) {
 	return &value, err
 }
 
-// IoctlGetEthtoolTsInfo fetches ethtool timestamping and PHC
-// association for the network device specified by ifname.
-func IoctlGetEthtoolTsInfo(fd int, ifname string) (*EthtoolTsInfo, error) {
-	ifr, err := NewIfreq(ifname)
-	if err != nil {
-		return nil, err
-	}
-
-	value := EthtoolTsInfo{Cmd: ETHTOOL_GET_TS_INFO}
-	ifrd := ifr.withData(unsafe.Pointer(&value))
-
-	err = ioctlIfreqData(fd, SIOCETHTOOL, &ifrd)
-	return &value, err
-}
-
-// IoctlGetHwTstamp retrieves the hardware timestamping configuration
-// for the network device specified by ifname.
-func IoctlGetHwTstamp(fd int, ifname string) (*HwTstampConfig, error) {
-	ifr, err := NewIfreq(ifname)
-	if err != nil {
-		return nil, err
-	}
-
-	value := HwTstampConfig{}
-	ifrd := ifr.withData(unsafe.Pointer(&value))
-
-	err = ioctlIfreqData(fd, SIOCGHWTSTAMP, &ifrd)
-	return &value, err
-}
-
-// IoctlSetHwTstamp updates the hardware timestamping configuration for
-// the network device specified by ifname.
-func IoctlSetHwTstamp(fd int, ifname string, cfg *HwTstampConfig) error {
-	ifr, err := NewIfreq(ifname)
-	if err != nil {
-		return err
-	}
-	ifrd := ifr.withData(unsafe.Pointer(cfg))
-	return ioctlIfreqData(fd, SIOCSHWTSTAMP, &ifrd)
-}
-
-// FdToClockID derives the clock ID from the file descriptor number
-// - see clock_gettime(3), FD_TO_CLOCKID macros. The resulting ID is
-// suitable for system calls like ClockGettime.
-func FdToClockID(fd int) int32 { return int32((int(^fd) << 3) | 3) }
-
-// IoctlPtpClockGetcaps returns the description of a given PTP device.
-func IoctlPtpClockGetcaps(fd int) (*PtpClockCaps, error) {
-	var value PtpClockCaps
-	err := ioctlPtr(fd, PTP_CLOCK_GETCAPS2, unsafe.Pointer(&value))
-	return &value, err
-}
-
-// IoctlPtpSysOffsetPrecise returns a description of the clock
-// offset compared to the system clock.
-func IoctlPtpSysOffsetPrecise(fd int) (*PtpSysOffsetPrecise, error) {
-	var value PtpSysOffsetPrecise
-	err := ioctlPtr(fd, PTP_SYS_OFFSET_PRECISE2, unsafe.Pointer(&value))
-	return &value, err
-}
-
-// IoctlPtpSysOffsetExtended returns an extended description of the
-// clock offset compared to the system clock. The samples parameter
-// specifies the desired number of measurements.
-func IoctlPtpSysOffsetExtended(fd int, samples uint) (*PtpSysOffsetExtended, error) {
-	value := PtpSysOffsetExtended{Samples: uint32(samples)}
-	err := ioctlPtr(fd, PTP_SYS_OFFSET_EXTENDED2, unsafe.Pointer(&value))
-	return &value, err
-}
-
-// IoctlPtpPinGetfunc returns the configuration of the specified
-// I/O pin on given PTP device.
-func IoctlPtpPinGetfunc(fd int, index uint) (*PtpPinDesc, error) {
-	value := PtpPinDesc{Index: uint32(index)}
-	err := ioctlPtr(fd, PTP_PIN_GETFUNC2, unsafe.Pointer(&value))
-	return &value, err
-}
-
-// IoctlPtpPinSetfunc updates configuration of the specified PTP
-// I/O pin.
-func IoctlPtpPinSetfunc(fd int, pd *PtpPinDesc) error {
-	return ioctlPtr(fd, PTP_PIN_SETFUNC2, unsafe.Pointer(pd))
-}
-
-// IoctlPtpPeroutRequest configures the periodic output mode of the
-// PTP I/O pins.
-func IoctlPtpPeroutRequest(fd int, r *PtpPeroutRequest) error {
-	return ioctlPtr(fd, PTP_PEROUT_REQUEST2, unsafe.Pointer(r))
-}
-
-// IoctlPtpExttsRequest configures the external timestamping mode
-// of the PTP I/O pins.
-func IoctlPtpExttsRequest(fd int, r *PtpExttsRequest) error {
-	return ioctlPtr(fd, PTP_EXTTS_REQUEST2, unsafe.Pointer(r))
-}
-
 // IoctlGetWatchdogInfo fetches information about a watchdog device from the
 // Linux watchdog API. For more information, see:
 // https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html.
diff --git a/vendor/golang.org/x/sys/unix/mkerrors.sh b/vendor/golang.org/x/sys/unix/mkerrors.sh
index 6ab02b6c..d07dd09e 100644
--- a/vendor/golang.org/x/sys/unix/mkerrors.sh
+++ b/vendor/golang.org/x/sys/unix/mkerrors.sh
@@ -158,16 +158,6 @@ includes_Linux='
 #endif
 #define _GNU_SOURCE
 
-// See the description in unix/linux/types.go
-#if defined(__ARM_EABI__) || \
-	(defined(__mips__) && (_MIPS_SIM == _ABIO32)) || \
-	(defined(__powerpc__) && (!defined(__powerpc64__)))
-# ifdef   _TIME_BITS
-#  undef  _TIME_BITS
-# endif
-# define  _TIME_BITS 32
-#endif
-
 // <sys/ioctl.h> is broken on powerpc64, as it fails to include definitions of
 // these structures. We just include them copied from <bits/termios.h>.
 #if defined(__powerpc__)
@@ -266,7 +256,6 @@ struct ltchars {
 #include <linux/nsfs.h>
 #include <linux/perf_event.h>
 #include <linux/pps.h>
-#include <linux/ptp_clock.h>
 #include <linux/ptrace.h>
 #include <linux/random.h>
 #include <linux/reboot.h>
@@ -538,7 +527,6 @@ ccflags="$@"
 		$2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|TCP|MCAST|EVFILT|NOTE|SHUT|PROT|MAP|MREMAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR|LOCAL|TCPOPT|UDP)_/ ||
 		$2 ~ /^NFC_(GENL|PROTO|COMM|RF|SE|DIRECTION|LLCP|SOCKPROTO)_/ ||
 		$2 ~ /^NFC_.*_(MAX)?SIZE$/ ||
-		$2 ~ /^PTP_/ ||
 		$2 ~ /^RAW_PAYLOAD_/ ||
 		$2 ~ /^[US]F_/ ||
 		$2 ~ /^TP_STATUS_/ ||
@@ -564,7 +552,6 @@ ccflags="$@"
 		$2 !~ /^RTC_VL_(ACCURACY|BACKUP|DATA)/ &&
 		$2 ~ /^(NETLINK|NLM|NLMSG|NLA|IFA|IFAN|RT|RTC|RTCF|RTN|RTPROT|RTNH|ARPHRD|ETH_P|NETNSA)_/ ||
 		$2 ~ /^SOCK_|SK_DIAG_|SKNLGRP_$/ ||
-		$2 ~ /^(CONNECT|SAE)_/ ||
 		$2 ~ /^FIORDCHK$/ ||
 		$2 ~ /^SIOC/ ||
 		$2 ~ /^TIOC/ ||
@@ -668,7 +655,7 @@ errors=$(
 signals=$(
 	echo '#include <signal.h>' | $CC -x c - -E -dM $ccflags |
 	awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print $2 }' |
-	grep -E -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' |
+	grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT\|SIGMAX64' |
 	sort
 )
 
@@ -678,7 +665,7 @@ echo '#include <errno.h>' | $CC -x c - -E -dM $ccflags |
 	sort >_error.grep
 echo '#include <signal.h>' | $CC -x c - -E -dM $ccflags |
 	awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print "^\t" $2 "[ \t]*=" }' |
-	grep -E -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' |
+	grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT\|SIGMAX64' |
 	sort >_signal.grep
 
 echo '// mkerrors.sh' "$@"
diff --git a/vendor/golang.org/x/sys/unix/syscall_aix.go b/vendor/golang.org/x/sys/unix/syscall_aix.go
index 6f15ba1e..67ce6cef 100644
--- a/vendor/golang.org/x/sys/unix/syscall_aix.go
+++ b/vendor/golang.org/x/sys/unix/syscall_aix.go
@@ -360,7 +360,7 @@ func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int,
 	var status _C_int
 	var r Pid_t
 	err = ERESTART
-	// AIX wait4 may return with ERESTART errno, while the process is still
+	// AIX wait4 may return with ERESTART errno, while the processus is still
 	// active.
 	for err == ERESTART {
 		r, err = wait4(Pid_t(pid), &status, options, rusage)
diff --git a/vendor/golang.org/x/sys/unix/syscall_darwin.go b/vendor/golang.org/x/sys/unix/syscall_darwin.go
index 099867de..2d15200a 100644
--- a/vendor/golang.org/x/sys/unix/syscall_darwin.go
+++ b/vendor/golang.org/x/sys/unix/syscall_darwin.go
@@ -566,43 +566,6 @@ func PthreadFchdir(fd int) (err error) {
 	return pthread_fchdir_np(fd)
 }
 
-// Connectx calls connectx(2) to initiate a connection on a socket.
-//
-// srcIf, srcAddr, and dstAddr are filled into a [SaEndpoints] struct and passed as the endpoints argument.
-//
-//   - srcIf is the optional source interface index. 0 means unspecified.
-//   - srcAddr is the optional source address. nil means unspecified.
-//   - dstAddr is the destination address.
-//
-// On success, Connectx returns the number of bytes enqueued for transmission.
-func Connectx(fd int, srcIf uint32, srcAddr, dstAddr Sockaddr, associd SaeAssocID, flags uint32, iov []Iovec, connid *SaeConnID) (n uintptr, err error) {
-	endpoints := SaEndpoints{
-		Srcif: srcIf,
-	}
-
-	if srcAddr != nil {
-		addrp, addrlen, err := srcAddr.sockaddr()
-		if err != nil {
-			return 0, err
-		}
-		endpoints.Srcaddr = (*RawSockaddr)(addrp)
-		endpoints.Srcaddrlen = uint32(addrlen)
-	}
-
-	if dstAddr != nil {
-		addrp, addrlen, err := dstAddr.sockaddr()
-		if err != nil {
-			return 0, err
-		}
-		endpoints.Dstaddr = (*RawSockaddr)(addrp)
-		endpoints.Dstaddrlen = uint32(addrlen)
-	}
-
-	err = connectx(fd, &endpoints, associd, flags, iov, &n, connid)
-	return
-}
-
-//sys	connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error)
 //sys	sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error)
 
 //sys	shmat(id int, addr uintptr, flag int) (ret uintptr, err error)
diff --git a/vendor/golang.org/x/sys/unix/syscall_dragonfly.go b/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
index be8c0020..97cb916f 100644
--- a/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
+++ b/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
@@ -246,18 +246,6 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 	return sendfile(outfd, infd, offset, count)
 }
 
-func Dup3(oldfd, newfd, flags int) error {
-	if oldfd == newfd || flags&^O_CLOEXEC != 0 {
-		return EINVAL
-	}
-	how := F_DUP2FD
-	if flags&O_CLOEXEC != 0 {
-		how = F_DUP2FD_CLOEXEC
-	}
-	_, err := fcntl(oldfd, how, newfd)
-	return err
-}
-
 /*
  * Exposed directly
  */
diff --git a/vendor/golang.org/x/sys/unix/syscall_hurd.go b/vendor/golang.org/x/sys/unix/syscall_hurd.go
index a6a2d2fc..ba46651f 100644
--- a/vendor/golang.org/x/sys/unix/syscall_hurd.go
+++ b/vendor/golang.org/x/sys/unix/syscall_hurd.go
@@ -11,7 +11,6 @@ package unix
 int ioctl(int, unsigned long int, uintptr_t);
 */
 import "C"
-import "unsafe"
 
 func ioctl(fd int, req uint, arg uintptr) (err error) {
 	r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(arg))
diff --git a/vendor/golang.org/x/sys/unix/syscall_linux.go b/vendor/golang.org/x/sys/unix/syscall_linux.go
index 230a9454..3f1d3d4c 100644
--- a/vendor/golang.org/x/sys/unix/syscall_linux.go
+++ b/vendor/golang.org/x/sys/unix/syscall_linux.go
@@ -1295,48 +1295,6 @@ func GetsockoptTCPInfo(fd, level, opt int) (*TCPInfo, error) {
 	return &value, err
 }
 
-// GetsockoptTCPCCVegasInfo returns algorithm specific congestion control information for a socket using the "vegas"
-// algorithm.
-//
-// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option:
-//
-//	algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION)
-func GetsockoptTCPCCVegasInfo(fd, level, opt int) (*TCPVegasInfo, error) {
-	var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment
-	vallen := _Socklen(SizeofTCPCCInfo)
-	err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
-	out := (*TCPVegasInfo)(unsafe.Pointer(&value[0]))
-	return out, err
-}
-
-// GetsockoptTCPCCDCTCPInfo returns algorithm specific congestion control information for a socket using the "dctp"
-// algorithm.
-//
-// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option:
-//
-//	algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION)
-func GetsockoptTCPCCDCTCPInfo(fd, level, opt int) (*TCPDCTCPInfo, error) {
-	var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment
-	vallen := _Socklen(SizeofTCPCCInfo)
-	err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
-	out := (*TCPDCTCPInfo)(unsafe.Pointer(&value[0]))
-	return out, err
-}
-
-// GetsockoptTCPCCBBRInfo returns algorithm specific congestion control information for a socket using the "bbr"
-// algorithm.
-//
-// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option:
-//
-//	algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION)
-func GetsockoptTCPCCBBRInfo(fd, level, opt int) (*TCPBBRInfo, error) {
-	var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment
-	vallen := _Socklen(SizeofTCPCCInfo)
-	err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
-	out := (*TCPBBRInfo)(unsafe.Pointer(&value[0]))
-	return out, err
-}
-
 // GetsockoptString returns the string value of the socket option opt for the
 // socket associated with fd at the given socket level.
 func GetsockoptString(fd, level, opt int) (string, error) {
@@ -1860,7 +1818,6 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 //sys	ClockAdjtime(clockid int32, buf *Timex) (state int, err error)
 //sys	ClockGetres(clockid int32, res *Timespec) (err error)
 //sys	ClockGettime(clockid int32, time *Timespec) (err error)
-//sys	ClockSettime(clockid int32, time *Timespec) (err error)
 //sys	ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error)
 //sys	Close(fd int) (err error)
 //sys	CloseRange(first uint, last uint, flags uint) (err error)
@@ -2002,26 +1959,7 @@ func Getpgrp() (pid int) {
 //sysnb	Getpid() (pid int)
 //sysnb	Getppid() (ppid int)
 //sys	Getpriority(which int, who int) (prio int, err error)
-
-func Getrandom(buf []byte, flags int) (n int, err error) {
-	vdsoRet, supported := vgetrandom(buf, uint32(flags))
-	if supported {
-		if vdsoRet < 0 {
-			return 0, errnoErr(syscall.Errno(-vdsoRet))
-		}
-		return vdsoRet, nil
-	}
-	var p *byte
-	if len(buf) > 0 {
-		p = &buf[0]
-	}
-	r, _, e := Syscall(SYS_GETRANDOM, uintptr(unsafe.Pointer(p)), uintptr(len(buf)), uintptr(flags))
-	if e != 0 {
-		return 0, errnoErr(e)
-	}
-	return int(r), nil
-}
-
+//sys	Getrandom(buf []byte, flags int) (n int, err error)
 //sysnb	Getrusage(who int, rusage *Rusage) (err error)
 //sysnb	Getsid(pid int) (sid int, err error)
 //sysnb	Gettid() (tid int)
diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go b/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
index 745e5c7e..cf2ee6c7 100644
--- a/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go
@@ -182,5 +182,3 @@ func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error
 	}
 	return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags)
 }
-
-const SYS_FSTATAT = SYS_NEWFSTATAT
diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go b/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go
index dd2262a4..3d0e9845 100644
--- a/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go
+++ b/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go
@@ -214,5 +214,3 @@ func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error
 	}
 	return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags)
 }
-
-const SYS_FSTATAT = SYS_NEWFSTATAT
diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go b/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
index 8cf3670b..6f5a2889 100644
--- a/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go
@@ -187,5 +187,3 @@ func RISCVHWProbe(pairs []RISCVHWProbePairs, set *CPUSet, flags uint) (err error
 	}
 	return riscvHWProbe(pairs, setSize, set, flags)
 }
-
-const SYS_FSTATAT = SYS_NEWFSTATAT
diff --git a/vendor/golang.org/x/sys/unix/syscall_solaris.go b/vendor/golang.org/x/sys/unix/syscall_solaris.go
index abc39554..21974af0 100644
--- a/vendor/golang.org/x/sys/unix/syscall_solaris.go
+++ b/vendor/golang.org/x/sys/unix/syscall_solaris.go
@@ -1102,90 +1102,3 @@ func (s *Strioctl) SetInt(i int) {
 func IoctlSetStrioctlRetInt(fd int, req int, s *Strioctl) (int, error) {
 	return ioctlPtrRet(fd, req, unsafe.Pointer(s))
 }
-
-// Ucred Helpers
-// See ucred(3c) and getpeerucred(3c)
-
-//sys	getpeerucred(fd uintptr, ucred *uintptr) (err error)
-//sys	ucredFree(ucred uintptr) = ucred_free
-//sys	ucredGet(pid int) (ucred uintptr, err error) = ucred_get
-//sys	ucredGeteuid(ucred uintptr) (uid int) = ucred_geteuid
-//sys	ucredGetegid(ucred uintptr) (gid int) = ucred_getegid
-//sys	ucredGetruid(ucred uintptr) (uid int) = ucred_getruid
-//sys	ucredGetrgid(ucred uintptr) (gid int) = ucred_getrgid
-//sys	ucredGetsuid(ucred uintptr) (uid int) = ucred_getsuid
-//sys	ucredGetsgid(ucred uintptr) (gid int) = ucred_getsgid
-//sys	ucredGetpid(ucred uintptr) (pid int) = ucred_getpid
-
-// Ucred is an opaque struct that holds user credentials.
-type Ucred struct {
-	ucred uintptr
-}
-
-// We need to ensure that ucredFree is called on the underlying ucred
-// when the Ucred is garbage collected.
-func ucredFinalizer(u *Ucred) {
-	ucredFree(u.ucred)
-}
-
-func GetPeerUcred(fd uintptr) (*Ucred, error) {
-	var ucred uintptr
-	err := getpeerucred(fd, &ucred)
-	if err != nil {
-		return nil, err
-	}
-	result := &Ucred{
-		ucred: ucred,
-	}
-	// set the finalizer on the result so that the ucred will be freed
-	runtime.SetFinalizer(result, ucredFinalizer)
-	return result, nil
-}
-
-func UcredGet(pid int) (*Ucred, error) {
-	ucred, err := ucredGet(pid)
-	if err != nil {
-		return nil, err
-	}
-	result := &Ucred{
-		ucred: ucred,
-	}
-	// set the finalizer on the result so that the ucred will be freed
-	runtime.SetFinalizer(result, ucredFinalizer)
-	return result, nil
-}
-
-func (u *Ucred) Geteuid() int {
-	defer runtime.KeepAlive(u)
-	return ucredGeteuid(u.ucred)
-}
-
-func (u *Ucred) Getruid() int {
-	defer runtime.KeepAlive(u)
-	return ucredGetruid(u.ucred)
-}
-
-func (u *Ucred) Getsuid() int {
-	defer runtime.KeepAlive(u)
-	return ucredGetsuid(u.ucred)
-}
-
-func (u *Ucred) Getegid() int {
-	defer runtime.KeepAlive(u)
-	return ucredGetegid(u.ucred)
-}
-
-func (u *Ucred) Getrgid() int {
-	defer runtime.KeepAlive(u)
-	return ucredGetrgid(u.ucred)
-}
-
-func (u *Ucred) Getsgid() int {
-	defer runtime.KeepAlive(u)
-	return ucredGetsgid(u.ucred)
-}
-
-func (u *Ucred) Getpid() int {
-	defer runtime.KeepAlive(u)
-	return ucredGetpid(u.ucred)
-}
diff --git a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
index 7bf5c04b..312ae6ac 100644
--- a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
+++ b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
@@ -768,15 +768,6 @@ func Munmap(b []byte) (err error) {
 	return mapper.Munmap(b)
 }
 
-func MmapPtr(fd int, offset int64, addr unsafe.Pointer, length uintptr, prot int, flags int) (ret unsafe.Pointer, err error) {
-	xaddr, err := mapper.mmap(uintptr(addr), length, prot, flags, fd, offset)
-	return unsafe.Pointer(xaddr), err
-}
-
-func MunmapPtr(addr unsafe.Pointer, length uintptr) (err error) {
-	return mapper.munmap(uintptr(addr), length)
-}
-
 //sys   Gethostname(buf []byte) (err error) = SYS___GETHOSTNAME_A
 //sysnb	Getgid() (gid int)
 //sysnb	Getpid() (pid int)
@@ -825,10 +816,10 @@ func Lstat(path string, stat *Stat_t) (err error) {
 // for checking symlinks begins with $VERSION/ $SYSNAME/ $SYSSYMR/ $SYSSYMA/
 func isSpecialPath(path []byte) (v bool) {
 	var special = [4][8]byte{
-		{'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'},
-		{'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'},
-		{'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'},
-		{'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}}
+		[8]byte{'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'},
+		[8]byte{'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'},
+		[8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'},
+		[8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}}
 
 	var i, j int
 	for i = 0; i < len(special); i++ {
@@ -3124,90 +3115,3 @@ func legacy_Mkfifoat(dirfd int, path string, mode uint32) (err error) {
 //sys	Posix_openpt(oflag int) (fd int, err error) = SYS_POSIX_OPENPT
 //sys	Grantpt(fildes int) (rc int, err error) = SYS_GRANTPT
 //sys	Unlockpt(fildes int) (rc int, err error) = SYS_UNLOCKPT
-
-func fcntlAsIs(fd uintptr, cmd int, arg uintptr) (val int, err error) {
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCNTL<<4, uintptr(fd), uintptr(cmd), arg)
-	runtime.ExitSyscall()
-	val = int(r0)
-	if int64(r0) == -1 {
-		err = errnoErr2(e1, e2)
-	}
-	return
-}
-
-func Fcntl(fd uintptr, cmd int, op interface{}) (ret int, err error) {
-	switch op.(type) {
-	case *Flock_t:
-		err = FcntlFlock(fd, cmd, op.(*Flock_t))
-		if err != nil {
-			ret = -1
-		}
-		return
-	case int:
-		return FcntlInt(fd, cmd, op.(int))
-	case *F_cnvrt:
-		return fcntlAsIs(fd, cmd, uintptr(unsafe.Pointer(op.(*F_cnvrt))))
-	case unsafe.Pointer:
-		return fcntlAsIs(fd, cmd, uintptr(op.(unsafe.Pointer)))
-	default:
-		return -1, EINVAL
-	}
-	return
-}
-
-func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
-	if raceenabled {
-		raceReleaseMerge(unsafe.Pointer(&ioSync))
-	}
-	return sendfile(outfd, infd, offset, count)
-}
-
-func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
-	// TODO: use LE call instead if the call is implemented
-	originalOffset, err := Seek(infd, 0, SEEK_CUR)
-	if err != nil {
-		return -1, err
-	}
-	//start reading data from in_fd
-	if offset != nil {
-		_, err := Seek(infd, *offset, SEEK_SET)
-		if err != nil {
-			return -1, err
-		}
-	}
-
-	buf := make([]byte, count)
-	readBuf := make([]byte, 0)
-	var n int = 0
-	for i := 0; i < count; i += n {
-		n, err := Read(infd, buf)
-		if n == 0 {
-			if err != nil {
-				return -1, err
-			} else { // EOF
-				break
-			}
-		}
-		readBuf = append(readBuf, buf...)
-		buf = buf[0:0]
-	}
-
-	n2, err := Write(outfd, readBuf)
-	if err != nil {
-		return -1, err
-	}
-
-	//When sendfile() returns, this variable will be set to the
-	// offset of the byte following the last byte that was read.
-	if offset != nil {
-		*offset = *offset + int64(n)
-		// If offset is not NULL, then sendfile() does not modify the file
-		// offset of in_fd
-		_, err := Seek(infd, originalOffset, SEEK_SET)
-		if err != nil {
-			return -1, err
-		}
-	}
-	return n2, nil
-}
diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
index d73c4652..4308ac17 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
@@ -237,9 +237,6 @@ const (
 	CLOCK_UPTIME_RAW_APPROX                 = 0x9
 	CLONE_NOFOLLOW                          = 0x1
 	CLONE_NOOWNERCOPY                       = 0x2
-	CONNECT_DATA_AUTHENTICATED              = 0x4
-	CONNECT_DATA_IDEMPOTENT                 = 0x2
-	CONNECT_RESUME_ON_READ_WRITE            = 0x1
 	CR0                                     = 0x0
 	CR1                                     = 0x1000
 	CR2                                     = 0x2000
@@ -1268,10 +1265,6 @@ const (
 	RTV_SSTHRESH                            = 0x20
 	RUSAGE_CHILDREN                         = -0x1
 	RUSAGE_SELF                             = 0x0
-	SAE_ASSOCID_ALL                         = 0xffffffff
-	SAE_ASSOCID_ANY                         = 0x0
-	SAE_CONNID_ALL                          = 0xffffffff
-	SAE_CONNID_ANY                          = 0x0
 	SCM_CREDS                               = 0x3
 	SCM_RIGHTS                              = 0x1
 	SCM_TIMESTAMP                           = 0x2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
index 4a55a400..c8068a7a 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
@@ -237,9 +237,6 @@ const (
 	CLOCK_UPTIME_RAW_APPROX                 = 0x9
 	CLONE_NOFOLLOW                          = 0x1
 	CLONE_NOOWNERCOPY                       = 0x2
-	CONNECT_DATA_AUTHENTICATED              = 0x4
-	CONNECT_DATA_IDEMPOTENT                 = 0x2
-	CONNECT_RESUME_ON_READ_WRITE            = 0x1
 	CR0                                     = 0x0
 	CR1                                     = 0x1000
 	CR2                                     = 0x2000
@@ -1268,10 +1265,6 @@ const (
 	RTV_SSTHRESH                            = 0x20
 	RUSAGE_CHILDREN                         = -0x1
 	RUSAGE_SELF                             = 0x0
-	SAE_ASSOCID_ALL                         = 0xffffffff
-	SAE_ASSOCID_ANY                         = 0x0
-	SAE_CONNID_ALL                          = 0xffffffff
-	SAE_CONNID_ANY                          = 0x0
 	SCM_CREDS                               = 0x3
 	SCM_RIGHTS                              = 0x1
 	SCM_TIMESTAMP                           = 0x2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux.go b/vendor/golang.org/x/sys/unix/zerrors_linux.go
index 4f432bfe..01a70b24 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux.go
@@ -321,9 +321,6 @@ const (
 	AUDIT_INTEGRITY_STATUS                      = 0x70a
 	AUDIT_IPC                                   = 0x517
 	AUDIT_IPC_SET_PERM                          = 0x51f
-	AUDIT_IPE_ACCESS                            = 0x58c
-	AUDIT_IPE_CONFIG_CHANGE                     = 0x58d
-	AUDIT_IPE_POLICY_LOAD                       = 0x58e
 	AUDIT_KERNEL                                = 0x7d0
 	AUDIT_KERNEL_OTHER                          = 0x524
 	AUDIT_KERN_MODULE                           = 0x532
@@ -492,14 +489,12 @@ const (
 	BPF_F_ID                                    = 0x20
 	BPF_F_NETFILTER_IP_DEFRAG                   = 0x1
 	BPF_F_QUERY_EFFECTIVE                       = 0x1
-	BPF_F_REDIRECT_FLAGS                        = 0x19
 	BPF_F_REPLACE                               = 0x4
 	BPF_F_SLEEPABLE                             = 0x10
 	BPF_F_STRICT_ALIGNMENT                      = 0x1
 	BPF_F_TEST_REG_INVARIANTS                   = 0x80
 	BPF_F_TEST_RND_HI32                         = 0x4
 	BPF_F_TEST_RUN_ON_CPU                       = 0x1
-	BPF_F_TEST_SKB_CHECKSUM_COMPLETE            = 0x4
 	BPF_F_TEST_STATE_FREQ                       = 0x8
 	BPF_F_TEST_XDP_LIVE_FRAMES                  = 0x2
 	BPF_F_XDP_DEV_BOUND_ONLY                    = 0x40
@@ -1170,7 +1165,6 @@ const (
 	EXTA                                        = 0xe
 	EXTB                                        = 0xf
 	F2FS_SUPER_MAGIC                            = 0xf2f52010
-	FALLOC_FL_ALLOCATE_RANGE                    = 0x0
 	FALLOC_FL_COLLAPSE_RANGE                    = 0x8
 	FALLOC_FL_INSERT_RANGE                      = 0x20
 	FALLOC_FL_KEEP_SIZE                         = 0x1
@@ -1245,7 +1239,6 @@ const (
 	FAN_REPORT_DFID_NAME                        = 0xc00
 	FAN_REPORT_DFID_NAME_TARGET                 = 0x1e00
 	FAN_REPORT_DIR_FID                          = 0x400
-	FAN_REPORT_FD_ERROR                         = 0x2000
 	FAN_REPORT_FID                              = 0x200
 	FAN_REPORT_NAME                             = 0x800
 	FAN_REPORT_PIDFD                            = 0x80
@@ -1331,10 +1324,8 @@ const (
 	FUSE_SUPER_MAGIC                            = 0x65735546
 	FUTEXFS_SUPER_MAGIC                         = 0xbad1dea
 	F_ADD_SEALS                                 = 0x409
-	F_CREATED_QUERY                             = 0x404
 	F_DUPFD                                     = 0x0
 	F_DUPFD_CLOEXEC                             = 0x406
-	F_DUPFD_QUERY                               = 0x403
 	F_EXLCK                                     = 0x4
 	F_GETFD                                     = 0x1
 	F_GETFL                                     = 0x3
@@ -1554,7 +1545,6 @@ const (
 	IPPROTO_ROUTING                             = 0x2b
 	IPPROTO_RSVP                                = 0x2e
 	IPPROTO_SCTP                                = 0x84
-	IPPROTO_SMC                                 = 0x100
 	IPPROTO_TCP                                 = 0x6
 	IPPROTO_TP                                  = 0x1d
 	IPPROTO_UDP                                 = 0x11
@@ -1627,8 +1617,6 @@ const (
 	IPV6_UNICAST_IF                             = 0x4c
 	IPV6_USER_FLOW                              = 0xe
 	IPV6_V6ONLY                                 = 0x1a
-	IPV6_VERSION                                = 0x60
-	IPV6_VERSION_MASK                           = 0xf0
 	IPV6_XFRM_POLICY                            = 0x23
 	IP_ADD_MEMBERSHIP                           = 0x23
 	IP_ADD_SOURCE_MEMBERSHIP                    = 0x27
@@ -1810,8 +1798,6 @@ const (
 	LANDLOCK_ACCESS_NET_BIND_TCP                = 0x1
 	LANDLOCK_ACCESS_NET_CONNECT_TCP             = 0x2
 	LANDLOCK_CREATE_RULESET_VERSION             = 0x1
-	LANDLOCK_SCOPE_ABSTRACT_UNIX_SOCKET         = 0x1
-	LANDLOCK_SCOPE_SIGNAL                       = 0x2
 	LINUX_REBOOT_CMD_CAD_OFF                    = 0x0
 	LINUX_REBOOT_CMD_CAD_ON                     = 0x89abcdef
 	LINUX_REBOOT_CMD_HALT                       = 0xcdef0123
@@ -1873,7 +1859,6 @@ const (
 	MADV_UNMERGEABLE                            = 0xd
 	MADV_WILLNEED                               = 0x3
 	MADV_WIPEONFORK                             = 0x12
-	MAP_DROPPABLE                               = 0x8
 	MAP_FILE                                    = 0x0
 	MAP_FIXED                                   = 0x10
 	MAP_FIXED_NOREPLACE                         = 0x100000
@@ -1937,8 +1922,6 @@ const (
 	MNT_EXPIRE                                  = 0x4
 	MNT_FORCE                                   = 0x1
 	MNT_ID_REQ_SIZE_VER0                        = 0x18
-	MNT_ID_REQ_SIZE_VER1                        = 0x20
-	MNT_NS_INFO_SIZE_VER0                       = 0x10
 	MODULE_INIT_COMPRESSED_FILE                 = 0x4
 	MODULE_INIT_IGNORE_MODVERSIONS              = 0x1
 	MODULE_INIT_IGNORE_VERMAGIC                 = 0x2
@@ -1974,7 +1957,6 @@ const (
 	MSG_PEEK                                    = 0x2
 	MSG_PROXY                                   = 0x10
 	MSG_RST                                     = 0x1000
-	MSG_SOCK_DEVMEM                             = 0x2000000
 	MSG_SYN                                     = 0x400
 	MSG_TRUNC                                   = 0x20
 	MSG_TRYHARD                                 = 0x4
@@ -2091,7 +2073,6 @@ const (
 	NFC_ATR_REQ_MAXSIZE                         = 0x40
 	NFC_ATR_RES_GB_MAXSIZE                      = 0x2f
 	NFC_ATR_RES_MAXSIZE                         = 0x40
-	NFC_ATS_MAXSIZE                             = 0x14
 	NFC_COMM_ACTIVE                             = 0x0
 	NFC_COMM_PASSIVE                            = 0x1
 	NFC_DEVICE_NAME_MAXSIZE                     = 0x8
@@ -2172,7 +2153,6 @@ const (
 	NFNL_SUBSYS_QUEUE                           = 0x3
 	NFNL_SUBSYS_ULOG                            = 0x4
 	NFS_SUPER_MAGIC                             = 0x6969
-	NFT_BITWISE_BOOL                            = 0x0
 	NFT_CHAIN_FLAGS                             = 0x7
 	NFT_CHAIN_MAXNAMELEN                        = 0x100
 	NFT_CT_MAX                                  = 0x17
@@ -2207,7 +2187,7 @@ const (
 	NFT_REG_SIZE                                = 0x10
 	NFT_REJECT_ICMPX_MAX                        = 0x3
 	NFT_RT_MAX                                  = 0x4
-	NFT_SECMARK_CTX_MAXLEN                      = 0x1000
+	NFT_SECMARK_CTX_MAXLEN                      = 0x100
 	NFT_SET_MAXNAMELEN                          = 0x100
 	NFT_SOCKET_MAX                              = 0x3
 	NFT_TABLE_F_MASK                            = 0x7
@@ -2376,11 +2356,9 @@ const (
 	PERF_MEM_LVLNUM_IO                          = 0xa
 	PERF_MEM_LVLNUM_L1                          = 0x1
 	PERF_MEM_LVLNUM_L2                          = 0x2
-	PERF_MEM_LVLNUM_L2_MHB                      = 0x5
 	PERF_MEM_LVLNUM_L3                          = 0x3
 	PERF_MEM_LVLNUM_L4                          = 0x4
 	PERF_MEM_LVLNUM_LFB                         = 0xc
-	PERF_MEM_LVLNUM_MSC                         = 0x6
 	PERF_MEM_LVLNUM_NA                          = 0xf
 	PERF_MEM_LVLNUM_PMEM                        = 0xe
 	PERF_MEM_LVLNUM_RAM                         = 0xd
@@ -2453,7 +2431,6 @@ const (
 	PRIO_PGRP                                   = 0x1
 	PRIO_PROCESS                                = 0x0
 	PRIO_USER                                   = 0x2
-	PROCFS_IOCTL_MAGIC                          = 'f'
 	PROC_SUPER_MAGIC                            = 0x9fa0
 	PROT_EXEC                                   = 0x4
 	PROT_GROWSDOWN                              = 0x1000000
@@ -2501,7 +2478,6 @@ const (
 	PR_GET_PDEATHSIG                            = 0x2
 	PR_GET_SECCOMP                              = 0x15
 	PR_GET_SECUREBITS                           = 0x1b
-	PR_GET_SHADOW_STACK_STATUS                  = 0x4a
 	PR_GET_SPECULATION_CTRL                     = 0x34
 	PR_GET_TAGGED_ADDR_CTRL                     = 0x38
 	PR_GET_THP_DISABLE                          = 0x2a
@@ -2510,7 +2486,6 @@ const (
 	PR_GET_TIMING                               = 0xd
 	PR_GET_TSC                                  = 0x19
 	PR_GET_UNALIGN                              = 0x5
-	PR_LOCK_SHADOW_STACK_STATUS                 = 0x4c
 	PR_MCE_KILL                                 = 0x21
 	PR_MCE_KILL_CLEAR                           = 0x0
 	PR_MCE_KILL_DEFAULT                         = 0x2
@@ -2537,8 +2512,6 @@ const (
 	PR_PAC_GET_ENABLED_KEYS                     = 0x3d
 	PR_PAC_RESET_KEYS                           = 0x36
 	PR_PAC_SET_ENABLED_KEYS                     = 0x3c
-	PR_PMLEN_MASK                               = 0x7f000000
-	PR_PMLEN_SHIFT                              = 0x18
 	PR_PPC_DEXCR_CTRL_CLEAR                     = 0x4
 	PR_PPC_DEXCR_CTRL_CLEAR_ONEXEC              = 0x10
 	PR_PPC_DEXCR_CTRL_EDITABLE                  = 0x1
@@ -2606,7 +2579,6 @@ const (
 	PR_SET_PTRACER                              = 0x59616d61
 	PR_SET_SECCOMP                              = 0x16
 	PR_SET_SECUREBITS                           = 0x1c
-	PR_SET_SHADOW_STACK_STATUS                  = 0x4b
 	PR_SET_SPECULATION_CTRL                     = 0x35
 	PR_SET_SYSCALL_USER_DISPATCH                = 0x3b
 	PR_SET_TAGGED_ADDR_CTRL                     = 0x37
@@ -2617,9 +2589,6 @@ const (
 	PR_SET_UNALIGN                              = 0x6
 	PR_SET_VMA                                  = 0x53564d41
 	PR_SET_VMA_ANON_NAME                        = 0x0
-	PR_SHADOW_STACK_ENABLE                      = 0x1
-	PR_SHADOW_STACK_PUSH                        = 0x4
-	PR_SHADOW_STACK_WRITE                       = 0x2
 	PR_SME_GET_VL                               = 0x40
 	PR_SME_SET_VL                               = 0x3f
 	PR_SME_SET_VL_ONEXEC                        = 0x40000
@@ -2651,28 +2620,6 @@ const (
 	PR_UNALIGN_NOPRINT                          = 0x1
 	PR_UNALIGN_SIGBUS                           = 0x2
 	PSTOREFS_MAGIC                              = 0x6165676c
-	PTP_CLK_MAGIC                               = '='
-	PTP_ENABLE_FEATURE                          = 0x1
-	PTP_EXTTS_EDGES                             = 0x6
-	PTP_EXTTS_EVENT_VALID                       = 0x1
-	PTP_EXTTS_V1_VALID_FLAGS                    = 0x7
-	PTP_EXTTS_VALID_FLAGS                       = 0x1f
-	PTP_EXT_OFFSET                              = 0x10
-	PTP_FALLING_EDGE                            = 0x4
-	PTP_MAX_SAMPLES                             = 0x19
-	PTP_PEROUT_DUTY_CYCLE                       = 0x2
-	PTP_PEROUT_ONE_SHOT                         = 0x1
-	PTP_PEROUT_PHASE                            = 0x4
-	PTP_PEROUT_V1_VALID_FLAGS                   = 0x0
-	PTP_PEROUT_VALID_FLAGS                      = 0x7
-	PTP_PIN_GETFUNC                             = 0xc0603d06
-	PTP_PIN_GETFUNC2                            = 0xc0603d0f
-	PTP_RISING_EDGE                             = 0x2
-	PTP_STRICT_FLAGS                            = 0x8
-	PTP_SYS_OFFSET_EXTENDED                     = 0xc4c03d09
-	PTP_SYS_OFFSET_EXTENDED2                    = 0xc4c03d12
-	PTP_SYS_OFFSET_PRECISE                      = 0xc0403d08
-	PTP_SYS_OFFSET_PRECISE2                     = 0xc0403d11
 	PTRACE_ATTACH                               = 0x10
 	PTRACE_CONT                                 = 0x7
 	PTRACE_DETACH                               = 0x11
@@ -2929,6 +2876,7 @@ const (
 	RTM_NEWNEXTHOP                              = 0x68
 	RTM_NEWNEXTHOPBUCKET                        = 0x74
 	RTM_NEWNSID                                 = 0x58
+	RTM_NEWNVLAN                                = 0x70
 	RTM_NEWPREFIX                               = 0x34
 	RTM_NEWQDISC                                = 0x24
 	RTM_NEWROUTE                                = 0x18
@@ -2937,7 +2885,6 @@ const (
 	RTM_NEWTCLASS                               = 0x28
 	RTM_NEWTFILTER                              = 0x2c
 	RTM_NEWTUNNEL                               = 0x78
-	RTM_NEWVLAN                                 = 0x70
 	RTM_NR_FAMILIES                             = 0x1b
 	RTM_NR_MSGTYPES                             = 0x6c
 	RTM_SETDCB                                  = 0x4f
@@ -2986,17 +2933,15 @@ const (
 	RUSAGE_SELF                                 = 0x0
 	RUSAGE_THREAD                               = 0x1
 	RWF_APPEND                                  = 0x10
-	RWF_ATOMIC                                  = 0x40
 	RWF_DSYNC                                   = 0x2
 	RWF_HIPRI                                   = 0x1
 	RWF_NOAPPEND                                = 0x20
 	RWF_NOWAIT                                  = 0x8
-	RWF_SUPPORTED                               = 0x7f
+	RWF_SUPPORTED                               = 0x3f
 	RWF_SYNC                                    = 0x4
 	RWF_WRITE_LIFE_NOT_SET                      = 0x0
 	SCHED_BATCH                                 = 0x3
 	SCHED_DEADLINE                              = 0x6
-	SCHED_EXT                                   = 0x7
 	SCHED_FIFO                                  = 0x1
 	SCHED_FLAG_ALL                              = 0x7f
 	SCHED_FLAG_DL_OVERRUN                       = 0x4
@@ -3265,7 +3210,6 @@ const (
 	STATX_ATTR_MOUNT_ROOT                       = 0x2000
 	STATX_ATTR_NODUMP                           = 0x40
 	STATX_ATTR_VERITY                           = 0x100000
-	STATX_ATTR_WRITE_ATOMIC                     = 0x400000
 	STATX_BASIC_STATS                           = 0x7ff
 	STATX_BLOCKS                                = 0x400
 	STATX_BTIME                                 = 0x800
@@ -3282,7 +3226,6 @@ const (
 	STATX_SUBVOL                                = 0x8000
 	STATX_TYPE                                  = 0x1
 	STATX_UID                                   = 0x8
-	STATX_WRITE_ATOMIC                          = 0x10000
 	STATX__RESERVED                             = 0x80000000
 	SYNC_FILE_RANGE_WAIT_AFTER                  = 0x4
 	SYNC_FILE_RANGE_WAIT_BEFORE                 = 0x1
@@ -3681,7 +3624,6 @@ const (
 	XDP_UMEM_PGOFF_COMPLETION_RING              = 0x180000000
 	XDP_UMEM_PGOFF_FILL_RING                    = 0x100000000
 	XDP_UMEM_REG                                = 0x4
-	XDP_UMEM_TX_METADATA_LEN                    = 0x4
 	XDP_UMEM_TX_SW_CSUM                         = 0x2
 	XDP_UMEM_UNALIGNED_CHUNK_FLAG               = 0x1
 	XDP_USE_NEED_WAKEUP                         = 0x8
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
index 75207613..684a5168 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
@@ -109,15 +109,12 @@ const (
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
-	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
-	IPV6_FLOWINFO_MASK               = 0xffffff0f
-	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -156,14 +153,9 @@ const (
 	NFDBITS                          = 0x20
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
-	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
-	NS_GET_PID_FROM_PIDNS            = 0x8004b706
-	NS_GET_PID_IN_PIDNS              = 0x8004b708
-	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
-	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -240,20 +232,6 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffff
-	PTP_CLOCK_GETCAPS                = 0x80503d01
-	PTP_CLOCK_GETCAPS2               = 0x80503d0a
-	PTP_ENABLE_PPS                   = 0x40043d04
-	PTP_ENABLE_PPS2                  = 0x40043d0d
-	PTP_EXTTS_REQUEST                = 0x40103d02
-	PTP_EXTTS_REQUEST2               = 0x40103d0b
-	PTP_MASK_CLEAR_ALL               = 0x3d13
-	PTP_MASK_EN_SINGLE               = 0x40043d14
-	PTP_PEROUT_REQUEST               = 0x40383d03
-	PTP_PEROUT_REQUEST2              = 0x40383d0c
-	PTP_PIN_SETFUNC                  = 0x40603d07
-	PTP_PIN_SETFUNC2                 = 0x40603d10
-	PTP_SYS_OFFSET                   = 0x43403d05
-	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GETFPXREGS                = 0x12
 	PTRACE_GET_THREAD_AREA           = 0x19
@@ -300,13 +278,10 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
-	SCM_DEVMEM_DMABUF                = 0x4f
-	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
-	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -341,9 +316,6 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
-	SO_DEVMEM_DMABUF                 = 0x4f
-	SO_DEVMEM_DONTNEED               = 0x50
-	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
index c68acda5..61d74b59 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
@@ -109,15 +109,12 @@ const (
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
-	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
-	IPV6_FLOWINFO_MASK               = 0xffffff0f
-	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -156,14 +153,9 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
-	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
-	NS_GET_PID_FROM_PIDNS            = 0x8004b706
-	NS_GET_PID_IN_PIDNS              = 0x8004b708
-	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
-	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -240,20 +232,6 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
-	PTP_CLOCK_GETCAPS                = 0x80503d01
-	PTP_CLOCK_GETCAPS2               = 0x80503d0a
-	PTP_ENABLE_PPS                   = 0x40043d04
-	PTP_ENABLE_PPS2                  = 0x40043d0d
-	PTP_EXTTS_REQUEST                = 0x40103d02
-	PTP_EXTTS_REQUEST2               = 0x40103d0b
-	PTP_MASK_CLEAR_ALL               = 0x3d13
-	PTP_MASK_EN_SINGLE               = 0x40043d14
-	PTP_PEROUT_REQUEST               = 0x40383d03
-	PTP_PEROUT_REQUEST2              = 0x40383d0c
-	PTP_PIN_SETFUNC                  = 0x40603d07
-	PTP_PIN_SETFUNC2                 = 0x40603d10
-	PTP_SYS_OFFSET                   = 0x43403d05
-	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_ARCH_PRCTL                = 0x1e
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GETFPXREGS                = 0x12
@@ -301,13 +279,10 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
-	SCM_DEVMEM_DMABUF                = 0x4f
-	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
-	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -342,9 +317,6 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
-	SO_DEVMEM_DMABUF                 = 0x4f
-	SO_DEVMEM_DONTNEED               = 0x50
-	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
index a8c607ab..a28c9e3e 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
@@ -108,15 +108,12 @@ const (
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
-	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
-	IPV6_FLOWINFO_MASK               = 0xffffff0f
-	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -153,14 +150,9 @@ const (
 	NFDBITS                          = 0x20
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
-	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
-	NS_GET_PID_FROM_PIDNS            = 0x8004b706
-	NS_GET_PID_IN_PIDNS              = 0x8004b708
-	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
-	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -237,20 +229,6 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffff
-	PTP_CLOCK_GETCAPS                = 0x80503d01
-	PTP_CLOCK_GETCAPS2               = 0x80503d0a
-	PTP_ENABLE_PPS                   = 0x40043d04
-	PTP_ENABLE_PPS2                  = 0x40043d0d
-	PTP_EXTTS_REQUEST                = 0x40103d02
-	PTP_EXTTS_REQUEST2               = 0x40103d0b
-	PTP_MASK_CLEAR_ALL               = 0x3d13
-	PTP_MASK_EN_SINGLE               = 0x40043d14
-	PTP_PEROUT_REQUEST               = 0x40383d03
-	PTP_PEROUT_REQUEST2              = 0x40383d0c
-	PTP_PIN_SETFUNC                  = 0x40603d07
-	PTP_PIN_SETFUNC2                 = 0x40603d10
-	PTP_SYS_OFFSET                   = 0x43403d05
-	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_GETCRUNCHREGS             = 0x19
 	PTRACE_GETFDPIC                  = 0x1f
 	PTRACE_GETFDPIC_EXEC             = 0x0
@@ -306,13 +284,10 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
-	SCM_DEVMEM_DMABUF                = 0x4f
-	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
-	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -347,9 +322,6 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
-	SO_DEVMEM_DMABUF                 = 0x4f
-	SO_DEVMEM_DONTNEED               = 0x50
-	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
index 18563dd8..ab5d1fe8 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
@@ -109,19 +109,15 @@ const (
 	F_SETOWN                         = 0x8
 	F_UNLCK                          = 0x2
 	F_WRLCK                          = 0x1
-	GCS_MAGIC                        = 0x47435300
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
-	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
-	IPV6_FLOWINFO_MASK               = 0xffffff0f
-	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -158,14 +154,9 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
-	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
-	NS_GET_PID_FROM_PIDNS            = 0x8004b706
-	NS_GET_PID_IN_PIDNS              = 0x8004b708
-	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
-	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -209,7 +200,6 @@ const (
 	PERF_EVENT_IOC_SET_BPF           = 0x40042408
 	PERF_EVENT_IOC_SET_FILTER        = 0x40082406
 	PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
-	POE_MAGIC                        = 0x504f4530
 	PPPIOCATTACH                     = 0x4004743d
 	PPPIOCATTCHAN                    = 0x40047438
 	PPPIOCBRIDGECHAN                 = 0x40047435
@@ -245,20 +235,6 @@ const (
 	PROT_BTI                         = 0x10
 	PROT_MTE                         = 0x20
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
-	PTP_CLOCK_GETCAPS                = 0x80503d01
-	PTP_CLOCK_GETCAPS2               = 0x80503d0a
-	PTP_ENABLE_PPS                   = 0x40043d04
-	PTP_ENABLE_PPS2                  = 0x40043d0d
-	PTP_EXTTS_REQUEST                = 0x40103d02
-	PTP_EXTTS_REQUEST2               = 0x40103d0b
-	PTP_MASK_CLEAR_ALL               = 0x3d13
-	PTP_MASK_EN_SINGLE               = 0x40043d14
-	PTP_PEROUT_REQUEST               = 0x40383d03
-	PTP_PEROUT_REQUEST2              = 0x40383d0c
-	PTP_PIN_SETFUNC                  = 0x40603d07
-	PTP_PIN_SETFUNC2                 = 0x40603d10
-	PTP_SYS_OFFSET                   = 0x43403d05
-	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_PEEKMTETAGS               = 0x21
 	PTRACE_POKEMTETAGS               = 0x22
 	PTRACE_SYSEMU                    = 0x1f
@@ -299,13 +275,10 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
-	SCM_DEVMEM_DMABUF                = 0x4f
-	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
-	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -340,9 +313,6 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
-	SO_DEVMEM_DMABUF                 = 0x4f
-	SO_DEVMEM_DONTNEED               = 0x50
-	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
index 22912cda..c523090e 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
@@ -109,15 +109,12 @@ const (
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
-	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
-	IPV6_FLOWINFO_MASK               = 0xffffff0f
-	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -157,14 +154,9 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
-	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
-	NS_GET_PID_FROM_PIDNS            = 0x8004b706
-	NS_GET_PID_IN_PIDNS              = 0x8004b708
-	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
-	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -241,20 +233,6 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
-	PTP_CLOCK_GETCAPS                = 0x80503d01
-	PTP_CLOCK_GETCAPS2               = 0x80503d0a
-	PTP_ENABLE_PPS                   = 0x40043d04
-	PTP_ENABLE_PPS2                  = 0x40043d0d
-	PTP_EXTTS_REQUEST                = 0x40103d02
-	PTP_EXTTS_REQUEST2               = 0x40103d0b
-	PTP_MASK_CLEAR_ALL               = 0x3d13
-	PTP_MASK_EN_SINGLE               = 0x40043d14
-	PTP_PEROUT_REQUEST               = 0x40383d03
-	PTP_PEROUT_REQUEST2              = 0x40383d0c
-	PTP_PIN_SETFUNC                  = 0x40603d07
-	PTP_PIN_SETFUNC2                 = 0x40603d10
-	PTP_SYS_OFFSET                   = 0x43403d05
-	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_SYSEMU                    = 0x1f
 	PTRACE_SYSEMU_SINGLESTEP         = 0x20
 	RLIMIT_AS                        = 0x9
@@ -293,13 +271,10 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
-	SCM_DEVMEM_DMABUF                = 0x4f
-	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
-	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -334,9 +309,6 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
-	SO_DEVMEM_DMABUF                 = 0x4f
-	SO_DEVMEM_DONTNEED               = 0x50
-	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
index 29344eb3..01e6ea78 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
@@ -108,15 +108,12 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
-	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x100
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x80
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
-	IPV6_FLOWINFO_MASK               = 0xfffffff
-	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -153,14 +150,9 @@ const (
 	NFDBITS                          = 0x20
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
-	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
-	NS_GET_PID_FROM_PIDNS            = 0x4004b706
-	NS_GET_PID_IN_PIDNS              = 0x4004b708
-	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
-	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -237,20 +229,6 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PR_SET_PTRACER_ANY               = 0xffffffff
-	PTP_CLOCK_GETCAPS                = 0x40503d01
-	PTP_CLOCK_GETCAPS2               = 0x40503d0a
-	PTP_ENABLE_PPS                   = 0x80043d04
-	PTP_ENABLE_PPS2                  = 0x80043d0d
-	PTP_EXTTS_REQUEST                = 0x80103d02
-	PTP_EXTTS_REQUEST2               = 0x80103d0b
-	PTP_MASK_CLEAR_ALL               = 0x20003d13
-	PTP_MASK_EN_SINGLE               = 0x80043d14
-	PTP_PEROUT_REQUEST               = 0x80383d03
-	PTP_PEROUT_REQUEST2              = 0x80383d0c
-	PTP_PIN_SETFUNC                  = 0x80603d07
-	PTP_PIN_SETFUNC2                 = 0x80603d10
-	PTP_SYS_OFFSET                   = 0x83403d05
-	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GET_THREAD_AREA           = 0x19
 	PTRACE_GET_THREAD_AREA_3264      = 0xc4
@@ -299,13 +277,10 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
-	SCM_DEVMEM_DMABUF                = 0x4f
-	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
-	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -340,9 +315,6 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
-	SO_DEVMEM_DMABUF                 = 0x4f
-	SO_DEVMEM_DONTNEED               = 0x50
-	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x1029
 	SO_DONTROUTE                     = 0x10
 	SO_ERROR                         = 0x1007
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
index 20d51fb9..7aa610b1 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
@@ -108,15 +108,12 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
-	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x100
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x80
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
-	IPV6_FLOWINFO_MASK               = 0xfffffff
-	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -153,14 +150,9 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
-	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
-	NS_GET_PID_FROM_PIDNS            = 0x4004b706
-	NS_GET_PID_IN_PIDNS              = 0x4004b708
-	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
-	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -237,20 +229,6 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
-	PTP_CLOCK_GETCAPS                = 0x40503d01
-	PTP_CLOCK_GETCAPS2               = 0x40503d0a
-	PTP_ENABLE_PPS                   = 0x80043d04
-	PTP_ENABLE_PPS2                  = 0x80043d0d
-	PTP_EXTTS_REQUEST                = 0x80103d02
-	PTP_EXTTS_REQUEST2               = 0x80103d0b
-	PTP_MASK_CLEAR_ALL               = 0x20003d13
-	PTP_MASK_EN_SINGLE               = 0x80043d14
-	PTP_PEROUT_REQUEST               = 0x80383d03
-	PTP_PEROUT_REQUEST2              = 0x80383d0c
-	PTP_PIN_SETFUNC                  = 0x80603d07
-	PTP_PIN_SETFUNC2                 = 0x80603d10
-	PTP_SYS_OFFSET                   = 0x83403d05
-	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GET_THREAD_AREA           = 0x19
 	PTRACE_GET_THREAD_AREA_3264      = 0xc4
@@ -299,13 +277,10 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
-	SCM_DEVMEM_DMABUF                = 0x4f
-	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
-	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -340,9 +315,6 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
-	SO_DEVMEM_DMABUF                 = 0x4f
-	SO_DEVMEM_DONTNEED               = 0x50
-	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x1029
 	SO_DONTROUTE                     = 0x10
 	SO_ERROR                         = 0x1007
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
index 321b6090..92af771b 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
@@ -108,15 +108,12 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
-	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x100
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x80
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
-	IPV6_FLOWINFO_MASK               = 0xffffff0f
-	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -153,14 +150,9 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
-	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
-	NS_GET_PID_FROM_PIDNS            = 0x4004b706
-	NS_GET_PID_IN_PIDNS              = 0x4004b708
-	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
-	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -237,20 +229,6 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
-	PTP_CLOCK_GETCAPS                = 0x40503d01
-	PTP_CLOCK_GETCAPS2               = 0x40503d0a
-	PTP_ENABLE_PPS                   = 0x80043d04
-	PTP_ENABLE_PPS2                  = 0x80043d0d
-	PTP_EXTTS_REQUEST                = 0x80103d02
-	PTP_EXTTS_REQUEST2               = 0x80103d0b
-	PTP_MASK_CLEAR_ALL               = 0x20003d13
-	PTP_MASK_EN_SINGLE               = 0x80043d14
-	PTP_PEROUT_REQUEST               = 0x80383d03
-	PTP_PEROUT_REQUEST2              = 0x80383d0c
-	PTP_PIN_SETFUNC                  = 0x80603d07
-	PTP_PIN_SETFUNC2                 = 0x80603d10
-	PTP_SYS_OFFSET                   = 0x83403d05
-	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GET_THREAD_AREA           = 0x19
 	PTRACE_GET_THREAD_AREA_3264      = 0xc4
@@ -299,13 +277,10 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
-	SCM_DEVMEM_DMABUF                = 0x4f
-	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
-	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -340,9 +315,6 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
-	SO_DEVMEM_DMABUF                 = 0x4f
-	SO_DEVMEM_DONTNEED               = 0x50
-	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x1029
 	SO_DONTROUTE                     = 0x10
 	SO_ERROR                         = 0x1007
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
index 9bacdf1e..b27ef5e6 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
@@ -108,15 +108,12 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
-	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x100
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x80
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
-	IPV6_FLOWINFO_MASK               = 0xffffff0f
-	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -153,14 +150,9 @@ const (
 	NFDBITS                          = 0x20
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
-	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
-	NS_GET_PID_FROM_PIDNS            = 0x4004b706
-	NS_GET_PID_IN_PIDNS              = 0x4004b708
-	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
-	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -237,20 +229,6 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PR_SET_PTRACER_ANY               = 0xffffffff
-	PTP_CLOCK_GETCAPS                = 0x40503d01
-	PTP_CLOCK_GETCAPS2               = 0x40503d0a
-	PTP_ENABLE_PPS                   = 0x80043d04
-	PTP_ENABLE_PPS2                  = 0x80043d0d
-	PTP_EXTTS_REQUEST                = 0x80103d02
-	PTP_EXTTS_REQUEST2               = 0x80103d0b
-	PTP_MASK_CLEAR_ALL               = 0x20003d13
-	PTP_MASK_EN_SINGLE               = 0x80043d14
-	PTP_PEROUT_REQUEST               = 0x80383d03
-	PTP_PEROUT_REQUEST2              = 0x80383d0c
-	PTP_PIN_SETFUNC                  = 0x80603d07
-	PTP_PIN_SETFUNC2                 = 0x80603d10
-	PTP_SYS_OFFSET                   = 0x83403d05
-	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GET_THREAD_AREA           = 0x19
 	PTRACE_GET_THREAD_AREA_3264      = 0xc4
@@ -299,13 +277,10 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
-	SCM_DEVMEM_DMABUF                = 0x4f
-	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
-	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -340,9 +315,6 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
-	SO_DEVMEM_DMABUF                 = 0x4f
-	SO_DEVMEM_DONTNEED               = 0x50
-	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x1029
 	SO_DONTROUTE                     = 0x10
 	SO_ERROR                         = 0x1007
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
index c2242726..237a2cef 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
@@ -108,15 +108,12 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
-	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x4000
 	ICANON                           = 0x100
 	IEXTEN                           = 0x400
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
-	IPV6_FLOWINFO_MASK               = 0xfffffff
-	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x80
 	IUCLC                            = 0x1000
 	IXOFF                            = 0x400
@@ -155,14 +152,9 @@ const (
 	NL3                              = 0x300
 	NLDLY                            = 0x300
 	NOFLSH                           = 0x80000000
-	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
-	NS_GET_PID_FROM_PIDNS            = 0x4004b706
-	NS_GET_PID_IN_PIDNS              = 0x4004b708
-	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
-	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x4
 	ONLCR                            = 0x2
@@ -240,20 +232,6 @@ const (
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PROT_SAO                         = 0x10
 	PR_SET_PTRACER_ANY               = 0xffffffff
-	PTP_CLOCK_GETCAPS                = 0x40503d01
-	PTP_CLOCK_GETCAPS2               = 0x40503d0a
-	PTP_ENABLE_PPS                   = 0x80043d04
-	PTP_ENABLE_PPS2                  = 0x80043d0d
-	PTP_EXTTS_REQUEST                = 0x80103d02
-	PTP_EXTTS_REQUEST2               = 0x80103d0b
-	PTP_MASK_CLEAR_ALL               = 0x20003d13
-	PTP_MASK_EN_SINGLE               = 0x80043d14
-	PTP_PEROUT_REQUEST               = 0x80383d03
-	PTP_PEROUT_REQUEST2              = 0x80383d0c
-	PTP_PIN_SETFUNC                  = 0x80603d07
-	PTP_PIN_SETFUNC2                 = 0x80603d10
-	PTP_SYS_OFFSET                   = 0x83403d05
-	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETEVRREGS                = 0x14
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GETREGS64                 = 0x16
@@ -354,13 +332,10 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
-	SCM_DEVMEM_DMABUF                = 0x4f
-	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
-	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -395,9 +370,6 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
-	SO_DEVMEM_DMABUF                 = 0x4f
-	SO_DEVMEM_DONTNEED               = 0x50
-	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
index 6270c8ee..4a5c555a 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
@@ -108,15 +108,12 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
-	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x4000
 	ICANON                           = 0x100
 	IEXTEN                           = 0x400
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
-	IPV6_FLOWINFO_MASK               = 0xfffffff
-	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x80
 	IUCLC                            = 0x1000
 	IXOFF                            = 0x400
@@ -155,14 +152,9 @@ const (
 	NL3                              = 0x300
 	NLDLY                            = 0x300
 	NOFLSH                           = 0x80000000
-	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
-	NS_GET_PID_FROM_PIDNS            = 0x4004b706
-	NS_GET_PID_IN_PIDNS              = 0x4004b708
-	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
-	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x4
 	ONLCR                            = 0x2
@@ -240,20 +232,6 @@ const (
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PROT_SAO                         = 0x10
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
-	PTP_CLOCK_GETCAPS                = 0x40503d01
-	PTP_CLOCK_GETCAPS2               = 0x40503d0a
-	PTP_ENABLE_PPS                   = 0x80043d04
-	PTP_ENABLE_PPS2                  = 0x80043d0d
-	PTP_EXTTS_REQUEST                = 0x80103d02
-	PTP_EXTTS_REQUEST2               = 0x80103d0b
-	PTP_MASK_CLEAR_ALL               = 0x20003d13
-	PTP_MASK_EN_SINGLE               = 0x80043d14
-	PTP_PEROUT_REQUEST               = 0x80383d03
-	PTP_PEROUT_REQUEST2              = 0x80383d0c
-	PTP_PIN_SETFUNC                  = 0x80603d07
-	PTP_PIN_SETFUNC2                 = 0x80603d10
-	PTP_SYS_OFFSET                   = 0x83403d05
-	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETEVRREGS                = 0x14
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GETREGS64                 = 0x16
@@ -358,13 +336,10 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
-	SCM_DEVMEM_DMABUF                = 0x4f
-	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
-	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -399,9 +374,6 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
-	SO_DEVMEM_DMABUF                 = 0x4f
-	SO_DEVMEM_DONTNEED               = 0x50
-	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
index 9966c194..a02fb49a 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
@@ -108,15 +108,12 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
-	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x4000
 	ICANON                           = 0x100
 	IEXTEN                           = 0x400
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
-	IPV6_FLOWINFO_MASK               = 0xffffff0f
-	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x80
 	IUCLC                            = 0x1000
 	IXOFF                            = 0x400
@@ -155,14 +152,9 @@ const (
 	NL3                              = 0x300
 	NLDLY                            = 0x300
 	NOFLSH                           = 0x80000000
-	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
-	NS_GET_PID_FROM_PIDNS            = 0x4004b706
-	NS_GET_PID_IN_PIDNS              = 0x4004b708
-	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
-	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x4
 	ONLCR                            = 0x2
@@ -240,20 +232,6 @@ const (
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PROT_SAO                         = 0x10
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
-	PTP_CLOCK_GETCAPS                = 0x40503d01
-	PTP_CLOCK_GETCAPS2               = 0x40503d0a
-	PTP_ENABLE_PPS                   = 0x80043d04
-	PTP_ENABLE_PPS2                  = 0x80043d0d
-	PTP_EXTTS_REQUEST                = 0x80103d02
-	PTP_EXTTS_REQUEST2               = 0x80103d0b
-	PTP_MASK_CLEAR_ALL               = 0x20003d13
-	PTP_MASK_EN_SINGLE               = 0x80043d14
-	PTP_PEROUT_REQUEST               = 0x80383d03
-	PTP_PEROUT_REQUEST2              = 0x80383d0c
-	PTP_PIN_SETFUNC                  = 0x80603d07
-	PTP_PIN_SETFUNC2                 = 0x80603d10
-	PTP_SYS_OFFSET                   = 0x83403d05
-	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETEVRREGS                = 0x14
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GETREGS64                 = 0x16
@@ -358,13 +336,10 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
-	SCM_DEVMEM_DMABUF                = 0x4f
-	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
-	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -399,9 +374,6 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
-	SO_DEVMEM_DMABUF                 = 0x4f
-	SO_DEVMEM_DONTNEED               = 0x50
-	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
index 848e5fcc..e26a7c61 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
@@ -108,15 +108,12 @@ const (
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
-	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
-	IPV6_FLOWINFO_MASK               = 0xffffff0f
-	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -153,14 +150,9 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
-	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
-	NS_GET_PID_FROM_PIDNS            = 0x8004b706
-	NS_GET_PID_IN_PIDNS              = 0x8004b708
-	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
-	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -237,20 +229,6 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
-	PTP_CLOCK_GETCAPS                = 0x80503d01
-	PTP_CLOCK_GETCAPS2               = 0x80503d0a
-	PTP_ENABLE_PPS                   = 0x40043d04
-	PTP_ENABLE_PPS2                  = 0x40043d0d
-	PTP_EXTTS_REQUEST                = 0x40103d02
-	PTP_EXTTS_REQUEST2               = 0x40103d0b
-	PTP_MASK_CLEAR_ALL               = 0x3d13
-	PTP_MASK_EN_SINGLE               = 0x40043d14
-	PTP_PEROUT_REQUEST               = 0x40383d03
-	PTP_PEROUT_REQUEST2              = 0x40383d0c
-	PTP_PIN_SETFUNC                  = 0x40603d07
-	PTP_PIN_SETFUNC2                 = 0x40603d10
-	PTP_SYS_OFFSET                   = 0x43403d05
-	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_GETFDPIC                  = 0x21
 	PTRACE_GETFDPIC_EXEC             = 0x0
 	PTRACE_GETFDPIC_INTERP           = 0x1
@@ -290,13 +268,10 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
-	SCM_DEVMEM_DMABUF                = 0x4f
-	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
-	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -331,9 +306,6 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
-	SO_DEVMEM_DMABUF                 = 0x4f
-	SO_DEVMEM_DONTNEED               = 0x50
-	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
index 669b2adb..c48f7c21 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
@@ -108,15 +108,12 @@ const (
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
-	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
-	IPV6_FLOWINFO_MASK               = 0xfffffff
-	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -153,14 +150,9 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
-	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
-	NS_GET_PID_FROM_PIDNS            = 0x8004b706
-	NS_GET_PID_IN_PIDNS              = 0x8004b708
-	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
-	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -237,20 +229,6 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
-	PTP_CLOCK_GETCAPS                = 0x80503d01
-	PTP_CLOCK_GETCAPS2               = 0x80503d0a
-	PTP_ENABLE_PPS                   = 0x40043d04
-	PTP_ENABLE_PPS2                  = 0x40043d0d
-	PTP_EXTTS_REQUEST                = 0x40103d02
-	PTP_EXTTS_REQUEST2               = 0x40103d0b
-	PTP_MASK_CLEAR_ALL               = 0x3d13
-	PTP_MASK_EN_SINGLE               = 0x40043d14
-	PTP_PEROUT_REQUEST               = 0x40383d03
-	PTP_PEROUT_REQUEST2              = 0x40383d0c
-	PTP_PIN_SETFUNC                  = 0x40603d07
-	PTP_PIN_SETFUNC2                 = 0x40603d10
-	PTP_SYS_OFFSET                   = 0x43403d05
-	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_DISABLE_TE                = 0x5010
 	PTRACE_ENABLE_TE                 = 0x5009
 	PTRACE_GET_LAST_BREAK            = 0x5006
@@ -362,13 +340,10 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
-	SCM_DEVMEM_DMABUF                = 0x4f
-	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
-	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -403,9 +378,6 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
-	SO_DEVMEM_DMABUF                 = 0x4f
-	SO_DEVMEM_DONTNEED               = 0x50
-	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
index 4834e575..ad4b9aac 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
@@ -112,15 +112,12 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
-	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x400000
 	IN_NONBLOCK                      = 0x4000
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
-	IPV6_FLOWINFO_MASK               = 0xfffffff
-	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -158,14 +155,9 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
-	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
-	NS_GET_PID_FROM_PIDNS            = 0x4004b706
-	NS_GET_PID_IN_PIDNS              = 0x4004b708
-	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
-	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -242,20 +234,6 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
-	PTP_CLOCK_GETCAPS                = 0x40503d01
-	PTP_CLOCK_GETCAPS2               = 0x40503d0a
-	PTP_ENABLE_PPS                   = 0x80043d04
-	PTP_ENABLE_PPS2                  = 0x80043d0d
-	PTP_EXTTS_REQUEST                = 0x80103d02
-	PTP_EXTTS_REQUEST2               = 0x80103d0b
-	PTP_MASK_CLEAR_ALL               = 0x20003d13
-	PTP_MASK_EN_SINGLE               = 0x80043d14
-	PTP_PEROUT_REQUEST               = 0x80383d03
-	PTP_PEROUT_REQUEST2              = 0x80383d0c
-	PTP_PIN_SETFUNC                  = 0x80603d07
-	PTP_PIN_SETFUNC2                 = 0x80603d10
-	PTP_SYS_OFFSET                   = 0x83403d05
-	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETFPAREGS                = 0x14
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GETFPREGS64               = 0x19
@@ -353,13 +331,10 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
-	SCM_DEVMEM_DMABUF                = 0x58
-	SCM_DEVMEM_LINEAR                = 0x57
 	SCM_TIMESTAMPING                 = 0x23
 	SCM_TIMESTAMPING_OPT_STATS       = 0x38
 	SCM_TIMESTAMPING_PKTINFO         = 0x3c
 	SCM_TIMESTAMPNS                  = 0x21
-	SCM_TS_OPT_ID                    = 0x5a
 	SCM_TXTIME                       = 0x3f
 	SCM_WIFI_STATUS                  = 0x25
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -442,9 +417,6 @@ const (
 	SO_CNX_ADVICE                    = 0x37
 	SO_COOKIE                        = 0x3b
 	SO_DETACH_REUSEPORT_BPF          = 0x47
-	SO_DEVMEM_DMABUF                 = 0x58
-	SO_DEVMEM_DONTNEED               = 0x59
-	SO_DEVMEM_LINEAR                 = 0x57
 	SO_DOMAIN                        = 0x1029
 	SO_DONTROUTE                     = 0x10
 	SO_ERROR                         = 0x1007
diff --git a/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
index 1ec2b140..da08b2ab 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go
@@ -581,8 +581,6 @@ const (
 	AT_EMPTY_PATH                   = 0x1000
 	AT_REMOVEDIR                    = 0x200
 	RENAME_NOREPLACE                = 1 << 0
-	ST_RDONLY                       = 1
-	ST_NOSUID                       = 2
 )
 
 const (
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
index 24b346e1..b622533e 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
@@ -841,26 +841,6 @@ var libc_pthread_fchdir_np_trampoline_addr uintptr
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) {
-	var _p0 unsafe.Pointer
-	if len(iov) > 0 {
-		_p0 = unsafe.Pointer(&iov[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := syscall_syscall9(libc_connectx_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(endpoints)), uintptr(associd), uintptr(flags), uintptr(_p0), uintptr(len(iov)), uintptr(unsafe.Pointer(n)), uintptr(unsafe.Pointer(connid)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-var libc_connectx_trampoline_addr uintptr
-
-//go:cgo_import_dynamic libc_connectx connectx "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
 func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
 	_, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags))
 	if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s
index ebd21310..cfe6646b 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s
+++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s
@@ -248,11 +248,6 @@ TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0
 GLOBL	·libc_pthread_fchdir_np_trampoline_addr(SB), RODATA, $8
 DATA	·libc_pthread_fchdir_np_trampoline_addr(SB)/8, $libc_pthread_fchdir_np_trampoline<>(SB)
 
-TEXT libc_connectx_trampoline<>(SB),NOSPLIT,$0-0
-	JMP	libc_connectx(SB)
-GLOBL	·libc_connectx_trampoline_addr(SB), RODATA, $8
-DATA	·libc_connectx_trampoline_addr(SB)/8, $libc_connectx_trampoline<>(SB)
-
 TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_sendfile(SB)
 GLOBL	·libc_sendfile_trampoline_addr(SB), RODATA, $8
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
index 824b9c2d..13f624f6 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
@@ -841,26 +841,6 @@ var libc_pthread_fchdir_np_trampoline_addr uintptr
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) {
-	var _p0 unsafe.Pointer
-	if len(iov) > 0 {
-		_p0 = unsafe.Pointer(&iov[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	_, _, e1 := syscall_syscall9(libc_connectx_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(endpoints)), uintptr(associd), uintptr(flags), uintptr(_p0), uintptr(len(iov)), uintptr(unsafe.Pointer(n)), uintptr(unsafe.Pointer(connid)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-var libc_connectx_trampoline_addr uintptr
-
-//go:cgo_import_dynamic libc_connectx connectx "/usr/lib/libSystem.B.dylib"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
 func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
 	_, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags))
 	if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s
index 4f178a22..fe222b75 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s
+++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s
@@ -248,11 +248,6 @@ TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0
 GLOBL	·libc_pthread_fchdir_np_trampoline_addr(SB), RODATA, $8
 DATA	·libc_pthread_fchdir_np_trampoline_addr(SB)/8, $libc_pthread_fchdir_np_trampoline<>(SB)
 
-TEXT libc_connectx_trampoline<>(SB),NOSPLIT,$0-0
-	JMP	libc_connectx(SB)
-GLOBL	·libc_connectx_trampoline_addr(SB), RODATA, $8
-DATA	·libc_connectx_trampoline_addr(SB)/8, $libc_connectx_trampoline<>(SB)
-
 TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0
 	JMP	libc_sendfile(SB)
 GLOBL	·libc_sendfile_trampoline_addr(SB), RODATA, $8
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux.go b/vendor/golang.org/x/sys/unix/zsyscall_linux.go
index 5cc1e8eb..1bc1a5ad 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_linux.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_linux.go
@@ -592,16 +592,6 @@ func ClockGettime(clockid int32, time *Timespec) (err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func ClockSettime(clockid int32, time *Timespec) (err error) {
-	_, _, e1 := Syscall(SYS_CLOCK_SETTIME, uintptr(clockid), uintptr(unsafe.Pointer(time)), 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
 func ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error) {
 	_, _, e1 := Syscall6(SYS_CLOCK_NANOSLEEP, uintptr(clockid), uintptr(flags), uintptr(unsafe.Pointer(request)), uintptr(unsafe.Pointer(remain)), 0, 0)
 	if e1 != 0 {
@@ -981,6 +971,23 @@ func Getpriority(which int, who int) (prio int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func Getrandom(buf []byte, flags int) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(buf) > 0 {
+		_p0 = unsafe.Pointer(&buf[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_GETRANDOM, uintptr(_p0), uintptr(len(buf)), uintptr(flags))
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Getrusage(who int, rusage *Rusage) (err error) {
 	_, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
 	if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
index c6545413..829b87fe 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
@@ -141,16 +141,6 @@ import (
 //go:cgo_import_dynamic libc_getpeername getpeername "libsocket.so"
 //go:cgo_import_dynamic libc_setsockopt setsockopt "libsocket.so"
 //go:cgo_import_dynamic libc_recvfrom recvfrom "libsocket.so"
-//go:cgo_import_dynamic libc_getpeerucred getpeerucred "libc.so"
-//go:cgo_import_dynamic libc_ucred_get ucred_get "libc.so"
-//go:cgo_import_dynamic libc_ucred_geteuid ucred_geteuid "libc.so"
-//go:cgo_import_dynamic libc_ucred_getegid ucred_getegid "libc.so"
-//go:cgo_import_dynamic libc_ucred_getruid ucred_getruid "libc.so"
-//go:cgo_import_dynamic libc_ucred_getrgid ucred_getrgid "libc.so"
-//go:cgo_import_dynamic libc_ucred_getsuid ucred_getsuid "libc.so"
-//go:cgo_import_dynamic libc_ucred_getsgid ucred_getsgid "libc.so"
-//go:cgo_import_dynamic libc_ucred_getpid ucred_getpid "libc.so"
-//go:cgo_import_dynamic libc_ucred_free ucred_free "libc.so"
 //go:cgo_import_dynamic libc_port_create port_create "libc.so"
 //go:cgo_import_dynamic libc_port_associate port_associate "libc.so"
 //go:cgo_import_dynamic libc_port_dissociate port_dissociate "libc.so"
@@ -290,16 +280,6 @@ import (
 //go:linkname procgetpeername libc_getpeername
 //go:linkname procsetsockopt libc_setsockopt
 //go:linkname procrecvfrom libc_recvfrom
-//go:linkname procgetpeerucred libc_getpeerucred
-//go:linkname procucred_get libc_ucred_get
-//go:linkname procucred_geteuid libc_ucred_geteuid
-//go:linkname procucred_getegid libc_ucred_getegid
-//go:linkname procucred_getruid libc_ucred_getruid
-//go:linkname procucred_getrgid libc_ucred_getrgid
-//go:linkname procucred_getsuid libc_ucred_getsuid
-//go:linkname procucred_getsgid libc_ucred_getsgid
-//go:linkname procucred_getpid libc_ucred_getpid
-//go:linkname procucred_free libc_ucred_free
 //go:linkname procport_create libc_port_create
 //go:linkname procport_associate libc_port_associate
 //go:linkname procport_dissociate libc_port_dissociate
@@ -440,16 +420,6 @@ var (
 	procgetpeername,
 	procsetsockopt,
 	procrecvfrom,
-	procgetpeerucred,
-	procucred_get,
-	procucred_geteuid,
-	procucred_getegid,
-	procucred_getruid,
-	procucred_getrgid,
-	procucred_getsuid,
-	procucred_getsgid,
-	procucred_getpid,
-	procucred_free,
 	procport_create,
 	procport_associate,
 	procport_dissociate,
@@ -2059,90 +2029,6 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func getpeerucred(fd uintptr, ucred *uintptr) (err error) {
-	_, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procgetpeerucred)), 2, uintptr(fd), uintptr(unsafe.Pointer(ucred)), 0, 0, 0, 0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func ucredGet(pid int) (ucred uintptr, err error) {
-	r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procucred_get)), 1, uintptr(pid), 0, 0, 0, 0, 0)
-	ucred = uintptr(r0)
-	if e1 != 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func ucredGeteuid(ucred uintptr) (uid int) {
-	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_geteuid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
-	uid = int(r0)
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func ucredGetegid(ucred uintptr) (gid int) {
-	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getegid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
-	gid = int(r0)
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func ucredGetruid(ucred uintptr) (uid int) {
-	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getruid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
-	uid = int(r0)
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func ucredGetrgid(ucred uintptr) (gid int) {
-	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getrgid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
-	gid = int(r0)
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func ucredGetsuid(ucred uintptr) (uid int) {
-	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getsuid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
-	uid = int(r0)
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func ucredGetsgid(ucred uintptr) (gid int) {
-	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getsgid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
-	gid = int(r0)
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func ucredGetpid(ucred uintptr) (pid int) {
-	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getpid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
-	pid = int(r0)
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func ucredFree(ucred uintptr) {
-	sysvicall6(uintptr(unsafe.Pointer(&procucred_free)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
 func port_create() (n int, err error) {
 	r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procport_create)), 0, 0, 0, 0, 0, 0, 0)
 	n = int(r0)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
index c79aaff3..524b0820 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
@@ -458,8 +458,4 @@ const (
 	SYS_LSM_SET_SELF_ATTR            = 460
 	SYS_LSM_LIST_MODULES             = 461
 	SYS_MSEAL                        = 462
-	SYS_SETXATTRAT                   = 463
-	SYS_GETXATTRAT                   = 464
-	SYS_LISTXATTRAT                  = 465
-	SYS_REMOVEXATTRAT                = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
index 5eb45069..d3e38f68 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
@@ -341,7 +341,6 @@ const (
 	SYS_STATX                   = 332
 	SYS_IO_PGETEVENTS           = 333
 	SYS_RSEQ                    = 334
-	SYS_URETPROBE               = 335
 	SYS_PIDFD_SEND_SIGNAL       = 424
 	SYS_IO_URING_SETUP          = 425
 	SYS_IO_URING_ENTER          = 426
@@ -381,8 +380,4 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
-	SYS_SETXATTRAT              = 463
-	SYS_GETXATTRAT              = 464
-	SYS_LISTXATTRAT             = 465
-	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
index 05e50297..70b35bf3 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
@@ -422,8 +422,4 @@ const (
 	SYS_LSM_SET_SELF_ATTR            = 460
 	SYS_LSM_LIST_MODULES             = 461
 	SYS_MSEAL                        = 462
-	SYS_SETXATTRAT                   = 463
-	SYS_GETXATTRAT                   = 464
-	SYS_LISTXATTRAT                  = 465
-	SYS_REMOVEXATTRAT                = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
index 38c53ec5..6c778c23 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
@@ -85,7 +85,7 @@ const (
 	SYS_SPLICE                  = 76
 	SYS_TEE                     = 77
 	SYS_READLINKAT              = 78
-	SYS_NEWFSTATAT              = 79
+	SYS_FSTATAT                 = 79
 	SYS_FSTAT                   = 80
 	SYS_SYNC                    = 81
 	SYS_FSYNC                   = 82
@@ -325,8 +325,4 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
-	SYS_SETXATTRAT              = 463
-	SYS_GETXATTRAT              = 464
-	SYS_LISTXATTRAT             = 465
-	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go
index 31d2e71a..37281cf5 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go
@@ -84,8 +84,6 @@ const (
 	SYS_SPLICE                  = 76
 	SYS_TEE                     = 77
 	SYS_READLINKAT              = 78
-	SYS_NEWFSTATAT              = 79
-	SYS_FSTAT                   = 80
 	SYS_SYNC                    = 81
 	SYS_FSYNC                   = 82
 	SYS_FDATASYNC               = 83
@@ -321,8 +319,4 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
-	SYS_SETXATTRAT              = 463
-	SYS_GETXATTRAT              = 464
-	SYS_LISTXATTRAT             = 465
-	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
index f4184a33..7e567f1e 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
@@ -442,8 +442,4 @@ const (
 	SYS_LSM_SET_SELF_ATTR            = 4460
 	SYS_LSM_LIST_MODULES             = 4461
 	SYS_MSEAL                        = 4462
-	SYS_SETXATTRAT                   = 4463
-	SYS_GETXATTRAT                   = 4464
-	SYS_LISTXATTRAT                  = 4465
-	SYS_REMOVEXATTRAT                = 4466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
index 05b99622..38ae55e5 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
@@ -372,8 +372,4 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 5460
 	SYS_LSM_LIST_MODULES        = 5461
 	SYS_MSEAL                   = 5462
-	SYS_SETXATTRAT              = 5463
-	SYS_GETXATTRAT              = 5464
-	SYS_LISTXATTRAT             = 5465
-	SYS_REMOVEXATTRAT           = 5466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
index 43a256e9..55e92e60 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
@@ -372,8 +372,4 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 5460
 	SYS_LSM_LIST_MODULES        = 5461
 	SYS_MSEAL                   = 5462
-	SYS_SETXATTRAT              = 5463
-	SYS_GETXATTRAT              = 5464
-	SYS_LISTXATTRAT             = 5465
-	SYS_REMOVEXATTRAT           = 5466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
index eea5ddfc..60658d6a 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
@@ -442,8 +442,4 @@ const (
 	SYS_LSM_SET_SELF_ATTR            = 4460
 	SYS_LSM_LIST_MODULES             = 4461
 	SYS_MSEAL                        = 4462
-	SYS_SETXATTRAT                   = 4463
-	SYS_GETXATTRAT                   = 4464
-	SYS_LISTXATTRAT                  = 4465
-	SYS_REMOVEXATTRAT                = 4466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
index 0d777bfb..e203e8a7 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
@@ -449,8 +449,4 @@ const (
 	SYS_LSM_SET_SELF_ATTR            = 460
 	SYS_LSM_LIST_MODULES             = 461
 	SYS_MSEAL                        = 462
-	SYS_SETXATTRAT                   = 463
-	SYS_GETXATTRAT                   = 464
-	SYS_LISTXATTRAT                  = 465
-	SYS_REMOVEXATTRAT                = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
index b4463650..5944b97d 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
@@ -421,8 +421,4 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
-	SYS_SETXATTRAT              = 463
-	SYS_GETXATTRAT              = 464
-	SYS_LISTXATTRAT             = 465
-	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
index 0c7d21c1..c66d416d 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
@@ -421,8 +421,4 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
-	SYS_SETXATTRAT              = 463
-	SYS_GETXATTRAT              = 464
-	SYS_LISTXATTRAT             = 465
-	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
index 84053916..9889f6a5 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
@@ -84,7 +84,7 @@ const (
 	SYS_SPLICE                  = 76
 	SYS_TEE                     = 77
 	SYS_READLINKAT              = 78
-	SYS_NEWFSTATAT              = 79
+	SYS_FSTATAT                 = 79
 	SYS_FSTAT                   = 80
 	SYS_SYNC                    = 81
 	SYS_FSYNC                   = 82
@@ -326,8 +326,4 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
-	SYS_SETXATTRAT              = 463
-	SYS_GETXATTRAT              = 464
-	SYS_LISTXATTRAT             = 465
-	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
index fcf1b790..01d86825 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
@@ -387,8 +387,4 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
-	SYS_SETXATTRAT              = 463
-	SYS_GETXATTRAT              = 464
-	SYS_LISTXATTRAT             = 465
-	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
index 52d15b5f..7b703e77 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
@@ -400,8 +400,4 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
-	SYS_SETXATTRAT              = 463
-	SYS_GETXATTRAT              = 464
-	SYS_LISTXATTRAT             = 465
-	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
index 17c53bd9..091d107f 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go
@@ -306,19 +306,6 @@ type XVSockPgen struct {
 
 type _Socklen uint32
 
-type SaeAssocID uint32
-
-type SaeConnID uint32
-
-type SaEndpoints struct {
-	Srcif      uint32
-	Srcaddr    *RawSockaddr
-	Srcaddrlen uint32
-	Dstaddr    *RawSockaddr
-	Dstaddrlen uint32
-	_          [4]byte
-}
-
 type Xucred struct {
 	Version uint32
 	Uid     uint32
@@ -462,14 +449,11 @@ type FdSet struct {
 
 const (
 	SizeofIfMsghdr    = 0x70
-	SizeofIfMsghdr2   = 0xa0
 	SizeofIfData      = 0x60
-	SizeofIfData64    = 0x80
 	SizeofIfaMsghdr   = 0x14
 	SizeofIfmaMsghdr  = 0x10
 	SizeofIfmaMsghdr2 = 0x14
 	SizeofRtMsghdr    = 0x5c
-	SizeofRtMsghdr2   = 0x5c
 	SizeofRtMetrics   = 0x38
 )
 
@@ -483,20 +467,6 @@ type IfMsghdr struct {
 	Data    IfData
 }
 
-type IfMsghdr2 struct {
-	Msglen     uint16
-	Version    uint8
-	Type       uint8
-	Addrs      int32
-	Flags      int32
-	Index      uint16
-	Snd_len    int32
-	Snd_maxlen int32
-	Snd_drops  int32
-	Timer      int32
-	Data       IfData64
-}
-
 type IfData struct {
 	Type       uint8
 	Typelen    uint8
@@ -529,34 +499,6 @@ type IfData struct {
 	Reserved2  uint32
 }
 
-type IfData64 struct {
-	Type       uint8
-	Typelen    uint8
-	Physical   uint8
-	Addrlen    uint8
-	Hdrlen     uint8
-	Recvquota  uint8
-	Xmitquota  uint8
-	Unused1    uint8
-	Mtu        uint32
-	Metric     uint32
-	Baudrate   uint64
-	Ipackets   uint64
-	Ierrors    uint64
-	Opackets   uint64
-	Oerrors    uint64
-	Collisions uint64
-	Ibytes     uint64
-	Obytes     uint64
-	Imcasts    uint64
-	Omcasts    uint64
-	Iqdrops    uint64
-	Noproto    uint64
-	Recvtiming uint32
-	Xmittiming uint32
-	Lastchange Timeval32
-}
-
 type IfaMsghdr struct {
 	Msglen  uint16
 	Version uint8
@@ -602,21 +544,6 @@ type RtMsghdr struct {
 	Rmx     RtMetrics
 }
 
-type RtMsghdr2 struct {
-	Msglen      uint16
-	Version     uint8
-	Type        uint8
-	Index       uint16
-	Flags       int32
-	Addrs       int32
-	Refcnt      int32
-	Parentflags int32
-	Reserved    int32
-	Use         int32
-	Inits       uint32
-	Rmx         RtMetrics
-}
-
 type RtMetrics struct {
 	Locks    uint32
 	Mtu      uint32
diff --git a/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
index 2392226a..28ff4ef7 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go
@@ -306,19 +306,6 @@ type XVSockPgen struct {
 
 type _Socklen uint32
 
-type SaeAssocID uint32
-
-type SaeConnID uint32
-
-type SaEndpoints struct {
-	Srcif      uint32
-	Srcaddr    *RawSockaddr
-	Srcaddrlen uint32
-	Dstaddr    *RawSockaddr
-	Dstaddrlen uint32
-	_          [4]byte
-}
-
 type Xucred struct {
 	Version uint32
 	Uid     uint32
@@ -462,14 +449,11 @@ type FdSet struct {
 
 const (
 	SizeofIfMsghdr    = 0x70
-	SizeofIfMsghdr2   = 0xa0
 	SizeofIfData      = 0x60
-	SizeofIfData64    = 0x80
 	SizeofIfaMsghdr   = 0x14
 	SizeofIfmaMsghdr  = 0x10
 	SizeofIfmaMsghdr2 = 0x14
 	SizeofRtMsghdr    = 0x5c
-	SizeofRtMsghdr2   = 0x5c
 	SizeofRtMetrics   = 0x38
 )
 
@@ -483,20 +467,6 @@ type IfMsghdr struct {
 	Data    IfData
 }
 
-type IfMsghdr2 struct {
-	Msglen     uint16
-	Version    uint8
-	Type       uint8
-	Addrs      int32
-	Flags      int32
-	Index      uint16
-	Snd_len    int32
-	Snd_maxlen int32
-	Snd_drops  int32
-	Timer      int32
-	Data       IfData64
-}
-
 type IfData struct {
 	Type       uint8
 	Typelen    uint8
@@ -529,34 +499,6 @@ type IfData struct {
 	Reserved2  uint32
 }
 
-type IfData64 struct {
-	Type       uint8
-	Typelen    uint8
-	Physical   uint8
-	Addrlen    uint8
-	Hdrlen     uint8
-	Recvquota  uint8
-	Xmitquota  uint8
-	Unused1    uint8
-	Mtu        uint32
-	Metric     uint32
-	Baudrate   uint64
-	Ipackets   uint64
-	Ierrors    uint64
-	Opackets   uint64
-	Oerrors    uint64
-	Collisions uint64
-	Ibytes     uint64
-	Obytes     uint64
-	Imcasts    uint64
-	Omcasts    uint64
-	Iqdrops    uint64
-	Noproto    uint64
-	Recvtiming uint32
-	Xmittiming uint32
-	Lastchange Timeval32
-}
-
 type IfaMsghdr struct {
 	Msglen  uint16
 	Version uint8
@@ -602,21 +544,6 @@ type RtMsghdr struct {
 	Rmx     RtMetrics
 }
 
-type RtMsghdr2 struct {
-	Msglen      uint16
-	Version     uint8
-	Type        uint8
-	Index       uint16
-	Flags       int32
-	Addrs       int32
-	Refcnt      int32
-	Parentflags int32
-	Reserved    int32
-	Use         int32
-	Inits       uint32
-	Rmx         RtMetrics
-}
-
 type RtMetrics struct {
 	Locks    uint32
 	Mtu      uint32
diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
index 51e13eb0..6cbd094a 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go
@@ -625,7 +625,6 @@ const (
 	POLLRDNORM   = 0x40
 	POLLWRBAND   = 0x100
 	POLLWRNORM   = 0x4
-	POLLRDHUP    = 0x4000
 )
 
 type CapRights struct {
diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
index d002d8ef..7c03b6ee 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go
@@ -630,7 +630,6 @@ const (
 	POLLRDNORM   = 0x40
 	POLLWRBAND   = 0x100
 	POLLWRNORM   = 0x4
-	POLLRDHUP    = 0x4000
 )
 
 type CapRights struct {
diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
index 3f863d89..422107ee 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go
@@ -616,7 +616,6 @@ const (
 	POLLRDNORM   = 0x40
 	POLLWRBAND   = 0x100
 	POLLWRNORM   = 0x4
-	POLLRDHUP    = 0x4000
 )
 
 type CapRights struct {
diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
index 61c72931..505a12ac 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go
@@ -610,7 +610,6 @@ const (
 	POLLRDNORM   = 0x40
 	POLLWRBAND   = 0x100
 	POLLWRNORM   = 0x4
-	POLLRDHUP    = 0x4000
 )
 
 type CapRights struct {
diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go
index b5d17414..cc986c79 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go
@@ -612,7 +612,6 @@ const (
 	POLLRDNORM   = 0x40
 	POLLWRBAND   = 0x100
 	POLLWRNORM   = 0x4
-	POLLRDHUP    = 0x4000
 )
 
 type CapRights struct {
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux.go b/vendor/golang.org/x/sys/unix/ztypes_linux.go
index a46abe64..b102b95a 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux.go
@@ -87,35 +87,31 @@ type StatxTimestamp struct {
 }
 
 type Statx_t struct {
-	Mask                      uint32
-	Blksize                   uint32
-	Attributes                uint64
-	Nlink                     uint32
-	Uid                       uint32
-	Gid                       uint32
-	Mode                      uint16
-	_                         [1]uint16
-	Ino                       uint64
-	Size                      uint64
-	Blocks                    uint64
-	Attributes_mask           uint64
-	Atime                     StatxTimestamp
-	Btime                     StatxTimestamp
-	Ctime                     StatxTimestamp
-	Mtime                     StatxTimestamp
-	Rdev_major                uint32
-	Rdev_minor                uint32
-	Dev_major                 uint32
-	Dev_minor                 uint32
-	Mnt_id                    uint64
-	Dio_mem_align             uint32
-	Dio_offset_align          uint32
-	Subvol                    uint64
-	Atomic_write_unit_min     uint32
-	Atomic_write_unit_max     uint32
-	Atomic_write_segments_max uint32
-	_                         [1]uint32
-	_                         [9]uint64
+	Mask             uint32
+	Blksize          uint32
+	Attributes       uint64
+	Nlink            uint32
+	Uid              uint32
+	Gid              uint32
+	Mode             uint16
+	_                [1]uint16
+	Ino              uint64
+	Size             uint64
+	Blocks           uint64
+	Attributes_mask  uint64
+	Atime            StatxTimestamp
+	Btime            StatxTimestamp
+	Ctime            StatxTimestamp
+	Mtime            StatxTimestamp
+	Rdev_major       uint32
+	Rdev_minor       uint32
+	Dev_major        uint32
+	Dev_minor        uint32
+	Mnt_id           uint64
+	Dio_mem_align    uint32
+	Dio_offset_align uint32
+	Subvol           uint64
+	_                [11]uint64
 }
 
 type Fsid struct {
@@ -520,29 +516,6 @@ type TCPInfo struct {
 	Total_rto_time       uint32
 }
 
-type TCPVegasInfo struct {
-	Enabled uint32
-	Rttcnt  uint32
-	Rtt     uint32
-	Minrtt  uint32
-}
-
-type TCPDCTCPInfo struct {
-	Enabled  uint16
-	Ce_state uint16
-	Alpha    uint32
-	Ab_ecn   uint32
-	Ab_tot   uint32
-}
-
-type TCPBBRInfo struct {
-	Bw_lo       uint32
-	Bw_hi       uint32
-	Min_rtt     uint32
-	Pacing_gain uint32
-	Cwnd_gain   uint32
-}
-
 type CanFilter struct {
 	Id   uint32
 	Mask uint32
@@ -584,7 +557,6 @@ const (
 	SizeofICMPv6Filter      = 0x20
 	SizeofUcred             = 0xc
 	SizeofTCPInfo           = 0xf8
-	SizeofTCPCCInfo         = 0x14
 	SizeofCanFilter         = 0x8
 	SizeofTCPRepairOpt      = 0x8
 )
@@ -1752,6 +1724,12 @@ const (
 	IFLA_IPVLAN_UNSPEC                         = 0x0
 	IFLA_IPVLAN_MODE                           = 0x1
 	IFLA_IPVLAN_FLAGS                          = 0x2
+	NETKIT_NEXT                                = -0x1
+	NETKIT_PASS                                = 0x0
+	NETKIT_DROP                                = 0x2
+	NETKIT_REDIRECT                            = 0x7
+	NETKIT_L2                                  = 0x0
+	NETKIT_L3                                  = 0x1
 	IFLA_NETKIT_UNSPEC                         = 0x0
 	IFLA_NETKIT_PEER_INFO                      = 0x1
 	IFLA_NETKIT_PRIMARY                        = 0x2
@@ -1790,7 +1768,6 @@ const (
 	IFLA_VXLAN_DF                              = 0x1d
 	IFLA_VXLAN_VNIFILTER                       = 0x1e
 	IFLA_VXLAN_LOCALBYPASS                     = 0x1f
-	IFLA_VXLAN_LABEL_POLICY                    = 0x20
 	IFLA_GENEVE_UNSPEC                         = 0x0
 	IFLA_GENEVE_ID                             = 0x1
 	IFLA_GENEVE_REMOTE                         = 0x2
@@ -1820,8 +1797,6 @@ const (
 	IFLA_GTP_ROLE                              = 0x4
 	IFLA_GTP_CREATE_SOCKETS                    = 0x5
 	IFLA_GTP_RESTART_COUNT                     = 0x6
-	IFLA_GTP_LOCAL                             = 0x7
-	IFLA_GTP_LOCAL6                            = 0x8
 	IFLA_BOND_UNSPEC                           = 0x0
 	IFLA_BOND_MODE                             = 0x1
 	IFLA_BOND_ACTIVE_SLAVE                     = 0x2
@@ -1854,7 +1829,6 @@ const (
 	IFLA_BOND_AD_LACP_ACTIVE                   = 0x1d
 	IFLA_BOND_MISSED_MAX                       = 0x1e
 	IFLA_BOND_NS_IP6_TARGET                    = 0x1f
-	IFLA_BOND_COUPLED_CONTROL                  = 0x20
 	IFLA_BOND_AD_INFO_UNSPEC                   = 0x0
 	IFLA_BOND_AD_INFO_AGGREGATOR               = 0x1
 	IFLA_BOND_AD_INFO_NUM_PORTS                = 0x2
@@ -1923,7 +1897,6 @@ const (
 	IFLA_HSR_SEQ_NR                            = 0x5
 	IFLA_HSR_VERSION                           = 0x6
 	IFLA_HSR_PROTOCOL                          = 0x7
-	IFLA_HSR_INTERLINK                         = 0x8
 	IFLA_STATS_UNSPEC                          = 0x0
 	IFLA_STATS_LINK_64                         = 0x1
 	IFLA_STATS_LINK_XSTATS                     = 0x2
@@ -1976,15 +1949,6 @@ const (
 	IFLA_DSA_MASTER                            = 0x1
 )
 
-const (
-	NETKIT_NEXT     = -0x1
-	NETKIT_PASS     = 0x0
-	NETKIT_DROP     = 0x2
-	NETKIT_REDIRECT = 0x7
-	NETKIT_L2       = 0x0
-	NETKIT_L3       = 0x1
-)
-
 const (
 	NF_INET_PRE_ROUTING  = 0x0
 	NF_INET_LOCAL_IN     = 0x1
@@ -2522,7 +2486,7 @@ type XDPMmapOffsets struct {
 type XDPUmemReg struct {
 	Addr            uint64
 	Len             uint64
-	Size            uint32
+	Chunk_size      uint32
 	Headroom        uint32
 	Flags           uint32
 	Tx_metadata_len uint32
@@ -2594,8 +2558,8 @@ const (
 	SOF_TIMESTAMPING_BIND_PHC     = 0x8000
 	SOF_TIMESTAMPING_OPT_ID_TCP   = 0x10000
 
-	SOF_TIMESTAMPING_LAST = 0x20000
-	SOF_TIMESTAMPING_MASK = 0x3ffff
+	SOF_TIMESTAMPING_LAST = 0x10000
+	SOF_TIMESTAMPING_MASK = 0x1ffff
 
 	SCM_TSTAMP_SND   = 0x0
 	SCM_TSTAMP_SCHED = 0x1
@@ -3541,7 +3505,7 @@ type Nhmsg struct {
 type NexthopGrp struct {
 	Id     uint32
 	Weight uint8
-	High   uint8
+	Resvd1 uint8
 	Resvd2 uint16
 }
 
@@ -3802,7 +3766,7 @@ const (
 	ETHTOOL_MSG_PSE_GET                       = 0x24
 	ETHTOOL_MSG_PSE_SET                       = 0x25
 	ETHTOOL_MSG_RSS_GET                       = 0x26
-	ETHTOOL_MSG_USER_MAX                      = 0x2d
+	ETHTOOL_MSG_USER_MAX                      = 0x2b
 	ETHTOOL_MSG_KERNEL_NONE                   = 0x0
 	ETHTOOL_MSG_STRSET_GET_REPLY              = 0x1
 	ETHTOOL_MSG_LINKINFO_GET_REPLY            = 0x2
@@ -3842,15 +3806,12 @@ const (
 	ETHTOOL_MSG_MODULE_NTF                    = 0x24
 	ETHTOOL_MSG_PSE_GET_REPLY                 = 0x25
 	ETHTOOL_MSG_RSS_GET_REPLY                 = 0x26
-	ETHTOOL_MSG_KERNEL_MAX                    = 0x2e
-	ETHTOOL_FLAG_COMPACT_BITSETS              = 0x1
-	ETHTOOL_FLAG_OMIT_REPLY                   = 0x2
-	ETHTOOL_FLAG_STATS                        = 0x4
+	ETHTOOL_MSG_KERNEL_MAX                    = 0x2b
 	ETHTOOL_A_HEADER_UNSPEC                   = 0x0
 	ETHTOOL_A_HEADER_DEV_INDEX                = 0x1
 	ETHTOOL_A_HEADER_DEV_NAME                 = 0x2
 	ETHTOOL_A_HEADER_FLAGS                    = 0x3
-	ETHTOOL_A_HEADER_MAX                      = 0x4
+	ETHTOOL_A_HEADER_MAX                      = 0x3
 	ETHTOOL_A_BITSET_BIT_UNSPEC               = 0x0
 	ETHTOOL_A_BITSET_BIT_INDEX                = 0x1
 	ETHTOOL_A_BITSET_BIT_NAME                 = 0x2
@@ -3987,7 +3948,7 @@ const (
 	ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL   = 0x17
 	ETHTOOL_A_COALESCE_USE_CQE_MODE_TX        = 0x18
 	ETHTOOL_A_COALESCE_USE_CQE_MODE_RX        = 0x19
-	ETHTOOL_A_COALESCE_MAX                    = 0x1e
+	ETHTOOL_A_COALESCE_MAX                    = 0x1c
 	ETHTOOL_A_PAUSE_UNSPEC                    = 0x0
 	ETHTOOL_A_PAUSE_HEADER                    = 0x1
 	ETHTOOL_A_PAUSE_AUTONEG                   = 0x2
@@ -4031,11 +3992,11 @@ const (
 	ETHTOOL_A_CABLE_RESULT_UNSPEC             = 0x0
 	ETHTOOL_A_CABLE_RESULT_PAIR               = 0x1
 	ETHTOOL_A_CABLE_RESULT_CODE               = 0x2
-	ETHTOOL_A_CABLE_RESULT_MAX                = 0x3
+	ETHTOOL_A_CABLE_RESULT_MAX                = 0x2
 	ETHTOOL_A_CABLE_FAULT_LENGTH_UNSPEC       = 0x0
 	ETHTOOL_A_CABLE_FAULT_LENGTH_PAIR         = 0x1
 	ETHTOOL_A_CABLE_FAULT_LENGTH_CM           = 0x2
-	ETHTOOL_A_CABLE_FAULT_LENGTH_MAX          = 0x3
+	ETHTOOL_A_CABLE_FAULT_LENGTH_MAX          = 0x2
 	ETHTOOL_A_CABLE_TEST_NTF_STATUS_UNSPEC    = 0x0
 	ETHTOOL_A_CABLE_TEST_NTF_STATUS_STARTED   = 0x1
 	ETHTOOL_A_CABLE_TEST_NTF_STATUS_COMPLETED = 0x2
@@ -4118,107 +4079,6 @@ type EthtoolDrvinfo struct {
 	Regdump_len  uint32
 }
 
-type EthtoolTsInfo struct {
-	Cmd             uint32
-	So_timestamping uint32
-	Phc_index       int32
-	Tx_types        uint32
-	Tx_reserved     [3]uint32
-	Rx_filters      uint32
-	Rx_reserved     [3]uint32
-}
-
-type HwTstampConfig struct {
-	Flags     int32
-	Tx_type   int32
-	Rx_filter int32
-}
-
-const (
-	HWTSTAMP_FILTER_NONE            = 0x0
-	HWTSTAMP_FILTER_ALL             = 0x1
-	HWTSTAMP_FILTER_SOME            = 0x2
-	HWTSTAMP_FILTER_PTP_V1_L4_EVENT = 0x3
-	HWTSTAMP_FILTER_PTP_V2_L4_EVENT = 0x6
-	HWTSTAMP_FILTER_PTP_V2_L2_EVENT = 0x9
-	HWTSTAMP_FILTER_PTP_V2_EVENT    = 0xc
-)
-
-const (
-	HWTSTAMP_TX_OFF          = 0x0
-	HWTSTAMP_TX_ON           = 0x1
-	HWTSTAMP_TX_ONESTEP_SYNC = 0x2
-)
-
-type (
-	PtpClockCaps struct {
-		Max_adj            int32
-		N_alarm            int32
-		N_ext_ts           int32
-		N_per_out          int32
-		Pps                int32
-		N_pins             int32
-		Cross_timestamping int32
-		Adjust_phase       int32
-		Max_phase_adj      int32
-		Rsv                [11]int32
-	}
-	PtpClockTime struct {
-		Sec      int64
-		Nsec     uint32
-		Reserved uint32
-	}
-	PtpExttsEvent struct {
-		T     PtpClockTime
-		Index uint32
-		Flags uint32
-		Rsv   [2]uint32
-	}
-	PtpExttsRequest struct {
-		Index uint32
-		Flags uint32
-		Rsv   [2]uint32
-	}
-	PtpPeroutRequest struct {
-		StartOrPhase PtpClockTime
-		Period       PtpClockTime
-		Index        uint32
-		Flags        uint32
-		On           PtpClockTime
-	}
-	PtpPinDesc struct {
-		Name  [64]byte
-		Index uint32
-		Func  uint32
-		Chan  uint32
-		Rsv   [5]uint32
-	}
-	PtpSysOffset struct {
-		Samples uint32
-		Rsv     [3]uint32
-		Ts      [51]PtpClockTime
-	}
-	PtpSysOffsetExtended struct {
-		Samples uint32
-		Clockid int32
-		Rsv     [2]uint32
-		Ts      [25][3]PtpClockTime
-	}
-	PtpSysOffsetPrecise struct {
-		Device   PtpClockTime
-		Realtime PtpClockTime
-		Monoraw  PtpClockTime
-		Rsv      [4]uint32
-	}
-)
-
-const (
-	PTP_PF_NONE    = 0x0
-	PTP_PF_EXTTS   = 0x1
-	PTP_PF_PEROUT  = 0x2
-	PTP_PF_PHYSYNC = 0x3
-)
-
 type (
 	HIDRawReportDescriptor struct {
 		Size  uint32
@@ -4400,7 +4260,6 @@ const (
 type LandlockRulesetAttr struct {
 	Access_fs  uint64
 	Access_net uint64
-	Scoped     uint64
 }
 
 type LandlockPathBeneathAttr struct {
@@ -4747,7 +4606,7 @@ const (
 	NL80211_ATTR_MAC_HINT                                   = 0xc8
 	NL80211_ATTR_MAC_MASK                                   = 0xd7
 	NL80211_ATTR_MAX_AP_ASSOC_STA                           = 0xca
-	NL80211_ATTR_MAX                                        = 0x14d
+	NL80211_ATTR_MAX                                        = 0x14a
 	NL80211_ATTR_MAX_CRIT_PROT_DURATION                     = 0xb4
 	NL80211_ATTR_MAX_CSA_COUNTERS                           = 0xce
 	NL80211_ATTR_MAX_MATCH_SETS                             = 0x85
@@ -5351,7 +5210,7 @@ const (
 	NL80211_FREQUENCY_ATTR_GO_CONCURRENT                    = 0xf
 	NL80211_FREQUENCY_ATTR_INDOOR_ONLY                      = 0xe
 	NL80211_FREQUENCY_ATTR_IR_CONCURRENT                    = 0xf
-	NL80211_FREQUENCY_ATTR_MAX                              = 0x21
+	NL80211_FREQUENCY_ATTR_MAX                              = 0x20
 	NL80211_FREQUENCY_ATTR_MAX_TX_POWER                     = 0x6
 	NL80211_FREQUENCY_ATTR_NO_10MHZ                         = 0x11
 	NL80211_FREQUENCY_ATTR_NO_160MHZ                        = 0xc
@@ -5519,7 +5378,7 @@ const (
 	NL80211_MNTR_FLAG_CONTROL                               = 0x3
 	NL80211_MNTR_FLAG_COOK_FRAMES                           = 0x5
 	NL80211_MNTR_FLAG_FCSFAIL                               = 0x1
-	NL80211_MNTR_FLAG_MAX                                   = 0x7
+	NL80211_MNTR_FLAG_MAX                                   = 0x6
 	NL80211_MNTR_FLAG_OTHER_BSS                             = 0x4
 	NL80211_MNTR_FLAG_PLCPFAIL                              = 0x2
 	NL80211_MPATH_FLAG_ACTIVE                               = 0x1
@@ -6174,5 +6033,3 @@ type SockDiagReq struct {
 	Family   uint8
 	Protocol uint8
 }
-
-const RTM_NEWNVLAN = 0x70
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
index ad05b51a..15adc041 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
@@ -727,37 +727,6 @@ const (
 	RISCV_HWPROBE_EXT_ZBA                = 0x8
 	RISCV_HWPROBE_EXT_ZBB                = 0x10
 	RISCV_HWPROBE_EXT_ZBS                = 0x20
-	RISCV_HWPROBE_EXT_ZICBOZ             = 0x40
-	RISCV_HWPROBE_EXT_ZBC                = 0x80
-	RISCV_HWPROBE_EXT_ZBKB               = 0x100
-	RISCV_HWPROBE_EXT_ZBKC               = 0x200
-	RISCV_HWPROBE_EXT_ZBKX               = 0x400
-	RISCV_HWPROBE_EXT_ZKND               = 0x800
-	RISCV_HWPROBE_EXT_ZKNE               = 0x1000
-	RISCV_HWPROBE_EXT_ZKNH               = 0x2000
-	RISCV_HWPROBE_EXT_ZKSED              = 0x4000
-	RISCV_HWPROBE_EXT_ZKSH               = 0x8000
-	RISCV_HWPROBE_EXT_ZKT                = 0x10000
-	RISCV_HWPROBE_EXT_ZVBB               = 0x20000
-	RISCV_HWPROBE_EXT_ZVBC               = 0x40000
-	RISCV_HWPROBE_EXT_ZVKB               = 0x80000
-	RISCV_HWPROBE_EXT_ZVKG               = 0x100000
-	RISCV_HWPROBE_EXT_ZVKNED             = 0x200000
-	RISCV_HWPROBE_EXT_ZVKNHA             = 0x400000
-	RISCV_HWPROBE_EXT_ZVKNHB             = 0x800000
-	RISCV_HWPROBE_EXT_ZVKSED             = 0x1000000
-	RISCV_HWPROBE_EXT_ZVKSH              = 0x2000000
-	RISCV_HWPROBE_EXT_ZVKT               = 0x4000000
-	RISCV_HWPROBE_EXT_ZFH                = 0x8000000
-	RISCV_HWPROBE_EXT_ZFHMIN             = 0x10000000
-	RISCV_HWPROBE_EXT_ZIHINTNTL          = 0x20000000
-	RISCV_HWPROBE_EXT_ZVFH               = 0x40000000
-	RISCV_HWPROBE_EXT_ZVFHMIN            = 0x80000000
-	RISCV_HWPROBE_EXT_ZFA                = 0x100000000
-	RISCV_HWPROBE_EXT_ZTSO               = 0x200000000
-	RISCV_HWPROBE_EXT_ZACAS              = 0x400000000
-	RISCV_HWPROBE_EXT_ZICOND             = 0x800000000
-	RISCV_HWPROBE_EXT_ZIHINTPAUSE        = 0x1000000000
 	RISCV_HWPROBE_KEY_CPUPERF_0          = 0x5
 	RISCV_HWPROBE_MISALIGNED_UNKNOWN     = 0x0
 	RISCV_HWPROBE_MISALIGNED_EMULATED    = 0x1
@@ -765,6 +734,4 @@ const (
 	RISCV_HWPROBE_MISALIGNED_FAST        = 0x3
 	RISCV_HWPROBE_MISALIGNED_UNSUPPORTED = 0x4
 	RISCV_HWPROBE_MISALIGNED_MASK        = 0x7
-	RISCV_HWPROBE_KEY_ZICBOZ_BLOCK_SIZE  = 0x6
-	RISCV_HWPROBE_WHICH_CPUS             = 0x1
 )
diff --git a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
index 2e5d5a44..d9a13af4 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
@@ -377,12 +377,6 @@ type Flock_t struct {
 	Pid    int32
 }
 
-type F_cnvrt struct {
-	Cvtcmd int32
-	Pccsid int16
-	Fccsid int16
-}
-
 type Termios struct {
 	Cflag uint32
 	Iflag uint32
diff --git a/vendor/modules.txt b/vendor/modules.txt
index b5929859..ec17340e 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -47,7 +47,7 @@ github.com/goccy/go-json/internal/encoder/vm_color_indent
 github.com/goccy/go-json/internal/encoder/vm_indent
 github.com/goccy/go-json/internal/errors
 github.com/goccy/go-json/internal/runtime
-# github.com/golang/snappy v1.0.0
+# github.com/golang/snappy v0.0.4
 ## explicit
 github.com/golang/snappy
 # github.com/google/uuid v1.3.0
@@ -62,12 +62,11 @@ github.com/huandu/go-clone/generic
 # github.com/json-iterator/go v1.1.12
 ## explicit; go 1.12
 github.com/json-iterator/go
-# github.com/klauspost/compress v1.16.7
-## explicit; go 1.18
+# github.com/klauspost/compress v1.13.6
+## explicit; go 1.15
 github.com/klauspost/compress
 github.com/klauspost/compress/fse
 github.com/klauspost/compress/huff0
-github.com/klauspost/compress/internal/cpuinfo
 github.com/klauspost/compress/internal/snapref
 github.com/klauspost/compress/zstd
 github.com/klauspost/compress/zstd/internal/xxhash
@@ -202,13 +201,7 @@ go.mongodb.org/mongo-driver/x/mongo/driver/operation
 go.mongodb.org/mongo-driver/x/mongo/driver/session
 go.mongodb.org/mongo-driver/x/mongo/driver/topology
 go.mongodb.org/mongo-driver/x/mongo/driver/wiremessage
-# go.mongodb.org/mongo-driver/v2 v2.2.3
-## explicit; go 1.18
-go.mongodb.org/mongo-driver/v2/bson
-go.mongodb.org/mongo-driver/v2/internal/bsoncoreutil
-go.mongodb.org/mongo-driver/v2/internal/decimal128
-go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore
-# golang.org/x/crypto v0.33.0
+# golang.org/x/crypto v0.26.0
 ## explicit; go 1.20
 golang.org/x/crypto/ocsp
 golang.org/x/crypto/pbkdf2
@@ -226,16 +219,16 @@ golang.org/x/net/http2
 golang.org/x/net/http2/h2c
 golang.org/x/net/http2/hpack
 golang.org/x/net/idna
-# golang.org/x/sync v0.11.0
+# golang.org/x/sync v0.8.0
 ## explicit; go 1.18
 golang.org/x/sync/errgroup
 golang.org/x/sync/semaphore
 golang.org/x/sync/singleflight
-# golang.org/x/sys v0.30.0
+# golang.org/x/sys v0.23.0
 ## explicit; go 1.18
 golang.org/x/sys/cpu
 golang.org/x/sys/unix
-# golang.org/x/text v0.22.0
+# golang.org/x/text v0.17.0
 ## explicit; go 1.18
 golang.org/x/text/cases
 golang.org/x/text/internal

From 0ed6dddbac84c71620f0f2b8a47190584e21414f Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Tue, 19 Aug 2025 13:55:49 -0400
Subject: [PATCH 19/32] revert

---
 internal/verifier/compare.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/verifier/compare.go b/internal/verifier/compare.go
index 1b595d00..d90e179c 100644
--- a/internal/verifier/compare.go
+++ b/internal/verifier/compare.go
@@ -21,7 +21,7 @@ import (
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
 	"go.mongodb.org/mongo-driver/mongo/readpref"
-	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
+	"go.mongodb.org/mongo-driver/x/bsonx/bsoncore"
 	"golang.org/x/exp/slices"
 )
 

From 578310c61fd128d9eb03dbbfb7beb52cbb1aef7f Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Tue, 19 Aug 2025 13:57:56 -0400
Subject: [PATCH 20/32] pare back

---
 .../github.com/klauspost/compress/SECURITY.md |   25 -
 .../compress/huff0/decompress_amd64.go        |  226 -
 .../compress/huff0/decompress_amd64.s         |  830 ----
 .../compress/huff0/decompress_generic.go      |  299 --
 .../compress/internal/cpuinfo/cpuinfo.go      |   34 -
 .../internal/cpuinfo/cpuinfo_amd64.go         |   11 -
 .../compress/internal/cpuinfo/cpuinfo_amd64.s |   36 -
 .../compress/zstd/fse_decoder_amd64.go        |   65 -
 .../compress/zstd/fse_decoder_amd64.s         |  126 -
 .../compress/zstd/fse_decoder_generic.go      |   72 -
 .../zstd/internal/xxhash/xxhash_arm64.s       |  184 -
 .../zstd/internal/xxhash/xxhash_asm.go        |   16 -
 .../klauspost/compress/zstd/matchlen_amd64.go |   16 -
 .../klauspost/compress/zstd/matchlen_amd64.s  |   68 -
 .../compress/zstd/matchlen_generic.go         |   33 -
 .../klauspost/compress/zstd/seqdec_amd64.go   |  394 --
 .../klauspost/compress/zstd/seqdec_amd64.s    | 4175 -----------------
 .../klauspost/compress/zstd/seqdec_generic.go |  237 -
 vendor/go.mongodb.org/mongo-driver/v2/LICENSE |  201 -
 .../mongo-driver/v2/bson/array_codec.go       |   42 -
 .../mongo-driver/v2/bson/bsoncodec.go         |  203 -
 .../mongo-driver/v2/bson/byte_slice_codec.go  |   97 -
 .../mongo-driver/v2/bson/codec_cache.go       |  166 -
 .../mongo-driver/v2/bson/cond_addr_codec.go   |   61 -
 .../mongo-driver/v2/bson/copier.go            |  431 --
 .../mongo-driver/v2/bson/decimal.go           |  339 --
 .../mongo-driver/v2/bson/decoder.go           |  136 -
 .../v2/bson/default_value_decoders.go         | 1518 ------
 .../v2/bson/default_value_encoders.go         |  517 --
 .../mongo-driver/v2/bson/doc.go               |  155 -
 .../v2/bson/empty_interface_codec.go          |  127 -
 .../mongo-driver/v2/bson/encoder.go           |  130 -
 .../mongo-driver/v2/bson/extjson_parser.go    |  804 ----
 .../mongo-driver/v2/bson/extjson_reader.go    |  606 ---
 .../mongo-driver/v2/bson/extjson_tables.go    |  223 -
 .../mongo-driver/v2/bson/extjson_wrappers.go  |  489 --
 .../mongo-driver/v2/bson/extjson_writer.go    |  690 ---
 .../mongo-driver/v2/bson/json_scanner.go      |  533 ---
 .../mongo-driver/v2/bson/map_codec.go         |  292 --
 .../mongo-driver/v2/bson/marshal.go           |  191 -
 .../mongo-driver/v2/bson/mgoregistry.go       |  209 -
 .../mongo-driver/v2/bson/mode.go              |   82 -
 .../mongo-driver/v2/bson/objectid.go          |  207 -
 .../mongo-driver/v2/bson/pointer_codec.go     |   88 -
 .../mongo-driver/v2/bson/primitive.go         |  379 --
 .../mongo-driver/v2/bson/primitive_codecs.go  |   89 -
 .../mongo-driver/v2/bson/raw.go               |   93 -
 .../mongo-driver/v2/bson/raw_array.go         |   73 -
 .../mongo-driver/v2/bson/raw_element.go       |   48 -
 .../mongo-driver/v2/bson/raw_value.go         |  306 --
 .../mongo-driver/v2/bson/reader.go            |   49 -
 .../mongo-driver/v2/bson/registry.go          |  381 --
 .../mongo-driver/v2/bson/slice_codec.go       |  173 -
 .../mongo-driver/v2/bson/string_codec.go      |  107 -
 .../mongo-driver/v2/bson/struct_codec.go      |  695 ---
 .../mongo-driver/v2/bson/struct_tag_parser.go |  123 -
 .../mongo-driver/v2/bson/time_codec.go        |  109 -
 .../mongo-driver/v2/bson/types.go             |  118 -
 .../mongo-driver/v2/bson/uint_codec.go        |  161 -
 .../mongo-driver/v2/bson/unmarshal.go         |   90 -
 .../mongo-driver/v2/bson/value_reader.go      |  898 ----
 .../mongo-driver/v2/bson/value_writer.go      |  600 ---
 .../mongo-driver/v2/bson/vector.go            |  268 --
 .../mongo-driver/v2/bson/writer.go            |   61 -
 .../v2/internal/bsoncoreutil/bsoncoreutil.go  |   40 -
 .../v2/internal/decimal128/decinal128.go      |  117 -
 .../mongo-driver/v2/x/bsonx/bsoncore/array.go |  185 -
 .../v2/x/bsonx/bsoncore/bson_arraybuilder.go  |  198 -
 .../x/bsonx/bsoncore/bson_documentbuilder.go  |  184 -
 .../v2/x/bsonx/bsoncore/bsoncore.go           |  842 ----
 .../mongo-driver/v2/x/bsonx/bsoncore/doc.go   |   34 -
 .../v2/x/bsonx/bsoncore/document.go           |  411 --
 .../v2/x/bsonx/bsoncore/element.go            |  166 -
 .../v2/x/bsonx/bsoncore/iterator.go           |  113 -
 .../v2/x/bsonx/bsoncore/tables.go             |  223 -
 .../mongo-driver/v2/x/bsonx/bsoncore/type.go  |   85 -
 .../mongo-driver/v2/x/bsonx/bsoncore/value.go |  986 ----
 .../golang.org/x/sys/cpu/asm_darwin_x86_gc.s  |   17 -
 vendor/golang.org/x/sys/cpu/cpu_darwin_x86.go |   61 -
 vendor/golang.org/x/sys/cpu/cpu_gc_x86.s      |   26 -
 .../golang.org/x/sys/cpu/cpu_linux_riscv64.go |  137 -
 vendor/golang.org/x/sys/cpu/cpu_other_x86.go  |   11 -
 .../x/sys/cpu/syscall_darwin_x86_gc.go        |   98 -
 vendor/golang.org/x/sys/unix/auxv.go          |   36 -
 .../golang.org/x/sys/unix/auxv_unsupported.go |   13 -
 .../golang.org/x/sys/unix/vgetrandom_linux.go |   13 -
 .../x/sys/unix/vgetrandom_unsupported.go      |   11 -
 87 files changed, 24212 deletions(-)
 delete mode 100644 vendor/github.com/klauspost/compress/SECURITY.md
 delete mode 100644 vendor/github.com/klauspost/compress/huff0/decompress_amd64.go
 delete mode 100644 vendor/github.com/klauspost/compress/huff0/decompress_amd64.s
 delete mode 100644 vendor/github.com/klauspost/compress/huff0/decompress_generic.go
 delete mode 100644 vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo.go
 delete mode 100644 vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.go
 delete mode 100644 vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.s
 delete mode 100644 vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.go
 delete mode 100644 vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.s
 delete mode 100644 vendor/github.com/klauspost/compress/zstd/fse_decoder_generic.go
 delete mode 100644 vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_arm64.s
 delete mode 100644 vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_asm.go
 delete mode 100644 vendor/github.com/klauspost/compress/zstd/matchlen_amd64.go
 delete mode 100644 vendor/github.com/klauspost/compress/zstd/matchlen_amd64.s
 delete mode 100644 vendor/github.com/klauspost/compress/zstd/matchlen_generic.go
 delete mode 100644 vendor/github.com/klauspost/compress/zstd/seqdec_amd64.go
 delete mode 100644 vendor/github.com/klauspost/compress/zstd/seqdec_amd64.s
 delete mode 100644 vendor/github.com/klauspost/compress/zstd/seqdec_generic.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/LICENSE
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/array_codec.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/bsoncodec.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/byte_slice_codec.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/codec_cache.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/cond_addr_codec.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/copier.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/decimal.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/decoder.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/default_value_decoders.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/default_value_encoders.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/doc.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/empty_interface_codec.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/encoder.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_parser.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_reader.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_tables.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_wrappers.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_writer.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/json_scanner.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/map_codec.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/marshal.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/mgoregistry.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/mode.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/objectid.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/pointer_codec.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/primitive.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/primitive_codecs.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/raw.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/raw_array.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/raw_element.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/raw_value.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/reader.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/registry.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/slice_codec.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/string_codec.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/struct_codec.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/struct_tag_parser.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/time_codec.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/types.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/uint_codec.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/unmarshal.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/value_reader.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/value_writer.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/vector.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/bson/writer.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/internal/bsoncoreutil/bsoncoreutil.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/internal/decimal128/decinal128.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/array.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bson_arraybuilder.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bson_documentbuilder.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bsoncore.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/doc.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/document.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/element.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/iterator.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/tables.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/type.go
 delete mode 100644 vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/value.go
 delete mode 100644 vendor/golang.org/x/sys/cpu/asm_darwin_x86_gc.s
 delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_darwin_x86.go
 delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_gc_x86.s
 delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go
 delete mode 100644 vendor/golang.org/x/sys/cpu/cpu_other_x86.go
 delete mode 100644 vendor/golang.org/x/sys/cpu/syscall_darwin_x86_gc.go
 delete mode 100644 vendor/golang.org/x/sys/unix/auxv.go
 delete mode 100644 vendor/golang.org/x/sys/unix/auxv_unsupported.go
 delete mode 100644 vendor/golang.org/x/sys/unix/vgetrandom_linux.go
 delete mode 100644 vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go

diff --git a/vendor/github.com/klauspost/compress/SECURITY.md b/vendor/github.com/klauspost/compress/SECURITY.md
deleted file mode 100644
index ca6685e2..00000000
--- a/vendor/github.com/klauspost/compress/SECURITY.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-Security updates are applied only to the latest release.
-
-## Vulnerability Definition
-
-A security vulnerability is a bug that with certain input triggers a crash or an infinite loop. Most calls will have varying execution time and only in rare cases will slow operation be considered a security vulnerability.
-
-Corrupted output generally is not considered a security vulnerability, unless independent operations are able to affect each other. Note that not all functionality is re-entrant and safe to use concurrently.
-
-Out-of-memory crashes only applies if the en/decoder uses an abnormal amount of memory, with appropriate options applied, to limit maximum window size, concurrency, etc. However, if you are in doubt you are welcome to file a security issue.
-
-It is assumed that all callers are trusted, meaning internal data exposed through reflection or inspection of returned data structures is not considered a vulnerability.
-
-Vulnerabilities resulting from compiler/assembler errors should be reported upstream. Depending on the severity this package may or may not implement a workaround.
-
-## Reporting a Vulnerability
-
-If you have discovered a security vulnerability in this project, please report it privately. **Do not disclose it as a public issue.** This gives us time to work with you to fix the issue before public exposure, reducing the chance that the exploit will be used before a patch is released.
-
-Please disclose it at [security advisory](https://github.com/klauspost/compress/security/advisories/new). If possible please provide a minimal reproducer. If the issue only applies to a single platform, it would be helpful to provide access to that.
-
-This project is maintained by a team of volunteers on a reasonable-effort basis. As such, vulnerabilities will be disclosed in a best effort base.
diff --git a/vendor/github.com/klauspost/compress/huff0/decompress_amd64.go b/vendor/github.com/klauspost/compress/huff0/decompress_amd64.go
deleted file mode 100644
index ba7e8e6b..00000000
--- a/vendor/github.com/klauspost/compress/huff0/decompress_amd64.go
+++ /dev/null
@@ -1,226 +0,0 @@
-//go:build amd64 && !appengine && !noasm && gc
-// +build amd64,!appengine,!noasm,gc
-
-// This file contains the specialisation of Decoder.Decompress4X
-// and Decoder.Decompress1X that use an asm implementation of thir main loops.
-package huff0
-
-import (
-	"errors"
-	"fmt"
-
-	"github.com/klauspost/compress/internal/cpuinfo"
-)
-
-// decompress4x_main_loop_x86 is an x86 assembler implementation
-// of Decompress4X when tablelog > 8.
-//
-//go:noescape
-func decompress4x_main_loop_amd64(ctx *decompress4xContext)
-
-// decompress4x_8b_loop_x86 is an x86 assembler implementation
-// of Decompress4X when tablelog <= 8 which decodes 4 entries
-// per loop.
-//
-//go:noescape
-func decompress4x_8b_main_loop_amd64(ctx *decompress4xContext)
-
-// fallback8BitSize is the size where using Go version is faster.
-const fallback8BitSize = 800
-
-type decompress4xContext struct {
-	pbr      *[4]bitReaderShifted
-	peekBits uint8
-	out      *byte
-	dstEvery int
-	tbl      *dEntrySingle
-	decoded  int
-	limit    *byte
-}
-
-// Decompress4X will decompress a 4X encoded stream.
-// The length of the supplied input must match the end of a block exactly.
-// The *capacity* of the dst slice must match the destination size of
-// the uncompressed data exactly.
-func (d *Decoder) Decompress4X(dst, src []byte) ([]byte, error) {
-	if len(d.dt.single) == 0 {
-		return nil, errors.New("no table loaded")
-	}
-	if len(src) < 6+(4*1) {
-		return nil, errors.New("input too small")
-	}
-
-	use8BitTables := d.actualTableLog <= 8
-	if cap(dst) < fallback8BitSize && use8BitTables {
-		return d.decompress4X8bit(dst, src)
-	}
-
-	var br [4]bitReaderShifted
-	// Decode "jump table"
-	start := 6
-	for i := 0; i < 3; i++ {
-		length := int(src[i*2]) | (int(src[i*2+1]) << 8)
-		if start+length >= len(src) {
-			return nil, errors.New("truncated input (or invalid offset)")
-		}
-		err := br[i].init(src[start : start+length])
-		if err != nil {
-			return nil, err
-		}
-		start += length
-	}
-	err := br[3].init(src[start:])
-	if err != nil {
-		return nil, err
-	}
-
-	// destination, offset to match first output
-	dstSize := cap(dst)
-	dst = dst[:dstSize]
-	out := dst
-	dstEvery := (dstSize + 3) / 4
-
-	const tlSize = 1 << tableLogMax
-	const tlMask = tlSize - 1
-	single := d.dt.single[:tlSize]
-
-	var decoded int
-
-	if len(out) > 4*4 && !(br[0].off < 4 || br[1].off < 4 || br[2].off < 4 || br[3].off < 4) {
-		ctx := decompress4xContext{
-			pbr:      &br,
-			peekBits: uint8((64 - d.actualTableLog) & 63), // see: bitReaderShifted.peekBitsFast()
-			out:      &out[0],
-			dstEvery: dstEvery,
-			tbl:      &single[0],
-			limit:    &out[dstEvery-4], // Always stop decoding when first buffer gets here to avoid writing OOB on last.
-		}
-		if use8BitTables {
-			decompress4x_8b_main_loop_amd64(&ctx)
-		} else {
-			decompress4x_main_loop_amd64(&ctx)
-		}
-
-		decoded = ctx.decoded
-		out = out[decoded/4:]
-	}
-
-	// Decode remaining.
-	remainBytes := dstEvery - (decoded / 4)
-	for i := range br {
-		offset := dstEvery * i
-		endsAt := offset + remainBytes
-		if endsAt > len(out) {
-			endsAt = len(out)
-		}
-		br := &br[i]
-		bitsLeft := br.remaining()
-		for bitsLeft > 0 {
-			br.fill()
-			if offset >= endsAt {
-				return nil, errors.New("corruption detected: stream overrun 4")
-			}
-
-			// Read value and increment offset.
-			val := br.peekBitsFast(d.actualTableLog)
-			v := single[val&tlMask].entry
-			nBits := uint8(v)
-			br.advance(nBits)
-			bitsLeft -= uint(nBits)
-			out[offset] = uint8(v >> 8)
-			offset++
-		}
-		if offset != endsAt {
-			return nil, fmt.Errorf("corruption detected: short output block %d, end %d != %d", i, offset, endsAt)
-		}
-		decoded += offset - dstEvery*i
-		err = br.close()
-		if err != nil {
-			return nil, err
-		}
-	}
-	if dstSize != decoded {
-		return nil, errors.New("corruption detected: short output block")
-	}
-	return dst, nil
-}
-
-// decompress4x_main_loop_x86 is an x86 assembler implementation
-// of Decompress1X when tablelog > 8.
-//
-//go:noescape
-func decompress1x_main_loop_amd64(ctx *decompress1xContext)
-
-// decompress4x_main_loop_x86 is an x86 with BMI2 assembler implementation
-// of Decompress1X when tablelog > 8.
-//
-//go:noescape
-func decompress1x_main_loop_bmi2(ctx *decompress1xContext)
-
-type decompress1xContext struct {
-	pbr      *bitReaderShifted
-	peekBits uint8
-	out      *byte
-	outCap   int
-	tbl      *dEntrySingle
-	decoded  int
-}
-
-// Error reported by asm implementations
-const error_max_decoded_size_exeeded = -1
-
-// Decompress1X will decompress a 1X encoded stream.
-// The cap of the output buffer will be the maximum decompressed size.
-// The length of the supplied input must match the end of a block exactly.
-func (d *Decoder) Decompress1X(dst, src []byte) ([]byte, error) {
-	if len(d.dt.single) == 0 {
-		return nil, errors.New("no table loaded")
-	}
-	var br bitReaderShifted
-	err := br.init(src)
-	if err != nil {
-		return dst, err
-	}
-	maxDecodedSize := cap(dst)
-	dst = dst[:maxDecodedSize]
-
-	const tlSize = 1 << tableLogMax
-	const tlMask = tlSize - 1
-
-	if maxDecodedSize >= 4 {
-		ctx := decompress1xContext{
-			pbr:      &br,
-			out:      &dst[0],
-			outCap:   maxDecodedSize,
-			peekBits: uint8((64 - d.actualTableLog) & 63), // see: bitReaderShifted.peekBitsFast()
-			tbl:      &d.dt.single[0],
-		}
-
-		if cpuinfo.HasBMI2() {
-			decompress1x_main_loop_bmi2(&ctx)
-		} else {
-			decompress1x_main_loop_amd64(&ctx)
-		}
-		if ctx.decoded == error_max_decoded_size_exeeded {
-			return nil, ErrMaxDecodedSizeExceeded
-		}
-
-		dst = dst[:ctx.decoded]
-	}
-
-	// br < 8, so uint8 is fine
-	bitsLeft := uint8(br.off)*8 + 64 - br.bitsRead
-	for bitsLeft > 0 {
-		br.fill()
-		if len(dst) >= maxDecodedSize {
-			br.close()
-			return nil, ErrMaxDecodedSizeExceeded
-		}
-		v := d.dt.single[br.peekBitsFast(d.actualTableLog)&tlMask]
-		nBits := uint8(v.entry)
-		br.advance(nBits)
-		bitsLeft -= nBits
-		dst = append(dst, uint8(v.entry>>8))
-	}
-	return dst, br.close()
-}
diff --git a/vendor/github.com/klauspost/compress/huff0/decompress_amd64.s b/vendor/github.com/klauspost/compress/huff0/decompress_amd64.s
deleted file mode 100644
index c4c7ab2d..00000000
--- a/vendor/github.com/klauspost/compress/huff0/decompress_amd64.s
+++ /dev/null
@@ -1,830 +0,0 @@
-// Code generated by command: go run gen.go -out ../decompress_amd64.s -pkg=huff0. DO NOT EDIT.
-
-//go:build amd64 && !appengine && !noasm && gc
-
-// func decompress4x_main_loop_amd64(ctx *decompress4xContext)
-TEXT ·decompress4x_main_loop_amd64(SB), $0-8
-	// Preload values
-	MOVQ    ctx+0(FP), AX
-	MOVBQZX 8(AX), DI
-	MOVQ    16(AX), BX
-	MOVQ    48(AX), SI
-	MOVQ    24(AX), R8
-	MOVQ    32(AX), R9
-	MOVQ    (AX), R10
-
-	// Main loop
-main_loop:
-	XORL  DX, DX
-	CMPQ  BX, SI
-	SETGE DL
-
-	// br0.fillFast32()
-	MOVQ    32(R10), R11
-	MOVBQZX 40(R10), R12
-	CMPQ    R12, $0x20
-	JBE     skip_fill0
-	MOVQ    24(R10), AX
-	SUBQ    $0x20, R12
-	SUBQ    $0x04, AX
-	MOVQ    (R10), R13
-
-	// b.value |= uint64(low) << (b.bitsRead & 63)
-	MOVL (AX)(R13*1), R13
-	MOVQ R12, CX
-	SHLQ CL, R13
-	MOVQ AX, 24(R10)
-	ORQ  R13, R11
-
-	// exhausted += (br0.off < 4)
-	CMPQ AX, $0x04
-	ADCB $+0, DL
-
-skip_fill0:
-	// val0 := br0.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v0 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br0.advance(uint8(v0.entry)
-	MOVB CH, AL
-	SHLQ CL, R11
-	ADDB CL, R12
-
-	// val1 := br0.peekTopBits(peekBits)
-	MOVQ DI, CX
-	MOVQ R11, R13
-	SHRQ CL, R13
-
-	// v1 := table[val1&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br0.advance(uint8(v1.entry))
-	MOVB CH, AH
-	SHLQ CL, R11
-	ADDB CL, R12
-
-	// these two writes get coalesced
-	// out[id * dstEvery + 0] = uint8(v0.entry >> 8)
-	// out[id * dstEvery + 1] = uint8(v1.entry >> 8)
-	MOVW AX, (BX)
-
-	// update the bitreader structure
-	MOVQ R11, 32(R10)
-	MOVB R12, 40(R10)
-
-	// br1.fillFast32()
-	MOVQ    80(R10), R11
-	MOVBQZX 88(R10), R12
-	CMPQ    R12, $0x20
-	JBE     skip_fill1
-	MOVQ    72(R10), AX
-	SUBQ    $0x20, R12
-	SUBQ    $0x04, AX
-	MOVQ    48(R10), R13
-
-	// b.value |= uint64(low) << (b.bitsRead & 63)
-	MOVL (AX)(R13*1), R13
-	MOVQ R12, CX
-	SHLQ CL, R13
-	MOVQ AX, 72(R10)
-	ORQ  R13, R11
-
-	// exhausted += (br1.off < 4)
-	CMPQ AX, $0x04
-	ADCB $+0, DL
-
-skip_fill1:
-	// val0 := br1.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v0 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br1.advance(uint8(v0.entry)
-	MOVB CH, AL
-	SHLQ CL, R11
-	ADDB CL, R12
-
-	// val1 := br1.peekTopBits(peekBits)
-	MOVQ DI, CX
-	MOVQ R11, R13
-	SHRQ CL, R13
-
-	// v1 := table[val1&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br1.advance(uint8(v1.entry))
-	MOVB CH, AH
-	SHLQ CL, R11
-	ADDB CL, R12
-
-	// these two writes get coalesced
-	// out[id * dstEvery + 0] = uint8(v0.entry >> 8)
-	// out[id * dstEvery + 1] = uint8(v1.entry >> 8)
-	MOVW AX, (BX)(R8*1)
-
-	// update the bitreader structure
-	MOVQ R11, 80(R10)
-	MOVB R12, 88(R10)
-
-	// br2.fillFast32()
-	MOVQ    128(R10), R11
-	MOVBQZX 136(R10), R12
-	CMPQ    R12, $0x20
-	JBE     skip_fill2
-	MOVQ    120(R10), AX
-	SUBQ    $0x20, R12
-	SUBQ    $0x04, AX
-	MOVQ    96(R10), R13
-
-	// b.value |= uint64(low) << (b.bitsRead & 63)
-	MOVL (AX)(R13*1), R13
-	MOVQ R12, CX
-	SHLQ CL, R13
-	MOVQ AX, 120(R10)
-	ORQ  R13, R11
-
-	// exhausted += (br2.off < 4)
-	CMPQ AX, $0x04
-	ADCB $+0, DL
-
-skip_fill2:
-	// val0 := br2.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v0 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br2.advance(uint8(v0.entry)
-	MOVB CH, AL
-	SHLQ CL, R11
-	ADDB CL, R12
-
-	// val1 := br2.peekTopBits(peekBits)
-	MOVQ DI, CX
-	MOVQ R11, R13
-	SHRQ CL, R13
-
-	// v1 := table[val1&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br2.advance(uint8(v1.entry))
-	MOVB CH, AH
-	SHLQ CL, R11
-	ADDB CL, R12
-
-	// these two writes get coalesced
-	// out[id * dstEvery + 0] = uint8(v0.entry >> 8)
-	// out[id * dstEvery + 1] = uint8(v1.entry >> 8)
-	MOVW AX, (BX)(R8*2)
-
-	// update the bitreader structure
-	MOVQ R11, 128(R10)
-	MOVB R12, 136(R10)
-
-	// br3.fillFast32()
-	MOVQ    176(R10), R11
-	MOVBQZX 184(R10), R12
-	CMPQ    R12, $0x20
-	JBE     skip_fill3
-	MOVQ    168(R10), AX
-	SUBQ    $0x20, R12
-	SUBQ    $0x04, AX
-	MOVQ    144(R10), R13
-
-	// b.value |= uint64(low) << (b.bitsRead & 63)
-	MOVL (AX)(R13*1), R13
-	MOVQ R12, CX
-	SHLQ CL, R13
-	MOVQ AX, 168(R10)
-	ORQ  R13, R11
-
-	// exhausted += (br3.off < 4)
-	CMPQ AX, $0x04
-	ADCB $+0, DL
-
-skip_fill3:
-	// val0 := br3.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v0 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br3.advance(uint8(v0.entry)
-	MOVB CH, AL
-	SHLQ CL, R11
-	ADDB CL, R12
-
-	// val1 := br3.peekTopBits(peekBits)
-	MOVQ DI, CX
-	MOVQ R11, R13
-	SHRQ CL, R13
-
-	// v1 := table[val1&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br3.advance(uint8(v1.entry))
-	MOVB CH, AH
-	SHLQ CL, R11
-	ADDB CL, R12
-
-	// these two writes get coalesced
-	// out[id * dstEvery + 0] = uint8(v0.entry >> 8)
-	// out[id * dstEvery + 1] = uint8(v1.entry >> 8)
-	LEAQ (R8)(R8*2), CX
-	MOVW AX, (BX)(CX*1)
-
-	// update the bitreader structure
-	MOVQ  R11, 176(R10)
-	MOVB  R12, 184(R10)
-	ADDQ  $0x02, BX
-	TESTB DL, DL
-	JZ    main_loop
-	MOVQ  ctx+0(FP), AX
-	SUBQ  16(AX), BX
-	SHLQ  $0x02, BX
-	MOVQ  BX, 40(AX)
-	RET
-
-// func decompress4x_8b_main_loop_amd64(ctx *decompress4xContext)
-TEXT ·decompress4x_8b_main_loop_amd64(SB), $0-8
-	// Preload values
-	MOVQ    ctx+0(FP), CX
-	MOVBQZX 8(CX), DI
-	MOVQ    16(CX), BX
-	MOVQ    48(CX), SI
-	MOVQ    24(CX), R8
-	MOVQ    32(CX), R9
-	MOVQ    (CX), R10
-
-	// Main loop
-main_loop:
-	XORL  DX, DX
-	CMPQ  BX, SI
-	SETGE DL
-
-	// br0.fillFast32()
-	MOVQ    32(R10), R11
-	MOVBQZX 40(R10), R12
-	CMPQ    R12, $0x20
-	JBE     skip_fill0
-	MOVQ    24(R10), R13
-	SUBQ    $0x20, R12
-	SUBQ    $0x04, R13
-	MOVQ    (R10), R14
-
-	// b.value |= uint64(low) << (b.bitsRead & 63)
-	MOVL (R13)(R14*1), R14
-	MOVQ R12, CX
-	SHLQ CL, R14
-	MOVQ R13, 24(R10)
-	ORQ  R14, R11
-
-	// exhausted += (br0.off < 4)
-	CMPQ R13, $0x04
-	ADCB $+0, DL
-
-skip_fill0:
-	// val0 := br0.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v0 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br0.advance(uint8(v0.entry)
-	MOVB CH, AL
-	SHLQ CL, R11
-	ADDB CL, R12
-
-	// val1 := br0.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v1 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br0.advance(uint8(v1.entry)
-	MOVB   CH, AH
-	SHLQ   CL, R11
-	ADDB   CL, R12
-	BSWAPL AX
-
-	// val2 := br0.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v2 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br0.advance(uint8(v2.entry)
-	MOVB CH, AH
-	SHLQ CL, R11
-	ADDB CL, R12
-
-	// val3 := br0.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v3 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br0.advance(uint8(v3.entry)
-	MOVB   CH, AL
-	SHLQ   CL, R11
-	ADDB   CL, R12
-	BSWAPL AX
-
-	// these four writes get coalesced
-	// out[id * dstEvery + 0] = uint8(v0.entry >> 8)
-	// out[id * dstEvery + 1] = uint8(v1.entry >> 8)
-	// out[id * dstEvery + 3] = uint8(v2.entry >> 8)
-	// out[id * dstEvery + 4] = uint8(v3.entry >> 8)
-	MOVL AX, (BX)
-
-	// update the bitreader structure
-	MOVQ R11, 32(R10)
-	MOVB R12, 40(R10)
-
-	// br1.fillFast32()
-	MOVQ    80(R10), R11
-	MOVBQZX 88(R10), R12
-	CMPQ    R12, $0x20
-	JBE     skip_fill1
-	MOVQ    72(R10), R13
-	SUBQ    $0x20, R12
-	SUBQ    $0x04, R13
-	MOVQ    48(R10), R14
-
-	// b.value |= uint64(low) << (b.bitsRead & 63)
-	MOVL (R13)(R14*1), R14
-	MOVQ R12, CX
-	SHLQ CL, R14
-	MOVQ R13, 72(R10)
-	ORQ  R14, R11
-
-	// exhausted += (br1.off < 4)
-	CMPQ R13, $0x04
-	ADCB $+0, DL
-
-skip_fill1:
-	// val0 := br1.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v0 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br1.advance(uint8(v0.entry)
-	MOVB CH, AL
-	SHLQ CL, R11
-	ADDB CL, R12
-
-	// val1 := br1.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v1 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br1.advance(uint8(v1.entry)
-	MOVB   CH, AH
-	SHLQ   CL, R11
-	ADDB   CL, R12
-	BSWAPL AX
-
-	// val2 := br1.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v2 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br1.advance(uint8(v2.entry)
-	MOVB CH, AH
-	SHLQ CL, R11
-	ADDB CL, R12
-
-	// val3 := br1.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v3 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br1.advance(uint8(v3.entry)
-	MOVB   CH, AL
-	SHLQ   CL, R11
-	ADDB   CL, R12
-	BSWAPL AX
-
-	// these four writes get coalesced
-	// out[id * dstEvery + 0] = uint8(v0.entry >> 8)
-	// out[id * dstEvery + 1] = uint8(v1.entry >> 8)
-	// out[id * dstEvery + 3] = uint8(v2.entry >> 8)
-	// out[id * dstEvery + 4] = uint8(v3.entry >> 8)
-	MOVL AX, (BX)(R8*1)
-
-	// update the bitreader structure
-	MOVQ R11, 80(R10)
-	MOVB R12, 88(R10)
-
-	// br2.fillFast32()
-	MOVQ    128(R10), R11
-	MOVBQZX 136(R10), R12
-	CMPQ    R12, $0x20
-	JBE     skip_fill2
-	MOVQ    120(R10), R13
-	SUBQ    $0x20, R12
-	SUBQ    $0x04, R13
-	MOVQ    96(R10), R14
-
-	// b.value |= uint64(low) << (b.bitsRead & 63)
-	MOVL (R13)(R14*1), R14
-	MOVQ R12, CX
-	SHLQ CL, R14
-	MOVQ R13, 120(R10)
-	ORQ  R14, R11
-
-	// exhausted += (br2.off < 4)
-	CMPQ R13, $0x04
-	ADCB $+0, DL
-
-skip_fill2:
-	// val0 := br2.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v0 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br2.advance(uint8(v0.entry)
-	MOVB CH, AL
-	SHLQ CL, R11
-	ADDB CL, R12
-
-	// val1 := br2.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v1 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br2.advance(uint8(v1.entry)
-	MOVB   CH, AH
-	SHLQ   CL, R11
-	ADDB   CL, R12
-	BSWAPL AX
-
-	// val2 := br2.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v2 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br2.advance(uint8(v2.entry)
-	MOVB CH, AH
-	SHLQ CL, R11
-	ADDB CL, R12
-
-	// val3 := br2.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v3 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br2.advance(uint8(v3.entry)
-	MOVB   CH, AL
-	SHLQ   CL, R11
-	ADDB   CL, R12
-	BSWAPL AX
-
-	// these four writes get coalesced
-	// out[id * dstEvery + 0] = uint8(v0.entry >> 8)
-	// out[id * dstEvery + 1] = uint8(v1.entry >> 8)
-	// out[id * dstEvery + 3] = uint8(v2.entry >> 8)
-	// out[id * dstEvery + 4] = uint8(v3.entry >> 8)
-	MOVL AX, (BX)(R8*2)
-
-	// update the bitreader structure
-	MOVQ R11, 128(R10)
-	MOVB R12, 136(R10)
-
-	// br3.fillFast32()
-	MOVQ    176(R10), R11
-	MOVBQZX 184(R10), R12
-	CMPQ    R12, $0x20
-	JBE     skip_fill3
-	MOVQ    168(R10), R13
-	SUBQ    $0x20, R12
-	SUBQ    $0x04, R13
-	MOVQ    144(R10), R14
-
-	// b.value |= uint64(low) << (b.bitsRead & 63)
-	MOVL (R13)(R14*1), R14
-	MOVQ R12, CX
-	SHLQ CL, R14
-	MOVQ R13, 168(R10)
-	ORQ  R14, R11
-
-	// exhausted += (br3.off < 4)
-	CMPQ R13, $0x04
-	ADCB $+0, DL
-
-skip_fill3:
-	// val0 := br3.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v0 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br3.advance(uint8(v0.entry)
-	MOVB CH, AL
-	SHLQ CL, R11
-	ADDB CL, R12
-
-	// val1 := br3.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v1 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br3.advance(uint8(v1.entry)
-	MOVB   CH, AH
-	SHLQ   CL, R11
-	ADDB   CL, R12
-	BSWAPL AX
-
-	// val2 := br3.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v2 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br3.advance(uint8(v2.entry)
-	MOVB CH, AH
-	SHLQ CL, R11
-	ADDB CL, R12
-
-	// val3 := br3.peekTopBits(peekBits)
-	MOVQ R11, R13
-	MOVQ DI, CX
-	SHRQ CL, R13
-
-	// v3 := table[val0&mask]
-	MOVW (R9)(R13*2), CX
-
-	// br3.advance(uint8(v3.entry)
-	MOVB   CH, AL
-	SHLQ   CL, R11
-	ADDB   CL, R12
-	BSWAPL AX
-
-	// these four writes get coalesced
-	// out[id * dstEvery + 0] = uint8(v0.entry >> 8)
-	// out[id * dstEvery + 1] = uint8(v1.entry >> 8)
-	// out[id * dstEvery + 3] = uint8(v2.entry >> 8)
-	// out[id * dstEvery + 4] = uint8(v3.entry >> 8)
-	LEAQ (R8)(R8*2), CX
-	MOVL AX, (BX)(CX*1)
-
-	// update the bitreader structure
-	MOVQ  R11, 176(R10)
-	MOVB  R12, 184(R10)
-	ADDQ  $0x04, BX
-	TESTB DL, DL
-	JZ    main_loop
-	MOVQ  ctx+0(FP), AX
-	SUBQ  16(AX), BX
-	SHLQ  $0x02, BX
-	MOVQ  BX, 40(AX)
-	RET
-
-// func decompress1x_main_loop_amd64(ctx *decompress1xContext)
-TEXT ·decompress1x_main_loop_amd64(SB), $0-8
-	MOVQ    ctx+0(FP), CX
-	MOVQ    16(CX), DX
-	MOVQ    24(CX), BX
-	CMPQ    BX, $0x04
-	JB      error_max_decoded_size_exceeded
-	LEAQ    (DX)(BX*1), BX
-	MOVQ    (CX), SI
-	MOVQ    (SI), R8
-	MOVQ    24(SI), R9
-	MOVQ    32(SI), R10
-	MOVBQZX 40(SI), R11
-	MOVQ    32(CX), SI
-	MOVBQZX 8(CX), DI
-	JMP     loop_condition
-
-main_loop:
-	// Check if we have room for 4 bytes in the output buffer
-	LEAQ 4(DX), CX
-	CMPQ CX, BX
-	JGE  error_max_decoded_size_exceeded
-
-	// Decode 4 values
-	CMPQ R11, $0x20
-	JL   bitReader_fillFast_1_end
-	SUBQ $0x20, R11
-	SUBQ $0x04, R9
-	MOVL (R8)(R9*1), R12
-	MOVQ R11, CX
-	SHLQ CL, R12
-	ORQ  R12, R10
-
-bitReader_fillFast_1_end:
-	MOVQ    DI, CX
-	MOVQ    R10, R12
-	SHRQ    CL, R12
-	MOVW    (SI)(R12*2), CX
-	MOVB    CH, AL
-	MOVBQZX CL, CX
-	ADDQ    CX, R11
-	SHLQ    CL, R10
-	MOVQ    DI, CX
-	MOVQ    R10, R12
-	SHRQ    CL, R12
-	MOVW    (SI)(R12*2), CX
-	MOVB    CH, AH
-	MOVBQZX CL, CX
-	ADDQ    CX, R11
-	SHLQ    CL, R10
-	BSWAPL  AX
-	CMPQ    R11, $0x20
-	JL      bitReader_fillFast_2_end
-	SUBQ    $0x20, R11
-	SUBQ    $0x04, R9
-	MOVL    (R8)(R9*1), R12
-	MOVQ    R11, CX
-	SHLQ    CL, R12
-	ORQ     R12, R10
-
-bitReader_fillFast_2_end:
-	MOVQ    DI, CX
-	MOVQ    R10, R12
-	SHRQ    CL, R12
-	MOVW    (SI)(R12*2), CX
-	MOVB    CH, AH
-	MOVBQZX CL, CX
-	ADDQ    CX, R11
-	SHLQ    CL, R10
-	MOVQ    DI, CX
-	MOVQ    R10, R12
-	SHRQ    CL, R12
-	MOVW    (SI)(R12*2), CX
-	MOVB    CH, AL
-	MOVBQZX CL, CX
-	ADDQ    CX, R11
-	SHLQ    CL, R10
-	BSWAPL  AX
-
-	// Store the decoded values
-	MOVL AX, (DX)
-	ADDQ $0x04, DX
-
-loop_condition:
-	CMPQ R9, $0x08
-	JGE  main_loop
-
-	// Update ctx structure
-	MOVQ ctx+0(FP), AX
-	SUBQ 16(AX), DX
-	MOVQ DX, 40(AX)
-	MOVQ (AX), AX
-	MOVQ R9, 24(AX)
-	MOVQ R10, 32(AX)
-	MOVB R11, 40(AX)
-	RET
-
-	// Report error
-error_max_decoded_size_exceeded:
-	MOVQ ctx+0(FP), AX
-	MOVQ $-1, CX
-	MOVQ CX, 40(AX)
-	RET
-
-// func decompress1x_main_loop_bmi2(ctx *decompress1xContext)
-// Requires: BMI2
-TEXT ·decompress1x_main_loop_bmi2(SB), $0-8
-	MOVQ    ctx+0(FP), CX
-	MOVQ    16(CX), DX
-	MOVQ    24(CX), BX
-	CMPQ    BX, $0x04
-	JB      error_max_decoded_size_exceeded
-	LEAQ    (DX)(BX*1), BX
-	MOVQ    (CX), SI
-	MOVQ    (SI), R8
-	MOVQ    24(SI), R9
-	MOVQ    32(SI), R10
-	MOVBQZX 40(SI), R11
-	MOVQ    32(CX), SI
-	MOVBQZX 8(CX), DI
-	JMP     loop_condition
-
-main_loop:
-	// Check if we have room for 4 bytes in the output buffer
-	LEAQ 4(DX), CX
-	CMPQ CX, BX
-	JGE  error_max_decoded_size_exceeded
-
-	// Decode 4 values
-	CMPQ  R11, $0x20
-	JL    bitReader_fillFast_1_end
-	SUBQ  $0x20, R11
-	SUBQ  $0x04, R9
-	MOVL  (R8)(R9*1), CX
-	SHLXQ R11, CX, CX
-	ORQ   CX, R10
-
-bitReader_fillFast_1_end:
-	SHRXQ   DI, R10, CX
-	MOVW    (SI)(CX*2), CX
-	MOVB    CH, AL
-	MOVBQZX CL, CX
-	ADDQ    CX, R11
-	SHLXQ   CX, R10, R10
-	SHRXQ   DI, R10, CX
-	MOVW    (SI)(CX*2), CX
-	MOVB    CH, AH
-	MOVBQZX CL, CX
-	ADDQ    CX, R11
-	SHLXQ   CX, R10, R10
-	BSWAPL  AX
-	CMPQ    R11, $0x20
-	JL      bitReader_fillFast_2_end
-	SUBQ    $0x20, R11
-	SUBQ    $0x04, R9
-	MOVL    (R8)(R9*1), CX
-	SHLXQ   R11, CX, CX
-	ORQ     CX, R10
-
-bitReader_fillFast_2_end:
-	SHRXQ   DI, R10, CX
-	MOVW    (SI)(CX*2), CX
-	MOVB    CH, AH
-	MOVBQZX CL, CX
-	ADDQ    CX, R11
-	SHLXQ   CX, R10, R10
-	SHRXQ   DI, R10, CX
-	MOVW    (SI)(CX*2), CX
-	MOVB    CH, AL
-	MOVBQZX CL, CX
-	ADDQ    CX, R11
-	SHLXQ   CX, R10, R10
-	BSWAPL  AX
-
-	// Store the decoded values
-	MOVL AX, (DX)
-	ADDQ $0x04, DX
-
-loop_condition:
-	CMPQ R9, $0x08
-	JGE  main_loop
-
-	// Update ctx structure
-	MOVQ ctx+0(FP), AX
-	SUBQ 16(AX), DX
-	MOVQ DX, 40(AX)
-	MOVQ (AX), AX
-	MOVQ R9, 24(AX)
-	MOVQ R10, 32(AX)
-	MOVB R11, 40(AX)
-	RET
-
-	// Report error
-error_max_decoded_size_exceeded:
-	MOVQ ctx+0(FP), AX
-	MOVQ $-1, CX
-	MOVQ CX, 40(AX)
-	RET
diff --git a/vendor/github.com/klauspost/compress/huff0/decompress_generic.go b/vendor/github.com/klauspost/compress/huff0/decompress_generic.go
deleted file mode 100644
index 908c17de..00000000
--- a/vendor/github.com/klauspost/compress/huff0/decompress_generic.go
+++ /dev/null
@@ -1,299 +0,0 @@
-//go:build !amd64 || appengine || !gc || noasm
-// +build !amd64 appengine !gc noasm
-
-// This file contains a generic implementation of Decoder.Decompress4X.
-package huff0
-
-import (
-	"errors"
-	"fmt"
-)
-
-// Decompress4X will decompress a 4X encoded stream.
-// The length of the supplied input must match the end of a block exactly.
-// The *capacity* of the dst slice must match the destination size of
-// the uncompressed data exactly.
-func (d *Decoder) Decompress4X(dst, src []byte) ([]byte, error) {
-	if len(d.dt.single) == 0 {
-		return nil, errors.New("no table loaded")
-	}
-	if len(src) < 6+(4*1) {
-		return nil, errors.New("input too small")
-	}
-	if use8BitTables && d.actualTableLog <= 8 {
-		return d.decompress4X8bit(dst, src)
-	}
-
-	var br [4]bitReaderShifted
-	// Decode "jump table"
-	start := 6
-	for i := 0; i < 3; i++ {
-		length := int(src[i*2]) | (int(src[i*2+1]) << 8)
-		if start+length >= len(src) {
-			return nil, errors.New("truncated input (or invalid offset)")
-		}
-		err := br[i].init(src[start : start+length])
-		if err != nil {
-			return nil, err
-		}
-		start += length
-	}
-	err := br[3].init(src[start:])
-	if err != nil {
-		return nil, err
-	}
-
-	// destination, offset to match first output
-	dstSize := cap(dst)
-	dst = dst[:dstSize]
-	out := dst
-	dstEvery := (dstSize + 3) / 4
-
-	const tlSize = 1 << tableLogMax
-	const tlMask = tlSize - 1
-	single := d.dt.single[:tlSize]
-
-	// Use temp table to avoid bound checks/append penalty.
-	buf := d.buffer()
-	var off uint8
-	var decoded int
-
-	// Decode 2 values from each decoder/loop.
-	const bufoff = 256
-	for {
-		if br[0].off < 4 || br[1].off < 4 || br[2].off < 4 || br[3].off < 4 {
-			break
-		}
-
-		{
-			const stream = 0
-			const stream2 = 1
-			br[stream].fillFast()
-			br[stream2].fillFast()
-
-			val := br[stream].peekBitsFast(d.actualTableLog)
-			val2 := br[stream2].peekBitsFast(d.actualTableLog)
-			v := single[val&tlMask]
-			v2 := single[val2&tlMask]
-			br[stream].advance(uint8(v.entry))
-			br[stream2].advance(uint8(v2.entry))
-			buf[stream][off] = uint8(v.entry >> 8)
-			buf[stream2][off] = uint8(v2.entry >> 8)
-
-			val = br[stream].peekBitsFast(d.actualTableLog)
-			val2 = br[stream2].peekBitsFast(d.actualTableLog)
-			v = single[val&tlMask]
-			v2 = single[val2&tlMask]
-			br[stream].advance(uint8(v.entry))
-			br[stream2].advance(uint8(v2.entry))
-			buf[stream][off+1] = uint8(v.entry >> 8)
-			buf[stream2][off+1] = uint8(v2.entry >> 8)
-		}
-
-		{
-			const stream = 2
-			const stream2 = 3
-			br[stream].fillFast()
-			br[stream2].fillFast()
-
-			val := br[stream].peekBitsFast(d.actualTableLog)
-			val2 := br[stream2].peekBitsFast(d.actualTableLog)
-			v := single[val&tlMask]
-			v2 := single[val2&tlMask]
-			br[stream].advance(uint8(v.entry))
-			br[stream2].advance(uint8(v2.entry))
-			buf[stream][off] = uint8(v.entry >> 8)
-			buf[stream2][off] = uint8(v2.entry >> 8)
-
-			val = br[stream].peekBitsFast(d.actualTableLog)
-			val2 = br[stream2].peekBitsFast(d.actualTableLog)
-			v = single[val&tlMask]
-			v2 = single[val2&tlMask]
-			br[stream].advance(uint8(v.entry))
-			br[stream2].advance(uint8(v2.entry))
-			buf[stream][off+1] = uint8(v.entry >> 8)
-			buf[stream2][off+1] = uint8(v2.entry >> 8)
-		}
-
-		off += 2
-
-		if off == 0 {
-			if bufoff > dstEvery {
-				d.bufs.Put(buf)
-				return nil, errors.New("corruption detected: stream overrun 1")
-			}
-			// There must at least be 3 buffers left.
-			if len(out)-bufoff < dstEvery*3 {
-				d.bufs.Put(buf)
-				return nil, errors.New("corruption detected: stream overrun 2")
-			}
-			//copy(out, buf[0][:])
-			//copy(out[dstEvery:], buf[1][:])
-			//copy(out[dstEvery*2:], buf[2][:])
-			//copy(out[dstEvery*3:], buf[3][:])
-			*(*[bufoff]byte)(out) = buf[0]
-			*(*[bufoff]byte)(out[dstEvery:]) = buf[1]
-			*(*[bufoff]byte)(out[dstEvery*2:]) = buf[2]
-			*(*[bufoff]byte)(out[dstEvery*3:]) = buf[3]
-			out = out[bufoff:]
-			decoded += bufoff * 4
-		}
-	}
-	if off > 0 {
-		ioff := int(off)
-		if len(out) < dstEvery*3+ioff {
-			d.bufs.Put(buf)
-			return nil, errors.New("corruption detected: stream overrun 3")
-		}
-		copy(out, buf[0][:off])
-		copy(out[dstEvery:], buf[1][:off])
-		copy(out[dstEvery*2:], buf[2][:off])
-		copy(out[dstEvery*3:], buf[3][:off])
-		decoded += int(off) * 4
-		out = out[off:]
-	}
-
-	// Decode remaining.
-	remainBytes := dstEvery - (decoded / 4)
-	for i := range br {
-		offset := dstEvery * i
-		endsAt := offset + remainBytes
-		if endsAt > len(out) {
-			endsAt = len(out)
-		}
-		br := &br[i]
-		bitsLeft := br.remaining()
-		for bitsLeft > 0 {
-			br.fill()
-			if offset >= endsAt {
-				d.bufs.Put(buf)
-				return nil, errors.New("corruption detected: stream overrun 4")
-			}
-
-			// Read value and increment offset.
-			val := br.peekBitsFast(d.actualTableLog)
-			v := single[val&tlMask].entry
-			nBits := uint8(v)
-			br.advance(nBits)
-			bitsLeft -= uint(nBits)
-			out[offset] = uint8(v >> 8)
-			offset++
-		}
-		if offset != endsAt {
-			d.bufs.Put(buf)
-			return nil, fmt.Errorf("corruption detected: short output block %d, end %d != %d", i, offset, endsAt)
-		}
-		decoded += offset - dstEvery*i
-		err = br.close()
-		if err != nil {
-			return nil, err
-		}
-	}
-	d.bufs.Put(buf)
-	if dstSize != decoded {
-		return nil, errors.New("corruption detected: short output block")
-	}
-	return dst, nil
-}
-
-// Decompress1X will decompress a 1X encoded stream.
-// The cap of the output buffer will be the maximum decompressed size.
-// The length of the supplied input must match the end of a block exactly.
-func (d *Decoder) Decompress1X(dst, src []byte) ([]byte, error) {
-	if len(d.dt.single) == 0 {
-		return nil, errors.New("no table loaded")
-	}
-	if use8BitTables && d.actualTableLog <= 8 {
-		return d.decompress1X8Bit(dst, src)
-	}
-	var br bitReaderShifted
-	err := br.init(src)
-	if err != nil {
-		return dst, err
-	}
-	maxDecodedSize := cap(dst)
-	dst = dst[:0]
-
-	// Avoid bounds check by always having full sized table.
-	const tlSize = 1 << tableLogMax
-	const tlMask = tlSize - 1
-	dt := d.dt.single[:tlSize]
-
-	// Use temp table to avoid bound checks/append penalty.
-	bufs := d.buffer()
-	buf := &bufs[0]
-	var off uint8
-
-	for br.off >= 8 {
-		br.fillFast()
-		v := dt[br.peekBitsFast(d.actualTableLog)&tlMask]
-		br.advance(uint8(v.entry))
-		buf[off+0] = uint8(v.entry >> 8)
-
-		v = dt[br.peekBitsFast(d.actualTableLog)&tlMask]
-		br.advance(uint8(v.entry))
-		buf[off+1] = uint8(v.entry >> 8)
-
-		// Refill
-		br.fillFast()
-
-		v = dt[br.peekBitsFast(d.actualTableLog)&tlMask]
-		br.advance(uint8(v.entry))
-		buf[off+2] = uint8(v.entry >> 8)
-
-		v = dt[br.peekBitsFast(d.actualTableLog)&tlMask]
-		br.advance(uint8(v.entry))
-		buf[off+3] = uint8(v.entry >> 8)
-
-		off += 4
-		if off == 0 {
-			if len(dst)+256 > maxDecodedSize {
-				br.close()
-				d.bufs.Put(bufs)
-				return nil, ErrMaxDecodedSizeExceeded
-			}
-			dst = append(dst, buf[:]...)
-		}
-	}
-
-	if len(dst)+int(off) > maxDecodedSize {
-		d.bufs.Put(bufs)
-		br.close()
-		return nil, ErrMaxDecodedSizeExceeded
-	}
-	dst = append(dst, buf[:off]...)
-
-	// br < 8, so uint8 is fine
-	bitsLeft := uint8(br.off)*8 + 64 - br.bitsRead
-	for bitsLeft > 0 {
-		br.fill()
-		if false && br.bitsRead >= 32 {
-			if br.off >= 4 {
-				v := br.in[br.off-4:]
-				v = v[:4]
-				low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
-				br.value = (br.value << 32) | uint64(low)
-				br.bitsRead -= 32
-				br.off -= 4
-			} else {
-				for br.off > 0 {
-					br.value = (br.value << 8) | uint64(br.in[br.off-1])
-					br.bitsRead -= 8
-					br.off--
-				}
-			}
-		}
-		if len(dst) >= maxDecodedSize {
-			d.bufs.Put(bufs)
-			br.close()
-			return nil, ErrMaxDecodedSizeExceeded
-		}
-		v := d.dt.single[br.peekBitsFast(d.actualTableLog)&tlMask]
-		nBits := uint8(v.entry)
-		br.advance(nBits)
-		bitsLeft -= nBits
-		dst = append(dst, uint8(v.entry>>8))
-	}
-	d.bufs.Put(bufs)
-	return dst, br.close()
-}
diff --git a/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo.go b/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo.go
deleted file mode 100644
index 3954c512..00000000
--- a/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo.go
+++ /dev/null
@@ -1,34 +0,0 @@
-// Package cpuinfo gives runtime info about the current CPU.
-//
-// This is a very limited module meant for use internally
-// in this project. For more versatile solution check
-// https://github.com/klauspost/cpuid.
-package cpuinfo
-
-// HasBMI1 checks whether an x86 CPU supports the BMI1 extension.
-func HasBMI1() bool {
-	return hasBMI1
-}
-
-// HasBMI2 checks whether an x86 CPU supports the BMI2 extension.
-func HasBMI2() bool {
-	return hasBMI2
-}
-
-// DisableBMI2 will disable BMI2, for testing purposes.
-// Call returned function to restore previous state.
-func DisableBMI2() func() {
-	old := hasBMI2
-	hasBMI2 = false
-	return func() {
-		hasBMI2 = old
-	}
-}
-
-// HasBMI checks whether an x86 CPU supports both BMI1 and BMI2 extensions.
-func HasBMI() bool {
-	return HasBMI1() && HasBMI2()
-}
-
-var hasBMI1 bool
-var hasBMI2 bool
diff --git a/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.go b/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.go
deleted file mode 100644
index e802579c..00000000
--- a/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.go
+++ /dev/null
@@ -1,11 +0,0 @@
-//go:build amd64 && !appengine && !noasm && gc
-// +build amd64,!appengine,!noasm,gc
-
-package cpuinfo
-
-// go:noescape
-func x86extensions() (bmi1, bmi2 bool)
-
-func init() {
-	hasBMI1, hasBMI2 = x86extensions()
-}
diff --git a/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.s b/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.s
deleted file mode 100644
index 4465fbe9..00000000
--- a/vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.s
+++ /dev/null
@@ -1,36 +0,0 @@
-// +build !appengine
-// +build gc
-// +build !noasm
-
-#include "textflag.h"
-#include "funcdata.h"
-#include "go_asm.h"
-
-TEXT ·x86extensions(SB), NOSPLIT, $0
-	// 1. determine max EAX value
-	XORQ AX, AX
-	CPUID
-
-	CMPQ AX, $7
-	JB   unsupported
-
-	// 2. EAX = 7, ECX = 0 --- see Table 3-8 "Information Returned by CPUID Instruction"
-	MOVQ $7, AX
-	MOVQ $0, CX
-	CPUID
-
-	BTQ   $3, BX // bit 3 = BMI1
-	SETCS AL
-
-	BTQ   $8, BX // bit 8 = BMI2
-	SETCS AH
-
-	MOVB AL, bmi1+0(FP)
-	MOVB AH, bmi2+1(FP)
-	RET
-
-unsupported:
-	XORQ AX, AX
-	MOVB AL, bmi1+0(FP)
-	MOVB AL, bmi2+1(FP)
-	RET
diff --git a/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.go b/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.go
deleted file mode 100644
index d04a829b..00000000
--- a/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.go
+++ /dev/null
@@ -1,65 +0,0 @@
-//go:build amd64 && !appengine && !noasm && gc
-// +build amd64,!appengine,!noasm,gc
-
-package zstd
-
-import (
-	"fmt"
-)
-
-type buildDtableAsmContext struct {
-	// inputs
-	stateTable *uint16
-	norm       *int16
-	dt         *uint64
-
-	// outputs --- set by the procedure in the case of error;
-	// for interpretation please see the error handling part below
-	errParam1 uint64
-	errParam2 uint64
-}
-
-// buildDtable_asm is an x86 assembly implementation of fseDecoder.buildDtable.
-// Function returns non-zero exit code on error.
-//
-//go:noescape
-func buildDtable_asm(s *fseDecoder, ctx *buildDtableAsmContext) int
-
-// please keep in sync with _generate/gen_fse.go
-const (
-	errorCorruptedNormalizedCounter = 1
-	errorNewStateTooBig             = 2
-	errorNewStateNoBits             = 3
-)
-
-// buildDtable will build the decoding table.
-func (s *fseDecoder) buildDtable() error {
-	ctx := buildDtableAsmContext{
-		stateTable: &s.stateTable[0],
-		norm:       &s.norm[0],
-		dt:         (*uint64)(&s.dt[0]),
-	}
-	code := buildDtable_asm(s, &ctx)
-
-	if code != 0 {
-		switch code {
-		case errorCorruptedNormalizedCounter:
-			position := ctx.errParam1
-			return fmt.Errorf("corrupted input (position=%d, expected 0)", position)
-
-		case errorNewStateTooBig:
-			newState := decSymbol(ctx.errParam1)
-			size := ctx.errParam2
-			return fmt.Errorf("newState (%d) outside table size (%d)", newState, size)
-
-		case errorNewStateNoBits:
-			newState := decSymbol(ctx.errParam1)
-			oldState := decSymbol(ctx.errParam2)
-			return fmt.Errorf("newState (%d) == oldState (%d) and no bits", newState, oldState)
-
-		default:
-			return fmt.Errorf("buildDtable_asm returned unhandled nonzero code = %d", code)
-		}
-	}
-	return nil
-}
diff --git a/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.s b/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.s
deleted file mode 100644
index bcde3986..00000000
--- a/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.s
+++ /dev/null
@@ -1,126 +0,0 @@
-// Code generated by command: go run gen_fse.go -out ../fse_decoder_amd64.s -pkg=zstd. DO NOT EDIT.
-
-//go:build !appengine && !noasm && gc && !noasm
-
-// func buildDtable_asm(s *fseDecoder, ctx *buildDtableAsmContext) int
-TEXT ·buildDtable_asm(SB), $0-24
-	MOVQ ctx+8(FP), CX
-	MOVQ s+0(FP), DI
-
-	// Load values
-	MOVBQZX 4098(DI), DX
-	XORQ    AX, AX
-	BTSQ    DX, AX
-	MOVQ    (CX), BX
-	MOVQ    16(CX), SI
-	LEAQ    -1(AX), R8
-	MOVQ    8(CX), CX
-	MOVWQZX 4096(DI), DI
-
-	// End load values
-	// Init, lay down lowprob symbols
-	XORQ R9, R9
-	JMP  init_main_loop_condition
-
-init_main_loop:
-	MOVWQSX (CX)(R9*2), R10
-	CMPW    R10, $-1
-	JNE     do_not_update_high_threshold
-	MOVB    R9, 1(SI)(R8*8)
-	DECQ    R8
-	MOVQ    $0x0000000000000001, R10
-
-do_not_update_high_threshold:
-	MOVW R10, (BX)(R9*2)
-	INCQ R9
-
-init_main_loop_condition:
-	CMPQ R9, DI
-	JL   init_main_loop
-
-	// Spread symbols
-	// Calculate table step
-	MOVQ AX, R9
-	SHRQ $0x01, R9
-	MOVQ AX, R10
-	SHRQ $0x03, R10
-	LEAQ 3(R9)(R10*1), R9
-
-	// Fill add bits values
-	LEAQ -1(AX), R10
-	XORQ R11, R11
-	XORQ R12, R12
-	JMP  spread_main_loop_condition
-
-spread_main_loop:
-	XORQ    R13, R13
-	MOVWQSX (CX)(R12*2), R14
-	JMP     spread_inner_loop_condition
-
-spread_inner_loop:
-	MOVB R12, 1(SI)(R11*8)
-
-adjust_position:
-	ADDQ R9, R11
-	ANDQ R10, R11
-	CMPQ R11, R8
-	JG   adjust_position
-	INCQ R13
-
-spread_inner_loop_condition:
-	CMPQ R13, R14
-	JL   spread_inner_loop
-	INCQ R12
-
-spread_main_loop_condition:
-	CMPQ  R12, DI
-	JL    spread_main_loop
-	TESTQ R11, R11
-	JZ    spread_check_ok
-	MOVQ  ctx+8(FP), AX
-	MOVQ  R11, 24(AX)
-	MOVQ  $+1, ret+16(FP)
-	RET
-
-spread_check_ok:
-	// Build Decoding table
-	XORQ DI, DI
-
-build_table_main_table:
-	MOVBQZX 1(SI)(DI*8), CX
-	MOVWQZX (BX)(CX*2), R8
-	LEAQ    1(R8), R9
-	MOVW    R9, (BX)(CX*2)
-	MOVQ    R8, R9
-	BSRQ    R9, R9
-	MOVQ    DX, CX
-	SUBQ    R9, CX
-	SHLQ    CL, R8
-	SUBQ    AX, R8
-	MOVB    CL, (SI)(DI*8)
-	MOVW    R8, 2(SI)(DI*8)
-	CMPQ    R8, AX
-	JLE     build_table_check1_ok
-	MOVQ    ctx+8(FP), CX
-	MOVQ    R8, 24(CX)
-	MOVQ    AX, 32(CX)
-	MOVQ    $+2, ret+16(FP)
-	RET
-
-build_table_check1_ok:
-	TESTB CL, CL
-	JNZ   build_table_check2_ok
-	CMPW  R8, DI
-	JNE   build_table_check2_ok
-	MOVQ  ctx+8(FP), AX
-	MOVQ  R8, 24(AX)
-	MOVQ  DI, 32(AX)
-	MOVQ  $+3, ret+16(FP)
-	RET
-
-build_table_check2_ok:
-	INCQ DI
-	CMPQ DI, AX
-	JL   build_table_main_table
-	MOVQ $+0, ret+16(FP)
-	RET
diff --git a/vendor/github.com/klauspost/compress/zstd/fse_decoder_generic.go b/vendor/github.com/klauspost/compress/zstd/fse_decoder_generic.go
deleted file mode 100644
index 332e51fe..00000000
--- a/vendor/github.com/klauspost/compress/zstd/fse_decoder_generic.go
+++ /dev/null
@@ -1,72 +0,0 @@
-//go:build !amd64 || appengine || !gc || noasm
-// +build !amd64 appengine !gc noasm
-
-package zstd
-
-import (
-	"errors"
-	"fmt"
-)
-
-// buildDtable will build the decoding table.
-func (s *fseDecoder) buildDtable() error {
-	tableSize := uint32(1 << s.actualTableLog)
-	highThreshold := tableSize - 1
-	symbolNext := s.stateTable[:256]
-
-	// Init, lay down lowprob symbols
-	{
-		for i, v := range s.norm[:s.symbolLen] {
-			if v == -1 {
-				s.dt[highThreshold].setAddBits(uint8(i))
-				highThreshold--
-				symbolNext[i] = 1
-			} else {
-				symbolNext[i] = uint16(v)
-			}
-		}
-	}
-
-	// Spread symbols
-	{
-		tableMask := tableSize - 1
-		step := tableStep(tableSize)
-		position := uint32(0)
-		for ss, v := range s.norm[:s.symbolLen] {
-			for i := 0; i < int(v); i++ {
-				s.dt[position].setAddBits(uint8(ss))
-				position = (position + step) & tableMask
-				for position > highThreshold {
-					// lowprob area
-					position = (position + step) & tableMask
-				}
-			}
-		}
-		if position != 0 {
-			// position must reach all cells once, otherwise normalizedCounter is incorrect
-			return errors.New("corrupted input (position != 0)")
-		}
-	}
-
-	// Build Decoding table
-	{
-		tableSize := uint16(1 << s.actualTableLog)
-		for u, v := range s.dt[:tableSize] {
-			symbol := v.addBits()
-			nextState := symbolNext[symbol]
-			symbolNext[symbol] = nextState + 1
-			nBits := s.actualTableLog - byte(highBits(uint32(nextState)))
-			s.dt[u&maxTableMask].setNBits(nBits)
-			newState := (nextState << nBits) - tableSize
-			if newState > tableSize {
-				return fmt.Errorf("newState (%d) outside table size (%d)", newState, tableSize)
-			}
-			if newState == uint16(u) && nBits == 0 {
-				// Seems weird that this is possible with nbits > 0.
-				return fmt.Errorf("newState (%d) == oldState (%d) and no bits", newState, u)
-			}
-			s.dt[u&maxTableMask].setNewState(newState)
-		}
-	}
-	return nil
-}
diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_arm64.s b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_arm64.s
deleted file mode 100644
index 17901e08..00000000
--- a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_arm64.s
+++ /dev/null
@@ -1,184 +0,0 @@
-//go:build !appengine && gc && !purego && !noasm
-// +build !appengine
-// +build gc
-// +build !purego
-// +build !noasm
-
-#include "textflag.h"
-
-// Registers:
-#define digest	R1
-#define h	R2 // return value
-#define p	R3 // input pointer
-#define n	R4 // input length
-#define nblocks	R5 // n / 32
-#define prime1	R7
-#define prime2	R8
-#define prime3	R9
-#define prime4	R10
-#define prime5	R11
-#define v1	R12
-#define v2	R13
-#define v3	R14
-#define v4	R15
-#define x1	R20
-#define x2	R21
-#define x3	R22
-#define x4	R23
-
-#define round(acc, x) \
-	MADD prime2, acc, x, acc \
-	ROR  $64-31, acc         \
-	MUL  prime1, acc
-
-// round0 performs the operation x = round(0, x).
-#define round0(x) \
-	MUL prime2, x \
-	ROR $64-31, x \
-	MUL prime1, x
-
-#define mergeRound(acc, x) \
-	round0(x)                     \
-	EOR  x, acc                   \
-	MADD acc, prime4, prime1, acc
-
-// blockLoop processes as many 32-byte blocks as possible,
-// updating v1, v2, v3, and v4. It assumes that n >= 32.
-#define blockLoop() \
-	LSR     $5, n, nblocks  \
-	PCALIGN $16             \
-	loop:                   \
-	LDP.P   16(p), (x1, x2) \
-	LDP.P   16(p), (x3, x4) \
-	round(v1, x1)           \
-	round(v2, x2)           \
-	round(v3, x3)           \
-	round(v4, x4)           \
-	SUB     $1, nblocks     \
-	CBNZ    nblocks, loop
-
-// func Sum64(b []byte) uint64
-TEXT ·Sum64(SB), NOSPLIT|NOFRAME, $0-32
-	LDP b_base+0(FP), (p, n)
-
-	LDP  ·primes+0(SB), (prime1, prime2)
-	LDP  ·primes+16(SB), (prime3, prime4)
-	MOVD ·primes+32(SB), prime5
-
-	CMP  $32, n
-	CSEL LT, prime5, ZR, h // if n < 32 { h = prime5 } else { h = 0 }
-	BLT  afterLoop
-
-	ADD  prime1, prime2, v1
-	MOVD prime2, v2
-	MOVD $0, v3
-	NEG  prime1, v4
-
-	blockLoop()
-
-	ROR $64-1, v1, x1
-	ROR $64-7, v2, x2
-	ADD x1, x2
-	ROR $64-12, v3, x3
-	ROR $64-18, v4, x4
-	ADD x3, x4
-	ADD x2, x4, h
-
-	mergeRound(h, v1)
-	mergeRound(h, v2)
-	mergeRound(h, v3)
-	mergeRound(h, v4)
-
-afterLoop:
-	ADD n, h
-
-	TBZ   $4, n, try8
-	LDP.P 16(p), (x1, x2)
-
-	round0(x1)
-
-	// NOTE: here and below, sequencing the EOR after the ROR (using a
-	// rotated register) is worth a small but measurable speedup for small
-	// inputs.
-	ROR  $64-27, h
-	EOR  x1 @> 64-27, h, h
-	MADD h, prime4, prime1, h
-
-	round0(x2)
-	ROR  $64-27, h
-	EOR  x2 @> 64-27, h, h
-	MADD h, prime4, prime1, h
-
-try8:
-	TBZ    $3, n, try4
-	MOVD.P 8(p), x1
-
-	round0(x1)
-	ROR  $64-27, h
-	EOR  x1 @> 64-27, h, h
-	MADD h, prime4, prime1, h
-
-try4:
-	TBZ     $2, n, try2
-	MOVWU.P 4(p), x2
-
-	MUL  prime1, x2
-	ROR  $64-23, h
-	EOR  x2 @> 64-23, h, h
-	MADD h, prime3, prime2, h
-
-try2:
-	TBZ     $1, n, try1
-	MOVHU.P 2(p), x3
-	AND     $255, x3, x1
-	LSR     $8, x3, x2
-
-	MUL prime5, x1
-	ROR $64-11, h
-	EOR x1 @> 64-11, h, h
-	MUL prime1, h
-
-	MUL prime5, x2
-	ROR $64-11, h
-	EOR x2 @> 64-11, h, h
-	MUL prime1, h
-
-try1:
-	TBZ   $0, n, finalize
-	MOVBU (p), x4
-
-	MUL prime5, x4
-	ROR $64-11, h
-	EOR x4 @> 64-11, h, h
-	MUL prime1, h
-
-finalize:
-	EOR h >> 33, h
-	MUL prime2, h
-	EOR h >> 29, h
-	MUL prime3, h
-	EOR h >> 32, h
-
-	MOVD h, ret+24(FP)
-	RET
-
-// func writeBlocks(d *Digest, b []byte) int
-TEXT ·writeBlocks(SB), NOSPLIT|NOFRAME, $0-40
-	LDP ·primes+0(SB), (prime1, prime2)
-
-	// Load state. Assume v[1-4] are stored contiguously.
-	MOVD d+0(FP), digest
-	LDP  0(digest), (v1, v2)
-	LDP  16(digest), (v3, v4)
-
-	LDP b_base+8(FP), (p, n)
-
-	blockLoop()
-
-	// Store updated state.
-	STP (v1, v2), 0(digest)
-	STP (v3, v4), 16(digest)
-
-	BIC  $31, n
-	MOVD n, ret+32(FP)
-	RET
diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_asm.go b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_asm.go
deleted file mode 100644
index d4221edf..00000000
--- a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_asm.go
+++ /dev/null
@@ -1,16 +0,0 @@
-//go:build (amd64 || arm64) && !appengine && gc && !purego && !noasm
-// +build amd64 arm64
-// +build !appengine
-// +build gc
-// +build !purego
-// +build !noasm
-
-package xxhash
-
-// Sum64 computes the 64-bit xxHash digest of b.
-//
-//go:noescape
-func Sum64(b []byte) uint64
-
-//go:noescape
-func writeBlocks(s *Digest, b []byte) int
diff --git a/vendor/github.com/klauspost/compress/zstd/matchlen_amd64.go b/vendor/github.com/klauspost/compress/zstd/matchlen_amd64.go
deleted file mode 100644
index f41932b7..00000000
--- a/vendor/github.com/klauspost/compress/zstd/matchlen_amd64.go
+++ /dev/null
@@ -1,16 +0,0 @@
-//go:build amd64 && !appengine && !noasm && gc
-// +build amd64,!appengine,!noasm,gc
-
-// Copyright 2019+ Klaus Post. All rights reserved.
-// License information can be found in the LICENSE file.
-
-package zstd
-
-// matchLen returns how many bytes match in a and b
-//
-// It assumes that:
-//
-//	len(a) <= len(b) and len(a) > 0
-//
-//go:noescape
-func matchLen(a []byte, b []byte) int
diff --git a/vendor/github.com/klauspost/compress/zstd/matchlen_amd64.s b/vendor/github.com/klauspost/compress/zstd/matchlen_amd64.s
deleted file mode 100644
index 9a7655c0..00000000
--- a/vendor/github.com/klauspost/compress/zstd/matchlen_amd64.s
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copied from S2 implementation.
-
-//go:build !appengine && !noasm && gc && !noasm
-
-#include "textflag.h"
-
-// func matchLen(a []byte, b []byte) int
-// Requires: BMI
-TEXT ·matchLen(SB), NOSPLIT, $0-56
-	MOVQ a_base+0(FP), AX
-	MOVQ b_base+24(FP), CX
-	MOVQ a_len+8(FP), DX
-
-	// matchLen
-	XORL SI, SI
-	CMPL DX, $0x08
-	JB   matchlen_match4_standalone
-
-matchlen_loopback_standalone:
-	MOVQ  (AX)(SI*1), BX
-	XORQ  (CX)(SI*1), BX
-	TESTQ BX, BX
-	JZ    matchlen_loop_standalone
-
-#ifdef GOAMD64_v3
-	TZCNTQ BX, BX
-#else
-	BSFQ BX, BX
-#endif
-	SARQ $0x03, BX
-	LEAL (SI)(BX*1), SI
-	JMP  gen_match_len_end
-
-matchlen_loop_standalone:
-	LEAL -8(DX), DX
-	LEAL 8(SI), SI
-	CMPL DX, $0x08
-	JAE  matchlen_loopback_standalone
-
-matchlen_match4_standalone:
-	CMPL DX, $0x04
-	JB   matchlen_match2_standalone
-	MOVL (AX)(SI*1), BX
-	CMPL (CX)(SI*1), BX
-	JNE  matchlen_match2_standalone
-	LEAL -4(DX), DX
-	LEAL 4(SI), SI
-
-matchlen_match2_standalone:
-	CMPL DX, $0x02
-	JB   matchlen_match1_standalone
-	MOVW (AX)(SI*1), BX
-	CMPW (CX)(SI*1), BX
-	JNE  matchlen_match1_standalone
-	LEAL -2(DX), DX
-	LEAL 2(SI), SI
-
-matchlen_match1_standalone:
-	CMPL DX, $0x01
-	JB   gen_match_len_end
-	MOVB (AX)(SI*1), BL
-	CMPB (CX)(SI*1), BL
-	JNE  gen_match_len_end
-	INCL SI
-
-gen_match_len_end:
-	MOVQ SI, ret+48(FP)
-	RET
diff --git a/vendor/github.com/klauspost/compress/zstd/matchlen_generic.go b/vendor/github.com/klauspost/compress/zstd/matchlen_generic.go
deleted file mode 100644
index 57b9c31c..00000000
--- a/vendor/github.com/klauspost/compress/zstd/matchlen_generic.go
+++ /dev/null
@@ -1,33 +0,0 @@
-//go:build !amd64 || appengine || !gc || noasm
-// +build !amd64 appengine !gc noasm
-
-// Copyright 2019+ Klaus Post. All rights reserved.
-// License information can be found in the LICENSE file.
-
-package zstd
-
-import (
-	"encoding/binary"
-	"math/bits"
-)
-
-// matchLen returns the maximum common prefix length of a and b.
-// a must be the shortest of the two.
-func matchLen(a, b []byte) (n int) {
-	for ; len(a) >= 8 && len(b) >= 8; a, b = a[8:], b[8:] {
-		diff := binary.LittleEndian.Uint64(a) ^ binary.LittleEndian.Uint64(b)
-		if diff != 0 {
-			return n + bits.TrailingZeros64(diff)>>3
-		}
-		n += 8
-	}
-
-	for i := range a {
-		if a[i] != b[i] {
-			break
-		}
-		n++
-	}
-	return n
-
-}
diff --git a/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.go b/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.go
deleted file mode 100644
index 8adabd82..00000000
--- a/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.go
+++ /dev/null
@@ -1,394 +0,0 @@
-//go:build amd64 && !appengine && !noasm && gc
-// +build amd64,!appengine,!noasm,gc
-
-package zstd
-
-import (
-	"fmt"
-	"io"
-
-	"github.com/klauspost/compress/internal/cpuinfo"
-)
-
-type decodeSyncAsmContext struct {
-	llTable     []decSymbol
-	mlTable     []decSymbol
-	ofTable     []decSymbol
-	llState     uint64
-	mlState     uint64
-	ofState     uint64
-	iteration   int
-	litRemain   int
-	out         []byte
-	outPosition int
-	literals    []byte
-	litPosition int
-	history     []byte
-	windowSize  int
-	ll          int // set on error (not for all errors, please refer to _generate/gen.go)
-	ml          int // set on error (not for all errors, please refer to _generate/gen.go)
-	mo          int // set on error (not for all errors, please refer to _generate/gen.go)
-}
-
-// sequenceDecs_decodeSync_amd64 implements the main loop of sequenceDecs.decodeSync in x86 asm.
-//
-// Please refer to seqdec_generic.go for the reference implementation.
-//
-//go:noescape
-func sequenceDecs_decodeSync_amd64(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
-
-// sequenceDecs_decodeSync_bmi2 implements the main loop of sequenceDecs.decodeSync in x86 asm with BMI2 extensions.
-//
-//go:noescape
-func sequenceDecs_decodeSync_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
-
-// sequenceDecs_decodeSync_safe_amd64 does the same as above, but does not write more than output buffer.
-//
-//go:noescape
-func sequenceDecs_decodeSync_safe_amd64(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
-
-// sequenceDecs_decodeSync_safe_bmi2 does the same as above, but does not write more than output buffer.
-//
-//go:noescape
-func sequenceDecs_decodeSync_safe_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
-
-// decode sequences from the stream with the provided history but without a dictionary.
-func (s *sequenceDecs) decodeSyncSimple(hist []byte) (bool, error) {
-	if len(s.dict) > 0 {
-		return false, nil
-	}
-	if s.maxSyncLen == 0 && cap(s.out)-len(s.out) < maxCompressedBlockSize {
-		return false, nil
-	}
-
-	// FIXME: Using unsafe memory copies leads to rare, random crashes
-	// with fuzz testing. It is therefore disabled for now.
-	const useSafe = true
-	/*
-		useSafe := false
-		if s.maxSyncLen == 0 && cap(s.out)-len(s.out) < maxCompressedBlockSizeAlloc {
-			useSafe = true
-		}
-		if s.maxSyncLen > 0 && cap(s.out)-len(s.out)-compressedBlockOverAlloc < int(s.maxSyncLen) {
-			useSafe = true
-		}
-		if cap(s.literals) < len(s.literals)+compressedBlockOverAlloc {
-			useSafe = true
-		}
-	*/
-
-	br := s.br
-
-	maxBlockSize := maxCompressedBlockSize
-	if s.windowSize < maxBlockSize {
-		maxBlockSize = s.windowSize
-	}
-
-	ctx := decodeSyncAsmContext{
-		llTable:     s.litLengths.fse.dt[:maxTablesize],
-		mlTable:     s.matchLengths.fse.dt[:maxTablesize],
-		ofTable:     s.offsets.fse.dt[:maxTablesize],
-		llState:     uint64(s.litLengths.state.state),
-		mlState:     uint64(s.matchLengths.state.state),
-		ofState:     uint64(s.offsets.state.state),
-		iteration:   s.nSeqs - 1,
-		litRemain:   len(s.literals),
-		out:         s.out,
-		outPosition: len(s.out),
-		literals:    s.literals,
-		windowSize:  s.windowSize,
-		history:     hist,
-	}
-
-	s.seqSize = 0
-	startSize := len(s.out)
-
-	var errCode int
-	if cpuinfo.HasBMI2() {
-		if useSafe {
-			errCode = sequenceDecs_decodeSync_safe_bmi2(s, br, &ctx)
-		} else {
-			errCode = sequenceDecs_decodeSync_bmi2(s, br, &ctx)
-		}
-	} else {
-		if useSafe {
-			errCode = sequenceDecs_decodeSync_safe_amd64(s, br, &ctx)
-		} else {
-			errCode = sequenceDecs_decodeSync_amd64(s, br, &ctx)
-		}
-	}
-	switch errCode {
-	case noError:
-		break
-
-	case errorMatchLenOfsMismatch:
-		return true, fmt.Errorf("zero matchoff and matchlen (%d) > 0", ctx.ml)
-
-	case errorMatchLenTooBig:
-		return true, fmt.Errorf("match len (%d) bigger than max allowed length", ctx.ml)
-
-	case errorMatchOffTooBig:
-		return true, fmt.Errorf("match offset (%d) bigger than current history (%d)",
-			ctx.mo, ctx.outPosition+len(hist)-startSize)
-
-	case errorNotEnoughLiterals:
-		return true, fmt.Errorf("unexpected literal count, want %d bytes, but only %d is available",
-			ctx.ll, ctx.litRemain+ctx.ll)
-
-	case errorOverread:
-		return true, io.ErrUnexpectedEOF
-
-	case errorNotEnoughSpace:
-		size := ctx.outPosition + ctx.ll + ctx.ml
-		if debugDecoder {
-			println("msl:", s.maxSyncLen, "cap", cap(s.out), "bef:", startSize, "sz:", size-startSize, "mbs:", maxBlockSize, "outsz:", cap(s.out)-startSize)
-		}
-		return true, fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
-
-	default:
-		return true, fmt.Errorf("sequenceDecs_decode returned erronous code %d", errCode)
-	}
-
-	s.seqSize += ctx.litRemain
-	if s.seqSize > maxBlockSize {
-		return true, fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
-	}
-	err := br.close()
-	if err != nil {
-		printf("Closing sequences: %v, %+v\n", err, *br)
-		return true, err
-	}
-
-	s.literals = s.literals[ctx.litPosition:]
-	t := ctx.outPosition
-	s.out = s.out[:t]
-
-	// Add final literals
-	s.out = append(s.out, s.literals...)
-	if debugDecoder {
-		t += len(s.literals)
-		if t != len(s.out) {
-			panic(fmt.Errorf("length mismatch, want %d, got %d", len(s.out), t))
-		}
-	}
-
-	return true, nil
-}
-
-// --------------------------------------------------------------------------------
-
-type decodeAsmContext struct {
-	llTable   []decSymbol
-	mlTable   []decSymbol
-	ofTable   []decSymbol
-	llState   uint64
-	mlState   uint64
-	ofState   uint64
-	iteration int
-	seqs      []seqVals
-	litRemain int
-}
-
-const noError = 0
-
-// error reported when mo == 0 && ml > 0
-const errorMatchLenOfsMismatch = 1
-
-// error reported when ml > maxMatchLen
-const errorMatchLenTooBig = 2
-
-// error reported when mo > available history or mo > s.windowSize
-const errorMatchOffTooBig = 3
-
-// error reported when the sum of literal lengths exeeceds the literal buffer size
-const errorNotEnoughLiterals = 4
-
-// error reported when capacity of `out` is too small
-const errorNotEnoughSpace = 5
-
-// error reported when bits are overread.
-const errorOverread = 6
-
-// sequenceDecs_decode implements the main loop of sequenceDecs in x86 asm.
-//
-// Please refer to seqdec_generic.go for the reference implementation.
-//
-//go:noescape
-func sequenceDecs_decode_amd64(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
-
-// sequenceDecs_decode implements the main loop of sequenceDecs in x86 asm.
-//
-// Please refer to seqdec_generic.go for the reference implementation.
-//
-//go:noescape
-func sequenceDecs_decode_56_amd64(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
-
-// sequenceDecs_decode implements the main loop of sequenceDecs in x86 asm with BMI2 extensions.
-//
-//go:noescape
-func sequenceDecs_decode_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
-
-// sequenceDecs_decode implements the main loop of sequenceDecs in x86 asm with BMI2 extensions.
-//
-//go:noescape
-func sequenceDecs_decode_56_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
-
-// decode sequences from the stream without the provided history.
-func (s *sequenceDecs) decode(seqs []seqVals) error {
-	br := s.br
-
-	maxBlockSize := maxCompressedBlockSize
-	if s.windowSize < maxBlockSize {
-		maxBlockSize = s.windowSize
-	}
-
-	ctx := decodeAsmContext{
-		llTable:   s.litLengths.fse.dt[:maxTablesize],
-		mlTable:   s.matchLengths.fse.dt[:maxTablesize],
-		ofTable:   s.offsets.fse.dt[:maxTablesize],
-		llState:   uint64(s.litLengths.state.state),
-		mlState:   uint64(s.matchLengths.state.state),
-		ofState:   uint64(s.offsets.state.state),
-		seqs:      seqs,
-		iteration: len(seqs) - 1,
-		litRemain: len(s.literals),
-	}
-
-	if debugDecoder {
-		println("decode: decoding", len(seqs), "sequences", br.remain(), "bits remain on stream")
-	}
-
-	s.seqSize = 0
-	lte56bits := s.maxBits+s.offsets.fse.actualTableLog+s.matchLengths.fse.actualTableLog+s.litLengths.fse.actualTableLog <= 56
-	var errCode int
-	if cpuinfo.HasBMI2() {
-		if lte56bits {
-			errCode = sequenceDecs_decode_56_bmi2(s, br, &ctx)
-		} else {
-			errCode = sequenceDecs_decode_bmi2(s, br, &ctx)
-		}
-	} else {
-		if lte56bits {
-			errCode = sequenceDecs_decode_56_amd64(s, br, &ctx)
-		} else {
-			errCode = sequenceDecs_decode_amd64(s, br, &ctx)
-		}
-	}
-	if errCode != 0 {
-		i := len(seqs) - ctx.iteration - 1
-		switch errCode {
-		case errorMatchLenOfsMismatch:
-			ml := ctx.seqs[i].ml
-			return fmt.Errorf("zero matchoff and matchlen (%d) > 0", ml)
-
-		case errorMatchLenTooBig:
-			ml := ctx.seqs[i].ml
-			return fmt.Errorf("match len (%d) bigger than max allowed length", ml)
-
-		case errorNotEnoughLiterals:
-			ll := ctx.seqs[i].ll
-			return fmt.Errorf("unexpected literal count, want %d bytes, but only %d is available", ll, ctx.litRemain+ll)
-		case errorOverread:
-			return io.ErrUnexpectedEOF
-		}
-
-		return fmt.Errorf("sequenceDecs_decode_amd64 returned erronous code %d", errCode)
-	}
-
-	if ctx.litRemain < 0 {
-		return fmt.Errorf("literal count is too big: total available %d, total requested %d",
-			len(s.literals), len(s.literals)-ctx.litRemain)
-	}
-
-	s.seqSize += ctx.litRemain
-	if s.seqSize > maxBlockSize {
-		return fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
-	}
-	if debugDecoder {
-		println("decode: ", br.remain(), "bits remain on stream. code:", errCode)
-	}
-	err := br.close()
-	if err != nil {
-		printf("Closing sequences: %v, %+v\n", err, *br)
-	}
-	return err
-}
-
-// --------------------------------------------------------------------------------
-
-type executeAsmContext struct {
-	seqs        []seqVals
-	seqIndex    int
-	out         []byte
-	history     []byte
-	literals    []byte
-	outPosition int
-	litPosition int
-	windowSize  int
-}
-
-// sequenceDecs_executeSimple_amd64 implements the main loop of sequenceDecs.executeSimple in x86 asm.
-//
-// Returns false if a match offset is too big.
-//
-// Please refer to seqdec_generic.go for the reference implementation.
-//
-//go:noescape
-func sequenceDecs_executeSimple_amd64(ctx *executeAsmContext) bool
-
-// Same as above, but with safe memcopies
-//
-//go:noescape
-func sequenceDecs_executeSimple_safe_amd64(ctx *executeAsmContext) bool
-
-// executeSimple handles cases when dictionary is not used.
-func (s *sequenceDecs) executeSimple(seqs []seqVals, hist []byte) error {
-	// Ensure we have enough output size...
-	if len(s.out)+s.seqSize+compressedBlockOverAlloc > cap(s.out) {
-		addBytes := s.seqSize + len(s.out) + compressedBlockOverAlloc
-		s.out = append(s.out, make([]byte, addBytes)...)
-		s.out = s.out[:len(s.out)-addBytes]
-	}
-
-	if debugDecoder {
-		printf("Execute %d seqs with literals: %d into %d bytes\n", len(seqs), len(s.literals), s.seqSize)
-	}
-
-	var t = len(s.out)
-	out := s.out[:t+s.seqSize]
-
-	ctx := executeAsmContext{
-		seqs:        seqs,
-		seqIndex:    0,
-		out:         out,
-		history:     hist,
-		outPosition: t,
-		litPosition: 0,
-		literals:    s.literals,
-		windowSize:  s.windowSize,
-	}
-	var ok bool
-	if cap(s.literals) < len(s.literals)+compressedBlockOverAlloc {
-		ok = sequenceDecs_executeSimple_safe_amd64(&ctx)
-	} else {
-		ok = sequenceDecs_executeSimple_amd64(&ctx)
-	}
-	if !ok {
-		return fmt.Errorf("match offset (%d) bigger than current history (%d)",
-			seqs[ctx.seqIndex].mo, ctx.outPosition+len(hist))
-	}
-	s.literals = s.literals[ctx.litPosition:]
-	t = ctx.outPosition
-
-	// Add final literals
-	copy(out[t:], s.literals)
-	if debugDecoder {
-		t += len(s.literals)
-		if t != len(out) {
-			panic(fmt.Errorf("length mismatch, want %d, got %d, ss: %d", len(out), t, s.seqSize))
-		}
-	}
-	s.out = out
-
-	return nil
-}
diff --git a/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.s b/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.s
deleted file mode 100644
index b6f4ba6f..00000000
--- a/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.s
+++ /dev/null
@@ -1,4175 +0,0 @@
-// Code generated by command: go run gen.go -out ../seqdec_amd64.s -pkg=zstd. DO NOT EDIT.
-
-//go:build !appengine && !noasm && gc && !noasm
-
-// func sequenceDecs_decode_amd64(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
-// Requires: CMOV
-TEXT ·sequenceDecs_decode_amd64(SB), $8-32
-	MOVQ    br+8(FP), AX
-	MOVQ    32(AX), DX
-	MOVBQZX 40(AX), BX
-	MOVQ    24(AX), SI
-	MOVQ    (AX), AX
-	ADDQ    SI, AX
-	MOVQ    AX, (SP)
-	MOVQ    ctx+16(FP), AX
-	MOVQ    72(AX), DI
-	MOVQ    80(AX), R8
-	MOVQ    88(AX), R9
-	MOVQ    104(AX), R10
-	MOVQ    s+0(FP), AX
-	MOVQ    144(AX), R11
-	MOVQ    152(AX), R12
-	MOVQ    160(AX), R13
-
-sequenceDecs_decode_amd64_main_loop:
-	MOVQ (SP), R14
-
-	// Fill bitreader to have enough for the offset and match length.
-	CMPQ SI, $0x08
-	JL   sequenceDecs_decode_amd64_fill_byte_by_byte
-	MOVQ BX, AX
-	SHRQ $0x03, AX
-	SUBQ AX, R14
-	MOVQ (R14), DX
-	SUBQ AX, SI
-	ANDQ $0x07, BX
-	JMP  sequenceDecs_decode_amd64_fill_end
-
-sequenceDecs_decode_amd64_fill_byte_by_byte:
-	CMPQ    SI, $0x00
-	JLE     sequenceDecs_decode_amd64_fill_check_overread
-	CMPQ    BX, $0x07
-	JLE     sequenceDecs_decode_amd64_fill_end
-	SHLQ    $0x08, DX
-	SUBQ    $0x01, R14
-	SUBQ    $0x01, SI
-	SUBQ    $0x08, BX
-	MOVBQZX (R14), AX
-	ORQ     AX, DX
-	JMP     sequenceDecs_decode_amd64_fill_byte_by_byte
-
-sequenceDecs_decode_amd64_fill_check_overread:
-	CMPQ BX, $0x40
-	JA   error_overread
-
-sequenceDecs_decode_amd64_fill_end:
-	// Update offset
-	MOVQ  R9, AX
-	MOVQ  BX, CX
-	MOVQ  DX, R15
-	SHLQ  CL, R15
-	MOVB  AH, CL
-	SHRQ  $0x20, AX
-	TESTQ CX, CX
-	JZ    sequenceDecs_decode_amd64_of_update_zero
-	ADDQ  CX, BX
-	CMPQ  BX, $0x40
-	JA    sequenceDecs_decode_amd64_of_update_zero
-	CMPQ  CX, $0x40
-	JAE   sequenceDecs_decode_amd64_of_update_zero
-	NEGQ  CX
-	SHRQ  CL, R15
-	ADDQ  R15, AX
-
-sequenceDecs_decode_amd64_of_update_zero:
-	MOVQ AX, 16(R10)
-
-	// Update match length
-	MOVQ  R8, AX
-	MOVQ  BX, CX
-	MOVQ  DX, R15
-	SHLQ  CL, R15
-	MOVB  AH, CL
-	SHRQ  $0x20, AX
-	TESTQ CX, CX
-	JZ    sequenceDecs_decode_amd64_ml_update_zero
-	ADDQ  CX, BX
-	CMPQ  BX, $0x40
-	JA    sequenceDecs_decode_amd64_ml_update_zero
-	CMPQ  CX, $0x40
-	JAE   sequenceDecs_decode_amd64_ml_update_zero
-	NEGQ  CX
-	SHRQ  CL, R15
-	ADDQ  R15, AX
-
-sequenceDecs_decode_amd64_ml_update_zero:
-	MOVQ AX, 8(R10)
-
-	// Fill bitreader to have enough for the remaining
-	CMPQ SI, $0x08
-	JL   sequenceDecs_decode_amd64_fill_2_byte_by_byte
-	MOVQ BX, AX
-	SHRQ $0x03, AX
-	SUBQ AX, R14
-	MOVQ (R14), DX
-	SUBQ AX, SI
-	ANDQ $0x07, BX
-	JMP  sequenceDecs_decode_amd64_fill_2_end
-
-sequenceDecs_decode_amd64_fill_2_byte_by_byte:
-	CMPQ    SI, $0x00
-	JLE     sequenceDecs_decode_amd64_fill_2_check_overread
-	CMPQ    BX, $0x07
-	JLE     sequenceDecs_decode_amd64_fill_2_end
-	SHLQ    $0x08, DX
-	SUBQ    $0x01, R14
-	SUBQ    $0x01, SI
-	SUBQ    $0x08, BX
-	MOVBQZX (R14), AX
-	ORQ     AX, DX
-	JMP     sequenceDecs_decode_amd64_fill_2_byte_by_byte
-
-sequenceDecs_decode_amd64_fill_2_check_overread:
-	CMPQ BX, $0x40
-	JA   error_overread
-
-sequenceDecs_decode_amd64_fill_2_end:
-	// Update literal length
-	MOVQ  DI, AX
-	MOVQ  BX, CX
-	MOVQ  DX, R15
-	SHLQ  CL, R15
-	MOVB  AH, CL
-	SHRQ  $0x20, AX
-	TESTQ CX, CX
-	JZ    sequenceDecs_decode_amd64_ll_update_zero
-	ADDQ  CX, BX
-	CMPQ  BX, $0x40
-	JA    sequenceDecs_decode_amd64_ll_update_zero
-	CMPQ  CX, $0x40
-	JAE   sequenceDecs_decode_amd64_ll_update_zero
-	NEGQ  CX
-	SHRQ  CL, R15
-	ADDQ  R15, AX
-
-sequenceDecs_decode_amd64_ll_update_zero:
-	MOVQ AX, (R10)
-
-	// Fill bitreader for state updates
-	MOVQ    R14, (SP)
-	MOVQ    R9, AX
-	SHRQ    $0x08, AX
-	MOVBQZX AL, AX
-	MOVQ    ctx+16(FP), CX
-	CMPQ    96(CX), $0x00
-	JZ      sequenceDecs_decode_amd64_skip_update
-
-	// Update Literal Length State
-	MOVBQZX DI, R14
-	SHRQ    $0x10, DI
-	MOVWQZX DI, DI
-	LEAQ    (BX)(R14*1), CX
-	MOVQ    DX, R15
-	MOVQ    CX, BX
-	ROLQ    CL, R15
-	MOVL    $0x00000001, BP
-	MOVB    R14, CL
-	SHLL    CL, BP
-	DECL    BP
-	ANDQ    BP, R15
-	ADDQ    R15, DI
-
-	// Load ctx.llTable
-	MOVQ ctx+16(FP), CX
-	MOVQ (CX), CX
-	MOVQ (CX)(DI*8), DI
-
-	// Update Match Length State
-	MOVBQZX R8, R14
-	SHRQ    $0x10, R8
-	MOVWQZX R8, R8
-	LEAQ    (BX)(R14*1), CX
-	MOVQ    DX, R15
-	MOVQ    CX, BX
-	ROLQ    CL, R15
-	MOVL    $0x00000001, BP
-	MOVB    R14, CL
-	SHLL    CL, BP
-	DECL    BP
-	ANDQ    BP, R15
-	ADDQ    R15, R8
-
-	// Load ctx.mlTable
-	MOVQ ctx+16(FP), CX
-	MOVQ 24(CX), CX
-	MOVQ (CX)(R8*8), R8
-
-	// Update Offset State
-	MOVBQZX R9, R14
-	SHRQ    $0x10, R9
-	MOVWQZX R9, R9
-	LEAQ    (BX)(R14*1), CX
-	MOVQ    DX, R15
-	MOVQ    CX, BX
-	ROLQ    CL, R15
-	MOVL    $0x00000001, BP
-	MOVB    R14, CL
-	SHLL    CL, BP
-	DECL    BP
-	ANDQ    BP, R15
-	ADDQ    R15, R9
-
-	// Load ctx.ofTable
-	MOVQ ctx+16(FP), CX
-	MOVQ 48(CX), CX
-	MOVQ (CX)(R9*8), R9
-
-sequenceDecs_decode_amd64_skip_update:
-	// Adjust offset
-	MOVQ 16(R10), CX
-	CMPQ AX, $0x01
-	JBE  sequenceDecs_decode_amd64_adjust_offsetB_1_or_0
-	MOVQ R12, R13
-	MOVQ R11, R12
-	MOVQ CX, R11
-	JMP  sequenceDecs_decode_amd64_after_adjust
-
-sequenceDecs_decode_amd64_adjust_offsetB_1_or_0:
-	CMPQ (R10), $0x00000000
-	JNE  sequenceDecs_decode_amd64_adjust_offset_maybezero
-	INCQ CX
-	JMP  sequenceDecs_decode_amd64_adjust_offset_nonzero
-
-sequenceDecs_decode_amd64_adjust_offset_maybezero:
-	TESTQ CX, CX
-	JNZ   sequenceDecs_decode_amd64_adjust_offset_nonzero
-	MOVQ  R11, CX
-	JMP   sequenceDecs_decode_amd64_after_adjust
-
-sequenceDecs_decode_amd64_adjust_offset_nonzero:
-	CMPQ CX, $0x01
-	JB   sequenceDecs_decode_amd64_adjust_zero
-	JEQ  sequenceDecs_decode_amd64_adjust_one
-	CMPQ CX, $0x02
-	JA   sequenceDecs_decode_amd64_adjust_three
-	JMP  sequenceDecs_decode_amd64_adjust_two
-
-sequenceDecs_decode_amd64_adjust_zero:
-	MOVQ R11, AX
-	JMP  sequenceDecs_decode_amd64_adjust_test_temp_valid
-
-sequenceDecs_decode_amd64_adjust_one:
-	MOVQ R12, AX
-	JMP  sequenceDecs_decode_amd64_adjust_test_temp_valid
-
-sequenceDecs_decode_amd64_adjust_two:
-	MOVQ R13, AX
-	JMP  sequenceDecs_decode_amd64_adjust_test_temp_valid
-
-sequenceDecs_decode_amd64_adjust_three:
-	LEAQ -1(R11), AX
-
-sequenceDecs_decode_amd64_adjust_test_temp_valid:
-	TESTQ AX, AX
-	JNZ   sequenceDecs_decode_amd64_adjust_temp_valid
-	MOVQ  $0x00000001, AX
-
-sequenceDecs_decode_amd64_adjust_temp_valid:
-	CMPQ    CX, $0x01
-	CMOVQNE R12, R13
-	MOVQ    R11, R12
-	MOVQ    AX, R11
-	MOVQ    AX, CX
-
-sequenceDecs_decode_amd64_after_adjust:
-	MOVQ CX, 16(R10)
-
-	// Check values
-	MOVQ  8(R10), AX
-	MOVQ  (R10), R14
-	LEAQ  (AX)(R14*1), R15
-	MOVQ  s+0(FP), BP
-	ADDQ  R15, 256(BP)
-	MOVQ  ctx+16(FP), R15
-	SUBQ  R14, 128(R15)
-	JS    error_not_enough_literals
-	CMPQ  AX, $0x00020002
-	JA    sequenceDecs_decode_amd64_error_match_len_too_big
-	TESTQ CX, CX
-	JNZ   sequenceDecs_decode_amd64_match_len_ofs_ok
-	TESTQ AX, AX
-	JNZ   sequenceDecs_decode_amd64_error_match_len_ofs_mismatch
-
-sequenceDecs_decode_amd64_match_len_ofs_ok:
-	ADDQ $0x18, R10
-	MOVQ ctx+16(FP), AX
-	DECQ 96(AX)
-	JNS  sequenceDecs_decode_amd64_main_loop
-	MOVQ s+0(FP), AX
-	MOVQ R11, 144(AX)
-	MOVQ R12, 152(AX)
-	MOVQ R13, 160(AX)
-	MOVQ br+8(FP), AX
-	MOVQ DX, 32(AX)
-	MOVB BL, 40(AX)
-	MOVQ SI, 24(AX)
-
-	// Return success
-	MOVQ $0x00000000, ret+24(FP)
-	RET
-
-	// Return with match length error
-sequenceDecs_decode_amd64_error_match_len_ofs_mismatch:
-	MOVQ $0x00000001, ret+24(FP)
-	RET
-
-	// Return with match too long error
-sequenceDecs_decode_amd64_error_match_len_too_big:
-	MOVQ $0x00000002, ret+24(FP)
-	RET
-
-	// Return with match offset too long error
-	MOVQ $0x00000003, ret+24(FP)
-	RET
-
-	// Return with not enough literals error
-error_not_enough_literals:
-	MOVQ $0x00000004, ret+24(FP)
-	RET
-
-	// Return with overread error
-error_overread:
-	MOVQ $0x00000006, ret+24(FP)
-	RET
-
-// func sequenceDecs_decode_56_amd64(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
-// Requires: CMOV
-TEXT ·sequenceDecs_decode_56_amd64(SB), $8-32
-	MOVQ    br+8(FP), AX
-	MOVQ    32(AX), DX
-	MOVBQZX 40(AX), BX
-	MOVQ    24(AX), SI
-	MOVQ    (AX), AX
-	ADDQ    SI, AX
-	MOVQ    AX, (SP)
-	MOVQ    ctx+16(FP), AX
-	MOVQ    72(AX), DI
-	MOVQ    80(AX), R8
-	MOVQ    88(AX), R9
-	MOVQ    104(AX), R10
-	MOVQ    s+0(FP), AX
-	MOVQ    144(AX), R11
-	MOVQ    152(AX), R12
-	MOVQ    160(AX), R13
-
-sequenceDecs_decode_56_amd64_main_loop:
-	MOVQ (SP), R14
-
-	// Fill bitreader to have enough for the offset and match length.
-	CMPQ SI, $0x08
-	JL   sequenceDecs_decode_56_amd64_fill_byte_by_byte
-	MOVQ BX, AX
-	SHRQ $0x03, AX
-	SUBQ AX, R14
-	MOVQ (R14), DX
-	SUBQ AX, SI
-	ANDQ $0x07, BX
-	JMP  sequenceDecs_decode_56_amd64_fill_end
-
-sequenceDecs_decode_56_amd64_fill_byte_by_byte:
-	CMPQ    SI, $0x00
-	JLE     sequenceDecs_decode_56_amd64_fill_check_overread
-	CMPQ    BX, $0x07
-	JLE     sequenceDecs_decode_56_amd64_fill_end
-	SHLQ    $0x08, DX
-	SUBQ    $0x01, R14
-	SUBQ    $0x01, SI
-	SUBQ    $0x08, BX
-	MOVBQZX (R14), AX
-	ORQ     AX, DX
-	JMP     sequenceDecs_decode_56_amd64_fill_byte_by_byte
-
-sequenceDecs_decode_56_amd64_fill_check_overread:
-	CMPQ BX, $0x40
-	JA   error_overread
-
-sequenceDecs_decode_56_amd64_fill_end:
-	// Update offset
-	MOVQ  R9, AX
-	MOVQ  BX, CX
-	MOVQ  DX, R15
-	SHLQ  CL, R15
-	MOVB  AH, CL
-	SHRQ  $0x20, AX
-	TESTQ CX, CX
-	JZ    sequenceDecs_decode_56_amd64_of_update_zero
-	ADDQ  CX, BX
-	CMPQ  BX, $0x40
-	JA    sequenceDecs_decode_56_amd64_of_update_zero
-	CMPQ  CX, $0x40
-	JAE   sequenceDecs_decode_56_amd64_of_update_zero
-	NEGQ  CX
-	SHRQ  CL, R15
-	ADDQ  R15, AX
-
-sequenceDecs_decode_56_amd64_of_update_zero:
-	MOVQ AX, 16(R10)
-
-	// Update match length
-	MOVQ  R8, AX
-	MOVQ  BX, CX
-	MOVQ  DX, R15
-	SHLQ  CL, R15
-	MOVB  AH, CL
-	SHRQ  $0x20, AX
-	TESTQ CX, CX
-	JZ    sequenceDecs_decode_56_amd64_ml_update_zero
-	ADDQ  CX, BX
-	CMPQ  BX, $0x40
-	JA    sequenceDecs_decode_56_amd64_ml_update_zero
-	CMPQ  CX, $0x40
-	JAE   sequenceDecs_decode_56_amd64_ml_update_zero
-	NEGQ  CX
-	SHRQ  CL, R15
-	ADDQ  R15, AX
-
-sequenceDecs_decode_56_amd64_ml_update_zero:
-	MOVQ AX, 8(R10)
-
-	// Update literal length
-	MOVQ  DI, AX
-	MOVQ  BX, CX
-	MOVQ  DX, R15
-	SHLQ  CL, R15
-	MOVB  AH, CL
-	SHRQ  $0x20, AX
-	TESTQ CX, CX
-	JZ    sequenceDecs_decode_56_amd64_ll_update_zero
-	ADDQ  CX, BX
-	CMPQ  BX, $0x40
-	JA    sequenceDecs_decode_56_amd64_ll_update_zero
-	CMPQ  CX, $0x40
-	JAE   sequenceDecs_decode_56_amd64_ll_update_zero
-	NEGQ  CX
-	SHRQ  CL, R15
-	ADDQ  R15, AX
-
-sequenceDecs_decode_56_amd64_ll_update_zero:
-	MOVQ AX, (R10)
-
-	// Fill bitreader for state updates
-	MOVQ    R14, (SP)
-	MOVQ    R9, AX
-	SHRQ    $0x08, AX
-	MOVBQZX AL, AX
-	MOVQ    ctx+16(FP), CX
-	CMPQ    96(CX), $0x00
-	JZ      sequenceDecs_decode_56_amd64_skip_update
-
-	// Update Literal Length State
-	MOVBQZX DI, R14
-	SHRQ    $0x10, DI
-	MOVWQZX DI, DI
-	LEAQ    (BX)(R14*1), CX
-	MOVQ    DX, R15
-	MOVQ    CX, BX
-	ROLQ    CL, R15
-	MOVL    $0x00000001, BP
-	MOVB    R14, CL
-	SHLL    CL, BP
-	DECL    BP
-	ANDQ    BP, R15
-	ADDQ    R15, DI
-
-	// Load ctx.llTable
-	MOVQ ctx+16(FP), CX
-	MOVQ (CX), CX
-	MOVQ (CX)(DI*8), DI
-
-	// Update Match Length State
-	MOVBQZX R8, R14
-	SHRQ    $0x10, R8
-	MOVWQZX R8, R8
-	LEAQ    (BX)(R14*1), CX
-	MOVQ    DX, R15
-	MOVQ    CX, BX
-	ROLQ    CL, R15
-	MOVL    $0x00000001, BP
-	MOVB    R14, CL
-	SHLL    CL, BP
-	DECL    BP
-	ANDQ    BP, R15
-	ADDQ    R15, R8
-
-	// Load ctx.mlTable
-	MOVQ ctx+16(FP), CX
-	MOVQ 24(CX), CX
-	MOVQ (CX)(R8*8), R8
-
-	// Update Offset State
-	MOVBQZX R9, R14
-	SHRQ    $0x10, R9
-	MOVWQZX R9, R9
-	LEAQ    (BX)(R14*1), CX
-	MOVQ    DX, R15
-	MOVQ    CX, BX
-	ROLQ    CL, R15
-	MOVL    $0x00000001, BP
-	MOVB    R14, CL
-	SHLL    CL, BP
-	DECL    BP
-	ANDQ    BP, R15
-	ADDQ    R15, R9
-
-	// Load ctx.ofTable
-	MOVQ ctx+16(FP), CX
-	MOVQ 48(CX), CX
-	MOVQ (CX)(R9*8), R9
-
-sequenceDecs_decode_56_amd64_skip_update:
-	// Adjust offset
-	MOVQ 16(R10), CX
-	CMPQ AX, $0x01
-	JBE  sequenceDecs_decode_56_amd64_adjust_offsetB_1_or_0
-	MOVQ R12, R13
-	MOVQ R11, R12
-	MOVQ CX, R11
-	JMP  sequenceDecs_decode_56_amd64_after_adjust
-
-sequenceDecs_decode_56_amd64_adjust_offsetB_1_or_0:
-	CMPQ (R10), $0x00000000
-	JNE  sequenceDecs_decode_56_amd64_adjust_offset_maybezero
-	INCQ CX
-	JMP  sequenceDecs_decode_56_amd64_adjust_offset_nonzero
-
-sequenceDecs_decode_56_amd64_adjust_offset_maybezero:
-	TESTQ CX, CX
-	JNZ   sequenceDecs_decode_56_amd64_adjust_offset_nonzero
-	MOVQ  R11, CX
-	JMP   sequenceDecs_decode_56_amd64_after_adjust
-
-sequenceDecs_decode_56_amd64_adjust_offset_nonzero:
-	CMPQ CX, $0x01
-	JB   sequenceDecs_decode_56_amd64_adjust_zero
-	JEQ  sequenceDecs_decode_56_amd64_adjust_one
-	CMPQ CX, $0x02
-	JA   sequenceDecs_decode_56_amd64_adjust_three
-	JMP  sequenceDecs_decode_56_amd64_adjust_two
-
-sequenceDecs_decode_56_amd64_adjust_zero:
-	MOVQ R11, AX
-	JMP  sequenceDecs_decode_56_amd64_adjust_test_temp_valid
-
-sequenceDecs_decode_56_amd64_adjust_one:
-	MOVQ R12, AX
-	JMP  sequenceDecs_decode_56_amd64_adjust_test_temp_valid
-
-sequenceDecs_decode_56_amd64_adjust_two:
-	MOVQ R13, AX
-	JMP  sequenceDecs_decode_56_amd64_adjust_test_temp_valid
-
-sequenceDecs_decode_56_amd64_adjust_three:
-	LEAQ -1(R11), AX
-
-sequenceDecs_decode_56_amd64_adjust_test_temp_valid:
-	TESTQ AX, AX
-	JNZ   sequenceDecs_decode_56_amd64_adjust_temp_valid
-	MOVQ  $0x00000001, AX
-
-sequenceDecs_decode_56_amd64_adjust_temp_valid:
-	CMPQ    CX, $0x01
-	CMOVQNE R12, R13
-	MOVQ    R11, R12
-	MOVQ    AX, R11
-	MOVQ    AX, CX
-
-sequenceDecs_decode_56_amd64_after_adjust:
-	MOVQ CX, 16(R10)
-
-	// Check values
-	MOVQ  8(R10), AX
-	MOVQ  (R10), R14
-	LEAQ  (AX)(R14*1), R15
-	MOVQ  s+0(FP), BP
-	ADDQ  R15, 256(BP)
-	MOVQ  ctx+16(FP), R15
-	SUBQ  R14, 128(R15)
-	JS    error_not_enough_literals
-	CMPQ  AX, $0x00020002
-	JA    sequenceDecs_decode_56_amd64_error_match_len_too_big
-	TESTQ CX, CX
-	JNZ   sequenceDecs_decode_56_amd64_match_len_ofs_ok
-	TESTQ AX, AX
-	JNZ   sequenceDecs_decode_56_amd64_error_match_len_ofs_mismatch
-
-sequenceDecs_decode_56_amd64_match_len_ofs_ok:
-	ADDQ $0x18, R10
-	MOVQ ctx+16(FP), AX
-	DECQ 96(AX)
-	JNS  sequenceDecs_decode_56_amd64_main_loop
-	MOVQ s+0(FP), AX
-	MOVQ R11, 144(AX)
-	MOVQ R12, 152(AX)
-	MOVQ R13, 160(AX)
-	MOVQ br+8(FP), AX
-	MOVQ DX, 32(AX)
-	MOVB BL, 40(AX)
-	MOVQ SI, 24(AX)
-
-	// Return success
-	MOVQ $0x00000000, ret+24(FP)
-	RET
-
-	// Return with match length error
-sequenceDecs_decode_56_amd64_error_match_len_ofs_mismatch:
-	MOVQ $0x00000001, ret+24(FP)
-	RET
-
-	// Return with match too long error
-sequenceDecs_decode_56_amd64_error_match_len_too_big:
-	MOVQ $0x00000002, ret+24(FP)
-	RET
-
-	// Return with match offset too long error
-	MOVQ $0x00000003, ret+24(FP)
-	RET
-
-	// Return with not enough literals error
-error_not_enough_literals:
-	MOVQ $0x00000004, ret+24(FP)
-	RET
-
-	// Return with overread error
-error_overread:
-	MOVQ $0x00000006, ret+24(FP)
-	RET
-
-// func sequenceDecs_decode_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
-// Requires: BMI, BMI2, CMOV
-TEXT ·sequenceDecs_decode_bmi2(SB), $8-32
-	MOVQ    br+8(FP), CX
-	MOVQ    32(CX), AX
-	MOVBQZX 40(CX), DX
-	MOVQ    24(CX), BX
-	MOVQ    (CX), CX
-	ADDQ    BX, CX
-	MOVQ    CX, (SP)
-	MOVQ    ctx+16(FP), CX
-	MOVQ    72(CX), SI
-	MOVQ    80(CX), DI
-	MOVQ    88(CX), R8
-	MOVQ    104(CX), R9
-	MOVQ    s+0(FP), CX
-	MOVQ    144(CX), R10
-	MOVQ    152(CX), R11
-	MOVQ    160(CX), R12
-
-sequenceDecs_decode_bmi2_main_loop:
-	MOVQ (SP), R13
-
-	// Fill bitreader to have enough for the offset and match length.
-	CMPQ BX, $0x08
-	JL   sequenceDecs_decode_bmi2_fill_byte_by_byte
-	MOVQ DX, CX
-	SHRQ $0x03, CX
-	SUBQ CX, R13
-	MOVQ (R13), AX
-	SUBQ CX, BX
-	ANDQ $0x07, DX
-	JMP  sequenceDecs_decode_bmi2_fill_end
-
-sequenceDecs_decode_bmi2_fill_byte_by_byte:
-	CMPQ    BX, $0x00
-	JLE     sequenceDecs_decode_bmi2_fill_check_overread
-	CMPQ    DX, $0x07
-	JLE     sequenceDecs_decode_bmi2_fill_end
-	SHLQ    $0x08, AX
-	SUBQ    $0x01, R13
-	SUBQ    $0x01, BX
-	SUBQ    $0x08, DX
-	MOVBQZX (R13), CX
-	ORQ     CX, AX
-	JMP     sequenceDecs_decode_bmi2_fill_byte_by_byte
-
-sequenceDecs_decode_bmi2_fill_check_overread:
-	CMPQ DX, $0x40
-	JA   error_overread
-
-sequenceDecs_decode_bmi2_fill_end:
-	// Update offset
-	MOVQ   $0x00000808, CX
-	BEXTRQ CX, R8, R14
-	MOVQ   AX, R15
-	LEAQ   (DX)(R14*1), CX
-	ROLQ   CL, R15
-	BZHIQ  R14, R15, R15
-	MOVQ   CX, DX
-	MOVQ   R8, CX
-	SHRQ   $0x20, CX
-	ADDQ   R15, CX
-	MOVQ   CX, 16(R9)
-
-	// Update match length
-	MOVQ   $0x00000808, CX
-	BEXTRQ CX, DI, R14
-	MOVQ   AX, R15
-	LEAQ   (DX)(R14*1), CX
-	ROLQ   CL, R15
-	BZHIQ  R14, R15, R15
-	MOVQ   CX, DX
-	MOVQ   DI, CX
-	SHRQ   $0x20, CX
-	ADDQ   R15, CX
-	MOVQ   CX, 8(R9)
-
-	// Fill bitreader to have enough for the remaining
-	CMPQ BX, $0x08
-	JL   sequenceDecs_decode_bmi2_fill_2_byte_by_byte
-	MOVQ DX, CX
-	SHRQ $0x03, CX
-	SUBQ CX, R13
-	MOVQ (R13), AX
-	SUBQ CX, BX
-	ANDQ $0x07, DX
-	JMP  sequenceDecs_decode_bmi2_fill_2_end
-
-sequenceDecs_decode_bmi2_fill_2_byte_by_byte:
-	CMPQ    BX, $0x00
-	JLE     sequenceDecs_decode_bmi2_fill_2_check_overread
-	CMPQ    DX, $0x07
-	JLE     sequenceDecs_decode_bmi2_fill_2_end
-	SHLQ    $0x08, AX
-	SUBQ    $0x01, R13
-	SUBQ    $0x01, BX
-	SUBQ    $0x08, DX
-	MOVBQZX (R13), CX
-	ORQ     CX, AX
-	JMP     sequenceDecs_decode_bmi2_fill_2_byte_by_byte
-
-sequenceDecs_decode_bmi2_fill_2_check_overread:
-	CMPQ DX, $0x40
-	JA   error_overread
-
-sequenceDecs_decode_bmi2_fill_2_end:
-	// Update literal length
-	MOVQ   $0x00000808, CX
-	BEXTRQ CX, SI, R14
-	MOVQ   AX, R15
-	LEAQ   (DX)(R14*1), CX
-	ROLQ   CL, R15
-	BZHIQ  R14, R15, R15
-	MOVQ   CX, DX
-	MOVQ   SI, CX
-	SHRQ   $0x20, CX
-	ADDQ   R15, CX
-	MOVQ   CX, (R9)
-
-	// Fill bitreader for state updates
-	MOVQ    R13, (SP)
-	MOVQ    $0x00000808, CX
-	BEXTRQ  CX, R8, R13
-	MOVQ    ctx+16(FP), CX
-	CMPQ    96(CX), $0x00
-	JZ      sequenceDecs_decode_bmi2_skip_update
-	LEAQ    (SI)(DI*1), R14
-	ADDQ    R8, R14
-	MOVBQZX R14, R14
-	LEAQ    (DX)(R14*1), CX
-	MOVQ    AX, R15
-	MOVQ    CX, DX
-	ROLQ    CL, R15
-	BZHIQ   R14, R15, R15
-
-	// Update Offset State
-	BZHIQ  R8, R15, CX
-	SHRXQ  R8, R15, R15
-	MOVQ   $0x00001010, R14
-	BEXTRQ R14, R8, R8
-	ADDQ   CX, R8
-
-	// Load ctx.ofTable
-	MOVQ ctx+16(FP), CX
-	MOVQ 48(CX), CX
-	MOVQ (CX)(R8*8), R8
-
-	// Update Match Length State
-	BZHIQ  DI, R15, CX
-	SHRXQ  DI, R15, R15
-	MOVQ   $0x00001010, R14
-	BEXTRQ R14, DI, DI
-	ADDQ   CX, DI
-
-	// Load ctx.mlTable
-	MOVQ ctx+16(FP), CX
-	MOVQ 24(CX), CX
-	MOVQ (CX)(DI*8), DI
-
-	// Update Literal Length State
-	BZHIQ  SI, R15, CX
-	MOVQ   $0x00001010, R14
-	BEXTRQ R14, SI, SI
-	ADDQ   CX, SI
-
-	// Load ctx.llTable
-	MOVQ ctx+16(FP), CX
-	MOVQ (CX), CX
-	MOVQ (CX)(SI*8), SI
-
-sequenceDecs_decode_bmi2_skip_update:
-	// Adjust offset
-	MOVQ 16(R9), CX
-	CMPQ R13, $0x01
-	JBE  sequenceDecs_decode_bmi2_adjust_offsetB_1_or_0
-	MOVQ R11, R12
-	MOVQ R10, R11
-	MOVQ CX, R10
-	JMP  sequenceDecs_decode_bmi2_after_adjust
-
-sequenceDecs_decode_bmi2_adjust_offsetB_1_or_0:
-	CMPQ (R9), $0x00000000
-	JNE  sequenceDecs_decode_bmi2_adjust_offset_maybezero
-	INCQ CX
-	JMP  sequenceDecs_decode_bmi2_adjust_offset_nonzero
-
-sequenceDecs_decode_bmi2_adjust_offset_maybezero:
-	TESTQ CX, CX
-	JNZ   sequenceDecs_decode_bmi2_adjust_offset_nonzero
-	MOVQ  R10, CX
-	JMP   sequenceDecs_decode_bmi2_after_adjust
-
-sequenceDecs_decode_bmi2_adjust_offset_nonzero:
-	CMPQ CX, $0x01
-	JB   sequenceDecs_decode_bmi2_adjust_zero
-	JEQ  sequenceDecs_decode_bmi2_adjust_one
-	CMPQ CX, $0x02
-	JA   sequenceDecs_decode_bmi2_adjust_three
-	JMP  sequenceDecs_decode_bmi2_adjust_two
-
-sequenceDecs_decode_bmi2_adjust_zero:
-	MOVQ R10, R13
-	JMP  sequenceDecs_decode_bmi2_adjust_test_temp_valid
-
-sequenceDecs_decode_bmi2_adjust_one:
-	MOVQ R11, R13
-	JMP  sequenceDecs_decode_bmi2_adjust_test_temp_valid
-
-sequenceDecs_decode_bmi2_adjust_two:
-	MOVQ R12, R13
-	JMP  sequenceDecs_decode_bmi2_adjust_test_temp_valid
-
-sequenceDecs_decode_bmi2_adjust_three:
-	LEAQ -1(R10), R13
-
-sequenceDecs_decode_bmi2_adjust_test_temp_valid:
-	TESTQ R13, R13
-	JNZ   sequenceDecs_decode_bmi2_adjust_temp_valid
-	MOVQ  $0x00000001, R13
-
-sequenceDecs_decode_bmi2_adjust_temp_valid:
-	CMPQ    CX, $0x01
-	CMOVQNE R11, R12
-	MOVQ    R10, R11
-	MOVQ    R13, R10
-	MOVQ    R13, CX
-
-sequenceDecs_decode_bmi2_after_adjust:
-	MOVQ CX, 16(R9)
-
-	// Check values
-	MOVQ  8(R9), R13
-	MOVQ  (R9), R14
-	LEAQ  (R13)(R14*1), R15
-	MOVQ  s+0(FP), BP
-	ADDQ  R15, 256(BP)
-	MOVQ  ctx+16(FP), R15
-	SUBQ  R14, 128(R15)
-	JS    error_not_enough_literals
-	CMPQ  R13, $0x00020002
-	JA    sequenceDecs_decode_bmi2_error_match_len_too_big
-	TESTQ CX, CX
-	JNZ   sequenceDecs_decode_bmi2_match_len_ofs_ok
-	TESTQ R13, R13
-	JNZ   sequenceDecs_decode_bmi2_error_match_len_ofs_mismatch
-
-sequenceDecs_decode_bmi2_match_len_ofs_ok:
-	ADDQ $0x18, R9
-	MOVQ ctx+16(FP), CX
-	DECQ 96(CX)
-	JNS  sequenceDecs_decode_bmi2_main_loop
-	MOVQ s+0(FP), CX
-	MOVQ R10, 144(CX)
-	MOVQ R11, 152(CX)
-	MOVQ R12, 160(CX)
-	MOVQ br+8(FP), CX
-	MOVQ AX, 32(CX)
-	MOVB DL, 40(CX)
-	MOVQ BX, 24(CX)
-
-	// Return success
-	MOVQ $0x00000000, ret+24(FP)
-	RET
-
-	// Return with match length error
-sequenceDecs_decode_bmi2_error_match_len_ofs_mismatch:
-	MOVQ $0x00000001, ret+24(FP)
-	RET
-
-	// Return with match too long error
-sequenceDecs_decode_bmi2_error_match_len_too_big:
-	MOVQ $0x00000002, ret+24(FP)
-	RET
-
-	// Return with match offset too long error
-	MOVQ $0x00000003, ret+24(FP)
-	RET
-
-	// Return with not enough literals error
-error_not_enough_literals:
-	MOVQ $0x00000004, ret+24(FP)
-	RET
-
-	// Return with overread error
-error_overread:
-	MOVQ $0x00000006, ret+24(FP)
-	RET
-
-// func sequenceDecs_decode_56_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
-// Requires: BMI, BMI2, CMOV
-TEXT ·sequenceDecs_decode_56_bmi2(SB), $8-32
-	MOVQ    br+8(FP), CX
-	MOVQ    32(CX), AX
-	MOVBQZX 40(CX), DX
-	MOVQ    24(CX), BX
-	MOVQ    (CX), CX
-	ADDQ    BX, CX
-	MOVQ    CX, (SP)
-	MOVQ    ctx+16(FP), CX
-	MOVQ    72(CX), SI
-	MOVQ    80(CX), DI
-	MOVQ    88(CX), R8
-	MOVQ    104(CX), R9
-	MOVQ    s+0(FP), CX
-	MOVQ    144(CX), R10
-	MOVQ    152(CX), R11
-	MOVQ    160(CX), R12
-
-sequenceDecs_decode_56_bmi2_main_loop:
-	MOVQ (SP), R13
-
-	// Fill bitreader to have enough for the offset and match length.
-	CMPQ BX, $0x08
-	JL   sequenceDecs_decode_56_bmi2_fill_byte_by_byte
-	MOVQ DX, CX
-	SHRQ $0x03, CX
-	SUBQ CX, R13
-	MOVQ (R13), AX
-	SUBQ CX, BX
-	ANDQ $0x07, DX
-	JMP  sequenceDecs_decode_56_bmi2_fill_end
-
-sequenceDecs_decode_56_bmi2_fill_byte_by_byte:
-	CMPQ    BX, $0x00
-	JLE     sequenceDecs_decode_56_bmi2_fill_check_overread
-	CMPQ    DX, $0x07
-	JLE     sequenceDecs_decode_56_bmi2_fill_end
-	SHLQ    $0x08, AX
-	SUBQ    $0x01, R13
-	SUBQ    $0x01, BX
-	SUBQ    $0x08, DX
-	MOVBQZX (R13), CX
-	ORQ     CX, AX
-	JMP     sequenceDecs_decode_56_bmi2_fill_byte_by_byte
-
-sequenceDecs_decode_56_bmi2_fill_check_overread:
-	CMPQ DX, $0x40
-	JA   error_overread
-
-sequenceDecs_decode_56_bmi2_fill_end:
-	// Update offset
-	MOVQ   $0x00000808, CX
-	BEXTRQ CX, R8, R14
-	MOVQ   AX, R15
-	LEAQ   (DX)(R14*1), CX
-	ROLQ   CL, R15
-	BZHIQ  R14, R15, R15
-	MOVQ   CX, DX
-	MOVQ   R8, CX
-	SHRQ   $0x20, CX
-	ADDQ   R15, CX
-	MOVQ   CX, 16(R9)
-
-	// Update match length
-	MOVQ   $0x00000808, CX
-	BEXTRQ CX, DI, R14
-	MOVQ   AX, R15
-	LEAQ   (DX)(R14*1), CX
-	ROLQ   CL, R15
-	BZHIQ  R14, R15, R15
-	MOVQ   CX, DX
-	MOVQ   DI, CX
-	SHRQ   $0x20, CX
-	ADDQ   R15, CX
-	MOVQ   CX, 8(R9)
-
-	// Update literal length
-	MOVQ   $0x00000808, CX
-	BEXTRQ CX, SI, R14
-	MOVQ   AX, R15
-	LEAQ   (DX)(R14*1), CX
-	ROLQ   CL, R15
-	BZHIQ  R14, R15, R15
-	MOVQ   CX, DX
-	MOVQ   SI, CX
-	SHRQ   $0x20, CX
-	ADDQ   R15, CX
-	MOVQ   CX, (R9)
-
-	// Fill bitreader for state updates
-	MOVQ    R13, (SP)
-	MOVQ    $0x00000808, CX
-	BEXTRQ  CX, R8, R13
-	MOVQ    ctx+16(FP), CX
-	CMPQ    96(CX), $0x00
-	JZ      sequenceDecs_decode_56_bmi2_skip_update
-	LEAQ    (SI)(DI*1), R14
-	ADDQ    R8, R14
-	MOVBQZX R14, R14
-	LEAQ    (DX)(R14*1), CX
-	MOVQ    AX, R15
-	MOVQ    CX, DX
-	ROLQ    CL, R15
-	BZHIQ   R14, R15, R15
-
-	// Update Offset State
-	BZHIQ  R8, R15, CX
-	SHRXQ  R8, R15, R15
-	MOVQ   $0x00001010, R14
-	BEXTRQ R14, R8, R8
-	ADDQ   CX, R8
-
-	// Load ctx.ofTable
-	MOVQ ctx+16(FP), CX
-	MOVQ 48(CX), CX
-	MOVQ (CX)(R8*8), R8
-
-	// Update Match Length State
-	BZHIQ  DI, R15, CX
-	SHRXQ  DI, R15, R15
-	MOVQ   $0x00001010, R14
-	BEXTRQ R14, DI, DI
-	ADDQ   CX, DI
-
-	// Load ctx.mlTable
-	MOVQ ctx+16(FP), CX
-	MOVQ 24(CX), CX
-	MOVQ (CX)(DI*8), DI
-
-	// Update Literal Length State
-	BZHIQ  SI, R15, CX
-	MOVQ   $0x00001010, R14
-	BEXTRQ R14, SI, SI
-	ADDQ   CX, SI
-
-	// Load ctx.llTable
-	MOVQ ctx+16(FP), CX
-	MOVQ (CX), CX
-	MOVQ (CX)(SI*8), SI
-
-sequenceDecs_decode_56_bmi2_skip_update:
-	// Adjust offset
-	MOVQ 16(R9), CX
-	CMPQ R13, $0x01
-	JBE  sequenceDecs_decode_56_bmi2_adjust_offsetB_1_or_0
-	MOVQ R11, R12
-	MOVQ R10, R11
-	MOVQ CX, R10
-	JMP  sequenceDecs_decode_56_bmi2_after_adjust
-
-sequenceDecs_decode_56_bmi2_adjust_offsetB_1_or_0:
-	CMPQ (R9), $0x00000000
-	JNE  sequenceDecs_decode_56_bmi2_adjust_offset_maybezero
-	INCQ CX
-	JMP  sequenceDecs_decode_56_bmi2_adjust_offset_nonzero
-
-sequenceDecs_decode_56_bmi2_adjust_offset_maybezero:
-	TESTQ CX, CX
-	JNZ   sequenceDecs_decode_56_bmi2_adjust_offset_nonzero
-	MOVQ  R10, CX
-	JMP   sequenceDecs_decode_56_bmi2_after_adjust
-
-sequenceDecs_decode_56_bmi2_adjust_offset_nonzero:
-	CMPQ CX, $0x01
-	JB   sequenceDecs_decode_56_bmi2_adjust_zero
-	JEQ  sequenceDecs_decode_56_bmi2_adjust_one
-	CMPQ CX, $0x02
-	JA   sequenceDecs_decode_56_bmi2_adjust_three
-	JMP  sequenceDecs_decode_56_bmi2_adjust_two
-
-sequenceDecs_decode_56_bmi2_adjust_zero:
-	MOVQ R10, R13
-	JMP  sequenceDecs_decode_56_bmi2_adjust_test_temp_valid
-
-sequenceDecs_decode_56_bmi2_adjust_one:
-	MOVQ R11, R13
-	JMP  sequenceDecs_decode_56_bmi2_adjust_test_temp_valid
-
-sequenceDecs_decode_56_bmi2_adjust_two:
-	MOVQ R12, R13
-	JMP  sequenceDecs_decode_56_bmi2_adjust_test_temp_valid
-
-sequenceDecs_decode_56_bmi2_adjust_three:
-	LEAQ -1(R10), R13
-
-sequenceDecs_decode_56_bmi2_adjust_test_temp_valid:
-	TESTQ R13, R13
-	JNZ   sequenceDecs_decode_56_bmi2_adjust_temp_valid
-	MOVQ  $0x00000001, R13
-
-sequenceDecs_decode_56_bmi2_adjust_temp_valid:
-	CMPQ    CX, $0x01
-	CMOVQNE R11, R12
-	MOVQ    R10, R11
-	MOVQ    R13, R10
-	MOVQ    R13, CX
-
-sequenceDecs_decode_56_bmi2_after_adjust:
-	MOVQ CX, 16(R9)
-
-	// Check values
-	MOVQ  8(R9), R13
-	MOVQ  (R9), R14
-	LEAQ  (R13)(R14*1), R15
-	MOVQ  s+0(FP), BP
-	ADDQ  R15, 256(BP)
-	MOVQ  ctx+16(FP), R15
-	SUBQ  R14, 128(R15)
-	JS    error_not_enough_literals
-	CMPQ  R13, $0x00020002
-	JA    sequenceDecs_decode_56_bmi2_error_match_len_too_big
-	TESTQ CX, CX
-	JNZ   sequenceDecs_decode_56_bmi2_match_len_ofs_ok
-	TESTQ R13, R13
-	JNZ   sequenceDecs_decode_56_bmi2_error_match_len_ofs_mismatch
-
-sequenceDecs_decode_56_bmi2_match_len_ofs_ok:
-	ADDQ $0x18, R9
-	MOVQ ctx+16(FP), CX
-	DECQ 96(CX)
-	JNS  sequenceDecs_decode_56_bmi2_main_loop
-	MOVQ s+0(FP), CX
-	MOVQ R10, 144(CX)
-	MOVQ R11, 152(CX)
-	MOVQ R12, 160(CX)
-	MOVQ br+8(FP), CX
-	MOVQ AX, 32(CX)
-	MOVB DL, 40(CX)
-	MOVQ BX, 24(CX)
-
-	// Return success
-	MOVQ $0x00000000, ret+24(FP)
-	RET
-
-	// Return with match length error
-sequenceDecs_decode_56_bmi2_error_match_len_ofs_mismatch:
-	MOVQ $0x00000001, ret+24(FP)
-	RET
-
-	// Return with match too long error
-sequenceDecs_decode_56_bmi2_error_match_len_too_big:
-	MOVQ $0x00000002, ret+24(FP)
-	RET
-
-	// Return with match offset too long error
-	MOVQ $0x00000003, ret+24(FP)
-	RET
-
-	// Return with not enough literals error
-error_not_enough_literals:
-	MOVQ $0x00000004, ret+24(FP)
-	RET
-
-	// Return with overread error
-error_overread:
-	MOVQ $0x00000006, ret+24(FP)
-	RET
-
-// func sequenceDecs_executeSimple_amd64(ctx *executeAsmContext) bool
-// Requires: SSE
-TEXT ·sequenceDecs_executeSimple_amd64(SB), $8-9
-	MOVQ  ctx+0(FP), R10
-	MOVQ  8(R10), CX
-	TESTQ CX, CX
-	JZ    empty_seqs
-	MOVQ  (R10), AX
-	MOVQ  24(R10), DX
-	MOVQ  32(R10), BX
-	MOVQ  80(R10), SI
-	MOVQ  104(R10), DI
-	MOVQ  120(R10), R8
-	MOVQ  56(R10), R9
-	MOVQ  64(R10), R10
-	ADDQ  R10, R9
-
-	// seqsBase += 24 * seqIndex
-	LEAQ (DX)(DX*2), R11
-	SHLQ $0x03, R11
-	ADDQ R11, AX
-
-	// outBase += outPosition
-	ADDQ DI, BX
-
-main_loop:
-	MOVQ (AX), R11
-	MOVQ 16(AX), R12
-	MOVQ 8(AX), R13
-
-	// Copy literals
-	TESTQ R11, R11
-	JZ    check_offset
-	XORQ  R14, R14
-
-copy_1:
-	MOVUPS (SI)(R14*1), X0
-	MOVUPS X0, (BX)(R14*1)
-	ADDQ   $0x10, R14
-	CMPQ   R14, R11
-	JB     copy_1
-	ADDQ   R11, SI
-	ADDQ   R11, BX
-	ADDQ   R11, DI
-
-	// Malformed input if seq.mo > t+len(hist) || seq.mo > s.windowSize)
-check_offset:
-	LEAQ (DI)(R10*1), R11
-	CMPQ R12, R11
-	JG   error_match_off_too_big
-	CMPQ R12, R8
-	JG   error_match_off_too_big
-
-	// Copy match from history
-	MOVQ R12, R11
-	SUBQ DI, R11
-	JLS  copy_match
-	MOVQ R9, R14
-	SUBQ R11, R14
-	CMPQ R13, R11
-	JG   copy_all_from_history
-	MOVQ R13, R11
-	SUBQ $0x10, R11
-	JB   copy_4_small
-
-copy_4_loop:
-	MOVUPS (R14), X0
-	MOVUPS X0, (BX)
-	ADDQ   $0x10, R14
-	ADDQ   $0x10, BX
-	SUBQ   $0x10, R11
-	JAE    copy_4_loop
-	LEAQ   16(R14)(R11*1), R14
-	LEAQ   16(BX)(R11*1), BX
-	MOVUPS -16(R14), X0
-	MOVUPS X0, -16(BX)
-	JMP    copy_4_end
-
-copy_4_small:
-	CMPQ R13, $0x03
-	JE   copy_4_move_3
-	CMPQ R13, $0x08
-	JB   copy_4_move_4through7
-	JMP  copy_4_move_8through16
-
-copy_4_move_3:
-	MOVW (R14), R11
-	MOVB 2(R14), R12
-	MOVW R11, (BX)
-	MOVB R12, 2(BX)
-	ADDQ R13, R14
-	ADDQ R13, BX
-	JMP  copy_4_end
-
-copy_4_move_4through7:
-	MOVL (R14), R11
-	MOVL -4(R14)(R13*1), R12
-	MOVL R11, (BX)
-	MOVL R12, -4(BX)(R13*1)
-	ADDQ R13, R14
-	ADDQ R13, BX
-	JMP  copy_4_end
-
-copy_4_move_8through16:
-	MOVQ (R14), R11
-	MOVQ -8(R14)(R13*1), R12
-	MOVQ R11, (BX)
-	MOVQ R12, -8(BX)(R13*1)
-	ADDQ R13, R14
-	ADDQ R13, BX
-
-copy_4_end:
-	ADDQ R13, DI
-	ADDQ $0x18, AX
-	INCQ DX
-	CMPQ DX, CX
-	JB   main_loop
-	JMP  loop_finished
-
-copy_all_from_history:
-	MOVQ R11, R15
-	SUBQ $0x10, R15
-	JB   copy_5_small
-
-copy_5_loop:
-	MOVUPS (R14), X0
-	MOVUPS X0, (BX)
-	ADDQ   $0x10, R14
-	ADDQ   $0x10, BX
-	SUBQ   $0x10, R15
-	JAE    copy_5_loop
-	LEAQ   16(R14)(R15*1), R14
-	LEAQ   16(BX)(R15*1), BX
-	MOVUPS -16(R14), X0
-	MOVUPS X0, -16(BX)
-	JMP    copy_5_end
-
-copy_5_small:
-	CMPQ R11, $0x03
-	JE   copy_5_move_3
-	JB   copy_5_move_1or2
-	CMPQ R11, $0x08
-	JB   copy_5_move_4through7
-	JMP  copy_5_move_8through16
-
-copy_5_move_1or2:
-	MOVB (R14), R15
-	MOVB -1(R14)(R11*1), BP
-	MOVB R15, (BX)
-	MOVB BP, -1(BX)(R11*1)
-	ADDQ R11, R14
-	ADDQ R11, BX
-	JMP  copy_5_end
-
-copy_5_move_3:
-	MOVW (R14), R15
-	MOVB 2(R14), BP
-	MOVW R15, (BX)
-	MOVB BP, 2(BX)
-	ADDQ R11, R14
-	ADDQ R11, BX
-	JMP  copy_5_end
-
-copy_5_move_4through7:
-	MOVL (R14), R15
-	MOVL -4(R14)(R11*1), BP
-	MOVL R15, (BX)
-	MOVL BP, -4(BX)(R11*1)
-	ADDQ R11, R14
-	ADDQ R11, BX
-	JMP  copy_5_end
-
-copy_5_move_8through16:
-	MOVQ (R14), R15
-	MOVQ -8(R14)(R11*1), BP
-	MOVQ R15, (BX)
-	MOVQ BP, -8(BX)(R11*1)
-	ADDQ R11, R14
-	ADDQ R11, BX
-
-copy_5_end:
-	ADDQ R11, DI
-	SUBQ R11, R13
-
-	// Copy match from the current buffer
-copy_match:
-	MOVQ BX, R11
-	SUBQ R12, R11
-
-	// ml <= mo
-	CMPQ R13, R12
-	JA   copy_overlapping_match
-
-	// Copy non-overlapping match
-	ADDQ R13, DI
-	MOVQ BX, R12
-	ADDQ R13, BX
-
-copy_2:
-	MOVUPS (R11), X0
-	MOVUPS X0, (R12)
-	ADDQ   $0x10, R11
-	ADDQ   $0x10, R12
-	SUBQ   $0x10, R13
-	JHI    copy_2
-	JMP    handle_loop
-
-	// Copy overlapping match
-copy_overlapping_match:
-	ADDQ R13, DI
-
-copy_slow_3:
-	MOVB (R11), R12
-	MOVB R12, (BX)
-	INCQ R11
-	INCQ BX
-	DECQ R13
-	JNZ  copy_slow_3
-
-handle_loop:
-	ADDQ $0x18, AX
-	INCQ DX
-	CMPQ DX, CX
-	JB   main_loop
-
-loop_finished:
-	// Return value
-	MOVB $0x01, ret+8(FP)
-
-	// Update the context
-	MOVQ ctx+0(FP), AX
-	MOVQ DX, 24(AX)
-	MOVQ DI, 104(AX)
-	SUBQ 80(AX), SI
-	MOVQ SI, 112(AX)
-	RET
-
-error_match_off_too_big:
-	// Return value
-	MOVB $0x00, ret+8(FP)
-
-	// Update the context
-	MOVQ ctx+0(FP), AX
-	MOVQ DX, 24(AX)
-	MOVQ DI, 104(AX)
-	SUBQ 80(AX), SI
-	MOVQ SI, 112(AX)
-	RET
-
-empty_seqs:
-	// Return value
-	MOVB $0x01, ret+8(FP)
-	RET
-
-// func sequenceDecs_executeSimple_safe_amd64(ctx *executeAsmContext) bool
-// Requires: SSE
-TEXT ·sequenceDecs_executeSimple_safe_amd64(SB), $8-9
-	MOVQ  ctx+0(FP), R10
-	MOVQ  8(R10), CX
-	TESTQ CX, CX
-	JZ    empty_seqs
-	MOVQ  (R10), AX
-	MOVQ  24(R10), DX
-	MOVQ  32(R10), BX
-	MOVQ  80(R10), SI
-	MOVQ  104(R10), DI
-	MOVQ  120(R10), R8
-	MOVQ  56(R10), R9
-	MOVQ  64(R10), R10
-	ADDQ  R10, R9
-
-	// seqsBase += 24 * seqIndex
-	LEAQ (DX)(DX*2), R11
-	SHLQ $0x03, R11
-	ADDQ R11, AX
-
-	// outBase += outPosition
-	ADDQ DI, BX
-
-main_loop:
-	MOVQ (AX), R11
-	MOVQ 16(AX), R12
-	MOVQ 8(AX), R13
-
-	// Copy literals
-	TESTQ R11, R11
-	JZ    check_offset
-	MOVQ  R11, R14
-	SUBQ  $0x10, R14
-	JB    copy_1_small
-
-copy_1_loop:
-	MOVUPS (SI), X0
-	MOVUPS X0, (BX)
-	ADDQ   $0x10, SI
-	ADDQ   $0x10, BX
-	SUBQ   $0x10, R14
-	JAE    copy_1_loop
-	LEAQ   16(SI)(R14*1), SI
-	LEAQ   16(BX)(R14*1), BX
-	MOVUPS -16(SI), X0
-	MOVUPS X0, -16(BX)
-	JMP    copy_1_end
-
-copy_1_small:
-	CMPQ R11, $0x03
-	JE   copy_1_move_3
-	JB   copy_1_move_1or2
-	CMPQ R11, $0x08
-	JB   copy_1_move_4through7
-	JMP  copy_1_move_8through16
-
-copy_1_move_1or2:
-	MOVB (SI), R14
-	MOVB -1(SI)(R11*1), R15
-	MOVB R14, (BX)
-	MOVB R15, -1(BX)(R11*1)
-	ADDQ R11, SI
-	ADDQ R11, BX
-	JMP  copy_1_end
-
-copy_1_move_3:
-	MOVW (SI), R14
-	MOVB 2(SI), R15
-	MOVW R14, (BX)
-	MOVB R15, 2(BX)
-	ADDQ R11, SI
-	ADDQ R11, BX
-	JMP  copy_1_end
-
-copy_1_move_4through7:
-	MOVL (SI), R14
-	MOVL -4(SI)(R11*1), R15
-	MOVL R14, (BX)
-	MOVL R15, -4(BX)(R11*1)
-	ADDQ R11, SI
-	ADDQ R11, BX
-	JMP  copy_1_end
-
-copy_1_move_8through16:
-	MOVQ (SI), R14
-	MOVQ -8(SI)(R11*1), R15
-	MOVQ R14, (BX)
-	MOVQ R15, -8(BX)(R11*1)
-	ADDQ R11, SI
-	ADDQ R11, BX
-
-copy_1_end:
-	ADDQ R11, DI
-
-	// Malformed input if seq.mo > t+len(hist) || seq.mo > s.windowSize)
-check_offset:
-	LEAQ (DI)(R10*1), R11
-	CMPQ R12, R11
-	JG   error_match_off_too_big
-	CMPQ R12, R8
-	JG   error_match_off_too_big
-
-	// Copy match from history
-	MOVQ R12, R11
-	SUBQ DI, R11
-	JLS  copy_match
-	MOVQ R9, R14
-	SUBQ R11, R14
-	CMPQ R13, R11
-	JG   copy_all_from_history
-	MOVQ R13, R11
-	SUBQ $0x10, R11
-	JB   copy_4_small
-
-copy_4_loop:
-	MOVUPS (R14), X0
-	MOVUPS X0, (BX)
-	ADDQ   $0x10, R14
-	ADDQ   $0x10, BX
-	SUBQ   $0x10, R11
-	JAE    copy_4_loop
-	LEAQ   16(R14)(R11*1), R14
-	LEAQ   16(BX)(R11*1), BX
-	MOVUPS -16(R14), X0
-	MOVUPS X0, -16(BX)
-	JMP    copy_4_end
-
-copy_4_small:
-	CMPQ R13, $0x03
-	JE   copy_4_move_3
-	CMPQ R13, $0x08
-	JB   copy_4_move_4through7
-	JMP  copy_4_move_8through16
-
-copy_4_move_3:
-	MOVW (R14), R11
-	MOVB 2(R14), R12
-	MOVW R11, (BX)
-	MOVB R12, 2(BX)
-	ADDQ R13, R14
-	ADDQ R13, BX
-	JMP  copy_4_end
-
-copy_4_move_4through7:
-	MOVL (R14), R11
-	MOVL -4(R14)(R13*1), R12
-	MOVL R11, (BX)
-	MOVL R12, -4(BX)(R13*1)
-	ADDQ R13, R14
-	ADDQ R13, BX
-	JMP  copy_4_end
-
-copy_4_move_8through16:
-	MOVQ (R14), R11
-	MOVQ -8(R14)(R13*1), R12
-	MOVQ R11, (BX)
-	MOVQ R12, -8(BX)(R13*1)
-	ADDQ R13, R14
-	ADDQ R13, BX
-
-copy_4_end:
-	ADDQ R13, DI
-	ADDQ $0x18, AX
-	INCQ DX
-	CMPQ DX, CX
-	JB   main_loop
-	JMP  loop_finished
-
-copy_all_from_history:
-	MOVQ R11, R15
-	SUBQ $0x10, R15
-	JB   copy_5_small
-
-copy_5_loop:
-	MOVUPS (R14), X0
-	MOVUPS X0, (BX)
-	ADDQ   $0x10, R14
-	ADDQ   $0x10, BX
-	SUBQ   $0x10, R15
-	JAE    copy_5_loop
-	LEAQ   16(R14)(R15*1), R14
-	LEAQ   16(BX)(R15*1), BX
-	MOVUPS -16(R14), X0
-	MOVUPS X0, -16(BX)
-	JMP    copy_5_end
-
-copy_5_small:
-	CMPQ R11, $0x03
-	JE   copy_5_move_3
-	JB   copy_5_move_1or2
-	CMPQ R11, $0x08
-	JB   copy_5_move_4through7
-	JMP  copy_5_move_8through16
-
-copy_5_move_1or2:
-	MOVB (R14), R15
-	MOVB -1(R14)(R11*1), BP
-	MOVB R15, (BX)
-	MOVB BP, -1(BX)(R11*1)
-	ADDQ R11, R14
-	ADDQ R11, BX
-	JMP  copy_5_end
-
-copy_5_move_3:
-	MOVW (R14), R15
-	MOVB 2(R14), BP
-	MOVW R15, (BX)
-	MOVB BP, 2(BX)
-	ADDQ R11, R14
-	ADDQ R11, BX
-	JMP  copy_5_end
-
-copy_5_move_4through7:
-	MOVL (R14), R15
-	MOVL -4(R14)(R11*1), BP
-	MOVL R15, (BX)
-	MOVL BP, -4(BX)(R11*1)
-	ADDQ R11, R14
-	ADDQ R11, BX
-	JMP  copy_5_end
-
-copy_5_move_8through16:
-	MOVQ (R14), R15
-	MOVQ -8(R14)(R11*1), BP
-	MOVQ R15, (BX)
-	MOVQ BP, -8(BX)(R11*1)
-	ADDQ R11, R14
-	ADDQ R11, BX
-
-copy_5_end:
-	ADDQ R11, DI
-	SUBQ R11, R13
-
-	// Copy match from the current buffer
-copy_match:
-	MOVQ BX, R11
-	SUBQ R12, R11
-
-	// ml <= mo
-	CMPQ R13, R12
-	JA   copy_overlapping_match
-
-	// Copy non-overlapping match
-	ADDQ R13, DI
-	MOVQ R13, R12
-	SUBQ $0x10, R12
-	JB   copy_2_small
-
-copy_2_loop:
-	MOVUPS (R11), X0
-	MOVUPS X0, (BX)
-	ADDQ   $0x10, R11
-	ADDQ   $0x10, BX
-	SUBQ   $0x10, R12
-	JAE    copy_2_loop
-	LEAQ   16(R11)(R12*1), R11
-	LEAQ   16(BX)(R12*1), BX
-	MOVUPS -16(R11), X0
-	MOVUPS X0, -16(BX)
-	JMP    copy_2_end
-
-copy_2_small:
-	CMPQ R13, $0x03
-	JE   copy_2_move_3
-	JB   copy_2_move_1or2
-	CMPQ R13, $0x08
-	JB   copy_2_move_4through7
-	JMP  copy_2_move_8through16
-
-copy_2_move_1or2:
-	MOVB (R11), R12
-	MOVB -1(R11)(R13*1), R14
-	MOVB R12, (BX)
-	MOVB R14, -1(BX)(R13*1)
-	ADDQ R13, R11
-	ADDQ R13, BX
-	JMP  copy_2_end
-
-copy_2_move_3:
-	MOVW (R11), R12
-	MOVB 2(R11), R14
-	MOVW R12, (BX)
-	MOVB R14, 2(BX)
-	ADDQ R13, R11
-	ADDQ R13, BX
-	JMP  copy_2_end
-
-copy_2_move_4through7:
-	MOVL (R11), R12
-	MOVL -4(R11)(R13*1), R14
-	MOVL R12, (BX)
-	MOVL R14, -4(BX)(R13*1)
-	ADDQ R13, R11
-	ADDQ R13, BX
-	JMP  copy_2_end
-
-copy_2_move_8through16:
-	MOVQ (R11), R12
-	MOVQ -8(R11)(R13*1), R14
-	MOVQ R12, (BX)
-	MOVQ R14, -8(BX)(R13*1)
-	ADDQ R13, R11
-	ADDQ R13, BX
-
-copy_2_end:
-	JMP handle_loop
-
-	// Copy overlapping match
-copy_overlapping_match:
-	ADDQ R13, DI
-
-copy_slow_3:
-	MOVB (R11), R12
-	MOVB R12, (BX)
-	INCQ R11
-	INCQ BX
-	DECQ R13
-	JNZ  copy_slow_3
-
-handle_loop:
-	ADDQ $0x18, AX
-	INCQ DX
-	CMPQ DX, CX
-	JB   main_loop
-
-loop_finished:
-	// Return value
-	MOVB $0x01, ret+8(FP)
-
-	// Update the context
-	MOVQ ctx+0(FP), AX
-	MOVQ DX, 24(AX)
-	MOVQ DI, 104(AX)
-	SUBQ 80(AX), SI
-	MOVQ SI, 112(AX)
-	RET
-
-error_match_off_too_big:
-	// Return value
-	MOVB $0x00, ret+8(FP)
-
-	// Update the context
-	MOVQ ctx+0(FP), AX
-	MOVQ DX, 24(AX)
-	MOVQ DI, 104(AX)
-	SUBQ 80(AX), SI
-	MOVQ SI, 112(AX)
-	RET
-
-empty_seqs:
-	// Return value
-	MOVB $0x01, ret+8(FP)
-	RET
-
-// func sequenceDecs_decodeSync_amd64(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
-// Requires: CMOV, SSE
-TEXT ·sequenceDecs_decodeSync_amd64(SB), $64-32
-	MOVQ    br+8(FP), AX
-	MOVQ    32(AX), DX
-	MOVBQZX 40(AX), BX
-	MOVQ    24(AX), SI
-	MOVQ    (AX), AX
-	ADDQ    SI, AX
-	MOVQ    AX, (SP)
-	MOVQ    ctx+16(FP), AX
-	MOVQ    72(AX), DI
-	MOVQ    80(AX), R8
-	MOVQ    88(AX), R9
-	XORQ    CX, CX
-	MOVQ    CX, 8(SP)
-	MOVQ    CX, 16(SP)
-	MOVQ    CX, 24(SP)
-	MOVQ    112(AX), R10
-	MOVQ    128(AX), CX
-	MOVQ    CX, 32(SP)
-	MOVQ    144(AX), R11
-	MOVQ    136(AX), R12
-	MOVQ    200(AX), CX
-	MOVQ    CX, 56(SP)
-	MOVQ    176(AX), CX
-	MOVQ    CX, 48(SP)
-	MOVQ    184(AX), AX
-	MOVQ    AX, 40(SP)
-	MOVQ    40(SP), AX
-	ADDQ    AX, 48(SP)
-
-	// Calculate poiter to s.out[cap(s.out)] (a past-end pointer)
-	ADDQ R10, 32(SP)
-
-	// outBase += outPosition
-	ADDQ R12, R10
-
-sequenceDecs_decodeSync_amd64_main_loop:
-	MOVQ (SP), R13
-
-	// Fill bitreader to have enough for the offset and match length.
-	CMPQ SI, $0x08
-	JL   sequenceDecs_decodeSync_amd64_fill_byte_by_byte
-	MOVQ BX, AX
-	SHRQ $0x03, AX
-	SUBQ AX, R13
-	MOVQ (R13), DX
-	SUBQ AX, SI
-	ANDQ $0x07, BX
-	JMP  sequenceDecs_decodeSync_amd64_fill_end
-
-sequenceDecs_decodeSync_amd64_fill_byte_by_byte:
-	CMPQ    SI, $0x00
-	JLE     sequenceDecs_decodeSync_amd64_fill_check_overread
-	CMPQ    BX, $0x07
-	JLE     sequenceDecs_decodeSync_amd64_fill_end
-	SHLQ    $0x08, DX
-	SUBQ    $0x01, R13
-	SUBQ    $0x01, SI
-	SUBQ    $0x08, BX
-	MOVBQZX (R13), AX
-	ORQ     AX, DX
-	JMP     sequenceDecs_decodeSync_amd64_fill_byte_by_byte
-
-sequenceDecs_decodeSync_amd64_fill_check_overread:
-	CMPQ BX, $0x40
-	JA   error_overread
-
-sequenceDecs_decodeSync_amd64_fill_end:
-	// Update offset
-	MOVQ  R9, AX
-	MOVQ  BX, CX
-	MOVQ  DX, R14
-	SHLQ  CL, R14
-	MOVB  AH, CL
-	SHRQ  $0x20, AX
-	TESTQ CX, CX
-	JZ    sequenceDecs_decodeSync_amd64_of_update_zero
-	ADDQ  CX, BX
-	CMPQ  BX, $0x40
-	JA    sequenceDecs_decodeSync_amd64_of_update_zero
-	CMPQ  CX, $0x40
-	JAE   sequenceDecs_decodeSync_amd64_of_update_zero
-	NEGQ  CX
-	SHRQ  CL, R14
-	ADDQ  R14, AX
-
-sequenceDecs_decodeSync_amd64_of_update_zero:
-	MOVQ AX, 8(SP)
-
-	// Update match length
-	MOVQ  R8, AX
-	MOVQ  BX, CX
-	MOVQ  DX, R14
-	SHLQ  CL, R14
-	MOVB  AH, CL
-	SHRQ  $0x20, AX
-	TESTQ CX, CX
-	JZ    sequenceDecs_decodeSync_amd64_ml_update_zero
-	ADDQ  CX, BX
-	CMPQ  BX, $0x40
-	JA    sequenceDecs_decodeSync_amd64_ml_update_zero
-	CMPQ  CX, $0x40
-	JAE   sequenceDecs_decodeSync_amd64_ml_update_zero
-	NEGQ  CX
-	SHRQ  CL, R14
-	ADDQ  R14, AX
-
-sequenceDecs_decodeSync_amd64_ml_update_zero:
-	MOVQ AX, 16(SP)
-
-	// Fill bitreader to have enough for the remaining
-	CMPQ SI, $0x08
-	JL   sequenceDecs_decodeSync_amd64_fill_2_byte_by_byte
-	MOVQ BX, AX
-	SHRQ $0x03, AX
-	SUBQ AX, R13
-	MOVQ (R13), DX
-	SUBQ AX, SI
-	ANDQ $0x07, BX
-	JMP  sequenceDecs_decodeSync_amd64_fill_2_end
-
-sequenceDecs_decodeSync_amd64_fill_2_byte_by_byte:
-	CMPQ    SI, $0x00
-	JLE     sequenceDecs_decodeSync_amd64_fill_2_check_overread
-	CMPQ    BX, $0x07
-	JLE     sequenceDecs_decodeSync_amd64_fill_2_end
-	SHLQ    $0x08, DX
-	SUBQ    $0x01, R13
-	SUBQ    $0x01, SI
-	SUBQ    $0x08, BX
-	MOVBQZX (R13), AX
-	ORQ     AX, DX
-	JMP     sequenceDecs_decodeSync_amd64_fill_2_byte_by_byte
-
-sequenceDecs_decodeSync_amd64_fill_2_check_overread:
-	CMPQ BX, $0x40
-	JA   error_overread
-
-sequenceDecs_decodeSync_amd64_fill_2_end:
-	// Update literal length
-	MOVQ  DI, AX
-	MOVQ  BX, CX
-	MOVQ  DX, R14
-	SHLQ  CL, R14
-	MOVB  AH, CL
-	SHRQ  $0x20, AX
-	TESTQ CX, CX
-	JZ    sequenceDecs_decodeSync_amd64_ll_update_zero
-	ADDQ  CX, BX
-	CMPQ  BX, $0x40
-	JA    sequenceDecs_decodeSync_amd64_ll_update_zero
-	CMPQ  CX, $0x40
-	JAE   sequenceDecs_decodeSync_amd64_ll_update_zero
-	NEGQ  CX
-	SHRQ  CL, R14
-	ADDQ  R14, AX
-
-sequenceDecs_decodeSync_amd64_ll_update_zero:
-	MOVQ AX, 24(SP)
-
-	// Fill bitreader for state updates
-	MOVQ    R13, (SP)
-	MOVQ    R9, AX
-	SHRQ    $0x08, AX
-	MOVBQZX AL, AX
-	MOVQ    ctx+16(FP), CX
-	CMPQ    96(CX), $0x00
-	JZ      sequenceDecs_decodeSync_amd64_skip_update
-
-	// Update Literal Length State
-	MOVBQZX DI, R13
-	SHRQ    $0x10, DI
-	MOVWQZX DI, DI
-	LEAQ    (BX)(R13*1), CX
-	MOVQ    DX, R14
-	MOVQ    CX, BX
-	ROLQ    CL, R14
-	MOVL    $0x00000001, R15
-	MOVB    R13, CL
-	SHLL    CL, R15
-	DECL    R15
-	ANDQ    R15, R14
-	ADDQ    R14, DI
-
-	// Load ctx.llTable
-	MOVQ ctx+16(FP), CX
-	MOVQ (CX), CX
-	MOVQ (CX)(DI*8), DI
-
-	// Update Match Length State
-	MOVBQZX R8, R13
-	SHRQ    $0x10, R8
-	MOVWQZX R8, R8
-	LEAQ    (BX)(R13*1), CX
-	MOVQ    DX, R14
-	MOVQ    CX, BX
-	ROLQ    CL, R14
-	MOVL    $0x00000001, R15
-	MOVB    R13, CL
-	SHLL    CL, R15
-	DECL    R15
-	ANDQ    R15, R14
-	ADDQ    R14, R8
-
-	// Load ctx.mlTable
-	MOVQ ctx+16(FP), CX
-	MOVQ 24(CX), CX
-	MOVQ (CX)(R8*8), R8
-
-	// Update Offset State
-	MOVBQZX R9, R13
-	SHRQ    $0x10, R9
-	MOVWQZX R9, R9
-	LEAQ    (BX)(R13*1), CX
-	MOVQ    DX, R14
-	MOVQ    CX, BX
-	ROLQ    CL, R14
-	MOVL    $0x00000001, R15
-	MOVB    R13, CL
-	SHLL    CL, R15
-	DECL    R15
-	ANDQ    R15, R14
-	ADDQ    R14, R9
-
-	// Load ctx.ofTable
-	MOVQ ctx+16(FP), CX
-	MOVQ 48(CX), CX
-	MOVQ (CX)(R9*8), R9
-
-sequenceDecs_decodeSync_amd64_skip_update:
-	// Adjust offset
-	MOVQ   s+0(FP), CX
-	MOVQ   8(SP), R13
-	CMPQ   AX, $0x01
-	JBE    sequenceDecs_decodeSync_amd64_adjust_offsetB_1_or_0
-	MOVUPS 144(CX), X0
-	MOVQ   R13, 144(CX)
-	MOVUPS X0, 152(CX)
-	JMP    sequenceDecs_decodeSync_amd64_after_adjust
-
-sequenceDecs_decodeSync_amd64_adjust_offsetB_1_or_0:
-	CMPQ 24(SP), $0x00000000
-	JNE  sequenceDecs_decodeSync_amd64_adjust_offset_maybezero
-	INCQ R13
-	JMP  sequenceDecs_decodeSync_amd64_adjust_offset_nonzero
-
-sequenceDecs_decodeSync_amd64_adjust_offset_maybezero:
-	TESTQ R13, R13
-	JNZ   sequenceDecs_decodeSync_amd64_adjust_offset_nonzero
-	MOVQ  144(CX), R13
-	JMP   sequenceDecs_decodeSync_amd64_after_adjust
-
-sequenceDecs_decodeSync_amd64_adjust_offset_nonzero:
-	MOVQ    R13, AX
-	XORQ    R14, R14
-	MOVQ    $-1, R15
-	CMPQ    R13, $0x03
-	CMOVQEQ R14, AX
-	CMOVQEQ R15, R14
-	ADDQ    144(CX)(AX*8), R14
-	JNZ     sequenceDecs_decodeSync_amd64_adjust_temp_valid
-	MOVQ    $0x00000001, R14
-
-sequenceDecs_decodeSync_amd64_adjust_temp_valid:
-	CMPQ R13, $0x01
-	JZ   sequenceDecs_decodeSync_amd64_adjust_skip
-	MOVQ 152(CX), AX
-	MOVQ AX, 160(CX)
-
-sequenceDecs_decodeSync_amd64_adjust_skip:
-	MOVQ 144(CX), AX
-	MOVQ AX, 152(CX)
-	MOVQ R14, 144(CX)
-	MOVQ R14, R13
-
-sequenceDecs_decodeSync_amd64_after_adjust:
-	MOVQ R13, 8(SP)
-
-	// Check values
-	MOVQ  16(SP), AX
-	MOVQ  24(SP), CX
-	LEAQ  (AX)(CX*1), R14
-	MOVQ  s+0(FP), R15
-	ADDQ  R14, 256(R15)
-	MOVQ  ctx+16(FP), R14
-	SUBQ  CX, 104(R14)
-	JS    error_not_enough_literals
-	CMPQ  AX, $0x00020002
-	JA    sequenceDecs_decodeSync_amd64_error_match_len_too_big
-	TESTQ R13, R13
-	JNZ   sequenceDecs_decodeSync_amd64_match_len_ofs_ok
-	TESTQ AX, AX
-	JNZ   sequenceDecs_decodeSync_amd64_error_match_len_ofs_mismatch
-
-sequenceDecs_decodeSync_amd64_match_len_ofs_ok:
-	MOVQ 24(SP), AX
-	MOVQ 8(SP), CX
-	MOVQ 16(SP), R13
-
-	// Check if we have enough space in s.out
-	LEAQ (AX)(R13*1), R14
-	ADDQ R10, R14
-	CMPQ R14, 32(SP)
-	JA   error_not_enough_space
-
-	// Copy literals
-	TESTQ AX, AX
-	JZ    check_offset
-	XORQ  R14, R14
-
-copy_1:
-	MOVUPS (R11)(R14*1), X0
-	MOVUPS X0, (R10)(R14*1)
-	ADDQ   $0x10, R14
-	CMPQ   R14, AX
-	JB     copy_1
-	ADDQ   AX, R11
-	ADDQ   AX, R10
-	ADDQ   AX, R12
-
-	// Malformed input if seq.mo > t+len(hist) || seq.mo > s.windowSize)
-check_offset:
-	MOVQ R12, AX
-	ADDQ 40(SP), AX
-	CMPQ CX, AX
-	JG   error_match_off_too_big
-	CMPQ CX, 56(SP)
-	JG   error_match_off_too_big
-
-	// Copy match from history
-	MOVQ CX, AX
-	SUBQ R12, AX
-	JLS  copy_match
-	MOVQ 48(SP), R14
-	SUBQ AX, R14
-	CMPQ R13, AX
-	JG   copy_all_from_history
-	MOVQ R13, AX
-	SUBQ $0x10, AX
-	JB   copy_4_small
-
-copy_4_loop:
-	MOVUPS (R14), X0
-	MOVUPS X0, (R10)
-	ADDQ   $0x10, R14
-	ADDQ   $0x10, R10
-	SUBQ   $0x10, AX
-	JAE    copy_4_loop
-	LEAQ   16(R14)(AX*1), R14
-	LEAQ   16(R10)(AX*1), R10
-	MOVUPS -16(R14), X0
-	MOVUPS X0, -16(R10)
-	JMP    copy_4_end
-
-copy_4_small:
-	CMPQ R13, $0x03
-	JE   copy_4_move_3
-	CMPQ R13, $0x08
-	JB   copy_4_move_4through7
-	JMP  copy_4_move_8through16
-
-copy_4_move_3:
-	MOVW (R14), AX
-	MOVB 2(R14), CL
-	MOVW AX, (R10)
-	MOVB CL, 2(R10)
-	ADDQ R13, R14
-	ADDQ R13, R10
-	JMP  copy_4_end
-
-copy_4_move_4through7:
-	MOVL (R14), AX
-	MOVL -4(R14)(R13*1), CX
-	MOVL AX, (R10)
-	MOVL CX, -4(R10)(R13*1)
-	ADDQ R13, R14
-	ADDQ R13, R10
-	JMP  copy_4_end
-
-copy_4_move_8through16:
-	MOVQ (R14), AX
-	MOVQ -8(R14)(R13*1), CX
-	MOVQ AX, (R10)
-	MOVQ CX, -8(R10)(R13*1)
-	ADDQ R13, R14
-	ADDQ R13, R10
-
-copy_4_end:
-	ADDQ R13, R12
-	JMP  handle_loop
-	JMP loop_finished
-
-copy_all_from_history:
-	MOVQ AX, R15
-	SUBQ $0x10, R15
-	JB   copy_5_small
-
-copy_5_loop:
-	MOVUPS (R14), X0
-	MOVUPS X0, (R10)
-	ADDQ   $0x10, R14
-	ADDQ   $0x10, R10
-	SUBQ   $0x10, R15
-	JAE    copy_5_loop
-	LEAQ   16(R14)(R15*1), R14
-	LEAQ   16(R10)(R15*1), R10
-	MOVUPS -16(R14), X0
-	MOVUPS X0, -16(R10)
-	JMP    copy_5_end
-
-copy_5_small:
-	CMPQ AX, $0x03
-	JE   copy_5_move_3
-	JB   copy_5_move_1or2
-	CMPQ AX, $0x08
-	JB   copy_5_move_4through7
-	JMP  copy_5_move_8through16
-
-copy_5_move_1or2:
-	MOVB (R14), R15
-	MOVB -1(R14)(AX*1), BP
-	MOVB R15, (R10)
-	MOVB BP, -1(R10)(AX*1)
-	ADDQ AX, R14
-	ADDQ AX, R10
-	JMP  copy_5_end
-
-copy_5_move_3:
-	MOVW (R14), R15
-	MOVB 2(R14), BP
-	MOVW R15, (R10)
-	MOVB BP, 2(R10)
-	ADDQ AX, R14
-	ADDQ AX, R10
-	JMP  copy_5_end
-
-copy_5_move_4through7:
-	MOVL (R14), R15
-	MOVL -4(R14)(AX*1), BP
-	MOVL R15, (R10)
-	MOVL BP, -4(R10)(AX*1)
-	ADDQ AX, R14
-	ADDQ AX, R10
-	JMP  copy_5_end
-
-copy_5_move_8through16:
-	MOVQ (R14), R15
-	MOVQ -8(R14)(AX*1), BP
-	MOVQ R15, (R10)
-	MOVQ BP, -8(R10)(AX*1)
-	ADDQ AX, R14
-	ADDQ AX, R10
-
-copy_5_end:
-	ADDQ AX, R12
-	SUBQ AX, R13
-
-	// Copy match from the current buffer
-copy_match:
-	MOVQ R10, AX
-	SUBQ CX, AX
-
-	// ml <= mo
-	CMPQ R13, CX
-	JA   copy_overlapping_match
-
-	// Copy non-overlapping match
-	ADDQ R13, R12
-	MOVQ R10, CX
-	ADDQ R13, R10
-
-copy_2:
-	MOVUPS (AX), X0
-	MOVUPS X0, (CX)
-	ADDQ   $0x10, AX
-	ADDQ   $0x10, CX
-	SUBQ   $0x10, R13
-	JHI    copy_2
-	JMP    handle_loop
-
-	// Copy overlapping match
-copy_overlapping_match:
-	ADDQ R13, R12
-
-copy_slow_3:
-	MOVB (AX), CL
-	MOVB CL, (R10)
-	INCQ AX
-	INCQ R10
-	DECQ R13
-	JNZ  copy_slow_3
-
-handle_loop:
-	MOVQ ctx+16(FP), AX
-	DECQ 96(AX)
-	JNS  sequenceDecs_decodeSync_amd64_main_loop
-
-loop_finished:
-	MOVQ br+8(FP), AX
-	MOVQ DX, 32(AX)
-	MOVB BL, 40(AX)
-	MOVQ SI, 24(AX)
-
-	// Update the context
-	MOVQ ctx+16(FP), AX
-	MOVQ R12, 136(AX)
-	MOVQ 144(AX), CX
-	SUBQ CX, R11
-	MOVQ R11, 168(AX)
-
-	// Return success
-	MOVQ $0x00000000, ret+24(FP)
-	RET
-
-	// Return with match length error
-sequenceDecs_decodeSync_amd64_error_match_len_ofs_mismatch:
-	MOVQ 16(SP), AX
-	MOVQ ctx+16(FP), CX
-	MOVQ AX, 216(CX)
-	MOVQ $0x00000001, ret+24(FP)
-	RET
-
-	// Return with match too long error
-sequenceDecs_decodeSync_amd64_error_match_len_too_big:
-	MOVQ ctx+16(FP), AX
-	MOVQ 16(SP), CX
-	MOVQ CX, 216(AX)
-	MOVQ $0x00000002, ret+24(FP)
-	RET
-
-	// Return with match offset too long error
-error_match_off_too_big:
-	MOVQ ctx+16(FP), AX
-	MOVQ 8(SP), CX
-	MOVQ CX, 224(AX)
-	MOVQ R12, 136(AX)
-	MOVQ $0x00000003, ret+24(FP)
-	RET
-
-	// Return with not enough literals error
-error_not_enough_literals:
-	MOVQ ctx+16(FP), AX
-	MOVQ 24(SP), CX
-	MOVQ CX, 208(AX)
-	MOVQ $0x00000004, ret+24(FP)
-	RET
-
-	// Return with overread error
-error_overread:
-	MOVQ $0x00000006, ret+24(FP)
-	RET
-
-	// Return with not enough output space error
-error_not_enough_space:
-	MOVQ ctx+16(FP), AX
-	MOVQ 24(SP), CX
-	MOVQ CX, 208(AX)
-	MOVQ 16(SP), CX
-	MOVQ CX, 216(AX)
-	MOVQ R12, 136(AX)
-	MOVQ $0x00000005, ret+24(FP)
-	RET
-
-// func sequenceDecs_decodeSync_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
-// Requires: BMI, BMI2, CMOV, SSE
-TEXT ·sequenceDecs_decodeSync_bmi2(SB), $64-32
-	MOVQ    br+8(FP), CX
-	MOVQ    32(CX), AX
-	MOVBQZX 40(CX), DX
-	MOVQ    24(CX), BX
-	MOVQ    (CX), CX
-	ADDQ    BX, CX
-	MOVQ    CX, (SP)
-	MOVQ    ctx+16(FP), CX
-	MOVQ    72(CX), SI
-	MOVQ    80(CX), DI
-	MOVQ    88(CX), R8
-	XORQ    R9, R9
-	MOVQ    R9, 8(SP)
-	MOVQ    R9, 16(SP)
-	MOVQ    R9, 24(SP)
-	MOVQ    112(CX), R9
-	MOVQ    128(CX), R10
-	MOVQ    R10, 32(SP)
-	MOVQ    144(CX), R10
-	MOVQ    136(CX), R11
-	MOVQ    200(CX), R12
-	MOVQ    R12, 56(SP)
-	MOVQ    176(CX), R12
-	MOVQ    R12, 48(SP)
-	MOVQ    184(CX), CX
-	MOVQ    CX, 40(SP)
-	MOVQ    40(SP), CX
-	ADDQ    CX, 48(SP)
-
-	// Calculate poiter to s.out[cap(s.out)] (a past-end pointer)
-	ADDQ R9, 32(SP)
-
-	// outBase += outPosition
-	ADDQ R11, R9
-
-sequenceDecs_decodeSync_bmi2_main_loop:
-	MOVQ (SP), R12
-
-	// Fill bitreader to have enough for the offset and match length.
-	CMPQ BX, $0x08
-	JL   sequenceDecs_decodeSync_bmi2_fill_byte_by_byte
-	MOVQ DX, CX
-	SHRQ $0x03, CX
-	SUBQ CX, R12
-	MOVQ (R12), AX
-	SUBQ CX, BX
-	ANDQ $0x07, DX
-	JMP  sequenceDecs_decodeSync_bmi2_fill_end
-
-sequenceDecs_decodeSync_bmi2_fill_byte_by_byte:
-	CMPQ    BX, $0x00
-	JLE     sequenceDecs_decodeSync_bmi2_fill_check_overread
-	CMPQ    DX, $0x07
-	JLE     sequenceDecs_decodeSync_bmi2_fill_end
-	SHLQ    $0x08, AX
-	SUBQ    $0x01, R12
-	SUBQ    $0x01, BX
-	SUBQ    $0x08, DX
-	MOVBQZX (R12), CX
-	ORQ     CX, AX
-	JMP     sequenceDecs_decodeSync_bmi2_fill_byte_by_byte
-
-sequenceDecs_decodeSync_bmi2_fill_check_overread:
-	CMPQ DX, $0x40
-	JA   error_overread
-
-sequenceDecs_decodeSync_bmi2_fill_end:
-	// Update offset
-	MOVQ   $0x00000808, CX
-	BEXTRQ CX, R8, R13
-	MOVQ   AX, R14
-	LEAQ   (DX)(R13*1), CX
-	ROLQ   CL, R14
-	BZHIQ  R13, R14, R14
-	MOVQ   CX, DX
-	MOVQ   R8, CX
-	SHRQ   $0x20, CX
-	ADDQ   R14, CX
-	MOVQ   CX, 8(SP)
-
-	// Update match length
-	MOVQ   $0x00000808, CX
-	BEXTRQ CX, DI, R13
-	MOVQ   AX, R14
-	LEAQ   (DX)(R13*1), CX
-	ROLQ   CL, R14
-	BZHIQ  R13, R14, R14
-	MOVQ   CX, DX
-	MOVQ   DI, CX
-	SHRQ   $0x20, CX
-	ADDQ   R14, CX
-	MOVQ   CX, 16(SP)
-
-	// Fill bitreader to have enough for the remaining
-	CMPQ BX, $0x08
-	JL   sequenceDecs_decodeSync_bmi2_fill_2_byte_by_byte
-	MOVQ DX, CX
-	SHRQ $0x03, CX
-	SUBQ CX, R12
-	MOVQ (R12), AX
-	SUBQ CX, BX
-	ANDQ $0x07, DX
-	JMP  sequenceDecs_decodeSync_bmi2_fill_2_end
-
-sequenceDecs_decodeSync_bmi2_fill_2_byte_by_byte:
-	CMPQ    BX, $0x00
-	JLE     sequenceDecs_decodeSync_bmi2_fill_2_check_overread
-	CMPQ    DX, $0x07
-	JLE     sequenceDecs_decodeSync_bmi2_fill_2_end
-	SHLQ    $0x08, AX
-	SUBQ    $0x01, R12
-	SUBQ    $0x01, BX
-	SUBQ    $0x08, DX
-	MOVBQZX (R12), CX
-	ORQ     CX, AX
-	JMP     sequenceDecs_decodeSync_bmi2_fill_2_byte_by_byte
-
-sequenceDecs_decodeSync_bmi2_fill_2_check_overread:
-	CMPQ DX, $0x40
-	JA   error_overread
-
-sequenceDecs_decodeSync_bmi2_fill_2_end:
-	// Update literal length
-	MOVQ   $0x00000808, CX
-	BEXTRQ CX, SI, R13
-	MOVQ   AX, R14
-	LEAQ   (DX)(R13*1), CX
-	ROLQ   CL, R14
-	BZHIQ  R13, R14, R14
-	MOVQ   CX, DX
-	MOVQ   SI, CX
-	SHRQ   $0x20, CX
-	ADDQ   R14, CX
-	MOVQ   CX, 24(SP)
-
-	// Fill bitreader for state updates
-	MOVQ    R12, (SP)
-	MOVQ    $0x00000808, CX
-	BEXTRQ  CX, R8, R12
-	MOVQ    ctx+16(FP), CX
-	CMPQ    96(CX), $0x00
-	JZ      sequenceDecs_decodeSync_bmi2_skip_update
-	LEAQ    (SI)(DI*1), R13
-	ADDQ    R8, R13
-	MOVBQZX R13, R13
-	LEAQ    (DX)(R13*1), CX
-	MOVQ    AX, R14
-	MOVQ    CX, DX
-	ROLQ    CL, R14
-	BZHIQ   R13, R14, R14
-
-	// Update Offset State
-	BZHIQ  R8, R14, CX
-	SHRXQ  R8, R14, R14
-	MOVQ   $0x00001010, R13
-	BEXTRQ R13, R8, R8
-	ADDQ   CX, R8
-
-	// Load ctx.ofTable
-	MOVQ ctx+16(FP), CX
-	MOVQ 48(CX), CX
-	MOVQ (CX)(R8*8), R8
-
-	// Update Match Length State
-	BZHIQ  DI, R14, CX
-	SHRXQ  DI, R14, R14
-	MOVQ   $0x00001010, R13
-	BEXTRQ R13, DI, DI
-	ADDQ   CX, DI
-
-	// Load ctx.mlTable
-	MOVQ ctx+16(FP), CX
-	MOVQ 24(CX), CX
-	MOVQ (CX)(DI*8), DI
-
-	// Update Literal Length State
-	BZHIQ  SI, R14, CX
-	MOVQ   $0x00001010, R13
-	BEXTRQ R13, SI, SI
-	ADDQ   CX, SI
-
-	// Load ctx.llTable
-	MOVQ ctx+16(FP), CX
-	MOVQ (CX), CX
-	MOVQ (CX)(SI*8), SI
-
-sequenceDecs_decodeSync_bmi2_skip_update:
-	// Adjust offset
-	MOVQ   s+0(FP), CX
-	MOVQ   8(SP), R13
-	CMPQ   R12, $0x01
-	JBE    sequenceDecs_decodeSync_bmi2_adjust_offsetB_1_or_0
-	MOVUPS 144(CX), X0
-	MOVQ   R13, 144(CX)
-	MOVUPS X0, 152(CX)
-	JMP    sequenceDecs_decodeSync_bmi2_after_adjust
-
-sequenceDecs_decodeSync_bmi2_adjust_offsetB_1_or_0:
-	CMPQ 24(SP), $0x00000000
-	JNE  sequenceDecs_decodeSync_bmi2_adjust_offset_maybezero
-	INCQ R13
-	JMP  sequenceDecs_decodeSync_bmi2_adjust_offset_nonzero
-
-sequenceDecs_decodeSync_bmi2_adjust_offset_maybezero:
-	TESTQ R13, R13
-	JNZ   sequenceDecs_decodeSync_bmi2_adjust_offset_nonzero
-	MOVQ  144(CX), R13
-	JMP   sequenceDecs_decodeSync_bmi2_after_adjust
-
-sequenceDecs_decodeSync_bmi2_adjust_offset_nonzero:
-	MOVQ    R13, R12
-	XORQ    R14, R14
-	MOVQ    $-1, R15
-	CMPQ    R13, $0x03
-	CMOVQEQ R14, R12
-	CMOVQEQ R15, R14
-	ADDQ    144(CX)(R12*8), R14
-	JNZ     sequenceDecs_decodeSync_bmi2_adjust_temp_valid
-	MOVQ    $0x00000001, R14
-
-sequenceDecs_decodeSync_bmi2_adjust_temp_valid:
-	CMPQ R13, $0x01
-	JZ   sequenceDecs_decodeSync_bmi2_adjust_skip
-	MOVQ 152(CX), R12
-	MOVQ R12, 160(CX)
-
-sequenceDecs_decodeSync_bmi2_adjust_skip:
-	MOVQ 144(CX), R12
-	MOVQ R12, 152(CX)
-	MOVQ R14, 144(CX)
-	MOVQ R14, R13
-
-sequenceDecs_decodeSync_bmi2_after_adjust:
-	MOVQ R13, 8(SP)
-
-	// Check values
-	MOVQ  16(SP), CX
-	MOVQ  24(SP), R12
-	LEAQ  (CX)(R12*1), R14
-	MOVQ  s+0(FP), R15
-	ADDQ  R14, 256(R15)
-	MOVQ  ctx+16(FP), R14
-	SUBQ  R12, 104(R14)
-	JS    error_not_enough_literals
-	CMPQ  CX, $0x00020002
-	JA    sequenceDecs_decodeSync_bmi2_error_match_len_too_big
-	TESTQ R13, R13
-	JNZ   sequenceDecs_decodeSync_bmi2_match_len_ofs_ok
-	TESTQ CX, CX
-	JNZ   sequenceDecs_decodeSync_bmi2_error_match_len_ofs_mismatch
-
-sequenceDecs_decodeSync_bmi2_match_len_ofs_ok:
-	MOVQ 24(SP), CX
-	MOVQ 8(SP), R12
-	MOVQ 16(SP), R13
-
-	// Check if we have enough space in s.out
-	LEAQ (CX)(R13*1), R14
-	ADDQ R9, R14
-	CMPQ R14, 32(SP)
-	JA   error_not_enough_space
-
-	// Copy literals
-	TESTQ CX, CX
-	JZ    check_offset
-	XORQ  R14, R14
-
-copy_1:
-	MOVUPS (R10)(R14*1), X0
-	MOVUPS X0, (R9)(R14*1)
-	ADDQ   $0x10, R14
-	CMPQ   R14, CX
-	JB     copy_1
-	ADDQ   CX, R10
-	ADDQ   CX, R9
-	ADDQ   CX, R11
-
-	// Malformed input if seq.mo > t+len(hist) || seq.mo > s.windowSize)
-check_offset:
-	MOVQ R11, CX
-	ADDQ 40(SP), CX
-	CMPQ R12, CX
-	JG   error_match_off_too_big
-	CMPQ R12, 56(SP)
-	JG   error_match_off_too_big
-
-	// Copy match from history
-	MOVQ R12, CX
-	SUBQ R11, CX
-	JLS  copy_match
-	MOVQ 48(SP), R14
-	SUBQ CX, R14
-	CMPQ R13, CX
-	JG   copy_all_from_history
-	MOVQ R13, CX
-	SUBQ $0x10, CX
-	JB   copy_4_small
-
-copy_4_loop:
-	MOVUPS (R14), X0
-	MOVUPS X0, (R9)
-	ADDQ   $0x10, R14
-	ADDQ   $0x10, R9
-	SUBQ   $0x10, CX
-	JAE    copy_4_loop
-	LEAQ   16(R14)(CX*1), R14
-	LEAQ   16(R9)(CX*1), R9
-	MOVUPS -16(R14), X0
-	MOVUPS X0, -16(R9)
-	JMP    copy_4_end
-
-copy_4_small:
-	CMPQ R13, $0x03
-	JE   copy_4_move_3
-	CMPQ R13, $0x08
-	JB   copy_4_move_4through7
-	JMP  copy_4_move_8through16
-
-copy_4_move_3:
-	MOVW (R14), CX
-	MOVB 2(R14), R12
-	MOVW CX, (R9)
-	MOVB R12, 2(R9)
-	ADDQ R13, R14
-	ADDQ R13, R9
-	JMP  copy_4_end
-
-copy_4_move_4through7:
-	MOVL (R14), CX
-	MOVL -4(R14)(R13*1), R12
-	MOVL CX, (R9)
-	MOVL R12, -4(R9)(R13*1)
-	ADDQ R13, R14
-	ADDQ R13, R9
-	JMP  copy_4_end
-
-copy_4_move_8through16:
-	MOVQ (R14), CX
-	MOVQ -8(R14)(R13*1), R12
-	MOVQ CX, (R9)
-	MOVQ R12, -8(R9)(R13*1)
-	ADDQ R13, R14
-	ADDQ R13, R9
-
-copy_4_end:
-	ADDQ R13, R11
-	JMP  handle_loop
-	JMP loop_finished
-
-copy_all_from_history:
-	MOVQ CX, R15
-	SUBQ $0x10, R15
-	JB   copy_5_small
-
-copy_5_loop:
-	MOVUPS (R14), X0
-	MOVUPS X0, (R9)
-	ADDQ   $0x10, R14
-	ADDQ   $0x10, R9
-	SUBQ   $0x10, R15
-	JAE    copy_5_loop
-	LEAQ   16(R14)(R15*1), R14
-	LEAQ   16(R9)(R15*1), R9
-	MOVUPS -16(R14), X0
-	MOVUPS X0, -16(R9)
-	JMP    copy_5_end
-
-copy_5_small:
-	CMPQ CX, $0x03
-	JE   copy_5_move_3
-	JB   copy_5_move_1or2
-	CMPQ CX, $0x08
-	JB   copy_5_move_4through7
-	JMP  copy_5_move_8through16
-
-copy_5_move_1or2:
-	MOVB (R14), R15
-	MOVB -1(R14)(CX*1), BP
-	MOVB R15, (R9)
-	MOVB BP, -1(R9)(CX*1)
-	ADDQ CX, R14
-	ADDQ CX, R9
-	JMP  copy_5_end
-
-copy_5_move_3:
-	MOVW (R14), R15
-	MOVB 2(R14), BP
-	MOVW R15, (R9)
-	MOVB BP, 2(R9)
-	ADDQ CX, R14
-	ADDQ CX, R9
-	JMP  copy_5_end
-
-copy_5_move_4through7:
-	MOVL (R14), R15
-	MOVL -4(R14)(CX*1), BP
-	MOVL R15, (R9)
-	MOVL BP, -4(R9)(CX*1)
-	ADDQ CX, R14
-	ADDQ CX, R9
-	JMP  copy_5_end
-
-copy_5_move_8through16:
-	MOVQ (R14), R15
-	MOVQ -8(R14)(CX*1), BP
-	MOVQ R15, (R9)
-	MOVQ BP, -8(R9)(CX*1)
-	ADDQ CX, R14
-	ADDQ CX, R9
-
-copy_5_end:
-	ADDQ CX, R11
-	SUBQ CX, R13
-
-	// Copy match from the current buffer
-copy_match:
-	MOVQ R9, CX
-	SUBQ R12, CX
-
-	// ml <= mo
-	CMPQ R13, R12
-	JA   copy_overlapping_match
-
-	// Copy non-overlapping match
-	ADDQ R13, R11
-	MOVQ R9, R12
-	ADDQ R13, R9
-
-copy_2:
-	MOVUPS (CX), X0
-	MOVUPS X0, (R12)
-	ADDQ   $0x10, CX
-	ADDQ   $0x10, R12
-	SUBQ   $0x10, R13
-	JHI    copy_2
-	JMP    handle_loop
-
-	// Copy overlapping match
-copy_overlapping_match:
-	ADDQ R13, R11
-
-copy_slow_3:
-	MOVB (CX), R12
-	MOVB R12, (R9)
-	INCQ CX
-	INCQ R9
-	DECQ R13
-	JNZ  copy_slow_3
-
-handle_loop:
-	MOVQ ctx+16(FP), CX
-	DECQ 96(CX)
-	JNS  sequenceDecs_decodeSync_bmi2_main_loop
-
-loop_finished:
-	MOVQ br+8(FP), CX
-	MOVQ AX, 32(CX)
-	MOVB DL, 40(CX)
-	MOVQ BX, 24(CX)
-
-	// Update the context
-	MOVQ ctx+16(FP), AX
-	MOVQ R11, 136(AX)
-	MOVQ 144(AX), CX
-	SUBQ CX, R10
-	MOVQ R10, 168(AX)
-
-	// Return success
-	MOVQ $0x00000000, ret+24(FP)
-	RET
-
-	// Return with match length error
-sequenceDecs_decodeSync_bmi2_error_match_len_ofs_mismatch:
-	MOVQ 16(SP), AX
-	MOVQ ctx+16(FP), CX
-	MOVQ AX, 216(CX)
-	MOVQ $0x00000001, ret+24(FP)
-	RET
-
-	// Return with match too long error
-sequenceDecs_decodeSync_bmi2_error_match_len_too_big:
-	MOVQ ctx+16(FP), AX
-	MOVQ 16(SP), CX
-	MOVQ CX, 216(AX)
-	MOVQ $0x00000002, ret+24(FP)
-	RET
-
-	// Return with match offset too long error
-error_match_off_too_big:
-	MOVQ ctx+16(FP), AX
-	MOVQ 8(SP), CX
-	MOVQ CX, 224(AX)
-	MOVQ R11, 136(AX)
-	MOVQ $0x00000003, ret+24(FP)
-	RET
-
-	// Return with not enough literals error
-error_not_enough_literals:
-	MOVQ ctx+16(FP), AX
-	MOVQ 24(SP), CX
-	MOVQ CX, 208(AX)
-	MOVQ $0x00000004, ret+24(FP)
-	RET
-
-	// Return with overread error
-error_overread:
-	MOVQ $0x00000006, ret+24(FP)
-	RET
-
-	// Return with not enough output space error
-error_not_enough_space:
-	MOVQ ctx+16(FP), AX
-	MOVQ 24(SP), CX
-	MOVQ CX, 208(AX)
-	MOVQ 16(SP), CX
-	MOVQ CX, 216(AX)
-	MOVQ R11, 136(AX)
-	MOVQ $0x00000005, ret+24(FP)
-	RET
-
-// func sequenceDecs_decodeSync_safe_amd64(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
-// Requires: CMOV, SSE
-TEXT ·sequenceDecs_decodeSync_safe_amd64(SB), $64-32
-	MOVQ    br+8(FP), AX
-	MOVQ    32(AX), DX
-	MOVBQZX 40(AX), BX
-	MOVQ    24(AX), SI
-	MOVQ    (AX), AX
-	ADDQ    SI, AX
-	MOVQ    AX, (SP)
-	MOVQ    ctx+16(FP), AX
-	MOVQ    72(AX), DI
-	MOVQ    80(AX), R8
-	MOVQ    88(AX), R9
-	XORQ    CX, CX
-	MOVQ    CX, 8(SP)
-	MOVQ    CX, 16(SP)
-	MOVQ    CX, 24(SP)
-	MOVQ    112(AX), R10
-	MOVQ    128(AX), CX
-	MOVQ    CX, 32(SP)
-	MOVQ    144(AX), R11
-	MOVQ    136(AX), R12
-	MOVQ    200(AX), CX
-	MOVQ    CX, 56(SP)
-	MOVQ    176(AX), CX
-	MOVQ    CX, 48(SP)
-	MOVQ    184(AX), AX
-	MOVQ    AX, 40(SP)
-	MOVQ    40(SP), AX
-	ADDQ    AX, 48(SP)
-
-	// Calculate poiter to s.out[cap(s.out)] (a past-end pointer)
-	ADDQ R10, 32(SP)
-
-	// outBase += outPosition
-	ADDQ R12, R10
-
-sequenceDecs_decodeSync_safe_amd64_main_loop:
-	MOVQ (SP), R13
-
-	// Fill bitreader to have enough for the offset and match length.
-	CMPQ SI, $0x08
-	JL   sequenceDecs_decodeSync_safe_amd64_fill_byte_by_byte
-	MOVQ BX, AX
-	SHRQ $0x03, AX
-	SUBQ AX, R13
-	MOVQ (R13), DX
-	SUBQ AX, SI
-	ANDQ $0x07, BX
-	JMP  sequenceDecs_decodeSync_safe_amd64_fill_end
-
-sequenceDecs_decodeSync_safe_amd64_fill_byte_by_byte:
-	CMPQ    SI, $0x00
-	JLE     sequenceDecs_decodeSync_safe_amd64_fill_check_overread
-	CMPQ    BX, $0x07
-	JLE     sequenceDecs_decodeSync_safe_amd64_fill_end
-	SHLQ    $0x08, DX
-	SUBQ    $0x01, R13
-	SUBQ    $0x01, SI
-	SUBQ    $0x08, BX
-	MOVBQZX (R13), AX
-	ORQ     AX, DX
-	JMP     sequenceDecs_decodeSync_safe_amd64_fill_byte_by_byte
-
-sequenceDecs_decodeSync_safe_amd64_fill_check_overread:
-	CMPQ BX, $0x40
-	JA   error_overread
-
-sequenceDecs_decodeSync_safe_amd64_fill_end:
-	// Update offset
-	MOVQ  R9, AX
-	MOVQ  BX, CX
-	MOVQ  DX, R14
-	SHLQ  CL, R14
-	MOVB  AH, CL
-	SHRQ  $0x20, AX
-	TESTQ CX, CX
-	JZ    sequenceDecs_decodeSync_safe_amd64_of_update_zero
-	ADDQ  CX, BX
-	CMPQ  BX, $0x40
-	JA    sequenceDecs_decodeSync_safe_amd64_of_update_zero
-	CMPQ  CX, $0x40
-	JAE   sequenceDecs_decodeSync_safe_amd64_of_update_zero
-	NEGQ  CX
-	SHRQ  CL, R14
-	ADDQ  R14, AX
-
-sequenceDecs_decodeSync_safe_amd64_of_update_zero:
-	MOVQ AX, 8(SP)
-
-	// Update match length
-	MOVQ  R8, AX
-	MOVQ  BX, CX
-	MOVQ  DX, R14
-	SHLQ  CL, R14
-	MOVB  AH, CL
-	SHRQ  $0x20, AX
-	TESTQ CX, CX
-	JZ    sequenceDecs_decodeSync_safe_amd64_ml_update_zero
-	ADDQ  CX, BX
-	CMPQ  BX, $0x40
-	JA    sequenceDecs_decodeSync_safe_amd64_ml_update_zero
-	CMPQ  CX, $0x40
-	JAE   sequenceDecs_decodeSync_safe_amd64_ml_update_zero
-	NEGQ  CX
-	SHRQ  CL, R14
-	ADDQ  R14, AX
-
-sequenceDecs_decodeSync_safe_amd64_ml_update_zero:
-	MOVQ AX, 16(SP)
-
-	// Fill bitreader to have enough for the remaining
-	CMPQ SI, $0x08
-	JL   sequenceDecs_decodeSync_safe_amd64_fill_2_byte_by_byte
-	MOVQ BX, AX
-	SHRQ $0x03, AX
-	SUBQ AX, R13
-	MOVQ (R13), DX
-	SUBQ AX, SI
-	ANDQ $0x07, BX
-	JMP  sequenceDecs_decodeSync_safe_amd64_fill_2_end
-
-sequenceDecs_decodeSync_safe_amd64_fill_2_byte_by_byte:
-	CMPQ    SI, $0x00
-	JLE     sequenceDecs_decodeSync_safe_amd64_fill_2_check_overread
-	CMPQ    BX, $0x07
-	JLE     sequenceDecs_decodeSync_safe_amd64_fill_2_end
-	SHLQ    $0x08, DX
-	SUBQ    $0x01, R13
-	SUBQ    $0x01, SI
-	SUBQ    $0x08, BX
-	MOVBQZX (R13), AX
-	ORQ     AX, DX
-	JMP     sequenceDecs_decodeSync_safe_amd64_fill_2_byte_by_byte
-
-sequenceDecs_decodeSync_safe_amd64_fill_2_check_overread:
-	CMPQ BX, $0x40
-	JA   error_overread
-
-sequenceDecs_decodeSync_safe_amd64_fill_2_end:
-	// Update literal length
-	MOVQ  DI, AX
-	MOVQ  BX, CX
-	MOVQ  DX, R14
-	SHLQ  CL, R14
-	MOVB  AH, CL
-	SHRQ  $0x20, AX
-	TESTQ CX, CX
-	JZ    sequenceDecs_decodeSync_safe_amd64_ll_update_zero
-	ADDQ  CX, BX
-	CMPQ  BX, $0x40
-	JA    sequenceDecs_decodeSync_safe_amd64_ll_update_zero
-	CMPQ  CX, $0x40
-	JAE   sequenceDecs_decodeSync_safe_amd64_ll_update_zero
-	NEGQ  CX
-	SHRQ  CL, R14
-	ADDQ  R14, AX
-
-sequenceDecs_decodeSync_safe_amd64_ll_update_zero:
-	MOVQ AX, 24(SP)
-
-	// Fill bitreader for state updates
-	MOVQ    R13, (SP)
-	MOVQ    R9, AX
-	SHRQ    $0x08, AX
-	MOVBQZX AL, AX
-	MOVQ    ctx+16(FP), CX
-	CMPQ    96(CX), $0x00
-	JZ      sequenceDecs_decodeSync_safe_amd64_skip_update
-
-	// Update Literal Length State
-	MOVBQZX DI, R13
-	SHRQ    $0x10, DI
-	MOVWQZX DI, DI
-	LEAQ    (BX)(R13*1), CX
-	MOVQ    DX, R14
-	MOVQ    CX, BX
-	ROLQ    CL, R14
-	MOVL    $0x00000001, R15
-	MOVB    R13, CL
-	SHLL    CL, R15
-	DECL    R15
-	ANDQ    R15, R14
-	ADDQ    R14, DI
-
-	// Load ctx.llTable
-	MOVQ ctx+16(FP), CX
-	MOVQ (CX), CX
-	MOVQ (CX)(DI*8), DI
-
-	// Update Match Length State
-	MOVBQZX R8, R13
-	SHRQ    $0x10, R8
-	MOVWQZX R8, R8
-	LEAQ    (BX)(R13*1), CX
-	MOVQ    DX, R14
-	MOVQ    CX, BX
-	ROLQ    CL, R14
-	MOVL    $0x00000001, R15
-	MOVB    R13, CL
-	SHLL    CL, R15
-	DECL    R15
-	ANDQ    R15, R14
-	ADDQ    R14, R8
-
-	// Load ctx.mlTable
-	MOVQ ctx+16(FP), CX
-	MOVQ 24(CX), CX
-	MOVQ (CX)(R8*8), R8
-
-	// Update Offset State
-	MOVBQZX R9, R13
-	SHRQ    $0x10, R9
-	MOVWQZX R9, R9
-	LEAQ    (BX)(R13*1), CX
-	MOVQ    DX, R14
-	MOVQ    CX, BX
-	ROLQ    CL, R14
-	MOVL    $0x00000001, R15
-	MOVB    R13, CL
-	SHLL    CL, R15
-	DECL    R15
-	ANDQ    R15, R14
-	ADDQ    R14, R9
-
-	// Load ctx.ofTable
-	MOVQ ctx+16(FP), CX
-	MOVQ 48(CX), CX
-	MOVQ (CX)(R9*8), R9
-
-sequenceDecs_decodeSync_safe_amd64_skip_update:
-	// Adjust offset
-	MOVQ   s+0(FP), CX
-	MOVQ   8(SP), R13
-	CMPQ   AX, $0x01
-	JBE    sequenceDecs_decodeSync_safe_amd64_adjust_offsetB_1_or_0
-	MOVUPS 144(CX), X0
-	MOVQ   R13, 144(CX)
-	MOVUPS X0, 152(CX)
-	JMP    sequenceDecs_decodeSync_safe_amd64_after_adjust
-
-sequenceDecs_decodeSync_safe_amd64_adjust_offsetB_1_or_0:
-	CMPQ 24(SP), $0x00000000
-	JNE  sequenceDecs_decodeSync_safe_amd64_adjust_offset_maybezero
-	INCQ R13
-	JMP  sequenceDecs_decodeSync_safe_amd64_adjust_offset_nonzero
-
-sequenceDecs_decodeSync_safe_amd64_adjust_offset_maybezero:
-	TESTQ R13, R13
-	JNZ   sequenceDecs_decodeSync_safe_amd64_adjust_offset_nonzero
-	MOVQ  144(CX), R13
-	JMP   sequenceDecs_decodeSync_safe_amd64_after_adjust
-
-sequenceDecs_decodeSync_safe_amd64_adjust_offset_nonzero:
-	MOVQ    R13, AX
-	XORQ    R14, R14
-	MOVQ    $-1, R15
-	CMPQ    R13, $0x03
-	CMOVQEQ R14, AX
-	CMOVQEQ R15, R14
-	ADDQ    144(CX)(AX*8), R14
-	JNZ     sequenceDecs_decodeSync_safe_amd64_adjust_temp_valid
-	MOVQ    $0x00000001, R14
-
-sequenceDecs_decodeSync_safe_amd64_adjust_temp_valid:
-	CMPQ R13, $0x01
-	JZ   sequenceDecs_decodeSync_safe_amd64_adjust_skip
-	MOVQ 152(CX), AX
-	MOVQ AX, 160(CX)
-
-sequenceDecs_decodeSync_safe_amd64_adjust_skip:
-	MOVQ 144(CX), AX
-	MOVQ AX, 152(CX)
-	MOVQ R14, 144(CX)
-	MOVQ R14, R13
-
-sequenceDecs_decodeSync_safe_amd64_after_adjust:
-	MOVQ R13, 8(SP)
-
-	// Check values
-	MOVQ  16(SP), AX
-	MOVQ  24(SP), CX
-	LEAQ  (AX)(CX*1), R14
-	MOVQ  s+0(FP), R15
-	ADDQ  R14, 256(R15)
-	MOVQ  ctx+16(FP), R14
-	SUBQ  CX, 104(R14)
-	JS    error_not_enough_literals
-	CMPQ  AX, $0x00020002
-	JA    sequenceDecs_decodeSync_safe_amd64_error_match_len_too_big
-	TESTQ R13, R13
-	JNZ   sequenceDecs_decodeSync_safe_amd64_match_len_ofs_ok
-	TESTQ AX, AX
-	JNZ   sequenceDecs_decodeSync_safe_amd64_error_match_len_ofs_mismatch
-
-sequenceDecs_decodeSync_safe_amd64_match_len_ofs_ok:
-	MOVQ 24(SP), AX
-	MOVQ 8(SP), CX
-	MOVQ 16(SP), R13
-
-	// Check if we have enough space in s.out
-	LEAQ (AX)(R13*1), R14
-	ADDQ R10, R14
-	CMPQ R14, 32(SP)
-	JA   error_not_enough_space
-
-	// Copy literals
-	TESTQ AX, AX
-	JZ    check_offset
-	MOVQ  AX, R14
-	SUBQ  $0x10, R14
-	JB    copy_1_small
-
-copy_1_loop:
-	MOVUPS (R11), X0
-	MOVUPS X0, (R10)
-	ADDQ   $0x10, R11
-	ADDQ   $0x10, R10
-	SUBQ   $0x10, R14
-	JAE    copy_1_loop
-	LEAQ   16(R11)(R14*1), R11
-	LEAQ   16(R10)(R14*1), R10
-	MOVUPS -16(R11), X0
-	MOVUPS X0, -16(R10)
-	JMP    copy_1_end
-
-copy_1_small:
-	CMPQ AX, $0x03
-	JE   copy_1_move_3
-	JB   copy_1_move_1or2
-	CMPQ AX, $0x08
-	JB   copy_1_move_4through7
-	JMP  copy_1_move_8through16
-
-copy_1_move_1or2:
-	MOVB (R11), R14
-	MOVB -1(R11)(AX*1), R15
-	MOVB R14, (R10)
-	MOVB R15, -1(R10)(AX*1)
-	ADDQ AX, R11
-	ADDQ AX, R10
-	JMP  copy_1_end
-
-copy_1_move_3:
-	MOVW (R11), R14
-	MOVB 2(R11), R15
-	MOVW R14, (R10)
-	MOVB R15, 2(R10)
-	ADDQ AX, R11
-	ADDQ AX, R10
-	JMP  copy_1_end
-
-copy_1_move_4through7:
-	MOVL (R11), R14
-	MOVL -4(R11)(AX*1), R15
-	MOVL R14, (R10)
-	MOVL R15, -4(R10)(AX*1)
-	ADDQ AX, R11
-	ADDQ AX, R10
-	JMP  copy_1_end
-
-copy_1_move_8through16:
-	MOVQ (R11), R14
-	MOVQ -8(R11)(AX*1), R15
-	MOVQ R14, (R10)
-	MOVQ R15, -8(R10)(AX*1)
-	ADDQ AX, R11
-	ADDQ AX, R10
-
-copy_1_end:
-	ADDQ AX, R12
-
-	// Malformed input if seq.mo > t+len(hist) || seq.mo > s.windowSize)
-check_offset:
-	MOVQ R12, AX
-	ADDQ 40(SP), AX
-	CMPQ CX, AX
-	JG   error_match_off_too_big
-	CMPQ CX, 56(SP)
-	JG   error_match_off_too_big
-
-	// Copy match from history
-	MOVQ CX, AX
-	SUBQ R12, AX
-	JLS  copy_match
-	MOVQ 48(SP), R14
-	SUBQ AX, R14
-	CMPQ R13, AX
-	JG   copy_all_from_history
-	MOVQ R13, AX
-	SUBQ $0x10, AX
-	JB   copy_4_small
-
-copy_4_loop:
-	MOVUPS (R14), X0
-	MOVUPS X0, (R10)
-	ADDQ   $0x10, R14
-	ADDQ   $0x10, R10
-	SUBQ   $0x10, AX
-	JAE    copy_4_loop
-	LEAQ   16(R14)(AX*1), R14
-	LEAQ   16(R10)(AX*1), R10
-	MOVUPS -16(R14), X0
-	MOVUPS X0, -16(R10)
-	JMP    copy_4_end
-
-copy_4_small:
-	CMPQ R13, $0x03
-	JE   copy_4_move_3
-	CMPQ R13, $0x08
-	JB   copy_4_move_4through7
-	JMP  copy_4_move_8through16
-
-copy_4_move_3:
-	MOVW (R14), AX
-	MOVB 2(R14), CL
-	MOVW AX, (R10)
-	MOVB CL, 2(R10)
-	ADDQ R13, R14
-	ADDQ R13, R10
-	JMP  copy_4_end
-
-copy_4_move_4through7:
-	MOVL (R14), AX
-	MOVL -4(R14)(R13*1), CX
-	MOVL AX, (R10)
-	MOVL CX, -4(R10)(R13*1)
-	ADDQ R13, R14
-	ADDQ R13, R10
-	JMP  copy_4_end
-
-copy_4_move_8through16:
-	MOVQ (R14), AX
-	MOVQ -8(R14)(R13*1), CX
-	MOVQ AX, (R10)
-	MOVQ CX, -8(R10)(R13*1)
-	ADDQ R13, R14
-	ADDQ R13, R10
-
-copy_4_end:
-	ADDQ R13, R12
-	JMP  handle_loop
-	JMP loop_finished
-
-copy_all_from_history:
-	MOVQ AX, R15
-	SUBQ $0x10, R15
-	JB   copy_5_small
-
-copy_5_loop:
-	MOVUPS (R14), X0
-	MOVUPS X0, (R10)
-	ADDQ   $0x10, R14
-	ADDQ   $0x10, R10
-	SUBQ   $0x10, R15
-	JAE    copy_5_loop
-	LEAQ   16(R14)(R15*1), R14
-	LEAQ   16(R10)(R15*1), R10
-	MOVUPS -16(R14), X0
-	MOVUPS X0, -16(R10)
-	JMP    copy_5_end
-
-copy_5_small:
-	CMPQ AX, $0x03
-	JE   copy_5_move_3
-	JB   copy_5_move_1or2
-	CMPQ AX, $0x08
-	JB   copy_5_move_4through7
-	JMP  copy_5_move_8through16
-
-copy_5_move_1or2:
-	MOVB (R14), R15
-	MOVB -1(R14)(AX*1), BP
-	MOVB R15, (R10)
-	MOVB BP, -1(R10)(AX*1)
-	ADDQ AX, R14
-	ADDQ AX, R10
-	JMP  copy_5_end
-
-copy_5_move_3:
-	MOVW (R14), R15
-	MOVB 2(R14), BP
-	MOVW R15, (R10)
-	MOVB BP, 2(R10)
-	ADDQ AX, R14
-	ADDQ AX, R10
-	JMP  copy_5_end
-
-copy_5_move_4through7:
-	MOVL (R14), R15
-	MOVL -4(R14)(AX*1), BP
-	MOVL R15, (R10)
-	MOVL BP, -4(R10)(AX*1)
-	ADDQ AX, R14
-	ADDQ AX, R10
-	JMP  copy_5_end
-
-copy_5_move_8through16:
-	MOVQ (R14), R15
-	MOVQ -8(R14)(AX*1), BP
-	MOVQ R15, (R10)
-	MOVQ BP, -8(R10)(AX*1)
-	ADDQ AX, R14
-	ADDQ AX, R10
-
-copy_5_end:
-	ADDQ AX, R12
-	SUBQ AX, R13
-
-	// Copy match from the current buffer
-copy_match:
-	MOVQ R10, AX
-	SUBQ CX, AX
-
-	// ml <= mo
-	CMPQ R13, CX
-	JA   copy_overlapping_match
-
-	// Copy non-overlapping match
-	ADDQ R13, R12
-	MOVQ R13, CX
-	SUBQ $0x10, CX
-	JB   copy_2_small
-
-copy_2_loop:
-	MOVUPS (AX), X0
-	MOVUPS X0, (R10)
-	ADDQ   $0x10, AX
-	ADDQ   $0x10, R10
-	SUBQ   $0x10, CX
-	JAE    copy_2_loop
-	LEAQ   16(AX)(CX*1), AX
-	LEAQ   16(R10)(CX*1), R10
-	MOVUPS -16(AX), X0
-	MOVUPS X0, -16(R10)
-	JMP    copy_2_end
-
-copy_2_small:
-	CMPQ R13, $0x03
-	JE   copy_2_move_3
-	JB   copy_2_move_1or2
-	CMPQ R13, $0x08
-	JB   copy_2_move_4through7
-	JMP  copy_2_move_8through16
-
-copy_2_move_1or2:
-	MOVB (AX), CL
-	MOVB -1(AX)(R13*1), R14
-	MOVB CL, (R10)
-	MOVB R14, -1(R10)(R13*1)
-	ADDQ R13, AX
-	ADDQ R13, R10
-	JMP  copy_2_end
-
-copy_2_move_3:
-	MOVW (AX), CX
-	MOVB 2(AX), R14
-	MOVW CX, (R10)
-	MOVB R14, 2(R10)
-	ADDQ R13, AX
-	ADDQ R13, R10
-	JMP  copy_2_end
-
-copy_2_move_4through7:
-	MOVL (AX), CX
-	MOVL -4(AX)(R13*1), R14
-	MOVL CX, (R10)
-	MOVL R14, -4(R10)(R13*1)
-	ADDQ R13, AX
-	ADDQ R13, R10
-	JMP  copy_2_end
-
-copy_2_move_8through16:
-	MOVQ (AX), CX
-	MOVQ -8(AX)(R13*1), R14
-	MOVQ CX, (R10)
-	MOVQ R14, -8(R10)(R13*1)
-	ADDQ R13, AX
-	ADDQ R13, R10
-
-copy_2_end:
-	JMP handle_loop
-
-	// Copy overlapping match
-copy_overlapping_match:
-	ADDQ R13, R12
-
-copy_slow_3:
-	MOVB (AX), CL
-	MOVB CL, (R10)
-	INCQ AX
-	INCQ R10
-	DECQ R13
-	JNZ  copy_slow_3
-
-handle_loop:
-	MOVQ ctx+16(FP), AX
-	DECQ 96(AX)
-	JNS  sequenceDecs_decodeSync_safe_amd64_main_loop
-
-loop_finished:
-	MOVQ br+8(FP), AX
-	MOVQ DX, 32(AX)
-	MOVB BL, 40(AX)
-	MOVQ SI, 24(AX)
-
-	// Update the context
-	MOVQ ctx+16(FP), AX
-	MOVQ R12, 136(AX)
-	MOVQ 144(AX), CX
-	SUBQ CX, R11
-	MOVQ R11, 168(AX)
-
-	// Return success
-	MOVQ $0x00000000, ret+24(FP)
-	RET
-
-	// Return with match length error
-sequenceDecs_decodeSync_safe_amd64_error_match_len_ofs_mismatch:
-	MOVQ 16(SP), AX
-	MOVQ ctx+16(FP), CX
-	MOVQ AX, 216(CX)
-	MOVQ $0x00000001, ret+24(FP)
-	RET
-
-	// Return with match too long error
-sequenceDecs_decodeSync_safe_amd64_error_match_len_too_big:
-	MOVQ ctx+16(FP), AX
-	MOVQ 16(SP), CX
-	MOVQ CX, 216(AX)
-	MOVQ $0x00000002, ret+24(FP)
-	RET
-
-	// Return with match offset too long error
-error_match_off_too_big:
-	MOVQ ctx+16(FP), AX
-	MOVQ 8(SP), CX
-	MOVQ CX, 224(AX)
-	MOVQ R12, 136(AX)
-	MOVQ $0x00000003, ret+24(FP)
-	RET
-
-	// Return with not enough literals error
-error_not_enough_literals:
-	MOVQ ctx+16(FP), AX
-	MOVQ 24(SP), CX
-	MOVQ CX, 208(AX)
-	MOVQ $0x00000004, ret+24(FP)
-	RET
-
-	// Return with overread error
-error_overread:
-	MOVQ $0x00000006, ret+24(FP)
-	RET
-
-	// Return with not enough output space error
-error_not_enough_space:
-	MOVQ ctx+16(FP), AX
-	MOVQ 24(SP), CX
-	MOVQ CX, 208(AX)
-	MOVQ 16(SP), CX
-	MOVQ CX, 216(AX)
-	MOVQ R12, 136(AX)
-	MOVQ $0x00000005, ret+24(FP)
-	RET
-
-// func sequenceDecs_decodeSync_safe_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
-// Requires: BMI, BMI2, CMOV, SSE
-TEXT ·sequenceDecs_decodeSync_safe_bmi2(SB), $64-32
-	MOVQ    br+8(FP), CX
-	MOVQ    32(CX), AX
-	MOVBQZX 40(CX), DX
-	MOVQ    24(CX), BX
-	MOVQ    (CX), CX
-	ADDQ    BX, CX
-	MOVQ    CX, (SP)
-	MOVQ    ctx+16(FP), CX
-	MOVQ    72(CX), SI
-	MOVQ    80(CX), DI
-	MOVQ    88(CX), R8
-	XORQ    R9, R9
-	MOVQ    R9, 8(SP)
-	MOVQ    R9, 16(SP)
-	MOVQ    R9, 24(SP)
-	MOVQ    112(CX), R9
-	MOVQ    128(CX), R10
-	MOVQ    R10, 32(SP)
-	MOVQ    144(CX), R10
-	MOVQ    136(CX), R11
-	MOVQ    200(CX), R12
-	MOVQ    R12, 56(SP)
-	MOVQ    176(CX), R12
-	MOVQ    R12, 48(SP)
-	MOVQ    184(CX), CX
-	MOVQ    CX, 40(SP)
-	MOVQ    40(SP), CX
-	ADDQ    CX, 48(SP)
-
-	// Calculate poiter to s.out[cap(s.out)] (a past-end pointer)
-	ADDQ R9, 32(SP)
-
-	// outBase += outPosition
-	ADDQ R11, R9
-
-sequenceDecs_decodeSync_safe_bmi2_main_loop:
-	MOVQ (SP), R12
-
-	// Fill bitreader to have enough for the offset and match length.
-	CMPQ BX, $0x08
-	JL   sequenceDecs_decodeSync_safe_bmi2_fill_byte_by_byte
-	MOVQ DX, CX
-	SHRQ $0x03, CX
-	SUBQ CX, R12
-	MOVQ (R12), AX
-	SUBQ CX, BX
-	ANDQ $0x07, DX
-	JMP  sequenceDecs_decodeSync_safe_bmi2_fill_end
-
-sequenceDecs_decodeSync_safe_bmi2_fill_byte_by_byte:
-	CMPQ    BX, $0x00
-	JLE     sequenceDecs_decodeSync_safe_bmi2_fill_check_overread
-	CMPQ    DX, $0x07
-	JLE     sequenceDecs_decodeSync_safe_bmi2_fill_end
-	SHLQ    $0x08, AX
-	SUBQ    $0x01, R12
-	SUBQ    $0x01, BX
-	SUBQ    $0x08, DX
-	MOVBQZX (R12), CX
-	ORQ     CX, AX
-	JMP     sequenceDecs_decodeSync_safe_bmi2_fill_byte_by_byte
-
-sequenceDecs_decodeSync_safe_bmi2_fill_check_overread:
-	CMPQ DX, $0x40
-	JA   error_overread
-
-sequenceDecs_decodeSync_safe_bmi2_fill_end:
-	// Update offset
-	MOVQ   $0x00000808, CX
-	BEXTRQ CX, R8, R13
-	MOVQ   AX, R14
-	LEAQ   (DX)(R13*1), CX
-	ROLQ   CL, R14
-	BZHIQ  R13, R14, R14
-	MOVQ   CX, DX
-	MOVQ   R8, CX
-	SHRQ   $0x20, CX
-	ADDQ   R14, CX
-	MOVQ   CX, 8(SP)
-
-	// Update match length
-	MOVQ   $0x00000808, CX
-	BEXTRQ CX, DI, R13
-	MOVQ   AX, R14
-	LEAQ   (DX)(R13*1), CX
-	ROLQ   CL, R14
-	BZHIQ  R13, R14, R14
-	MOVQ   CX, DX
-	MOVQ   DI, CX
-	SHRQ   $0x20, CX
-	ADDQ   R14, CX
-	MOVQ   CX, 16(SP)
-
-	// Fill bitreader to have enough for the remaining
-	CMPQ BX, $0x08
-	JL   sequenceDecs_decodeSync_safe_bmi2_fill_2_byte_by_byte
-	MOVQ DX, CX
-	SHRQ $0x03, CX
-	SUBQ CX, R12
-	MOVQ (R12), AX
-	SUBQ CX, BX
-	ANDQ $0x07, DX
-	JMP  sequenceDecs_decodeSync_safe_bmi2_fill_2_end
-
-sequenceDecs_decodeSync_safe_bmi2_fill_2_byte_by_byte:
-	CMPQ    BX, $0x00
-	JLE     sequenceDecs_decodeSync_safe_bmi2_fill_2_check_overread
-	CMPQ    DX, $0x07
-	JLE     sequenceDecs_decodeSync_safe_bmi2_fill_2_end
-	SHLQ    $0x08, AX
-	SUBQ    $0x01, R12
-	SUBQ    $0x01, BX
-	SUBQ    $0x08, DX
-	MOVBQZX (R12), CX
-	ORQ     CX, AX
-	JMP     sequenceDecs_decodeSync_safe_bmi2_fill_2_byte_by_byte
-
-sequenceDecs_decodeSync_safe_bmi2_fill_2_check_overread:
-	CMPQ DX, $0x40
-	JA   error_overread
-
-sequenceDecs_decodeSync_safe_bmi2_fill_2_end:
-	// Update literal length
-	MOVQ   $0x00000808, CX
-	BEXTRQ CX, SI, R13
-	MOVQ   AX, R14
-	LEAQ   (DX)(R13*1), CX
-	ROLQ   CL, R14
-	BZHIQ  R13, R14, R14
-	MOVQ   CX, DX
-	MOVQ   SI, CX
-	SHRQ   $0x20, CX
-	ADDQ   R14, CX
-	MOVQ   CX, 24(SP)
-
-	// Fill bitreader for state updates
-	MOVQ    R12, (SP)
-	MOVQ    $0x00000808, CX
-	BEXTRQ  CX, R8, R12
-	MOVQ    ctx+16(FP), CX
-	CMPQ    96(CX), $0x00
-	JZ      sequenceDecs_decodeSync_safe_bmi2_skip_update
-	LEAQ    (SI)(DI*1), R13
-	ADDQ    R8, R13
-	MOVBQZX R13, R13
-	LEAQ    (DX)(R13*1), CX
-	MOVQ    AX, R14
-	MOVQ    CX, DX
-	ROLQ    CL, R14
-	BZHIQ   R13, R14, R14
-
-	// Update Offset State
-	BZHIQ  R8, R14, CX
-	SHRXQ  R8, R14, R14
-	MOVQ   $0x00001010, R13
-	BEXTRQ R13, R8, R8
-	ADDQ   CX, R8
-
-	// Load ctx.ofTable
-	MOVQ ctx+16(FP), CX
-	MOVQ 48(CX), CX
-	MOVQ (CX)(R8*8), R8
-
-	// Update Match Length State
-	BZHIQ  DI, R14, CX
-	SHRXQ  DI, R14, R14
-	MOVQ   $0x00001010, R13
-	BEXTRQ R13, DI, DI
-	ADDQ   CX, DI
-
-	// Load ctx.mlTable
-	MOVQ ctx+16(FP), CX
-	MOVQ 24(CX), CX
-	MOVQ (CX)(DI*8), DI
-
-	// Update Literal Length State
-	BZHIQ  SI, R14, CX
-	MOVQ   $0x00001010, R13
-	BEXTRQ R13, SI, SI
-	ADDQ   CX, SI
-
-	// Load ctx.llTable
-	MOVQ ctx+16(FP), CX
-	MOVQ (CX), CX
-	MOVQ (CX)(SI*8), SI
-
-sequenceDecs_decodeSync_safe_bmi2_skip_update:
-	// Adjust offset
-	MOVQ   s+0(FP), CX
-	MOVQ   8(SP), R13
-	CMPQ   R12, $0x01
-	JBE    sequenceDecs_decodeSync_safe_bmi2_adjust_offsetB_1_or_0
-	MOVUPS 144(CX), X0
-	MOVQ   R13, 144(CX)
-	MOVUPS X0, 152(CX)
-	JMP    sequenceDecs_decodeSync_safe_bmi2_after_adjust
-
-sequenceDecs_decodeSync_safe_bmi2_adjust_offsetB_1_or_0:
-	CMPQ 24(SP), $0x00000000
-	JNE  sequenceDecs_decodeSync_safe_bmi2_adjust_offset_maybezero
-	INCQ R13
-	JMP  sequenceDecs_decodeSync_safe_bmi2_adjust_offset_nonzero
-
-sequenceDecs_decodeSync_safe_bmi2_adjust_offset_maybezero:
-	TESTQ R13, R13
-	JNZ   sequenceDecs_decodeSync_safe_bmi2_adjust_offset_nonzero
-	MOVQ  144(CX), R13
-	JMP   sequenceDecs_decodeSync_safe_bmi2_after_adjust
-
-sequenceDecs_decodeSync_safe_bmi2_adjust_offset_nonzero:
-	MOVQ    R13, R12
-	XORQ    R14, R14
-	MOVQ    $-1, R15
-	CMPQ    R13, $0x03
-	CMOVQEQ R14, R12
-	CMOVQEQ R15, R14
-	ADDQ    144(CX)(R12*8), R14
-	JNZ     sequenceDecs_decodeSync_safe_bmi2_adjust_temp_valid
-	MOVQ    $0x00000001, R14
-
-sequenceDecs_decodeSync_safe_bmi2_adjust_temp_valid:
-	CMPQ R13, $0x01
-	JZ   sequenceDecs_decodeSync_safe_bmi2_adjust_skip
-	MOVQ 152(CX), R12
-	MOVQ R12, 160(CX)
-
-sequenceDecs_decodeSync_safe_bmi2_adjust_skip:
-	MOVQ 144(CX), R12
-	MOVQ R12, 152(CX)
-	MOVQ R14, 144(CX)
-	MOVQ R14, R13
-
-sequenceDecs_decodeSync_safe_bmi2_after_adjust:
-	MOVQ R13, 8(SP)
-
-	// Check values
-	MOVQ  16(SP), CX
-	MOVQ  24(SP), R12
-	LEAQ  (CX)(R12*1), R14
-	MOVQ  s+0(FP), R15
-	ADDQ  R14, 256(R15)
-	MOVQ  ctx+16(FP), R14
-	SUBQ  R12, 104(R14)
-	JS    error_not_enough_literals
-	CMPQ  CX, $0x00020002
-	JA    sequenceDecs_decodeSync_safe_bmi2_error_match_len_too_big
-	TESTQ R13, R13
-	JNZ   sequenceDecs_decodeSync_safe_bmi2_match_len_ofs_ok
-	TESTQ CX, CX
-	JNZ   sequenceDecs_decodeSync_safe_bmi2_error_match_len_ofs_mismatch
-
-sequenceDecs_decodeSync_safe_bmi2_match_len_ofs_ok:
-	MOVQ 24(SP), CX
-	MOVQ 8(SP), R12
-	MOVQ 16(SP), R13
-
-	// Check if we have enough space in s.out
-	LEAQ (CX)(R13*1), R14
-	ADDQ R9, R14
-	CMPQ R14, 32(SP)
-	JA   error_not_enough_space
-
-	// Copy literals
-	TESTQ CX, CX
-	JZ    check_offset
-	MOVQ  CX, R14
-	SUBQ  $0x10, R14
-	JB    copy_1_small
-
-copy_1_loop:
-	MOVUPS (R10), X0
-	MOVUPS X0, (R9)
-	ADDQ   $0x10, R10
-	ADDQ   $0x10, R9
-	SUBQ   $0x10, R14
-	JAE    copy_1_loop
-	LEAQ   16(R10)(R14*1), R10
-	LEAQ   16(R9)(R14*1), R9
-	MOVUPS -16(R10), X0
-	MOVUPS X0, -16(R9)
-	JMP    copy_1_end
-
-copy_1_small:
-	CMPQ CX, $0x03
-	JE   copy_1_move_3
-	JB   copy_1_move_1or2
-	CMPQ CX, $0x08
-	JB   copy_1_move_4through7
-	JMP  copy_1_move_8through16
-
-copy_1_move_1or2:
-	MOVB (R10), R14
-	MOVB -1(R10)(CX*1), R15
-	MOVB R14, (R9)
-	MOVB R15, -1(R9)(CX*1)
-	ADDQ CX, R10
-	ADDQ CX, R9
-	JMP  copy_1_end
-
-copy_1_move_3:
-	MOVW (R10), R14
-	MOVB 2(R10), R15
-	MOVW R14, (R9)
-	MOVB R15, 2(R9)
-	ADDQ CX, R10
-	ADDQ CX, R9
-	JMP  copy_1_end
-
-copy_1_move_4through7:
-	MOVL (R10), R14
-	MOVL -4(R10)(CX*1), R15
-	MOVL R14, (R9)
-	MOVL R15, -4(R9)(CX*1)
-	ADDQ CX, R10
-	ADDQ CX, R9
-	JMP  copy_1_end
-
-copy_1_move_8through16:
-	MOVQ (R10), R14
-	MOVQ -8(R10)(CX*1), R15
-	MOVQ R14, (R9)
-	MOVQ R15, -8(R9)(CX*1)
-	ADDQ CX, R10
-	ADDQ CX, R9
-
-copy_1_end:
-	ADDQ CX, R11
-
-	// Malformed input if seq.mo > t+len(hist) || seq.mo > s.windowSize)
-check_offset:
-	MOVQ R11, CX
-	ADDQ 40(SP), CX
-	CMPQ R12, CX
-	JG   error_match_off_too_big
-	CMPQ R12, 56(SP)
-	JG   error_match_off_too_big
-
-	// Copy match from history
-	MOVQ R12, CX
-	SUBQ R11, CX
-	JLS  copy_match
-	MOVQ 48(SP), R14
-	SUBQ CX, R14
-	CMPQ R13, CX
-	JG   copy_all_from_history
-	MOVQ R13, CX
-	SUBQ $0x10, CX
-	JB   copy_4_small
-
-copy_4_loop:
-	MOVUPS (R14), X0
-	MOVUPS X0, (R9)
-	ADDQ   $0x10, R14
-	ADDQ   $0x10, R9
-	SUBQ   $0x10, CX
-	JAE    copy_4_loop
-	LEAQ   16(R14)(CX*1), R14
-	LEAQ   16(R9)(CX*1), R9
-	MOVUPS -16(R14), X0
-	MOVUPS X0, -16(R9)
-	JMP    copy_4_end
-
-copy_4_small:
-	CMPQ R13, $0x03
-	JE   copy_4_move_3
-	CMPQ R13, $0x08
-	JB   copy_4_move_4through7
-	JMP  copy_4_move_8through16
-
-copy_4_move_3:
-	MOVW (R14), CX
-	MOVB 2(R14), R12
-	MOVW CX, (R9)
-	MOVB R12, 2(R9)
-	ADDQ R13, R14
-	ADDQ R13, R9
-	JMP  copy_4_end
-
-copy_4_move_4through7:
-	MOVL (R14), CX
-	MOVL -4(R14)(R13*1), R12
-	MOVL CX, (R9)
-	MOVL R12, -4(R9)(R13*1)
-	ADDQ R13, R14
-	ADDQ R13, R9
-	JMP  copy_4_end
-
-copy_4_move_8through16:
-	MOVQ (R14), CX
-	MOVQ -8(R14)(R13*1), R12
-	MOVQ CX, (R9)
-	MOVQ R12, -8(R9)(R13*1)
-	ADDQ R13, R14
-	ADDQ R13, R9
-
-copy_4_end:
-	ADDQ R13, R11
-	JMP  handle_loop
-	JMP loop_finished
-
-copy_all_from_history:
-	MOVQ CX, R15
-	SUBQ $0x10, R15
-	JB   copy_5_small
-
-copy_5_loop:
-	MOVUPS (R14), X0
-	MOVUPS X0, (R9)
-	ADDQ   $0x10, R14
-	ADDQ   $0x10, R9
-	SUBQ   $0x10, R15
-	JAE    copy_5_loop
-	LEAQ   16(R14)(R15*1), R14
-	LEAQ   16(R9)(R15*1), R9
-	MOVUPS -16(R14), X0
-	MOVUPS X0, -16(R9)
-	JMP    copy_5_end
-
-copy_5_small:
-	CMPQ CX, $0x03
-	JE   copy_5_move_3
-	JB   copy_5_move_1or2
-	CMPQ CX, $0x08
-	JB   copy_5_move_4through7
-	JMP  copy_5_move_8through16
-
-copy_5_move_1or2:
-	MOVB (R14), R15
-	MOVB -1(R14)(CX*1), BP
-	MOVB R15, (R9)
-	MOVB BP, -1(R9)(CX*1)
-	ADDQ CX, R14
-	ADDQ CX, R9
-	JMP  copy_5_end
-
-copy_5_move_3:
-	MOVW (R14), R15
-	MOVB 2(R14), BP
-	MOVW R15, (R9)
-	MOVB BP, 2(R9)
-	ADDQ CX, R14
-	ADDQ CX, R9
-	JMP  copy_5_end
-
-copy_5_move_4through7:
-	MOVL (R14), R15
-	MOVL -4(R14)(CX*1), BP
-	MOVL R15, (R9)
-	MOVL BP, -4(R9)(CX*1)
-	ADDQ CX, R14
-	ADDQ CX, R9
-	JMP  copy_5_end
-
-copy_5_move_8through16:
-	MOVQ (R14), R15
-	MOVQ -8(R14)(CX*1), BP
-	MOVQ R15, (R9)
-	MOVQ BP, -8(R9)(CX*1)
-	ADDQ CX, R14
-	ADDQ CX, R9
-
-copy_5_end:
-	ADDQ CX, R11
-	SUBQ CX, R13
-
-	// Copy match from the current buffer
-copy_match:
-	MOVQ R9, CX
-	SUBQ R12, CX
-
-	// ml <= mo
-	CMPQ R13, R12
-	JA   copy_overlapping_match
-
-	// Copy non-overlapping match
-	ADDQ R13, R11
-	MOVQ R13, R12
-	SUBQ $0x10, R12
-	JB   copy_2_small
-
-copy_2_loop:
-	MOVUPS (CX), X0
-	MOVUPS X0, (R9)
-	ADDQ   $0x10, CX
-	ADDQ   $0x10, R9
-	SUBQ   $0x10, R12
-	JAE    copy_2_loop
-	LEAQ   16(CX)(R12*1), CX
-	LEAQ   16(R9)(R12*1), R9
-	MOVUPS -16(CX), X0
-	MOVUPS X0, -16(R9)
-	JMP    copy_2_end
-
-copy_2_small:
-	CMPQ R13, $0x03
-	JE   copy_2_move_3
-	JB   copy_2_move_1or2
-	CMPQ R13, $0x08
-	JB   copy_2_move_4through7
-	JMP  copy_2_move_8through16
-
-copy_2_move_1or2:
-	MOVB (CX), R12
-	MOVB -1(CX)(R13*1), R14
-	MOVB R12, (R9)
-	MOVB R14, -1(R9)(R13*1)
-	ADDQ R13, CX
-	ADDQ R13, R9
-	JMP  copy_2_end
-
-copy_2_move_3:
-	MOVW (CX), R12
-	MOVB 2(CX), R14
-	MOVW R12, (R9)
-	MOVB R14, 2(R9)
-	ADDQ R13, CX
-	ADDQ R13, R9
-	JMP  copy_2_end
-
-copy_2_move_4through7:
-	MOVL (CX), R12
-	MOVL -4(CX)(R13*1), R14
-	MOVL R12, (R9)
-	MOVL R14, -4(R9)(R13*1)
-	ADDQ R13, CX
-	ADDQ R13, R9
-	JMP  copy_2_end
-
-copy_2_move_8through16:
-	MOVQ (CX), R12
-	MOVQ -8(CX)(R13*1), R14
-	MOVQ R12, (R9)
-	MOVQ R14, -8(R9)(R13*1)
-	ADDQ R13, CX
-	ADDQ R13, R9
-
-copy_2_end:
-	JMP handle_loop
-
-	// Copy overlapping match
-copy_overlapping_match:
-	ADDQ R13, R11
-
-copy_slow_3:
-	MOVB (CX), R12
-	MOVB R12, (R9)
-	INCQ CX
-	INCQ R9
-	DECQ R13
-	JNZ  copy_slow_3
-
-handle_loop:
-	MOVQ ctx+16(FP), CX
-	DECQ 96(CX)
-	JNS  sequenceDecs_decodeSync_safe_bmi2_main_loop
-
-loop_finished:
-	MOVQ br+8(FP), CX
-	MOVQ AX, 32(CX)
-	MOVB DL, 40(CX)
-	MOVQ BX, 24(CX)
-
-	// Update the context
-	MOVQ ctx+16(FP), AX
-	MOVQ R11, 136(AX)
-	MOVQ 144(AX), CX
-	SUBQ CX, R10
-	MOVQ R10, 168(AX)
-
-	// Return success
-	MOVQ $0x00000000, ret+24(FP)
-	RET
-
-	// Return with match length error
-sequenceDecs_decodeSync_safe_bmi2_error_match_len_ofs_mismatch:
-	MOVQ 16(SP), AX
-	MOVQ ctx+16(FP), CX
-	MOVQ AX, 216(CX)
-	MOVQ $0x00000001, ret+24(FP)
-	RET
-
-	// Return with match too long error
-sequenceDecs_decodeSync_safe_bmi2_error_match_len_too_big:
-	MOVQ ctx+16(FP), AX
-	MOVQ 16(SP), CX
-	MOVQ CX, 216(AX)
-	MOVQ $0x00000002, ret+24(FP)
-	RET
-
-	// Return with match offset too long error
-error_match_off_too_big:
-	MOVQ ctx+16(FP), AX
-	MOVQ 8(SP), CX
-	MOVQ CX, 224(AX)
-	MOVQ R11, 136(AX)
-	MOVQ $0x00000003, ret+24(FP)
-	RET
-
-	// Return with not enough literals error
-error_not_enough_literals:
-	MOVQ ctx+16(FP), AX
-	MOVQ 24(SP), CX
-	MOVQ CX, 208(AX)
-	MOVQ $0x00000004, ret+24(FP)
-	RET
-
-	// Return with overread error
-error_overread:
-	MOVQ $0x00000006, ret+24(FP)
-	RET
-
-	// Return with not enough output space error
-error_not_enough_space:
-	MOVQ ctx+16(FP), AX
-	MOVQ 24(SP), CX
-	MOVQ CX, 208(AX)
-	MOVQ 16(SP), CX
-	MOVQ CX, 216(AX)
-	MOVQ R11, 136(AX)
-	MOVQ $0x00000005, ret+24(FP)
-	RET
diff --git a/vendor/github.com/klauspost/compress/zstd/seqdec_generic.go b/vendor/github.com/klauspost/compress/zstd/seqdec_generic.go
deleted file mode 100644
index ac2a80d2..00000000
--- a/vendor/github.com/klauspost/compress/zstd/seqdec_generic.go
+++ /dev/null
@@ -1,237 +0,0 @@
-//go:build !amd64 || appengine || !gc || noasm
-// +build !amd64 appengine !gc noasm
-
-package zstd
-
-import (
-	"fmt"
-	"io"
-)
-
-// decode sequences from the stream with the provided history but without dictionary.
-func (s *sequenceDecs) decodeSyncSimple(hist []byte) (bool, error) {
-	return false, nil
-}
-
-// decode sequences from the stream without the provided history.
-func (s *sequenceDecs) decode(seqs []seqVals) error {
-	br := s.br
-
-	// Grab full sizes tables, to avoid bounds checks.
-	llTable, mlTable, ofTable := s.litLengths.fse.dt[:maxTablesize], s.matchLengths.fse.dt[:maxTablesize], s.offsets.fse.dt[:maxTablesize]
-	llState, mlState, ofState := s.litLengths.state.state, s.matchLengths.state.state, s.offsets.state.state
-	s.seqSize = 0
-	litRemain := len(s.literals)
-
-	maxBlockSize := maxCompressedBlockSize
-	if s.windowSize < maxBlockSize {
-		maxBlockSize = s.windowSize
-	}
-	for i := range seqs {
-		var ll, mo, ml int
-		if br.off > 4+((maxOffsetBits+16+16)>>3) {
-			// inlined function:
-			// ll, mo, ml = s.nextFast(br, llState, mlState, ofState)
-
-			// Final will not read from stream.
-			var llB, mlB, moB uint8
-			ll, llB = llState.final()
-			ml, mlB = mlState.final()
-			mo, moB = ofState.final()
-
-			// extra bits are stored in reverse order.
-			br.fillFast()
-			mo += br.getBits(moB)
-			if s.maxBits > 32 {
-				br.fillFast()
-			}
-			ml += br.getBits(mlB)
-			ll += br.getBits(llB)
-
-			if moB > 1 {
-				s.prevOffset[2] = s.prevOffset[1]
-				s.prevOffset[1] = s.prevOffset[0]
-				s.prevOffset[0] = mo
-			} else {
-				// mo = s.adjustOffset(mo, ll, moB)
-				// Inlined for rather big speedup
-				if ll == 0 {
-					// There is an exception though, when current sequence's literals_length = 0.
-					// In this case, repeated offsets are shifted by one, so an offset_value of 1 means Repeated_Offset2,
-					// an offset_value of 2 means Repeated_Offset3, and an offset_value of 3 means Repeated_Offset1 - 1_byte.
-					mo++
-				}
-
-				if mo == 0 {
-					mo = s.prevOffset[0]
-				} else {
-					var temp int
-					if mo == 3 {
-						temp = s.prevOffset[0] - 1
-					} else {
-						temp = s.prevOffset[mo]
-					}
-
-					if temp == 0 {
-						// 0 is not valid; input is corrupted; force offset to 1
-						println("WARNING: temp was 0")
-						temp = 1
-					}
-
-					if mo != 1 {
-						s.prevOffset[2] = s.prevOffset[1]
-					}
-					s.prevOffset[1] = s.prevOffset[0]
-					s.prevOffset[0] = temp
-					mo = temp
-				}
-			}
-			br.fillFast()
-		} else {
-			if br.overread() {
-				if debugDecoder {
-					printf("reading sequence %d, exceeded available data\n", i)
-				}
-				return io.ErrUnexpectedEOF
-			}
-			ll, mo, ml = s.next(br, llState, mlState, ofState)
-			br.fill()
-		}
-
-		if debugSequences {
-			println("Seq", i, "Litlen:", ll, "mo:", mo, "(abs) ml:", ml)
-		}
-		// Evaluate.
-		// We might be doing this async, so do it early.
-		if mo == 0 && ml > 0 {
-			return fmt.Errorf("zero matchoff and matchlen (%d) > 0", ml)
-		}
-		if ml > maxMatchLen {
-			return fmt.Errorf("match len (%d) bigger than max allowed length", ml)
-		}
-		s.seqSize += ll + ml
-		if s.seqSize > maxBlockSize {
-			return fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
-		}
-		litRemain -= ll
-		if litRemain < 0 {
-			return fmt.Errorf("unexpected literal count, want %d bytes, but only %d is available", ll, litRemain+ll)
-		}
-		seqs[i] = seqVals{
-			ll: ll,
-			ml: ml,
-			mo: mo,
-		}
-		if i == len(seqs)-1 {
-			// This is the last sequence, so we shouldn't update state.
-			break
-		}
-
-		// Manually inlined, ~ 5-20% faster
-		// Update all 3 states at once. Approx 20% faster.
-		nBits := llState.nbBits() + mlState.nbBits() + ofState.nbBits()
-		if nBits == 0 {
-			llState = llTable[llState.newState()&maxTableMask]
-			mlState = mlTable[mlState.newState()&maxTableMask]
-			ofState = ofTable[ofState.newState()&maxTableMask]
-		} else {
-			bits := br.get32BitsFast(nBits)
-			lowBits := uint16(bits >> ((ofState.nbBits() + mlState.nbBits()) & 31))
-			llState = llTable[(llState.newState()+lowBits)&maxTableMask]
-
-			lowBits = uint16(bits >> (ofState.nbBits() & 31))
-			lowBits &= bitMask[mlState.nbBits()&15]
-			mlState = mlTable[(mlState.newState()+lowBits)&maxTableMask]
-
-			lowBits = uint16(bits) & bitMask[ofState.nbBits()&15]
-			ofState = ofTable[(ofState.newState()+lowBits)&maxTableMask]
-		}
-	}
-	s.seqSize += litRemain
-	if s.seqSize > maxBlockSize {
-		return fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
-	}
-	err := br.close()
-	if err != nil {
-		printf("Closing sequences: %v, %+v\n", err, *br)
-	}
-	return err
-}
-
-// executeSimple handles cases when a dictionary is not used.
-func (s *sequenceDecs) executeSimple(seqs []seqVals, hist []byte) error {
-	// Ensure we have enough output size...
-	if len(s.out)+s.seqSize > cap(s.out) {
-		addBytes := s.seqSize + len(s.out)
-		s.out = append(s.out, make([]byte, addBytes)...)
-		s.out = s.out[:len(s.out)-addBytes]
-	}
-
-	if debugDecoder {
-		printf("Execute %d seqs with literals: %d into %d bytes\n", len(seqs), len(s.literals), s.seqSize)
-	}
-
-	var t = len(s.out)
-	out := s.out[:t+s.seqSize]
-
-	for _, seq := range seqs {
-		// Add literals
-		copy(out[t:], s.literals[:seq.ll])
-		t += seq.ll
-		s.literals = s.literals[seq.ll:]
-
-		// Malformed input
-		if seq.mo > t+len(hist) || seq.mo > s.windowSize {
-			return fmt.Errorf("match offset (%d) bigger than current history (%d)", seq.mo, t+len(hist))
-		}
-
-		// Copy from history.
-		if v := seq.mo - t; v > 0 {
-			// v is the start position in history from end.
-			start := len(hist) - v
-			if seq.ml > v {
-				// Some goes into the current block.
-				// Copy remainder of history
-				copy(out[t:], hist[start:])
-				t += v
-				seq.ml -= v
-			} else {
-				copy(out[t:], hist[start:start+seq.ml])
-				t += seq.ml
-				continue
-			}
-		}
-
-		// We must be in the current buffer now
-		if seq.ml > 0 {
-			start := t - seq.mo
-			if seq.ml <= t-start {
-				// No overlap
-				copy(out[t:], out[start:start+seq.ml])
-				t += seq.ml
-			} else {
-				// Overlapping copy
-				// Extend destination slice and copy one byte at the time.
-				src := out[start : start+seq.ml]
-				dst := out[t:]
-				dst = dst[:len(src)]
-				t += len(src)
-				// Destination is the space we just added.
-				for i := range src {
-					dst[i] = src[i]
-				}
-			}
-		}
-	}
-	// Add final literals
-	copy(out[t:], s.literals)
-	if debugDecoder {
-		t += len(s.literals)
-		if t != len(out) {
-			panic(fmt.Errorf("length mismatch, want %d, got %d, ss: %d", len(out), t, s.seqSize))
-		}
-	}
-	s.out = out
-
-	return nil
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/LICENSE b/vendor/go.mongodb.org/mongo-driver/v2/LICENSE
deleted file mode 100644
index 261eeb9e..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/LICENSE
+++ /dev/null
@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/array_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/array_codec.go
deleted file mode 100644
index 4642fb6e..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/array_codec.go
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"reflect"
-
-	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
-)
-
-// arrayCodec is the Codec used for bsoncore.Array values.
-type arrayCodec struct{}
-
-// EncodeValue is the ValueEncoder for bsoncore.Array values.
-func (ac *arrayCodec) EncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tCoreArray {
-		return ValueEncoderError{Name: "CoreArrayEncodeValue", Types: []reflect.Type{tCoreArray}, Received: val}
-	}
-
-	arr := val.Interface().(bsoncore.Array)
-	return copyArrayFromBytes(vw, arr)
-}
-
-// DecodeValue is the ValueDecoder for bsoncore.Array values.
-func (ac *arrayCodec) DecodeValue(_ DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tCoreArray {
-		return ValueDecoderError{Name: "CoreArrayDecodeValue", Types: []reflect.Type{tCoreArray}, Received: val}
-	}
-
-	if val.IsNil() {
-		val.Set(reflect.MakeSlice(val.Type(), 0, 0))
-	}
-
-	val.SetLen(0)
-	arr, err := appendArrayBytes(val.Interface().(bsoncore.Array), vr)
-	val.Set(reflect.ValueOf(arr))
-	return err
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/bsoncodec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/bsoncodec.go
deleted file mode 100644
index 91592a3e..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/bsoncodec.go
+++ /dev/null
@@ -1,203 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-)
-
-var (
-	emptyValue = reflect.Value{}
-)
-
-// ValueEncoderError is an error returned from a ValueEncoder when the provided value can't be
-// encoded by the ValueEncoder.
-type ValueEncoderError struct {
-	Name     string
-	Types    []reflect.Type
-	Kinds    []reflect.Kind
-	Received reflect.Value
-}
-
-func (vee ValueEncoderError) Error() string {
-	typeKinds := make([]string, 0, len(vee.Types)+len(vee.Kinds))
-	for _, t := range vee.Types {
-		typeKinds = append(typeKinds, t.String())
-	}
-	for _, k := range vee.Kinds {
-		if k == reflect.Map {
-			typeKinds = append(typeKinds, "map[string]*")
-			continue
-		}
-		typeKinds = append(typeKinds, k.String())
-	}
-	received := vee.Received.Kind().String()
-	if vee.Received.IsValid() {
-		received = vee.Received.Type().String()
-	}
-	return fmt.Sprintf("%s can only encode valid %s, but got %s", vee.Name, strings.Join(typeKinds, ", "), received)
-}
-
-// ValueDecoderError is an error returned from a ValueDecoder when the provided value can't be
-// decoded by the ValueDecoder.
-type ValueDecoderError struct {
-	Name     string
-	Types    []reflect.Type
-	Kinds    []reflect.Kind
-	Received reflect.Value
-}
-
-func (vde ValueDecoderError) Error() string {
-	typeKinds := make([]string, 0, len(vde.Types)+len(vde.Kinds))
-	for _, t := range vde.Types {
-		typeKinds = append(typeKinds, t.String())
-	}
-	for _, k := range vde.Kinds {
-		if k == reflect.Map {
-			typeKinds = append(typeKinds, "map[string]*")
-			continue
-		}
-		typeKinds = append(typeKinds, k.String())
-	}
-	received := vde.Received.Kind().String()
-	if vde.Received.IsValid() {
-		received = vde.Received.Type().String()
-	}
-	if !vde.Received.CanSet() {
-		received = "unsettable " + received
-	}
-	return fmt.Sprintf("%s can only decode valid and settable %s, but got %s", vde.Name, strings.Join(typeKinds, ", "), received)
-}
-
-// EncodeContext is the contextual information required for a Codec to encode a
-// value.
-type EncodeContext struct {
-	*Registry
-
-	// minSize causes the Encoder to marshal Go integer values (int, int8, int16, int32, int64,
-	// uint, uint8, uint16, uint32, or uint64) as the minimum BSON int size (either 32 or 64 bits)
-	// that can represent the integer value.
-	minSize bool
-
-	errorOnInlineDuplicates bool
-	stringifyMapKeysWithFmt bool
-	nilMapAsEmpty           bool
-	nilSliceAsEmpty         bool
-	nilByteSliceAsEmpty     bool
-	omitZeroStruct          bool
-	omitEmpty               bool
-	useJSONStructTags       bool
-}
-
-// DecodeContext is the contextual information required for a Codec to decode a
-// value.
-type DecodeContext struct {
-	*Registry
-
-	// truncate, if true, instructs decoders to to truncate the fractional part of BSON "double"
-	// values when attempting to unmarshal them into a Go integer (int, int8, int16, int32, int64,
-	// uint, uint8, uint16, uint32, or uint64) struct field. The truncation logic does not apply to
-	// BSON "decimal128" values.
-	truncate bool
-
-	// defaultDocumentType specifies the Go type to decode top-level and nested BSON documents into. In particular, the
-	// usage for this field is restricted to data typed as "interface{}" or "map[string]interface{}". If DocumentType is
-	// set to a type that a BSON document cannot be unmarshaled into (e.g. "string"), unmarshalling will result in an
-	// error.
-	defaultDocumentType reflect.Type
-
-	binaryAsSlice bool
-
-	// a false value results in a decoding error.
-	objectIDAsHexString bool
-
-	useJSONStructTags bool
-	useLocalTimeZone  bool
-	zeroMaps          bool
-	zeroStructs       bool
-}
-
-// ValueEncoder is the interface implemented by types that can encode a provided Go type to BSON.
-// The value to encode is provided as a reflect.Value and a bson.ValueWriter is used within the
-// EncodeValue method to actually create the BSON representation. For convenience, ValueEncoderFunc
-// is provided to allow use of a function with the correct signature as a ValueEncoder. An
-// EncodeContext instance is provided to allow implementations to lookup further ValueEncoders and
-// to provide configuration information.
-type ValueEncoder interface {
-	EncodeValue(EncodeContext, ValueWriter, reflect.Value) error
-}
-
-// ValueEncoderFunc is an adapter function that allows a function with the correct signature to be
-// used as a ValueEncoder.
-type ValueEncoderFunc func(EncodeContext, ValueWriter, reflect.Value) error
-
-// EncodeValue implements the ValueEncoder interface.
-func (fn ValueEncoderFunc) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
-	return fn(ec, vw, val)
-}
-
-// ValueDecoder is the interface implemented by types that can decode BSON to a provided Go type.
-// Implementations should ensure that the value they receive is settable. Similar to ValueEncoderFunc,
-// ValueDecoderFunc is provided to allow the use of a function with the correct signature as a
-// ValueDecoder. A DecodeContext instance is provided and serves similar functionality to the
-// EncodeContext.
-type ValueDecoder interface {
-	DecodeValue(DecodeContext, ValueReader, reflect.Value) error
-}
-
-// ValueDecoderFunc is an adapter function that allows a function with the correct signature to be
-// used as a ValueDecoder.
-type ValueDecoderFunc func(DecodeContext, ValueReader, reflect.Value) error
-
-// DecodeValue implements the ValueDecoder interface.
-func (fn ValueDecoderFunc) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	return fn(dc, vr, val)
-}
-
-// typeDecoder is the interface implemented by types that can handle the decoding of a value given its type.
-type typeDecoder interface {
-	decodeType(DecodeContext, ValueReader, reflect.Type) (reflect.Value, error)
-}
-
-// typeDecoderFunc is an adapter function that allows a function with the correct signature to be used as a typeDecoder.
-type typeDecoderFunc func(DecodeContext, ValueReader, reflect.Type) (reflect.Value, error)
-
-func (fn typeDecoderFunc) decodeType(dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	return fn(dc, vr, t)
-}
-
-// decodeAdapter allows two functions with the correct signatures to be used as both a ValueDecoder and typeDecoder.
-type decodeAdapter struct {
-	ValueDecoderFunc
-	typeDecoderFunc
-}
-
-var _ ValueDecoder = decodeAdapter{}
-var _ typeDecoder = decodeAdapter{}
-
-func decodeTypeOrValueWithInfo(vd ValueDecoder, dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if td, _ := vd.(typeDecoder); td != nil {
-		val, err := td.decodeType(dc, vr, t)
-		if err == nil && val.Type() != t {
-			// This conversion step is necessary for slices and maps. If a user declares variables like:
-			//
-			// type myBool bool
-			// var m map[string]myBool
-			//
-			// and tries to decode BSON bytes into the map, the decoding will fail if this conversion is not present
-			// because we'll try to assign a value of type bool to one of type myBool.
-			val = val.Convert(t)
-		}
-		return val, err
-	}
-
-	val := reflect.New(t).Elem()
-	err := vd.DecodeValue(dc, vr, val)
-	return val, err
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/byte_slice_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/byte_slice_codec.go
deleted file mode 100644
index bd44cf9a..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/byte_slice_codec.go
+++ /dev/null
@@ -1,97 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"fmt"
-	"reflect"
-)
-
-// byteSliceCodec is the Codec used for []byte values.
-type byteSliceCodec struct {
-	// encodeNilAsEmpty causes EncodeValue to marshal nil Go byte slices as empty BSON binary values
-	// instead of BSON null.
-	encodeNilAsEmpty bool
-}
-
-// Assert that byteSliceCodec satisfies the typeDecoder interface, which allows it to be
-// used by collection type decoders (e.g. map, slice, etc) to set individual values in a
-// collection.
-var _ typeDecoder = &byteSliceCodec{}
-
-// EncodeValue is the ValueEncoder for []byte.
-func (bsc *byteSliceCodec) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tByteSlice {
-		return ValueEncoderError{Name: "ByteSliceEncodeValue", Types: []reflect.Type{tByteSlice}, Received: val}
-	}
-	if val.IsNil() && !bsc.encodeNilAsEmpty && !ec.nilByteSliceAsEmpty {
-		return vw.WriteNull()
-	}
-	return vw.WriteBinary(val.Interface().([]byte))
-}
-
-func (bsc *byteSliceCodec) decodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tByteSlice {
-		return emptyValue, ValueDecoderError{
-			Name:     "ByteSliceDecodeValue",
-			Types:    []reflect.Type{tByteSlice},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	var data []byte
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeString:
-		str, err := vr.ReadString()
-		if err != nil {
-			return emptyValue, err
-		}
-		data = []byte(str)
-	case TypeSymbol:
-		sym, err := vr.ReadSymbol()
-		if err != nil {
-			return emptyValue, err
-		}
-		data = []byte(sym)
-	case TypeBinary:
-		var subtype byte
-		data, subtype, err = vr.ReadBinary()
-		if err != nil {
-			return emptyValue, err
-		}
-		if subtype != TypeBinaryGeneric && subtype != TypeBinaryBinaryOld {
-			return emptyValue, decodeBinaryError{subtype: subtype, typeName: "[]byte"}
-		}
-	case TypeNull:
-		err = vr.ReadNull()
-	case TypeUndefined:
-		err = vr.ReadUndefined()
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a []byte", vrType)
-	}
-	if err != nil {
-		return emptyValue, err
-	}
-
-	return reflect.ValueOf(data), nil
-}
-
-// DecodeValue is the ValueDecoder for []byte.
-func (bsc *byteSliceCodec) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tByteSlice {
-		return ValueDecoderError{Name: "ByteSliceDecodeValue", Types: []reflect.Type{tByteSlice}, Received: val}
-	}
-
-	elem, err := bsc.decodeType(dc, vr, tByteSlice)
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/codec_cache.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/codec_cache.go
deleted file mode 100644
index b4042822..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/codec_cache.go
+++ /dev/null
@@ -1,166 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"reflect"
-	"sync"
-	"sync/atomic"
-)
-
-// Runtime check that the kind encoder and decoder caches can store any valid
-// reflect.Kind constant.
-func init() {
-	if s := reflect.Kind(len(kindEncoderCache{}.entries)).String(); s != "kind27" {
-		panic("The capacity of kindEncoderCache is too small.\n" +
-			"This is due to a new type being added to reflect.Kind.")
-	}
-}
-
-// statically assert array size
-var _ = (kindEncoderCache{}).entries[reflect.UnsafePointer]
-var _ = (kindDecoderCache{}).entries[reflect.UnsafePointer]
-
-type typeEncoderCache struct {
-	cache sync.Map // map[reflect.Type]ValueEncoder
-}
-
-func (c *typeEncoderCache) Store(rt reflect.Type, enc ValueEncoder) {
-	c.cache.Store(rt, enc)
-}
-
-func (c *typeEncoderCache) Load(rt reflect.Type) (ValueEncoder, bool) {
-	if v, _ := c.cache.Load(rt); v != nil {
-		return v.(ValueEncoder), true
-	}
-	return nil, false
-}
-
-func (c *typeEncoderCache) LoadOrStore(rt reflect.Type, enc ValueEncoder) ValueEncoder {
-	if v, loaded := c.cache.LoadOrStore(rt, enc); loaded {
-		enc = v.(ValueEncoder)
-	}
-	return enc
-}
-
-func (c *typeEncoderCache) Clone() *typeEncoderCache {
-	cc := new(typeEncoderCache)
-	c.cache.Range(func(k, v interface{}) bool {
-		if k != nil && v != nil {
-			cc.cache.Store(k, v)
-		}
-		return true
-	})
-	return cc
-}
-
-type typeDecoderCache struct {
-	cache sync.Map // map[reflect.Type]ValueDecoder
-}
-
-func (c *typeDecoderCache) Store(rt reflect.Type, dec ValueDecoder) {
-	c.cache.Store(rt, dec)
-}
-
-func (c *typeDecoderCache) Load(rt reflect.Type) (ValueDecoder, bool) {
-	if v, _ := c.cache.Load(rt); v != nil {
-		return v.(ValueDecoder), true
-	}
-	return nil, false
-}
-
-func (c *typeDecoderCache) LoadOrStore(rt reflect.Type, dec ValueDecoder) ValueDecoder {
-	if v, loaded := c.cache.LoadOrStore(rt, dec); loaded {
-		dec = v.(ValueDecoder)
-	}
-	return dec
-}
-
-func (c *typeDecoderCache) Clone() *typeDecoderCache {
-	cc := new(typeDecoderCache)
-	c.cache.Range(func(k, v interface{}) bool {
-		if k != nil && v != nil {
-			cc.cache.Store(k, v)
-		}
-		return true
-	})
-	return cc
-}
-
-// atomic.Value requires that all calls to Store() have the same concrete type
-// so we wrap the ValueEncoder with a kindEncoderCacheEntry to ensure the type
-// is always the same (since different concrete types may implement the
-// ValueEncoder interface).
-type kindEncoderCacheEntry struct {
-	enc ValueEncoder
-}
-
-type kindEncoderCache struct {
-	entries [reflect.UnsafePointer + 1]atomic.Value // *kindEncoderCacheEntry
-}
-
-func (c *kindEncoderCache) Store(rt reflect.Kind, enc ValueEncoder) {
-	if enc != nil && rt < reflect.Kind(len(c.entries)) {
-		c.entries[rt].Store(&kindEncoderCacheEntry{enc: enc})
-	}
-}
-
-func (c *kindEncoderCache) Load(rt reflect.Kind) (ValueEncoder, bool) {
-	if rt < reflect.Kind(len(c.entries)) {
-		if ent, ok := c.entries[rt].Load().(*kindEncoderCacheEntry); ok {
-			return ent.enc, ent.enc != nil
-		}
-	}
-	return nil, false
-}
-
-func (c *kindEncoderCache) Clone() *kindEncoderCache {
-	cc := new(kindEncoderCache)
-	for i, v := range c.entries {
-		if val := v.Load(); val != nil {
-			cc.entries[i].Store(val)
-		}
-	}
-	return cc
-}
-
-// atomic.Value requires that all calls to Store() have the same concrete type
-// so we wrap the ValueDecoder with a kindDecoderCacheEntry to ensure the type
-// is always the same (since different concrete types may implement the
-// ValueDecoder interface).
-type kindDecoderCacheEntry struct {
-	dec ValueDecoder
-}
-
-type kindDecoderCache struct {
-	entries [reflect.UnsafePointer + 1]atomic.Value // *kindDecoderCacheEntry
-}
-
-func (c *kindDecoderCache) Store(rt reflect.Kind, dec ValueDecoder) {
-	if rt < reflect.Kind(len(c.entries)) {
-		c.entries[rt].Store(&kindDecoderCacheEntry{dec: dec})
-	}
-}
-
-func (c *kindDecoderCache) Load(rt reflect.Kind) (ValueDecoder, bool) {
-	if rt < reflect.Kind(len(c.entries)) {
-		if ent, ok := c.entries[rt].Load().(*kindDecoderCacheEntry); ok {
-			return ent.dec, ent.dec != nil
-		}
-	}
-	return nil, false
-}
-
-func (c *kindDecoderCache) Clone() *kindDecoderCache {
-	cc := new(kindDecoderCache)
-	for i, v := range c.entries {
-		if val := v.Load(); val != nil {
-			cc.entries[i].Store(val)
-		}
-	}
-	return cc
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/cond_addr_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/cond_addr_codec.go
deleted file mode 100644
index fed4d1f8..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/cond_addr_codec.go
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"reflect"
-)
-
-// condAddrEncoder is the encoder used when a pointer to the encoding value has an encoder.
-type condAddrEncoder struct {
-	canAddrEnc ValueEncoder
-	elseEnc    ValueEncoder
-}
-
-var _ ValueEncoder = &condAddrEncoder{}
-
-// newCondAddrEncoder returns an condAddrEncoder.
-func newCondAddrEncoder(canAddrEnc, elseEnc ValueEncoder) *condAddrEncoder {
-	encoder := condAddrEncoder{canAddrEnc: canAddrEnc, elseEnc: elseEnc}
-	return &encoder
-}
-
-// EncodeValue is the ValueEncoderFunc for a value that may be addressable.
-func (cae *condAddrEncoder) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if val.CanAddr() {
-		return cae.canAddrEnc.EncodeValue(ec, vw, val)
-	}
-	if cae.elseEnc != nil {
-		return cae.elseEnc.EncodeValue(ec, vw, val)
-	}
-	return errNoEncoder{Type: val.Type()}
-}
-
-// condAddrDecoder is the decoder used when a pointer to the value has a decoder.
-type condAddrDecoder struct {
-	canAddrDec ValueDecoder
-	elseDec    ValueDecoder
-}
-
-var _ ValueDecoder = &condAddrDecoder{}
-
-// newCondAddrDecoder returns an CondAddrDecoder.
-func newCondAddrDecoder(canAddrDec, elseDec ValueDecoder) *condAddrDecoder {
-	decoder := condAddrDecoder{canAddrDec: canAddrDec, elseDec: elseDec}
-	return &decoder
-}
-
-// DecodeValue is the ValueDecoderFunc for a value that may be addressable.
-func (cad *condAddrDecoder) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if val.CanAddr() {
-		return cad.canAddrDec.DecodeValue(dc, vr, val)
-	}
-	if cad.elseDec != nil {
-		return cad.elseDec.DecodeValue(dc, vr, val)
-	}
-	return errNoDecoder{Type: val.Type()}
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/copier.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/copier.go
deleted file mode 100644
index 6279f072..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/copier.go
+++ /dev/null
@@ -1,431 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-
-	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
-)
-
-// copyDocument handles copying one document from the src to the dst.
-func copyDocument(dst ValueWriter, src ValueReader) error {
-	dr, err := src.ReadDocument()
-	if err != nil {
-		return err
-	}
-
-	dw, err := dst.WriteDocument()
-	if err != nil {
-		return err
-	}
-
-	return copyDocumentCore(dw, dr)
-}
-
-// copyArrayFromBytes copies the values from a BSON array represented as a
-// []byte to a ValueWriter.
-func copyArrayFromBytes(dst ValueWriter, src []byte) error {
-	aw, err := dst.WriteArray()
-	if err != nil {
-		return err
-	}
-
-	err = copyBytesToArrayWriter(aw, src)
-	if err != nil {
-		return err
-	}
-
-	return aw.WriteArrayEnd()
-}
-
-// copyDocumentFromBytes copies the values from a BSON document represented as a
-// []byte to a ValueWriter.
-func copyDocumentFromBytes(dst ValueWriter, src []byte) error {
-	dw, err := dst.WriteDocument()
-	if err != nil {
-		return err
-	}
-
-	err = copyBytesToDocumentWriter(dw, src)
-	if err != nil {
-		return err
-	}
-
-	return dw.WriteDocumentEnd()
-}
-
-type writeElementFn func(key string) (ValueWriter, error)
-
-// copyBytesToArrayWriter copies the values from a BSON Array represented as a []byte to an
-// ArrayWriter.
-func copyBytesToArrayWriter(dst ArrayWriter, src []byte) error {
-	wef := func(_ string) (ValueWriter, error) {
-		return dst.WriteArrayElement()
-	}
-
-	return copyBytesToValueWriter(src, wef)
-}
-
-// copyBytesToDocumentWriter copies the values from a BSON document represented as a []byte to a
-// DocumentWriter.
-func copyBytesToDocumentWriter(dst DocumentWriter, src []byte) error {
-	wef := func(key string) (ValueWriter, error) {
-		return dst.WriteDocumentElement(key)
-	}
-
-	return copyBytesToValueWriter(src, wef)
-}
-
-func copyBytesToValueWriter(src []byte, wef writeElementFn) error {
-	// TODO(skriptble): Create errors types here. Anything that is a tag should be a property.
-	length, rem, ok := bsoncore.ReadLength(src)
-	if !ok {
-		return fmt.Errorf("couldn't read length from src, not enough bytes. length=%d", len(src))
-	}
-	if len(src) < int(length) {
-		return fmt.Errorf("length read exceeds number of bytes available. length=%d bytes=%d", len(src), length)
-	}
-	rem = rem[:length-4]
-
-	var t bsoncore.Type
-	var key string
-	var val bsoncore.Value
-	for {
-		t, rem, ok = bsoncore.ReadType(rem)
-		if !ok {
-			return io.EOF
-		}
-		if t == bsoncore.Type(0) {
-			if len(rem) != 0 {
-				return fmt.Errorf("document end byte found before end of document. remaining bytes=%v", rem)
-			}
-			break
-		}
-
-		key, rem, ok = bsoncore.ReadKey(rem)
-		if !ok {
-			return fmt.Errorf("invalid key found. remaining bytes=%v", rem)
-		}
-
-		// write as either array element or document element using writeElementFn
-		vw, err := wef(key)
-		if err != nil {
-			return err
-		}
-
-		val, rem, ok = bsoncore.ReadValue(rem, t)
-		if !ok {
-			return fmt.Errorf("not enough bytes available to read type. bytes=%d type=%s", len(rem), t)
-		}
-		err = copyValueFromBytes(vw, Type(t), val.Data)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// copyDocumentToBytes copies an entire document from the ValueReader and
-// returns it as bytes.
-func copyDocumentToBytes(src ValueReader) ([]byte, error) {
-	return appendDocumentBytes(nil, src)
-}
-
-// appendDocumentBytes functions the same as CopyDocumentToBytes, but will
-// append the result to dst.
-func appendDocumentBytes(dst []byte, src ValueReader) ([]byte, error) {
-	if br, ok := src.(bytesReader); ok {
-		_, dst, err := br.readValueBytes(dst)
-		return dst, err
-	}
-
-	vw := vwPool.Get().(*valueWriter)
-	defer putValueWriter(vw)
-
-	vw.reset(dst)
-
-	err := copyDocument(vw, src)
-	dst = vw.buf
-	return dst, err
-}
-
-// appendArrayBytes copies an array from the ValueReader to dst.
-func appendArrayBytes(dst []byte, src ValueReader) ([]byte, error) {
-	if br, ok := src.(bytesReader); ok {
-		_, dst, err := br.readValueBytes(dst)
-		return dst, err
-	}
-
-	vw := vwPool.Get().(*valueWriter)
-	defer putValueWriter(vw)
-
-	vw.reset(dst)
-
-	err := copyArray(vw, src)
-	dst = vw.buf
-	return dst, err
-}
-
-// copyValueFromBytes will write the value represtend by t and src to dst.
-func copyValueFromBytes(dst ValueWriter, t Type, src []byte) error {
-	if wvb, ok := dst.(bytesWriter); ok {
-		return wvb.writeValueBytes(t, src)
-	}
-
-	vr := newDocumentReader(bytes.NewReader(src))
-	vr.pushElement(t)
-
-	return copyValue(dst, vr)
-}
-
-// copyValueToBytes copies a value from src and returns it as a Type and a
-// []byte.
-func copyValueToBytes(src ValueReader) (Type, []byte, error) {
-	if br, ok := src.(bytesReader); ok {
-		return br.readValueBytes(nil)
-	}
-
-	vw := vwPool.Get().(*valueWriter)
-	defer putValueWriter(vw)
-
-	vw.reset(nil)
-	vw.push(mElement)
-
-	err := copyValue(vw, src)
-	if err != nil {
-		return 0, nil, err
-	}
-
-	return Type(vw.buf[0]), vw.buf[2:], nil
-}
-
-// copyValue will copy a single value from src to dst.
-func copyValue(dst ValueWriter, src ValueReader) error {
-	var err error
-	switch src.Type() {
-	case TypeDouble:
-		var f64 float64
-		f64, err = src.ReadDouble()
-		if err != nil {
-			break
-		}
-		err = dst.WriteDouble(f64)
-	case TypeString:
-		var str string
-		str, err = src.ReadString()
-		if err != nil {
-			return err
-		}
-		err = dst.WriteString(str)
-	case TypeEmbeddedDocument:
-		err = copyDocument(dst, src)
-	case TypeArray:
-		err = copyArray(dst, src)
-	case TypeBinary:
-		var data []byte
-		var subtype byte
-		data, subtype, err = src.ReadBinary()
-		if err != nil {
-			break
-		}
-		err = dst.WriteBinaryWithSubtype(data, subtype)
-	case TypeUndefined:
-		err = src.ReadUndefined()
-		if err != nil {
-			break
-		}
-		err = dst.WriteUndefined()
-	case TypeObjectID:
-		var oid ObjectID
-		oid, err = src.ReadObjectID()
-		if err != nil {
-			break
-		}
-		err = dst.WriteObjectID(oid)
-	case TypeBoolean:
-		var b bool
-		b, err = src.ReadBoolean()
-		if err != nil {
-			break
-		}
-		err = dst.WriteBoolean(b)
-	case TypeDateTime:
-		var dt int64
-		dt, err = src.ReadDateTime()
-		if err != nil {
-			break
-		}
-		err = dst.WriteDateTime(dt)
-	case TypeNull:
-		err = src.ReadNull()
-		if err != nil {
-			break
-		}
-		err = dst.WriteNull()
-	case TypeRegex:
-		var pattern, options string
-		pattern, options, err = src.ReadRegex()
-		if err != nil {
-			break
-		}
-		err = dst.WriteRegex(pattern, options)
-	case TypeDBPointer:
-		var ns string
-		var pointer ObjectID
-		ns, pointer, err = src.ReadDBPointer()
-		if err != nil {
-			break
-		}
-		err = dst.WriteDBPointer(ns, pointer)
-	case TypeJavaScript:
-		var js string
-		js, err = src.ReadJavascript()
-		if err != nil {
-			break
-		}
-		err = dst.WriteJavascript(js)
-	case TypeSymbol:
-		var symbol string
-		symbol, err = src.ReadSymbol()
-		if err != nil {
-			break
-		}
-		err = dst.WriteSymbol(symbol)
-	case TypeCodeWithScope:
-		var code string
-		var srcScope DocumentReader
-		code, srcScope, err = src.ReadCodeWithScope()
-		if err != nil {
-			break
-		}
-
-		var dstScope DocumentWriter
-		dstScope, err = dst.WriteCodeWithScope(code)
-		if err != nil {
-			break
-		}
-		err = copyDocumentCore(dstScope, srcScope)
-	case TypeInt32:
-		var i32 int32
-		i32, err = src.ReadInt32()
-		if err != nil {
-			break
-		}
-		err = dst.WriteInt32(i32)
-	case TypeTimestamp:
-		var t, i uint32
-		t, i, err = src.ReadTimestamp()
-		if err != nil {
-			break
-		}
-		err = dst.WriteTimestamp(t, i)
-	case TypeInt64:
-		var i64 int64
-		i64, err = src.ReadInt64()
-		if err != nil {
-			break
-		}
-		err = dst.WriteInt64(i64)
-	case TypeDecimal128:
-		var d128 Decimal128
-		d128, err = src.ReadDecimal128()
-		if err != nil {
-			break
-		}
-		err = dst.WriteDecimal128(d128)
-	case TypeMinKey:
-		err = src.ReadMinKey()
-		if err != nil {
-			break
-		}
-		err = dst.WriteMinKey()
-	case TypeMaxKey:
-		err = src.ReadMaxKey()
-		if err != nil {
-			break
-		}
-		err = dst.WriteMaxKey()
-	default:
-		err = fmt.Errorf("cannot copy unknown BSON type %s", src.Type())
-	}
-
-	return err
-}
-
-func copyArray(dst ValueWriter, src ValueReader) error {
-	ar, err := src.ReadArray()
-	if err != nil {
-		return err
-	}
-
-	aw, err := dst.WriteArray()
-	if err != nil {
-		return err
-	}
-
-	for {
-		vr, err := ar.ReadValue()
-		if errors.Is(err, ErrEOA) {
-			break
-		}
-		if err != nil {
-			return err
-		}
-
-		vw, err := aw.WriteArrayElement()
-		if err != nil {
-			return err
-		}
-
-		err = copyValue(vw, vr)
-		if err != nil {
-			return err
-		}
-	}
-
-	return aw.WriteArrayEnd()
-}
-
-func copyDocumentCore(dw DocumentWriter, dr DocumentReader) error {
-	for {
-		key, vr, err := dr.ReadElement()
-		if errors.Is(err, ErrEOD) {
-			break
-		}
-		if err != nil {
-			return err
-		}
-
-		vw, err := dw.WriteDocumentElement(key)
-		if err != nil {
-			return err
-		}
-
-		err = copyValue(vw, vr)
-		if err != nil {
-			return err
-		}
-	}
-
-	return dw.WriteDocumentEnd()
-}
-
-// bytesReader is the interface used to read BSON bytes from a valueReader.
-//
-// The bytes of the value will be appended to dst.
-type bytesReader interface {
-	readValueBytes(dst []byte) (Type, []byte, error)
-}
-
-// bytesWriter is the interface used to write BSON bytes to a valueWriter.
-type bytesWriter interface {
-	writeValueBytes(t Type, b []byte) error
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/decimal.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/decimal.go
deleted file mode 100644
index 85c506ef..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/decimal.go
+++ /dev/null
@@ -1,339 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-//
-// Based on gopkg.in/mgo.v2/bson by Gustavo Niemeyer
-// See THIRD-PARTY-NOTICES for original license terms.
-
-package bson
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"math/big"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"go.mongodb.org/mongo-driver/v2/internal/decimal128"
-)
-
-// These constants are the maximum and minimum values for the exponent field in a decimal128 value.
-const (
-	MaxDecimal128Exp = 6111
-	MinDecimal128Exp = -6176
-)
-
-// These errors are returned when an invalid value is parsed as a big.Int.
-var (
-	ErrParseNaN    = errors.New("cannot parse NaN as a *big.Int")
-	ErrParseInf    = errors.New("cannot parse Infinity as a *big.Int")
-	ErrParseNegInf = errors.New("cannot parse -Infinity as a *big.Int")
-)
-
-// Decimal128 holds decimal128 BSON values.
-type Decimal128 struct {
-	h, l uint64
-}
-
-// NewDecimal128 creates a Decimal128 using the provide high and low uint64s.
-func NewDecimal128(h, l uint64) Decimal128 {
-	return Decimal128{h: h, l: l}
-}
-
-// GetBytes returns the underlying bytes of the BSON decimal value as two uint64 values. The first
-// contains the most first 8 bytes of the value and the second contains the latter.
-func (d Decimal128) GetBytes() (uint64, uint64) {
-	return d.h, d.l
-}
-
-// String returns a string representation of the decimal value.
-func (d Decimal128) String() string {
-	return decimal128.String(d.h, d.l)
-}
-
-// BigInt returns significand as big.Int and exponent, bi * 10 ^ exp.
-func (d Decimal128) BigInt() (*big.Int, int, error) {
-	high, low := d.GetBytes()
-	posSign := high>>63&1 == 0 // positive sign
-
-	switch high >> 58 & (1<<5 - 1) {
-	case 0x1F:
-		return nil, 0, ErrParseNaN
-	case 0x1E:
-		if posSign {
-			return nil, 0, ErrParseInf
-		}
-		return nil, 0, ErrParseNegInf
-	}
-
-	var exp int
-	if high>>61&3 == 3 {
-		// Bits: 1*sign 2*ignored 14*exponent 111*significand.
-		// Implicit 0b100 prefix in significand.
-		exp = int(high >> 47 & (1<<14 - 1))
-		// Spec says all of these values are out of range.
-		high, low = 0, 0
-	} else {
-		// Bits: 1*sign 14*exponent 113*significand
-		exp = int(high >> 49 & (1<<14 - 1))
-		high &= (1<<49 - 1)
-	}
-	exp += MinDecimal128Exp
-
-	// Would be handled by the logic below, but that's trivial and common.
-	if high == 0 && low == 0 && exp == 0 {
-		return new(big.Int), 0, nil
-	}
-
-	bi := big.NewInt(0)
-	const host32bit = ^uint(0)>>32 == 0
-	if host32bit {
-		bi.SetBits([]big.Word{big.Word(low), big.Word(low >> 32), big.Word(high), big.Word(high >> 32)})
-	} else {
-		bi.SetBits([]big.Word{big.Word(low), big.Word(high)})
-	}
-
-	if !posSign {
-		return bi.Neg(bi), exp, nil
-	}
-	return bi, exp, nil
-}
-
-// IsNaN returns whether d is NaN.
-func (d Decimal128) IsNaN() bool {
-	return d.h>>58&(1<<5-1) == 0x1F
-}
-
-// IsInf returns:
-//
-//	+1 d == Infinity
-//	 0 other case
-//	-1 d == -Infinity
-func (d Decimal128) IsInf() int {
-	if d.h>>58&(1<<5-1) != 0x1E {
-		return 0
-	}
-
-	if d.h>>63&1 == 0 {
-		return 1
-	}
-	return -1
-}
-
-// IsZero returns true if d is the empty Decimal128.
-func (d Decimal128) IsZero() bool {
-	return d.h == 0 && d.l == 0
-}
-
-// MarshalJSON returns Decimal128 as a string.
-func (d Decimal128) MarshalJSON() ([]byte, error) {
-	return json.Marshal(d.String())
-}
-
-// UnmarshalJSON creates a Decimal128 from a JSON string, an extended JSON $numberDecimal value, or the string
-// "null". If b is a JSON string or extended JSON value, d will have the value of that string, and if b is "null", d will
-// be unchanged.
-func (d *Decimal128) UnmarshalJSON(b []byte) error {
-	// Ignore "null" to keep parity with the standard library. Decoding a JSON null into a non-pointer Decimal128 field
-	// will leave the field unchanged. For pointer values, encoding/json will set the pointer to nil and will not
-	// enter the UnmarshalJSON hook.
-	if string(b) == "null" {
-		return nil
-	}
-
-	var res interface{}
-	err := json.Unmarshal(b, &res)
-	if err != nil {
-		return err
-	}
-	str, ok := res.(string)
-
-	// Extended JSON
-	if !ok {
-		m, ok := res.(map[string]interface{})
-		if !ok {
-			return errors.New("not an extended JSON Decimal128: expected document")
-		}
-		d128, ok := m["$numberDecimal"]
-		if !ok {
-			return errors.New("not an extended JSON Decimal128: expected key $numberDecimal")
-		}
-		str, ok = d128.(string)
-		if !ok {
-			return errors.New("not an extended JSON Decimal128: expected decimal to be string")
-		}
-	}
-
-	*d, err = ParseDecimal128(str)
-	return err
-}
-
-var dNaN = Decimal128{0x1F << 58, 0}
-var dPosInf = Decimal128{0x1E << 58, 0}
-var dNegInf = Decimal128{0x3E << 58, 0}
-
-func dErr(s string) (Decimal128, error) {
-	return dNaN, fmt.Errorf("cannot parse %q as a decimal128", s)
-}
-
-// match scientific notation number, example -10.15e-18
-var normalNumber = regexp.MustCompile(`^(?P<int>[-+]?\d*)?(?:\.(?P<dec>\d*))?(?:[Ee](?P<exp>[-+]?\d+))?$`)
-
-// ParseDecimal128 takes the given string and attempts to parse it into a valid
-// Decimal128 value.
-func ParseDecimal128(s string) (Decimal128, error) {
-	if s == "" {
-		return dErr(s)
-	}
-
-	matches := normalNumber.FindStringSubmatch(s)
-	if len(matches) == 0 {
-		orig := s
-		neg := s[0] == '-'
-		if neg || s[0] == '+' {
-			s = s[1:]
-		}
-
-		if s == "NaN" || s == "nan" || strings.EqualFold(s, "nan") {
-			return dNaN, nil
-		}
-		if s == "Inf" || s == "inf" || strings.EqualFold(s, "inf") || strings.EqualFold(s, "infinity") {
-			if neg {
-				return dNegInf, nil
-			}
-			return dPosInf, nil
-		}
-		return dErr(orig)
-	}
-
-	intPart := matches[1]
-	decPart := matches[2]
-	expPart := matches[3]
-
-	var err error
-	exp := 0
-	if expPart != "" {
-		exp, err = strconv.Atoi(expPart)
-		if err != nil {
-			return dErr(s)
-		}
-	}
-	if decPart != "" {
-		exp -= len(decPart)
-	}
-
-	if len(strings.Trim(intPart+decPart, "-0")) > 35 {
-		return dErr(s)
-	}
-
-	// Parse the significand (i.e. the non-exponent part) as a big.Int.
-	bi, ok := new(big.Int).SetString(intPart+decPart, 10)
-	if !ok {
-		return dErr(s)
-	}
-
-	d, ok := ParseDecimal128FromBigInt(bi, exp)
-	if !ok {
-		return dErr(s)
-	}
-
-	if bi.Sign() == 0 && s[0] == '-' {
-		d.h |= 1 << 63
-	}
-
-	return d, nil
-}
-
-var (
-	ten  = big.NewInt(10)
-	zero = new(big.Int)
-
-	maxS, _ = new(big.Int).SetString("9999999999999999999999999999999999", 10)
-)
-
-// ParseDecimal128FromBigInt attempts to parse the given significand and exponent into a valid Decimal128 value.
-func ParseDecimal128FromBigInt(bi *big.Int, exp int) (Decimal128, bool) {
-	// copy
-	bi = new(big.Int).Set(bi)
-
-	q := new(big.Int)
-	r := new(big.Int)
-
-	// If the significand is zero, the logical value will always be zero, independent of the
-	// exponent. However, the loops for handling out-of-range exponent values below may be extremely
-	// slow for zero values because the significand never changes. Limit the exponent value to the
-	// supported range here to prevent entering the loops below.
-	if bi.Cmp(zero) == 0 {
-		if exp > MaxDecimal128Exp {
-			exp = MaxDecimal128Exp
-		}
-		if exp < MinDecimal128Exp {
-			exp = MinDecimal128Exp
-		}
-	}
-
-	for bigIntCmpAbs(bi, maxS) == 1 {
-		bi, _ = q.QuoRem(bi, ten, r)
-		if r.Cmp(zero) != 0 {
-			return Decimal128{}, false
-		}
-		exp++
-		if exp > MaxDecimal128Exp {
-			return Decimal128{}, false
-		}
-	}
-
-	for exp < MinDecimal128Exp {
-		// Subnormal.
-		bi, _ = q.QuoRem(bi, ten, r)
-		if r.Cmp(zero) != 0 {
-			return Decimal128{}, false
-		}
-		exp++
-	}
-	for exp > MaxDecimal128Exp {
-		// Clamped.
-		bi.Mul(bi, ten)
-		if bigIntCmpAbs(bi, maxS) == 1 {
-			return Decimal128{}, false
-		}
-		exp--
-	}
-
-	b := bi.Bytes()
-	var h, l uint64
-	for i := 0; i < len(b); i++ {
-		if i < len(b)-8 {
-			h = h<<8 | uint64(b[i])
-			continue
-		}
-		l = l<<8 | uint64(b[i])
-	}
-
-	h |= uint64(exp-MinDecimal128Exp) & uint64(1<<14-1) << 49
-	if bi.Sign() == -1 {
-		h |= 1 << 63
-	}
-
-	return Decimal128{h: h, l: l}, true
-}
-
-// bigIntCmpAbs computes big.Int.Cmp(absoluteValue(x), absoluteValue(y)).
-func bigIntCmpAbs(x, y *big.Int) int {
-	xAbs := bigIntAbsValue(x)
-	yAbs := bigIntAbsValue(y)
-	return xAbs.Cmp(yAbs)
-}
-
-// bigIntAbsValue returns a big.Int containing the absolute value of b.
-// If b is already a non-negative number, it is returned without any changes or copies.
-func bigIntAbsValue(b *big.Int) *big.Int {
-	if b.Sign() >= 0 {
-		return b // already positive
-	}
-	return new(big.Int).Abs(b)
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/decoder.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/decoder.go
deleted file mode 100644
index 2fa9e6f1..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/decoder.go
+++ /dev/null
@@ -1,136 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"sync"
-)
-
-// ErrDecodeToNil is the error returned when trying to decode to a nil value
-var ErrDecodeToNil = errors.New("cannot Decode to nil value")
-
-// This pool is used to keep the allocations of Decoders down. This is only used for the Marshal*
-// methods and is not consumable from outside of this package. The Decoders retrieved from this pool
-// must have both Reset and SetRegistry called on them.
-var decPool = sync.Pool{
-	New: func() interface{} {
-		return new(Decoder)
-	},
-}
-
-// A Decoder reads and decodes BSON documents from a stream. It reads from a ValueReader as
-// the source of BSON data.
-type Decoder struct {
-	dc DecodeContext
-	vr ValueReader
-}
-
-// NewDecoder returns a new decoder that reads from vr.
-func NewDecoder(vr ValueReader) *Decoder {
-	return &Decoder{
-		dc: DecodeContext{Registry: defaultRegistry},
-		vr: vr,
-	}
-}
-
-// Decode reads the next BSON document from the stream and decodes it into the
-// value pointed to by val.
-//
-// See [Unmarshal] for details about BSON unmarshaling behavior.
-func (d *Decoder) Decode(val interface{}) error {
-	if unmarshaler, ok := val.(Unmarshaler); ok {
-		// TODO(skriptble): Reuse a []byte here and use the AppendDocumentBytes method.
-		buf, err := copyDocumentToBytes(d.vr)
-		if err != nil {
-			return err
-		}
-		return unmarshaler.UnmarshalBSON(buf)
-	}
-
-	rval := reflect.ValueOf(val)
-	switch rval.Kind() {
-	case reflect.Ptr:
-		if rval.IsNil() {
-			return ErrDecodeToNil
-		}
-		rval = rval.Elem()
-	case reflect.Map:
-		if rval.IsNil() {
-			return ErrDecodeToNil
-		}
-	default:
-		return fmt.Errorf("argument to Decode must be a pointer or a map, but got %v", rval)
-	}
-	decoder, err := d.dc.LookupDecoder(rval.Type())
-	if err != nil {
-		return err
-	}
-
-	return decoder.DecodeValue(d.dc, d.vr, rval)
-}
-
-// Reset will reset the state of the decoder, using the same *DecodeContext used in
-// the original construction but using vr for reading.
-func (d *Decoder) Reset(vr ValueReader) {
-	d.vr = vr
-}
-
-// SetRegistry replaces the current registry of the decoder with r.
-func (d *Decoder) SetRegistry(r *Registry) {
-	d.dc.Registry = r
-}
-
-// DefaultDocumentM causes the Decoder to always unmarshal documents into the bson.M type. This
-// behavior is restricted to data typed as "interface{}" or "map[string]interface{}".
-func (d *Decoder) DefaultDocumentM() {
-	d.dc.defaultDocumentType = reflect.TypeOf(M{})
-}
-
-// AllowTruncatingDoubles causes the Decoder to truncate the fractional part of BSON "double" values
-// when attempting to unmarshal them into a Go integer (int, int8, int16, int32, or int64) struct
-// field. The truncation logic does not apply to BSON "decimal128" values.
-func (d *Decoder) AllowTruncatingDoubles() {
-	d.dc.truncate = true
-}
-
-// BinaryAsSlice causes the Decoder to unmarshal BSON binary field values that are the "Generic" or
-// "Old" BSON binary subtype as a Go byte slice instead of a bson.Binary.
-func (d *Decoder) BinaryAsSlice() {
-	d.dc.binaryAsSlice = true
-}
-
-// ObjectIDAsHexString causes the Decoder to decode object IDs to their hex representation.
-func (d *Decoder) ObjectIDAsHexString() {
-	d.dc.objectIDAsHexString = true
-}
-
-// UseJSONStructTags causes the Decoder to fall back to using the "json" struct tag if a "bson"
-// struct tag is not specified.
-func (d *Decoder) UseJSONStructTags() {
-	d.dc.useJSONStructTags = true
-}
-
-// UseLocalTimeZone causes the Decoder to unmarshal time.Time values in the local timezone instead
-// of the UTC timezone.
-func (d *Decoder) UseLocalTimeZone() {
-	d.dc.useLocalTimeZone = true
-}
-
-// ZeroMaps causes the Decoder to delete any existing values from Go maps in the destination value
-// passed to Decode before unmarshaling BSON documents into them.
-func (d *Decoder) ZeroMaps() {
-	d.dc.zeroMaps = true
-}
-
-// ZeroStructs causes the Decoder to delete any existing values from Go structs in the destination
-// value passed to Decode before unmarshaling BSON documents into them.
-func (d *Decoder) ZeroStructs() {
-	d.dc.zeroStructs = true
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/default_value_decoders.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/default_value_decoders.go
deleted file mode 100644
index b7d20339..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/default_value_decoders.go
+++ /dev/null
@@ -1,1518 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"math"
-	"net/url"
-	"reflect"
-	"strconv"
-
-	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
-)
-
-var errCannotTruncate = errors.New("float64 can only be truncated to a lower precision type when truncation is enabled")
-
-type decodeBinaryError struct {
-	subtype  byte
-	typeName string
-}
-
-func (d decodeBinaryError) Error() string {
-	return fmt.Sprintf("only binary values with subtype 0x00 or 0x02 can be decoded into %s, but got subtype %v", d.typeName, d.subtype)
-}
-
-// registerDefaultDecoders will register the decoder methods attached to DefaultValueDecoders with
-// the provided RegistryBuilder.
-//
-// There is no support for decoding map[string]interface{} because there is no decoder for
-// interface{}, so users must either register this decoder themselves or use the
-// EmptyInterfaceDecoder available in the bson package.
-func registerDefaultDecoders(reg *Registry) {
-	intDecoder := decodeAdapter{intDecodeValue, intDecodeType}
-	floatDecoder := decodeAdapter{floatDecodeValue, floatDecodeType}
-	uintCodec := &uintCodec{}
-
-	reg.RegisterTypeDecoder(tD, ValueDecoderFunc(dDecodeValue))
-	reg.RegisterTypeDecoder(tBinary, decodeAdapter{binaryDecodeValue, binaryDecodeType})
-	reg.RegisterTypeDecoder(tVector, decodeAdapter{vectorDecodeValue, vectorDecodeType})
-	reg.RegisterTypeDecoder(tUndefined, decodeAdapter{undefinedDecodeValue, undefinedDecodeType})
-	reg.RegisterTypeDecoder(tDateTime, decodeAdapter{dateTimeDecodeValue, dateTimeDecodeType})
-	reg.RegisterTypeDecoder(tNull, decodeAdapter{nullDecodeValue, nullDecodeType})
-	reg.RegisterTypeDecoder(tRegex, decodeAdapter{regexDecodeValue, regexDecodeType})
-	reg.RegisterTypeDecoder(tDBPointer, decodeAdapter{dbPointerDecodeValue, dbPointerDecodeType})
-	reg.RegisterTypeDecoder(tTimestamp, decodeAdapter{timestampDecodeValue, timestampDecodeType})
-	reg.RegisterTypeDecoder(tMinKey, decodeAdapter{minKeyDecodeValue, minKeyDecodeType})
-	reg.RegisterTypeDecoder(tMaxKey, decodeAdapter{maxKeyDecodeValue, maxKeyDecodeType})
-	reg.RegisterTypeDecoder(tJavaScript, decodeAdapter{javaScriptDecodeValue, javaScriptDecodeType})
-	reg.RegisterTypeDecoder(tSymbol, decodeAdapter{symbolDecodeValue, symbolDecodeType})
-	reg.RegisterTypeDecoder(tByteSlice, &byteSliceCodec{})
-	reg.RegisterTypeDecoder(tTime, &timeCodec{})
-	reg.RegisterTypeDecoder(tEmpty, &emptyInterfaceCodec{})
-	reg.RegisterTypeDecoder(tCoreArray, &arrayCodec{})
-	reg.RegisterTypeDecoder(tOID, decodeAdapter{objectIDDecodeValue, objectIDDecodeType})
-	reg.RegisterTypeDecoder(tDecimal, decodeAdapter{decimal128DecodeValue, decimal128DecodeType})
-	reg.RegisterTypeDecoder(tJSONNumber, decodeAdapter{jsonNumberDecodeValue, jsonNumberDecodeType})
-	reg.RegisterTypeDecoder(tURL, decodeAdapter{urlDecodeValue, urlDecodeType})
-	reg.RegisterTypeDecoder(tCoreDocument, ValueDecoderFunc(coreDocumentDecodeValue))
-	reg.RegisterTypeDecoder(tCodeWithScope, decodeAdapter{codeWithScopeDecodeValue, codeWithScopeDecodeType})
-	reg.RegisterKindDecoder(reflect.Bool, decodeAdapter{booleanDecodeValue, booleanDecodeType})
-	reg.RegisterKindDecoder(reflect.Int, intDecoder)
-	reg.RegisterKindDecoder(reflect.Int8, intDecoder)
-	reg.RegisterKindDecoder(reflect.Int16, intDecoder)
-	reg.RegisterKindDecoder(reflect.Int32, intDecoder)
-	reg.RegisterKindDecoder(reflect.Int64, intDecoder)
-	reg.RegisterKindDecoder(reflect.Uint, uintCodec)
-	reg.RegisterKindDecoder(reflect.Uint8, uintCodec)
-	reg.RegisterKindDecoder(reflect.Uint16, uintCodec)
-	reg.RegisterKindDecoder(reflect.Uint32, uintCodec)
-	reg.RegisterKindDecoder(reflect.Uint64, uintCodec)
-	reg.RegisterKindDecoder(reflect.Float32, floatDecoder)
-	reg.RegisterKindDecoder(reflect.Float64, floatDecoder)
-	reg.RegisterKindDecoder(reflect.Array, ValueDecoderFunc(arrayDecodeValue))
-	reg.RegisterKindDecoder(reflect.Map, &mapCodec{})
-	reg.RegisterKindDecoder(reflect.Slice, &sliceCodec{})
-	reg.RegisterKindDecoder(reflect.String, &stringCodec{})
-	reg.RegisterKindDecoder(reflect.Struct, newStructCodec(nil))
-	reg.RegisterKindDecoder(reflect.Ptr, &pointerCodec{})
-	reg.RegisterTypeMapEntry(TypeDouble, tFloat64)
-	reg.RegisterTypeMapEntry(TypeString, tString)
-	reg.RegisterTypeMapEntry(TypeArray, tA)
-	reg.RegisterTypeMapEntry(TypeBinary, tBinary)
-	reg.RegisterTypeMapEntry(TypeUndefined, tUndefined)
-	reg.RegisterTypeMapEntry(TypeObjectID, tOID)
-	reg.RegisterTypeMapEntry(TypeBoolean, tBool)
-	reg.RegisterTypeMapEntry(TypeDateTime, tDateTime)
-	reg.RegisterTypeMapEntry(TypeRegex, tRegex)
-	reg.RegisterTypeMapEntry(TypeDBPointer, tDBPointer)
-	reg.RegisterTypeMapEntry(TypeJavaScript, tJavaScript)
-	reg.RegisterTypeMapEntry(TypeSymbol, tSymbol)
-	reg.RegisterTypeMapEntry(TypeCodeWithScope, tCodeWithScope)
-	reg.RegisterTypeMapEntry(TypeInt32, tInt32)
-	reg.RegisterTypeMapEntry(TypeInt64, tInt64)
-	reg.RegisterTypeMapEntry(TypeTimestamp, tTimestamp)
-	reg.RegisterTypeMapEntry(TypeDecimal128, tDecimal)
-	reg.RegisterTypeMapEntry(TypeMinKey, tMinKey)
-	reg.RegisterTypeMapEntry(TypeMaxKey, tMaxKey)
-	reg.RegisterTypeMapEntry(Type(0), tD)
-	reg.RegisterTypeMapEntry(TypeEmbeddedDocument, tD)
-	reg.RegisterInterfaceDecoder(tValueUnmarshaler, ValueDecoderFunc(valueUnmarshalerDecodeValue))
-	reg.RegisterInterfaceDecoder(tUnmarshaler, ValueDecoderFunc(unmarshalerDecodeValue))
-}
-
-// dDecodeValue is the ValueDecoderFunc for D instances.
-func dDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.IsValid() || !val.CanSet() || val.Type() != tD {
-		return ValueDecoderError{Name: "DDecodeValue", Kinds: []reflect.Kind{reflect.Slice}, Received: val}
-	}
-
-	switch vrType := vr.Type(); vrType {
-	case Type(0), TypeEmbeddedDocument:
-		break
-	case TypeNull:
-		val.Set(reflect.Zero(val.Type()))
-		return vr.ReadNull()
-	default:
-		return fmt.Errorf("cannot decode %v into a D", vrType)
-	}
-
-	dr, err := vr.ReadDocument()
-	if err != nil {
-		return err
-	}
-
-	decoder, err := dc.LookupDecoder(tEmpty)
-	if err != nil {
-		return err
-	}
-
-	// Use the elements in the provided value if it's non nil. Otherwise, allocate a new D instance.
-	var elems D
-	if !val.IsNil() {
-		val.SetLen(0)
-		elems = val.Interface().(D)
-	} else {
-		elems = make(D, 0)
-	}
-
-	for {
-		key, elemVr, err := dr.ReadElement()
-		if errors.Is(err, ErrEOD) {
-			break
-		} else if err != nil {
-			return err
-		}
-
-		var v interface{}
-		err = decoder.DecodeValue(dc, elemVr, reflect.ValueOf(&v).Elem())
-		if err != nil {
-			return err
-		}
-
-		elems = append(elems, E{Key: key, Value: v})
-	}
-
-	val.Set(reflect.ValueOf(elems))
-	return nil
-}
-
-func booleanDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t.Kind() != reflect.Bool {
-		return emptyValue, ValueDecoderError{
-			Name:     "BooleanDecodeValue",
-			Kinds:    []reflect.Kind{reflect.Bool},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	var b bool
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeInt32:
-		i32, err := vr.ReadInt32()
-		if err != nil {
-			return emptyValue, err
-		}
-		b = (i32 != 0)
-	case TypeInt64:
-		i64, err := vr.ReadInt64()
-		if err != nil {
-			return emptyValue, err
-		}
-		b = (i64 != 0)
-	case TypeDouble:
-		f64, err := vr.ReadDouble()
-		if err != nil {
-			return emptyValue, err
-		}
-		b = (f64 != 0)
-	case TypeBoolean:
-		b, err = vr.ReadBoolean()
-	case TypeNull:
-		err = vr.ReadNull()
-	case TypeUndefined:
-		err = vr.ReadUndefined()
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a boolean", vrType)
-	}
-	if err != nil {
-		return emptyValue, err
-	}
-
-	return reflect.ValueOf(b), nil
-}
-
-// booleanDecodeValue is the ValueDecoderFunc for bool types.
-func booleanDecodeValue(dctx DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.IsValid() || !val.CanSet() || val.Kind() != reflect.Bool {
-		return ValueDecoderError{Name: "BooleanDecodeValue", Kinds: []reflect.Kind{reflect.Bool}, Received: val}
-	}
-
-	elem, err := booleanDecodeType(dctx, vr, val.Type())
-	if err != nil {
-		return err
-	}
-
-	val.SetBool(elem.Bool())
-	return nil
-}
-
-func intDecodeType(dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	var i64 int64
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeInt32:
-		i32, err := vr.ReadInt32()
-		if err != nil {
-			return emptyValue, err
-		}
-		i64 = int64(i32)
-	case TypeInt64:
-		i64, err = vr.ReadInt64()
-		if err != nil {
-			return emptyValue, err
-		}
-	case TypeDouble:
-		f64, err := vr.ReadDouble()
-		if err != nil {
-			return emptyValue, err
-		}
-		if !dc.truncate && math.Floor(f64) != f64 {
-			return emptyValue, errCannotTruncate
-		}
-		if f64 > float64(math.MaxInt64) {
-			return emptyValue, fmt.Errorf("%g overflows int64", f64)
-		}
-		i64 = int64(f64)
-	case TypeBoolean:
-		b, err := vr.ReadBoolean()
-		if err != nil {
-			return emptyValue, err
-		}
-		if b {
-			i64 = 1
-		}
-	case TypeNull:
-		if err = vr.ReadNull(); err != nil {
-			return emptyValue, err
-		}
-	case TypeUndefined:
-		if err = vr.ReadUndefined(); err != nil {
-			return emptyValue, err
-		}
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into an integer type", vrType)
-	}
-
-	switch t.Kind() {
-	case reflect.Int8:
-		if i64 < math.MinInt8 || i64 > math.MaxInt8 {
-			return emptyValue, fmt.Errorf("%d overflows int8", i64)
-		}
-
-		return reflect.ValueOf(int8(i64)), nil
-	case reflect.Int16:
-		if i64 < math.MinInt16 || i64 > math.MaxInt16 {
-			return emptyValue, fmt.Errorf("%d overflows int16", i64)
-		}
-
-		return reflect.ValueOf(int16(i64)), nil
-	case reflect.Int32:
-		if i64 < math.MinInt32 || i64 > math.MaxInt32 {
-			return emptyValue, fmt.Errorf("%d overflows int32", i64)
-		}
-
-		return reflect.ValueOf(int32(i64)), nil
-	case reflect.Int64:
-		return reflect.ValueOf(i64), nil
-	case reflect.Int:
-		if i64 > math.MaxInt { // Can we fit this inside of an int
-			return emptyValue, fmt.Errorf("%d overflows int", i64)
-		}
-
-		return reflect.ValueOf(int(i64)), nil
-	default:
-		return emptyValue, ValueDecoderError{
-			Name:     "IntDecodeValue",
-			Kinds:    []reflect.Kind{reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int},
-			Received: reflect.Zero(t),
-		}
-	}
-}
-
-// intDecodeValue is the ValueDecoderFunc for int types.
-func intDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() {
-		return ValueDecoderError{
-			Name:     "IntDecodeValue",
-			Kinds:    []reflect.Kind{reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int},
-			Received: val,
-		}
-	}
-
-	elem, err := intDecodeType(dc, vr, val.Type())
-	if err != nil {
-		return err
-	}
-
-	val.SetInt(elem.Int())
-	return nil
-}
-
-func floatDecodeType(dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	var f float64
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeInt32:
-		i32, err := vr.ReadInt32()
-		if err != nil {
-			return emptyValue, err
-		}
-		f = float64(i32)
-	case TypeInt64:
-		i64, err := vr.ReadInt64()
-		if err != nil {
-			return emptyValue, err
-		}
-		f = float64(i64)
-	case TypeDouble:
-		f, err = vr.ReadDouble()
-		if err != nil {
-			return emptyValue, err
-		}
-	case TypeBoolean:
-		b, err := vr.ReadBoolean()
-		if err != nil {
-			return emptyValue, err
-		}
-		if b {
-			f = 1
-		}
-	case TypeNull:
-		if err = vr.ReadNull(); err != nil {
-			return emptyValue, err
-		}
-	case TypeUndefined:
-		if err = vr.ReadUndefined(); err != nil {
-			return emptyValue, err
-		}
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a float32 or float64 type", vrType)
-	}
-
-	switch t.Kind() {
-	case reflect.Float32:
-		if !dc.truncate && float64(float32(f)) != f {
-			return emptyValue, errCannotTruncate
-		}
-
-		return reflect.ValueOf(float32(f)), nil
-	case reflect.Float64:
-		return reflect.ValueOf(f), nil
-	default:
-		return emptyValue, ValueDecoderError{
-			Name:     "FloatDecodeValue",
-			Kinds:    []reflect.Kind{reflect.Float32, reflect.Float64},
-			Received: reflect.Zero(t),
-		}
-	}
-}
-
-// floatDecodeValue is the ValueDecoderFunc for float types.
-func floatDecodeValue(ec DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() {
-		return ValueDecoderError{
-			Name:     "FloatDecodeValue",
-			Kinds:    []reflect.Kind{reflect.Float32, reflect.Float64},
-			Received: val,
-		}
-	}
-
-	elem, err := floatDecodeType(ec, vr, val.Type())
-	if err != nil {
-		return err
-	}
-
-	val.SetFloat(elem.Float())
-	return nil
-}
-
-func javaScriptDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tJavaScript {
-		return emptyValue, ValueDecoderError{
-			Name:     "JavaScriptDecodeValue",
-			Types:    []reflect.Type{tJavaScript},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	var js string
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeJavaScript:
-		js, err = vr.ReadJavascript()
-	case TypeNull:
-		err = vr.ReadNull()
-	case TypeUndefined:
-		err = vr.ReadUndefined()
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a JavaScript", vrType)
-	}
-	if err != nil {
-		return emptyValue, err
-	}
-
-	return reflect.ValueOf(JavaScript(js)), nil
-}
-
-// javaScriptDecodeValue is the ValueDecoderFunc for the JavaScript type.
-func javaScriptDecodeValue(dctx DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tJavaScript {
-		return ValueDecoderError{Name: "JavaScriptDecodeValue", Types: []reflect.Type{tJavaScript}, Received: val}
-	}
-
-	elem, err := javaScriptDecodeType(dctx, vr, tJavaScript)
-	if err != nil {
-		return err
-	}
-
-	val.SetString(elem.String())
-	return nil
-}
-
-func symbolDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tSymbol {
-		return emptyValue, ValueDecoderError{
-			Name:     "SymbolDecodeValue",
-			Types:    []reflect.Type{tSymbol},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	var symbol string
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeString:
-		symbol, err = vr.ReadString()
-	case TypeSymbol:
-		symbol, err = vr.ReadSymbol()
-	case TypeBinary:
-		data, subtype, err := vr.ReadBinary()
-		if err != nil {
-			return emptyValue, err
-		}
-
-		if subtype != TypeBinaryGeneric && subtype != TypeBinaryBinaryOld {
-			return emptyValue, decodeBinaryError{subtype: subtype, typeName: "Symbol"}
-		}
-		symbol = string(data)
-	case TypeNull:
-		err = vr.ReadNull()
-	case TypeUndefined:
-		err = vr.ReadUndefined()
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a Symbol", vrType)
-	}
-	if err != nil {
-		return emptyValue, err
-	}
-
-	return reflect.ValueOf(Symbol(symbol)), nil
-}
-
-// symbolDecodeValue is the ValueDecoderFunc for the Symbol type.
-func symbolDecodeValue(dctx DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tSymbol {
-		return ValueDecoderError{Name: "SymbolDecodeValue", Types: []reflect.Type{tSymbol}, Received: val}
-	}
-
-	elem, err := symbolDecodeType(dctx, vr, tSymbol)
-	if err != nil {
-		return err
-	}
-
-	val.SetString(elem.String())
-	return nil
-}
-
-func binaryDecode(vr ValueReader) (Binary, error) {
-	var b Binary
-
-	var data []byte
-	var subtype byte
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeBinary:
-		data, subtype, err = vr.ReadBinary()
-	case TypeNull:
-		err = vr.ReadNull()
-	case TypeUndefined:
-		err = vr.ReadUndefined()
-	default:
-		return b, fmt.Errorf("cannot decode %v into a Binary", vrType)
-	}
-	if err != nil {
-		return b, err
-	}
-	b.Subtype = subtype
-	b.Data = data
-
-	return b, nil
-}
-
-func binaryDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tBinary {
-		return emptyValue, ValueDecoderError{
-			Name:     "BinaryDecodeValue",
-			Types:    []reflect.Type{tBinary},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	b, err := binaryDecode(vr)
-	if err != nil {
-		return emptyValue, err
-	}
-	return reflect.ValueOf(b), nil
-}
-
-// binaryDecodeValue is the ValueDecoderFunc for Binary.
-func binaryDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tBinary {
-		return ValueDecoderError{Name: "BinaryDecodeValue", Types: []reflect.Type{tBinary}, Received: val}
-	}
-
-	elem, err := binaryDecodeType(dc, vr, tBinary)
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
-
-func vectorDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tVector {
-		return emptyValue, ValueDecoderError{
-			Name:     "VectorDecodeValue",
-			Types:    []reflect.Type{tVector},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	b, err := binaryDecode(vr)
-	if err != nil {
-		return emptyValue, err
-	}
-
-	v, err := NewVectorFromBinary(b)
-	if err != nil {
-		return emptyValue, err
-	}
-
-	return reflect.ValueOf(v), nil
-}
-
-// vectorDecodeValue is the ValueDecoderFunc for Vector.
-func vectorDecodeValue(dctx DecodeContext, vr ValueReader, val reflect.Value) error {
-	t := val.Type()
-	if !val.CanSet() || t != tVector {
-		return ValueDecoderError{
-			Name:     "VectorDecodeValue",
-			Types:    []reflect.Type{tVector},
-			Received: val,
-		}
-	}
-
-	elem, err := vectorDecodeType(dctx, vr, t)
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
-
-func undefinedDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tUndefined {
-		return emptyValue, ValueDecoderError{
-			Name:     "UndefinedDecodeValue",
-			Types:    []reflect.Type{tUndefined},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeUndefined:
-		err = vr.ReadUndefined()
-	case TypeNull:
-		err = vr.ReadNull()
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into an Undefined", vr.Type())
-	}
-	if err != nil {
-		return emptyValue, err
-	}
-
-	return reflect.ValueOf(Undefined{}), nil
-}
-
-// undefinedDecodeValue is the ValueDecoderFunc for Undefined.
-func undefinedDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tUndefined {
-		return ValueDecoderError{Name: "UndefinedDecodeValue", Types: []reflect.Type{tUndefined}, Received: val}
-	}
-
-	elem, err := undefinedDecodeType(dc, vr, tUndefined)
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
-
-// Accept both 12-byte string and pretty-printed 24-byte hex string formats.
-func objectIDDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tOID {
-		return emptyValue, ValueDecoderError{
-			Name:     "ObjectIDDecodeValue",
-			Types:    []reflect.Type{tOID},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	var oid ObjectID
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeObjectID:
-		oid, err = vr.ReadObjectID()
-		if err != nil {
-			return emptyValue, err
-		}
-	case TypeString:
-		str, err := vr.ReadString()
-		if err != nil {
-			return emptyValue, err
-		}
-		if oid, err = ObjectIDFromHex(str); err == nil {
-			break
-		}
-		if len(str) != 12 {
-			return emptyValue, fmt.Errorf("an ObjectID string must be exactly 12 bytes long (got %v)", len(str))
-		}
-		byteArr := []byte(str)
-		copy(oid[:], byteArr)
-	case TypeNull:
-		if err = vr.ReadNull(); err != nil {
-			return emptyValue, err
-		}
-	case TypeUndefined:
-		if err = vr.ReadUndefined(); err != nil {
-			return emptyValue, err
-		}
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into an ObjectID", vrType)
-	}
-
-	return reflect.ValueOf(oid), nil
-}
-
-// objectIDDecodeValue is the ValueDecoderFunc for ObjectID.
-func objectIDDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tOID {
-		return ValueDecoderError{Name: "ObjectIDDecodeValue", Types: []reflect.Type{tOID}, Received: val}
-	}
-
-	elem, err := objectIDDecodeType(dc, vr, tOID)
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
-
-func dateTimeDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tDateTime {
-		return emptyValue, ValueDecoderError{
-			Name:     "DateTimeDecodeValue",
-			Types:    []reflect.Type{tDateTime},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	var dt int64
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeDateTime:
-		dt, err = vr.ReadDateTime()
-	case TypeNull:
-		err = vr.ReadNull()
-	case TypeUndefined:
-		err = vr.ReadUndefined()
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a DateTime", vrType)
-	}
-	if err != nil {
-		return emptyValue, err
-	}
-
-	return reflect.ValueOf(DateTime(dt)), nil
-}
-
-// dateTimeDecodeValue is the ValueDecoderFunc for DateTime.
-func dateTimeDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tDateTime {
-		return ValueDecoderError{Name: "DateTimeDecodeValue", Types: []reflect.Type{tDateTime}, Received: val}
-	}
-
-	elem, err := dateTimeDecodeType(dc, vr, tDateTime)
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
-
-func nullDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tNull {
-		return emptyValue, ValueDecoderError{
-			Name:     "NullDecodeValue",
-			Types:    []reflect.Type{tNull},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeUndefined:
-		err = vr.ReadUndefined()
-	case TypeNull:
-		err = vr.ReadNull()
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a Null", vr.Type())
-	}
-	if err != nil {
-		return emptyValue, err
-	}
-
-	return reflect.ValueOf(Null{}), nil
-}
-
-// nullDecodeValue is the ValueDecoderFunc for Null.
-func nullDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tNull {
-		return ValueDecoderError{Name: "NullDecodeValue", Types: []reflect.Type{tNull}, Received: val}
-	}
-
-	elem, err := nullDecodeType(dc, vr, tNull)
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
-
-func regexDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tRegex {
-		return emptyValue, ValueDecoderError{
-			Name:     "RegexDecodeValue",
-			Types:    []reflect.Type{tRegex},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	var pattern, options string
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeRegex:
-		pattern, options, err = vr.ReadRegex()
-	case TypeNull:
-		err = vr.ReadNull()
-	case TypeUndefined:
-		err = vr.ReadUndefined()
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a Regex", vrType)
-	}
-	if err != nil {
-		return emptyValue, err
-	}
-
-	return reflect.ValueOf(Regex{Pattern: pattern, Options: options}), nil
-}
-
-// regexDecodeValue is the ValueDecoderFunc for Regex.
-func regexDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tRegex {
-		return ValueDecoderError{Name: "RegexDecodeValue", Types: []reflect.Type{tRegex}, Received: val}
-	}
-
-	elem, err := regexDecodeType(dc, vr, tRegex)
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
-
-func dbPointerDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tDBPointer {
-		return emptyValue, ValueDecoderError{
-			Name:     "DBPointerDecodeValue",
-			Types:    []reflect.Type{tDBPointer},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	var ns string
-	var pointer ObjectID
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeDBPointer:
-		ns, pointer, err = vr.ReadDBPointer()
-	case TypeNull:
-		err = vr.ReadNull()
-	case TypeUndefined:
-		err = vr.ReadUndefined()
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a DBPointer", vrType)
-	}
-	if err != nil {
-		return emptyValue, err
-	}
-
-	return reflect.ValueOf(DBPointer{DB: ns, Pointer: pointer}), nil
-}
-
-// dbPointerDecodeValue is the ValueDecoderFunc for DBPointer.
-func dbPointerDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tDBPointer {
-		return ValueDecoderError{Name: "DBPointerDecodeValue", Types: []reflect.Type{tDBPointer}, Received: val}
-	}
-
-	elem, err := dbPointerDecodeType(dc, vr, tDBPointer)
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
-
-func timestampDecodeType(_ DecodeContext, vr ValueReader, reflectType reflect.Type) (reflect.Value, error) {
-	if reflectType != tTimestamp {
-		return emptyValue, ValueDecoderError{
-			Name:     "TimestampDecodeValue",
-			Types:    []reflect.Type{tTimestamp},
-			Received: reflect.Zero(reflectType),
-		}
-	}
-
-	var t, incr uint32
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeTimestamp:
-		t, incr, err = vr.ReadTimestamp()
-	case TypeNull:
-		err = vr.ReadNull()
-	case TypeUndefined:
-		err = vr.ReadUndefined()
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a Timestamp", vrType)
-	}
-	if err != nil {
-		return emptyValue, err
-	}
-
-	return reflect.ValueOf(Timestamp{T: t, I: incr}), nil
-}
-
-// timestampDecodeValue is the ValueDecoderFunc for Timestamp.
-func timestampDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tTimestamp {
-		return ValueDecoderError{Name: "TimestampDecodeValue", Types: []reflect.Type{tTimestamp}, Received: val}
-	}
-
-	elem, err := timestampDecodeType(dc, vr, tTimestamp)
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
-
-func minKeyDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tMinKey {
-		return emptyValue, ValueDecoderError{
-			Name:     "MinKeyDecodeValue",
-			Types:    []reflect.Type{tMinKey},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeMinKey:
-		err = vr.ReadMinKey()
-	case TypeNull:
-		err = vr.ReadNull()
-	case TypeUndefined:
-		err = vr.ReadUndefined()
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a MinKey", vr.Type())
-	}
-	if err != nil {
-		return emptyValue, err
-	}
-
-	return reflect.ValueOf(MinKey{}), nil
-}
-
-// minKeyDecodeValue is the ValueDecoderFunc for MinKey.
-func minKeyDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tMinKey {
-		return ValueDecoderError{Name: "MinKeyDecodeValue", Types: []reflect.Type{tMinKey}, Received: val}
-	}
-
-	elem, err := minKeyDecodeType(dc, vr, tMinKey)
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
-
-func maxKeyDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tMaxKey {
-		return emptyValue, ValueDecoderError{
-			Name:     "MaxKeyDecodeValue",
-			Types:    []reflect.Type{tMaxKey},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeMaxKey:
-		err = vr.ReadMaxKey()
-	case TypeNull:
-		err = vr.ReadNull()
-	case TypeUndefined:
-		err = vr.ReadUndefined()
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a MaxKey", vr.Type())
-	}
-	if err != nil {
-		return emptyValue, err
-	}
-
-	return reflect.ValueOf(MaxKey{}), nil
-}
-
-// maxKeyDecodeValue is the ValueDecoderFunc for MaxKey.
-func maxKeyDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tMaxKey {
-		return ValueDecoderError{Name: "MaxKeyDecodeValue", Types: []reflect.Type{tMaxKey}, Received: val}
-	}
-
-	elem, err := maxKeyDecodeType(dc, vr, tMaxKey)
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
-
-func decimal128DecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tDecimal {
-		return emptyValue, ValueDecoderError{
-			Name:     "Decimal128DecodeValue",
-			Types:    []reflect.Type{tDecimal},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	var d128 Decimal128
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeDecimal128:
-		d128, err = vr.ReadDecimal128()
-	case TypeNull:
-		err = vr.ReadNull()
-	case TypeUndefined:
-		err = vr.ReadUndefined()
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a Decimal128", vr.Type())
-	}
-	if err != nil {
-		return emptyValue, err
-	}
-
-	return reflect.ValueOf(d128), nil
-}
-
-// decimal128DecodeValue is the ValueDecoderFunc for Decimal128.
-func decimal128DecodeValue(dctx DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tDecimal {
-		return ValueDecoderError{Name: "Decimal128DecodeValue", Types: []reflect.Type{tDecimal}, Received: val}
-	}
-
-	elem, err := decimal128DecodeType(dctx, vr, tDecimal)
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
-
-func jsonNumberDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tJSONNumber {
-		return emptyValue, ValueDecoderError{
-			Name:     "JSONNumberDecodeValue",
-			Types:    []reflect.Type{tJSONNumber},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	var jsonNum json.Number
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeDouble:
-		f64, err := vr.ReadDouble()
-		if err != nil {
-			return emptyValue, err
-		}
-		jsonNum = json.Number(strconv.FormatFloat(f64, 'f', -1, 64))
-	case TypeInt32:
-		i32, err := vr.ReadInt32()
-		if err != nil {
-			return emptyValue, err
-		}
-		jsonNum = json.Number(strconv.FormatInt(int64(i32), 10))
-	case TypeInt64:
-		i64, err := vr.ReadInt64()
-		if err != nil {
-			return emptyValue, err
-		}
-		jsonNum = json.Number(strconv.FormatInt(i64, 10))
-	case TypeNull:
-		err = vr.ReadNull()
-	case TypeUndefined:
-		err = vr.ReadUndefined()
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a json.Number", vrType)
-	}
-	if err != nil {
-		return emptyValue, err
-	}
-
-	return reflect.ValueOf(jsonNum), nil
-}
-
-// jsonNumberDecodeValue is the ValueDecoderFunc for json.Number.
-func jsonNumberDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tJSONNumber {
-		return ValueDecoderError{Name: "JSONNumberDecodeValue", Types: []reflect.Type{tJSONNumber}, Received: val}
-	}
-
-	elem, err := jsonNumberDecodeType(dc, vr, tJSONNumber)
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
-
-func urlDecodeType(_ DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tURL {
-		return emptyValue, ValueDecoderError{
-			Name:     "URLDecodeValue",
-			Types:    []reflect.Type{tURL},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	urlPtr := &url.URL{}
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeString:
-		var str string // Declare str here to avoid shadowing err during the ReadString call.
-		str, err = vr.ReadString()
-		if err != nil {
-			return emptyValue, err
-		}
-
-		urlPtr, err = url.Parse(str)
-	case TypeNull:
-		err = vr.ReadNull()
-	case TypeUndefined:
-		err = vr.ReadUndefined()
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a *url.URL", vrType)
-	}
-	if err != nil {
-		return emptyValue, err
-	}
-
-	return reflect.ValueOf(urlPtr).Elem(), nil
-}
-
-// urlDecodeValue is the ValueDecoderFunc for url.URL.
-func urlDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tURL {
-		return ValueDecoderError{Name: "URLDecodeValue", Types: []reflect.Type{tURL}, Received: val}
-	}
-
-	elem, err := urlDecodeType(dc, vr, tURL)
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
-
-// arrayDecodeValue is the ValueDecoderFunc for array types.
-func arrayDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.IsValid() || val.Kind() != reflect.Array {
-		return ValueDecoderError{Name: "ArrayDecodeValue", Kinds: []reflect.Kind{reflect.Array}, Received: val}
-	}
-
-	switch vrType := vr.Type(); vrType {
-	case TypeArray:
-	case Type(0), TypeEmbeddedDocument:
-		if val.Type().Elem() != tE {
-			return fmt.Errorf("cannot decode document into %s", val.Type())
-		}
-	case TypeBinary:
-		if val.Type().Elem() != tByte {
-			return fmt.Errorf("ArrayDecodeValue can only be used to decode binary into a byte array, got %v", vrType)
-		}
-		data, subtype, err := vr.ReadBinary()
-		if err != nil {
-			return err
-		}
-		if subtype != TypeBinaryGeneric && subtype != TypeBinaryBinaryOld {
-			return fmt.Errorf("ArrayDecodeValue can only be used to decode subtype 0x00 or 0x02 for %s, got %v", TypeBinary, subtype)
-		}
-
-		if len(data) > val.Len() {
-			return fmt.Errorf("more elements returned in array than can fit inside %s", val.Type())
-		}
-
-		for idx, elem := range data {
-			val.Index(idx).Set(reflect.ValueOf(elem))
-		}
-		return nil
-	case TypeNull:
-		val.Set(reflect.Zero(val.Type()))
-		return vr.ReadNull()
-	case TypeUndefined:
-		val.Set(reflect.Zero(val.Type()))
-		return vr.ReadUndefined()
-	default:
-		return fmt.Errorf("cannot decode %v into an array", vrType)
-	}
-
-	var elemsFunc func(DecodeContext, ValueReader, reflect.Value) ([]reflect.Value, error)
-	switch val.Type().Elem() {
-	case tE:
-		elemsFunc = decodeD
-	default:
-		elemsFunc = decodeDefault
-	}
-
-	elems, err := elemsFunc(dc, vr, val)
-	if err != nil {
-		return err
-	}
-
-	if len(elems) > val.Len() {
-		return fmt.Errorf("more elements returned in array than can fit inside %s, got %v elements", val.Type(), len(elems))
-	}
-
-	for idx, elem := range elems {
-		val.Index(idx).Set(elem)
-	}
-
-	return nil
-}
-
-// valueUnmarshalerDecodeValue is the ValueDecoderFunc for ValueUnmarshaler implementations.
-func valueUnmarshalerDecodeValue(_ DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.IsValid() || (!val.Type().Implements(tValueUnmarshaler) && !reflect.PtrTo(val.Type()).Implements(tValueUnmarshaler)) {
-		return ValueDecoderError{Name: "ValueUnmarshalerDecodeValue", Types: []reflect.Type{tValueUnmarshaler}, Received: val}
-	}
-
-	// If BSON value is null and the go value is a pointer, then don't call
-	// UnmarshalBSONValue. Even if the Go pointer is already initialized (i.e.,
-	// non-nil), encountering null in BSON will result in the pointer being
-	// directly set to nil here. Since the pointer is being replaced with nil,
-	// there is no opportunity (or reason) for the custom UnmarshalBSONValue logic
-	// to be called.
-	if vr.Type() == TypeNull && val.Kind() == reflect.Ptr {
-		val.Set(reflect.Zero(val.Type()))
-
-		return vr.ReadNull()
-	}
-
-	if val.Kind() == reflect.Ptr && val.IsNil() {
-		if !val.CanSet() {
-			return ValueDecoderError{Name: "ValueUnmarshalerDecodeValue", Types: []reflect.Type{tValueUnmarshaler}, Received: val}
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	if !val.Type().Implements(tValueUnmarshaler) {
-		if !val.CanAddr() {
-			return ValueDecoderError{Name: "ValueUnmarshalerDecodeValue", Types: []reflect.Type{tValueUnmarshaler}, Received: val}
-		}
-		val = val.Addr() // If the type doesn't implement the interface, a pointer to it must.
-	}
-
-	t, src, err := copyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	m, ok := val.Interface().(ValueUnmarshaler)
-	if !ok {
-		// NB: this error should be unreachable due to the above checks
-		return ValueDecoderError{Name: "ValueUnmarshalerDecodeValue", Types: []reflect.Type{tValueUnmarshaler}, Received: val}
-	}
-	return m.UnmarshalBSONValue(byte(t), src)
-}
-
-// unmarshalerDecodeValue is the ValueDecoderFunc for Unmarshaler implementations.
-func unmarshalerDecodeValue(_ DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.IsValid() || (!val.Type().Implements(tUnmarshaler) && !reflect.PtrTo(val.Type()).Implements(tUnmarshaler)) {
-		return ValueDecoderError{Name: "UnmarshalerDecodeValue", Types: []reflect.Type{tUnmarshaler}, Received: val}
-	}
-
-	if val.Kind() == reflect.Ptr && val.IsNil() {
-		if !val.CanSet() {
-			return ValueDecoderError{Name: "UnmarshalerDecodeValue", Types: []reflect.Type{tUnmarshaler}, Received: val}
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	_, src, err := copyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	// If the target Go value is a pointer and the BSON field value is empty, set the value to the
-	// zero value of the pointer (nil) and don't call UnmarshalBSON. UnmarshalBSON has no way to
-	// change the pointer value from within the function (only the value at the pointer address),
-	// so it can't set the pointer to "nil" itself. Since the most common Go value for an empty BSON
-	// field value is "nil", we set "nil" here and don't call UnmarshalBSON. This behavior matches
-	// the behavior of the Go "encoding/json" unmarshaler when the target Go value is a pointer and
-	// the JSON field value is "null".
-	if val.Kind() == reflect.Ptr && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	if !val.Type().Implements(tUnmarshaler) {
-		if !val.CanAddr() {
-			return ValueDecoderError{Name: "UnmarshalerDecodeValue", Types: []reflect.Type{tUnmarshaler}, Received: val}
-		}
-		val = val.Addr() // If the type doesn't implement the interface, a pointer to it must.
-	}
-
-	m, ok := val.Interface().(Unmarshaler)
-	if !ok {
-		// NB: this error should be unreachable due to the above checks
-		return ValueDecoderError{Name: "UnmarshalerDecodeValue", Types: []reflect.Type{tUnmarshaler}, Received: val}
-	}
-	return m.UnmarshalBSON(src)
-}
-
-// coreDocumentDecodeValue is the ValueDecoderFunc for bsoncore.Document.
-func coreDocumentDecodeValue(_ DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tCoreDocument {
-		return ValueDecoderError{Name: "CoreDocumentDecodeValue", Types: []reflect.Type{tCoreDocument}, Received: val}
-	}
-
-	if val.IsNil() {
-		val.Set(reflect.MakeSlice(val.Type(), 0, 0))
-	}
-
-	val.SetLen(0)
-
-	cdoc, err := appendDocumentBytes(val.Interface().(bsoncore.Document), vr)
-	val.Set(reflect.ValueOf(cdoc))
-	return err
-}
-
-func decodeDefault(dc DecodeContext, vr ValueReader, val reflect.Value) ([]reflect.Value, error) {
-	elems := make([]reflect.Value, 0)
-
-	ar, err := vr.ReadArray()
-	if err != nil {
-		return nil, err
-	}
-
-	eType := val.Type().Elem()
-
-	isInterfaceSlice := eType.Kind() == reflect.Interface && val.Len() > 0
-
-	// If this is not an interface slice with pre-populated elements, we can look up
-	// the decoder for eType once.
-	var vDecoder ValueDecoder
-	if !isInterfaceSlice {
-		vDecoder, err = dc.LookupDecoder(eType)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	idx := 0
-	for {
-		vr, err := ar.ReadValue()
-		if errors.Is(err, ErrEOA) {
-			break
-		}
-		if err != nil {
-			return nil, err
-		}
-
-		var elem reflect.Value
-		if isInterfaceSlice && idx < val.Len() {
-			// Decode into an existing interface{} slot.
-
-			elem = val.Index(idx).Elem()
-			switch {
-			case elem.Kind() != reflect.Ptr || elem.IsNil():
-				valueDecoder, err := dc.LookupDecoder(elem.Type())
-				if err != nil {
-					return nil, err
-				}
-
-				// If an element is allocated and unsettable, it must be overwritten.
-				if !elem.CanSet() {
-					elem = reflect.New(elem.Type()).Elem()
-				}
-
-				err = valueDecoder.DecodeValue(dc, vr, elem)
-				if err != nil {
-					return nil, newDecodeError(strconv.Itoa(idx), err)
-				}
-			case vr.Type() == TypeNull:
-				if err = vr.ReadNull(); err != nil {
-					return nil, err
-				}
-				elem = reflect.Zero(val.Index(idx).Type())
-			default:
-				e := elem.Elem()
-				valueDecoder, err := dc.LookupDecoder(e.Type())
-				if err != nil {
-					return nil, err
-				}
-				err = valueDecoder.DecodeValue(dc, vr, e)
-				if err != nil {
-					return nil, newDecodeError(strconv.Itoa(idx), err)
-				}
-			}
-		} else {
-			// For non-interface slices, or if we've exhausted the pre-populated
-			// slots, we create a fresh value.
-
-			if vDecoder == nil {
-				vDecoder, err = dc.LookupDecoder(eType)
-				if err != nil {
-					return nil, err
-				}
-			}
-			elem, err = decodeTypeOrValueWithInfo(vDecoder, dc, vr, eType)
-			if err != nil {
-				return nil, newDecodeError(strconv.Itoa(idx), err)
-			}
-		}
-
-		elems = append(elems, elem)
-		idx++
-	}
-
-	return elems, nil
-}
-
-func codeWithScopeDecodeType(dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tCodeWithScope {
-		return emptyValue, ValueDecoderError{
-			Name:     "CodeWithScopeDecodeValue",
-			Types:    []reflect.Type{tCodeWithScope},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	var cws CodeWithScope
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeCodeWithScope:
-		code, dr, err := vr.ReadCodeWithScope()
-		if err != nil {
-			return emptyValue, err
-		}
-
-		scope := reflect.New(tD).Elem()
-		elems, err := decodeElemsFromDocumentReader(dc, dr)
-		if err != nil {
-			return emptyValue, err
-		}
-
-		scope.Set(reflect.MakeSlice(tD, 0, len(elems)))
-		scope.Set(reflect.Append(scope, elems...))
-
-		cws = CodeWithScope{
-			Code:  JavaScript(code),
-			Scope: scope.Interface().(D),
-		}
-	case TypeNull:
-		err = vr.ReadNull()
-	case TypeUndefined:
-		err = vr.ReadUndefined()
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a CodeWithScope", vrType)
-	}
-	if err != nil {
-		return emptyValue, err
-	}
-
-	return reflect.ValueOf(cws), nil
-}
-
-// codeWithScopeDecodeValue is the ValueDecoderFunc for CodeWithScope.
-func codeWithScopeDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tCodeWithScope {
-		return ValueDecoderError{Name: "CodeWithScopeDecodeValue", Types: []reflect.Type{tCodeWithScope}, Received: val}
-	}
-
-	elem, err := codeWithScopeDecodeType(dc, vr, tCodeWithScope)
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
-
-func decodeD(dc DecodeContext, vr ValueReader, _ reflect.Value) ([]reflect.Value, error) {
-	switch vr.Type() {
-	case Type(0), TypeEmbeddedDocument:
-	default:
-		return nil, fmt.Errorf("cannot decode %v into a D", vr.Type())
-	}
-
-	dr, err := vr.ReadDocument()
-	if err != nil {
-		return nil, err
-	}
-
-	return decodeElemsFromDocumentReader(dc, dr)
-}
-
-func decodeElemsFromDocumentReader(dc DecodeContext, dr DocumentReader) ([]reflect.Value, error) {
-	decoder, err := dc.LookupDecoder(tEmpty)
-	if err != nil {
-		return nil, err
-	}
-
-	elems := make([]reflect.Value, 0)
-	for {
-		key, vr, err := dr.ReadElement()
-		if errors.Is(err, ErrEOD) {
-			break
-		}
-		if err != nil {
-			return nil, err
-		}
-
-		val := reflect.New(tEmpty).Elem()
-		err = decoder.DecodeValue(dc, vr, val)
-		if err != nil {
-			return nil, newDecodeError(key, err)
-		}
-
-		elems = append(elems, reflect.ValueOf(E{Key: key, Value: val.Interface()}))
-	}
-
-	return elems, nil
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/default_value_encoders.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/default_value_encoders.go
deleted file mode 100644
index bd5a20f2..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/default_value_encoders.go
+++ /dev/null
@@ -1,517 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"encoding/json"
-	"errors"
-	"math"
-	"net/url"
-	"reflect"
-	"sync"
-
-	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
-)
-
-var bvwPool = sync.Pool{
-	New: func() interface{} {
-		return new(valueWriter)
-	},
-}
-
-var errInvalidValue = errors.New("cannot encode invalid element")
-
-var sliceWriterPool = sync.Pool{
-	New: func() interface{} {
-		sw := make(sliceWriter, 0)
-		return &sw
-	},
-}
-
-func encodeElement(ec EncodeContext, dw DocumentWriter, e E) error {
-	vw, err := dw.WriteDocumentElement(e.Key)
-	if err != nil {
-		return err
-	}
-
-	if e.Value == nil {
-		return vw.WriteNull()
-	}
-	encoder, err := ec.LookupEncoder(reflect.TypeOf(e.Value))
-	if err != nil {
-		return err
-	}
-
-	err = encoder.EncodeValue(ec, vw, reflect.ValueOf(e.Value))
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// registerDefaultEncoders will register the encoder methods attached to DefaultValueEncoders with
-// the provided RegistryBuilder.
-func registerDefaultEncoders(reg *Registry) {
-	mapEncoder := &mapCodec{}
-	uintCodec := &uintCodec{}
-
-	reg.RegisterTypeEncoder(tByteSlice, &byteSliceCodec{})
-	reg.RegisterTypeEncoder(tTime, &timeCodec{})
-	reg.RegisterTypeEncoder(tEmpty, &emptyInterfaceCodec{})
-	reg.RegisterTypeEncoder(tCoreArray, &arrayCodec{})
-	reg.RegisterTypeEncoder(tOID, ValueEncoderFunc(objectIDEncodeValue))
-	reg.RegisterTypeEncoder(tDecimal, ValueEncoderFunc(decimal128EncodeValue))
-	reg.RegisterTypeEncoder(tJSONNumber, ValueEncoderFunc(jsonNumberEncodeValue))
-	reg.RegisterTypeEncoder(tURL, ValueEncoderFunc(urlEncodeValue))
-	reg.RegisterTypeEncoder(tJavaScript, ValueEncoderFunc(javaScriptEncodeValue))
-	reg.RegisterTypeEncoder(tSymbol, ValueEncoderFunc(symbolEncodeValue))
-	reg.RegisterTypeEncoder(tBinary, ValueEncoderFunc(binaryEncodeValue))
-	reg.RegisterTypeEncoder(tVector, ValueEncoderFunc(vectorEncodeValue))
-	reg.RegisterTypeEncoder(tUndefined, ValueEncoderFunc(undefinedEncodeValue))
-	reg.RegisterTypeEncoder(tDateTime, ValueEncoderFunc(dateTimeEncodeValue))
-	reg.RegisterTypeEncoder(tNull, ValueEncoderFunc(nullEncodeValue))
-	reg.RegisterTypeEncoder(tRegex, ValueEncoderFunc(regexEncodeValue))
-	reg.RegisterTypeEncoder(tDBPointer, ValueEncoderFunc(dbPointerEncodeValue))
-	reg.RegisterTypeEncoder(tTimestamp, ValueEncoderFunc(timestampEncodeValue))
-	reg.RegisterTypeEncoder(tMinKey, ValueEncoderFunc(minKeyEncodeValue))
-	reg.RegisterTypeEncoder(tMaxKey, ValueEncoderFunc(maxKeyEncodeValue))
-	reg.RegisterTypeEncoder(tCoreDocument, ValueEncoderFunc(coreDocumentEncodeValue))
-	reg.RegisterTypeEncoder(tCodeWithScope, ValueEncoderFunc(codeWithScopeEncodeValue))
-	reg.RegisterKindEncoder(reflect.Bool, ValueEncoderFunc(booleanEncodeValue))
-	reg.RegisterKindEncoder(reflect.Int, ValueEncoderFunc(intEncodeValue))
-	reg.RegisterKindEncoder(reflect.Int8, ValueEncoderFunc(intEncodeValue))
-	reg.RegisterKindEncoder(reflect.Int16, ValueEncoderFunc(intEncodeValue))
-	reg.RegisterKindEncoder(reflect.Int32, ValueEncoderFunc(intEncodeValue))
-	reg.RegisterKindEncoder(reflect.Int64, ValueEncoderFunc(intEncodeValue))
-	reg.RegisterKindEncoder(reflect.Uint, uintCodec)
-	reg.RegisterKindEncoder(reflect.Uint8, uintCodec)
-	reg.RegisterKindEncoder(reflect.Uint16, uintCodec)
-	reg.RegisterKindEncoder(reflect.Uint32, uintCodec)
-	reg.RegisterKindEncoder(reflect.Uint64, uintCodec)
-	reg.RegisterKindEncoder(reflect.Float32, ValueEncoderFunc(floatEncodeValue))
-	reg.RegisterKindEncoder(reflect.Float64, ValueEncoderFunc(floatEncodeValue))
-	reg.RegisterKindEncoder(reflect.Array, ValueEncoderFunc(arrayEncodeValue))
-	reg.RegisterKindEncoder(reflect.Map, mapEncoder)
-	reg.RegisterKindEncoder(reflect.Slice, &sliceCodec{})
-	reg.RegisterKindEncoder(reflect.String, &stringCodec{})
-	reg.RegisterKindEncoder(reflect.Struct, newStructCodec(mapEncoder))
-	reg.RegisterKindEncoder(reflect.Ptr, &pointerCodec{})
-	reg.RegisterInterfaceEncoder(tValueMarshaler, ValueEncoderFunc(valueMarshalerEncodeValue))
-	reg.RegisterInterfaceEncoder(tMarshaler, ValueEncoderFunc(marshalerEncodeValue))
-}
-
-// booleanEncodeValue is the ValueEncoderFunc for bool types.
-func booleanEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Kind() != reflect.Bool {
-		return ValueEncoderError{Name: "BooleanEncodeValue", Kinds: []reflect.Kind{reflect.Bool}, Received: val}
-	}
-	return vw.WriteBoolean(val.Bool())
-}
-
-func fitsIn32Bits(i int64) bool {
-	return math.MinInt32 <= i && i <= math.MaxInt32
-}
-
-// intEncodeValue is the ValueEncoderFunc for int types.
-func intEncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
-	switch val.Kind() {
-	case reflect.Int8, reflect.Int16, reflect.Int32:
-		return vw.WriteInt32(int32(val.Int()))
-	case reflect.Int:
-		i64 := val.Int()
-		if fitsIn32Bits(i64) {
-			return vw.WriteInt32(int32(i64))
-		}
-		return vw.WriteInt64(i64)
-	case reflect.Int64:
-		i64 := val.Int()
-		if ec.minSize && fitsIn32Bits(i64) {
-			return vw.WriteInt32(int32(i64))
-		}
-		return vw.WriteInt64(i64)
-	}
-
-	return ValueEncoderError{
-		Name:     "IntEncodeValue",
-		Kinds:    []reflect.Kind{reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int},
-		Received: val,
-	}
-}
-
-// floatEncodeValue is the ValueEncoderFunc for float types.
-func floatEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	switch val.Kind() {
-	case reflect.Float32, reflect.Float64:
-		return vw.WriteDouble(val.Float())
-	}
-
-	return ValueEncoderError{Name: "FloatEncodeValue", Kinds: []reflect.Kind{reflect.Float32, reflect.Float64}, Received: val}
-}
-
-// objectIDEncodeValue is the ValueEncoderFunc for ObjectID.
-func objectIDEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tOID {
-		return ValueEncoderError{Name: "ObjectIDEncodeValue", Types: []reflect.Type{tOID}, Received: val}
-	}
-	return vw.WriteObjectID(val.Interface().(ObjectID))
-}
-
-// decimal128EncodeValue is the ValueEncoderFunc for Decimal128.
-func decimal128EncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tDecimal {
-		return ValueEncoderError{Name: "Decimal128EncodeValue", Types: []reflect.Type{tDecimal}, Received: val}
-	}
-	return vw.WriteDecimal128(val.Interface().(Decimal128))
-}
-
-// jsonNumberEncodeValue is the ValueEncoderFunc for json.Number.
-func jsonNumberEncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tJSONNumber {
-		return ValueEncoderError{Name: "JSONNumberEncodeValue", Types: []reflect.Type{tJSONNumber}, Received: val}
-	}
-	jsnum := val.Interface().(json.Number)
-
-	// Attempt int first, then float64
-	if i64, err := jsnum.Int64(); err == nil {
-		return intEncodeValue(ec, vw, reflect.ValueOf(i64))
-	}
-
-	f64, err := jsnum.Float64()
-	if err != nil {
-		return err
-	}
-
-	return floatEncodeValue(ec, vw, reflect.ValueOf(f64))
-}
-
-// urlEncodeValue is the ValueEncoderFunc for url.URL.
-func urlEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tURL {
-		return ValueEncoderError{Name: "URLEncodeValue", Types: []reflect.Type{tURL}, Received: val}
-	}
-	u := val.Interface().(url.URL)
-	return vw.WriteString(u.String())
-}
-
-// arrayEncodeValue is the ValueEncoderFunc for array types.
-func arrayEncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Kind() != reflect.Array {
-		return ValueEncoderError{Name: "ArrayEncodeValue", Kinds: []reflect.Kind{reflect.Array}, Received: val}
-	}
-
-	// If we have a []E we want to treat it as a document instead of as an array.
-	if val.Type().Elem() == tE {
-		dw, err := vw.WriteDocument()
-		if err != nil {
-			return err
-		}
-
-		for idx := 0; idx < val.Len(); idx++ {
-			e := val.Index(idx).Interface().(E)
-			err = encodeElement(ec, dw, e)
-			if err != nil {
-				return err
-			}
-		}
-
-		return dw.WriteDocumentEnd()
-	}
-
-	// If we have a []byte we want to treat it as a binary instead of as an array.
-	if val.Type().Elem() == tByte {
-		var byteSlice []byte
-		for idx := 0; idx < val.Len(); idx++ {
-			byteSlice = append(byteSlice, val.Index(idx).Interface().(byte))
-		}
-		return vw.WriteBinary(byteSlice)
-	}
-
-	aw, err := vw.WriteArray()
-	if err != nil {
-		return err
-	}
-
-	elemType := val.Type().Elem()
-	encoder, err := ec.LookupEncoder(elemType)
-	if err != nil && elemType.Kind() != reflect.Interface {
-		return err
-	}
-
-	for idx := 0; idx < val.Len(); idx++ {
-		currEncoder, currVal, lookupErr := lookupElementEncoder(ec, encoder, val.Index(idx))
-		if lookupErr != nil && !errors.Is(lookupErr, errInvalidValue) {
-			return lookupErr
-		}
-
-		vw, err := aw.WriteArrayElement()
-		if err != nil {
-			return err
-		}
-
-		if errors.Is(lookupErr, errInvalidValue) {
-			err = vw.WriteNull()
-			if err != nil {
-				return err
-			}
-			continue
-		}
-
-		err = currEncoder.EncodeValue(ec, vw, currVal)
-		if err != nil {
-			return err
-		}
-	}
-	return aw.WriteArrayEnd()
-}
-
-func lookupElementEncoder(ec EncodeContext, origEncoder ValueEncoder, currVal reflect.Value) (ValueEncoder, reflect.Value, error) {
-	if origEncoder != nil || (currVal.Kind() != reflect.Interface) {
-		return origEncoder, currVal, nil
-	}
-	currVal = currVal.Elem()
-	if !currVal.IsValid() {
-		return nil, currVal, errInvalidValue
-	}
-	currEncoder, err := ec.LookupEncoder(currVal.Type())
-
-	return currEncoder, currVal, err
-}
-
-// valueMarshalerEncodeValue is the ValueEncoderFunc for ValueMarshaler implementations.
-func valueMarshalerEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	// Either val or a pointer to val must implement ValueMarshaler
-	switch {
-	case !val.IsValid():
-		return ValueEncoderError{Name: "ValueMarshalerEncodeValue", Types: []reflect.Type{tValueMarshaler}, Received: val}
-	case val.Type().Implements(tValueMarshaler):
-		// If ValueMarshaler is implemented on a concrete type, make sure that val isn't a nil pointer
-		if isImplementationNil(val, tValueMarshaler) {
-			return vw.WriteNull()
-		}
-	case reflect.PtrTo(val.Type()).Implements(tValueMarshaler) && val.CanAddr():
-		val = val.Addr()
-	default:
-		return ValueEncoderError{Name: "ValueMarshalerEncodeValue", Types: []reflect.Type{tValueMarshaler}, Received: val}
-	}
-
-	m, ok := val.Interface().(ValueMarshaler)
-	if !ok {
-		return vw.WriteNull()
-	}
-	t, data, err := m.MarshalBSONValue()
-	if err != nil {
-		return err
-	}
-	return copyValueFromBytes(vw, Type(t), data)
-}
-
-// marshalerEncodeValue is the ValueEncoderFunc for Marshaler implementations.
-func marshalerEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	// Either val or a pointer to val must implement Marshaler
-	switch {
-	case !val.IsValid():
-		return ValueEncoderError{Name: "MarshalerEncodeValue", Types: []reflect.Type{tMarshaler}, Received: val}
-	case val.Type().Implements(tMarshaler):
-		// If Marshaler is implemented on a concrete type, make sure that val isn't a nil pointer
-		if isImplementationNil(val, tMarshaler) {
-			return vw.WriteNull()
-		}
-	case reflect.PtrTo(val.Type()).Implements(tMarshaler) && val.CanAddr():
-		val = val.Addr()
-	default:
-		return ValueEncoderError{Name: "MarshalerEncodeValue", Types: []reflect.Type{tMarshaler}, Received: val}
-	}
-
-	m, ok := val.Interface().(Marshaler)
-	if !ok {
-		return vw.WriteNull()
-	}
-	data, err := m.MarshalBSON()
-	if err != nil {
-		return err
-	}
-	return copyValueFromBytes(vw, TypeEmbeddedDocument, data)
-}
-
-// javaScriptEncodeValue is the ValueEncoderFunc for the JavaScript type.
-func javaScriptEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tJavaScript {
-		return ValueEncoderError{Name: "JavaScriptEncodeValue", Types: []reflect.Type{tJavaScript}, Received: val}
-	}
-
-	return vw.WriteJavascript(val.String())
-}
-
-// symbolEncodeValue is the ValueEncoderFunc for the Symbol type.
-func symbolEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tSymbol {
-		return ValueEncoderError{Name: "SymbolEncodeValue", Types: []reflect.Type{tSymbol}, Received: val}
-	}
-
-	return vw.WriteSymbol(val.String())
-}
-
-// binaryEncodeValue is the ValueEncoderFunc for Binary.
-func binaryEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tBinary {
-		return ValueEncoderError{Name: "BinaryEncodeValue", Types: []reflect.Type{tBinary}, Received: val}
-	}
-	b := val.Interface().(Binary)
-
-	return vw.WriteBinaryWithSubtype(b.Data, b.Subtype)
-}
-
-// vectorEncodeValue is the ValueEncoderFunc for Vector.
-func vectorEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	t := val.Type()
-	if !val.IsValid() || t != tVector {
-		return ValueEncoderError{Name: "VectorEncodeValue",
-			Types:    []reflect.Type{tVector},
-			Received: val,
-		}
-	}
-	v := val.Interface().(Vector)
-	b := v.Binary()
-	return vw.WriteBinaryWithSubtype(b.Data, b.Subtype)
-}
-
-// undefinedEncodeValue is the ValueEncoderFunc for Undefined.
-func undefinedEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tUndefined {
-		return ValueEncoderError{Name: "UndefinedEncodeValue", Types: []reflect.Type{tUndefined}, Received: val}
-	}
-
-	return vw.WriteUndefined()
-}
-
-// dateTimeEncodeValue is the ValueEncoderFunc for DateTime.
-func dateTimeEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tDateTime {
-		return ValueEncoderError{Name: "DateTimeEncodeValue", Types: []reflect.Type{tDateTime}, Received: val}
-	}
-
-	return vw.WriteDateTime(val.Int())
-}
-
-// nullEncodeValue is the ValueEncoderFunc for Null.
-func nullEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tNull {
-		return ValueEncoderError{Name: "NullEncodeValue", Types: []reflect.Type{tNull}, Received: val}
-	}
-
-	return vw.WriteNull()
-}
-
-// regexEncodeValue is the ValueEncoderFunc for Regex.
-func regexEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tRegex {
-		return ValueEncoderError{Name: "RegexEncodeValue", Types: []reflect.Type{tRegex}, Received: val}
-	}
-
-	regex := val.Interface().(Regex)
-
-	return vw.WriteRegex(regex.Pattern, regex.Options)
-}
-
-// dbPointerEncodeValue is the ValueEncoderFunc for DBPointer.
-func dbPointerEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tDBPointer {
-		return ValueEncoderError{Name: "DBPointerEncodeValue", Types: []reflect.Type{tDBPointer}, Received: val}
-	}
-
-	dbp := val.Interface().(DBPointer)
-
-	return vw.WriteDBPointer(dbp.DB, dbp.Pointer)
-}
-
-// timestampEncodeValue is the ValueEncoderFunc for Timestamp.
-func timestampEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tTimestamp {
-		return ValueEncoderError{Name: "TimestampEncodeValue", Types: []reflect.Type{tTimestamp}, Received: val}
-	}
-
-	ts := val.Interface().(Timestamp)
-
-	return vw.WriteTimestamp(ts.T, ts.I)
-}
-
-// minKeyEncodeValue is the ValueEncoderFunc for MinKey.
-func minKeyEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tMinKey {
-		return ValueEncoderError{Name: "MinKeyEncodeValue", Types: []reflect.Type{tMinKey}, Received: val}
-	}
-
-	return vw.WriteMinKey()
-}
-
-// maxKeyEncodeValue is the ValueEncoderFunc for MaxKey.
-func maxKeyEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tMaxKey {
-		return ValueEncoderError{Name: "MaxKeyEncodeValue", Types: []reflect.Type{tMaxKey}, Received: val}
-	}
-
-	return vw.WriteMaxKey()
-}
-
-// coreDocumentEncodeValue is the ValueEncoderFunc for bsoncore.Document.
-func coreDocumentEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tCoreDocument {
-		return ValueEncoderError{Name: "CoreDocumentEncodeValue", Types: []reflect.Type{tCoreDocument}, Received: val}
-	}
-
-	cdoc := val.Interface().(bsoncore.Document)
-
-	return copyDocumentFromBytes(vw, cdoc)
-}
-
-// codeWithScopeEncodeValue is the ValueEncoderFunc for CodeWithScope.
-func codeWithScopeEncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tCodeWithScope {
-		return ValueEncoderError{Name: "CodeWithScopeEncodeValue", Types: []reflect.Type{tCodeWithScope}, Received: val}
-	}
-
-	cws := val.Interface().(CodeWithScope)
-
-	dw, err := vw.WriteCodeWithScope(string(cws.Code))
-	if err != nil {
-		return err
-	}
-
-	sw := sliceWriterPool.Get().(*sliceWriter)
-	defer sliceWriterPool.Put(sw)
-	*sw = (*sw)[:0]
-
-	scopeVW := bvwPool.Get().(*valueWriter)
-	scopeVW.reset(scopeVW.buf[:0])
-	scopeVW.w = sw
-	defer bvwPool.Put(scopeVW)
-
-	encoder, err := ec.LookupEncoder(reflect.TypeOf(cws.Scope))
-	if err != nil {
-		return err
-	}
-
-	err = encoder.EncodeValue(ec, scopeVW, reflect.ValueOf(cws.Scope))
-	if err != nil {
-		return err
-	}
-
-	err = copyBytesToDocumentWriter(dw, *sw)
-	if err != nil {
-		return err
-	}
-	return dw.WriteDocumentEnd()
-}
-
-// isImplementationNil returns if val is a nil pointer and inter is implemented on a concrete type
-func isImplementationNil(val reflect.Value, inter reflect.Type) bool {
-	vt := val.Type()
-	for vt.Kind() == reflect.Ptr {
-		vt = vt.Elem()
-	}
-	return vt.Implements(inter) && val.Kind() == reflect.Ptr && val.IsNil()
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/doc.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/doc.go
deleted file mode 100644
index 81aceef2..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/doc.go
+++ /dev/null
@@ -1,155 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-// Package bson is a library for reading, writing, and manipulating BSON. BSON is a binary serialization format used to
-// store documents and make remote procedure calls in MongoDB. The BSON specification is located at https://bsonspec.org.
-// The BSON library handles marshaling and unmarshaling of values through a configurable codec system. For a description
-// of the codec system and examples of registering custom codecs, see the bsoncodec package. For additional information
-// and usage examples, check out the [Work with BSON] page in the Go Driver docs site.
-//
-// # Raw BSON
-//
-// The Raw family of types is used to validate and retrieve elements from a slice of bytes. This
-// type is most useful when you want do lookups on BSON bytes without unmarshaling it into another
-// type.
-//
-// Example:
-//
-//	var raw bson.Raw = ... // bytes from somewhere
-//	err := raw.Validate()
-//	if err != nil { return err }
-//	val := raw.Lookup("foo")
-//	i32, ok := val.Int32OK()
-//	// do something with i32...
-//
-// # Native Go Types
-//
-// The D and M types defined in this package can be used to build representations of BSON using native Go types. D is a
-// slice and M is a map. For more information about the use cases for these types, see the documentation on the type
-// definitions.
-//
-// Note that a D should not be constructed with duplicate key names, as that can cause undefined server behavior.
-//
-// Example:
-//
-//	bson.D{{"foo", "bar"}, {"hello", "world"}, {"pi", 3.14159}}
-//	bson.M{"foo": "bar", "hello": "world", "pi": 3.14159}
-//
-// When decoding BSON to a D or M, the following type mappings apply when unmarshaling:
-//
-//  1. BSON int32 unmarshals to an int32.
-//  2. BSON int64 unmarshals to an int64.
-//  3. BSON double unmarshals to a float64.
-//  4. BSON string unmarshals to a string.
-//  5. BSON boolean unmarshals to a bool.
-//  6. BSON embedded document unmarshals to the parent type (i.e. D for a D, M for an M).
-//  7. BSON array unmarshals to a bson.A.
-//  8. BSON ObjectId unmarshals to a bson.ObjectID.
-//  9. BSON datetime unmarshals to a bson.DateTime.
-//  10. BSON binary unmarshals to a bson.Binary.
-//  11. BSON regular expression unmarshals to a bson.Regex.
-//  12. BSON JavaScript unmarshals to a bson.JavaScript.
-//  13. BSON code with scope unmarshals to a bson.CodeWithScope.
-//  14. BSON timestamp unmarshals to an bson.Timestamp.
-//  15. BSON 128-bit decimal unmarshals to an bson.Decimal128.
-//  16. BSON min key unmarshals to an bson.MinKey.
-//  17. BSON max key unmarshals to an bson.MaxKey.
-//  18. BSON undefined unmarshals to a bson.Undefined.
-//  19. BSON null unmarshals to nil.
-//  20. BSON DBPointer unmarshals to a bson.DBPointer.
-//  21. BSON symbol unmarshals to a bson.Symbol.
-//
-// The above mappings also apply when marshaling a D or M to BSON. Some other useful marshaling mappings are:
-//
-//  1. time.Time marshals to a BSON datetime.
-//  2. int8, int16, and int32 marshal to a BSON int32.
-//  3. int marshals to a BSON int32 if the value is between math.MinInt32 and math.MaxInt32, inclusive, and a BSON int64
-//     otherwise.
-//  4. int64 marshals to BSON int64 (unless [Encoder.IntMinSize] is set).
-//  5. uint8 and uint16 marshal to a BSON int32.
-//  6. uint, uint32, and uint64 marshal to a BSON int64 (unless [Encoder.IntMinSize] is set).
-//  7. BSON null and undefined values will unmarshal into the zero value of a field (e.g. unmarshaling a BSON null or
-//     undefined value into a string will yield the empty string.).
-//
-// # Structs
-//
-// Structs can be marshaled/unmarshaled to/from BSON or Extended JSON. When transforming structs to/from BSON or Extended
-// JSON, the following rules apply:
-//
-//  1. Only exported fields in structs will be marshaled or unmarshaled.
-//
-//  2. When marshaling a struct, each field will be lowercased to generate the key for the corresponding BSON element.
-//     For example, a struct field named "Foo" will generate key "foo". This can be overridden via a struct tag (e.g.
-//     `bson:"fooField"` to generate key "fooField" instead).
-//
-//  3. An embedded struct field is marshaled as a subdocument. The key will be the lowercased name of the field's type.
-//
-//  4. A pointer field is marshaled as the underlying type if the pointer is non-nil. If the pointer is nil, it is
-//     marshaled as a BSON null value.
-//
-//  5. When unmarshaling, a field of type interface{} will follow the D/M type mappings listed above. BSON documents
-//     unmarshaled into an interface{} field will be unmarshaled as a D.
-//
-// The encoding of each struct field can be customized by the "bson" struct tag.
-//
-// This tag behavior is configurable, and different struct tag behavior can be configured by initializing a new
-// bsoncodec.StructCodec with the desired tag parser and registering that StructCodec onto the Registry. By default, JSON
-// tags are not honored, but that can be enabled by creating a StructCodec with JSONFallbackStructTagParser, like below:
-//
-// Example:
-//
-//	structcodec, _ := bsoncodec.NewStructCodec(bsoncodec.JSONFallbackStructTagParser)
-//
-// The bson tag gives the name of the field, possibly followed by a comma-separated list of options.
-// The name may be empty in order to specify options without overriding the default field name. The following options can
-// be used to configure behavior:
-//
-//  1. omitempty: If the "omitempty" struct tag is specified on a field, the field will not be marshaled if it is set to
-//     an "empty" value. Numbers, booleans, and strings are considered empty if their value is equal to the zero value for
-//     the type (i.e. 0 for numbers, false for booleans, and "" for strings). Slices, maps, and arrays are considered
-//     empty if they are of length zero. Interfaces and pointers are considered empty if their value is nil. By default,
-//     structs are only considered empty if the struct type implements [bsoncodec.Zeroer] and the IsZero
-//     method returns true. Struct types that do not implement [bsoncodec.Zeroer] are never considered empty and will be
-//     marshaled as embedded documents. NOTE: It is recommended that this tag be used for all slice and map fields.
-//
-//  2. minsize: If the minsize struct tag is specified on a field of type int64, uint, uint32, or uint64 and the value of
-//     the field can fit in a signed int32, the field will be serialized as a BSON int32 rather than a BSON int64. For
-//     other types, this tag is ignored.
-//
-//  3. truncate: If the truncate struct tag is specified on a field with a non-float numeric type, BSON doubles
-//     unmarshaled into that field will be truncated at the decimal point. For example, if 3.14 is unmarshaled into a
-//     field of type int, it will be unmarshaled as 3. If this tag is not specified, the decoder will throw an error if
-//     the value cannot be decoded without losing precision. For float64 or non-numeric types, this tag is ignored.
-//
-//  4. inline: If the inline struct tag is specified for a struct or map field, the field will be "flattened" when
-//     marshaling and "un-flattened" when unmarshaling. This means that all of the fields in that struct/map will be
-//     pulled up one level and will become top-level fields rather than being fields in a nested document. For example,
-//     if a map field named "Map" with value map[string]interface{}{"foo": "bar"} is inlined, the resulting document will
-//     be {"foo": "bar"} instead of {"map": {"foo": "bar"}}. There can only be one inlined map field in a struct. If
-//     there are duplicated fields in the resulting document when an inlined struct is marshaled, the inlined field will
-//     be overwritten. If there are duplicated fields in the resulting document when an inlined map is marshaled, an
-//     error will be returned. This tag can be used with fields that are pointers to structs. If an inlined pointer field
-//     is nil, it will not be marshaled. For fields that are not maps or structs, this tag is ignored.
-//
-// # Marshaling and Unmarshaling
-//
-// Manually marshaling and unmarshaling can be done with the Marshal and Unmarshal family of functions.
-//
-// bsoncodec code provides a system for encoding values to BSON representations and decoding
-// values from BSON representations. This package considers both binary BSON and ExtendedJSON as
-// BSON representations. The types in this package enable a flexible system for handling this
-// encoding and decoding.
-//
-// The codec system is composed of two parts:
-//
-// 1) [ValueEncoder] and [ValueDecoder] that handle encoding and decoding Go values to and from BSON
-// representations.
-//
-// 2) A [Registry] that holds these ValueEncoders and ValueDecoders and provides methods for
-// retrieving them.
-//
-// [Work with BSON]: https://www.mongodb.com/docs/drivers/go/current/fundamentals/bson/
-package bson
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/empty_interface_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/empty_interface_codec.go
deleted file mode 100644
index 80d44d8c..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/empty_interface_codec.go
+++ /dev/null
@@ -1,127 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"reflect"
-)
-
-// emptyInterfaceCodec is the Codec used for interface{} values.
-type emptyInterfaceCodec struct {
-	// decodeBinaryAsSlice causes DecodeValue to unmarshal BSON binary field values that are the
-	// "Generic" or "Old" BSON binary subtype as a Go byte slice instead of a Binary.
-	decodeBinaryAsSlice bool
-}
-
-// Assert that emptyInterfaceCodec satisfies the typeDecoder interface, which allows it
-// to be used by collection type decoders (e.g. map, slice, etc) to set individual values in a
-// collection.
-var _ typeDecoder = &emptyInterfaceCodec{}
-
-// EncodeValue is the ValueEncoderFunc for interface{}.
-func (eic *emptyInterfaceCodec) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tEmpty {
-		return ValueEncoderError{Name: "EmptyInterfaceEncodeValue", Types: []reflect.Type{tEmpty}, Received: val}
-	}
-
-	if val.IsNil() {
-		return vw.WriteNull()
-	}
-	encoder, err := ec.LookupEncoder(val.Elem().Type())
-	if err != nil {
-		return err
-	}
-
-	return encoder.EncodeValue(ec, vw, val.Elem())
-}
-
-func (eic *emptyInterfaceCodec) getEmptyInterfaceDecodeType(dc DecodeContext, valueType Type) (reflect.Type, error) {
-	isDocument := valueType == Type(0) || valueType == TypeEmbeddedDocument
-	if isDocument {
-		if dc.defaultDocumentType != nil {
-			// If the bsontype is an embedded document and the DocumentType is set on the DecodeContext, then return
-			// that type.
-			return dc.defaultDocumentType, nil
-		}
-	}
-
-	rtype, err := dc.LookupTypeMapEntry(valueType)
-	if err == nil {
-		return rtype, nil
-	}
-
-	if isDocument {
-		// For documents, fallback to looking up a type map entry for Type(0) or TypeEmbeddedDocument,
-		// depending on the original valueType.
-		var lookupType Type
-		switch valueType {
-		case Type(0):
-			lookupType = TypeEmbeddedDocument
-		case TypeEmbeddedDocument:
-			lookupType = Type(0)
-		}
-
-		rtype, err = dc.LookupTypeMapEntry(lookupType)
-		if err == nil {
-			return rtype, nil
-		}
-		// fallback to bson.D
-		return tD, nil
-	}
-
-	return nil, err
-}
-
-func (eic *emptyInterfaceCodec) decodeType(dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tEmpty {
-		return emptyValue, ValueDecoderError{Name: "EmptyInterfaceDecodeValue", Types: []reflect.Type{tEmpty}, Received: reflect.Zero(t)}
-	}
-
-	rtype, err := eic.getEmptyInterfaceDecodeType(dc, vr.Type())
-	if err != nil {
-		switch vr.Type() {
-		case TypeNull:
-			return reflect.Zero(t), vr.ReadNull()
-		default:
-			return emptyValue, err
-		}
-	}
-
-	decoder, err := dc.LookupDecoder(rtype)
-	if err != nil {
-		return emptyValue, err
-	}
-
-	elem, err := decodeTypeOrValueWithInfo(decoder, dc, vr, rtype)
-	if err != nil {
-		return emptyValue, err
-	}
-
-	if (eic.decodeBinaryAsSlice || dc.binaryAsSlice) && rtype == tBinary {
-		binElem := elem.Interface().(Binary)
-		if binElem.Subtype == TypeBinaryGeneric || binElem.Subtype == TypeBinaryBinaryOld {
-			elem = reflect.ValueOf(binElem.Data)
-		}
-	}
-
-	return elem, nil
-}
-
-// DecodeValue is the ValueDecoderFunc for interface{}.
-func (eic *emptyInterfaceCodec) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tEmpty {
-		return ValueDecoderError{Name: "EmptyInterfaceDecodeValue", Types: []reflect.Type{tEmpty}, Received: val}
-	}
-
-	elem, err := eic.decodeType(dc, vr, val.Type())
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/encoder.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/encoder.go
deleted file mode 100644
index 8299e94f..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/encoder.go
+++ /dev/null
@@ -1,130 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"reflect"
-	"sync"
-)
-
-// This pool is used to keep the allocations of Encoders down. This is only used for the Marshal*
-// methods and is not consumable from outside of this package. The Encoders retrieved from this pool
-// must have both Reset and SetRegistry called on them.
-var encPool = sync.Pool{
-	New: func() interface{} {
-		return new(Encoder)
-	},
-}
-
-// An Encoder writes a serialization format to an output stream. It writes to a ValueWriter
-// as the destination of BSON data.
-type Encoder struct {
-	ec EncodeContext
-	vw ValueWriter
-}
-
-// NewEncoder returns a new encoder that writes to vw.
-func NewEncoder(vw ValueWriter) *Encoder {
-	return &Encoder{
-		ec: EncodeContext{Registry: defaultRegistry},
-		vw: vw,
-	}
-}
-
-// Encode writes the BSON encoding of val to the stream.
-//
-// See [Marshal] for details about BSON marshaling behavior.
-func (e *Encoder) Encode(val interface{}) error {
-	if marshaler, ok := val.(Marshaler); ok {
-		// TODO(skriptble): Should we have a MarshalAppender interface so that we can have []byte reuse?
-		buf, err := marshaler.MarshalBSON()
-		if err != nil {
-			return err
-		}
-		return copyDocumentFromBytes(e.vw, buf)
-	}
-
-	encoder, err := e.ec.LookupEncoder(reflect.TypeOf(val))
-	if err != nil {
-		return err
-	}
-
-	return encoder.EncodeValue(e.ec, e.vw, reflect.ValueOf(val))
-}
-
-// Reset will reset the state of the Encoder, using the same *EncodeContext used in
-// the original construction but using vw.
-func (e *Encoder) Reset(vw ValueWriter) {
-	e.vw = vw
-}
-
-// SetRegistry replaces the current registry of the Encoder with r.
-func (e *Encoder) SetRegistry(r *Registry) {
-	e.ec.Registry = r
-}
-
-// ErrorOnInlineDuplicates causes the Encoder to return an error if there is a duplicate field in
-// the marshaled BSON when the "inline" struct tag option is set.
-func (e *Encoder) ErrorOnInlineDuplicates() {
-	e.ec.errorOnInlineDuplicates = true
-}
-
-// IntMinSize causes the Encoder to marshal Go integer values (int, int8, int16, int32, int64, uint,
-// uint8, uint16, uint32, or uint64) as the minimum BSON int size (either 32 or 64 bits) that can
-// represent the integer value.
-func (e *Encoder) IntMinSize() {
-	e.ec.minSize = true
-}
-
-// StringifyMapKeysWithFmt causes the Encoder to convert Go map keys to BSON document field name
-// strings using fmt.Sprint instead of the default string conversion logic.
-func (e *Encoder) StringifyMapKeysWithFmt() {
-	e.ec.stringifyMapKeysWithFmt = true
-}
-
-// NilMapAsEmpty causes the Encoder to marshal nil Go maps as empty BSON documents instead of BSON
-// null.
-func (e *Encoder) NilMapAsEmpty() {
-	e.ec.nilMapAsEmpty = true
-}
-
-// NilSliceAsEmpty causes the Encoder to marshal nil Go slices as empty BSON arrays instead of BSON
-// null.
-func (e *Encoder) NilSliceAsEmpty() {
-	e.ec.nilSliceAsEmpty = true
-}
-
-// NilByteSliceAsEmpty causes the Encoder to marshal nil Go byte slices as empty BSON binary values
-// instead of BSON null.
-func (e *Encoder) NilByteSliceAsEmpty() {
-	e.ec.nilByteSliceAsEmpty = true
-}
-
-// TODO(GODRIVER-2820): Update the description to remove the note about only examining exported
-// TODO struct fields once the logic is updated to also inspect private struct fields.
-
-// OmitZeroStruct causes the Encoder to consider the zero value for a struct (e.g. MyStruct{})
-// as empty and omit it from the marshaled BSON when the "omitempty" struct tag option is set
-// or the OmitEmpty() method is called.
-//
-// Note that the Encoder only examines exported struct fields when determining if a struct is the
-// zero value. It considers pointers to a zero struct value (e.g. &MyStruct{}) not empty.
-func (e *Encoder) OmitZeroStruct() {
-	e.ec.omitZeroStruct = true
-}
-
-// OmitEmpty causes the Encoder to omit empty values from the marshaled BSON as the "omitempty"
-// struct tag option is set.
-func (e *Encoder) OmitEmpty() {
-	e.ec.omitEmpty = true
-}
-
-// UseJSONStructTags causes the Encoder to fall back to using the "json" struct tag if a "bson"
-// struct tag is not specified.
-func (e *Encoder) UseJSONStructTags() {
-	e.ec.useJSONStructTags = true
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_parser.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_parser.go
deleted file mode 100644
index a63f23a2..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_parser.go
+++ /dev/null
@@ -1,804 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"encoding/base64"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"io"
-	"strings"
-)
-
-const maxNestingDepth = 200
-
-// ErrInvalidJSON indicates the JSON input is invalid
-var ErrInvalidJSON = errors.New("invalid JSON input")
-
-type jsonParseState byte
-
-const (
-	jpsStartState jsonParseState = iota
-	jpsSawBeginObject
-	jpsSawEndObject
-	jpsSawBeginArray
-	jpsSawEndArray
-	jpsSawColon
-	jpsSawComma
-	jpsSawKey
-	jpsSawValue
-	jpsDoneState
-	jpsInvalidState
-)
-
-type jsonParseMode byte
-
-const (
-	jpmInvalidMode jsonParseMode = iota
-	jpmObjectMode
-	jpmArrayMode
-)
-
-type extJSONValue struct {
-	t Type
-	v interface{}
-}
-
-type extJSONObject struct {
-	keys   []string
-	values []*extJSONValue
-}
-
-type extJSONParser struct {
-	js *jsonScanner
-	s  jsonParseState
-	m  []jsonParseMode
-	k  string
-	v  *extJSONValue
-
-	err           error
-	canonicalOnly bool
-	depth         int
-	maxDepth      int
-
-	emptyObject bool
-	relaxedUUID bool
-}
-
-// newExtJSONParser returns a new extended JSON parser, ready to to begin
-// parsing from the first character of the argued json input. It will not
-// perform any read-ahead and will therefore not report any errors about
-// malformed JSON at this point.
-func newExtJSONParser(r io.Reader, canonicalOnly bool) *extJSONParser {
-	return &extJSONParser{
-		js:            &jsonScanner{r: r},
-		s:             jpsStartState,
-		m:             []jsonParseMode{},
-		canonicalOnly: canonicalOnly,
-		maxDepth:      maxNestingDepth,
-	}
-}
-
-// peekType examines the next value and returns its BSON Type
-func (ejp *extJSONParser) peekType() (Type, error) {
-	var t Type
-	var err error
-	initialState := ejp.s
-
-	ejp.advanceState()
-	switch ejp.s {
-	case jpsSawValue:
-		t = ejp.v.t
-	case jpsSawBeginArray:
-		t = TypeArray
-	case jpsInvalidState:
-		err = ejp.err
-	case jpsSawComma:
-		// in array mode, seeing a comma means we need to progress again to actually observe a type
-		if ejp.peekMode() == jpmArrayMode {
-			return ejp.peekType()
-		}
-	case jpsSawEndArray:
-		// this would only be a valid state if we were in array mode, so return end-of-array error
-		err = ErrEOA
-	case jpsSawBeginObject:
-		// peek key to determine type
-		ejp.advanceState()
-		switch ejp.s {
-		case jpsSawEndObject: // empty embedded document
-			t = TypeEmbeddedDocument
-			ejp.emptyObject = true
-		case jpsInvalidState:
-			err = ejp.err
-		case jpsSawKey:
-			if initialState == jpsStartState {
-				return TypeEmbeddedDocument, nil
-			}
-			t = wrapperKeyBSONType(ejp.k)
-
-			// if $uuid is encountered, parse as binary subtype 4
-			if ejp.k == "$uuid" {
-				ejp.relaxedUUID = true
-				t = TypeBinary
-			}
-
-			switch t {
-			case TypeJavaScript:
-				// just saw $code, need to check for $scope at same level
-				_, err = ejp.readValue(TypeJavaScript)
-				if err != nil {
-					break
-				}
-
-				switch ejp.s {
-				case jpsSawEndObject: // type is TypeJavaScript
-				case jpsSawComma:
-					ejp.advanceState()
-
-					if ejp.s == jpsSawKey && ejp.k == "$scope" {
-						t = TypeCodeWithScope
-					} else {
-						err = fmt.Errorf("invalid extended JSON: unexpected key %s in CodeWithScope object", ejp.k)
-					}
-				case jpsInvalidState:
-					err = ejp.err
-				default:
-					err = ErrInvalidJSON
-				}
-			case TypeCodeWithScope:
-				err = errors.New("invalid extended JSON: code with $scope must contain $code before $scope")
-			}
-		}
-	}
-
-	return t, err
-}
-
-// readKey parses the next key and its type and returns them
-func (ejp *extJSONParser) readKey() (string, Type, error) {
-	if ejp.emptyObject {
-		ejp.emptyObject = false
-		return "", 0, ErrEOD
-	}
-
-	// advance to key (or return with error)
-	switch ejp.s {
-	case jpsStartState:
-		ejp.advanceState()
-		if ejp.s == jpsSawBeginObject {
-			ejp.advanceState()
-		}
-	case jpsSawBeginObject:
-		ejp.advanceState()
-	case jpsSawValue, jpsSawEndObject, jpsSawEndArray:
-		ejp.advanceState()
-		switch ejp.s {
-		case jpsSawBeginObject, jpsSawComma:
-			ejp.advanceState()
-		case jpsSawEndObject:
-			return "", 0, ErrEOD
-		case jpsDoneState:
-			return "", 0, io.EOF
-		case jpsInvalidState:
-			return "", 0, ejp.err
-		default:
-			return "", 0, ErrInvalidJSON
-		}
-	case jpsSawKey: // do nothing (key was peeked before)
-	default:
-		return "", 0, invalidRequestError("key")
-	}
-
-	// read key
-	var key string
-
-	switch ejp.s {
-	case jpsSawKey:
-		key = ejp.k
-	case jpsSawEndObject:
-		return "", 0, ErrEOD
-	case jpsInvalidState:
-		return "", 0, ejp.err
-	default:
-		return "", 0, invalidRequestError("key")
-	}
-
-	// check for colon
-	ejp.advanceState()
-	if err := ensureColon(ejp.s, key); err != nil {
-		return "", 0, err
-	}
-
-	// peek at the value to determine type
-	t, err := ejp.peekType()
-	if err != nil {
-		return "", 0, err
-	}
-
-	return key, t, nil
-}
-
-// readValue returns the value corresponding to the Type returned by peekType
-func (ejp *extJSONParser) readValue(t Type) (*extJSONValue, error) {
-	if ejp.s == jpsInvalidState {
-		return nil, ejp.err
-	}
-
-	var v *extJSONValue
-
-	switch t {
-	case TypeNull, TypeBoolean, TypeString:
-		if ejp.s != jpsSawValue {
-			return nil, invalidRequestError(t.String())
-		}
-		v = ejp.v
-	case TypeInt32, TypeInt64, TypeDouble:
-		// relaxed version allows these to be literal number values
-		if ejp.s == jpsSawValue {
-			v = ejp.v
-			break
-		}
-		fallthrough
-	case TypeDecimal128, TypeSymbol, TypeObjectID, TypeMinKey, TypeMaxKey, TypeUndefined:
-		switch ejp.s {
-		case jpsSawKey:
-			// read colon
-			ejp.advanceState()
-			if err := ensureColon(ejp.s, ejp.k); err != nil {
-				return nil, err
-			}
-
-			// read value
-			ejp.advanceState()
-			if ejp.s != jpsSawValue || !ejp.ensureExtValueType(t) {
-				return nil, invalidJSONErrorForType("value", t)
-			}
-
-			v = ejp.v
-
-			// read end object
-			ejp.advanceState()
-			if ejp.s != jpsSawEndObject {
-				return nil, invalidJSONErrorForType("} after value", t)
-			}
-		default:
-			return nil, invalidRequestError(t.String())
-		}
-	case TypeBinary, TypeRegex, TypeTimestamp, TypeDBPointer:
-		if ejp.s != jpsSawKey {
-			return nil, invalidRequestError(t.String())
-		}
-		// read colon
-		ejp.advanceState()
-		if err := ensureColon(ejp.s, ejp.k); err != nil {
-			return nil, err
-		}
-
-		ejp.advanceState()
-		if t == TypeBinary && ejp.s == jpsSawValue {
-			// convert relaxed $uuid format
-			if ejp.relaxedUUID {
-				defer func() { ejp.relaxedUUID = false }()
-				uuid, err := ejp.v.parseSymbol()
-				if err != nil {
-					return nil, err
-				}
-
-				// RFC 4122 defines the length of a UUID as 36 and the hyphens in a UUID as appearing
-				// in the 8th, 13th, 18th, and 23rd characters.
-				//
-				// See https://tools.ietf.org/html/rfc4122#section-3
-				valid := len(uuid) == 36 &&
-					string(uuid[8]) == "-" &&
-					string(uuid[13]) == "-" &&
-					string(uuid[18]) == "-" &&
-					string(uuid[23]) == "-"
-				if !valid {
-					return nil, fmt.Errorf("$uuid value does not follow RFC 4122 format regarding length and hyphens")
-				}
-
-				// remove hyphens
-				uuidNoHyphens := strings.ReplaceAll(uuid, "-", "")
-				if len(uuidNoHyphens) != 32 {
-					return nil, fmt.Errorf("$uuid value does not follow RFC 4122 format regarding length and hyphens")
-				}
-
-				// convert hex to bytes
-				bytes, err := hex.DecodeString(uuidNoHyphens)
-				if err != nil {
-					return nil, fmt.Errorf("$uuid value does not follow RFC 4122 format regarding hex bytes: %w", err)
-				}
-
-				ejp.advanceState()
-				if ejp.s != jpsSawEndObject {
-					return nil, invalidJSONErrorForType("$uuid and value and then }", TypeBinary)
-				}
-
-				base64 := &extJSONValue{
-					t: TypeString,
-					v: base64.StdEncoding.EncodeToString(bytes),
-				}
-				subType := &extJSONValue{
-					t: TypeString,
-					v: "04",
-				}
-
-				v = &extJSONValue{
-					t: TypeEmbeddedDocument,
-					v: &extJSONObject{
-						keys:   []string{"base64", "subType"},
-						values: []*extJSONValue{base64, subType},
-					},
-				}
-
-				break
-			}
-
-			// convert legacy $binary format
-			base64 := ejp.v
-
-			ejp.advanceState()
-			if ejp.s != jpsSawComma {
-				return nil, invalidJSONErrorForType(",", TypeBinary)
-			}
-
-			ejp.advanceState()
-			key, t, err := ejp.readKey()
-			if err != nil {
-				return nil, err
-			}
-			if key != "$type" {
-				return nil, invalidJSONErrorForType("$type", TypeBinary)
-			}
-
-			subType, err := ejp.readValue(t)
-			if err != nil {
-				return nil, err
-			}
-
-			ejp.advanceState()
-			if ejp.s != jpsSawEndObject {
-				return nil, invalidJSONErrorForType("2 key-value pairs and then }", TypeBinary)
-			}
-
-			v = &extJSONValue{
-				t: TypeEmbeddedDocument,
-				v: &extJSONObject{
-					keys:   []string{"base64", "subType"},
-					values: []*extJSONValue{base64, subType},
-				},
-			}
-			break
-		}
-
-		// read KV pairs
-		if ejp.s != jpsSawBeginObject {
-			return nil, invalidJSONErrorForType("{", t)
-		}
-
-		keys, vals, err := ejp.readObject(2, true)
-		if err != nil {
-			return nil, err
-		}
-
-		ejp.advanceState()
-		if ejp.s != jpsSawEndObject {
-			return nil, invalidJSONErrorForType("2 key-value pairs and then }", t)
-		}
-
-		v = &extJSONValue{t: TypeEmbeddedDocument, v: &extJSONObject{keys: keys, values: vals}}
-
-	case TypeDateTime:
-		switch ejp.s {
-		case jpsSawValue:
-			v = ejp.v
-		case jpsSawKey:
-			// read colon
-			ejp.advanceState()
-			if err := ensureColon(ejp.s, ejp.k); err != nil {
-				return nil, err
-			}
-
-			ejp.advanceState()
-			switch ejp.s {
-			case jpsSawBeginObject:
-				keys, vals, err := ejp.readObject(1, true)
-				if err != nil {
-					return nil, err
-				}
-				v = &extJSONValue{t: TypeEmbeddedDocument, v: &extJSONObject{keys: keys, values: vals}}
-			case jpsSawValue:
-				if ejp.canonicalOnly {
-					return nil, invalidJSONError("{")
-				}
-				v = ejp.v
-			default:
-				if ejp.canonicalOnly {
-					return nil, invalidJSONErrorForType("object", t)
-				}
-				return nil, invalidJSONErrorForType("ISO-8601 Internet Date/Time Format as described in RFC-3339", t)
-			}
-
-			ejp.advanceState()
-			if ejp.s != jpsSawEndObject {
-				return nil, invalidJSONErrorForType("value and then }", t)
-			}
-		default:
-			return nil, invalidRequestError(t.String())
-		}
-	case TypeJavaScript:
-		switch ejp.s {
-		case jpsSawKey:
-			// read colon
-			ejp.advanceState()
-			if err := ensureColon(ejp.s, ejp.k); err != nil {
-				return nil, err
-			}
-
-			// read value
-			ejp.advanceState()
-			if ejp.s != jpsSawValue {
-				return nil, invalidJSONErrorForType("value", t)
-			}
-			v = ejp.v
-
-			// read end object or comma and just return
-			ejp.advanceState()
-		case jpsSawEndObject:
-			v = ejp.v
-		default:
-			return nil, invalidRequestError(t.String())
-		}
-	case TypeCodeWithScope:
-		if ejp.s == jpsSawKey && ejp.k == "$scope" {
-			v = ejp.v // this is the $code string from earlier
-
-			// read colon
-			ejp.advanceState()
-			if err := ensureColon(ejp.s, ejp.k); err != nil {
-				return nil, err
-			}
-
-			// read {
-			ejp.advanceState()
-			if ejp.s != jpsSawBeginObject {
-				return nil, invalidJSONError("$scope to be embedded document")
-			}
-		} else {
-			return nil, invalidRequestError(t.String())
-		}
-	case TypeEmbeddedDocument, TypeArray:
-		return nil, invalidRequestError(t.String())
-	}
-
-	return v, nil
-}
-
-// readObject is a utility method for reading full objects of known (or expected) size
-// it is useful for extended JSON types such as binary, datetime, regex, and timestamp
-func (ejp *extJSONParser) readObject(numKeys int, started bool) ([]string, []*extJSONValue, error) {
-	keys := make([]string, numKeys)
-	vals := make([]*extJSONValue, numKeys)
-
-	if !started {
-		ejp.advanceState()
-		if ejp.s != jpsSawBeginObject {
-			return nil, nil, invalidJSONError("{")
-		}
-	}
-
-	for i := 0; i < numKeys; i++ {
-		key, t, err := ejp.readKey()
-		if err != nil {
-			return nil, nil, err
-		}
-
-		switch ejp.s {
-		case jpsSawKey:
-			v, err := ejp.readValue(t)
-			if err != nil {
-				return nil, nil, err
-			}
-
-			keys[i] = key
-			vals[i] = v
-		case jpsSawValue:
-			keys[i] = key
-			vals[i] = ejp.v
-		default:
-			return nil, nil, invalidJSONError("value")
-		}
-	}
-
-	ejp.advanceState()
-	if ejp.s != jpsSawEndObject {
-		return nil, nil, invalidJSONError("}")
-	}
-
-	return keys, vals, nil
-}
-
-// advanceState reads the next JSON token from the scanner and transitions
-// from the current state based on that token's type
-func (ejp *extJSONParser) advanceState() {
-	if ejp.s == jpsDoneState || ejp.s == jpsInvalidState {
-		return
-	}
-
-	jt, err := ejp.js.nextToken()
-
-	if err != nil {
-		ejp.err = err
-		ejp.s = jpsInvalidState
-		return
-	}
-
-	valid := ejp.validateToken(jt.t)
-	if !valid {
-		ejp.err = unexpectedTokenError(jt)
-		ejp.s = jpsInvalidState
-		return
-	}
-
-	switch jt.t {
-	case jttBeginObject:
-		ejp.s = jpsSawBeginObject
-		ejp.pushMode(jpmObjectMode)
-		ejp.depth++
-
-		if ejp.depth > ejp.maxDepth {
-			ejp.err = nestingDepthError(jt.p, ejp.depth)
-			ejp.s = jpsInvalidState
-		}
-	case jttEndObject:
-		ejp.s = jpsSawEndObject
-		ejp.depth--
-
-		if ejp.popMode() != jpmObjectMode {
-			ejp.err = unexpectedTokenError(jt)
-			ejp.s = jpsInvalidState
-		}
-	case jttBeginArray:
-		ejp.s = jpsSawBeginArray
-		ejp.pushMode(jpmArrayMode)
-	case jttEndArray:
-		ejp.s = jpsSawEndArray
-
-		if ejp.popMode() != jpmArrayMode {
-			ejp.err = unexpectedTokenError(jt)
-			ejp.s = jpsInvalidState
-		}
-	case jttColon:
-		ejp.s = jpsSawColon
-	case jttComma:
-		ejp.s = jpsSawComma
-	case jttEOF:
-		ejp.s = jpsDoneState
-		if len(ejp.m) != 0 {
-			ejp.err = unexpectedTokenError(jt)
-			ejp.s = jpsInvalidState
-		}
-	case jttString:
-		switch ejp.s {
-		case jpsSawComma:
-			if ejp.peekMode() == jpmArrayMode {
-				ejp.s = jpsSawValue
-				ejp.v = extendJSONToken(jt)
-				return
-			}
-			fallthrough
-		case jpsSawBeginObject:
-			ejp.s = jpsSawKey
-			ejp.k = jt.v.(string)
-			return
-		}
-		fallthrough
-	default:
-		ejp.s = jpsSawValue
-		ejp.v = extendJSONToken(jt)
-	}
-}
-
-var jpsValidTransitionTokens = map[jsonParseState]map[jsonTokenType]bool{
-	jpsStartState: {
-		jttBeginObject: true,
-		jttBeginArray:  true,
-		jttInt32:       true,
-		jttInt64:       true,
-		jttDouble:      true,
-		jttString:      true,
-		jttBool:        true,
-		jttNull:        true,
-		jttEOF:         true,
-	},
-	jpsSawBeginObject: {
-		jttEndObject: true,
-		jttString:    true,
-	},
-	jpsSawEndObject: {
-		jttEndObject: true,
-		jttEndArray:  true,
-		jttComma:     true,
-		jttEOF:       true,
-	},
-	jpsSawBeginArray: {
-		jttBeginObject: true,
-		jttBeginArray:  true,
-		jttEndArray:    true,
-		jttInt32:       true,
-		jttInt64:       true,
-		jttDouble:      true,
-		jttString:      true,
-		jttBool:        true,
-		jttNull:        true,
-	},
-	jpsSawEndArray: {
-		jttEndObject: true,
-		jttEndArray:  true,
-		jttComma:     true,
-		jttEOF:       true,
-	},
-	jpsSawColon: {
-		jttBeginObject: true,
-		jttBeginArray:  true,
-		jttInt32:       true,
-		jttInt64:       true,
-		jttDouble:      true,
-		jttString:      true,
-		jttBool:        true,
-		jttNull:        true,
-	},
-	jpsSawComma: {
-		jttBeginObject: true,
-		jttBeginArray:  true,
-		jttInt32:       true,
-		jttInt64:       true,
-		jttDouble:      true,
-		jttString:      true,
-		jttBool:        true,
-		jttNull:        true,
-	},
-	jpsSawKey: {
-		jttColon: true,
-	},
-	jpsSawValue: {
-		jttEndObject: true,
-		jttEndArray:  true,
-		jttComma:     true,
-		jttEOF:       true,
-	},
-	jpsDoneState:    {},
-	jpsInvalidState: {},
-}
-
-func (ejp *extJSONParser) validateToken(jtt jsonTokenType) bool {
-	switch ejp.s {
-	case jpsSawEndObject:
-		// if we are at depth zero and the next token is a '{',
-		// we can consider it valid only if we are not in array mode.
-		if jtt == jttBeginObject && ejp.depth == 0 {
-			return ejp.peekMode() != jpmArrayMode
-		}
-	case jpsSawComma:
-		switch ejp.peekMode() {
-		// the only valid next token after a comma inside a document is a string (a key)
-		case jpmObjectMode:
-			return jtt == jttString
-		case jpmInvalidMode:
-			return false
-		}
-	}
-
-	_, ok := jpsValidTransitionTokens[ejp.s][jtt]
-	return ok
-}
-
-// ensureExtValueType returns true if the current value has the expected
-// value type for single-key extended JSON types. For example,
-// {"$numberInt": v} v must be TypeString
-func (ejp *extJSONParser) ensureExtValueType(t Type) bool {
-	switch t {
-	case TypeMinKey, TypeMaxKey:
-		return ejp.v.t == TypeInt32
-	case TypeUndefined:
-		return ejp.v.t == TypeBoolean
-	case TypeInt32, TypeInt64, TypeDouble, TypeDecimal128, TypeSymbol, TypeObjectID:
-		return ejp.v.t == TypeString
-	default:
-		return false
-	}
-}
-
-func (ejp *extJSONParser) pushMode(m jsonParseMode) {
-	ejp.m = append(ejp.m, m)
-}
-
-func (ejp *extJSONParser) popMode() jsonParseMode {
-	l := len(ejp.m)
-	if l == 0 {
-		return jpmInvalidMode
-	}
-
-	m := ejp.m[l-1]
-	ejp.m = ejp.m[:l-1]
-
-	return m
-}
-
-func (ejp *extJSONParser) peekMode() jsonParseMode {
-	l := len(ejp.m)
-	if l == 0 {
-		return jpmInvalidMode
-	}
-
-	return ejp.m[l-1]
-}
-
-func extendJSONToken(jt *jsonToken) *extJSONValue {
-	var t Type
-
-	switch jt.t {
-	case jttInt32:
-		t = TypeInt32
-	case jttInt64:
-		t = TypeInt64
-	case jttDouble:
-		t = TypeDouble
-	case jttString:
-		t = TypeString
-	case jttBool:
-		t = TypeBoolean
-	case jttNull:
-		t = TypeNull
-	default:
-		return nil
-	}
-
-	return &extJSONValue{t: t, v: jt.v}
-}
-
-func ensureColon(s jsonParseState, key string) error {
-	if s != jpsSawColon {
-		return fmt.Errorf("invalid JSON input: missing colon after key \"%s\"", key)
-	}
-
-	return nil
-}
-
-func invalidRequestError(s string) error {
-	return fmt.Errorf("invalid request to read %s", s)
-}
-
-func invalidJSONError(expected string) error {
-	return fmt.Errorf("invalid JSON input; expected %s", expected)
-}
-
-func invalidJSONErrorForType(expected string, t Type) error {
-	return fmt.Errorf("invalid JSON input; expected %s for %s", expected, t)
-}
-
-func unexpectedTokenError(jt *jsonToken) error {
-	switch jt.t {
-	case jttInt32, jttInt64, jttDouble:
-		return fmt.Errorf("invalid JSON input; unexpected number (%v) at position %d", jt.v, jt.p)
-	case jttString:
-		return fmt.Errorf("invalid JSON input; unexpected string (\"%v\") at position %d", jt.v, jt.p)
-	case jttBool:
-		return fmt.Errorf("invalid JSON input; unexpected boolean literal (%v) at position %d", jt.v, jt.p)
-	case jttNull:
-		return fmt.Errorf("invalid JSON input; unexpected null literal at position %d", jt.p)
-	case jttEOF:
-		return fmt.Errorf("invalid JSON input; unexpected end of input at position %d", jt.p)
-	default:
-		return fmt.Errorf("invalid JSON input; unexpected %c at position %d", jt.v.(byte), jt.p)
-	}
-}
-
-func nestingDepthError(p, depth int) error {
-	return fmt.Errorf("invalid JSON input; nesting too deep (%d levels) at position %d", depth, p)
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_reader.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_reader.go
deleted file mode 100644
index 4bee3efc..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_reader.go
+++ /dev/null
@@ -1,606 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"errors"
-	"fmt"
-	"io"
-)
-
-type ejvrState struct {
-	mode  mode
-	vType Type
-	depth int
-}
-
-// extJSONValueReader is for reading extended JSON.
-type extJSONValueReader struct {
-	p *extJSONParser
-
-	stack []ejvrState
-	frame int
-}
-
-// NewExtJSONValueReader returns a ValueReader that reads Extended JSON values
-// from r. If canonicalOnly is true, reading values from the ValueReader returns
-// an error if the Extended JSON was not marshaled in canonical mode.
-func NewExtJSONValueReader(r io.Reader, canonicalOnly bool) (ValueReader, error) {
-	return newExtJSONValueReader(r, canonicalOnly)
-}
-
-func newExtJSONValueReader(r io.Reader, canonicalOnly bool) (*extJSONValueReader, error) {
-	ejvr := new(extJSONValueReader)
-	return ejvr.reset(r, canonicalOnly)
-}
-
-func (ejvr *extJSONValueReader) reset(r io.Reader, canonicalOnly bool) (*extJSONValueReader, error) {
-	p := newExtJSONParser(r, canonicalOnly)
-	typ, err := p.peekType()
-
-	if err != nil {
-		return nil, ErrInvalidJSON
-	}
-
-	var m mode
-	switch typ {
-	case TypeEmbeddedDocument:
-		m = mTopLevel
-	case TypeArray:
-		m = mArray
-	default:
-		m = mValue
-	}
-
-	stack := make([]ejvrState, 1, 5)
-	stack[0] = ejvrState{
-		mode:  m,
-		vType: typ,
-	}
-	return &extJSONValueReader{
-		p:     p,
-		stack: stack,
-	}, nil
-}
-
-func (ejvr *extJSONValueReader) advanceFrame() {
-	if ejvr.frame+1 >= len(ejvr.stack) { // We need to grow the stack
-		length := len(ejvr.stack)
-		if length+1 >= cap(ejvr.stack) {
-			// double it
-			buf := make([]ejvrState, 2*cap(ejvr.stack)+1)
-			copy(buf, ejvr.stack)
-			ejvr.stack = buf
-		}
-		ejvr.stack = ejvr.stack[:length+1]
-	}
-	ejvr.frame++
-
-	// Clean the stack
-	ejvr.stack[ejvr.frame].mode = 0
-	ejvr.stack[ejvr.frame].vType = 0
-	ejvr.stack[ejvr.frame].depth = 0
-}
-
-func (ejvr *extJSONValueReader) pushDocument() {
-	ejvr.advanceFrame()
-
-	ejvr.stack[ejvr.frame].mode = mDocument
-	ejvr.stack[ejvr.frame].depth = ejvr.p.depth
-}
-
-func (ejvr *extJSONValueReader) pushCodeWithScope() {
-	ejvr.advanceFrame()
-
-	ejvr.stack[ejvr.frame].mode = mCodeWithScope
-}
-
-func (ejvr *extJSONValueReader) pushArray() {
-	ejvr.advanceFrame()
-
-	ejvr.stack[ejvr.frame].mode = mArray
-}
-
-func (ejvr *extJSONValueReader) push(m mode, t Type) {
-	ejvr.advanceFrame()
-
-	ejvr.stack[ejvr.frame].mode = m
-	ejvr.stack[ejvr.frame].vType = t
-}
-
-func (ejvr *extJSONValueReader) pop() {
-	switch ejvr.stack[ejvr.frame].mode {
-	case mElement, mValue:
-		ejvr.frame--
-	case mDocument, mArray, mCodeWithScope:
-		ejvr.frame -= 2 // we pop twice to jump over the vrElement: vrDocument -> vrElement -> vrDocument/TopLevel/etc...
-	}
-}
-
-func (ejvr *extJSONValueReader) skipObject() {
-	// read entire object until depth returns to 0 (last ending } or ] seen)
-	depth := 1
-	for depth > 0 {
-		ejvr.p.advanceState()
-
-		// If object is empty, raise depth and continue. When emptyObject is true, the
-		// parser has already read both the opening and closing brackets of an empty
-		// object ("{}"), so the next valid token will be part of the parent document,
-		// not part of the nested document.
-		//
-		// If there is a comma, there are remaining fields, emptyObject must be set back
-		// to false, and comma must be skipped with advanceState().
-		if ejvr.p.emptyObject {
-			if ejvr.p.s == jpsSawComma {
-				ejvr.p.emptyObject = false
-				ejvr.p.advanceState()
-			}
-			depth--
-			continue
-		}
-
-		switch ejvr.p.s {
-		case jpsSawBeginObject, jpsSawBeginArray:
-			depth++
-		case jpsSawEndObject, jpsSawEndArray:
-			depth--
-		}
-	}
-}
-
-func (ejvr *extJSONValueReader) invalidTransitionErr(destination mode, name string, modes []mode) error {
-	te := TransitionError{
-		name:        name,
-		current:     ejvr.stack[ejvr.frame].mode,
-		destination: destination,
-		modes:       modes,
-		action:      "read",
-	}
-	if ejvr.frame != 0 {
-		te.parent = ejvr.stack[ejvr.frame-1].mode
-	}
-	return te
-}
-
-func (ejvr *extJSONValueReader) typeError(t Type) error {
-	return fmt.Errorf("positioned on %s, but attempted to read %s", ejvr.stack[ejvr.frame].vType, t)
-}
-
-func (ejvr *extJSONValueReader) ensureElementValue(t Type, destination mode, callerName string, addModes ...mode) error {
-	switch ejvr.stack[ejvr.frame].mode {
-	case mElement, mValue:
-		if ejvr.stack[ejvr.frame].vType != t {
-			return ejvr.typeError(t)
-		}
-	default:
-		modes := []mode{mElement, mValue}
-		if addModes != nil {
-			modes = append(modes, addModes...)
-		}
-		return ejvr.invalidTransitionErr(destination, callerName, modes)
-	}
-
-	return nil
-}
-
-func (ejvr *extJSONValueReader) Type() Type {
-	return ejvr.stack[ejvr.frame].vType
-}
-
-func (ejvr *extJSONValueReader) Skip() error {
-	switch ejvr.stack[ejvr.frame].mode {
-	case mElement, mValue:
-	default:
-		return ejvr.invalidTransitionErr(0, "Skip", []mode{mElement, mValue})
-	}
-
-	defer ejvr.pop()
-
-	t := ejvr.stack[ejvr.frame].vType
-	switch t {
-	case TypeArray, TypeEmbeddedDocument, TypeCodeWithScope:
-		// read entire array, doc or CodeWithScope
-		ejvr.skipObject()
-	default:
-		_, err := ejvr.p.readValue(t)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (ejvr *extJSONValueReader) ReadArray() (ArrayReader, error) {
-	switch ejvr.stack[ejvr.frame].mode {
-	case mTopLevel: // allow reading array from top level
-	case mArray:
-		return ejvr, nil
-	default:
-		if err := ejvr.ensureElementValue(TypeArray, mArray, "ReadArray", mTopLevel, mArray); err != nil {
-			return nil, err
-		}
-	}
-
-	ejvr.pushArray()
-
-	return ejvr, nil
-}
-
-func (ejvr *extJSONValueReader) ReadBinary() (b []byte, btype byte, err error) {
-	if err := ejvr.ensureElementValue(TypeBinary, 0, "ReadBinary"); err != nil {
-		return nil, 0, err
-	}
-
-	v, err := ejvr.p.readValue(TypeBinary)
-	if err != nil {
-		return nil, 0, err
-	}
-
-	b, btype, err = v.parseBinary()
-
-	ejvr.pop()
-	return b, btype, err
-}
-
-func (ejvr *extJSONValueReader) ReadBoolean() (bool, error) {
-	if err := ejvr.ensureElementValue(TypeBoolean, 0, "ReadBoolean"); err != nil {
-		return false, err
-	}
-
-	v, err := ejvr.p.readValue(TypeBoolean)
-	if err != nil {
-		return false, err
-	}
-
-	if v.t != TypeBoolean {
-		return false, fmt.Errorf("expected type bool, but got type %s", v.t)
-	}
-
-	ejvr.pop()
-	return v.v.(bool), nil
-}
-
-func (ejvr *extJSONValueReader) ReadDocument() (DocumentReader, error) {
-	switch ejvr.stack[ejvr.frame].mode {
-	case mTopLevel:
-		return ejvr, nil
-	case mElement, mValue:
-		if ejvr.stack[ejvr.frame].vType != TypeEmbeddedDocument {
-			return nil, ejvr.typeError(TypeEmbeddedDocument)
-		}
-
-		ejvr.pushDocument()
-		return ejvr, nil
-	default:
-		return nil, ejvr.invalidTransitionErr(mDocument, "ReadDocument", []mode{mTopLevel, mElement, mValue})
-	}
-}
-
-func (ejvr *extJSONValueReader) ReadCodeWithScope() (code string, dr DocumentReader, err error) {
-	if err = ejvr.ensureElementValue(TypeCodeWithScope, 0, "ReadCodeWithScope"); err != nil {
-		return "", nil, err
-	}
-
-	v, err := ejvr.p.readValue(TypeCodeWithScope)
-	if err != nil {
-		return "", nil, err
-	}
-
-	code, err = v.parseJavascript()
-
-	ejvr.pushCodeWithScope()
-	return code, ejvr, err
-}
-
-func (ejvr *extJSONValueReader) ReadDBPointer() (ns string, oid ObjectID, err error) {
-	if err = ejvr.ensureElementValue(TypeDBPointer, 0, "ReadDBPointer"); err != nil {
-		return "", NilObjectID, err
-	}
-
-	v, err := ejvr.p.readValue(TypeDBPointer)
-	if err != nil {
-		return "", NilObjectID, err
-	}
-
-	ns, oid, err = v.parseDBPointer()
-
-	ejvr.pop()
-	return ns, oid, err
-}
-
-func (ejvr *extJSONValueReader) ReadDateTime() (int64, error) {
-	if err := ejvr.ensureElementValue(TypeDateTime, 0, "ReadDateTime"); err != nil {
-		return 0, err
-	}
-
-	v, err := ejvr.p.readValue(TypeDateTime)
-	if err != nil {
-		return 0, err
-	}
-
-	d, err := v.parseDateTime()
-
-	ejvr.pop()
-	return d, err
-}
-
-func (ejvr *extJSONValueReader) ReadDecimal128() (Decimal128, error) {
-	if err := ejvr.ensureElementValue(TypeDecimal128, 0, "ReadDecimal128"); err != nil {
-		return Decimal128{}, err
-	}
-
-	v, err := ejvr.p.readValue(TypeDecimal128)
-	if err != nil {
-		return Decimal128{}, err
-	}
-
-	d, err := v.parseDecimal128()
-
-	ejvr.pop()
-	return d, err
-}
-
-func (ejvr *extJSONValueReader) ReadDouble() (float64, error) {
-	if err := ejvr.ensureElementValue(TypeDouble, 0, "ReadDouble"); err != nil {
-		return 0, err
-	}
-
-	v, err := ejvr.p.readValue(TypeDouble)
-	if err != nil {
-		return 0, err
-	}
-
-	d, err := v.parseDouble()
-
-	ejvr.pop()
-	return d, err
-}
-
-func (ejvr *extJSONValueReader) ReadInt32() (int32, error) {
-	if err := ejvr.ensureElementValue(TypeInt32, 0, "ReadInt32"); err != nil {
-		return 0, err
-	}
-
-	v, err := ejvr.p.readValue(TypeInt32)
-	if err != nil {
-		return 0, err
-	}
-
-	i, err := v.parseInt32()
-
-	ejvr.pop()
-	return i, err
-}
-
-func (ejvr *extJSONValueReader) ReadInt64() (int64, error) {
-	if err := ejvr.ensureElementValue(TypeInt64, 0, "ReadInt64"); err != nil {
-		return 0, err
-	}
-
-	v, err := ejvr.p.readValue(TypeInt64)
-	if err != nil {
-		return 0, err
-	}
-
-	i, err := v.parseInt64()
-
-	ejvr.pop()
-	return i, err
-}
-
-func (ejvr *extJSONValueReader) ReadJavascript() (code string, err error) {
-	if err = ejvr.ensureElementValue(TypeJavaScript, 0, "ReadJavascript"); err != nil {
-		return "", err
-	}
-
-	v, err := ejvr.p.readValue(TypeJavaScript)
-	if err != nil {
-		return "", err
-	}
-
-	code, err = v.parseJavascript()
-
-	ejvr.pop()
-	return code, err
-}
-
-func (ejvr *extJSONValueReader) ReadMaxKey() error {
-	if err := ejvr.ensureElementValue(TypeMaxKey, 0, "ReadMaxKey"); err != nil {
-		return err
-	}
-
-	v, err := ejvr.p.readValue(TypeMaxKey)
-	if err != nil {
-		return err
-	}
-
-	err = v.parseMinMaxKey("max")
-
-	ejvr.pop()
-	return err
-}
-
-func (ejvr *extJSONValueReader) ReadMinKey() error {
-	if err := ejvr.ensureElementValue(TypeMinKey, 0, "ReadMinKey"); err != nil {
-		return err
-	}
-
-	v, err := ejvr.p.readValue(TypeMinKey)
-	if err != nil {
-		return err
-	}
-
-	err = v.parseMinMaxKey("min")
-
-	ejvr.pop()
-	return err
-}
-
-func (ejvr *extJSONValueReader) ReadNull() error {
-	if err := ejvr.ensureElementValue(TypeNull, 0, "ReadNull"); err != nil {
-		return err
-	}
-
-	v, err := ejvr.p.readValue(TypeNull)
-	if err != nil {
-		return err
-	}
-
-	if v.t != TypeNull {
-		return fmt.Errorf("expected type null but got type %s", v.t)
-	}
-
-	ejvr.pop()
-	return nil
-}
-
-func (ejvr *extJSONValueReader) ReadObjectID() (ObjectID, error) {
-	if err := ejvr.ensureElementValue(TypeObjectID, 0, "ReadObjectID"); err != nil {
-		return ObjectID{}, err
-	}
-
-	v, err := ejvr.p.readValue(TypeObjectID)
-	if err != nil {
-		return ObjectID{}, err
-	}
-
-	oid, err := v.parseObjectID()
-
-	ejvr.pop()
-	return oid, err
-}
-
-func (ejvr *extJSONValueReader) ReadRegex() (pattern string, options string, err error) {
-	if err = ejvr.ensureElementValue(TypeRegex, 0, "ReadRegex"); err != nil {
-		return "", "", err
-	}
-
-	v, err := ejvr.p.readValue(TypeRegex)
-	if err != nil {
-		return "", "", err
-	}
-
-	pattern, options, err = v.parseRegex()
-
-	ejvr.pop()
-	return pattern, options, err
-}
-
-func (ejvr *extJSONValueReader) ReadString() (string, error) {
-	if err := ejvr.ensureElementValue(TypeString, 0, "ReadString"); err != nil {
-		return "", err
-	}
-
-	v, err := ejvr.p.readValue(TypeString)
-	if err != nil {
-		return "", err
-	}
-
-	if v.t != TypeString {
-		return "", fmt.Errorf("expected type string but got type %s", v.t)
-	}
-
-	ejvr.pop()
-	return v.v.(string), nil
-}
-
-func (ejvr *extJSONValueReader) ReadSymbol() (symbol string, err error) {
-	if err = ejvr.ensureElementValue(TypeSymbol, 0, "ReadSymbol"); err != nil {
-		return "", err
-	}
-
-	v, err := ejvr.p.readValue(TypeSymbol)
-	if err != nil {
-		return "", err
-	}
-
-	symbol, err = v.parseSymbol()
-
-	ejvr.pop()
-	return symbol, err
-}
-
-func (ejvr *extJSONValueReader) ReadTimestamp() (t uint32, i uint32, err error) {
-	if err = ejvr.ensureElementValue(TypeTimestamp, 0, "ReadTimestamp"); err != nil {
-		return 0, 0, err
-	}
-
-	v, err := ejvr.p.readValue(TypeTimestamp)
-	if err != nil {
-		return 0, 0, err
-	}
-
-	t, i, err = v.parseTimestamp()
-
-	ejvr.pop()
-	return t, i, err
-}
-
-func (ejvr *extJSONValueReader) ReadUndefined() error {
-	if err := ejvr.ensureElementValue(TypeUndefined, 0, "ReadUndefined"); err != nil {
-		return err
-	}
-
-	v, err := ejvr.p.readValue(TypeUndefined)
-	if err != nil {
-		return err
-	}
-
-	err = v.parseUndefined()
-
-	ejvr.pop()
-	return err
-}
-
-func (ejvr *extJSONValueReader) ReadElement() (string, ValueReader, error) {
-	switch ejvr.stack[ejvr.frame].mode {
-	case mTopLevel, mDocument, mCodeWithScope:
-	default:
-		return "", nil, ejvr.invalidTransitionErr(mElement, "ReadElement", []mode{mTopLevel, mDocument, mCodeWithScope})
-	}
-
-	name, t, err := ejvr.p.readKey()
-
-	if err != nil {
-		if errors.Is(err, ErrEOD) {
-			if ejvr.stack[ejvr.frame].mode == mCodeWithScope {
-				_, err := ejvr.p.peekType()
-				if err != nil {
-					return "", nil, err
-				}
-			}
-
-			ejvr.pop()
-		}
-
-		return "", nil, err
-	}
-
-	ejvr.push(mElement, t)
-	return name, ejvr, nil
-}
-
-func (ejvr *extJSONValueReader) ReadValue() (ValueReader, error) {
-	switch ejvr.stack[ejvr.frame].mode {
-	case mArray:
-	default:
-		return nil, ejvr.invalidTransitionErr(mValue, "ReadValue", []mode{mArray})
-	}
-
-	t, err := ejvr.p.peekType()
-	if err != nil {
-		if errors.Is(err, ErrEOA) {
-			ejvr.pop()
-		}
-
-		return nil, err
-	}
-
-	ejvr.push(mValue, t)
-	return ejvr, nil
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_tables.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_tables.go
deleted file mode 100644
index 5384db22..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_tables.go
+++ /dev/null
@@ -1,223 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-//
-// Based on github.com/golang/go by The Go Authors
-// See THIRD-PARTY-NOTICES for original license terms.
-
-package bson
-
-import "unicode/utf8"
-
-// safeSet holds the value true if the ASCII character with the given array
-// position can be represented inside a JSON string without any further
-// escaping.
-//
-// All values are true except for the ASCII control characters (0-31), the
-// double quote ("), and the backslash character ("\").
-var safeSet = [utf8.RuneSelf]bool{
-	' ':      true,
-	'!':      true,
-	'"':      false,
-	'#':      true,
-	'$':      true,
-	'%':      true,
-	'&':      true,
-	'\'':     true,
-	'(':      true,
-	')':      true,
-	'*':      true,
-	'+':      true,
-	',':      true,
-	'-':      true,
-	'.':      true,
-	'/':      true,
-	'0':      true,
-	'1':      true,
-	'2':      true,
-	'3':      true,
-	'4':      true,
-	'5':      true,
-	'6':      true,
-	'7':      true,
-	'8':      true,
-	'9':      true,
-	':':      true,
-	';':      true,
-	'<':      true,
-	'=':      true,
-	'>':      true,
-	'?':      true,
-	'@':      true,
-	'A':      true,
-	'B':      true,
-	'C':      true,
-	'D':      true,
-	'E':      true,
-	'F':      true,
-	'G':      true,
-	'H':      true,
-	'I':      true,
-	'J':      true,
-	'K':      true,
-	'L':      true,
-	'M':      true,
-	'N':      true,
-	'O':      true,
-	'P':      true,
-	'Q':      true,
-	'R':      true,
-	'S':      true,
-	'T':      true,
-	'U':      true,
-	'V':      true,
-	'W':      true,
-	'X':      true,
-	'Y':      true,
-	'Z':      true,
-	'[':      true,
-	'\\':     false,
-	']':      true,
-	'^':      true,
-	'_':      true,
-	'`':      true,
-	'a':      true,
-	'b':      true,
-	'c':      true,
-	'd':      true,
-	'e':      true,
-	'f':      true,
-	'g':      true,
-	'h':      true,
-	'i':      true,
-	'j':      true,
-	'k':      true,
-	'l':      true,
-	'm':      true,
-	'n':      true,
-	'o':      true,
-	'p':      true,
-	'q':      true,
-	'r':      true,
-	's':      true,
-	't':      true,
-	'u':      true,
-	'v':      true,
-	'w':      true,
-	'x':      true,
-	'y':      true,
-	'z':      true,
-	'{':      true,
-	'|':      true,
-	'}':      true,
-	'~':      true,
-	'\u007f': true,
-}
-
-// htmlSafeSet holds the value true if the ASCII character with the given
-// array position can be safely represented inside a JSON string, embedded
-// inside of HTML <script> tags, without any additional escaping.
-//
-// All values are true except for the ASCII control characters (0-31), the
-// double quote ("), the backslash character ("\"), HTML opening and closing
-// tags ("<" and ">"), and the ampersand ("&").
-var htmlSafeSet = [utf8.RuneSelf]bool{
-	' ':      true,
-	'!':      true,
-	'"':      false,
-	'#':      true,
-	'$':      true,
-	'%':      true,
-	'&':      false,
-	'\'':     true,
-	'(':      true,
-	')':      true,
-	'*':      true,
-	'+':      true,
-	',':      true,
-	'-':      true,
-	'.':      true,
-	'/':      true,
-	'0':      true,
-	'1':      true,
-	'2':      true,
-	'3':      true,
-	'4':      true,
-	'5':      true,
-	'6':      true,
-	'7':      true,
-	'8':      true,
-	'9':      true,
-	':':      true,
-	';':      true,
-	'<':      false,
-	'=':      true,
-	'>':      false,
-	'?':      true,
-	'@':      true,
-	'A':      true,
-	'B':      true,
-	'C':      true,
-	'D':      true,
-	'E':      true,
-	'F':      true,
-	'G':      true,
-	'H':      true,
-	'I':      true,
-	'J':      true,
-	'K':      true,
-	'L':      true,
-	'M':      true,
-	'N':      true,
-	'O':      true,
-	'P':      true,
-	'Q':      true,
-	'R':      true,
-	'S':      true,
-	'T':      true,
-	'U':      true,
-	'V':      true,
-	'W':      true,
-	'X':      true,
-	'Y':      true,
-	'Z':      true,
-	'[':      true,
-	'\\':     false,
-	']':      true,
-	'^':      true,
-	'_':      true,
-	'`':      true,
-	'a':      true,
-	'b':      true,
-	'c':      true,
-	'd':      true,
-	'e':      true,
-	'f':      true,
-	'g':      true,
-	'h':      true,
-	'i':      true,
-	'j':      true,
-	'k':      true,
-	'l':      true,
-	'm':      true,
-	'n':      true,
-	'o':      true,
-	'p':      true,
-	'q':      true,
-	'r':      true,
-	's':      true,
-	't':      true,
-	'u':      true,
-	'v':      true,
-	'w':      true,
-	'x':      true,
-	'y':      true,
-	'z':      true,
-	'{':      true,
-	'|':      true,
-	'}':      true,
-	'~':      true,
-	'\u007f': true,
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_wrappers.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_wrappers.go
deleted file mode 100644
index e98b6428..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_wrappers.go
+++ /dev/null
@@ -1,489 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"encoding/base64"
-	"errors"
-	"fmt"
-	"math"
-	"strconv"
-	"time"
-)
-
-func wrapperKeyBSONType(key string) Type {
-	switch key {
-	case "$numberInt":
-		return TypeInt32
-	case "$numberLong":
-		return TypeInt64
-	case "$oid":
-		return TypeObjectID
-	case "$symbol":
-		return TypeSymbol
-	case "$numberDouble":
-		return TypeDouble
-	case "$numberDecimal":
-		return TypeDecimal128
-	case "$binary":
-		return TypeBinary
-	case "$code":
-		return TypeJavaScript
-	case "$scope":
-		return TypeCodeWithScope
-	case "$timestamp":
-		return TypeTimestamp
-	case "$regularExpression":
-		return TypeRegex
-	case "$dbPointer":
-		return TypeDBPointer
-	case "$date":
-		return TypeDateTime
-	case "$minKey":
-		return TypeMinKey
-	case "$maxKey":
-		return TypeMaxKey
-	case "$undefined":
-		return TypeUndefined
-	}
-
-	return TypeEmbeddedDocument
-}
-
-func (ejv *extJSONValue) parseBinary() (b []byte, subType byte, err error) {
-	if ejv.t != TypeEmbeddedDocument {
-		return nil, 0, fmt.Errorf("$binary value should be object, but instead is %s", ejv.t)
-	}
-
-	binObj := ejv.v.(*extJSONObject)
-	bFound := false
-	stFound := false
-
-	for i, key := range binObj.keys {
-		val := binObj.values[i]
-
-		switch key {
-		case "base64":
-			if bFound {
-				return nil, 0, errors.New("duplicate base64 key in $binary")
-			}
-
-			if val.t != TypeString {
-				return nil, 0, fmt.Errorf("$binary base64 value should be string, but instead is %s", val.t)
-			}
-
-			base64Bytes, err := base64.StdEncoding.DecodeString(val.v.(string))
-			if err != nil {
-				return nil, 0, fmt.Errorf("invalid $binary base64 string: %s", val.v.(string))
-			}
-
-			b = base64Bytes
-			bFound = true
-		case "subType":
-			if stFound {
-				return nil, 0, errors.New("duplicate subType key in $binary")
-			}
-
-			if val.t != TypeString {
-				return nil, 0, fmt.Errorf("$binary subType value should be string, but instead is %s", val.t)
-			}
-
-			i, err := strconv.ParseUint(val.v.(string), 16, 8)
-			if err != nil {
-				return nil, 0, fmt.Errorf("invalid $binary subType string: %q: %w", val.v.(string), err)
-			}
-
-			subType = byte(i)
-			stFound = true
-		default:
-			return nil, 0, fmt.Errorf("invalid key in $binary object: %s", key)
-		}
-	}
-
-	if !bFound {
-		return nil, 0, errors.New("missing base64 field in $binary object")
-	}
-
-	if !stFound {
-		return nil, 0, errors.New("missing subType field in $binary object")
-
-	}
-
-	return b, subType, nil
-}
-
-func (ejv *extJSONValue) parseDBPointer() (ns string, oid ObjectID, err error) {
-	if ejv.t != TypeEmbeddedDocument {
-		return "", NilObjectID, fmt.Errorf("$dbPointer value should be object, but instead is %s", ejv.t)
-	}
-
-	dbpObj := ejv.v.(*extJSONObject)
-	oidFound := false
-	nsFound := false
-
-	for i, key := range dbpObj.keys {
-		val := dbpObj.values[i]
-
-		switch key {
-		case "$ref":
-			if nsFound {
-				return "", NilObjectID, errors.New("duplicate $ref key in $dbPointer")
-			}
-
-			if val.t != TypeString {
-				return "", NilObjectID, fmt.Errorf("$dbPointer $ref value should be string, but instead is %s", val.t)
-			}
-
-			ns = val.v.(string)
-			nsFound = true
-		case "$id":
-			if oidFound {
-				return "", NilObjectID, errors.New("duplicate $id key in $dbPointer")
-			}
-
-			if val.t != TypeString {
-				return "", NilObjectID, fmt.Errorf("$dbPointer $id value should be string, but instead is %s", val.t)
-			}
-
-			oid, err = ObjectIDFromHex(val.v.(string))
-			if err != nil {
-				return "", NilObjectID, err
-			}
-
-			oidFound = true
-		default:
-			return "", NilObjectID, fmt.Errorf("invalid key in $dbPointer object: %s", key)
-		}
-	}
-
-	if !nsFound {
-		return "", oid, errors.New("missing $ref field in $dbPointer object")
-	}
-
-	if !oidFound {
-		return "", oid, errors.New("missing $id field in $dbPointer object")
-	}
-
-	return ns, oid, nil
-}
-
-const (
-	rfc3339Milli = "2006-01-02T15:04:05.999Z07:00"
-)
-
-var (
-	timeFormats = []string{rfc3339Milli, "2006-01-02T15:04:05.999Z0700"}
-)
-
-func (ejv *extJSONValue) parseDateTime() (int64, error) {
-	switch ejv.t {
-	case TypeInt32:
-		return int64(ejv.v.(int32)), nil
-	case TypeInt64:
-		return ejv.v.(int64), nil
-	case TypeString:
-		return parseDatetimeString(ejv.v.(string))
-	case TypeEmbeddedDocument:
-		return parseDatetimeObject(ejv.v.(*extJSONObject))
-	default:
-		return 0, fmt.Errorf("$date value should be string or object, but instead is %s", ejv.t)
-	}
-}
-
-func parseDatetimeString(data string) (int64, error) {
-	var t time.Time
-	var err error
-	// try acceptable time formats until one matches
-	for _, format := range timeFormats {
-		t, err = time.Parse(format, data)
-		if err == nil {
-			break
-		}
-	}
-	if err != nil {
-		return 0, fmt.Errorf("invalid $date value string: %s", data)
-	}
-
-	return int64(NewDateTimeFromTime(t)), nil
-}
-
-func parseDatetimeObject(data *extJSONObject) (d int64, err error) {
-	dFound := false
-
-	for i, key := range data.keys {
-		val := data.values[i]
-
-		switch key {
-		case "$numberLong":
-			if dFound {
-				return 0, errors.New("duplicate $numberLong key in $date")
-			}
-
-			if val.t != TypeString {
-				return 0, fmt.Errorf("$date $numberLong field should be string, but instead is %s", val.t)
-			}
-
-			d, err = val.parseInt64()
-			if err != nil {
-				return 0, err
-			}
-			dFound = true
-		default:
-			return 0, fmt.Errorf("invalid key in $date object: %s", key)
-		}
-	}
-
-	if !dFound {
-		return 0, errors.New("missing $numberLong field in $date object")
-	}
-
-	return d, nil
-}
-
-func (ejv *extJSONValue) parseDecimal128() (Decimal128, error) {
-	if ejv.t != TypeString {
-		return Decimal128{}, fmt.Errorf("$numberDecimal value should be string, but instead is %s", ejv.t)
-	}
-
-	d, err := ParseDecimal128(ejv.v.(string))
-	if err != nil {
-		return Decimal128{}, fmt.Errorf("$invalid $numberDecimal string: %s", ejv.v.(string))
-	}
-
-	return d, nil
-}
-
-func (ejv *extJSONValue) parseDouble() (float64, error) {
-	if ejv.t == TypeDouble {
-		return ejv.v.(float64), nil
-	}
-
-	if ejv.t != TypeString {
-		return 0, fmt.Errorf("$numberDouble value should be string, but instead is %s", ejv.t)
-	}
-
-	switch ejv.v.(string) {
-	case "Infinity":
-		return math.Inf(1), nil
-	case "-Infinity":
-		return math.Inf(-1), nil
-	case "NaN":
-		return math.NaN(), nil
-	}
-
-	f, err := strconv.ParseFloat(ejv.v.(string), 64)
-	if err != nil {
-		return 0, err
-	}
-
-	return f, nil
-}
-
-func (ejv *extJSONValue) parseInt32() (int32, error) {
-	if ejv.t == TypeInt32 {
-		return ejv.v.(int32), nil
-	}
-
-	if ejv.t != TypeString {
-		return 0, fmt.Errorf("$numberInt value should be string, but instead is %s", ejv.t)
-	}
-
-	i, err := strconv.ParseInt(ejv.v.(string), 10, 64)
-	if err != nil {
-		return 0, err
-	}
-
-	if i < math.MinInt32 || i > math.MaxInt32 {
-		return 0, fmt.Errorf("$numberInt value should be int32 but instead is int64: %d", i)
-	}
-
-	return int32(i), nil
-}
-
-func (ejv *extJSONValue) parseInt64() (int64, error) {
-	if ejv.t == TypeInt64 {
-		return ejv.v.(int64), nil
-	}
-
-	if ejv.t != TypeString {
-		return 0, fmt.Errorf("$numberLong value should be string, but instead is %s", ejv.t)
-	}
-
-	i, err := strconv.ParseInt(ejv.v.(string), 10, 64)
-	if err != nil {
-		return 0, err
-	}
-
-	return i, nil
-}
-
-func (ejv *extJSONValue) parseJavascript() (code string, err error) {
-	if ejv.t != TypeString {
-		return "", fmt.Errorf("$code value should be string, but instead is %s", ejv.t)
-	}
-
-	return ejv.v.(string), nil
-}
-
-func (ejv *extJSONValue) parseMinMaxKey(minmax string) error {
-	if ejv.t != TypeInt32 {
-		return fmt.Errorf("$%sKey value should be int32, but instead is %s", minmax, ejv.t)
-	}
-
-	if ejv.v.(int32) != 1 {
-		return fmt.Errorf("$%sKey value must be 1, but instead is %d", minmax, ejv.v.(int32))
-	}
-
-	return nil
-}
-
-func (ejv *extJSONValue) parseObjectID() (ObjectID, error) {
-	if ejv.t != TypeString {
-		return NilObjectID, fmt.Errorf("$oid value should be string, but instead is %s", ejv.t)
-	}
-
-	return ObjectIDFromHex(ejv.v.(string))
-}
-
-func (ejv *extJSONValue) parseRegex() (pattern, options string, err error) {
-	if ejv.t != TypeEmbeddedDocument {
-		return "", "", fmt.Errorf("$regularExpression value should be object, but instead is %s", ejv.t)
-	}
-
-	regexObj := ejv.v.(*extJSONObject)
-	patFound := false
-	optFound := false
-
-	for i, key := range regexObj.keys {
-		val := regexObj.values[i]
-
-		switch key {
-		case "pattern":
-			if patFound {
-				return "", "", errors.New("duplicate pattern key in $regularExpression")
-			}
-
-			if val.t != TypeString {
-				return "", "", fmt.Errorf("$regularExpression pattern value should be string, but instead is %s", val.t)
-			}
-
-			pattern = val.v.(string)
-			patFound = true
-		case "options":
-			if optFound {
-				return "", "", errors.New("duplicate options key in $regularExpression")
-			}
-
-			if val.t != TypeString {
-				return "", "", fmt.Errorf("$regularExpression options value should be string, but instead is %s", val.t)
-			}
-
-			options = val.v.(string)
-			optFound = true
-		default:
-			return "", "", fmt.Errorf("invalid key in $regularExpression object: %s", key)
-		}
-	}
-
-	if !patFound {
-		return "", "", errors.New("missing pattern field in $regularExpression object")
-	}
-
-	if !optFound {
-		return "", "", errors.New("missing options field in $regularExpression object")
-
-	}
-
-	return pattern, options, nil
-}
-
-func (ejv *extJSONValue) parseSymbol() (string, error) {
-	if ejv.t != TypeString {
-		return "", fmt.Errorf("$symbol value should be string, but instead is %s", ejv.t)
-	}
-
-	return ejv.v.(string), nil
-}
-
-func (ejv *extJSONValue) parseTimestamp() (t, i uint32, err error) {
-	if ejv.t != TypeEmbeddedDocument {
-		return 0, 0, fmt.Errorf("$timestamp value should be object, but instead is %s", ejv.t)
-	}
-
-	handleKey := func(key string, val *extJSONValue, flag bool) (uint32, error) {
-		if flag {
-			return 0, fmt.Errorf("duplicate %s key in $timestamp", key)
-		}
-
-		switch val.t {
-		case TypeInt32:
-			value := val.v.(int32)
-
-			if value < 0 {
-				return 0, fmt.Errorf("$timestamp %s number should be uint32: %d", key, value)
-			}
-
-			return uint32(value), nil
-		case TypeInt64:
-			value := val.v.(int64)
-			if value < 0 || value > int64(math.MaxUint32) {
-				return 0, fmt.Errorf("$timestamp %s number should be uint32: %d", key, value)
-			}
-
-			return uint32(value), nil
-		default:
-			return 0, fmt.Errorf("$timestamp %s value should be uint32, but instead is %s", key, val.t)
-		}
-	}
-
-	tsObj := ejv.v.(*extJSONObject)
-	tFound := false
-	iFound := false
-
-	for j, key := range tsObj.keys {
-		val := tsObj.values[j]
-
-		switch key {
-		case "t":
-			if t, err = handleKey(key, val, tFound); err != nil {
-				return 0, 0, err
-			}
-
-			tFound = true
-		case "i":
-			if i, err = handleKey(key, val, iFound); err != nil {
-				return 0, 0, err
-			}
-
-			iFound = true
-		default:
-			return 0, 0, fmt.Errorf("invalid key in $timestamp object: %s", key)
-		}
-	}
-
-	if !tFound {
-		return 0, 0, errors.New("missing t field in $timestamp object")
-	}
-
-	if !iFound {
-		return 0, 0, errors.New("missing i field in $timestamp object")
-	}
-
-	return t, i, nil
-}
-
-func (ejv *extJSONValue) parseUndefined() error {
-	if ejv.t != TypeBoolean {
-		return fmt.Errorf("undefined value should be boolean, but instead is %s", ejv.t)
-	}
-
-	if !ejv.v.(bool) {
-		return fmt.Errorf("$undefined balue boolean should be true, but instead is %v", ejv.v.(bool))
-	}
-
-	return nil
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_writer.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_writer.go
deleted file mode 100644
index 2d43943f..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/extjson_writer.go
+++ /dev/null
@@ -1,690 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"bytes"
-	"encoding/base64"
-	"fmt"
-	"io"
-	"math"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-	"unicode/utf8"
-)
-
-type ejvwState struct {
-	mode mode
-}
-
-type extJSONValueWriter struct {
-	w   io.Writer
-	buf []byte
-
-	stack      []ejvwState
-	frame      int64
-	canonical  bool
-	escapeHTML bool
-	newlines   bool
-}
-
-// NewExtJSONValueWriter creates a ValueWriter that writes Extended JSON to w.
-func NewExtJSONValueWriter(w io.Writer, canonical, escapeHTML bool) ValueWriter {
-	// Enable newlines for all Extended JSON value writers created by NewExtJSONValueWriter. We
-	// expect these value writers to be used with an Encoder, which should add newlines after
-	// encoded Extended JSON documents.
-	return newExtJSONWriter(w, canonical, escapeHTML, true)
-}
-
-func newExtJSONWriter(w io.Writer, canonical, escapeHTML, newlines bool) *extJSONValueWriter {
-	stack := make([]ejvwState, 1, 5)
-	stack[0] = ejvwState{mode: mTopLevel}
-
-	return &extJSONValueWriter{
-		w:          w,
-		buf:        []byte{},
-		stack:      stack,
-		canonical:  canonical,
-		escapeHTML: escapeHTML,
-		newlines:   newlines,
-	}
-}
-
-func newExtJSONWriterFromSlice(buf []byte, canonical, escapeHTML bool) *extJSONValueWriter {
-	stack := make([]ejvwState, 1, 5)
-	stack[0] = ejvwState{mode: mTopLevel}
-
-	return &extJSONValueWriter{
-		buf:        buf,
-		stack:      stack,
-		canonical:  canonical,
-		escapeHTML: escapeHTML,
-	}
-}
-
-func (ejvw *extJSONValueWriter) reset(buf []byte, canonical, escapeHTML bool) {
-	if ejvw.stack == nil {
-		ejvw.stack = make([]ejvwState, 1, 5)
-	}
-
-	ejvw.stack = ejvw.stack[:1]
-	ejvw.stack[0] = ejvwState{mode: mTopLevel}
-	ejvw.canonical = canonical
-	ejvw.escapeHTML = escapeHTML
-	ejvw.frame = 0
-	ejvw.buf = buf
-	ejvw.w = nil
-}
-
-func (ejvw *extJSONValueWriter) advanceFrame() {
-	if ejvw.frame+1 >= int64(len(ejvw.stack)) { // We need to grow the stack
-		length := len(ejvw.stack)
-		if length+1 >= cap(ejvw.stack) {
-			// double it
-			buf := make([]ejvwState, 2*cap(ejvw.stack)+1)
-			copy(buf, ejvw.stack)
-			ejvw.stack = buf
-		}
-		ejvw.stack = ejvw.stack[:length+1]
-	}
-	ejvw.frame++
-}
-
-func (ejvw *extJSONValueWriter) push(m mode) {
-	ejvw.advanceFrame()
-
-	ejvw.stack[ejvw.frame].mode = m
-}
-
-func (ejvw *extJSONValueWriter) pop() {
-	switch ejvw.stack[ejvw.frame].mode {
-	case mElement, mValue:
-		ejvw.frame--
-	case mDocument, mArray, mCodeWithScope:
-		ejvw.frame -= 2 // we pop twice to jump over the mElement: mDocument -> mElement -> mDocument/mTopLevel/etc...
-	}
-}
-
-func (ejvw *extJSONValueWriter) invalidTransitionErr(destination mode, name string, modes []mode) error {
-	te := TransitionError{
-		name:        name,
-		current:     ejvw.stack[ejvw.frame].mode,
-		destination: destination,
-		modes:       modes,
-		action:      "write",
-	}
-	if ejvw.frame != 0 {
-		te.parent = ejvw.stack[ejvw.frame-1].mode
-	}
-	return te
-}
-
-func (ejvw *extJSONValueWriter) ensureElementValue(destination mode, callerName string, addmodes ...mode) error {
-	switch ejvw.stack[ejvw.frame].mode {
-	case mElement, mValue:
-	default:
-		modes := []mode{mElement, mValue}
-		if addmodes != nil {
-			modes = append(modes, addmodes...)
-		}
-		return ejvw.invalidTransitionErr(destination, callerName, modes)
-	}
-
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) writeExtendedSingleValue(key string, value string, quotes bool) {
-	var s string
-	if quotes {
-		s = fmt.Sprintf(`{"$%s":"%s"}`, key, value)
-	} else {
-		s = fmt.Sprintf(`{"$%s":%s}`, key, value)
-	}
-
-	ejvw.buf = append(ejvw.buf, []byte(s)...)
-}
-
-func (ejvw *extJSONValueWriter) WriteArray() (ArrayWriter, error) {
-	if err := ejvw.ensureElementValue(mArray, "WriteArray"); err != nil {
-		return nil, err
-	}
-
-	ejvw.buf = append(ejvw.buf, '[')
-
-	ejvw.push(mArray)
-	return ejvw, nil
-}
-
-func (ejvw *extJSONValueWriter) WriteBinary(b []byte) error {
-	return ejvw.WriteBinaryWithSubtype(b, 0x00)
-}
-
-func (ejvw *extJSONValueWriter) WriteBinaryWithSubtype(b []byte, btype byte) error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteBinaryWithSubtype"); err != nil {
-		return err
-	}
-
-	var buf bytes.Buffer
-	buf.WriteString(`{"$binary":{"base64":"`)
-	buf.WriteString(base64.StdEncoding.EncodeToString(b))
-	buf.WriteString(fmt.Sprintf(`","subType":"%02x"}},`, btype))
-
-	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteBoolean(b bool) error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteBoolean"); err != nil {
-		return err
-	}
-
-	ejvw.buf = append(ejvw.buf, []byte(strconv.FormatBool(b))...)
-	ejvw.buf = append(ejvw.buf, ',')
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteCodeWithScope(code string) (DocumentWriter, error) {
-	if err := ejvw.ensureElementValue(mCodeWithScope, "WriteCodeWithScope"); err != nil {
-		return nil, err
-	}
-
-	var buf bytes.Buffer
-	buf.WriteString(`{"$code":`)
-	writeStringWithEscapes(code, &buf, ejvw.escapeHTML)
-	buf.WriteString(`,"$scope":{`)
-
-	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
-
-	ejvw.push(mCodeWithScope)
-	return ejvw, nil
-}
-
-func (ejvw *extJSONValueWriter) WriteDBPointer(ns string, oid ObjectID) error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteDBPointer"); err != nil {
-		return err
-	}
-
-	var buf bytes.Buffer
-	buf.WriteString(`{"$dbPointer":{"$ref":"`)
-	buf.WriteString(ns)
-	buf.WriteString(`","$id":{"$oid":"`)
-	buf.WriteString(oid.Hex())
-	buf.WriteString(`"}}},`)
-
-	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteDateTime(dt int64) error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteDateTime"); err != nil {
-		return err
-	}
-
-	t := time.Unix(dt/1e3, dt%1e3*1e6).UTC()
-
-	if ejvw.canonical || t.Year() < 1970 || t.Year() > 9999 {
-		s := fmt.Sprintf(`{"$numberLong":"%d"}`, dt)
-		ejvw.writeExtendedSingleValue("date", s, false)
-	} else {
-		ejvw.writeExtendedSingleValue("date", t.Format(rfc3339Milli), true)
-	}
-
-	ejvw.buf = append(ejvw.buf, ',')
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteDecimal128(d Decimal128) error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteDecimal128"); err != nil {
-		return err
-	}
-
-	ejvw.writeExtendedSingleValue("numberDecimal", d.String(), true)
-	ejvw.buf = append(ejvw.buf, ',')
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteDocument() (DocumentWriter, error) {
-	if ejvw.stack[ejvw.frame].mode == mTopLevel {
-		ejvw.buf = append(ejvw.buf, '{')
-		return ejvw, nil
-	}
-
-	if err := ejvw.ensureElementValue(mDocument, "WriteDocument", mTopLevel); err != nil {
-		return nil, err
-	}
-
-	ejvw.buf = append(ejvw.buf, '{')
-	ejvw.push(mDocument)
-	return ejvw, nil
-}
-
-func (ejvw *extJSONValueWriter) WriteDouble(f float64) error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteDouble"); err != nil {
-		return err
-	}
-
-	s := formatDouble(f)
-
-	if ejvw.canonical {
-		ejvw.writeExtendedSingleValue("numberDouble", s, true)
-	} else {
-		switch s {
-		case "Infinity":
-			fallthrough
-		case "-Infinity":
-			fallthrough
-		case "NaN":
-			s = fmt.Sprintf(`{"$numberDouble":"%s"}`, s)
-		}
-		ejvw.buf = append(ejvw.buf, []byte(s)...)
-	}
-
-	ejvw.buf = append(ejvw.buf, ',')
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteInt32(i int32) error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteInt32"); err != nil {
-		return err
-	}
-
-	s := strconv.FormatInt(int64(i), 10)
-
-	if ejvw.canonical {
-		ejvw.writeExtendedSingleValue("numberInt", s, true)
-	} else {
-		ejvw.buf = append(ejvw.buf, []byte(s)...)
-	}
-
-	ejvw.buf = append(ejvw.buf, ',')
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteInt64(i int64) error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteInt64"); err != nil {
-		return err
-	}
-
-	s := strconv.FormatInt(i, 10)
-
-	if ejvw.canonical {
-		ejvw.writeExtendedSingleValue("numberLong", s, true)
-	} else {
-		ejvw.buf = append(ejvw.buf, []byte(s)...)
-	}
-
-	ejvw.buf = append(ejvw.buf, ',')
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteJavascript(code string) error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteJavascript"); err != nil {
-		return err
-	}
-
-	var buf bytes.Buffer
-	writeStringWithEscapes(code, &buf, ejvw.escapeHTML)
-
-	ejvw.writeExtendedSingleValue("code", buf.String(), false)
-	ejvw.buf = append(ejvw.buf, ',')
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteMaxKey() error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteMaxKey"); err != nil {
-		return err
-	}
-
-	ejvw.writeExtendedSingleValue("maxKey", "1", false)
-	ejvw.buf = append(ejvw.buf, ',')
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteMinKey() error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteMinKey"); err != nil {
-		return err
-	}
-
-	ejvw.writeExtendedSingleValue("minKey", "1", false)
-	ejvw.buf = append(ejvw.buf, ',')
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteNull() error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteNull"); err != nil {
-		return err
-	}
-
-	ejvw.buf = append(ejvw.buf, []byte("null")...)
-	ejvw.buf = append(ejvw.buf, ',')
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteObjectID(oid ObjectID) error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteObjectID"); err != nil {
-		return err
-	}
-
-	ejvw.writeExtendedSingleValue("oid", oid.Hex(), true)
-	ejvw.buf = append(ejvw.buf, ',')
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteRegex(pattern string, options string) error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteRegex"); err != nil {
-		return err
-	}
-
-	options = sortStringAlphebeticAscending(options)
-	var buf bytes.Buffer
-	buf.WriteString(`{"$regularExpression":{"pattern":`)
-	writeStringWithEscapes(pattern, &buf, ejvw.escapeHTML)
-	buf.WriteString(`,"options":`)
-	writeStringWithEscapes(options, &buf, ejvw.escapeHTML)
-	buf.WriteString(`}},`)
-
-	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteString(s string) error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteString"); err != nil {
-		return err
-	}
-
-	var buf bytes.Buffer
-	writeStringWithEscapes(s, &buf, ejvw.escapeHTML)
-
-	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
-	ejvw.buf = append(ejvw.buf, ',')
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteSymbol(symbol string) error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteSymbol"); err != nil {
-		return err
-	}
-
-	var buf bytes.Buffer
-	writeStringWithEscapes(symbol, &buf, ejvw.escapeHTML)
-
-	ejvw.writeExtendedSingleValue("symbol", buf.String(), false)
-	ejvw.buf = append(ejvw.buf, ',')
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteTimestamp(t uint32, i uint32) error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteTimestamp"); err != nil {
-		return err
-	}
-
-	var buf bytes.Buffer
-	buf.WriteString(`{"$timestamp":{"t":`)
-	buf.WriteString(strconv.FormatUint(uint64(t), 10))
-	buf.WriteString(`,"i":`)
-	buf.WriteString(strconv.FormatUint(uint64(i), 10))
-	buf.WriteString(`}},`)
-
-	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteUndefined() error {
-	if err := ejvw.ensureElementValue(mode(0), "WriteUndefined"); err != nil {
-		return err
-	}
-
-	ejvw.writeExtendedSingleValue("undefined", "true", false)
-	ejvw.buf = append(ejvw.buf, ',')
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteDocumentElement(key string) (ValueWriter, error) {
-	switch ejvw.stack[ejvw.frame].mode {
-	case mDocument, mTopLevel, mCodeWithScope:
-		var buf bytes.Buffer
-		writeStringWithEscapes(key, &buf, ejvw.escapeHTML)
-
-		ejvw.buf = append(ejvw.buf, []byte(fmt.Sprintf(`%s:`, buf.String()))...)
-		ejvw.push(mElement)
-	default:
-		return nil, ejvw.invalidTransitionErr(mElement, "WriteDocumentElement", []mode{mDocument, mTopLevel, mCodeWithScope})
-	}
-
-	return ejvw, nil
-}
-
-func (ejvw *extJSONValueWriter) WriteDocumentEnd() error {
-	switch ejvw.stack[ejvw.frame].mode {
-	case mDocument, mTopLevel, mCodeWithScope:
-	default:
-		return fmt.Errorf("incorrect mode to end document: %s", ejvw.stack[ejvw.frame].mode)
-	}
-
-	// close the document
-	if ejvw.buf[len(ejvw.buf)-1] == ',' {
-		ejvw.buf[len(ejvw.buf)-1] = '}'
-	} else {
-		ejvw.buf = append(ejvw.buf, '}')
-	}
-
-	switch ejvw.stack[ejvw.frame].mode {
-	case mCodeWithScope:
-		ejvw.buf = append(ejvw.buf, '}')
-		fallthrough
-	case mDocument:
-		ejvw.buf = append(ejvw.buf, ',')
-	case mTopLevel:
-		// If the value writer has newlines enabled, end top-level documents with a newline so that
-		// multiple documents encoded to the same writer are separated by newlines. That matches the
-		// Go json.Encoder behavior and also works with NewExtJSONValueReader.
-		if ejvw.newlines {
-			ejvw.buf = append(ejvw.buf, '\n')
-		}
-		if ejvw.w != nil {
-			if _, err := ejvw.w.Write(ejvw.buf); err != nil {
-				return err
-			}
-			ejvw.buf = ejvw.buf[:0]
-		}
-	}
-
-	ejvw.pop()
-	return nil
-}
-
-func (ejvw *extJSONValueWriter) WriteArrayElement() (ValueWriter, error) {
-	switch ejvw.stack[ejvw.frame].mode {
-	case mArray:
-		ejvw.push(mValue)
-	default:
-		return nil, ejvw.invalidTransitionErr(mValue, "WriteArrayElement", []mode{mArray})
-	}
-
-	return ejvw, nil
-}
-
-func (ejvw *extJSONValueWriter) WriteArrayEnd() error {
-	switch ejvw.stack[ejvw.frame].mode {
-	case mArray:
-		// close the array
-		if ejvw.buf[len(ejvw.buf)-1] == ',' {
-			ejvw.buf[len(ejvw.buf)-1] = ']'
-		} else {
-			ejvw.buf = append(ejvw.buf, ']')
-		}
-
-		ejvw.buf = append(ejvw.buf, ',')
-
-		ejvw.pop()
-	default:
-		return fmt.Errorf("incorrect mode to end array: %s", ejvw.stack[ejvw.frame].mode)
-	}
-
-	return nil
-}
-
-func formatDouble(f float64) string {
-	var s string
-	switch {
-	case math.IsInf(f, 1):
-		s = "Infinity"
-	case math.IsInf(f, -1):
-		s = "-Infinity"
-	case math.IsNaN(f):
-		s = "NaN"
-	default:
-		// Print exactly one decimalType place for integers; otherwise, print as many are necessary to
-		// perfectly represent it.
-		s = strconv.FormatFloat(f, 'G', -1, 64)
-		if !strings.ContainsRune(s, 'E') && !strings.ContainsRune(s, '.') {
-			s += ".0"
-		}
-	}
-
-	return s
-}
-
-var hexChars = "0123456789abcdef"
-
-func writeStringWithEscapes(s string, buf *bytes.Buffer, escapeHTML bool) {
-	buf.WriteByte('"')
-	start := 0
-	for i := 0; i < len(s); {
-		if b := s[i]; b < utf8.RuneSelf {
-			if htmlSafeSet[b] || (!escapeHTML && safeSet[b]) {
-				i++
-				continue
-			}
-			if start < i {
-				buf.WriteString(s[start:i])
-			}
-			switch b {
-			case '\\', '"':
-				buf.WriteByte('\\')
-				buf.WriteByte(b)
-			case '\n':
-				buf.WriteByte('\\')
-				buf.WriteByte('n')
-			case '\r':
-				buf.WriteByte('\\')
-				buf.WriteByte('r')
-			case '\t':
-				buf.WriteByte('\\')
-				buf.WriteByte('t')
-			case '\b':
-				buf.WriteByte('\\')
-				buf.WriteByte('b')
-			case '\f':
-				buf.WriteByte('\\')
-				buf.WriteByte('f')
-			default:
-				// This encodes bytes < 0x20 except for \t, \n and \r.
-				// If escapeHTML is set, it also escapes <, >, and &
-				// because they can lead to security holes when
-				// user-controlled strings are rendered into JSON
-				// and served to some browsers.
-				buf.WriteString(`\u00`)
-				buf.WriteByte(hexChars[b>>4])
-				buf.WriteByte(hexChars[b&0xF])
-			}
-			i++
-			start = i
-			continue
-		}
-		c, size := utf8.DecodeRuneInString(s[i:])
-		if c == utf8.RuneError && size == 1 {
-			if start < i {
-				buf.WriteString(s[start:i])
-			}
-			buf.WriteString(`\ufffd`)
-			i += size
-			start = i
-			continue
-		}
-		// U+2028 is LINE SEPARATOR.
-		// U+2029 is PARAGRAPH SEPARATOR.
-		// They are both technically valid characters in JSON strings,
-		// but don't work in JSONP, which has to be evaluated as JavaScript,
-		// and can lead to security holes there. It is valid JSON to
-		// escape them, so we do so unconditionally.
-		// See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
-		if c == '\u2028' || c == '\u2029' {
-			if start < i {
-				buf.WriteString(s[start:i])
-			}
-			buf.WriteString(`\u202`)
-			buf.WriteByte(hexChars[c&0xF])
-			i += size
-			start = i
-			continue
-		}
-		i += size
-	}
-	if start < len(s) {
-		buf.WriteString(s[start:])
-	}
-	buf.WriteByte('"')
-}
-
-type sortableString []rune
-
-func (ss sortableString) Len() int {
-	return len(ss)
-}
-
-func (ss sortableString) Less(i, j int) bool {
-	return ss[i] < ss[j]
-}
-
-func (ss sortableString) Swap(i, j int) {
-	ss[i], ss[j] = ss[j], ss[i]
-}
-
-func sortStringAlphebeticAscending(s string) string {
-	ss := sortableString([]rune(s))
-	sort.Sort(ss)
-	return string([]rune(ss))
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/json_scanner.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/json_scanner.go
deleted file mode 100644
index b6eba79e..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/json_scanner.go
+++ /dev/null
@@ -1,533 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"strconv"
-	"unicode"
-	"unicode/utf16"
-)
-
-type jsonTokenType byte
-
-const (
-	jttBeginObject jsonTokenType = iota
-	jttEndObject
-	jttBeginArray
-	jttEndArray
-	jttColon
-	jttComma
-	jttInt32
-	jttInt64
-	jttDouble
-	jttString
-	jttBool
-	jttNull
-	jttEOF
-)
-
-type jsonToken struct {
-	t jsonTokenType
-	v interface{}
-	p int
-}
-
-type jsonScanner struct {
-	r           io.Reader
-	buf         []byte
-	pos         int
-	lastReadErr error
-}
-
-// nextToken returns the next JSON token if one exists. A token is a character
-// of the JSON grammar, a number, a string, or a literal.
-func (js *jsonScanner) nextToken() (*jsonToken, error) {
-	c, err := js.readNextByte()
-
-	// keep reading until a non-space is encountered (break on read error or EOF)
-	for isWhiteSpace(c) && err == nil {
-		c, err = js.readNextByte()
-	}
-
-	if errors.Is(err, io.EOF) {
-		return &jsonToken{t: jttEOF}, nil
-	} else if err != nil {
-		return nil, err
-	}
-
-	// switch on the character
-	switch c {
-	case '{':
-		return &jsonToken{t: jttBeginObject, v: byte('{'), p: js.pos - 1}, nil
-	case '}':
-		return &jsonToken{t: jttEndObject, v: byte('}'), p: js.pos - 1}, nil
-	case '[':
-		return &jsonToken{t: jttBeginArray, v: byte('['), p: js.pos - 1}, nil
-	case ']':
-		return &jsonToken{t: jttEndArray, v: byte(']'), p: js.pos - 1}, nil
-	case ':':
-		return &jsonToken{t: jttColon, v: byte(':'), p: js.pos - 1}, nil
-	case ',':
-		return &jsonToken{t: jttComma, v: byte(','), p: js.pos - 1}, nil
-	case '"': // RFC-8259 only allows for double quotes (") not single (')
-		return js.scanString()
-	default:
-		// check if it's a number
-		switch {
-		case c == '-' || isDigit(c):
-			return js.scanNumber(c)
-		case c == 't' || c == 'f' || c == 'n':
-			// maybe a literal
-			return js.scanLiteral(c)
-		default:
-			return nil, fmt.Errorf("invalid JSON input. Position: %d. Character: %c", js.pos-1, c)
-		}
-	}
-}
-
-// readNextByte attempts to read the next byte from the buffer. If the buffer
-// has been exhausted, this function calls readIntoBuf, thus refilling the
-// buffer and resetting the read position to 0
-func (js *jsonScanner) readNextByte() (byte, error) {
-	if js.pos >= len(js.buf) {
-		err := js.readIntoBuf()
-
-		if err != nil {
-			return 0, err
-		}
-	}
-
-	b := js.buf[js.pos]
-	js.pos++
-
-	return b, nil
-}
-
-// readNNextBytes reads n bytes into dst, starting at offset
-func (js *jsonScanner) readNNextBytes(dst []byte, n, offset int) error {
-	var err error
-
-	for i := 0; i < n; i++ {
-		dst[i+offset], err = js.readNextByte()
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// readIntoBuf reads up to 512 bytes from the scanner's io.Reader into the buffer
-func (js *jsonScanner) readIntoBuf() error {
-	if js.lastReadErr != nil {
-		js.buf = js.buf[:0]
-		js.pos = 0
-		return js.lastReadErr
-	}
-
-	if cap(js.buf) == 0 {
-		js.buf = make([]byte, 0, 512)
-	}
-
-	n, err := js.r.Read(js.buf[:cap(js.buf)])
-	if err != nil {
-		js.lastReadErr = err
-		if n > 0 {
-			err = nil
-		}
-	}
-	js.buf = js.buf[:n]
-	js.pos = 0
-
-	return err
-}
-
-func isWhiteSpace(c byte) bool {
-	return c == ' ' || c == '\t' || c == '\r' || c == '\n'
-}
-
-func isDigit(c byte) bool {
-	return unicode.IsDigit(rune(c))
-}
-
-func isValueTerminator(c byte) bool {
-	return c == ',' || c == '}' || c == ']' || isWhiteSpace(c)
-}
-
-// getu4 decodes the 4-byte hex sequence from the beginning of s, returning the hex value as a rune,
-// or it returns -1. Note that the "\u" from the unicode escape sequence should not be present.
-// It is copied and lightly modified from the Go JSON decode function at
-// https://github.com/golang/go/blob/1b0a0316802b8048d69da49dc23c5a5ab08e8ae8/src/encoding/json/decode.go#L1169-L1188
-func getu4(s []byte) rune {
-	if len(s) < 4 {
-		return -1
-	}
-	var r rune
-	for _, c := range s[:4] {
-		switch {
-		case '0' <= c && c <= '9':
-			c -= '0'
-		case 'a' <= c && c <= 'f':
-			c = c - 'a' + 10
-		case 'A' <= c && c <= 'F':
-			c = c - 'A' + 10
-		default:
-			return -1
-		}
-		r = r*16 + rune(c)
-	}
-	return r
-}
-
-// scanString reads from an opening '"' to a closing '"' and handles escaped characters
-func (js *jsonScanner) scanString() (*jsonToken, error) {
-	var b bytes.Buffer
-	var c byte
-	var err error
-
-	p := js.pos - 1
-
-	for {
-		c, err = js.readNextByte()
-		if err != nil {
-			if errors.Is(err, io.EOF) {
-				return nil, errors.New("end of input in JSON string")
-			}
-			return nil, err
-		}
-
-	evalNextChar:
-		switch c {
-		case '\\':
-			c, err = js.readNextByte()
-			if err != nil {
-				if errors.Is(err, io.EOF) {
-					return nil, errors.New("end of input in JSON string")
-				}
-				return nil, err
-			}
-
-		evalNextEscapeChar:
-			switch c {
-			case '"', '\\', '/':
-				b.WriteByte(c)
-			case 'b':
-				b.WriteByte('\b')
-			case 'f':
-				b.WriteByte('\f')
-			case 'n':
-				b.WriteByte('\n')
-			case 'r':
-				b.WriteByte('\r')
-			case 't':
-				b.WriteByte('\t')
-			case 'u':
-				us := make([]byte, 4)
-				err = js.readNNextBytes(us, 4, 0)
-				if err != nil {
-					return nil, fmt.Errorf("invalid unicode sequence in JSON string: %s", us)
-				}
-
-				rn := getu4(us)
-
-				// If the rune we just decoded is the high or low value of a possible surrogate pair,
-				// try to decode the next sequence as the low value of a surrogate pair. We're
-				// expecting the next sequence to be another Unicode escape sequence (e.g. "\uDD1E"),
-				// but need to handle cases where the input is not a valid surrogate pair.
-				// For more context on unicode surrogate pairs, see:
-				// https://www.christianfscott.com/rust-chars-vs-go-runes/
-				// https://www.unicode.org/glossary/#high_surrogate_code_point
-				if utf16.IsSurrogate(rn) {
-					c, err = js.readNextByte()
-					if err != nil {
-						if errors.Is(err, io.EOF) {
-							return nil, errors.New("end of input in JSON string")
-						}
-						return nil, err
-					}
-
-					// If the next value isn't the beginning of a backslash escape sequence, write
-					// the Unicode replacement character for the surrogate value and goto the
-					// beginning of the next char eval block.
-					if c != '\\' {
-						b.WriteRune(unicode.ReplacementChar)
-						goto evalNextChar
-					}
-
-					c, err = js.readNextByte()
-					if err != nil {
-						if errors.Is(err, io.EOF) {
-							return nil, errors.New("end of input in JSON string")
-						}
-						return nil, err
-					}
-
-					// If the next value isn't the beginning of a unicode escape sequence, write the
-					// Unicode replacement character for the surrogate value and goto the beginning
-					// of the next escape char eval block.
-					if c != 'u' {
-						b.WriteRune(unicode.ReplacementChar)
-						goto evalNextEscapeChar
-					}
-
-					err = js.readNNextBytes(us, 4, 0)
-					if err != nil {
-						return nil, fmt.Errorf("invalid unicode sequence in JSON string: %s", us)
-					}
-
-					rn2 := getu4(us)
-
-					// Try to decode the pair of runes as a utf16 surrogate pair. If that fails, write
-					// the Unicode replacement character for the surrogate value and the 2nd decoded rune.
-					if rnPair := utf16.DecodeRune(rn, rn2); rnPair != unicode.ReplacementChar {
-						b.WriteRune(rnPair)
-					} else {
-						b.WriteRune(unicode.ReplacementChar)
-						b.WriteRune(rn2)
-					}
-
-					break
-				}
-
-				b.WriteRune(rn)
-			default:
-				return nil, fmt.Errorf("invalid escape sequence in JSON string '\\%c'", c)
-			}
-		case '"':
-			return &jsonToken{t: jttString, v: b.String(), p: p}, nil
-		default:
-			b.WriteByte(c)
-		}
-	}
-}
-
-// scanLiteral reads an unquoted sequence of characters and determines if it is one of
-// three valid JSON literals (true, false, null); if so, it returns the appropriate
-// jsonToken; otherwise, it returns an error
-func (js *jsonScanner) scanLiteral(first byte) (*jsonToken, error) {
-	p := js.pos - 1
-
-	lit := make([]byte, 4)
-	lit[0] = first
-
-	err := js.readNNextBytes(lit, 3, 1)
-	if err != nil {
-		return nil, err
-	}
-
-	c5, err := js.readNextByte()
-
-	switch {
-	case bytes.Equal([]byte("true"), lit) && (isValueTerminator(c5) || errors.Is(err, io.EOF)):
-		js.pos = int(math.Max(0, float64(js.pos-1)))
-		return &jsonToken{t: jttBool, v: true, p: p}, nil
-	case bytes.Equal([]byte("null"), lit) && (isValueTerminator(c5) || errors.Is(err, io.EOF)):
-		js.pos = int(math.Max(0, float64(js.pos-1)))
-		return &jsonToken{t: jttNull, v: nil, p: p}, nil
-	case bytes.Equal([]byte("fals"), lit):
-		if c5 == 'e' {
-			c5, err = js.readNextByte()
-
-			if isValueTerminator(c5) || errors.Is(err, io.EOF) {
-				js.pos = int(math.Max(0, float64(js.pos-1)))
-				return &jsonToken{t: jttBool, v: false, p: p}, nil
-			}
-		}
-	}
-
-	return nil, fmt.Errorf("invalid JSON literal. Position: %d, literal: %s", p, lit)
-}
-
-type numberScanState byte
-
-const (
-	nssSawLeadingMinus numberScanState = iota
-	nssSawLeadingZero
-	nssSawIntegerDigits
-	nssSawDecimalPoint
-	nssSawFractionDigits
-	nssSawExponentLetter
-	nssSawExponentSign
-	nssSawExponentDigits
-	nssDone
-	nssInvalid
-)
-
-// scanNumber reads a JSON number (according to RFC-8259)
-func (js *jsonScanner) scanNumber(first byte) (*jsonToken, error) {
-	var b bytes.Buffer
-	var s numberScanState
-	var c byte
-	var err error
-
-	t := jttInt64 // assume it's an int64 until the type can be determined
-	start := js.pos - 1
-
-	b.WriteByte(first)
-
-	switch first {
-	case '-':
-		s = nssSawLeadingMinus
-	case '0':
-		s = nssSawLeadingZero
-	default:
-		s = nssSawIntegerDigits
-	}
-
-	for {
-		c, err = js.readNextByte()
-
-		if err != nil && !errors.Is(err, io.EOF) {
-			return nil, err
-		}
-
-		switch s {
-		case nssSawLeadingMinus:
-			switch c {
-			case '0':
-				s = nssSawLeadingZero
-				b.WriteByte(c)
-			default:
-				if isDigit(c) {
-					s = nssSawIntegerDigits
-					b.WriteByte(c)
-				} else {
-					s = nssInvalid
-				}
-			}
-		case nssSawLeadingZero:
-			switch c {
-			case '.':
-				s = nssSawDecimalPoint
-				b.WriteByte(c)
-			case 'e', 'E':
-				s = nssSawExponentLetter
-				b.WriteByte(c)
-			case '}', ']', ',':
-				s = nssDone
-			default:
-				if isWhiteSpace(c) || errors.Is(err, io.EOF) {
-					s = nssDone
-				} else {
-					s = nssInvalid
-				}
-			}
-		case nssSawIntegerDigits:
-			switch c {
-			case '.':
-				s = nssSawDecimalPoint
-				b.WriteByte(c)
-			case 'e', 'E':
-				s = nssSawExponentLetter
-				b.WriteByte(c)
-			case '}', ']', ',':
-				s = nssDone
-			default:
-				switch {
-				case isWhiteSpace(c) || errors.Is(err, io.EOF):
-					s = nssDone
-				case isDigit(c):
-					s = nssSawIntegerDigits
-					b.WriteByte(c)
-				default:
-					s = nssInvalid
-				}
-			}
-		case nssSawDecimalPoint:
-			t = jttDouble
-			if isDigit(c) {
-				s = nssSawFractionDigits
-				b.WriteByte(c)
-			} else {
-				s = nssInvalid
-			}
-		case nssSawFractionDigits:
-			switch c {
-			case 'e', 'E':
-				s = nssSawExponentLetter
-				b.WriteByte(c)
-			case '}', ']', ',':
-				s = nssDone
-			default:
-				switch {
-				case isWhiteSpace(c) || errors.Is(err, io.EOF):
-					s = nssDone
-				case isDigit(c):
-					s = nssSawFractionDigits
-					b.WriteByte(c)
-				default:
-					s = nssInvalid
-				}
-			}
-		case nssSawExponentLetter:
-			t = jttDouble
-			switch c {
-			case '+', '-':
-				s = nssSawExponentSign
-				b.WriteByte(c)
-			default:
-				if isDigit(c) {
-					s = nssSawExponentDigits
-					b.WriteByte(c)
-				} else {
-					s = nssInvalid
-				}
-			}
-		case nssSawExponentSign:
-			if isDigit(c) {
-				s = nssSawExponentDigits
-				b.WriteByte(c)
-			} else {
-				s = nssInvalid
-			}
-		case nssSawExponentDigits:
-			switch c {
-			case '}', ']', ',':
-				s = nssDone
-			default:
-				switch {
-				case isWhiteSpace(c) || errors.Is(err, io.EOF):
-					s = nssDone
-				case isDigit(c):
-					s = nssSawExponentDigits
-					b.WriteByte(c)
-				default:
-					s = nssInvalid
-				}
-			}
-		}
-
-		switch s {
-		case nssInvalid:
-			return nil, fmt.Errorf("invalid JSON number. Position: %d", start)
-		case nssDone:
-			js.pos = int(math.Max(0, float64(js.pos-1)))
-			if t != jttDouble {
-				v, err := strconv.ParseInt(b.String(), 10, 64)
-				if err == nil {
-					if v < math.MinInt32 || v > math.MaxInt32 {
-						return &jsonToken{t: jttInt64, v: v, p: start}, nil
-					}
-
-					return &jsonToken{t: jttInt32, v: int32(v), p: start}, nil
-				}
-			}
-
-			v, err := strconv.ParseFloat(b.String(), 64)
-			if err != nil {
-				return nil, err
-			}
-
-			return &jsonToken{t: jttDouble, v: v, p: start}, nil
-		}
-	}
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/map_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/map_codec.go
deleted file mode 100644
index 4f33484b..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/map_codec.go
+++ /dev/null
@@ -1,292 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"encoding"
-	"errors"
-	"fmt"
-	"reflect"
-	"strconv"
-)
-
-// mapCodec is the Codec used for map values.
-type mapCodec struct {
-	// DecodeZerosMap causes DecodeValue to delete any existing values from Go maps in the destination
-	// value passed to Decode before unmarshaling BSON documents into them.
-	decodeZerosMap bool
-
-	// EncodeNilAsEmpty causes EncodeValue to marshal nil Go maps as empty BSON documents instead of
-	// BSON null.
-	encodeNilAsEmpty bool
-
-	// EncodeKeysWithStringer causes the Encoder to convert Go map keys to BSON document field name
-	// strings using fmt.Sprintf() instead of the default string conversion logic.
-	encodeKeysWithStringer bool
-}
-
-// KeyMarshaler is the interface implemented by an object that can marshal itself into a string key.
-// This applies to types used as map keys and is similar to encoding.TextMarshaler.
-type KeyMarshaler interface {
-	MarshalKey() (key string, err error)
-}
-
-// KeyUnmarshaler is the interface implemented by an object that can unmarshal a string representation
-// of itself. This applies to types used as map keys and is similar to encoding.TextUnmarshaler.
-//
-// UnmarshalKey must be able to decode the form generated by MarshalKey.
-// UnmarshalKey must copy the text if it wishes to retain the text
-// after returning.
-type KeyUnmarshaler interface {
-	UnmarshalKey(key string) error
-}
-
-// EncodeValue is the ValueEncoder for map[*]* types.
-func (mc *mapCodec) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Kind() != reflect.Map {
-		return ValueEncoderError{Name: "MapEncodeValue", Kinds: []reflect.Kind{reflect.Map}, Received: val}
-	}
-
-	if val.IsNil() && !mc.encodeNilAsEmpty && !ec.nilMapAsEmpty {
-		// If we have a nil map but we can't WriteNull, that means we're probably trying to encode
-		// to a TopLevel document. We can't currently tell if this is what actually happened, but if
-		// there's a deeper underlying problem, the error will also be returned from WriteDocument,
-		// so just continue. The operations on a map reflection value are valid, so we can call
-		// MapKeys within mapEncodeValue without a problem.
-		err := vw.WriteNull()
-		if err == nil {
-			return nil
-		}
-	}
-
-	dw, err := vw.WriteDocument()
-	if err != nil {
-		return err
-	}
-
-	err = mc.encodeMapElements(ec, dw, val, nil)
-	if err != nil {
-		return err
-	}
-	return dw.WriteDocumentEnd()
-}
-
-// encodeMapElements handles encoding of the values of a map. The collisionFn returns
-// true if the provided key exists, this is mainly used for inline maps in the
-// struct codec.
-func (mc *mapCodec) encodeMapElements(ec EncodeContext, dw DocumentWriter, val reflect.Value, collisionFn func(string) bool) error {
-
-	elemType := val.Type().Elem()
-	encoder, err := ec.LookupEncoder(elemType)
-	if err != nil && elemType.Kind() != reflect.Interface {
-		return err
-	}
-
-	keys := val.MapKeys()
-	for _, key := range keys {
-		keyStr, err := mc.encodeKey(key, ec.stringifyMapKeysWithFmt)
-		if err != nil {
-			return err
-		}
-
-		if collisionFn != nil && collisionFn(keyStr) {
-			return fmt.Errorf("Key %s of inlined map conflicts with a struct field name", key)
-		}
-
-		currEncoder, currVal, lookupErr := lookupElementEncoder(ec, encoder, val.MapIndex(key))
-		if lookupErr != nil && !errors.Is(lookupErr, errInvalidValue) {
-			return lookupErr
-		}
-
-		vw, err := dw.WriteDocumentElement(keyStr)
-		if err != nil {
-			return err
-		}
-
-		if errors.Is(lookupErr, errInvalidValue) {
-			err = vw.WriteNull()
-			if err != nil {
-				return err
-			}
-			continue
-		}
-
-		err = currEncoder.EncodeValue(ec, vw, currVal)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// DecodeValue is the ValueDecoder for map[string/decimal]* types.
-func (mc *mapCodec) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if val.Kind() != reflect.Map || (!val.CanSet() && val.IsNil()) {
-		return ValueDecoderError{Name: "MapDecodeValue", Kinds: []reflect.Kind{reflect.Map}, Received: val}
-	}
-
-	switch vrType := vr.Type(); vrType {
-	case Type(0), TypeEmbeddedDocument:
-	case TypeNull:
-		val.Set(reflect.Zero(val.Type()))
-		return vr.ReadNull()
-	case TypeUndefined:
-		val.Set(reflect.Zero(val.Type()))
-		return vr.ReadUndefined()
-	default:
-		return fmt.Errorf("cannot decode %v into a %s", vrType, val.Type())
-	}
-
-	dr, err := vr.ReadDocument()
-	if err != nil {
-		return err
-	}
-
-	if val.IsNil() {
-		val.Set(reflect.MakeMap(val.Type()))
-	}
-
-	if val.Len() > 0 && (mc.decodeZerosMap || dc.zeroMaps) {
-		clearMap(val)
-	}
-
-	eType := val.Type().Elem()
-	decoder, err := dc.LookupDecoder(eType)
-	if err != nil {
-		return err
-	}
-
-	keyType := val.Type().Key()
-
-	for {
-		key, vr, err := dr.ReadElement()
-		if errors.Is(err, ErrEOD) {
-			break
-		}
-		if err != nil {
-			return err
-		}
-
-		k, err := mc.decodeKey(key, keyType)
-		if err != nil {
-			return err
-		}
-
-		elem, err := decodeTypeOrValueWithInfo(decoder, dc, vr, eType)
-		if err != nil {
-			return newDecodeError(key, err)
-		}
-
-		val.SetMapIndex(k, elem)
-	}
-	return nil
-}
-
-func clearMap(m reflect.Value) {
-	var none reflect.Value
-	for _, k := range m.MapKeys() {
-		m.SetMapIndex(k, none)
-	}
-}
-
-func (mc *mapCodec) encodeKey(val reflect.Value, encodeKeysWithStringer bool) (string, error) {
-	if mc.encodeKeysWithStringer || encodeKeysWithStringer {
-		return fmt.Sprint(val), nil
-	}
-
-	// keys of any string type are used directly
-	if val.Kind() == reflect.String {
-		return val.String(), nil
-	}
-	// KeyMarshalers are marshaled
-	if km, ok := val.Interface().(KeyMarshaler); ok {
-		if val.Kind() == reflect.Ptr && val.IsNil() {
-			return "", nil
-		}
-		buf, err := km.MarshalKey()
-		if err == nil {
-			return buf, nil
-		}
-		return "", err
-	}
-	// keys implement encoding.TextMarshaler are marshaled.
-	if km, ok := val.Interface().(encoding.TextMarshaler); ok {
-		if val.Kind() == reflect.Ptr && val.IsNil() {
-			return "", nil
-		}
-
-		buf, err := km.MarshalText()
-		if err != nil {
-			return "", err
-		}
-
-		return string(buf), nil
-	}
-
-	switch val.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return strconv.FormatInt(val.Int(), 10), nil
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		return strconv.FormatUint(val.Uint(), 10), nil
-	}
-	return "", fmt.Errorf("unsupported key type: %v", val.Type())
-}
-
-var keyUnmarshalerType = reflect.TypeOf((*KeyUnmarshaler)(nil)).Elem()
-var textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
-
-func (mc *mapCodec) decodeKey(key string, keyType reflect.Type) (reflect.Value, error) {
-	keyVal := reflect.ValueOf(key)
-	var err error
-	switch {
-	// First, if EncodeKeysWithStringer is not enabled, try to decode withKeyUnmarshaler
-	case !mc.encodeKeysWithStringer && reflect.PtrTo(keyType).Implements(keyUnmarshalerType):
-		keyVal = reflect.New(keyType)
-		v := keyVal.Interface().(KeyUnmarshaler)
-		err = v.UnmarshalKey(key)
-		keyVal = keyVal.Elem()
-	// Try to decode encoding.TextUnmarshalers.
-	case reflect.PtrTo(keyType).Implements(textUnmarshalerType):
-		keyVal = reflect.New(keyType)
-		v := keyVal.Interface().(encoding.TextUnmarshaler)
-		err = v.UnmarshalText([]byte(key))
-		keyVal = keyVal.Elem()
-	// Otherwise, go to type specific behavior
-	default:
-		switch keyType.Kind() {
-		case reflect.String:
-			keyVal = reflect.ValueOf(key).Convert(keyType)
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			n, parseErr := strconv.ParseInt(key, 10, 64)
-			if parseErr != nil || reflect.Zero(keyType).OverflowInt(n) {
-				err = fmt.Errorf("failed to unmarshal number key %v", key)
-			}
-			keyVal = reflect.ValueOf(n).Convert(keyType)
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-			n, parseErr := strconv.ParseUint(key, 10, 64)
-			if parseErr != nil || reflect.Zero(keyType).OverflowUint(n) {
-				err = fmt.Errorf("failed to unmarshal number key %v", key)
-				break
-			}
-			keyVal = reflect.ValueOf(n).Convert(keyType)
-		case reflect.Float32, reflect.Float64:
-			if mc.encodeKeysWithStringer {
-				parsed, err := strconv.ParseFloat(key, 64)
-				if err != nil {
-					return keyVal, fmt.Errorf("Map key is defined to be a decimal type (%v) but got error %w", keyType.Kind(), err)
-				}
-				keyVal = reflect.ValueOf(parsed)
-				break
-			}
-			fallthrough
-		default:
-			return keyVal, fmt.Errorf("unsupported key type: %v", keyType)
-		}
-	}
-	return keyVal, err
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/marshal.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/marshal.go
deleted file mode 100644
index 88a85c0f..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/marshal.go
+++ /dev/null
@@ -1,191 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"bytes"
-	"encoding/json"
-	"sync"
-)
-
-const defaultDstCap = 256
-
-var extjPool = sync.Pool{
-	New: func() interface{} {
-		return new(extJSONValueWriter)
-	},
-}
-
-// Marshaler is the interface implemented by types that can marshal themselves
-// into a valid BSON document.
-//
-// Implementations of Marshaler must return a full BSON document. To create
-// custom BSON marshaling behavior for individual values in a BSON document,
-// implement the ValueMarshaler interface instead.
-type Marshaler interface {
-	MarshalBSON() ([]byte, error)
-}
-
-// ValueMarshaler is the interface implemented by types that can marshal
-// themselves into a valid BSON value. The format of the returned bytes must
-// match the returned type.
-//
-// Implementations of ValueMarshaler must return an individual BSON value. To
-// create custom BSON marshaling behavior for an entire BSON document, implement
-// the Marshaler interface instead.
-type ValueMarshaler interface {
-	MarshalBSONValue() (typ byte, data []byte, err error)
-}
-
-// Pool of buffers for marshalling BSON.
-var bufPool = sync.Pool{
-	New: func() interface{} {
-		return new(bytes.Buffer)
-	},
-}
-
-// Marshal returns the BSON encoding of val as a BSON document. If val is not a type that can be transformed into a
-// document, MarshalValue should be used instead.
-//
-// Marshal will use the default registry created by NewRegistry to recursively
-// marshal val into a []byte. Marshal will inspect struct tags and alter the
-// marshaling process accordingly.
-func Marshal(val interface{}) ([]byte, error) {
-	sw := bufPool.Get().(*bytes.Buffer)
-	defer func() {
-		// Proper usage of a sync.Pool requires each entry to have approximately
-		// the same memory cost. To obtain this property when the stored type
-		// contains a variably-sized buffer, we add a hard limit on the maximum
-		// buffer to place back in the pool. We limit the size to 16MiB because
-		// that's the maximum wire message size supported by any current MongoDB
-		// server.
-		//
-		// Comment based on
-		// https://cs.opensource.google/go/go/+/refs/tags/go1.19:src/fmt/print.go;l=147
-		//
-		// Recycle byte slices that are smaller than 16MiB and at least half
-		// occupied.
-		if sw.Cap() < 16*1024*1024 && sw.Cap()/2 < sw.Len() {
-			bufPool.Put(sw)
-		}
-	}()
-	sw.Reset()
-
-	vw := getDocumentWriter(sw)
-	defer putDocumentWriter(vw)
-
-	enc := encPool.Get().(*Encoder)
-	defer encPool.Put(enc)
-	enc.Reset(vw)
-	enc.SetRegistry(defaultRegistry)
-	err := enc.Encode(val)
-	if err != nil {
-		return nil, err
-	}
-	buf := append([]byte(nil), sw.Bytes()...)
-	return buf, nil
-}
-
-// MarshalValue returns the BSON encoding of val.
-//
-// MarshalValue will use bson.NewRegistry() to transform val into a BSON value. If val is a struct, this function will
-// inspect struct tags and alter the marshalling process accordingly.
-func MarshalValue(val interface{}) (Type, []byte, error) {
-	sw := bufPool.Get().(*bytes.Buffer)
-	defer func() {
-		// Proper usage of a sync.Pool requires each entry to have approximately
-		// the same memory cost. To obtain this property when the stored type
-		// contains a variably-sized buffer, we add a hard limit on the maximum
-		// buffer to place back in the pool. We limit the size to 16MiB because
-		// that's the maximum wire message size supported by any current MongoDB
-		// server.
-		//
-		// Comment based on
-		// https://cs.opensource.google/go/go/+/refs/tags/go1.19:src/fmt/print.go;l=147
-		//
-		// Recycle byte slices that are smaller than 16MiB and at least half
-		// occupied.
-		if sw.Cap() < 16*1024*1024 && sw.Cap()/2 < sw.Len() {
-			bufPool.Put(sw)
-		}
-	}()
-	sw.Reset()
-	vwFlusher := newDocumentWriter(sw)
-	vw, err := vwFlusher.WriteDocumentElement("")
-	if err != nil {
-		return 0, nil, err
-	}
-
-	// get an Encoder and encode the value
-	enc := encPool.Get().(*Encoder)
-	defer encPool.Put(enc)
-	enc.Reset(vw)
-	enc.SetRegistry(defaultRegistry)
-	if err := enc.Encode(val); err != nil {
-		return 0, nil, err
-	}
-
-	// flush the bytes written because we cannot guarantee that a full document has been written
-	// after the flush, *sw will be in the format
-	// [value type, 0 (null byte to indicate end of empty element name), value bytes..]
-	if err := vwFlusher.Flush(); err != nil {
-		return 0, nil, err
-	}
-	typ := sw.Next(2)
-	clone := append([]byte{}, sw.Bytes()...) // Don't hand out a shared reference to byte buffer bytes
-	// and fully copy the data. The byte buffer is (potentially) reused
-	// and handing out only a reference to the bytes may lead to race-conditions with the buffer.
-	return Type(typ[0]), clone, nil
-}
-
-// MarshalExtJSON returns the extended JSON encoding of val.
-func MarshalExtJSON(val interface{}, canonical, escapeHTML bool) ([]byte, error) {
-	sw := sliceWriter(make([]byte, 0, defaultDstCap))
-	ejvw := extjPool.Get().(*extJSONValueWriter)
-	ejvw.reset(sw, canonical, escapeHTML)
-	ejvw.w = &sw
-	defer func() {
-		ejvw.buf = nil
-		ejvw.w = nil
-		extjPool.Put(ejvw)
-	}()
-
-	enc := encPool.Get().(*Encoder)
-	defer encPool.Put(enc)
-
-	enc.Reset(ejvw)
-	enc.ec = EncodeContext{Registry: defaultRegistry}
-
-	err := enc.Encode(val)
-	if err != nil {
-		return nil, err
-	}
-
-	return sw, nil
-}
-
-// IndentExtJSON will prefix and indent the provided extended JSON src and append it to dst.
-func IndentExtJSON(dst *bytes.Buffer, src []byte, prefix, indent string) error {
-	return json.Indent(dst, src, prefix, indent)
-}
-
-// MarshalExtJSONIndent returns the extended JSON encoding of val with each line with prefixed
-// and indented.
-func MarshalExtJSONIndent(val interface{}, canonical, escapeHTML bool, prefix, indent string) ([]byte, error) {
-	marshaled, err := MarshalExtJSON(val, canonical, escapeHTML)
-	if err != nil {
-		return nil, err
-	}
-
-	var buf bytes.Buffer
-	err = IndentExtJSON(&buf, marshaled, prefix, indent)
-	if err != nil {
-		return nil, err
-	}
-
-	return buf.Bytes(), nil
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/mgoregistry.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/mgoregistry.go
deleted file mode 100644
index f42935e5..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/mgoregistry.go
+++ /dev/null
@@ -1,209 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"errors"
-	"reflect"
-)
-
-var (
-	// ErrMgoSetZero may be returned from a SetBSON method to have the value set to its respective zero value.
-	ErrMgoSetZero = errors.New("set to zero")
-
-	tInt            = reflect.TypeOf(int(0))
-	tM              = reflect.TypeOf(M{})
-	tInterfaceSlice = reflect.TypeOf([]interface{}{})
-	tGetter         = reflect.TypeOf((*getter)(nil)).Elem()
-	tSetter         = reflect.TypeOf((*setter)(nil)).Elem()
-)
-
-// NewMgoRegistry creates a new bson.Registry configured with the default encoders and decoders.
-func NewMgoRegistry() *Registry {
-	mapCodec := &mapCodec{
-		decodeZerosMap:         true,
-		encodeNilAsEmpty:       true,
-		encodeKeysWithStringer: true,
-	}
-	structCodec := &structCodec{
-		inlineMapEncoder:        mapCodec,
-		decodeZeroStruct:        true,
-		encodeOmitDefaultStruct: true,
-		allowUnexportedFields:   true,
-	}
-	uintCodec := &uintCodec{encodeToMinSize: true}
-
-	reg := NewRegistry()
-	reg.RegisterTypeDecoder(tEmpty, &emptyInterfaceCodec{decodeBinaryAsSlice: true})
-	reg.RegisterKindDecoder(reflect.String, ValueDecoderFunc(mgoStringDecodeValue))
-	reg.RegisterKindDecoder(reflect.Struct, structCodec)
-	reg.RegisterKindDecoder(reflect.Map, mapCodec)
-	reg.RegisterTypeEncoder(tByteSlice, &byteSliceCodec{encodeNilAsEmpty: true})
-	reg.RegisterKindEncoder(reflect.Struct, structCodec)
-	reg.RegisterKindEncoder(reflect.Slice, &sliceCodec{encodeNilAsEmpty: true})
-	reg.RegisterKindEncoder(reflect.Map, mapCodec)
-	reg.RegisterKindEncoder(reflect.Uint, uintCodec)
-	reg.RegisterKindEncoder(reflect.Uint8, uintCodec)
-	reg.RegisterKindEncoder(reflect.Uint16, uintCodec)
-	reg.RegisterKindEncoder(reflect.Uint32, uintCodec)
-	reg.RegisterKindEncoder(reflect.Uint64, uintCodec)
-	reg.RegisterTypeMapEntry(TypeInt32, tInt)
-	reg.RegisterTypeMapEntry(TypeDateTime, tTime)
-	reg.RegisterTypeMapEntry(TypeArray, tInterfaceSlice)
-	reg.RegisterTypeMapEntry(Type(0), tM)
-	reg.RegisterTypeMapEntry(TypeEmbeddedDocument, tM)
-	reg.RegisterInterfaceEncoder(tGetter, ValueEncoderFunc(getterEncodeValue))
-	reg.RegisterInterfaceDecoder(tSetter, ValueDecoderFunc(setterDecodeValue))
-	return reg
-}
-
-// NewRespectNilValuesMgoRegistry creates a new bson.Registry configured to behave like mgo/bson
-// with RespectNilValues set to true.
-func NewRespectNilValuesMgoRegistry() *Registry {
-	mapCodec := &mapCodec{
-		decodeZerosMap: true,
-	}
-
-	reg := NewMgoRegistry()
-	reg.RegisterKindDecoder(reflect.Map, mapCodec)
-	reg.RegisterTypeEncoder(tByteSlice, &byteSliceCodec{encodeNilAsEmpty: false})
-	reg.RegisterKindEncoder(reflect.Slice, &sliceCodec{})
-	reg.RegisterKindEncoder(reflect.Map, mapCodec)
-	return reg
-}
-
-func mgoStringDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if val.Kind() != reflect.String {
-		return ValueDecoderError{
-			Name:     "StringDecodeValue",
-			Kinds:    []reflect.Kind{reflect.String},
-			Received: reflect.Zero(val.Type()),
-		}
-	}
-
-	if vr.Type() == TypeObjectID {
-		oid, err := vr.ReadObjectID()
-		if err != nil {
-			return err
-		}
-		if dc.objectIDAsHexString {
-			val.SetString(oid.Hex())
-		} else {
-			val.SetString(string(oid[:]))
-		}
-		return nil
-	}
-	return (&stringCodec{}).DecodeValue(dc, vr, val)
-}
-
-// setter interface: a value implementing the bson.Setter interface will receive the BSON
-// value via the SetBSON method during unmarshaling, and the object
-// itself will not be changed as usual.
-//
-// If setting the value works, the method should return nil or alternatively
-// ErrMgoSetZero to set the respective field to its zero value (nil for
-// pointer types). If SetBSON returns a non-nil error, the unmarshalling
-// procedure will stop and error out with the provided value.
-//
-// This interface is generally useful in pointer receivers, since the method
-// will want to change the receiver. A type field that implements the Setter
-// interface doesn't have to be a pointer, though.
-//
-// For example:
-//
-//	type MyString string
-//
-//	func (s *MyString) SetBSON(raw bson.RawValue) error {
-//	    return raw.Unmarshal(s)
-//	}
-type setter interface {
-	SetBSON(raw RawValue) error
-}
-
-// getter interface: a value implementing the bson.Getter interface will have its GetBSON
-// method called when the given value has to be marshalled, and the result
-// of this method will be marshaled in place of the actual object.
-//
-// If GetBSON returns return a non-nil error, the marshalling procedure
-// will stop and error out with the provided value.
-type getter interface {
-	GetBSON() (interface{}, error)
-}
-
-// setterDecodeValue is the ValueDecoderFunc for Setter types.
-func setterDecodeValue(_ DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.IsValid() || (!val.Type().Implements(tSetter) && !reflect.PtrTo(val.Type()).Implements(tSetter)) {
-		return ValueDecoderError{Name: "SetterDecodeValue", Types: []reflect.Type{tSetter}, Received: val}
-	}
-
-	if val.Kind() == reflect.Ptr && val.IsNil() {
-		if !val.CanSet() {
-			return ValueDecoderError{Name: "SetterDecodeValue", Types: []reflect.Type{tSetter}, Received: val}
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	if !val.Type().Implements(tSetter) {
-		if !val.CanAddr() {
-			return ValueDecoderError{Name: "ValueUnmarshalerDecodeValue", Types: []reflect.Type{tSetter}, Received: val}
-		}
-		val = val.Addr() // If the type doesn't implement the interface, a pointer to it must.
-	}
-
-	t, src, err := copyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	m, ok := val.Interface().(setter)
-	if !ok {
-		return ValueDecoderError{Name: "SetterDecodeValue", Types: []reflect.Type{tSetter}, Received: val}
-	}
-	if err := m.SetBSON(RawValue{Type: t, Value: src}); err != nil {
-		if !errors.Is(err, ErrMgoSetZero) {
-			return err
-		}
-		val.Set(reflect.Zero(val.Type()))
-	}
-	return nil
-}
-
-// getterEncodeValue is the ValueEncoderFunc for Getter types.
-func getterEncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
-	// Either val or a pointer to val must implement Getter
-	switch {
-	case !val.IsValid():
-		return ValueEncoderError{Name: "GetterEncodeValue", Types: []reflect.Type{tGetter}, Received: val}
-	case val.Type().Implements(tGetter):
-		// If Getter is implemented on a concrete type, make sure that val isn't a nil pointer
-		if isImplementationNil(val, tGetter) {
-			return vw.WriteNull()
-		}
-	case reflect.PtrTo(val.Type()).Implements(tGetter) && val.CanAddr():
-		val = val.Addr()
-	default:
-		return ValueEncoderError{Name: "GetterEncodeValue", Types: []reflect.Type{tGetter}, Received: val}
-	}
-
-	m, ok := val.Interface().(getter)
-	if !ok {
-		return vw.WriteNull()
-	}
-	x, err := m.GetBSON()
-	if err != nil {
-		return err
-	}
-	if x == nil {
-		return vw.WriteNull()
-	}
-	vv := reflect.ValueOf(x)
-	encoder, err := ec.Registry.LookupEncoder(vv.Type())
-	if err != nil {
-		return err
-	}
-	return encoder.EncodeValue(ec, vw, vv)
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/mode.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/mode.go
deleted file mode 100644
index a4563892..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/mode.go
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"fmt"
-)
-
-type mode int
-
-const (
-	_ mode = iota
-	mTopLevel
-	mDocument
-	mArray
-	mValue
-	mElement
-	mCodeWithScope
-	mSpacer
-)
-
-func (m mode) String() string {
-	var str string
-
-	switch m {
-	case mTopLevel:
-		str = "TopLevel"
-	case mDocument:
-		str = "Document"
-	case mArray:
-		str = "Array"
-	case mValue:
-		str = "Value"
-	case mElement:
-		str = "Element"
-	case mCodeWithScope:
-		str = "CodeWithScope"
-	case mSpacer:
-		str = "CodeWithScopeSpacer"
-	default:
-		str = "Unknown"
-	}
-
-	return str
-}
-
-// TransitionError is an error returned when an invalid progressing a
-// ValueReader or ValueWriter state machine occurs.
-type TransitionError struct {
-	name        string
-	parent      mode
-	current     mode
-	destination mode
-	modes       []mode
-	action      string
-}
-
-func (te TransitionError) Error() string {
-	errString := fmt.Sprintf("%s can only %s", te.name, te.action)
-	if te.destination != mode(0) {
-		errString = fmt.Sprintf("%s a %s", errString, te.destination)
-	}
-	errString = fmt.Sprintf("%s while positioned on a", errString)
-	for ind, m := range te.modes {
-		if ind != 0 && len(te.modes) > 2 {
-			errString = fmt.Sprintf("%s,", errString)
-		}
-		if ind == len(te.modes)-1 && len(te.modes) > 1 {
-			errString = fmt.Sprintf("%s or", errString)
-		}
-		errString = fmt.Sprintf("%s %s", errString, m)
-	}
-	errString = fmt.Sprintf("%s but is positioned on a %s", errString, te.current)
-	if te.parent != mode(0) {
-		errString = fmt.Sprintf("%s with parent %s", errString, te.parent)
-	}
-	return errString
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/objectid.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/objectid.go
deleted file mode 100644
index 024281eb..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/objectid.go
+++ /dev/null
@@ -1,207 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-//
-// Based on gopkg.in/mgo.v2/bson by Gustavo Niemeyer
-// See THIRD-PARTY-NOTICES for original license terms.
-
-package bson
-
-import (
-	"crypto/rand"
-	"encoding"
-	"encoding/binary"
-	"encoding/hex"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"sync/atomic"
-	"time"
-)
-
-// ErrInvalidHex indicates that a hex string cannot be converted to an ObjectID.
-var ErrInvalidHex = errors.New("the provided hex string is not a valid ObjectID")
-
-// ObjectID is the BSON ObjectID type.
-type ObjectID [12]byte
-
-// NilObjectID is the zero value for ObjectID.
-var NilObjectID ObjectID
-
-var objectIDCounter = readRandomUint32()
-var processUnique = processUniqueBytes()
-
-var _ encoding.TextMarshaler = ObjectID{}
-var _ encoding.TextUnmarshaler = &ObjectID{}
-
-// NewObjectID generates a new ObjectID.
-func NewObjectID() ObjectID {
-	return NewObjectIDFromTimestamp(time.Now())
-}
-
-// NewObjectIDFromTimestamp generates a new ObjectID based on the given time.
-func NewObjectIDFromTimestamp(timestamp time.Time) ObjectID {
-	var b [12]byte
-
-	binary.BigEndian.PutUint32(b[0:4], uint32(timestamp.Unix()))
-	copy(b[4:9], processUnique[:])
-	putUint24(b[9:12], atomic.AddUint32(&objectIDCounter, 1))
-
-	return b
-}
-
-// Timestamp extracts the time part of the ObjectId.
-func (id ObjectID) Timestamp() time.Time {
-	unixSecs := binary.BigEndian.Uint32(id[0:4])
-	return time.Unix(int64(unixSecs), 0).UTC()
-}
-
-// Hex returns the hex encoding of the ObjectID as a string.
-func (id ObjectID) Hex() string {
-	var buf [24]byte
-	hex.Encode(buf[:], id[:])
-	return string(buf[:])
-}
-
-func (id ObjectID) String() string {
-	return `ObjectID("` + id.Hex() + `")`
-}
-
-// IsZero returns true if id is the empty ObjectID.
-func (id ObjectID) IsZero() bool {
-	return id == NilObjectID
-}
-
-// ObjectIDFromHex creates a new ObjectID from a hex string. It returns an error if the hex string is not a
-// valid ObjectID.
-func ObjectIDFromHex(s string) (ObjectID, error) {
-	if len(s) != 24 {
-		return NilObjectID, ErrInvalidHex
-	}
-
-	var oid [12]byte
-	_, err := hex.Decode(oid[:], []byte(s))
-	if err != nil {
-		return NilObjectID, err
-	}
-
-	return oid, nil
-}
-
-// MarshalText returns the ObjectID as UTF-8-encoded text. Implementing this allows us to use ObjectID
-// as a map key when marshalling JSON. See https://pkg.go.dev/encoding#TextMarshaler
-func (id ObjectID) MarshalText() ([]byte, error) {
-	var buf [24]byte
-	hex.Encode(buf[:], id[:])
-	return buf[:], nil
-}
-
-// UnmarshalText populates the byte slice with the ObjectID. If the byte slice
-// is 24 bytes long, it will be populated with the hex representation of the
-// ObjectID. If the byte slice is 12 bytes long, it will be populated with the
-// BSON representation of the ObjectID. This method also accepts empty strings
-// and decodes them as NilObjectID.
-//
-// For any other inputs, an error will be returned.
-//
-// Implementing this allows us to use ObjectID as a map key when unmarshalling
-// JSON. See https://pkg.go.dev/encoding#TextUnmarshaler
-func (id *ObjectID) UnmarshalText(b []byte) error {
-	// NB(charlie): The json package will use UnmarshalText instead of
-	// UnmarshalJSON if the value is a string.
-
-	// An empty string is not a valid ObjectID, but we treat it as a
-	// special value that decodes as NilObjectID.
-	if len(b) == 0 {
-		return nil
-	}
-	oid, err := ObjectIDFromHex(string(b))
-	if err != nil {
-		return err
-	}
-	*id = oid
-	return nil
-}
-
-// MarshalJSON returns the ObjectID as a string
-func (id ObjectID) MarshalJSON() ([]byte, error) {
-	var buf [26]byte
-	buf[0] = '"'
-	hex.Encode(buf[1:25], id[:])
-	buf[25] = '"'
-	return buf[:], nil
-}
-
-// UnmarshalJSON populates the byte slice with the ObjectID. If the byte slice
-// is 24 bytes long, it will be populated with the hex representation of the
-// ObjectID. If the byte slice is 12 bytes long, it will be populated with the
-// BSON representation of the ObjectID. This method also accepts empty strings
-// and decodes them as NilObjectID.
-//
-// As a special case UnmarshalJSON will decode a JSON object with key "$oid"
-// that stores a hex encoded ObjectID: {"$oid": "65b3f7edd9bfca00daa6e3b31"}.
-//
-// For any other inputs, an error will be returned.
-func (id *ObjectID) UnmarshalJSON(b []byte) error {
-	// Ignore "null" to keep parity with the standard library. Decoding a JSON
-	// null into a non-pointer ObjectID field will leave the field unchanged.
-	// For pointer values, encoding/json will set the pointer to nil and will
-	// not enter the UnmarshalJSON hook.
-	if string(b) == "null" {
-		return nil
-	}
-
-	// Handle string
-	if len(b) >= 2 && b[0] == '"' {
-		// TODO: fails because of error
-		return id.UnmarshalText(b[1 : len(b)-1])
-	}
-	if len(b) == 12 {
-		copy(id[:], b)
-		return nil
-	}
-	var v struct {
-		OID *string `json:"$oid"`
-	}
-	if err := json.Unmarshal(b, &v); err != nil {
-		return fmt.Errorf("failed to parse extended JSON ObjectID: %w", err)
-	}
-	if v.OID == nil {
-		return errors.New("not an extended JSON ObjectID")
-	}
-	i, err := ObjectIDFromHex(*v.OID)
-	if err != nil {
-		return err
-	}
-	*id = i
-	return nil
-}
-
-func processUniqueBytes() [5]byte {
-	var b [5]byte
-	_, err := io.ReadFull(rand.Reader, b[:])
-	if err != nil {
-		panic(fmt.Errorf("cannot initialize objectid package with crypto.rand.Reader: %w", err))
-	}
-
-	return b
-}
-
-func readRandomUint32() uint32 {
-	var b [4]byte
-	_, err := io.ReadFull(rand.Reader, b[:])
-	if err != nil {
-		panic(fmt.Errorf("cannot initialize objectid package with crypto.rand.Reader: %w", err))
-	}
-
-	return (uint32(b[0]) << 0) | (uint32(b[1]) << 8) | (uint32(b[2]) << 16) | (uint32(b[3]) << 24)
-}
-
-func putUint24(b []byte, v uint32) {
-	b[0] = byte(v >> 16)
-	b[1] = byte(v >> 8)
-	b[2] = byte(v)
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/pointer_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/pointer_codec.go
deleted file mode 100644
index ff2e940c..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/pointer_codec.go
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"reflect"
-)
-
-var (
-	_ ValueEncoder = &pointerCodec{}
-	_ ValueDecoder = &pointerCodec{}
-)
-
-// pointerCodec is the Codec used for pointers.
-type pointerCodec struct {
-	ecache typeEncoderCache
-	dcache typeDecoderCache
-}
-
-// EncodeValue handles encoding a pointer by either encoding it to BSON Null if the pointer is nil
-// or looking up an encoder for the type of value the pointer points to.
-func (pc *pointerCodec) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if val.Kind() != reflect.Ptr {
-		if !val.IsValid() {
-			return vw.WriteNull()
-		}
-		return ValueEncoderError{Name: "PointerCodec.EncodeValue", Kinds: []reflect.Kind{reflect.Ptr}, Received: val}
-	}
-
-	if val.IsNil() {
-		return vw.WriteNull()
-	}
-
-	typ := val.Type()
-	if v, ok := pc.ecache.Load(typ); ok {
-		if v == nil {
-			return errNoEncoder{Type: typ}
-		}
-		return v.EncodeValue(ec, vw, val.Elem())
-	}
-	// TODO(charlie): handle concurrent requests for the same type
-	enc, err := ec.LookupEncoder(typ.Elem())
-	enc = pc.ecache.LoadOrStore(typ, enc)
-	if err != nil {
-		return err
-	}
-	return enc.EncodeValue(ec, vw, val.Elem())
-}
-
-// DecodeValue handles decoding a pointer by looking up a decoder for the type it points to and
-// using that to decode. If the BSON value is Null, this method will set the pointer to nil.
-func (pc *pointerCodec) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Kind() != reflect.Ptr {
-		return ValueDecoderError{Name: "PointerCodec.DecodeValue", Kinds: []reflect.Kind{reflect.Ptr}, Received: val}
-	}
-
-	typ := val.Type()
-	if vr.Type() == TypeNull {
-		val.Set(reflect.Zero(typ))
-		return vr.ReadNull()
-	}
-	if vr.Type() == TypeUndefined {
-		val.Set(reflect.Zero(typ))
-		return vr.ReadUndefined()
-	}
-
-	if val.IsNil() {
-		val.Set(reflect.New(typ.Elem()))
-	}
-
-	if v, ok := pc.dcache.Load(typ); ok {
-		if v == nil {
-			return errNoDecoder{Type: typ}
-		}
-		return v.DecodeValue(dc, vr, val.Elem())
-	}
-	// TODO(charlie): handle concurrent requests for the same type
-	dec, err := dc.LookupDecoder(typ.Elem())
-	dec = pc.dcache.LoadOrStore(typ, dec)
-	if err != nil {
-		return err
-	}
-	return dec.DecodeValue(dc, vr, val.Elem())
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/primitive.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/primitive.go
deleted file mode 100644
index 162bfa71..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/primitive.go
+++ /dev/null
@@ -1,379 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-//
-// Based on gopkg.in/mgo.v2/bson by Gustavo Niemeyer
-// See THIRD-PARTY-NOTICES for original license terms.
-
-package bson
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"reflect"
-	"time"
-)
-
-// Zeroer allows custom struct types to implement a report of zero
-// state. All struct types that don't implement Zeroer or where IsZero
-// returns false are considered to be not zero.
-type Zeroer interface {
-	IsZero() bool
-}
-
-// The following primitive types are similar to Go primitives for BSON types that
-// do not have direct Go primitive representations.
-
-// Binary represents a BSON binary value.
-type Binary struct {
-	Subtype byte
-	Data    []byte
-}
-
-// Equal compares bp to bp2 and returns true if they are equal.
-func (bp Binary) Equal(bp2 Binary) bool {
-	if bp.Subtype != bp2.Subtype {
-		return false
-	}
-	return bytes.Equal(bp.Data, bp2.Data)
-}
-
-// IsZero returns if bp is the empty Binary.
-func (bp Binary) IsZero() bool {
-	return bp.Subtype == 0 && len(bp.Data) == 0
-}
-
-// Undefined represents the BSON undefined value type.
-type Undefined struct{}
-
-// DateTime represents the BSON datetime value.
-type DateTime int64
-
-var _ json.Marshaler = DateTime(0)
-var _ json.Unmarshaler = (*DateTime)(nil)
-
-// MarshalJSON marshal to time type.
-func (d DateTime) MarshalJSON() ([]byte, error) {
-	return d.Time().UTC().MarshalJSON()
-}
-
-// UnmarshalJSON creates a bson.DateTime from a JSON string.
-func (d *DateTime) UnmarshalJSON(data []byte) error {
-	// Ignore "null" so that we can distinguish between a "null" value and
-	// valid value that is the zero time (as reported by time.Time.IsZero).
-	if string(data) == "null" {
-		return nil
-	}
-	var t time.Time
-	if err := t.UnmarshalJSON(data); err != nil {
-		return err
-	}
-	*d = NewDateTimeFromTime(t)
-	return nil
-}
-
-// Time returns the date as a time type.
-func (d DateTime) Time() time.Time {
-	return time.Unix(int64(d)/1000, int64(d)%1000*1000000)
-}
-
-// NewDateTimeFromTime creates a new DateTime from a Time.
-func NewDateTimeFromTime(t time.Time) DateTime {
-	return DateTime(t.Unix()*1e3 + int64(t.Nanosecond())/1e6)
-}
-
-// Null represents the BSON null value.
-type Null struct{}
-
-// Regex represents a BSON regex value.
-type Regex struct {
-	Pattern string
-	Options string
-}
-
-func (rp Regex) String() string {
-	return fmt.Sprintf(`{"pattern": "%s", "options": "%s"}`, rp.Pattern, rp.Options)
-}
-
-// Equal compares rp to rp2 and returns true if they are equal.
-func (rp Regex) Equal(rp2 Regex) bool {
-	return rp.Pattern == rp2.Pattern && rp.Options == rp2.Options
-}
-
-// IsZero returns if rp is the empty Regex.
-func (rp Regex) IsZero() bool {
-	return rp.Pattern == "" && rp.Options == ""
-}
-
-// DBPointer represents a BSON dbpointer value.
-type DBPointer struct {
-	DB      string
-	Pointer ObjectID
-}
-
-func (d DBPointer) String() string {
-	return fmt.Sprintf(`{"db": "%s", "pointer": "%s"}`, d.DB, d.Pointer)
-}
-
-// Equal compares d to d2 and returns true if they are equal.
-func (d DBPointer) Equal(d2 DBPointer) bool {
-	return d == d2
-}
-
-// IsZero returns if d is the empty DBPointer.
-func (d DBPointer) IsZero() bool {
-	return d.DB == "" && d.Pointer.IsZero()
-}
-
-// JavaScript represents a BSON JavaScript code value.
-type JavaScript string
-
-// Symbol represents a BSON symbol value.
-type Symbol string
-
-// CodeWithScope represents a BSON JavaScript code with scope value.
-type CodeWithScope struct {
-	Code  JavaScript
-	Scope interface{}
-}
-
-func (cws CodeWithScope) String() string {
-	return fmt.Sprintf(`{"code": "%s", "scope": %v}`, cws.Code, cws.Scope)
-}
-
-// Timestamp represents a BSON timestamp value.
-type Timestamp struct {
-	T uint32
-	I uint32
-}
-
-// After reports whether the time instant tp is after tp2.
-func (tp Timestamp) After(tp2 Timestamp) bool {
-	return tp.T > tp2.T || (tp.T == tp2.T && tp.I > tp2.I)
-}
-
-// Before reports whether the time instant tp is before tp2.
-func (tp Timestamp) Before(tp2 Timestamp) bool {
-	return tp.T < tp2.T || (tp.T == tp2.T && tp.I < tp2.I)
-}
-
-// Equal compares tp to tp2 and returns true if they are equal.
-func (tp Timestamp) Equal(tp2 Timestamp) bool {
-	return tp.T == tp2.T && tp.I == tp2.I
-}
-
-// IsZero returns if tp is the zero Timestamp.
-func (tp Timestamp) IsZero() bool {
-	return tp.T == 0 && tp.I == 0
-}
-
-// Compare compares the time instant tp with tp2. If tp is before tp2, it returns -1; if tp is after
-// tp2, it returns +1; if they're the same, it returns 0.
-func (tp Timestamp) Compare(tp2 Timestamp) int {
-	switch {
-	case tp.Equal(tp2):
-		return 0
-	case tp.Before(tp2):
-		return -1
-	default:
-		return +1
-	}
-}
-
-// MinKey represents the BSON minkey value.
-type MinKey struct{}
-
-// MaxKey represents the BSON maxkey value.
-type MaxKey struct{}
-
-// D is an ordered representation of a BSON document. This type should be used when the order of the elements matters,
-// such as MongoDB command documents. If the order of the elements does not matter, an M should be used instead.
-//
-// Example usage:
-//
-//	bson.D{{"foo", "bar"}, {"hello", "world"}, {"pi", 3.14159}}
-type D []E
-
-func (d D) String() string {
-	b, err := MarshalExtJSON(d, true, false)
-	if err != nil {
-		return ""
-	}
-	return string(b)
-}
-
-// MarshalJSON encodes D into JSON.
-func (d D) MarshalJSON() ([]byte, error) {
-	if d == nil {
-		return json.Marshal(nil)
-	}
-	var err error
-	var buf bytes.Buffer
-	buf.Write([]byte("{"))
-	enc := json.NewEncoder(&buf)
-	for i, e := range d {
-		err = enc.Encode(e.Key)
-		if err != nil {
-			return nil, err
-		}
-		buf.Write([]byte(":"))
-		err = enc.Encode(e.Value)
-		if err != nil {
-			return nil, err
-		}
-		if i < len(d)-1 {
-			buf.Write([]byte(","))
-		}
-	}
-	buf.Write([]byte("}"))
-	return json.RawMessage(buf.Bytes()).MarshalJSON()
-}
-
-// UnmarshalJSON decodes D from JSON.
-func (d *D) UnmarshalJSON(b []byte) error {
-	dec := json.NewDecoder(bytes.NewReader(b))
-	t, err := dec.Token()
-	if err != nil {
-		return err
-	}
-	if t == nil {
-		*d = nil
-		return nil
-	}
-	if v, ok := t.(json.Delim); !ok || v != '{' {
-		return &json.UnmarshalTypeError{
-			Value:  tokenString(t),
-			Type:   reflect.TypeOf(D(nil)),
-			Offset: dec.InputOffset(),
-		}
-	}
-	*d, err = jsonDecodeD(dec)
-	return err
-}
-
-// E represents a BSON element for a D. It is usually used inside a D.
-type E struct {
-	Key   string
-	Value interface{}
-}
-
-// M is an unordered representation of a BSON document. This type should be used when the order of the elements does not
-// matter. This type is handled as a regular map[string]interface{} when encoding and decoding. Elements will be
-// serialized in an undefined, random order. If the order of the elements matters, a D should be used instead.
-//
-// Example usage:
-//
-//	bson.M{"foo": "bar", "hello": "world", "pi": 3.14159}
-type M map[string]interface{}
-
-func (m M) String() string {
-	b, err := MarshalExtJSON(m, true, false)
-	if err != nil {
-		return ""
-	}
-	return string(b)
-}
-
-// An A is an ordered representation of a BSON array.
-//
-// Example usage:
-//
-//	bson.A{"bar", "world", 3.14159, bson.D{{"qux", 12345}}}
-type A []interface{}
-
-func jsonDecodeD(dec *json.Decoder) (D, error) {
-	res := D{}
-	for {
-		var e E
-
-		t, err := dec.Token()
-		if err != nil {
-			return nil, err
-		}
-		key, ok := t.(string)
-		if !ok {
-			break
-		}
-		e.Key = key
-
-		t, err = dec.Token()
-		if err != nil {
-			return nil, err
-		}
-		switch v := t.(type) {
-		case json.Delim:
-			switch v {
-			case '[':
-				e.Value, err = jsonDecodeSlice(dec)
-				if err != nil {
-					return nil, err
-				}
-			case '{':
-				e.Value, err = jsonDecodeD(dec)
-				if err != nil {
-					return nil, err
-				}
-			}
-		default:
-			e.Value = t
-		}
-
-		res = append(res, e)
-	}
-	return res, nil
-}
-
-func jsonDecodeSlice(dec *json.Decoder) ([]interface{}, error) {
-	var res []interface{}
-	done := false
-	for !done {
-		t, err := dec.Token()
-		if err != nil {
-			return nil, err
-		}
-		switch v := t.(type) {
-		case json.Delim:
-			switch v {
-			case '[':
-				a, err := jsonDecodeSlice(dec)
-				if err != nil {
-					return nil, err
-				}
-				res = append(res, a)
-			case '{':
-				d, err := jsonDecodeD(dec)
-				if err != nil {
-					return nil, err
-				}
-				res = append(res, d)
-			default:
-				done = true
-			}
-		default:
-			res = append(res, t)
-		}
-	}
-	return res, nil
-}
-
-func tokenString(t json.Token) string {
-	switch v := t.(type) {
-	case json.Delim:
-		switch v {
-		case '{':
-			return "object"
-		case '[':
-			return "array"
-		}
-	case bool:
-		return "bool"
-	case float64:
-		return "number"
-	case json.Number, string:
-		return "string"
-	}
-	return "unknown"
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/primitive_codecs.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/primitive_codecs.go
deleted file mode 100644
index 5ac5f000..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/primitive_codecs.go
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"fmt"
-	"reflect"
-)
-
-var tRawValue = reflect.TypeOf(RawValue{})
-var tRaw = reflect.TypeOf(Raw(nil))
-
-// registerPrimitiveCodecs will register the encode and decode methods attached to PrimitiveCodecs
-// with the provided RegistryBuilder. if rb is nil, a new empty RegistryBuilder will be created.
-func registerPrimitiveCodecs(reg *Registry) {
-	reg.RegisterTypeEncoder(tRawValue, ValueEncoderFunc(rawValueEncodeValue))
-	reg.RegisterTypeEncoder(tRaw, ValueEncoderFunc(rawEncodeValue))
-	reg.RegisterTypeDecoder(tRawValue, ValueDecoderFunc(rawValueDecodeValue))
-	reg.RegisterTypeDecoder(tRaw, ValueDecoderFunc(rawDecodeValue))
-}
-
-// rawValueEncodeValue is the ValueEncoderFunc for RawValue.
-//
-// If the RawValue's Type is "invalid" and the RawValue's Value is not empty or
-// nil, then this method will return an error.
-func rawValueEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tRawValue {
-		return ValueEncoderError{
-			Name:     "RawValueEncodeValue",
-			Types:    []reflect.Type{tRawValue},
-			Received: val,
-		}
-	}
-
-	rawvalue := val.Interface().(RawValue)
-
-	if !rawvalue.Type.IsValid() {
-		return fmt.Errorf("the RawValue Type specifies an invalid BSON type: %#x", byte(rawvalue.Type))
-	}
-
-	return copyValueFromBytes(vw, rawvalue.Type, rawvalue.Value)
-}
-
-// rawValueDecodeValue is the ValueDecoderFunc for RawValue.
-func rawValueDecodeValue(_ DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tRawValue {
-		return ValueDecoderError{Name: "RawValueDecodeValue", Types: []reflect.Type{tRawValue}, Received: val}
-	}
-
-	t, value, err := copyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	val.Set(reflect.ValueOf(RawValue{Type: t, Value: value}))
-	return nil
-}
-
-// rawEncodeValue is the ValueEncoderFunc for Reader.
-func rawEncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tRaw {
-		return ValueEncoderError{Name: "RawEncodeValue", Types: []reflect.Type{tRaw}, Received: val}
-	}
-
-	rdr := val.Interface().(Raw)
-
-	return copyDocumentFromBytes(vw, rdr)
-}
-
-// rawDecodeValue is the ValueDecoderFunc for Reader.
-func rawDecodeValue(_ DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tRaw {
-		return ValueDecoderError{Name: "RawDecodeValue", Types: []reflect.Type{tRaw}, Received: val}
-	}
-
-	if val.IsNil() {
-		val.Set(reflect.MakeSlice(val.Type(), 0, 0))
-	}
-
-	val.SetLen(0)
-
-	rdr, err := appendDocumentBytes(val.Interface().(Raw), vr)
-	val.Set(reflect.ValueOf(rdr))
-	return err
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/raw.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/raw.go
deleted file mode 100644
index 1c49faee..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/raw.go
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"errors"
-	"io"
-
-	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
-)
-
-// ErrNilReader indicates that an operation was attempted on a nil bson.Reader.
-var ErrNilReader = errors.New("nil reader")
-
-// Raw is a raw encoded BSON document. It can be used to delay BSON document decoding or precompute
-// a BSON encoded document.
-//
-// A Raw must be a full BSON document. Use the RawValue type for individual BSON values.
-type Raw []byte
-
-// ReadDocument reads a BSON document from the io.Reader and returns it as a bson.Raw. If the
-// reader contains multiple BSON documents, only the first document is read.
-func ReadDocument(r io.Reader) (Raw, error) {
-	doc, err := bsoncore.NewDocumentFromReader(r)
-	return Raw(doc), err
-}
-
-// Validate validates the document. This method only validates the first document in
-// the slice, to validate other documents, the slice must be resliced.
-func (r Raw) Validate() (err error) { return bsoncore.Document(r).Validate() }
-
-// Lookup search the document, potentially recursively, for the given key. If
-// there are multiple keys provided, this method will recurse down, as long as
-// the top and intermediate nodes are either documents or arrays.If an error
-// occurs or if the value doesn't exist, an empty RawValue is returned.
-func (r Raw) Lookup(key ...string) RawValue {
-	return convertFromCoreValue(bsoncore.Document(r).Lookup(key...))
-}
-
-// LookupErr searches the document and potentially subdocuments or arrays for the
-// provided key. Each key provided to this method represents a layer of depth.
-func (r Raw) LookupErr(key ...string) (RawValue, error) {
-	val, err := bsoncore.Document(r).LookupErr(key...)
-	return convertFromCoreValue(val), err
-}
-
-// Elements returns this document as a slice of elements. The returned slice will contain valid
-// elements. If the document is not valid, the elements up to the invalid point will be returned
-// along with an error.
-func (r Raw) Elements() ([]RawElement, error) {
-	doc := bsoncore.Document(r)
-	if len(doc) == 0 {
-		return nil, nil
-	}
-	elems, err := doc.Elements()
-	if err != nil {
-		return nil, err
-	}
-	relems := make([]RawElement, 0, len(elems))
-	for _, elem := range elems {
-		relems = append(relems, RawElement(elem))
-	}
-	return relems, nil
-}
-
-// Values returns this document as a slice of values. The returned slice will contain valid values.
-// If the document is not valid, the values up to the invalid point will be returned along with an
-// error.
-func (r Raw) Values() ([]RawValue, error) {
-	vals, err := bsoncore.Document(r).Values()
-	rvals := make([]RawValue, 0, len(vals))
-	for _, val := range vals {
-		rvals = append(rvals, convertFromCoreValue(val))
-	}
-	return rvals, err
-}
-
-// Index searches for and retrieves the element at the given index. This method will panic if
-// the document is invalid or if the index is out of bounds.
-func (r Raw) Index(index uint) RawElement { return RawElement(bsoncore.Document(r).Index(index)) }
-
-// IndexErr searches for and retrieves the element at the given index.
-func (r Raw) IndexErr(index uint) (RawElement, error) {
-	elem, err := bsoncore.Document(r).IndexErr(index)
-	return RawElement(elem), err
-}
-
-// String returns the BSON document encoded as Extended JSON.
-func (r Raw) String() string { return bsoncore.Document(r).String() }
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_array.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_array.go
deleted file mode 100644
index 1d2e9be7..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_array.go
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2024-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"io"
-
-	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
-)
-
-// RawArray is a raw bytes representation of a BSON array.
-type RawArray []byte
-
-// ReadArray reads a BSON array from the io.Reader and returns it as a
-// bson.RawArray.
-func ReadArray(r io.Reader) (RawArray, error) {
-	doc, err := bsoncore.NewArrayFromReader(r)
-
-	return RawArray(doc), err
-}
-
-// Index searches for and retrieves the value at the given index. This method
-// will panic if the array is invalid or if the index is out of bounds.
-func (a RawArray) Index(index uint) RawValue {
-	return convertFromCoreValue(bsoncore.Array(a).Index(index))
-}
-
-// IndexErr searches for and retrieves the value at the given index.
-func (a RawArray) IndexErr(index uint) (RawValue, error) {
-	elem, err := bsoncore.Array(a).IndexErr(index)
-
-	return convertFromCoreValue(elem), err
-}
-
-// DebugString outputs a human readable version of Array. It will attempt to
-// stringify the valid components of the array even if the entire array is not
-// valid.
-func (a RawArray) DebugString() string {
-	return bsoncore.Array(a).DebugString()
-}
-
-// String outputs an ExtendedJSON version of Array. If the Array is not valid,
-// this method returns an empty string.
-func (a RawArray) String() string {
-	return bsoncore.Array(a).String()
-}
-
-// Values returns this array as a slice of values. The returned slice will
-// contain valid values. If the array is not valid, the values up to the invalid
-// point will be returned along with an error.
-func (a RawArray) Values() ([]RawValue, error) {
-	vals, err := bsoncore.Array(a).Values()
-	if err != nil {
-		return nil, err
-	}
-
-	rvals := make([]RawValue, 0, len(vals))
-	for _, val := range vals {
-		rvals = append(rvals, convertFromCoreValue(val))
-	}
-
-	return rvals, err
-}
-
-// Validate validates the array and ensures the elements contained within are
-// valid.
-func (a RawArray) Validate() error {
-	return bsoncore.Array(a).Validate()
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_element.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_element.go
deleted file mode 100644
index 75a00350..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_element.go
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
-)
-
-// RawElement is a raw encoded BSON document or array element.
-type RawElement []byte
-
-// Key returns the key for this element. If the element is not valid, this method returns an empty
-// string. If knowing if the element is valid is important, use KeyErr.
-func (re RawElement) Key() string { return bsoncore.Element(re).Key() }
-
-// KeyErr returns the key for this element, returning an error if the element is not valid.
-func (re RawElement) KeyErr() (string, error) { return bsoncore.Element(re).KeyErr() }
-
-// Value returns the value of this element. If the element is not valid, this method returns an
-// empty Value. If knowing if the element is valid is important, use ValueErr.
-func (re RawElement) Value() RawValue { return convertFromCoreValue(bsoncore.Element(re).Value()) }
-
-// ValueErr returns the value for this element, returning an error if the element is not valid.
-func (re RawElement) ValueErr() (RawValue, error) {
-	val, err := bsoncore.Element(re).ValueErr()
-	return convertFromCoreValue(val), err
-}
-
-// Validate ensures re is a valid BSON element.
-func (re RawElement) Validate() error { return bsoncore.Element(re).Validate() }
-
-// String returns the BSON element encoded as Extended JSON.
-func (re RawElement) String() string {
-	doc := bsoncore.BuildDocument(nil, re)
-	j, err := MarshalExtJSON(Raw(doc), true, false)
-	if err != nil {
-		return "<malformed>"
-	}
-	return string(j)
-}
-
-// DebugString outputs a human readable version of RawElement. It will attempt to stringify the
-// valid components of the element even if the entire element is not valid.
-func (re RawElement) DebugString() string { return bsoncore.Element(re).DebugString() }
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_value.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_value.go
deleted file mode 100644
index 53f053f0..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/raw_value.go
+++ /dev/null
@@ -1,306 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"reflect"
-	"time"
-
-	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
-)
-
-// ErrNilContext is returned when the provided DecodeContext is nil.
-var ErrNilContext = errors.New("DecodeContext cannot be nil")
-
-// ErrNilRegistry is returned when the provided registry is nil.
-var ErrNilRegistry = errors.New("Registry cannot be nil")
-
-// RawValue is a raw encoded BSON value. It can be used to delay BSON value decoding or precompute
-// BSON encoded value. Type is the BSON type of the value and Value is the raw encoded BSON value.
-//
-// A RawValue must be an individual BSON value. Use the Raw type for full BSON documents.
-type RawValue struct {
-	Type  Type
-	Value []byte
-
-	r *Registry
-}
-
-// IsZero reports whether the RawValue is zero, i.e. no data is present on
-// the RawValue. It returns true if Type is 0 and Value is empty or nil.
-func (rv RawValue) IsZero() bool {
-	return rv.Type == 0x00 && len(rv.Value) == 0
-}
-
-// Unmarshal deserializes BSON into the provided val. If RawValue cannot be unmarshaled into val, an
-// error is returned. This method will use the registry used to create the RawValue, if the RawValue
-// was created from partial BSON processing, or it will use the default registry. Users wishing to
-// specify the registry to use should use UnmarshalWithRegistry.
-func (rv RawValue) Unmarshal(val interface{}) error {
-	reg := rv.r
-	if reg == nil {
-		reg = defaultRegistry
-	}
-	return rv.UnmarshalWithRegistry(reg, val)
-}
-
-// Equal compares rv and rv2 and returns true if they are equal.
-func (rv RawValue) Equal(rv2 RawValue) bool {
-	if rv.Type != rv2.Type {
-		return false
-	}
-
-	if !bytes.Equal(rv.Value, rv2.Value) {
-		return false
-	}
-
-	return true
-}
-
-// UnmarshalWithRegistry performs the same unmarshalling as Unmarshal but uses the provided registry
-// instead of the one attached or the default registry.
-func (rv RawValue) UnmarshalWithRegistry(r *Registry, val interface{}) error {
-	if r == nil {
-		return ErrNilRegistry
-	}
-
-	vr := newValueReader(rv.Type, bytes.NewReader(rv.Value))
-	rval := reflect.ValueOf(val)
-	if rval.Kind() != reflect.Ptr {
-		return fmt.Errorf("argument to Unmarshal* must be a pointer to a type, but got %v", rval)
-	}
-	rval = rval.Elem()
-	dec, err := r.LookupDecoder(rval.Type())
-	if err != nil {
-		return err
-	}
-	return dec.DecodeValue(DecodeContext{Registry: r}, vr, rval)
-}
-
-// UnmarshalWithContext performs the same unmarshalling as Unmarshal but uses the provided DecodeContext
-// instead of the one attached or the default registry.
-func (rv RawValue) UnmarshalWithContext(dc *DecodeContext, val interface{}) error {
-	if dc == nil {
-		return ErrNilContext
-	}
-
-	vr := newValueReader(rv.Type, bytes.NewReader(rv.Value))
-	rval := reflect.ValueOf(val)
-	if rval.Kind() != reflect.Ptr {
-		return fmt.Errorf("argument to Unmarshal* must be a pointer to a type, but got %v", rval)
-	}
-	rval = rval.Elem()
-	dec, err := dc.LookupDecoder(rval.Type())
-	if err != nil {
-		return err
-	}
-	return dec.DecodeValue(*dc, vr, rval)
-}
-
-func convertFromCoreValue(v bsoncore.Value) RawValue {
-	return RawValue{Type: Type(v.Type), Value: v.Data}
-}
-func convertToCoreValue(v RawValue) bsoncore.Value {
-	return bsoncore.Value{Type: bsoncore.Type(v.Type), Data: v.Value}
-}
-
-// Validate ensures the value is a valid BSON value.
-func (rv RawValue) Validate() error { return convertToCoreValue(rv).Validate() }
-
-// IsNumber returns true if the type of v is a numeric BSON type.
-func (rv RawValue) IsNumber() bool { return convertToCoreValue(rv).IsNumber() }
-
-// String implements the fmt.String interface. This method will return values in extended JSON
-// format. If the value is not valid, this returns an empty string
-func (rv RawValue) String() string { return convertToCoreValue(rv).String() }
-
-// DebugString outputs a human readable version of Document. It will attempt to stringify the
-// valid components of the document even if the entire document is not valid.
-func (rv RawValue) DebugString() string { return convertToCoreValue(rv).DebugString() }
-
-// Double returns the float64 value for this element.
-// It panics if e's BSON type is not bson.TypeDouble.
-func (rv RawValue) Double() float64 { return convertToCoreValue(rv).Double() }
-
-// DoubleOK is the same as Double, but returns a boolean instead of panicking.
-func (rv RawValue) DoubleOK() (float64, bool) { return convertToCoreValue(rv).DoubleOK() }
-
-// StringValue returns the string value for this element.
-// It panics if e's BSON type is not bson.TypeString.
-//
-// NOTE: This method is called StringValue to avoid a collision with the String method which
-// implements the fmt.Stringer interface.
-func (rv RawValue) StringValue() string { return convertToCoreValue(rv).StringValue() }
-
-// StringValueOK is the same as StringValue, but returns a boolean instead of
-// panicking.
-func (rv RawValue) StringValueOK() (string, bool) { return convertToCoreValue(rv).StringValueOK() }
-
-// Document returns the BSON document the Value represents as a Document. It panics if the
-// value is a BSON type other than document.
-func (rv RawValue) Document() Raw { return Raw(convertToCoreValue(rv).Document()) }
-
-// DocumentOK is the same as Document, except it returns a boolean
-// instead of panicking.
-func (rv RawValue) DocumentOK() (Raw, bool) {
-	doc, ok := convertToCoreValue(rv).DocumentOK()
-	return Raw(doc), ok
-}
-
-// Array returns the BSON array the Value represents as an Array. It panics if the
-// value is a BSON type other than array.
-func (rv RawValue) Array() RawArray { return RawArray(convertToCoreValue(rv).Array()) }
-
-// ArrayOK is the same as Array, except it returns a boolean instead
-// of panicking.
-func (rv RawValue) ArrayOK() (RawArray, bool) {
-	doc, ok := convertToCoreValue(rv).ArrayOK()
-
-	return RawArray(doc), ok
-}
-
-// Binary returns the BSON binary value the Value represents. It panics if the value is a BSON type
-// other than binary.
-func (rv RawValue) Binary() (subtype byte, data []byte) { return convertToCoreValue(rv).Binary() }
-
-// BinaryOK is the same as Binary, except it returns a boolean instead of
-// panicking.
-func (rv RawValue) BinaryOK() (subtype byte, data []byte, ok bool) {
-	return convertToCoreValue(rv).BinaryOK()
-}
-
-// ObjectID returns the BSON objectid value the Value represents. It panics if the value is a BSON
-// type other than objectid.
-func (rv RawValue) ObjectID() ObjectID { return convertToCoreValue(rv).ObjectID() }
-
-// ObjectIDOK is the same as ObjectID, except it returns a boolean instead of
-// panicking.
-func (rv RawValue) ObjectIDOK() (ObjectID, bool) {
-	return convertToCoreValue(rv).ObjectIDOK()
-}
-
-// Boolean returns the boolean value the Value represents. It panics if the
-// value is a BSON type other than boolean.
-func (rv RawValue) Boolean() bool { return convertToCoreValue(rv).Boolean() }
-
-// BooleanOK is the same as Boolean, except it returns a boolean instead of
-// panicking.
-func (rv RawValue) BooleanOK() (bool, bool) { return convertToCoreValue(rv).BooleanOK() }
-
-// DateTime returns the BSON datetime value the Value represents as a
-// unix timestamp. It panics if the value is a BSON type other than datetime.
-func (rv RawValue) DateTime() int64 { return convertToCoreValue(rv).DateTime() }
-
-// DateTimeOK is the same as DateTime, except it returns a boolean instead of
-// panicking.
-func (rv RawValue) DateTimeOK() (int64, bool) { return convertToCoreValue(rv).DateTimeOK() }
-
-// Time returns the BSON datetime value the Value represents. It panics if the value is a BSON
-// type other than datetime.
-func (rv RawValue) Time() time.Time { return convertToCoreValue(rv).Time() }
-
-// TimeOK is the same as Time, except it returns a boolean instead of
-// panicking.
-func (rv RawValue) TimeOK() (time.Time, bool) { return convertToCoreValue(rv).TimeOK() }
-
-// Regex returns the BSON regex value the Value represents. It panics if the value is a BSON
-// type other than regex.
-func (rv RawValue) Regex() (pattern, options string) { return convertToCoreValue(rv).Regex() }
-
-// RegexOK is the same as Regex, except it returns a boolean instead of
-// panicking.
-func (rv RawValue) RegexOK() (pattern, options string, ok bool) {
-	return convertToCoreValue(rv).RegexOK()
-}
-
-// DBPointer returns the BSON dbpointer value the Value represents. It panics if the value is a BSON
-// type other than DBPointer.
-func (rv RawValue) DBPointer() (string, ObjectID) {
-	return convertToCoreValue(rv).DBPointer()
-}
-
-// DBPointerOK is the same as DBPoitner, except that it returns a boolean
-// instead of panicking.
-func (rv RawValue) DBPointerOK() (string, ObjectID, bool) {
-	return convertToCoreValue(rv).DBPointerOK()
-}
-
-// JavaScript returns the BSON JavaScript code value the Value represents. It panics if the value is
-// a BSON type other than JavaScript code.
-func (rv RawValue) JavaScript() string { return convertToCoreValue(rv).JavaScript() }
-
-// JavaScriptOK is the same as Javascript, excepti that it returns a boolean
-// instead of panicking.
-func (rv RawValue) JavaScriptOK() (string, bool) { return convertToCoreValue(rv).JavaScriptOK() }
-
-// Symbol returns the BSON symbol value the Value represents. It panics if the value is a BSON
-// type other than symbol.
-func (rv RawValue) Symbol() string { return convertToCoreValue(rv).Symbol() }
-
-// SymbolOK is the same as Symbol, excepti that it returns a boolean
-// instead of panicking.
-func (rv RawValue) SymbolOK() (string, bool) { return convertToCoreValue(rv).SymbolOK() }
-
-// CodeWithScope returns the BSON JavaScript code with scope the Value represents.
-// It panics if the value is a BSON type other than JavaScript code with scope.
-func (rv RawValue) CodeWithScope() (string, Raw) {
-	code, scope := convertToCoreValue(rv).CodeWithScope()
-	return code, Raw(scope)
-}
-
-// CodeWithScopeOK is the same as CodeWithScope, except that it returns a boolean instead of
-// panicking.
-func (rv RawValue) CodeWithScopeOK() (string, Raw, bool) {
-	code, scope, ok := convertToCoreValue(rv).CodeWithScopeOK()
-	return code, Raw(scope), ok
-}
-
-// Int32 returns the int32 the Value represents. It panics if the value is a BSON type other than
-// int32.
-func (rv RawValue) Int32() int32 { return convertToCoreValue(rv).Int32() }
-
-// Int32OK is the same as Int32, except that it returns a boolean instead of
-// panicking.
-func (rv RawValue) Int32OK() (int32, bool) { return convertToCoreValue(rv).Int32OK() }
-
-// Timestamp returns the BSON timestamp value the Value represents. It panics if the value is a
-// BSON type other than timestamp.
-func (rv RawValue) Timestamp() (t, i uint32) { return convertToCoreValue(rv).Timestamp() }
-
-// TimestampOK is the same as Timestamp, except that it returns a boolean
-// instead of panicking.
-func (rv RawValue) TimestampOK() (t, i uint32, ok bool) { return convertToCoreValue(rv).TimestampOK() }
-
-// Int64 returns the int64 the Value represents. It panics if the value is a BSON type other than
-// int64.
-func (rv RawValue) Int64() int64 { return convertToCoreValue(rv).Int64() }
-
-// Int64OK is the same as Int64, except that it returns a boolean instead of
-// panicking.
-func (rv RawValue) Int64OK() (int64, bool) { return convertToCoreValue(rv).Int64OK() }
-
-// AsInt64 returns a BSON number as an int64. If the BSON type is not a numeric one, this method
-// will panic.
-func (rv RawValue) AsInt64() int64 { return convertToCoreValue(rv).AsInt64() }
-
-// AsInt64OK is the same as AsInt64, except that it returns a boolean instead of
-// panicking.
-func (rv RawValue) AsInt64OK() (int64, bool) { return convertToCoreValue(rv).AsInt64OK() }
-
-// Decimal128 returns the decimal the Value represents. It panics if the value is a BSON type other than
-// decimal.
-func (rv RawValue) Decimal128() Decimal128 { return NewDecimal128(convertToCoreValue(rv).Decimal128()) }
-
-// Decimal128OK is the same as Decimal128, except that it returns a boolean
-// instead of panicking.
-func (rv RawValue) Decimal128OK() (Decimal128, bool) {
-	h, l, ok := convertToCoreValue(rv).Decimal128OK()
-	return NewDecimal128(h, l), ok
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/reader.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/reader.go
deleted file mode 100644
index 955d2e9f..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/reader.go
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-// ArrayReader is implemented by types that allow reading values from a BSON
-// array.
-type ArrayReader interface {
-	ReadValue() (ValueReader, error)
-}
-
-// DocumentReader is implemented by types that allow reading elements from a
-// BSON document.
-type DocumentReader interface {
-	ReadElement() (string, ValueReader, error)
-}
-
-// ValueReader is a generic interface used to read values from BSON. This type
-// is implemented by several types with different underlying representations of
-// BSON, such as a bson.Document, raw BSON bytes, or extended JSON.
-type ValueReader interface {
-	Type() Type
-	Skip() error
-
-	ReadArray() (ArrayReader, error)
-	ReadBinary() (b []byte, btype byte, err error)
-	ReadBoolean() (bool, error)
-	ReadDocument() (DocumentReader, error)
-	ReadCodeWithScope() (code string, dr DocumentReader, err error)
-	ReadDBPointer() (ns string, oid ObjectID, err error)
-	ReadDateTime() (int64, error)
-	ReadDecimal128() (Decimal128, error)
-	ReadDouble() (float64, error)
-	ReadInt32() (int32, error)
-	ReadInt64() (int64, error)
-	ReadJavascript() (code string, err error)
-	ReadMaxKey() error
-	ReadMinKey() error
-	ReadNull() error
-	ReadObjectID() (ObjectID, error)
-	ReadRegex() (pattern, options string, err error)
-	ReadString() (string, error)
-	ReadSymbol() (symbol string, err error)
-	ReadTimestamp() (t, i uint32, err error)
-	ReadUndefined() error
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/registry.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/registry.go
deleted file mode 100644
index d8f65ddc..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/registry.go
+++ /dev/null
@@ -1,381 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"sync"
-)
-
-// defaultRegistry is the default Registry. It contains the default codecs and the
-// primitive codecs.
-var defaultRegistry = NewRegistry()
-
-// errNoEncoder is returned when there wasn't an encoder available for a type.
-type errNoEncoder struct {
-	Type reflect.Type
-}
-
-func (ene errNoEncoder) Error() string {
-	if ene.Type == nil {
-		return "no encoder found for <nil>"
-	}
-	return "no encoder found for " + ene.Type.String()
-}
-
-// errNoDecoder is returned when there wasn't a decoder available for a type.
-type errNoDecoder struct {
-	Type reflect.Type
-}
-
-func (end errNoDecoder) Error() string {
-	return "no decoder found for " + end.Type.String()
-}
-
-// errNoTypeMapEntry is returned when there wasn't a type available for the provided BSON type.
-type errNoTypeMapEntry struct {
-	Type Type
-}
-
-func (entme errNoTypeMapEntry) Error() string {
-	return "no type map entry found for " + entme.Type.String()
-}
-
-// A Registry is a store for ValueEncoders, ValueDecoders, and a type map. See the Registry type
-// documentation for examples of registering various custom encoders and decoders. A Registry can
-// have four main types of codecs:
-//
-// 1. Type encoders/decoders - These can be registered using the RegisterTypeEncoder and
-// RegisterTypeDecoder methods. The registered codec will be invoked when encoding/decoding a value
-// whose type matches the registered type exactly.
-// If the registered type is an interface, the codec will be invoked when encoding or decoding
-// values whose type is the interface, but not for values with concrete types that implement the
-// interface.
-//
-// 2. Interface encoders/decoders - These can be registered using the RegisterInterfaceEncoder and
-// RegisterInterfaceDecoder methods. These methods only accept interface types and the registered codecs
-// will be invoked when encoding or decoding values whose types implement the interface. An example
-// of an interface defined by the driver is bson.Marshaler. The driver will call the MarshalBSON method
-// for any value whose type implements bson.Marshaler, regardless of the value's concrete type.
-//
-// 3. Type map entries - This can be used to associate a BSON type with a Go type. These type
-// associations are used when decoding into a bson.D/bson.M or a struct field of type interface{}.
-// For example, by default, BSON int32 and int64 values decode as Go int32 and int64 instances,
-// respectively, when decoding into a bson.D. The following code would change the behavior so these
-// values decode as Go int instances instead:
-//
-//	intType := reflect.TypeOf(int(0))
-//	registry.RegisterTypeMapEntry(bson.TypeInt32, intType).RegisterTypeMapEntry(bson.TypeInt64, intType)
-//
-// 4. Kind encoder/decoders - These can be registered using the RegisterDefaultEncoder and
-// RegisterDefaultDecoder methods. The registered codec will be invoked when encoding or decoding
-// values whose reflect.Kind matches the registered reflect.Kind as long as the value's type doesn't
-// match a registered type or interface encoder/decoder first. These methods should be used to change the
-// behavior for all values for a specific kind.
-//
-// Read [Registry.LookupDecoder] and [Registry.LookupEncoder] for Registry lookup procedure.
-type Registry struct {
-	interfaceEncoders []interfaceValueEncoder
-	interfaceDecoders []interfaceValueDecoder
-	typeEncoders      *typeEncoderCache
-	typeDecoders      *typeDecoderCache
-	kindEncoders      *kindEncoderCache
-	kindDecoders      *kindDecoderCache
-	typeMap           sync.Map // map[Type]reflect.Type
-}
-
-// NewRegistry creates a new empty Registry.
-func NewRegistry() *Registry {
-	reg := &Registry{
-		typeEncoders: new(typeEncoderCache),
-		typeDecoders: new(typeDecoderCache),
-		kindEncoders: new(kindEncoderCache),
-		kindDecoders: new(kindDecoderCache),
-	}
-	registerDefaultEncoders(reg)
-	registerDefaultDecoders(reg)
-	registerPrimitiveCodecs(reg)
-	return reg
-}
-
-// RegisterTypeEncoder registers the provided ValueEncoder for the provided type.
-//
-// The type will be used as provided, so an encoder can be registered for a type and a different
-// encoder can be registered for a pointer to that type.
-//
-// If the given type is an interface, the encoder will be called when marshaling a type that is
-// that interface. It will not be called when marshaling a non-interface type that implements the
-// interface. To get the latter behavior, call RegisterHookEncoder instead.
-//
-// RegisterTypeEncoder should not be called concurrently with any other Registry method.
-func (r *Registry) RegisterTypeEncoder(valueType reflect.Type, enc ValueEncoder) {
-	r.typeEncoders.Store(valueType, enc)
-}
-
-// RegisterTypeDecoder registers the provided ValueDecoder for the provided type.
-//
-// The type will be used as provided, so a decoder can be registered for a type and a different
-// decoder can be registered for a pointer to that type.
-//
-// If the given type is an interface, the decoder will be called when unmarshaling into a type that
-// is that interface. It will not be called when unmarshaling into a non-interface type that
-// implements the interface. To get the latter behavior, call RegisterHookDecoder instead.
-//
-// RegisterTypeDecoder should not be called concurrently with any other Registry method.
-func (r *Registry) RegisterTypeDecoder(valueType reflect.Type, dec ValueDecoder) {
-	r.typeDecoders.Store(valueType, dec)
-}
-
-// RegisterKindEncoder registers the provided ValueEncoder for the provided kind.
-//
-// Use RegisterKindEncoder to register an encoder for any type with the same underlying kind. For
-// example, consider the type MyInt defined as
-//
-//	type MyInt int32
-//
-// To define an encoder for MyInt and int32, use RegisterKindEncoder like
-//
-//	reg.RegisterKindEncoder(reflect.Int32, myEncoder)
-//
-// RegisterKindEncoder should not be called concurrently with any other Registry method.
-func (r *Registry) RegisterKindEncoder(kind reflect.Kind, enc ValueEncoder) {
-	r.kindEncoders.Store(kind, enc)
-}
-
-// RegisterKindDecoder registers the provided ValueDecoder for the provided kind.
-//
-// Use RegisterKindDecoder to register a decoder for any type with the same underlying kind. For
-// example, consider the type MyInt defined as
-//
-//	type MyInt int32
-//
-// To define an decoder for MyInt and int32, use RegisterKindDecoder like
-//
-//	reg.RegisterKindDecoder(reflect.Int32, myDecoder)
-//
-// RegisterKindDecoder should not be called concurrently with any other Registry method.
-func (r *Registry) RegisterKindDecoder(kind reflect.Kind, dec ValueDecoder) {
-	r.kindDecoders.Store(kind, dec)
-}
-
-// RegisterInterfaceEncoder registers an encoder for the provided interface type iface. This encoder will
-// be called when marshaling a type if the type implements iface or a pointer to the type
-// implements iface. If the provided type is not an interface
-// (i.e. iface.Kind() != reflect.Interface), this method will panic.
-//
-// RegisterInterfaceEncoder should not be called concurrently with any other Registry method.
-func (r *Registry) RegisterInterfaceEncoder(iface reflect.Type, enc ValueEncoder) {
-	if iface.Kind() != reflect.Interface {
-		panicStr := fmt.Errorf("RegisterInterfaceEncoder expects a type with kind reflect.Interface, "+
-			"got type %s with kind %s", iface, iface.Kind())
-		panic(panicStr)
-	}
-
-	for idx, encoder := range r.interfaceEncoders {
-		if encoder.i == iface {
-			r.interfaceEncoders[idx].ve = enc
-			return
-		}
-	}
-
-	r.interfaceEncoders = append(r.interfaceEncoders, interfaceValueEncoder{i: iface, ve: enc})
-}
-
-// RegisterInterfaceDecoder registers an decoder for the provided interface type iface. This decoder will
-// be called when unmarshaling into a type if the type implements iface or a pointer to the type
-// implements iface. If the provided type is not an interface (i.e. iface.Kind() != reflect.Interface),
-// this method will panic.
-//
-// RegisterInterfaceDecoder should not be called concurrently with any other Registry method.
-func (r *Registry) RegisterInterfaceDecoder(iface reflect.Type, dec ValueDecoder) {
-	if iface.Kind() != reflect.Interface {
-		panicStr := fmt.Errorf("RegisterInterfaceDecoder expects a type with kind reflect.Interface, "+
-			"got type %s with kind %s", iface, iface.Kind())
-		panic(panicStr)
-	}
-
-	for idx, decoder := range r.interfaceDecoders {
-		if decoder.i == iface {
-			r.interfaceDecoders[idx].vd = dec
-			return
-		}
-	}
-
-	r.interfaceDecoders = append(r.interfaceDecoders, interfaceValueDecoder{i: iface, vd: dec})
-}
-
-// RegisterTypeMapEntry will register the provided type to the BSON type. The primary usage for this
-// mapping is decoding situations where an empty interface is used and a default type needs to be
-// created and decoded into.
-//
-// By default, BSON documents will decode into interface{} values as bson.D. To change the default type for BSON
-// documents, a type map entry for TypeEmbeddedDocument should be registered. For example, to force BSON documents
-// to decode to bson.Raw, use the following code:
-//
-//	reg.RegisterTypeMapEntry(TypeEmbeddedDocument, reflect.TypeOf(bson.Raw{}))
-func (r *Registry) RegisterTypeMapEntry(bt Type, rt reflect.Type) {
-	r.typeMap.Store(bt, rt)
-}
-
-// LookupEncoder returns the first matching encoder in the Registry. It uses the following lookup
-// order:
-//
-// 1. An encoder registered for the exact type. If the given type is an interface, an encoder
-// registered using RegisterTypeEncoder for that interface will be selected.
-//
-// 2. An encoder registered using RegisterInterfaceEncoder for an interface implemented by the type
-// or by a pointer to the type. If the value matches multiple interfaces (e.g. the type implements
-// bson.Marshaler and bson.ValueMarshaler), the first one registered will be selected.
-// Note that registries constructed using bson.NewRegistry have driver-defined interfaces registered
-// for the bson.Marshaler, bson.ValueMarshaler, and bson.Proxy interfaces, so those will take
-// precedence over any new interfaces.
-//
-// 3. An encoder registered using RegisterKindEncoder for the kind of value.
-//
-// If no encoder is found, an error of type ErrNoEncoder is returned. LookupEncoder is safe for
-// concurrent use by multiple goroutines after all codecs and encoders are registered.
-func (r *Registry) LookupEncoder(valueType reflect.Type) (ValueEncoder, error) {
-	if valueType == nil {
-		return nil, errNoEncoder{Type: valueType}
-	}
-	enc, found := r.lookupTypeEncoder(valueType)
-	if found {
-		if enc == nil {
-			return nil, errNoEncoder{Type: valueType}
-		}
-		return enc, nil
-	}
-
-	enc, found = r.lookupInterfaceEncoder(valueType, true)
-	if found {
-		return r.typeEncoders.LoadOrStore(valueType, enc), nil
-	}
-
-	if v, ok := r.kindEncoders.Load(valueType.Kind()); ok {
-		return r.storeTypeEncoder(valueType, v), nil
-	}
-	return nil, errNoEncoder{Type: valueType}
-}
-
-func (r *Registry) storeTypeEncoder(rt reflect.Type, enc ValueEncoder) ValueEncoder {
-	return r.typeEncoders.LoadOrStore(rt, enc)
-}
-
-func (r *Registry) lookupTypeEncoder(rt reflect.Type) (ValueEncoder, bool) {
-	return r.typeEncoders.Load(rt)
-}
-
-func (r *Registry) lookupInterfaceEncoder(valueType reflect.Type, allowAddr bool) (ValueEncoder, bool) {
-	if valueType == nil {
-		return nil, false
-	}
-	for _, ienc := range r.interfaceEncoders {
-		if valueType.Implements(ienc.i) {
-			return ienc.ve, true
-		}
-		if allowAddr && valueType.Kind() != reflect.Ptr && reflect.PtrTo(valueType).Implements(ienc.i) {
-			// if *t implements an interface, this will catch if t implements an interface further
-			// ahead in interfaceEncoders
-			defaultEnc, found := r.lookupInterfaceEncoder(valueType, false)
-			if !found {
-				defaultEnc, _ = r.kindEncoders.Load(valueType.Kind())
-			}
-			return newCondAddrEncoder(ienc.ve, defaultEnc), true
-		}
-	}
-	return nil, false
-}
-
-// LookupDecoder returns the first matching decoder in the Registry. It uses the following lookup
-// order:
-//
-// 1. A decoder registered for the exact type. If the given type is an interface, a decoder
-// registered using RegisterTypeDecoder for that interface will be selected.
-//
-// 2. A decoder registered using RegisterInterfaceDecoder for an interface implemented by the type or by
-// a pointer to the type. If the value matches multiple interfaces (e.g. the type implements
-// bson.Unmarshaler and bson.ValueUnmarshaler), the first one registered will be selected.
-// Note that registries constructed using bson.NewRegistry have driver-defined interfaces registered
-// for the bson.Unmarshaler and bson.ValueUnmarshaler interfaces, so those will take
-// precedence over any new interfaces.
-//
-// 3. A decoder registered using RegisterKindDecoder for the kind of value.
-//
-// If no decoder is found, an error of type ErrNoDecoder is returned. LookupDecoder is safe for
-// concurrent use by multiple goroutines after all codecs and decoders are registered.
-func (r *Registry) LookupDecoder(valueType reflect.Type) (ValueDecoder, error) {
-	if valueType == nil {
-		return nil, errors.New("cannot perform a decoder lookup on <nil>")
-	}
-	dec, found := r.lookupTypeDecoder(valueType)
-	if found {
-		if dec == nil {
-			return nil, errNoDecoder{Type: valueType}
-		}
-		return dec, nil
-	}
-
-	dec, found = r.lookupInterfaceDecoder(valueType, true)
-	if found {
-		return r.storeTypeDecoder(valueType, dec), nil
-	}
-
-	if v, ok := r.kindDecoders.Load(valueType.Kind()); ok {
-		return r.storeTypeDecoder(valueType, v), nil
-	}
-	return nil, errNoDecoder{Type: valueType}
-}
-
-func (r *Registry) lookupTypeDecoder(valueType reflect.Type) (ValueDecoder, bool) {
-	return r.typeDecoders.Load(valueType)
-}
-
-func (r *Registry) storeTypeDecoder(typ reflect.Type, dec ValueDecoder) ValueDecoder {
-	return r.typeDecoders.LoadOrStore(typ, dec)
-}
-
-func (r *Registry) lookupInterfaceDecoder(valueType reflect.Type, allowAddr bool) (ValueDecoder, bool) {
-	for _, idec := range r.interfaceDecoders {
-		if valueType.Implements(idec.i) {
-			return idec.vd, true
-		}
-		if allowAddr && valueType.Kind() != reflect.Ptr && reflect.PtrTo(valueType).Implements(idec.i) {
-			// if *t implements an interface, this will catch if t implements an interface further
-			// ahead in interfaceDecoders
-			defaultDec, found := r.lookupInterfaceDecoder(valueType, false)
-			if !found {
-				defaultDec, _ = r.kindDecoders.Load(valueType.Kind())
-			}
-			return newCondAddrDecoder(idec.vd, defaultDec), true
-		}
-	}
-	return nil, false
-}
-
-// LookupTypeMapEntry inspects the registry's type map for a Go type for the corresponding BSON
-// type. If no type is found, ErrNoTypeMapEntry is returned.
-//
-// LookupTypeMapEntry should not be called concurrently with any other Registry method.
-func (r *Registry) LookupTypeMapEntry(bt Type) (reflect.Type, error) {
-	v, ok := r.typeMap.Load(bt)
-	if v == nil || !ok {
-		return nil, errNoTypeMapEntry{Type: bt}
-	}
-	return v.(reflect.Type), nil
-}
-
-type interfaceValueEncoder struct {
-	i  reflect.Type
-	ve ValueEncoder
-}
-
-type interfaceValueDecoder struct {
-	i  reflect.Type
-	vd ValueDecoder
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/slice_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/slice_codec.go
deleted file mode 100644
index c8719dcc..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/slice_codec.go
+++ /dev/null
@@ -1,173 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-)
-
-// sliceCodec is the Codec used for slice values.
-type sliceCodec struct {
-	// encodeNilAsEmpty causes EncodeValue to marshal nil Go slices as empty BSON arrays instead of
-	// BSON null.
-	encodeNilAsEmpty bool
-}
-
-// EncodeValue is the ValueEncoder for slice types.
-func (sc *sliceCodec) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Kind() != reflect.Slice {
-		return ValueEncoderError{Name: "SliceEncodeValue", Kinds: []reflect.Kind{reflect.Slice}, Received: val}
-	}
-
-	if val.IsNil() && !sc.encodeNilAsEmpty && !ec.nilSliceAsEmpty {
-		return vw.WriteNull()
-	}
-
-	// If we have a []byte we want to treat it as a binary instead of as an array.
-	if val.Type().Elem() == tByte {
-		byteSlice := make([]byte, val.Len())
-		reflect.Copy(reflect.ValueOf(byteSlice), val)
-		return vw.WriteBinary(byteSlice)
-	}
-
-	// If we have a []E we want to treat it as a document instead of as an array.
-	if val.Type() == tD || val.Type().ConvertibleTo(tD) {
-		d := val.Convert(tD).Interface().(D)
-
-		dw, err := vw.WriteDocument()
-		if err != nil {
-			return err
-		}
-
-		for _, e := range d {
-			err = encodeElement(ec, dw, e)
-			if err != nil {
-				return err
-			}
-		}
-
-		return dw.WriteDocumentEnd()
-	}
-
-	aw, err := vw.WriteArray()
-	if err != nil {
-		return err
-	}
-
-	elemType := val.Type().Elem()
-	encoder, err := ec.LookupEncoder(elemType)
-	if err != nil && elemType.Kind() != reflect.Interface {
-		return err
-	}
-
-	for idx := 0; idx < val.Len(); idx++ {
-		currEncoder, currVal, lookupErr := lookupElementEncoder(ec, encoder, val.Index(idx))
-		if lookupErr != nil && !errors.Is(lookupErr, errInvalidValue) {
-			return lookupErr
-		}
-
-		vw, err := aw.WriteArrayElement()
-		if err != nil {
-			return err
-		}
-
-		if errors.Is(lookupErr, errInvalidValue) {
-			err = vw.WriteNull()
-			if err != nil {
-				return err
-			}
-			continue
-		}
-
-		err = currEncoder.EncodeValue(ec, vw, currVal)
-		if err != nil {
-			return err
-		}
-	}
-	return aw.WriteArrayEnd()
-}
-
-// DecodeValue is the ValueDecoder for slice types.
-func (sc *sliceCodec) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Kind() != reflect.Slice {
-		return ValueDecoderError{Name: "SliceDecodeValue", Kinds: []reflect.Kind{reflect.Slice}, Received: val}
-	}
-
-	switch vrType := vr.Type(); vrType {
-	case TypeArray:
-	case TypeNull:
-		val.Set(reflect.Zero(val.Type()))
-		return vr.ReadNull()
-	case TypeUndefined:
-		val.Set(reflect.Zero(val.Type()))
-		return vr.ReadUndefined()
-	case Type(0), TypeEmbeddedDocument:
-		if val.Type().Elem() != tE {
-			return fmt.Errorf("cannot decode document into %s", val.Type())
-		}
-	case TypeBinary:
-		if val.Type().Elem() != tByte {
-			return fmt.Errorf("SliceDecodeValue can only decode a binary into a byte array, got %v", vrType)
-		}
-		data, subtype, err := vr.ReadBinary()
-		if err != nil {
-			return err
-		}
-		if subtype != TypeBinaryGeneric && subtype != TypeBinaryBinaryOld {
-			return fmt.Errorf("SliceDecodeValue can only be used to decode subtype 0x00 or 0x02 for %s, got %v", TypeBinary, subtype)
-		}
-
-		if val.IsNil() {
-			val.Set(reflect.MakeSlice(val.Type(), 0, len(data)))
-		}
-		val.SetLen(0)
-		val.Set(reflect.AppendSlice(val, reflect.ValueOf(data)))
-		return nil
-	case TypeString:
-		if sliceType := val.Type().Elem(); sliceType != tByte {
-			return fmt.Errorf("SliceDecodeValue can only decode a string into a byte array, got %v", sliceType)
-		}
-		str, err := vr.ReadString()
-		if err != nil {
-			return err
-		}
-		byteStr := []byte(str)
-
-		if val.IsNil() {
-			val.Set(reflect.MakeSlice(val.Type(), 0, len(byteStr)))
-		}
-		val.SetLen(0)
-		val.Set(reflect.AppendSlice(val, reflect.ValueOf(byteStr)))
-		return nil
-	default:
-		return fmt.Errorf("cannot decode %v into a slice", vrType)
-	}
-
-	var elemsFunc func(DecodeContext, ValueReader, reflect.Value) ([]reflect.Value, error)
-	switch val.Type().Elem() {
-	case tE:
-		elemsFunc = decodeD
-	default:
-		elemsFunc = decodeDefault
-	}
-
-	elems, err := elemsFunc(dc, vr, val)
-	if err != nil {
-		return err
-	}
-
-	if val.IsNil() {
-		val.Set(reflect.MakeSlice(val.Type(), 0, len(elems)))
-	}
-
-	val.SetLen(0)
-	val.Set(reflect.Append(val, elems...))
-
-	return nil
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/string_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/string_codec.go
deleted file mode 100644
index 456028c1..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/string_codec.go
+++ /dev/null
@@ -1,107 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-)
-
-// stringCodec is the Codec used for string values.
-type stringCodec struct{}
-
-// Assert that stringCodec satisfies the typeDecoder interface, which allows it to be
-// used by collection type decoders (e.g. map, slice, etc) to set individual values in a
-// collection.
-var _ typeDecoder = &stringCodec{}
-
-// EncodeValue is the ValueEncoder for string types.
-func (sc *stringCodec) EncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if val.Kind() != reflect.String {
-		return ValueEncoderError{
-			Name:     "StringEncodeValue",
-			Kinds:    []reflect.Kind{reflect.String},
-			Received: val,
-		}
-	}
-
-	return vw.WriteString(val.String())
-}
-
-func (sc *stringCodec) decodeType(dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t.Kind() != reflect.String {
-		return emptyValue, ValueDecoderError{
-			Name:     "StringDecodeValue",
-			Kinds:    []reflect.Kind{reflect.String},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	var str string
-	var err error
-	switch vr.Type() {
-	case TypeString:
-		str, err = vr.ReadString()
-		if err != nil {
-			return emptyValue, err
-		}
-	case TypeObjectID:
-		if dc.objectIDAsHexString {
-			oid, err := vr.ReadObjectID()
-			if err != nil {
-				return emptyValue, err
-			}
-			str = oid.Hex()
-		} else {
-			const msg = "decoding an object ID into a string is not supported by default " +
-				"(set Decoder.ObjectIDAsHexString to enable decoding as a hexadecimal string)"
-			return emptyValue, errors.New(msg)
-		}
-	case TypeSymbol:
-		str, err = vr.ReadSymbol()
-		if err != nil {
-			return emptyValue, err
-		}
-	case TypeBinary:
-		data, subtype, err := vr.ReadBinary()
-		if err != nil {
-			return emptyValue, err
-		}
-		if subtype != TypeBinaryGeneric && subtype != TypeBinaryBinaryOld {
-			return emptyValue, decodeBinaryError{subtype: subtype, typeName: "string"}
-		}
-		str = string(data)
-	case TypeNull:
-		if err = vr.ReadNull(); err != nil {
-			return emptyValue, err
-		}
-	case TypeUndefined:
-		if err = vr.ReadUndefined(); err != nil {
-			return emptyValue, err
-		}
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a string type", vr.Type())
-	}
-
-	return reflect.ValueOf(str), nil
-}
-
-// DecodeValue is the ValueDecoder for string types.
-func (sc *stringCodec) DecodeValue(dctx DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Kind() != reflect.String {
-		return ValueDecoderError{Name: "StringDecodeValue", Kinds: []reflect.Kind{reflect.String}, Received: val}
-	}
-
-	elem, err := sc.decodeType(dctx, vr, val.Type())
-	if err != nil {
-		return err
-	}
-
-	val.SetString(elem.String())
-	return nil
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/struct_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/struct_codec.go
deleted file mode 100644
index 83b63f5f..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/struct_codec.go
+++ /dev/null
@@ -1,695 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"sort"
-	"strings"
-	"sync"
-	"time"
-)
-
-// DecodeError represents an error that occurs when unmarshalling BSON bytes into a native Go type.
-type DecodeError struct {
-	keys    []string
-	wrapped error
-}
-
-// Unwrap returns the underlying error
-func (de *DecodeError) Unwrap() error {
-	return de.wrapped
-}
-
-// Error implements the error interface.
-func (de *DecodeError) Error() string {
-	// The keys are stored in reverse order because the de.keys slice is builtup while propagating the error up the
-	// stack of BSON keys, so we call de.Keys(), which reverses them.
-	keyPath := strings.Join(de.Keys(), ".")
-	return fmt.Sprintf("error decoding key %s: %v", keyPath, de.wrapped)
-}
-
-// Keys returns the BSON key path that caused an error as a slice of strings. The keys in the slice are in top-down
-// order. For example, if the document being unmarshalled was {a: {b: {c: 1}}} and the value for c was supposed to be
-// a string, the keys slice will be ["a", "b", "c"].
-func (de *DecodeError) Keys() []string {
-	reversedKeys := make([]string, 0, len(de.keys))
-	for idx := len(de.keys) - 1; idx >= 0; idx-- {
-		reversedKeys = append(reversedKeys, de.keys[idx])
-	}
-
-	return reversedKeys
-}
-
-// mapElementsEncoder handles encoding of the values of an inline  map.
-type mapElementsEncoder interface {
-	encodeMapElements(EncodeContext, DocumentWriter, reflect.Value, func(string) bool) error
-}
-
-// structCodec is the Codec used for struct values.
-type structCodec struct {
-	cache            sync.Map // map[reflect.Type]*structDescription
-	inlineMapEncoder mapElementsEncoder
-
-	// decodeZeroStruct causes DecodeValue to delete any existing values from Go structs in the
-	// destination value passed to Decode before unmarshaling BSON documents into them.
-	decodeZeroStruct bool
-
-	// decodeDeepZeroInline causes DecodeValue to delete any existing values from Go structs in the
-	// destination value passed to Decode before unmarshaling BSON documents into them.
-	decodeDeepZeroInline bool
-
-	// encodeOmitDefaultStruct causes the Encoder to consider the zero value for a struct (e.g.
-	// MyStruct{}) as empty and omit it from the marshaled BSON when the "omitempty" struct tag
-	// option is set.
-	encodeOmitDefaultStruct bool
-
-	// allowUnexportedFields allows encoding and decoding values from un-exported struct fields.
-	allowUnexportedFields bool
-
-	// overwriteDuplicatedInlinedFields, if false, causes EncodeValue to return an error if there is
-	// a duplicate field in the marshaled BSON when the "inline" struct tag option is set. The
-	// default value is true.
-	overwriteDuplicatedInlinedFields bool
-}
-
-var (
-	_ ValueEncoder = &structCodec{}
-	_ ValueDecoder = &structCodec{}
-)
-
-// newStructCodec returns a StructCodec that uses p for struct tag parsing.
-func newStructCodec(elemEncoder mapElementsEncoder) *structCodec {
-	return &structCodec{
-		inlineMapEncoder:                 elemEncoder,
-		overwriteDuplicatedInlinedFields: true,
-	}
-}
-
-// EncodeValue handles encoding generic struct types.
-func (sc *structCodec) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Kind() != reflect.Struct {
-		return ValueEncoderError{Name: "StructCodec.EncodeValue", Kinds: []reflect.Kind{reflect.Struct}, Received: val}
-	}
-
-	sd, err := sc.describeStruct(ec.Registry, val.Type(), ec.useJSONStructTags, ec.errorOnInlineDuplicates)
-	if err != nil {
-		return err
-	}
-
-	dw, err := vw.WriteDocument()
-	if err != nil {
-		return err
-	}
-	var rv reflect.Value
-	for _, desc := range sd.fl {
-		if desc.inline == nil {
-			rv = val.Field(desc.idx)
-		} else {
-			rv, err = fieldByIndexErr(val, desc.inline)
-			if err != nil {
-				continue
-			}
-		}
-
-		if ec.omitEmpty {
-			desc.omitEmpty = true
-		}
-
-		desc.encoder, rv, err = lookupElementEncoder(ec, desc.encoder, rv)
-
-		if err != nil && !errors.Is(err, errInvalidValue) {
-			return err
-		}
-
-		if errors.Is(err, errInvalidValue) {
-			if desc.omitEmpty {
-				continue
-			}
-			vw2, err := dw.WriteDocumentElement(desc.name)
-			if err != nil {
-				return err
-			}
-			err = vw2.WriteNull()
-			if err != nil {
-				return err
-			}
-			continue
-		}
-
-		if desc.encoder == nil {
-			return errNoEncoder{Type: rv.Type()}
-		}
-
-		encoder := desc.encoder
-
-		var empty bool
-		if rv.Kind() == reflect.Interface {
-			// isEmpty will not treat an interface rv as an interface, so we need to check for the
-			// nil interface separately.
-			empty = rv.IsNil()
-		} else {
-			empty = isEmpty(rv, sc.encodeOmitDefaultStruct || ec.omitZeroStruct)
-		}
-		if desc.omitEmpty && empty {
-			continue
-		}
-
-		vw2, err := dw.WriteDocumentElement(desc.name)
-		if err != nil {
-			return err
-		}
-
-		ectx := EncodeContext{
-			Registry:                ec.Registry,
-			minSize:                 desc.minSize || ec.minSize,
-			errorOnInlineDuplicates: ec.errorOnInlineDuplicates,
-			stringifyMapKeysWithFmt: ec.stringifyMapKeysWithFmt,
-			nilMapAsEmpty:           ec.nilMapAsEmpty,
-			nilSliceAsEmpty:         ec.nilSliceAsEmpty,
-			nilByteSliceAsEmpty:     ec.nilByteSliceAsEmpty,
-			omitZeroStruct:          ec.omitZeroStruct,
-			useJSONStructTags:       ec.useJSONStructTags,
-		}
-		err = encoder.EncodeValue(ectx, vw2, rv)
-		if err != nil {
-			return err
-		}
-	}
-
-	if sd.inlineMap >= 0 {
-		rv := val.Field(sd.inlineMap)
-		collisionFn := func(key string) bool {
-			_, exists := sd.fm[key]
-			return exists
-		}
-
-		err = sc.inlineMapEncoder.encodeMapElements(ec, dw, rv, collisionFn)
-		if err != nil {
-			return err
-		}
-	}
-
-	return dw.WriteDocumentEnd()
-}
-
-func newDecodeError(key string, original error) error {
-	var de *DecodeError
-	if !errors.As(original, &de) {
-		return &DecodeError{
-			keys:    []string{key},
-			wrapped: original,
-		}
-	}
-
-	de.keys = append(de.keys, key)
-	return de
-}
-
-// DecodeValue implements the Codec interface.
-// By default, map types in val will not be cleared. If a map has existing key/value pairs, it will be extended with the new ones from vr.
-// For slices, the decoder will set the length of the slice to zero and append all elements. The underlying array will not be cleared.
-func (sc *structCodec) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Kind() != reflect.Struct {
-		return ValueDecoderError{Name: "StructCodec.DecodeValue", Kinds: []reflect.Kind{reflect.Struct}, Received: val}
-	}
-
-	switch vrType := vr.Type(); vrType {
-	case Type(0), TypeEmbeddedDocument:
-	case TypeNull:
-		if err := vr.ReadNull(); err != nil {
-			return err
-		}
-
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	case TypeUndefined:
-		if err := vr.ReadUndefined(); err != nil {
-			return err
-		}
-
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	default:
-		return fmt.Errorf("cannot decode %v into a %s", vrType, val.Type())
-	}
-
-	sd, err := sc.describeStruct(dc.Registry, val.Type(), dc.useJSONStructTags, false)
-	if err != nil {
-		return err
-	}
-
-	if sc.decodeZeroStruct || dc.zeroStructs {
-		val.Set(reflect.Zero(val.Type()))
-	}
-	if sc.decodeDeepZeroInline && sd.inline {
-		val.Set(deepZero(val.Type()))
-	}
-
-	var decoder ValueDecoder
-	var inlineMap reflect.Value
-	if sd.inlineMap >= 0 {
-		inlineMap = val.Field(sd.inlineMap)
-		decoder, err = dc.LookupDecoder(inlineMap.Type().Elem())
-		if err != nil {
-			return err
-		}
-	}
-
-	dr, err := vr.ReadDocument()
-	if err != nil {
-		return err
-	}
-
-	for {
-		name, vr, err := dr.ReadElement()
-		if errors.Is(err, ErrEOD) {
-			break
-		}
-		if err != nil {
-			return err
-		}
-
-		fd, exists := sd.fm[name]
-		if !exists {
-			// if the original name isn't found in the struct description, try again with the name in lowercase
-			// this could match if a BSON tag isn't specified because by default, describeStruct lowercases all field
-			// names
-			fd, exists = sd.fm[strings.ToLower(name)]
-		}
-
-		if !exists {
-			if sd.inlineMap < 0 {
-				// The encoding/json package requires a flag to return on error for non-existent fields.
-				// This functionality seems appropriate for the struct codec.
-				err = vr.Skip()
-				if err != nil {
-					return err
-				}
-				continue
-			}
-
-			if inlineMap.IsNil() {
-				inlineMap.Set(reflect.MakeMap(inlineMap.Type()))
-			}
-
-			elem := reflect.New(inlineMap.Type().Elem()).Elem()
-			err = decoder.DecodeValue(dc, vr, elem)
-			if err != nil {
-				return err
-			}
-			inlineMap.SetMapIndex(reflect.ValueOf(name), elem)
-			continue
-		}
-
-		var field reflect.Value
-		if fd.inline == nil {
-			field = val.Field(fd.idx)
-		} else {
-			field, err = getInlineField(val, fd.inline)
-			if err != nil {
-				return err
-			}
-		}
-
-		if field.Kind() == reflect.Interface && !field.IsNil() && field.Elem().Kind() == reflect.Ptr {
-			v := field.Elem().Elem()
-			decoder, err = dc.LookupDecoder(v.Type())
-			if err != nil {
-				return err
-			}
-			err = decoder.DecodeValue(dc, vr, v)
-			if err != nil {
-				return newDecodeError(fd.name, err)
-			}
-			continue
-		}
-
-		if !field.CanSet() { // Being settable is a super set of being addressable.
-			innerErr := fmt.Errorf("field %v is not settable", field)
-			return newDecodeError(fd.name, innerErr)
-		}
-		if field.Kind() == reflect.Ptr && field.IsNil() {
-			field.Set(reflect.New(field.Type().Elem()))
-		}
-		field = field.Addr()
-
-		dctx := DecodeContext{
-			Registry:            dc.Registry,
-			truncate:            fd.truncate || dc.truncate,
-			defaultDocumentType: dc.defaultDocumentType,
-			binaryAsSlice:       dc.binaryAsSlice,
-			objectIDAsHexString: dc.objectIDAsHexString,
-			useJSONStructTags:   dc.useJSONStructTags,
-			useLocalTimeZone:    dc.useLocalTimeZone,
-			zeroMaps:            dc.zeroMaps,
-			zeroStructs:         dc.zeroStructs,
-		}
-
-		if fd.decoder == nil {
-			return newDecodeError(fd.name, errNoDecoder{Type: field.Elem().Type()})
-		}
-
-		err = fd.decoder.DecodeValue(dctx, vr, field.Elem())
-		if err != nil {
-			return newDecodeError(fd.name, err)
-		}
-	}
-
-	return nil
-}
-
-func isEmpty(v reflect.Value, omitZeroStruct bool) bool {
-	kind := v.Kind()
-	if (kind != reflect.Ptr || !v.IsNil()) && v.Type().Implements(tZeroer) {
-		return v.Interface().(Zeroer).IsZero()
-	}
-	switch kind {
-	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
-		return v.Len() == 0
-	case reflect.Struct:
-		if !omitZeroStruct {
-			return false
-		}
-		vt := v.Type()
-		if vt == tTime {
-			return v.Interface().(time.Time).IsZero()
-		}
-		numField := vt.NumField()
-		for i := 0; i < numField; i++ {
-			ff := vt.Field(i)
-			if ff.PkgPath != "" && !ff.Anonymous {
-				continue // Private field
-			}
-			if !isEmpty(v.Field(i), omitZeroStruct) {
-				return false
-			}
-		}
-		return true
-	}
-	return !v.IsValid() || v.IsZero()
-}
-
-type structDescription struct {
-	fm        map[string]fieldDescription
-	fl        []fieldDescription
-	inlineMap int
-	inline    bool
-}
-
-type fieldDescription struct {
-	name      string // BSON key name
-	fieldName string // struct field name
-	idx       int
-	omitEmpty bool
-	minSize   bool
-	truncate  bool
-	inline    []int
-	encoder   ValueEncoder
-	decoder   ValueDecoder
-}
-
-type byIndex []fieldDescription
-
-func (bi byIndex) Len() int { return len(bi) }
-
-func (bi byIndex) Swap(i, j int) { bi[i], bi[j] = bi[j], bi[i] }
-
-func (bi byIndex) Less(i, j int) bool {
-	// If a field is inlined, its index in the top level struct is stored at inline[0]
-	iIdx, jIdx := bi[i].idx, bi[j].idx
-	if len(bi[i].inline) > 0 {
-		iIdx = bi[i].inline[0]
-	}
-	if len(bi[j].inline) > 0 {
-		jIdx = bi[j].inline[0]
-	}
-	if iIdx != jIdx {
-		return iIdx < jIdx
-	}
-	for k, biik := range bi[i].inline {
-		if k >= len(bi[j].inline) {
-			return false
-		}
-		if biik != bi[j].inline[k] {
-			return biik < bi[j].inline[k]
-		}
-	}
-	return len(bi[i].inline) < len(bi[j].inline)
-}
-
-func (sc *structCodec) describeStruct(
-	r *Registry,
-	t reflect.Type,
-	useJSONStructTags bool,
-	errorOnDuplicates bool,
-) (*structDescription, error) {
-	// We need to analyze the struct, including getting the tags, collecting
-	// information about inlining, and create a map of the field name to the field.
-	if v, ok := sc.cache.Load(t); ok {
-		return v.(*structDescription), nil
-	}
-	// TODO(charlie): Only describe the struct once when called
-	// concurrently with the same type.
-	ds, err := sc.describeStructSlow(r, t, useJSONStructTags, errorOnDuplicates)
-	if err != nil {
-		return nil, err
-	}
-	if v, loaded := sc.cache.LoadOrStore(t, ds); loaded {
-		ds = v.(*structDescription)
-	}
-	return ds, nil
-}
-
-func (sc *structCodec) describeStructSlow(
-	r *Registry,
-	t reflect.Type,
-	useJSONStructTags bool,
-	errorOnDuplicates bool,
-) (*structDescription, error) {
-	numFields := t.NumField()
-	sd := &structDescription{
-		fm:        make(map[string]fieldDescription, numFields),
-		fl:        make([]fieldDescription, 0, numFields),
-		inlineMap: -1,
-	}
-
-	var fields []fieldDescription
-	for i := 0; i < numFields; i++ {
-		sf := t.Field(i)
-		if sf.PkgPath != "" && (!sc.allowUnexportedFields || !sf.Anonymous) {
-			// field is private or unexported fields aren't allowed, ignore
-			continue
-		}
-
-		sfType := sf.Type
-		encoder, err := r.LookupEncoder(sfType)
-		if err != nil {
-			encoder = nil
-		}
-		decoder, err := r.LookupDecoder(sfType)
-		if err != nil {
-			decoder = nil
-		}
-
-		description := fieldDescription{
-			fieldName: sf.Name,
-			idx:       i,
-			encoder:   encoder,
-			decoder:   decoder,
-		}
-
-		var stags *structTags
-		// If the caller requested that we use JSON struct tags, use the JSONFallbackStructTagParser
-		// instead of the parser defined on the codec.
-		if useJSONStructTags {
-			stags, err = parseJSONStructTags(sf)
-		} else {
-			stags, err = parseStructTags(sf)
-		}
-		if err != nil {
-			return nil, err
-		}
-		if stags.Skip {
-			continue
-		}
-		description.name = stags.Name
-		description.omitEmpty = stags.OmitEmpty
-		description.minSize = stags.MinSize
-		description.truncate = stags.Truncate
-
-		if stags.Inline {
-			sd.inline = true
-			switch sfType.Kind() {
-			case reflect.Map:
-				if sd.inlineMap >= 0 {
-					return nil, errors.New("(struct " + t.String() + ") multiple inline maps")
-				}
-				if sfType.Key() != tString {
-					return nil, errors.New("(struct " + t.String() + ") inline map must have a string keys")
-				}
-				sd.inlineMap = description.idx
-			case reflect.Ptr:
-				sfType = sfType.Elem()
-				if sfType.Kind() != reflect.Struct {
-					return nil, fmt.Errorf("(struct %s) inline fields must be a struct, a struct pointer, or a map", t.String())
-				}
-				fallthrough
-			case reflect.Struct:
-				inlinesf, err := sc.describeStruct(r, sfType, useJSONStructTags, errorOnDuplicates)
-				if err != nil {
-					return nil, err
-				}
-				for _, fd := range inlinesf.fl {
-					if fd.inline == nil {
-						fd.inline = []int{i, fd.idx}
-					} else {
-						fd.inline = append([]int{i}, fd.inline...)
-					}
-					fields = append(fields, fd)
-
-				}
-			default:
-				return nil, fmt.Errorf("(struct %s) inline fields must be a struct, a struct pointer, or a map", t.String())
-			}
-			continue
-		}
-		fields = append(fields, description)
-	}
-
-	// Sort fieldDescriptions by name and use dominance rules to determine which should be added for each name
-	sort.Slice(fields, func(i, j int) bool {
-		x := fields
-		// sort field by name, breaking ties with depth, then
-		// breaking ties with index sequence.
-		if x[i].name != x[j].name {
-			return x[i].name < x[j].name
-		}
-		if len(x[i].inline) != len(x[j].inline) {
-			return len(x[i].inline) < len(x[j].inline)
-		}
-		return byIndex(x).Less(i, j)
-	})
-
-	for advance, i := 0, 0; i < len(fields); i += advance {
-		// One iteration per name.
-		// Find the sequence of fields with the name of this first field.
-		fi := fields[i]
-		name := fi.name
-		for advance = 1; i+advance < len(fields); advance++ {
-			fj := fields[i+advance]
-			if fj.name != name {
-				break
-			}
-		}
-		if advance == 1 { // Only one field with this name
-			sd.fl = append(sd.fl, fi)
-			sd.fm[name] = fi
-			continue
-		}
-		dominant, ok := dominantField(fields[i : i+advance])
-		if !ok || !sc.overwriteDuplicatedInlinedFields || errorOnDuplicates {
-			return nil, fmt.Errorf("struct %s has duplicated key %s", t.String(), name)
-		}
-		sd.fl = append(sd.fl, dominant)
-		sd.fm[name] = dominant
-	}
-
-	sort.Sort(byIndex(sd.fl))
-
-	return sd, nil
-}
-
-// dominantField looks through the fields, all of which are known to
-// have the same name, to find the single field that dominates the
-// others using Go's inlining rules. If there are multiple top-level
-// fields, the boolean will be false: This condition is an error in Go
-// and we skip all the fields.
-func dominantField(fields []fieldDescription) (fieldDescription, bool) {
-	// The fields are sorted in increasing index-length order, then by presence of tag.
-	// That means that the first field is the dominant one. We need only check
-	// for error cases: two fields at top level.
-	if len(fields) > 1 &&
-		len(fields[0].inline) == len(fields[1].inline) {
-		return fieldDescription{}, false
-	}
-	return fields[0], true
-}
-
-func fieldByIndexErr(v reflect.Value, index []int) (result reflect.Value, err error) {
-	defer func() {
-		if recovered := recover(); recovered != nil {
-			switch r := recovered.(type) {
-			case string:
-				err = fmt.Errorf("%s", r)
-			case error:
-				err = r
-			}
-		}
-	}()
-
-	result = v.FieldByIndex(index)
-	return
-}
-
-func getInlineField(val reflect.Value, index []int) (reflect.Value, error) {
-	field, err := fieldByIndexErr(val, index)
-	if err == nil {
-		return field, nil
-	}
-
-	// if parent of this element doesn't exist, fix its parent
-	inlineParent := index[:len(index)-1]
-	var fParent reflect.Value
-	if fParent, err = fieldByIndexErr(val, inlineParent); err != nil {
-		fParent, err = getInlineField(val, inlineParent)
-		if err != nil {
-			return fParent, err
-		}
-	}
-	fParent.Set(reflect.New(fParent.Type().Elem()))
-
-	return fieldByIndexErr(val, index)
-}
-
-// DeepZero returns recursive zero object
-func deepZero(st reflect.Type) (result reflect.Value) {
-	if st.Kind() == reflect.Struct {
-		numField := st.NumField()
-		for i := 0; i < numField; i++ {
-			if result == emptyValue {
-				result = reflect.Indirect(reflect.New(st))
-			}
-			f := result.Field(i)
-			if f.CanInterface() {
-				if f.Type().Kind() == reflect.Struct {
-					result.Field(i).Set(recursivePointerTo(deepZero(f.Type().Elem())))
-				}
-			}
-		}
-	}
-	return result
-}
-
-// recursivePointerTo calls reflect.New(v.Type) but recursively for its fields inside
-func recursivePointerTo(v reflect.Value) reflect.Value {
-	v = reflect.Indirect(v)
-	result := reflect.New(v.Type())
-	if v.Kind() == reflect.Struct {
-		for i := 0; i < v.NumField(); i++ {
-			if f := v.Field(i); f.Kind() == reflect.Ptr {
-				if f.Elem().Kind() == reflect.Struct {
-					result.Elem().Field(i).Set(recursivePointerTo(f))
-				}
-			}
-		}
-	}
-
-	return result
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/struct_tag_parser.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/struct_tag_parser.go
deleted file mode 100644
index 47955639..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/struct_tag_parser.go
+++ /dev/null
@@ -1,123 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"reflect"
-	"strings"
-)
-
-// structTags represents the struct tag fields that the StructCodec uses during
-// the encoding and decoding process.
-//
-// In the case of a struct, the lowercased field name is used as the key for each exported
-// field but this behavior may be changed using a struct tag. The tag may also contain flags to
-// adjust the marshalling behavior for the field.
-//
-// The properties are defined below:
-//
-//	OmitEmpty  Only include the field if it's not set to the zero value for the type or to
-//	           empty slices or maps.
-//
-//	MinSize    Marshal an integer of a type larger than 32 bits value as an int32, if that's
-//	           feasible while preserving the numeric value.
-//
-//	Truncate   When unmarshaling a BSON double, it is permitted to lose precision to fit within
-//	           a float32.
-//
-//	Inline     Inline the field, which must be a struct or a map, causing all of its fields
-//	           or keys to be processed as if they were part of the outer struct. For maps,
-//	           keys must not conflict with the bson keys of other struct fields.
-//
-//	Skip       This struct field should be skipped. This is usually denoted by parsing a "-"
-//	           for the name.
-type structTags struct {
-	Name      string
-	OmitEmpty bool
-	MinSize   bool
-	Truncate  bool
-	Inline    bool
-	Skip      bool
-}
-
-// DefaultStructTagParser is the StructTagParser used by the StructCodec by default.
-// It will handle the bson struct tag. See the documentation for StructTags to see
-// what each of the returned fields means.
-//
-// If there is no name in the struct tag fields, the struct field name is lowercased.
-// The tag formats accepted are:
-//
-//	"[<key>][,<flag1>[,<flag2>]]"
-//
-//	`(...) bson:"[<key>][,<flag1>[,<flag2>]]" (...)`
-//
-// An example:
-//
-//	type T struct {
-//	    A bool
-//	    B int    "myb"
-//	    C string "myc,omitempty"
-//	    D string `bson:",omitempty" json:"jsonkey"`
-//	    E int64  ",minsize"
-//	    F int64  "myf,omitempty,minsize"
-//	}
-//
-// A struct tag either consisting entirely of '-' or with a bson key with a
-// value consisting entirely of '-' will return a StructTags with Skip true and
-// the remaining fields will be their default values.
-func parseStructTags(sf reflect.StructField) (*structTags, error) {
-	key := strings.ToLower(sf.Name)
-	tag, ok := sf.Tag.Lookup("bson")
-	if !ok && !strings.Contains(string(sf.Tag), ":") && len(sf.Tag) > 0 {
-		tag = string(sf.Tag)
-	}
-	return parseTags(key, tag)
-}
-
-// jsonStructTagParser has the same behavior as DefaultStructTagParser
-// but will also fallback to parsing the json tag instead on a field where the
-// bson tag isn't available.
-func parseJSONStructTags(sf reflect.StructField) (*structTags, error) {
-	key := strings.ToLower(sf.Name)
-	tag, ok := sf.Tag.Lookup("bson")
-	if !ok {
-		tag, ok = sf.Tag.Lookup("json")
-	}
-	if !ok && !strings.Contains(string(sf.Tag), ":") && len(sf.Tag) > 0 {
-		tag = string(sf.Tag)
-	}
-
-	return parseTags(key, tag)
-}
-
-func parseTags(key string, tag string) (*structTags, error) {
-	var st structTags
-	if tag == "-" {
-		st.Skip = true
-		return &st, nil
-	}
-
-	for idx, str := range strings.Split(tag, ",") {
-		if idx == 0 && str != "" {
-			key = str
-		}
-		switch str {
-		case "omitempty":
-			st.OmitEmpty = true
-		case "minsize":
-			st.MinSize = true
-		case "truncate":
-			st.Truncate = true
-		case "inline":
-			st.Inline = true
-		}
-	}
-
-	st.Name = key
-
-	return &st, nil
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/time_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/time_codec.go
deleted file mode 100644
index 1c00374c..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/time_codec.go
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"fmt"
-	"reflect"
-	"time"
-)
-
-const (
-	timeFormatString = "2006-01-02T15:04:05.999Z07:00"
-)
-
-// timeCodec is the Codec used for time.Time values.
-type timeCodec struct {
-	// useLocalTimeZone specifies if we should decode into the local time zone. Defaults to false.
-	useLocalTimeZone bool
-}
-
-// Assert that timeCodec satisfies the typeDecoder interface, which allows it to be used
-// by collection type decoders (e.g. map, slice, etc) to set individual values in a collection.
-var _ typeDecoder = &timeCodec{}
-
-func (tc *timeCodec) decodeType(dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	if t != tTime {
-		return emptyValue, ValueDecoderError{
-			Name:     "TimeDecodeValue",
-			Types:    []reflect.Type{tTime},
-			Received: reflect.Zero(t),
-		}
-	}
-
-	var timeVal time.Time
-	switch vrType := vr.Type(); vrType {
-	case TypeDateTime:
-		dt, err := vr.ReadDateTime()
-		if err != nil {
-			return emptyValue, err
-		}
-		timeVal = time.Unix(dt/1000, dt%1000*1000000)
-	case TypeString:
-		// assume strings are in the isoTimeFormat
-		timeStr, err := vr.ReadString()
-		if err != nil {
-			return emptyValue, err
-		}
-		timeVal, err = time.Parse(timeFormatString, timeStr)
-		if err != nil {
-			return emptyValue, err
-		}
-	case TypeInt64:
-		i64, err := vr.ReadInt64()
-		if err != nil {
-			return emptyValue, err
-		}
-		timeVal = time.Unix(i64/1000, i64%1000*1000000)
-	case TypeTimestamp:
-		t, _, err := vr.ReadTimestamp()
-		if err != nil {
-			return emptyValue, err
-		}
-		timeVal = time.Unix(int64(t), 0)
-	case TypeNull:
-		if err := vr.ReadNull(); err != nil {
-			return emptyValue, err
-		}
-	case TypeUndefined:
-		if err := vr.ReadUndefined(); err != nil {
-			return emptyValue, err
-		}
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into a time.Time", vrType)
-	}
-
-	if !tc.useLocalTimeZone && !dc.useLocalTimeZone {
-		timeVal = timeVal.UTC()
-	}
-	return reflect.ValueOf(timeVal), nil
-}
-
-// DecodeValue is the ValueDecoderFunc for time.Time.
-func (tc *timeCodec) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() || val.Type() != tTime {
-		return ValueDecoderError{Name: "TimeDecodeValue", Types: []reflect.Type{tTime}, Received: val}
-	}
-
-	elem, err := tc.decodeType(dc, vr, tTime)
-	if err != nil {
-		return err
-	}
-
-	val.Set(elem)
-	return nil
-}
-
-// EncodeValue is the ValueEncoderFunc for time.TIme.
-func (tc *timeCodec) EncodeValue(_ EncodeContext, vw ValueWriter, val reflect.Value) error {
-	if !val.IsValid() || val.Type() != tTime {
-		return ValueEncoderError{Name: "TimeEncodeValue", Types: []reflect.Type{tTime}, Received: val}
-	}
-	tt := val.Interface().(time.Time)
-	dt := NewDateTimeFromTime(tt)
-	return vw.WriteDateTime(int64(dt))
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/types.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/types.go
deleted file mode 100644
index c2883aa4..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/types.go
+++ /dev/null
@@ -1,118 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"encoding/json"
-	"net/url"
-	"reflect"
-	"time"
-
-	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
-)
-
-// Type represents a BSON type.
-type Type byte
-
-// String returns the string representation of the BSON type's name.
-func (bt Type) String() string {
-	return bsoncore.Type(bt).String()
-}
-
-// IsValid will return true if the Type is valid.
-func (bt Type) IsValid() bool {
-	switch bt {
-	case TypeDouble, TypeString, TypeEmbeddedDocument, TypeArray, TypeBinary,
-		TypeUndefined, TypeObjectID, TypeBoolean, TypeDateTime, TypeNull, TypeRegex,
-		TypeDBPointer, TypeJavaScript, TypeSymbol, TypeCodeWithScope, TypeInt32,
-		TypeTimestamp, TypeInt64, TypeDecimal128, TypeMinKey, TypeMaxKey:
-		return true
-	default:
-		return false
-	}
-}
-
-// BSON element types as described in https://bsonspec.org/spec.html.
-const (
-	TypeDouble           Type = 0x01
-	TypeString           Type = 0x02
-	TypeEmbeddedDocument Type = 0x03
-	TypeArray            Type = 0x04
-	TypeBinary           Type = 0x05
-	TypeUndefined        Type = 0x06
-	TypeObjectID         Type = 0x07
-	TypeBoolean          Type = 0x08
-	TypeDateTime         Type = 0x09
-	TypeNull             Type = 0x0A
-	TypeRegex            Type = 0x0B
-	TypeDBPointer        Type = 0x0C
-	TypeJavaScript       Type = 0x0D
-	TypeSymbol           Type = 0x0E
-	TypeCodeWithScope    Type = 0x0F
-	TypeInt32            Type = 0x10
-	TypeTimestamp        Type = 0x11
-	TypeInt64            Type = 0x12
-	TypeDecimal128       Type = 0x13
-	TypeMaxKey           Type = 0x7F
-	TypeMinKey           Type = 0xFF
-)
-
-// BSON binary element subtypes as described in https://bsonspec.org/spec.html.
-const (
-	TypeBinaryGeneric     byte = 0x00
-	TypeBinaryFunction    byte = 0x01
-	TypeBinaryBinaryOld   byte = 0x02
-	TypeBinaryUUIDOld     byte = 0x03
-	TypeBinaryUUID        byte = 0x04
-	TypeBinaryMD5         byte = 0x05
-	TypeBinaryEncrypted   byte = 0x06
-	TypeBinaryColumn      byte = 0x07
-	TypeBinarySensitive   byte = 0x08
-	TypeBinaryVector      byte = 0x09
-	TypeBinaryUserDefined byte = 0x80
-)
-
-var tBool = reflect.TypeOf(false)
-var tFloat64 = reflect.TypeOf(float64(0))
-var tInt32 = reflect.TypeOf(int32(0))
-var tInt64 = reflect.TypeOf(int64(0))
-var tString = reflect.TypeOf("")
-var tTime = reflect.TypeOf(time.Time{})
-
-var tEmpty = reflect.TypeOf((*interface{})(nil)).Elem()
-var tByteSlice = reflect.TypeOf([]byte(nil))
-var tByte = reflect.TypeOf(byte(0x00))
-var tURL = reflect.TypeOf(url.URL{})
-var tJSONNumber = reflect.TypeOf(json.Number(""))
-
-var tValueMarshaler = reflect.TypeOf((*ValueMarshaler)(nil)).Elem()
-var tValueUnmarshaler = reflect.TypeOf((*ValueUnmarshaler)(nil)).Elem()
-var tMarshaler = reflect.TypeOf((*Marshaler)(nil)).Elem()
-var tUnmarshaler = reflect.TypeOf((*Unmarshaler)(nil)).Elem()
-var tZeroer = reflect.TypeOf((*Zeroer)(nil)).Elem()
-
-var tBinary = reflect.TypeOf(Binary{})
-var tUndefined = reflect.TypeOf(Undefined{})
-var tOID = reflect.TypeOf(ObjectID{})
-var tDateTime = reflect.TypeOf(DateTime(0))
-var tNull = reflect.TypeOf(Null{})
-var tRegex = reflect.TypeOf(Regex{})
-var tCodeWithScope = reflect.TypeOf(CodeWithScope{})
-var tDBPointer = reflect.TypeOf(DBPointer{})
-var tJavaScript = reflect.TypeOf(JavaScript(""))
-var tSymbol = reflect.TypeOf(Symbol(""))
-var tTimestamp = reflect.TypeOf(Timestamp{})
-var tDecimal = reflect.TypeOf(Decimal128{})
-var tVector = reflect.TypeOf(Vector{})
-var tMinKey = reflect.TypeOf(MinKey{})
-var tMaxKey = reflect.TypeOf(MaxKey{})
-var tD = reflect.TypeOf(D{})
-var tA = reflect.TypeOf(A{})
-var tE = reflect.TypeOf(E{})
-
-var tCoreDocument = reflect.TypeOf(bsoncore.Document{})
-var tCoreArray = reflect.TypeOf(bsoncore.Array{})
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/uint_codec.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/uint_codec.go
deleted file mode 100644
index 0cdcc635..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/uint_codec.go
+++ /dev/null
@@ -1,161 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"fmt"
-	"math"
-	"reflect"
-)
-
-// uintCodec is the Codec used for uint values.
-type uintCodec struct {
-	// encodeToMinSize causes EncodeValue to marshal Go uint values (excluding uint64) as the
-	// minimum BSON int size (either 32-bit or 64-bit) that can represent the integer value.
-	encodeToMinSize bool
-}
-
-// Assert that uintCodec satisfies the typeDecoder interface, which allows it to be used
-// by collection type decoders (e.g. map, slice, etc) to set individual values in a collection.
-var _ typeDecoder = &uintCodec{}
-
-// EncodeValue is the ValueEncoder for uint types.
-func (uic *uintCodec) EncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
-	switch val.Kind() {
-	case reflect.Uint8, reflect.Uint16:
-		return vw.WriteInt32(int32(val.Uint()))
-	case reflect.Uint, reflect.Uint32, reflect.Uint64:
-		u64 := val.Uint()
-
-		// If ec.MinSize or if encodeToMinSize is true for a non-uint64 value we should write val as an int32
-		useMinSize := ec.minSize || (uic.encodeToMinSize && val.Kind() != reflect.Uint64)
-
-		if u64 <= math.MaxInt32 && useMinSize {
-			return vw.WriteInt32(int32(u64))
-		}
-		if u64 > math.MaxInt64 {
-			return fmt.Errorf("%d overflows int64", u64)
-		}
-		return vw.WriteInt64(int64(u64))
-	}
-
-	return ValueEncoderError{
-		Name:     "UintEncodeValue",
-		Kinds:    []reflect.Kind{reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint},
-		Received: val,
-	}
-}
-
-func (uic *uintCodec) decodeType(dc DecodeContext, vr ValueReader, t reflect.Type) (reflect.Value, error) {
-	var i64 int64
-	var err error
-	switch vrType := vr.Type(); vrType {
-	case TypeInt32:
-		i32, err := vr.ReadInt32()
-		if err != nil {
-			return emptyValue, err
-		}
-		i64 = int64(i32)
-	case TypeInt64:
-		i64, err = vr.ReadInt64()
-		if err != nil {
-			return emptyValue, err
-		}
-	case TypeDouble:
-		f64, err := vr.ReadDouble()
-		if err != nil {
-			return emptyValue, err
-		}
-		if !dc.truncate && math.Floor(f64) != f64 {
-			return emptyValue, errCannotTruncate
-		}
-		if f64 > float64(math.MaxInt64) {
-			return emptyValue, fmt.Errorf("%g overflows int64", f64)
-		}
-		i64 = int64(f64)
-	case TypeBoolean:
-		b, err := vr.ReadBoolean()
-		if err != nil {
-			return emptyValue, err
-		}
-		if b {
-			i64 = 1
-		}
-	case TypeNull:
-		if err = vr.ReadNull(); err != nil {
-			return emptyValue, err
-		}
-	case TypeUndefined:
-		if err = vr.ReadUndefined(); err != nil {
-			return emptyValue, err
-		}
-	default:
-		return emptyValue, fmt.Errorf("cannot decode %v into an integer type", vrType)
-	}
-
-	switch t.Kind() {
-	case reflect.Uint8:
-		if i64 < 0 || i64 > math.MaxUint8 {
-			return emptyValue, fmt.Errorf("%d overflows uint8", i64)
-		}
-
-		return reflect.ValueOf(uint8(i64)), nil
-	case reflect.Uint16:
-		if i64 < 0 || i64 > math.MaxUint16 {
-			return emptyValue, fmt.Errorf("%d overflows uint16", i64)
-		}
-
-		return reflect.ValueOf(uint16(i64)), nil
-	case reflect.Uint32:
-		if i64 < 0 || i64 > math.MaxUint32 {
-			return emptyValue, fmt.Errorf("%d overflows uint32", i64)
-		}
-
-		return reflect.ValueOf(uint32(i64)), nil
-	case reflect.Uint64:
-		if i64 < 0 {
-			return emptyValue, fmt.Errorf("%d overflows uint64", i64)
-		}
-
-		return reflect.ValueOf(uint64(i64)), nil
-	case reflect.Uint:
-		if i64 < 0 {
-			return emptyValue, fmt.Errorf("%d overflows uint", i64)
-		}
-		v := uint64(i64)
-		if v > math.MaxUint { // Can we fit this inside of an uint
-			return emptyValue, fmt.Errorf("%d overflows uint", i64)
-		}
-
-		return reflect.ValueOf(uint(v)), nil
-	default:
-		return emptyValue, ValueDecoderError{
-			Name:     "UintDecodeValue",
-			Kinds:    []reflect.Kind{reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint},
-			Received: reflect.Zero(t),
-		}
-	}
-}
-
-// DecodeValue is the ValueDecoder for uint types.
-func (uic *uintCodec) DecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
-	if !val.CanSet() {
-		return ValueDecoderError{
-			Name:     "UintDecodeValue",
-			Kinds:    []reflect.Kind{reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint},
-			Received: val,
-		}
-	}
-
-	elem, err := uic.decodeType(dc, vr, val.Type())
-	if err != nil {
-		return err
-	}
-
-	val.SetUint(elem.Uint())
-	return nil
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/unmarshal.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/unmarshal.go
deleted file mode 100644
index 52bd94fe..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/unmarshal.go
+++ /dev/null
@@ -1,90 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"bytes"
-	"fmt"
-)
-
-// Unmarshaler is the interface implemented by types that can unmarshal a BSON
-// document representation of themselves. The input can be assumed to be a valid
-// encoding of a BSON document. UnmarshalBSON must copy the JSON data if it
-// wishes to retain the data after returning.
-//
-// Unmarshaler is only used to unmarshal full BSON documents. To create custom
-// BSON unmarshaling behavior for individual values in a BSON document,
-// implement the ValueUnmarshaler interface instead.
-type Unmarshaler interface {
-	UnmarshalBSON([]byte) error
-}
-
-// ValueUnmarshaler is the interface implemented by types that can unmarshal a
-// BSON value representation of themselves. The input can be assumed to be a
-// valid encoding of a BSON value. UnmarshalBSONValue must copy the BSON value
-// bytes if it wishes to retain the data after returning.
-//
-// ValueUnmarshaler is only used to unmarshal individual values in a BSON
-// document. To create custom BSON unmarshaling behavior for an entire BSON
-// document, implement the Unmarshaler interface instead.
-type ValueUnmarshaler interface {
-	UnmarshalBSONValue(typ byte, data []byte) error
-}
-
-// Unmarshal parses the BSON-encoded data and stores the result in the value
-// pointed to by val. If val is nil or not a pointer, Unmarshal returns an
-// error.
-//
-// When unmarshaling BSON, if the BSON value is null and the Go value is a
-// pointer, the pointer is set to nil without calling UnmarshalBSONValue.
-func Unmarshal(data []byte, val interface{}) error {
-	vr := getDocumentReader(bytes.NewReader(data))
-	defer putDocumentReader(vr)
-
-	if l, err := vr.peekLength(); err != nil {
-		return err
-	} else if int(l) != len(data) {
-		return fmt.Errorf("invalid document length")
-	}
-	return unmarshalFromReader(DecodeContext{Registry: defaultRegistry}, vr, val)
-}
-
-// UnmarshalValue parses the BSON value of type t with bson.NewRegistry() and
-// stores the result in the value pointed to by val. If val is nil or not a pointer,
-// UnmarshalValue returns an error.
-func UnmarshalValue(t Type, data []byte, val interface{}) error {
-	vr := newValueReader(t, bytes.NewReader(data))
-	return unmarshalFromReader(DecodeContext{Registry: defaultRegistry}, vr, val)
-}
-
-// UnmarshalExtJSON parses the extended JSON-encoded data and stores the result
-// in the value pointed to by val. If val is nil or not a pointer, UnmarshalExtJSON
-// returns an error.
-//
-// If canonicalOnly is true, UnmarshalExtJSON returns an error if the Extended
-// JSON was not marshaled in canonical mode.
-//
-// For more information about Extended JSON, see
-// https://www.mongodb.com/docs/manual/reference/mongodb-extended-json/
-func UnmarshalExtJSON(data []byte, canonicalOnly bool, val interface{}) error {
-	ejvr, err := NewExtJSONValueReader(bytes.NewReader(data), canonicalOnly)
-	if err != nil {
-		return err
-	}
-
-	return unmarshalFromReader(DecodeContext{Registry: defaultRegistry}, ejvr, val)
-}
-
-func unmarshalFromReader(dc DecodeContext, vr ValueReader, val interface{}) error {
-	dec := decPool.Get().(*Decoder)
-	defer decPool.Put(dec)
-
-	dec.Reset(vr)
-	dec.dc = dc
-
-	return dec.Decode(val)
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/value_reader.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/value_reader.go
deleted file mode 100644
index d713e669..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/value_reader.go
+++ /dev/null
@@ -1,898 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"bufio"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"sync"
-)
-
-var _ ValueReader = &valueReader{}
-
-// ErrEOA is the error returned when the end of a BSON array has been reached.
-var ErrEOA = errors.New("end of array")
-
-// ErrEOD is the error returned when the end of a BSON document has been reached.
-var ErrEOD = errors.New("end of document")
-
-type vrState struct {
-	mode  mode
-	vType Type
-	end   int64
-}
-
-var bufioReaderPool = sync.Pool{
-	New: func() interface{} {
-		return bufio.NewReader(nil)
-	},
-}
-
-var vrPool = sync.Pool{
-	New: func() interface{} {
-		return &valueReader{
-			stack: make([]vrState, 1, 5),
-		}
-	},
-}
-
-// valueReader is for reading BSON values.
-type valueReader struct {
-	r      *bufio.Reader
-	offset int64
-
-	stack []vrState
-	frame int64
-}
-
-func getDocumentReader(r io.Reader) *valueReader {
-	vr := vrPool.Get().(*valueReader)
-
-	vr.offset = 0
-	vr.frame = 0
-
-	vr.stack = vr.stack[:1]
-	vr.stack[0] = vrState{mode: mTopLevel}
-
-	br := bufioReaderPool.Get().(*bufio.Reader)
-	br.Reset(r)
-	vr.r = br
-
-	return vr
-}
-
-func putDocumentReader(vr *valueReader) {
-	if vr == nil {
-		return
-	}
-
-	bufioReaderPool.Put(vr.r)
-	vr.r = nil
-
-	vrPool.Put(vr)
-}
-
-// NewDocumentReader returns a ValueReader using b for the underlying BSON
-// representation.
-func NewDocumentReader(r io.Reader) ValueReader {
-	return newDocumentReader(r)
-}
-
-// newValueReader returns a ValueReader that starts in the Value mode instead of in top
-// level document mode. This enables the creation of a ValueReader for a single BSON value.
-func newValueReader(t Type, r io.Reader) ValueReader {
-	vr := newDocumentReader(r)
-	if len(vr.stack) == 0 {
-		vr.stack = make([]vrState, 1, 5)
-	}
-	vr.stack[0].mode = mValue
-	vr.stack[0].vType = t
-	return vr
-}
-
-func newDocumentReader(r io.Reader) *valueReader {
-	stack := make([]vrState, 1, 5)
-	stack[0] = vrState{
-		mode: mTopLevel,
-	}
-	return &valueReader{
-		r:     bufio.NewReader(r),
-		stack: stack,
-	}
-}
-
-func (vr *valueReader) advanceFrame() {
-	if vr.frame+1 >= int64(len(vr.stack)) { // We need to grow the stack
-		length := len(vr.stack)
-		if length+1 >= cap(vr.stack) {
-			// double it
-			buf := make([]vrState, 2*cap(vr.stack)+1)
-			copy(buf, vr.stack)
-			vr.stack = buf
-		}
-		vr.stack = vr.stack[:length+1]
-	}
-	vr.frame++
-
-	// Clean the stack
-	vr.stack[vr.frame].mode = 0
-	vr.stack[vr.frame].vType = 0
-	vr.stack[vr.frame].end = 0
-}
-
-func (vr *valueReader) pushDocument() error {
-	vr.advanceFrame()
-
-	vr.stack[vr.frame].mode = mDocument
-
-	length, err := vr.readLength()
-	if err != nil {
-		return err
-	}
-	vr.stack[vr.frame].end = int64(length) + vr.offset - 4
-
-	return nil
-}
-
-func (vr *valueReader) pushArray() error {
-	vr.advanceFrame()
-
-	vr.stack[vr.frame].mode = mArray
-
-	length, err := vr.readLength()
-	if err != nil {
-		return err
-	}
-	vr.stack[vr.frame].end = int64(length) + vr.offset - 4
-
-	return nil
-}
-
-func (vr *valueReader) pushElement(t Type) {
-	vr.advanceFrame()
-
-	vr.stack[vr.frame].mode = mElement
-	vr.stack[vr.frame].vType = t
-}
-
-func (vr *valueReader) pushValue(t Type) {
-	vr.advanceFrame()
-
-	vr.stack[vr.frame].mode = mValue
-	vr.stack[vr.frame].vType = t
-}
-
-func (vr *valueReader) pushCodeWithScope() (int64, error) {
-	vr.advanceFrame()
-
-	vr.stack[vr.frame].mode = mCodeWithScope
-
-	length, err := vr.readLength()
-	if err != nil {
-		return 0, err
-	}
-	vr.stack[vr.frame].end = int64(length) + vr.offset - 4
-
-	return int64(length), nil
-}
-
-func (vr *valueReader) pop() error {
-	var cnt int
-	switch vr.stack[vr.frame].mode {
-	case mElement, mValue:
-		cnt = 1
-	case mDocument, mArray, mCodeWithScope:
-		cnt = 2 // we pop twice to jump over the vrElement: vrDocument -> vrElement -> vrDocument/TopLevel/etc...
-	}
-	for i := 0; i < cnt && vr.frame > 0; i++ {
-		if vr.offset < vr.stack[vr.frame].end {
-			_, err := vr.r.Discard(int(vr.stack[vr.frame].end - vr.offset))
-			if err != nil {
-				return err
-			}
-		}
-		vr.frame--
-	}
-	if vr.frame == 0 {
-		if vr.stack[0].end > vr.offset {
-			vr.stack[0].end -= vr.offset
-		} else {
-			vr.stack[0].end = 0
-		}
-		vr.offset = 0
-	}
-	return nil
-}
-
-func (vr *valueReader) invalidTransitionErr(destination mode, name string, modes []mode) error {
-	te := TransitionError{
-		name:        name,
-		current:     vr.stack[vr.frame].mode,
-		destination: destination,
-		modes:       modes,
-		action:      "read",
-	}
-	if vr.frame != 0 {
-		te.parent = vr.stack[vr.frame-1].mode
-	}
-	return te
-}
-
-func (vr *valueReader) typeError(t Type) error {
-	return fmt.Errorf("positioned on %s, but attempted to read %s", vr.stack[vr.frame].vType, t)
-}
-
-func (vr *valueReader) invalidDocumentLengthError() error {
-	return fmt.Errorf("document is invalid, end byte is at %d, but null byte found at %d", vr.stack[vr.frame].end, vr.offset)
-}
-
-func (vr *valueReader) ensureElementValue(t Type, destination mode, callerName string) error {
-	switch vr.stack[vr.frame].mode {
-	case mElement, mValue:
-		if vr.stack[vr.frame].vType != t {
-			return vr.typeError(t)
-		}
-	default:
-		return vr.invalidTransitionErr(destination, callerName, []mode{mElement, mValue})
-	}
-
-	return nil
-}
-
-func (vr *valueReader) Type() Type {
-	return vr.stack[vr.frame].vType
-}
-
-func (vr *valueReader) appendNextElement(dst []byte) ([]byte, error) {
-	var length int32
-	var err error
-	switch vr.stack[vr.frame].vType {
-	case TypeArray, TypeEmbeddedDocument, TypeCodeWithScope:
-		length, err = vr.peekLength()
-	case TypeBinary:
-		length, err = vr.peekLength()
-		length += 4 + 1 // binary length + subtype byte
-	case TypeBoolean:
-		length = 1
-	case TypeDBPointer:
-		length, err = vr.peekLength()
-		length += 4 + 12 // string length + ObjectID length
-	case TypeDateTime, TypeDouble, TypeInt64, TypeTimestamp:
-		length = 8
-	case TypeDecimal128:
-		length = 16
-	case TypeInt32:
-		length = 4
-	case TypeJavaScript, TypeString, TypeSymbol:
-		length, err = vr.peekLength()
-		length += 4
-	case TypeMaxKey, TypeMinKey, TypeNull, TypeUndefined:
-		length = 0
-	case TypeObjectID:
-		length = 12
-	case TypeRegex:
-		for n := 0; n < 2; n++ { // Read two C strings.
-			str, err := vr.r.ReadBytes(0x00)
-			if err != nil {
-				return nil, err
-			}
-			dst = append(dst, str...)
-			vr.offset += int64(len(str))
-		}
-		return dst, nil
-	default:
-		return nil, fmt.Errorf("attempted to read bytes of unknown BSON type %v", vr.stack[vr.frame].vType)
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	buf, err := vr.r.Peek(int(length))
-	if err != nil {
-		if err == bufio.ErrBufferFull {
-			temp := make([]byte, length)
-			if _, err = io.ReadFull(vr.r, temp); err != nil {
-				return nil, err
-			}
-			dst = append(dst, temp...)
-			vr.offset += int64(len(temp))
-			return dst, nil
-		}
-
-		return nil, err
-	}
-
-	dst = append(dst, buf...)
-	if _, err = vr.r.Discard(int(length)); err != nil {
-		return nil, err
-	}
-
-	vr.offset += int64(length)
-	return dst, nil
-}
-
-func (vr *valueReader) readValueBytes(dst []byte) (Type, []byte, error) {
-	switch vr.stack[vr.frame].mode {
-	case mTopLevel:
-		length, err := vr.peekLength()
-		if err != nil {
-			return Type(0), nil, err
-		}
-		dst, err = vr.appendBytes(dst, length)
-		if err != nil {
-			return Type(0), nil, err
-		}
-		return Type(0), dst, nil
-	case mElement, mValue:
-		dst, err := vr.appendNextElement(dst)
-		if err != nil {
-			return Type(0), dst, err
-		}
-
-		t := vr.stack[vr.frame].vType
-		err = vr.pop()
-		if err != nil {
-			return Type(0), nil, err
-		}
-		return t, dst, nil
-	default:
-		return Type(0), nil, vr.invalidTransitionErr(0, "ReadValueBytes", []mode{mElement, mValue})
-	}
-}
-
-func (vr *valueReader) Skip() error {
-	switch vr.stack[vr.frame].mode {
-	case mElement, mValue:
-	default:
-		return vr.invalidTransitionErr(0, "Skip", []mode{mElement, mValue})
-	}
-
-	_, err := vr.appendNextElement(nil)
-	if err != nil {
-		return err
-	}
-
-	return vr.pop()
-}
-
-func (vr *valueReader) ReadArray() (ArrayReader, error) {
-	if err := vr.ensureElementValue(TypeArray, mArray, "ReadArray"); err != nil {
-		return nil, err
-	}
-
-	err := vr.pushArray()
-	if err != nil {
-		return nil, err
-	}
-
-	return vr, nil
-}
-
-func (vr *valueReader) ReadBinary() (b []byte, btype byte, err error) {
-	if err := vr.ensureElementValue(TypeBinary, 0, "ReadBinary"); err != nil {
-		return nil, 0, err
-	}
-
-	length, err := vr.readLength()
-	if err != nil {
-		return nil, 0, err
-	}
-
-	btype, err = vr.readByte()
-	if err != nil {
-		return nil, 0, err
-	}
-
-	// Check length in case it is an old binary without a length.
-	if btype == 0x02 && length > 4 {
-		length, err = vr.readLength()
-		if err != nil {
-			return nil, 0, err
-		}
-	}
-
-	b = make([]byte, length)
-	err = vr.read(b)
-	if err != nil {
-		return nil, 0, err
-	}
-
-	if err := vr.pop(); err != nil {
-		return nil, 0, err
-	}
-	return b, btype, nil
-}
-
-func (vr *valueReader) ReadBoolean() (bool, error) {
-	if err := vr.ensureElementValue(TypeBoolean, 0, "ReadBoolean"); err != nil {
-		return false, err
-	}
-
-	b, err := vr.readByte()
-	if err != nil {
-		return false, err
-	}
-
-	if b > 1 {
-		return false, fmt.Errorf("invalid byte for boolean, %b", b)
-	}
-
-	if err := vr.pop(); err != nil {
-		return false, err
-	}
-	return b == 1, nil
-}
-
-func (vr *valueReader) ReadDocument() (DocumentReader, error) {
-	switch vr.stack[vr.frame].mode {
-	case mTopLevel:
-		length, err := vr.readLength()
-		if err != nil {
-			return nil, err
-		}
-		if length <= 4 {
-			return nil, fmt.Errorf("invalid string length: %d", length)
-		}
-
-		vr.stack[vr.frame].end = int64(length) + vr.offset - 4
-		return vr, nil
-	case mElement, mValue:
-		if vr.stack[vr.frame].vType != TypeEmbeddedDocument {
-			return nil, vr.typeError(TypeEmbeddedDocument)
-		}
-	default:
-		return nil, vr.invalidTransitionErr(mDocument, "ReadDocument", []mode{mTopLevel, mElement, mValue})
-	}
-
-	err := vr.pushDocument()
-	if err != nil {
-		return nil, err
-	}
-
-	return vr, nil
-}
-
-func (vr *valueReader) ReadCodeWithScope() (code string, dr DocumentReader, err error) {
-	if err := vr.ensureElementValue(TypeCodeWithScope, 0, "ReadCodeWithScope"); err != nil {
-		return "", nil, err
-	}
-
-	totalLength, err := vr.readLength()
-	if err != nil {
-		return "", nil, err
-	}
-	strLength, err := vr.readLength()
-	if err != nil {
-		return "", nil, err
-	}
-	if strLength <= 0 {
-		return "", nil, fmt.Errorf("invalid string length: %d", strLength)
-	}
-	strBytes := make([]byte, strLength)
-	err = vr.read(strBytes)
-	if err != nil {
-		return "", nil, err
-	}
-	code = string(strBytes[:len(strBytes)-1])
-
-	size, err := vr.pushCodeWithScope()
-	if err != nil {
-		return "", nil, err
-	}
-
-	// The total length should equal:
-	// 4 (total length) + strLength + 4 (the length of str itself) + (document length)
-	componentsLength := int64(4+strLength+4) + size
-	if int64(totalLength) != componentsLength {
-		return "", nil, fmt.Errorf(
-			"length of CodeWithScope does not match lengths of components; total: %d; components: %d",
-			totalLength, componentsLength,
-		)
-	}
-	return code, vr, nil
-}
-
-func (vr *valueReader) ReadDBPointer() (ns string, oid ObjectID, err error) {
-	if err := vr.ensureElementValue(TypeDBPointer, 0, "ReadDBPointer"); err != nil {
-		return "", oid, err
-	}
-
-	ns, err = vr.readString()
-	if err != nil {
-		return "", oid, err
-	}
-
-	err = vr.read(oid[:])
-	if err != nil {
-		return "", ObjectID{}, err
-	}
-
-	if err := vr.pop(); err != nil {
-		return "", ObjectID{}, err
-	}
-	return ns, oid, nil
-}
-
-func (vr *valueReader) ReadDateTime() (int64, error) {
-	if err := vr.ensureElementValue(TypeDateTime, 0, "ReadDateTime"); err != nil {
-		return 0, err
-	}
-
-	i, err := vr.readi64()
-	if err != nil {
-		return 0, err
-	}
-
-	if err := vr.pop(); err != nil {
-		return 0, err
-	}
-	return i, nil
-}
-
-func (vr *valueReader) ReadDecimal128() (Decimal128, error) {
-	if err := vr.ensureElementValue(TypeDecimal128, 0, "ReadDecimal128"); err != nil {
-		return Decimal128{}, err
-	}
-
-	var b [16]byte
-	err := vr.read(b[:])
-	if err != nil {
-		return Decimal128{}, err
-	}
-
-	l := binary.LittleEndian.Uint64(b[0:8])
-	h := binary.LittleEndian.Uint64(b[8:16])
-
-	if err := vr.pop(); err != nil {
-		return Decimal128{}, err
-	}
-	return NewDecimal128(h, l), nil
-}
-
-func (vr *valueReader) ReadDouble() (float64, error) {
-	if err := vr.ensureElementValue(TypeDouble, 0, "ReadDouble"); err != nil {
-		return 0, err
-	}
-
-	u, err := vr.readu64()
-	if err != nil {
-		return 0, err
-	}
-
-	if err := vr.pop(); err != nil {
-		return 0, err
-	}
-	return math.Float64frombits(u), nil
-}
-
-func (vr *valueReader) ReadInt32() (int32, error) {
-	if err := vr.ensureElementValue(TypeInt32, 0, "ReadInt32"); err != nil {
-		return 0, err
-	}
-
-	if err := vr.pop(); err != nil {
-		return 0, err
-	}
-	return vr.readi32()
-}
-
-func (vr *valueReader) ReadInt64() (int64, error) {
-	if err := vr.ensureElementValue(TypeInt64, 0, "ReadInt64"); err != nil {
-		return 0, err
-	}
-
-	if err := vr.pop(); err != nil {
-		return 0, err
-	}
-	return vr.readi64()
-}
-
-func (vr *valueReader) ReadJavascript() (string, error) {
-	if err := vr.ensureElementValue(TypeJavaScript, 0, "ReadJavascript"); err != nil {
-		return "", err
-	}
-
-	if err := vr.pop(); err != nil {
-		return "", err
-	}
-	return vr.readString()
-}
-
-func (vr *valueReader) ReadMaxKey() error {
-	if err := vr.ensureElementValue(TypeMaxKey, 0, "ReadMaxKey"); err != nil {
-		return err
-	}
-
-	return vr.pop()
-}
-
-func (vr *valueReader) ReadMinKey() error {
-	if err := vr.ensureElementValue(TypeMinKey, 0, "ReadMinKey"); err != nil {
-		return err
-	}
-
-	return vr.pop()
-}
-
-func (vr *valueReader) ReadNull() error {
-	if err := vr.ensureElementValue(TypeNull, 0, "ReadNull"); err != nil {
-		return err
-	}
-
-	return vr.pop()
-}
-
-func (vr *valueReader) ReadObjectID() (ObjectID, error) {
-	if err := vr.ensureElementValue(TypeObjectID, 0, "ReadObjectID"); err != nil {
-		return ObjectID{}, err
-	}
-
-	var oid ObjectID
-	err := vr.read(oid[:])
-	if err != nil {
-		return ObjectID{}, err
-	}
-
-	if err := vr.pop(); err != nil {
-		return ObjectID{}, err
-	}
-	return oid, nil
-}
-
-func (vr *valueReader) ReadRegex() (string, string, error) {
-	if err := vr.ensureElementValue(TypeRegex, 0, "ReadRegex"); err != nil {
-		return "", "", err
-	}
-
-	pattern, err := vr.readCString()
-	if err != nil {
-		return "", "", err
-	}
-
-	options, err := vr.readCString()
-	if err != nil {
-		return "", "", err
-	}
-
-	if err := vr.pop(); err != nil {
-		return "", "", err
-	}
-	return pattern, options, nil
-}
-
-func (vr *valueReader) ReadString() (string, error) {
-	if err := vr.ensureElementValue(TypeString, 0, "ReadString"); err != nil {
-		return "", err
-	}
-
-	if err := vr.pop(); err != nil {
-		return "", err
-	}
-	return vr.readString()
-}
-
-func (vr *valueReader) ReadSymbol() (string, error) {
-	if err := vr.ensureElementValue(TypeSymbol, 0, "ReadSymbol"); err != nil {
-		return "", err
-	}
-
-	if err := vr.pop(); err != nil {
-		return "", err
-	}
-	return vr.readString()
-}
-
-func (vr *valueReader) ReadTimestamp() (t uint32, i uint32, err error) {
-	if err := vr.ensureElementValue(TypeTimestamp, 0, "ReadTimestamp"); err != nil {
-		return 0, 0, err
-	}
-
-	i, err = vr.readu32()
-	if err != nil {
-		return 0, 0, err
-	}
-
-	t, err = vr.readu32()
-	if err != nil {
-		return 0, 0, err
-	}
-
-	if err := vr.pop(); err != nil {
-		return 0, 0, err
-	}
-	return t, i, nil
-}
-
-func (vr *valueReader) ReadUndefined() error {
-	if err := vr.ensureElementValue(TypeUndefined, 0, "ReadUndefined"); err != nil {
-		return err
-	}
-
-	return vr.pop()
-}
-
-func (vr *valueReader) ReadElement() (string, ValueReader, error) {
-	switch vr.stack[vr.frame].mode {
-	case mTopLevel, mDocument, mCodeWithScope:
-	default:
-		return "", nil, vr.invalidTransitionErr(mElement, "ReadElement", []mode{mTopLevel, mDocument, mCodeWithScope})
-	}
-
-	t, err := vr.readByte()
-	if err != nil {
-		return "", nil, err
-	}
-
-	if t == 0 {
-		if vr.offset != vr.stack[vr.frame].end {
-			return "", nil, vr.invalidDocumentLengthError()
-		}
-
-		_ = vr.pop() // Ignore the error because the call here never reads from the underlying reader.
-		return "", nil, ErrEOD
-	}
-
-	name, err := vr.readCString()
-	if err != nil {
-		return "", nil, err
-	}
-
-	vr.pushElement(Type(t))
-	return name, vr, nil
-}
-
-func (vr *valueReader) ReadValue() (ValueReader, error) {
-	switch vr.stack[vr.frame].mode {
-	case mArray:
-	default:
-		return nil, vr.invalidTransitionErr(mValue, "ReadValue", []mode{mArray})
-	}
-
-	t, err := vr.readByte()
-	if err != nil {
-		return nil, err
-	}
-
-	if t == 0 {
-		if vr.offset != vr.stack[vr.frame].end {
-			return nil, vr.invalidDocumentLengthError()
-		}
-
-		_ = vr.pop() // Ignore the error because the call here never reads from the underlying reader.
-		return nil, ErrEOA
-	}
-
-	if _, err := vr.readCString(); err != nil {
-		return nil, err
-	}
-
-	vr.pushValue(Type(t))
-	return vr, nil
-}
-
-func (vr *valueReader) read(p []byte) error {
-	n, err := io.ReadFull(vr.r, p)
-	if err != nil {
-		return err
-	}
-	vr.offset += int64(n)
-	return nil
-}
-
-func (vr *valueReader) appendBytes(dst []byte, length int32) ([]byte, error) {
-	buf := make([]byte, length)
-	err := vr.read(buf)
-	if err != nil {
-		return nil, err
-	}
-	return append(dst, buf...), nil
-}
-
-func (vr *valueReader) readByte() (byte, error) {
-	b, err := vr.r.ReadByte()
-	if err != nil {
-		return 0x0, err
-	}
-	vr.offset++
-	return b, nil
-}
-
-func (vr *valueReader) readCString() (string, error) {
-	str, err := vr.r.ReadString(0x00)
-	if err != nil {
-		return "", err
-	}
-	l := len(str)
-	vr.offset += int64(l)
-	return str[:l-1], nil
-}
-
-func (vr *valueReader) readString() (string, error) {
-	length, err := vr.readLength()
-	if err != nil {
-		return "", err
-	}
-	if length <= 0 {
-		return "", fmt.Errorf("invalid string length: %d", length)
-	}
-
-	buf := make([]byte, length)
-	err = vr.read(buf)
-	if err != nil {
-		return "", err
-	}
-
-	if buf[length-1] != 0x00 {
-		return "", fmt.Errorf("string does not end with null byte, but with %v", buf[length-1])
-	}
-
-	return string(buf[:length-1]), nil
-}
-
-func (vr *valueReader) peekLength() (int32, error) {
-	buf, err := vr.r.Peek(4)
-	if err != nil {
-		return 0, err
-	}
-
-	return int32(binary.LittleEndian.Uint32(buf)), nil
-}
-
-func (vr *valueReader) readLength() (int32, error) {
-	l, err := vr.readi32()
-	if err != nil {
-		return 0, err
-	}
-	if l < 0 {
-		return 0, fmt.Errorf("invalid negative length: %d", l)
-	}
-	return l, nil
-}
-
-func (vr *valueReader) readi32() (int32, error) {
-	var buf [4]byte
-	err := vr.read(buf[:])
-	if err != nil {
-		return 0, err
-	}
-
-	return int32(binary.LittleEndian.Uint32(buf[:])), nil
-}
-
-func (vr *valueReader) readu32() (uint32, error) {
-	var buf [4]byte
-	err := vr.read(buf[:])
-	if err != nil {
-		return 0, err
-	}
-
-	return binary.LittleEndian.Uint32(buf[:]), nil
-}
-
-func (vr *valueReader) readi64() (int64, error) {
-	var buf [8]byte
-	err := vr.read(buf[:])
-	if err != nil {
-		return 0, err
-	}
-
-	return int64(binary.LittleEndian.Uint64(buf[:])), nil
-}
-
-func (vr *valueReader) readu64() (uint64, error) {
-	var buf [8]byte
-	err := vr.read(buf[:])
-	if err != nil {
-		return 0, err
-	}
-
-	return binary.LittleEndian.Uint64(buf[:]), nil
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/value_writer.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/value_writer.go
deleted file mode 100644
index 2748696f..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/value_writer.go
+++ /dev/null
@@ -1,600 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"strconv"
-	"strings"
-	"sync"
-
-	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
-)
-
-var _ ValueWriter = &valueWriter{}
-
-var vwPool = sync.Pool{
-	New: func() interface{} {
-		return new(valueWriter)
-	},
-}
-
-func putValueWriter(vw *valueWriter) {
-	if vw != nil {
-		vw.w = nil // don't leak the writer
-		vwPool.Put(vw)
-	}
-}
-
-var documentWriterPool = sync.Pool{
-	New: func() interface{} {
-		return newDocumentWriter(nil)
-	},
-}
-
-func getDocumentWriter(w io.Writer) *valueWriter {
-	vw := documentWriterPool.Get().(*valueWriter)
-
-	vw.reset(vw.buf)
-	vw.buf = vw.buf[:0]
-	vw.w = w
-
-	return vw
-}
-
-func putDocumentWriter(vw *valueWriter) {
-	if vw != nil {
-		vw.w = nil // don't leak the writer
-		documentWriterPool.Put(vw)
-	}
-}
-
-// This is here so that during testing we can change it and not require
-// allocating a 4GB slice.
-var maxSize = math.MaxInt32
-
-type errMaxDocumentSizeExceeded struct {
-	size int64
-}
-
-func (mdse errMaxDocumentSizeExceeded) Error() string {
-	return fmt.Sprintf("document size (%d) is larger than the max int32", mdse.size)
-}
-
-type vwMode int
-
-const (
-	_ vwMode = iota
-	vwTopLevel
-	vwDocument
-	vwArray
-	vwValue
-	vwElement
-	vwCodeWithScope
-)
-
-func (vm vwMode) String() string {
-	var str string
-
-	switch vm {
-	case vwTopLevel:
-		str = "TopLevel"
-	case vwDocument:
-		str = "DocumentMode"
-	case vwArray:
-		str = "ArrayMode"
-	case vwValue:
-		str = "ValueMode"
-	case vwElement:
-		str = "ElementMode"
-	case vwCodeWithScope:
-		str = "CodeWithScopeMode"
-	default:
-		str = "UnknownMode"
-	}
-
-	return str
-}
-
-type vwState struct {
-	mode   mode
-	key    string
-	arrkey int
-	start  int32
-}
-
-type valueWriter struct {
-	w   io.Writer
-	buf []byte
-
-	stack []vwState
-	frame int64
-}
-
-func (vw *valueWriter) advanceFrame() {
-	vw.frame++
-	if vw.frame >= int64(len(vw.stack)) {
-		vw.stack = append(vw.stack, vwState{})
-	}
-}
-
-func (vw *valueWriter) push(m mode) {
-	vw.advanceFrame()
-
-	// Clean the stack
-	vw.stack[vw.frame] = vwState{mode: m}
-
-	switch m {
-	case mDocument, mArray, mCodeWithScope:
-		vw.reserveLength() // WARN: this is not needed
-	}
-}
-
-func (vw *valueWriter) reserveLength() {
-	vw.stack[vw.frame].start = int32(len(vw.buf))
-	vw.buf = append(vw.buf, 0x00, 0x00, 0x00, 0x00)
-}
-
-func (vw *valueWriter) pop() {
-	switch vw.stack[vw.frame].mode {
-	case mElement, mValue:
-		vw.frame--
-	case mDocument, mArray, mCodeWithScope:
-		vw.frame -= 2 // we pop twice to jump over the mElement: mDocument -> mElement -> mDocument/mTopLevel/etc...
-	}
-}
-
-// NewDocumentWriter creates a ValueWriter that writes BSON to w.
-//
-// This ValueWriter will only write entire documents to the io.Writer and it
-// will buffer the document as it is built.
-func NewDocumentWriter(w io.Writer) ValueWriter {
-	return newDocumentWriter(w)
-}
-
-func newDocumentWriter(w io.Writer) *valueWriter {
-	vw := new(valueWriter)
-	stack := make([]vwState, 1, 5)
-	stack[0] = vwState{mode: mTopLevel}
-	vw.w = w
-	vw.stack = stack
-
-	return vw
-}
-
-func newValueWriterFromSlice(buf []byte) *valueWriter {
-	vw := new(valueWriter)
-	stack := make([]vwState, 1, 5)
-	stack[0] = vwState{mode: mTopLevel}
-	vw.stack = stack
-	vw.buf = buf
-
-	return vw
-}
-
-func (vw *valueWriter) reset(buf []byte) {
-	if vw.stack == nil {
-		vw.stack = make([]vwState, 1, 5)
-	}
-	vw.stack = vw.stack[:1]
-	vw.stack[0] = vwState{mode: mTopLevel}
-	vw.buf = buf
-	vw.frame = 0
-	vw.w = nil
-}
-
-func (vw *valueWriter) invalidTransitionError(destination mode, name string, modes []mode) error {
-	te := TransitionError{
-		name:        name,
-		current:     vw.stack[vw.frame].mode,
-		destination: destination,
-		modes:       modes,
-		action:      "write",
-	}
-	if vw.frame != 0 {
-		te.parent = vw.stack[vw.frame-1].mode
-	}
-	return te
-}
-
-func (vw *valueWriter) writeElementHeader(t Type, destination mode, callerName string, addmodes ...mode) error {
-	frame := &vw.stack[vw.frame]
-	switch frame.mode {
-	case mElement:
-		key := frame.key
-		if !isValidCString(key) {
-			return errors.New("BSON element key cannot contain null bytes")
-		}
-		vw.appendHeader(t, key)
-	case mValue:
-		vw.appendIntHeader(t, frame.arrkey)
-	default:
-		modes := []mode{mElement, mValue}
-		if addmodes != nil {
-			modes = append(modes, addmodes...)
-		}
-		return vw.invalidTransitionError(destination, callerName, modes)
-	}
-
-	return nil
-}
-
-func (vw *valueWriter) writeValueBytes(t Type, b []byte) error {
-	if err := vw.writeElementHeader(t, mode(0), "WriteValueBytes"); err != nil {
-		return err
-	}
-	vw.buf = append(vw.buf, b...)
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteArray() (ArrayWriter, error) {
-	if err := vw.writeElementHeader(TypeArray, mArray, "WriteArray"); err != nil {
-		return nil, err
-	}
-
-	vw.push(mArray)
-
-	return vw, nil
-}
-
-func (vw *valueWriter) WriteBinary(b []byte) error {
-	return vw.WriteBinaryWithSubtype(b, 0x00)
-}
-
-func (vw *valueWriter) WriteBinaryWithSubtype(b []byte, btype byte) error {
-	if err := vw.writeElementHeader(TypeBinary, mode(0), "WriteBinaryWithSubtype"); err != nil {
-		return err
-	}
-
-	vw.buf = bsoncore.AppendBinary(vw.buf, btype, b)
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteBoolean(b bool) error {
-	if err := vw.writeElementHeader(TypeBoolean, mode(0), "WriteBoolean"); err != nil {
-		return err
-	}
-
-	vw.buf = bsoncore.AppendBoolean(vw.buf, b)
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteCodeWithScope(code string) (DocumentWriter, error) {
-	if err := vw.writeElementHeader(TypeCodeWithScope, mCodeWithScope, "WriteCodeWithScope"); err != nil {
-		return nil, err
-	}
-
-	// CodeWithScope is a different than other types because we need an extra
-	// frame on the stack. In the EndDocument code, we write the document
-	// length, pop, write the code with scope length, and pop. To simplify the
-	// pop code, we push a spacer frame that we'll always jump over.
-	vw.push(mCodeWithScope)
-	vw.buf = bsoncore.AppendString(vw.buf, code)
-	vw.push(mSpacer)
-	vw.push(mDocument)
-
-	return vw, nil
-}
-
-func (vw *valueWriter) WriteDBPointer(ns string, oid ObjectID) error {
-	if err := vw.writeElementHeader(TypeDBPointer, mode(0), "WriteDBPointer"); err != nil {
-		return err
-	}
-
-	vw.buf = bsoncore.AppendDBPointer(vw.buf, ns, oid)
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteDateTime(dt int64) error {
-	if err := vw.writeElementHeader(TypeDateTime, mode(0), "WriteDateTime"); err != nil {
-		return err
-	}
-
-	vw.buf = bsoncore.AppendDateTime(vw.buf, dt)
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteDecimal128(d128 Decimal128) error {
-	if err := vw.writeElementHeader(TypeDecimal128, mode(0), "WriteDecimal128"); err != nil {
-		return err
-	}
-
-	h, l := d128.GetBytes()
-	vw.buf = bsoncore.AppendDecimal128(vw.buf, h, l)
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteDouble(f float64) error {
-	if err := vw.writeElementHeader(TypeDouble, mode(0), "WriteDouble"); err != nil {
-		return err
-	}
-
-	vw.buf = bsoncore.AppendDouble(vw.buf, f)
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteInt32(i32 int32) error {
-	if err := vw.writeElementHeader(TypeInt32, mode(0), "WriteInt32"); err != nil {
-		return err
-	}
-
-	vw.buf = bsoncore.AppendInt32(vw.buf, i32)
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteInt64(i64 int64) error {
-	if err := vw.writeElementHeader(TypeInt64, mode(0), "WriteInt64"); err != nil {
-		return err
-	}
-
-	vw.buf = bsoncore.AppendInt64(vw.buf, i64)
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteJavascript(code string) error {
-	if err := vw.writeElementHeader(TypeJavaScript, mode(0), "WriteJavascript"); err != nil {
-		return err
-	}
-
-	vw.buf = bsoncore.AppendJavaScript(vw.buf, code)
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteMaxKey() error {
-	if err := vw.writeElementHeader(TypeMaxKey, mode(0), "WriteMaxKey"); err != nil {
-		return err
-	}
-
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteMinKey() error {
-	if err := vw.writeElementHeader(TypeMinKey, mode(0), "WriteMinKey"); err != nil {
-		return err
-	}
-
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteNull() error {
-	if err := vw.writeElementHeader(TypeNull, mode(0), "WriteNull"); err != nil {
-		return err
-	}
-
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteObjectID(oid ObjectID) error {
-	if err := vw.writeElementHeader(TypeObjectID, mode(0), "WriteObjectID"); err != nil {
-		return err
-	}
-
-	vw.buf = bsoncore.AppendObjectID(vw.buf, oid)
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteRegex(pattern string, options string) error {
-	if !isValidCString(pattern) || !isValidCString(options) {
-		return errors.New("BSON regex values cannot contain null bytes")
-	}
-	if err := vw.writeElementHeader(TypeRegex, mode(0), "WriteRegex"); err != nil {
-		return err
-	}
-
-	vw.buf = bsoncore.AppendRegex(vw.buf, pattern, sortStringAlphebeticAscending(options))
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteString(s string) error {
-	if err := vw.writeElementHeader(TypeString, mode(0), "WriteString"); err != nil {
-		return err
-	}
-
-	vw.buf = bsoncore.AppendString(vw.buf, s)
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteDocument() (DocumentWriter, error) {
-	if vw.stack[vw.frame].mode == mTopLevel {
-		vw.reserveLength()
-		return vw, nil
-	}
-	if err := vw.writeElementHeader(TypeEmbeddedDocument, mDocument, "WriteDocument", mTopLevel); err != nil {
-		return nil, err
-	}
-
-	vw.push(mDocument)
-	return vw, nil
-}
-
-func (vw *valueWriter) WriteSymbol(symbol string) error {
-	if err := vw.writeElementHeader(TypeSymbol, mode(0), "WriteSymbol"); err != nil {
-		return err
-	}
-
-	vw.buf = bsoncore.AppendSymbol(vw.buf, symbol)
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteTimestamp(t uint32, i uint32) error {
-	if err := vw.writeElementHeader(TypeTimestamp, mode(0), "WriteTimestamp"); err != nil {
-		return err
-	}
-
-	vw.buf = bsoncore.AppendTimestamp(vw.buf, t, i)
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteUndefined() error {
-	if err := vw.writeElementHeader(TypeUndefined, mode(0), "WriteUndefined"); err != nil {
-		return err
-	}
-
-	vw.pop()
-	return nil
-}
-
-func (vw *valueWriter) WriteDocumentElement(key string) (ValueWriter, error) {
-	switch vw.stack[vw.frame].mode {
-	case mTopLevel, mDocument:
-	default:
-		return nil, vw.invalidTransitionError(mElement, "WriteDocumentElement", []mode{mTopLevel, mDocument})
-	}
-
-	vw.push(mElement)
-	vw.stack[vw.frame].key = key
-
-	return vw, nil
-}
-
-func (vw *valueWriter) WriteDocumentEnd() error {
-	switch vw.stack[vw.frame].mode {
-	case mTopLevel, mDocument:
-	default:
-		return fmt.Errorf("incorrect mode to end document: %s", vw.stack[vw.frame].mode)
-	}
-
-	vw.buf = append(vw.buf, 0x00)
-
-	err := vw.writeLength()
-	if err != nil {
-		return err
-	}
-
-	if vw.stack[vw.frame].mode == mTopLevel {
-		if err = vw.Flush(); err != nil {
-			return err
-		}
-	}
-
-	vw.pop()
-
-	if vw.stack[vw.frame].mode == mCodeWithScope {
-		// We ignore the error here because of the guarantee of writeLength.
-		// See the docs for writeLength for more info.
-		_ = vw.writeLength()
-		vw.pop()
-	}
-	return nil
-}
-
-func (vw *valueWriter) Flush() error {
-	if vw.w == nil {
-		return nil
-	}
-
-	if _, err := vw.w.Write(vw.buf); err != nil {
-		return err
-	}
-	// reset buffer
-	vw.buf = vw.buf[:0]
-	return nil
-}
-
-func (vw *valueWriter) WriteArrayElement() (ValueWriter, error) {
-	if vw.stack[vw.frame].mode != mArray {
-		return nil, vw.invalidTransitionError(mValue, "WriteArrayElement", []mode{mArray})
-	}
-
-	arrkey := vw.stack[vw.frame].arrkey
-	vw.stack[vw.frame].arrkey++
-
-	vw.push(mValue)
-	vw.stack[vw.frame].arrkey = arrkey
-
-	return vw, nil
-}
-
-func (vw *valueWriter) WriteArrayEnd() error {
-	if vw.stack[vw.frame].mode != mArray {
-		return fmt.Errorf("incorrect mode to end array: %s", vw.stack[vw.frame].mode)
-	}
-
-	vw.buf = append(vw.buf, 0x00)
-
-	err := vw.writeLength()
-	if err != nil {
-		return err
-	}
-
-	vw.pop()
-	return nil
-}
-
-// NOTE: We assume that if we call writeLength more than once the same function
-// within the same function without altering the vw.buf that this method will
-// not return an error. If this changes ensure that the following methods are
-// updated:
-//
-// - WriteDocumentEnd
-func (vw *valueWriter) writeLength() error {
-	length := len(vw.buf)
-	if length > maxSize {
-		return errMaxDocumentSizeExceeded{size: int64(len(vw.buf))}
-	}
-	frame := &vw.stack[vw.frame]
-	length -= int(frame.start)
-	start := frame.start
-
-	_ = vw.buf[start+3] // BCE
-	vw.buf[start+0] = byte(length)
-	vw.buf[start+1] = byte(length >> 8)
-	vw.buf[start+2] = byte(length >> 16)
-	vw.buf[start+3] = byte(length >> 24)
-	return nil
-}
-
-func isValidCString(cs string) bool {
-	// Disallow the zero byte in a cstring because the zero byte is used as the
-	// terminating character.
-	//
-	// It's safe to check bytes instead of runes because all multibyte UTF-8
-	// code points start with (binary) 11xxxxxx or 10xxxxxx, so 00000000 (i.e.
-	// 0) will never be part of a multibyte UTF-8 code point. This logic is the
-	// same as the "r < utf8.RuneSelf" case in strings.IndexRune but can be
-	// inlined.
-	//
-	// https://cs.opensource.google/go/go/+/refs/tags/go1.21.1:src/strings/strings.go;l=127
-	return strings.IndexByte(cs, 0) == -1
-}
-
-// appendHeader is the same as bsoncore.AppendHeader but does not check if the
-// key is a valid C string since the caller has already checked for that.
-//
-// The caller of this function must check if key is a valid C string.
-func (vw *valueWriter) appendHeader(t Type, key string) {
-	vw.buf = bsoncore.AppendType(vw.buf, bsoncore.Type(t))
-	vw.buf = append(vw.buf, key...)
-	vw.buf = append(vw.buf, 0x00)
-}
-
-func (vw *valueWriter) appendIntHeader(t Type, key int) {
-	vw.buf = bsoncore.AppendType(vw.buf, bsoncore.Type(t))
-	vw.buf = strconv.AppendInt(vw.buf, int64(key), 10)
-	vw.buf = append(vw.buf, 0x00)
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/vector.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/vector.go
deleted file mode 100644
index 31a10bd5..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/vector.go
+++ /dev/null
@@ -1,268 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2024-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-import (
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"math"
-)
-
-// BSON binary vector types as described in https://bsonspec.org/spec.html.
-const (
-	Int8Vector      byte = 0x03
-	Float32Vector   byte = 0x27
-	PackedBitVector byte = 0x10
-)
-
-// These are vector conversion errors.
-var (
-	errInsufficientVectorData = errors.New("insufficient data")
-	errNonZeroVectorPadding   = errors.New("padding must be 0")
-	errVectorPaddingTooLarge  = errors.New("padding cannot be larger than 7")
-)
-
-type vectorTypeError struct {
-	Method string
-	Type   byte
-}
-
-// Error implements the error interface.
-func (vte vectorTypeError) Error() string {
-	t := "invalid"
-	switch vte.Type {
-	case Int8Vector:
-		t = "int8"
-	case Float32Vector:
-		t = "float32"
-	case PackedBitVector:
-		t = "packed bit"
-	}
-	return fmt.Sprintf("cannot call %s, on a type %s vector", vte.Method, t)
-}
-
-// Vector represents a densely packed array of numbers / bits.
-type Vector struct {
-	dType       byte
-	int8Data    []int8
-	float32Data []float32
-	bitData     []byte
-	bitPadding  uint8
-}
-
-// Type returns the vector type.
-func (v Vector) Type() byte {
-	return v.dType
-}
-
-// Int8 returns the int8 slice hold by the vector.
-// It panics if v is not an int8 vector.
-func (v Vector) Int8() []int8 {
-	d, ok := v.Int8OK()
-	if !ok {
-		panic(vectorTypeError{"bson.Vector.Int8", v.dType})
-	}
-	return d
-}
-
-// Int8OK is the same as Int8, but returns a boolean instead of panicking.
-func (v Vector) Int8OK() ([]int8, bool) {
-	if v.dType != Int8Vector {
-		return nil, false
-	}
-	return v.int8Data, true
-}
-
-// Float32 returns the float32 slice hold by the vector.
-// It panics if v is not a float32 vector.
-func (v Vector) Float32() []float32 {
-	d, ok := v.Float32OK()
-	if !ok {
-		panic(vectorTypeError{"bson.Vector.Float32", v.dType})
-	}
-	return d
-}
-
-// Float32OK is the same as Float32, but returns a boolean instead of panicking.
-func (v Vector) Float32OK() ([]float32, bool) {
-	if v.dType != Float32Vector {
-		return nil, false
-	}
-	return v.float32Data, true
-}
-
-// PackedBit returns the byte slice representing the binary quantized (packed bit) vector and the byte padding, which
-// is the number of bits in the final byte that are to be ignored.
-// It panics if v is not a packed bit vector.
-func (v Vector) PackedBit() ([]byte, uint8) {
-	d, p, ok := v.PackedBitOK()
-	if !ok {
-		panic(vectorTypeError{"bson.Vector.PackedBit", v.dType})
-	}
-	return d, p
-}
-
-// PackedBitOK is the same as PackedBit, but returns a boolean instead of panicking.
-func (v Vector) PackedBitOK() ([]byte, uint8, bool) {
-	if v.dType != PackedBitVector {
-		return nil, 0, false
-	}
-	return v.bitData, v.bitPadding, true
-}
-
-// Binary returns the BSON Binary representation of the Vector.
-func (v Vector) Binary() Binary {
-	switch v.Type() {
-	case Int8Vector:
-		return binaryFromInt8Vector(v.Int8())
-	case Float32Vector:
-		return binaryFromFloat32Vector(v.Float32())
-	case PackedBitVector:
-		return binaryFromBitVector(v.PackedBit())
-	default:
-		panic(fmt.Sprintf("invalid Vector data type: %d", v.dType))
-	}
-}
-
-func binaryFromInt8Vector(v []int8) Binary {
-	data := make([]byte, len(v)+2)
-	data[0] = Int8Vector
-	data[1] = 0
-
-	for i, e := range v {
-		data[i+2] = byte(e)
-	}
-
-	return Binary{
-		Subtype: TypeBinaryVector,
-		Data:    data,
-	}
-}
-
-func binaryFromFloat32Vector(v []float32) Binary {
-	data := make([]byte, 2, len(v)*4+2)
-	data[0] = Float32Vector
-	data[1] = 0
-	var a [4]byte
-	for _, e := range v {
-		binary.LittleEndian.PutUint32(a[:], math.Float32bits(e))
-		data = append(data, a[:]...)
-	}
-
-	return Binary{
-		Subtype: TypeBinaryVector,
-		Data:    data,
-	}
-}
-
-func binaryFromBitVector(bits []byte, padding uint8) Binary {
-	data := make([]byte, len(bits)+2)
-	data[0] = PackedBitVector
-	data[1] = padding
-	copy(data[2:], bits)
-	return Binary{
-		Subtype: TypeBinaryVector,
-		Data:    data,
-	}
-}
-
-// NewVector constructs a Vector from a slice of int8 or float32.
-func NewVector[T int8 | float32](data []T) Vector {
-	var v Vector
-	switch a := any(data).(type) {
-	case []int8:
-		v.dType = Int8Vector
-		v.int8Data = make([]int8, len(data))
-		copy(v.int8Data, a)
-	case []float32:
-		v.dType = Float32Vector
-		v.float32Data = make([]float32, len(data))
-		copy(v.float32Data, a)
-	default:
-		panic(fmt.Errorf("unsupported type %T", data))
-	}
-	return v
-}
-
-// NewPackedBitVector constructs a Vector from a byte slice and a value of byte padding.
-func NewPackedBitVector(bits []byte, padding uint8) (Vector, error) {
-	var v Vector
-	if padding > 7 {
-		return v, errVectorPaddingTooLarge
-	}
-	if padding > 0 && len(bits) == 0 {
-		return v, errNonZeroVectorPadding
-	}
-	v.dType = PackedBitVector
-	v.bitData = make([]byte, len(bits))
-	copy(v.bitData, bits)
-	v.bitPadding = padding
-	return v, nil
-}
-
-// NewVectorFromBinary unpacks a BSON Binary into a Vector.
-func NewVectorFromBinary(b Binary) (Vector, error) {
-	var v Vector
-	if b.Subtype != TypeBinaryVector {
-		return v, errors.New("not a vector")
-	}
-	if len(b.Data) < 2 {
-		return v, errInsufficientVectorData
-	}
-	switch t := b.Data[0]; t {
-	case Int8Vector:
-		return newInt8Vector(b.Data[1:])
-	case Float32Vector:
-		return newFloat32Vector(b.Data[1:])
-	case PackedBitVector:
-		return newBitVector(b.Data[1:])
-	default:
-		return v, fmt.Errorf("invalid Vector data type: %d", t)
-	}
-}
-
-func newInt8Vector(b []byte) (Vector, error) {
-	var v Vector
-	if len(b) == 0 {
-		return v, errInsufficientVectorData
-	}
-	if padding := b[0]; padding > 0 {
-		return v, errNonZeroVectorPadding
-	}
-	s := make([]int8, 0, len(b)-1)
-	for i := 1; i < len(b); i++ {
-		s = append(s, int8(b[i]))
-	}
-	return NewVector(s), nil
-}
-
-func newFloat32Vector(b []byte) (Vector, error) {
-	var v Vector
-	if len(b) == 0 {
-		return v, errInsufficientVectorData
-	}
-	if padding := b[0]; padding > 0 {
-		return v, errNonZeroVectorPadding
-	}
-	l := (len(b) - 1) / 4
-	if l*4 != len(b)-1 {
-		return v, errInsufficientVectorData
-	}
-	s := make([]float32, 0, l)
-	for i := 1; i < len(b); i += 4 {
-		s = append(s, math.Float32frombits(binary.LittleEndian.Uint32(b[i:i+4])))
-	}
-	return NewVector(s), nil
-}
-
-func newBitVector(b []byte) (Vector, error) {
-	if len(b) == 0 {
-		return Vector{}, errInsufficientVectorData
-	}
-	return NewPackedBitVector(b[1:], b[0])
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/bson/writer.go b/vendor/go.mongodb.org/mongo-driver/v2/bson/writer.go
deleted file mode 100644
index 84cad0dd..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/bson/writer.go
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bson
-
-// ArrayWriter is the interface used to create a BSON or BSON adjacent array.
-// Callers must ensure they call WriteArrayEnd when they have finished creating
-// the array.
-type ArrayWriter interface {
-	WriteArrayElement() (ValueWriter, error)
-	WriteArrayEnd() error
-}
-
-// DocumentWriter is the interface used to create a BSON or BSON adjacent
-// document. Callers must ensure they call WriteDocumentEnd when they have
-// finished creating the document.
-type DocumentWriter interface {
-	WriteDocumentElement(string) (ValueWriter, error)
-	WriteDocumentEnd() error
-}
-
-// ValueWriter is the interface used to write BSON values. Implementations of
-// this interface handle creating BSON or BSON adjacent representations of the
-// values.
-type ValueWriter interface {
-	WriteArray() (ArrayWriter, error)
-	WriteBinary(b []byte) error
-	WriteBinaryWithSubtype(b []byte, btype byte) error
-	WriteBoolean(bool) error
-	WriteCodeWithScope(code string) (DocumentWriter, error)
-	WriteDBPointer(ns string, oid ObjectID) error
-	WriteDateTime(dt int64) error
-	WriteDecimal128(Decimal128) error
-	WriteDouble(float64) error
-	WriteInt32(int32) error
-	WriteInt64(int64) error
-	WriteJavascript(code string) error
-	WriteMaxKey() error
-	WriteMinKey() error
-	WriteNull() error
-	WriteObjectID(ObjectID) error
-	WriteRegex(pattern, options string) error
-	WriteString(string) error
-	WriteDocument() (DocumentWriter, error)
-	WriteSymbol(symbol string) error
-	WriteTimestamp(t, i uint32) error
-	WriteUndefined() error
-}
-
-// sliceWriter allows a pointer to a slice of bytes to be used as an io.Writer.
-type sliceWriter []byte
-
-// Write writes the bytes to the underlying slice.
-func (sw *sliceWriter) Write(p []byte) (int, error) {
-	written := len(p)
-	*sw = append(*sw, p...)
-	return written, nil
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/internal/bsoncoreutil/bsoncoreutil.go b/vendor/go.mongodb.org/mongo-driver/v2/internal/bsoncoreutil/bsoncoreutil.go
deleted file mode 100644
index ff0f6493..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/internal/bsoncoreutil/bsoncoreutil.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2024-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bsoncoreutil
-
-// Truncate truncates a given string for a certain width
-func Truncate(str string, width int) string {
-	if width == 0 {
-		return ""
-	}
-
-	if len(str) <= width {
-		return str
-	}
-
-	// Truncate the byte slice of the string to the given width.
-	newStr := str[:width]
-
-	// Check if the last byte is at the beginning of a multi-byte character.
-	// If it is, then remove the last byte.
-	if newStr[len(newStr)-1]&0xC0 == 0xC0 {
-		return newStr[:len(newStr)-1]
-	}
-
-	// Check if the last byte is a multi-byte character
-	if newStr[len(newStr)-1]&0xC0 == 0x80 {
-		// If it is, step back until you we are at the start of a character
-		for i := len(newStr) - 1; i >= 0; i-- {
-			if newStr[i]&0xC0 == 0xC0 {
-				// Truncate at the end of the character before the character we stepped back to
-				return newStr[:i]
-			}
-		}
-	}
-
-	return newStr
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/internal/decimal128/decinal128.go b/vendor/go.mongodb.org/mongo-driver/v2/internal/decimal128/decinal128.go
deleted file mode 100644
index 2767e445..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/internal/decimal128/decinal128.go
+++ /dev/null
@@ -1,117 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package decimal128
-
-import (
-	"strconv"
-)
-
-// These constants are the maximum and minimum values for the exponent field in a decimal128 value.
-const (
-	MaxDecimal128Exp = 6111
-	MinDecimal128Exp = -6176
-)
-
-func divmod(h, l uint64, div uint32) (qh, ql uint64, rem uint32) {
-	div64 := uint64(div)
-	a := h >> 32
-	aq := a / div64
-	ar := a % div64
-	b := ar<<32 + h&(1<<32-1)
-	bq := b / div64
-	br := b % div64
-	c := br<<32 + l>>32
-	cq := c / div64
-	cr := c % div64
-	d := cr<<32 + l&(1<<32-1)
-	dq := d / div64
-	dr := d % div64
-	return (aq<<32 | bq), (cq<<32 | dq), uint32(dr)
-}
-
-// String returns a string representation of the decimal value.
-func String(h, l uint64) string {
-	var posSign int      // positive sign
-	var exp int          // exponent
-	var high, low uint64 // significand high/low
-
-	if h>>63&1 == 0 {
-		posSign = 1
-	}
-
-	switch h >> 58 & (1<<5 - 1) {
-	case 0x1F:
-		return "NaN"
-	case 0x1E:
-		return "-Infinity"[posSign:]
-	}
-
-	low = l
-	if h>>61&3 == 3 {
-		// Bits: 1*sign 2*ignored 14*exponent 111*significand.
-		// Implicit 0b100 prefix in significand.
-		exp = int(h >> 47 & (1<<14 - 1))
-		// Spec says all of these values are out of range.
-		high, low = 0, 0
-	} else {
-		// Bits: 1*sign 14*exponent 113*significand
-		exp = int(h >> 49 & (1<<14 - 1))
-		high = h & (1<<49 - 1)
-	}
-	exp += MinDecimal128Exp
-
-	// Would be handled by the logic below, but that's trivial and common.
-	if high == 0 && low == 0 && exp == 0 {
-		return "-0"[posSign:]
-	}
-
-	var repr [48]byte // Loop 5 times over 9 digits plus dot, negative sign, and leading zero.
-	var last = len(repr)
-	var i = len(repr)
-	var dot = len(repr) + exp
-	var rem uint32
-Loop:
-	for d9 := 0; d9 < 5; d9++ {
-		high, low, rem = divmod(high, low, 1e9)
-		for d1 := 0; d1 < 9; d1++ {
-			// Handle "-0.0", "0.00123400", "-1.00E-6", "1.050E+3", etc.
-			if i < len(repr) && (dot == i || low == 0 && high == 0 && rem > 0 && rem < 10 && (dot < i-6 || exp > 0)) {
-				exp += len(repr) - i
-				i--
-				repr[i] = '.'
-				last = i - 1
-				dot = len(repr) // Unmark.
-			}
-			c := '0' + byte(rem%10)
-			rem /= 10
-			i--
-			repr[i] = c
-			// Handle "0E+3", "1E+3", etc.
-			if low == 0 && high == 0 && rem == 0 && i == len(repr)-1 && (dot < i-5 || exp > 0) {
-				last = i
-				break Loop
-			}
-			if c != '0' {
-				last = i
-			}
-			// Break early. Works without it, but why.
-			if dot > i && low == 0 && high == 0 && rem == 0 {
-				break Loop
-			}
-		}
-	}
-	repr[last-1] = '-'
-	last--
-
-	if exp > 0 {
-		return string(repr[last+posSign:]) + "E+" + strconv.Itoa(exp)
-	}
-	if exp < 0 {
-		return string(repr[last+posSign:]) + "E" + strconv.Itoa(exp)
-	}
-	return string(repr[last+posSign:])
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/array.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/array.go
deleted file mode 100644
index 0efbdc0f..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/array.go
+++ /dev/null
@@ -1,185 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bsoncore
-
-import (
-	"fmt"
-	"io"
-	"math"
-	"strconv"
-	"strings"
-)
-
-// NewArrayLengthError creates and returns an error for when the length of an array exceeds the
-// bytes available.
-func NewArrayLengthError(length, rem int) error {
-	return lengthError("array", length, rem)
-}
-
-// Array is a raw bytes representation of a BSON array.
-type Array []byte
-
-// NewArrayFromReader reads an array from r. This function will only validate the length is
-// correct and that the array ends with a null byte.
-func NewArrayFromReader(r io.Reader) (Array, error) {
-	return newBufferFromReader(r)
-}
-
-// Index searches for and retrieves the value at the given index. This method will panic if
-// the array is invalid or if the index is out of bounds.
-func (a Array) Index(index uint) Value {
-	value, err := a.IndexErr(index)
-	if err != nil {
-		panic(err)
-	}
-	return value
-}
-
-// IndexErr searches for and retrieves the value at the given index.
-func (a Array) IndexErr(index uint) (Value, error) {
-	elem, err := indexErr(a, index)
-	if err != nil {
-		return Value{}, err
-	}
-	return elem.Value(), err
-}
-
-// DebugString outputs a human readable version of Array. It will attempt to stringify the
-// valid components of the array even if the entire array is not valid.
-func (a Array) DebugString() string {
-	if len(a) < 5 {
-		return "<malformed>"
-	}
-	var buf strings.Builder
-	buf.WriteString("Array")
-	length, rem, _ := ReadLength(a) // We know we have enough bytes to read the length
-	buf.WriteByte('(')
-	buf.WriteString(strconv.Itoa(int(length)))
-	length -= 4
-	buf.WriteString(")[")
-	var elem Element
-	var ok bool
-	for length > 1 {
-		elem, rem, ok = ReadElement(rem)
-		length -= int32(len(elem))
-		if !ok {
-			buf.WriteString(fmt.Sprintf("<malformed (%d)>", length))
-			break
-		}
-		buf.WriteString(elem.Value().DebugString())
-		if length != 1 {
-			buf.WriteByte(',')
-		}
-	}
-	buf.WriteByte(']')
-
-	return buf.String()
-}
-
-// String outputs an ExtendedJSON version of Array. If the Array is not valid, this method
-// returns an empty string.
-func (a Array) String() string {
-	return a.StringN(math.MaxInt)
-}
-
-// StringN stringifies an array upto N bytes
-func (a Array) StringN(n int) string {
-	if lens, _, _ := ReadLength(a); lens < 5 || n <= 0 {
-		return ""
-	}
-
-	var buf strings.Builder
-	buf.WriteByte('[')
-
-	length, rem, _ := ReadLength(a) // We know we have enough bytes to read the length
-	length -= 4
-
-	var elem Element
-	var ok bool
-
-	if n > 0 {
-		for length > 1 {
-			elem, rem, ok = ReadElement(rem)
-
-			length -= int32(len(elem))
-			if !ok {
-				return ""
-			}
-
-			str := elem.Value().StringN(n - buf.Len())
-
-			buf.WriteString(str)
-
-			if buf.Len() == n {
-				return buf.String()
-			}
-
-			if length > 1 {
-				buf.WriteByte(',')
-			}
-		}
-		if length != 1 { // Missing final null byte or inaccurate length
-			return ""
-		}
-	}
-
-	if buf.Len()+1 <= n {
-		buf.WriteByte(']')
-	}
-
-	return buf.String()
-}
-
-// Values returns this array as a slice of values. The returned slice will contain valid values.
-// If the array is not valid, the values up to the invalid point will be returned along with an
-// error.
-func (a Array) Values() ([]Value, error) {
-	return values(a)
-}
-
-// Validate validates the array and ensures the elements contained within are valid.
-func (a Array) Validate() error {
-	length, rem, ok := ReadLength(a)
-	if !ok {
-		return NewInsufficientBytesError(a, rem)
-	}
-	if int(length) > len(a) {
-		return NewArrayLengthError(int(length), len(a))
-	}
-	if a[length-1] != 0x00 {
-		return ErrMissingNull
-	}
-
-	length -= 4
-	var elem Element
-
-	var keyNum int64
-	for length > 1 {
-		elem, rem, ok = ReadElement(rem)
-		length -= int32(len(elem))
-		if !ok {
-			return NewInsufficientBytesError(a, rem)
-		}
-
-		// validate element
-		err := elem.Validate()
-		if err != nil {
-			return err
-		}
-
-		// validate keys increase numerically
-		if fmt.Sprint(keyNum) != elem.Key() {
-			return fmt.Errorf("array key %q is out of order or invalid", elem.Key())
-		}
-		keyNum++
-	}
-
-	if len(rem) < 1 || rem[0] != 0x00 {
-		return ErrMissingNull
-	}
-	return nil
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bson_arraybuilder.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bson_arraybuilder.go
deleted file mode 100644
index 8856c113..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bson_arraybuilder.go
+++ /dev/null
@@ -1,198 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bsoncore
-
-import (
-	"strconv"
-)
-
-// ArrayBuilder builds a bson array
-type ArrayBuilder struct {
-	arr     []byte
-	indexes []int32
-	keys    []int
-}
-
-// NewArrayBuilder creates a new ArrayBuilder
-func NewArrayBuilder() *ArrayBuilder {
-	return (&ArrayBuilder{}).startArray()
-}
-
-// startArray reserves the array's length and sets the index to where the length begins
-func (a *ArrayBuilder) startArray() *ArrayBuilder {
-	var index int32
-	index, a.arr = AppendArrayStart(a.arr)
-	a.indexes = append(a.indexes, index)
-	a.keys = append(a.keys, 0)
-	return a
-}
-
-// Build updates the length of the array and index to the beginning of the documents length
-// bytes, then returns the array (bson bytes)
-func (a *ArrayBuilder) Build() Array {
-	lastIndex := len(a.indexes) - 1
-	lastKey := len(a.keys) - 1
-	a.arr, _ = AppendArrayEnd(a.arr, a.indexes[lastIndex])
-	a.indexes = a.indexes[:lastIndex]
-	a.keys = a.keys[:lastKey]
-	return a.arr
-}
-
-// incrementKey() increments the value keys and returns the key to be used to a.appendArray* functions
-func (a *ArrayBuilder) incrementKey() string {
-	idx := len(a.keys) - 1
-	key := strconv.Itoa(a.keys[idx])
-	a.keys[idx]++
-	return key
-}
-
-// AppendInt32 will append i32 to ArrayBuilder.arr
-func (a *ArrayBuilder) AppendInt32(i32 int32) *ArrayBuilder {
-	a.arr = AppendInt32Element(a.arr, a.incrementKey(), i32)
-	return a
-}
-
-// AppendDocument will append doc to ArrayBuilder.arr
-func (a *ArrayBuilder) AppendDocument(doc []byte) *ArrayBuilder {
-	a.arr = AppendDocumentElement(a.arr, a.incrementKey(), doc)
-	return a
-}
-
-// AppendArray will append arr to ArrayBuilder.arr
-func (a *ArrayBuilder) AppendArray(arr []byte) *ArrayBuilder {
-	a.arr = AppendArrayElement(a.arr, a.incrementKey(), arr)
-	return a
-}
-
-// AppendDouble will append f to ArrayBuilder.doc
-func (a *ArrayBuilder) AppendDouble(f float64) *ArrayBuilder {
-	a.arr = AppendDoubleElement(a.arr, a.incrementKey(), f)
-	return a
-}
-
-// AppendString will append str to ArrayBuilder.doc
-func (a *ArrayBuilder) AppendString(str string) *ArrayBuilder {
-	a.arr = AppendStringElement(a.arr, a.incrementKey(), str)
-	return a
-}
-
-// AppendObjectID will append oid to ArrayBuilder.doc
-func (a *ArrayBuilder) AppendObjectID(oid objectID) *ArrayBuilder {
-	a.arr = AppendObjectIDElement(a.arr, a.incrementKey(), oid)
-	return a
-}
-
-// AppendBinary will append a BSON binary element using subtype, and
-// b to a.arr
-func (a *ArrayBuilder) AppendBinary(subtype byte, b []byte) *ArrayBuilder {
-	a.arr = AppendBinaryElement(a.arr, a.incrementKey(), subtype, b)
-	return a
-}
-
-// AppendUndefined will append a BSON undefined element using key to a.arr
-func (a *ArrayBuilder) AppendUndefined() *ArrayBuilder {
-	a.arr = AppendUndefinedElement(a.arr, a.incrementKey())
-	return a
-}
-
-// AppendBoolean will append a boolean element using b to a.arr
-func (a *ArrayBuilder) AppendBoolean(b bool) *ArrayBuilder {
-	a.arr = AppendBooleanElement(a.arr, a.incrementKey(), b)
-	return a
-}
-
-// AppendDateTime will append datetime element dt to a.arr
-func (a *ArrayBuilder) AppendDateTime(dt int64) *ArrayBuilder {
-	a.arr = AppendDateTimeElement(a.arr, a.incrementKey(), dt)
-	return a
-}
-
-// AppendNull will append a null element to a.arr
-func (a *ArrayBuilder) AppendNull() *ArrayBuilder {
-	a.arr = AppendNullElement(a.arr, a.incrementKey())
-	return a
-}
-
-// AppendRegex will append pattern and options to a.arr
-func (a *ArrayBuilder) AppendRegex(pattern, options string) *ArrayBuilder {
-	a.arr = AppendRegexElement(a.arr, a.incrementKey(), pattern, options)
-	return a
-}
-
-// AppendDBPointer will append ns and oid to a.arr
-func (a *ArrayBuilder) AppendDBPointer(ns string, oid objectID) *ArrayBuilder {
-	a.arr = AppendDBPointerElement(a.arr, a.incrementKey(), ns, oid)
-	return a
-}
-
-// AppendJavaScript will append js to a.arr
-func (a *ArrayBuilder) AppendJavaScript(js string) *ArrayBuilder {
-	a.arr = AppendJavaScriptElement(a.arr, a.incrementKey(), js)
-	return a
-}
-
-// AppendSymbol will append symbol to a.arr
-func (a *ArrayBuilder) AppendSymbol(symbol string) *ArrayBuilder {
-	a.arr = AppendSymbolElement(a.arr, a.incrementKey(), symbol)
-	return a
-}
-
-// AppendCodeWithScope will append code and scope to a.arr
-func (a *ArrayBuilder) AppendCodeWithScope(code string, scope Document) *ArrayBuilder {
-	a.arr = AppendCodeWithScopeElement(a.arr, a.incrementKey(), code, scope)
-	return a
-}
-
-// AppendTimestamp will append t and i to a.arr
-func (a *ArrayBuilder) AppendTimestamp(t, i uint32) *ArrayBuilder {
-	a.arr = AppendTimestampElement(a.arr, a.incrementKey(), t, i)
-	return a
-}
-
-// AppendInt64 will append i64 to a.arr
-func (a *ArrayBuilder) AppendInt64(i64 int64) *ArrayBuilder {
-	a.arr = AppendInt64Element(a.arr, a.incrementKey(), i64)
-	return a
-}
-
-// AppendDecimal128 will append d128 to a.arr
-func (a *ArrayBuilder) AppendDecimal128(high, low uint64) *ArrayBuilder {
-	a.arr = AppendDecimal128Element(a.arr, a.incrementKey(), high, low)
-	return a
-}
-
-// AppendMaxKey will append a max key element to a.arr
-func (a *ArrayBuilder) AppendMaxKey() *ArrayBuilder {
-	a.arr = AppendMaxKeyElement(a.arr, a.incrementKey())
-	return a
-}
-
-// AppendMinKey will append a min key element to a.arr
-func (a *ArrayBuilder) AppendMinKey() *ArrayBuilder {
-	a.arr = AppendMinKeyElement(a.arr, a.incrementKey())
-	return a
-}
-
-// AppendValue appends a BSON value to the array.
-func (a *ArrayBuilder) AppendValue(val Value) *ArrayBuilder {
-	a.arr = AppendValueElement(a.arr, a.incrementKey(), val)
-	return a
-}
-
-// StartArray starts building an inline Array. After this document is completed,
-// the user must call a.FinishArray
-func (a *ArrayBuilder) StartArray() *ArrayBuilder {
-	a.arr = AppendHeader(a.arr, TypeArray, a.incrementKey())
-	a.startArray()
-	return a
-}
-
-// FinishArray builds the most recent array created
-func (a *ArrayBuilder) FinishArray() *ArrayBuilder {
-	a.arr = a.Build()
-	return a
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bson_documentbuilder.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bson_documentbuilder.go
deleted file mode 100644
index 931fc6bf..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bson_documentbuilder.go
+++ /dev/null
@@ -1,184 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bsoncore
-
-// DocumentBuilder builds a bson document
-type DocumentBuilder struct {
-	doc     []byte
-	indexes []int32
-}
-
-// startDocument reserves the document's length and set the index to where the length begins
-func (db *DocumentBuilder) startDocument() *DocumentBuilder {
-	var index int32
-	index, db.doc = AppendDocumentStart(db.doc)
-	db.indexes = append(db.indexes, index)
-	return db
-}
-
-// NewDocumentBuilder creates a new DocumentBuilder
-func NewDocumentBuilder() *DocumentBuilder {
-	return (&DocumentBuilder{}).startDocument()
-}
-
-// Build updates the length of the document and index to the beginning of the documents length
-// bytes, then returns the document (bson bytes)
-func (db *DocumentBuilder) Build() Document {
-	last := len(db.indexes) - 1
-	db.doc, _ = AppendDocumentEnd(db.doc, db.indexes[last])
-	db.indexes = db.indexes[:last]
-	return db.doc
-}
-
-// AppendInt32 will append an int32 element using key and i32 to DocumentBuilder.doc
-func (db *DocumentBuilder) AppendInt32(key string, i32 int32) *DocumentBuilder {
-	db.doc = AppendInt32Element(db.doc, key, i32)
-	return db
-}
-
-// AppendDocument will append a bson embedded document element using key
-// and doc to DocumentBuilder.doc
-func (db *DocumentBuilder) AppendDocument(key string, doc []byte) *DocumentBuilder {
-	db.doc = AppendDocumentElement(db.doc, key, doc)
-	return db
-}
-
-// AppendArray will append a bson array using key and arr to DocumentBuilder.doc
-func (db *DocumentBuilder) AppendArray(key string, arr []byte) *DocumentBuilder {
-	db.doc = AppendHeader(db.doc, TypeArray, key)
-	db.doc = AppendArray(db.doc, arr)
-	return db
-}
-
-// AppendDouble will append a double element using key and f to DocumentBuilder.doc
-func (db *DocumentBuilder) AppendDouble(key string, f float64) *DocumentBuilder {
-	db.doc = AppendDoubleElement(db.doc, key, f)
-	return db
-}
-
-// AppendString will append str to DocumentBuilder.doc with the given key
-func (db *DocumentBuilder) AppendString(key string, str string) *DocumentBuilder {
-	db.doc = AppendStringElement(db.doc, key, str)
-	return db
-}
-
-// AppendObjectID will append oid to DocumentBuilder.doc with the given key
-func (db *DocumentBuilder) AppendObjectID(key string, oid objectID) *DocumentBuilder {
-	db.doc = AppendObjectIDElement(db.doc, key, oid)
-	return db
-}
-
-// AppendBinary will append a BSON binary element using key, subtype, and
-// b to db.doc
-func (db *DocumentBuilder) AppendBinary(key string, subtype byte, b []byte) *DocumentBuilder {
-	db.doc = AppendBinaryElement(db.doc, key, subtype, b)
-	return db
-}
-
-// AppendUndefined will append a BSON undefined element using key to db.doc
-func (db *DocumentBuilder) AppendUndefined(key string) *DocumentBuilder {
-	db.doc = AppendUndefinedElement(db.doc, key)
-	return db
-}
-
-// AppendBoolean will append a boolean element using key and b to db.doc
-func (db *DocumentBuilder) AppendBoolean(key string, b bool) *DocumentBuilder {
-	db.doc = AppendBooleanElement(db.doc, key, b)
-	return db
-}
-
-// AppendDateTime will append a datetime element using key and dt to db.doc
-func (db *DocumentBuilder) AppendDateTime(key string, dt int64) *DocumentBuilder {
-	db.doc = AppendDateTimeElement(db.doc, key, dt)
-	return db
-}
-
-// AppendNull will append a null element using key to db.doc
-func (db *DocumentBuilder) AppendNull(key string) *DocumentBuilder {
-	db.doc = AppendNullElement(db.doc, key)
-	return db
-}
-
-// AppendRegex will append pattern and options using key to db.doc
-func (db *DocumentBuilder) AppendRegex(key, pattern, options string) *DocumentBuilder {
-	db.doc = AppendRegexElement(db.doc, key, pattern, options)
-	return db
-}
-
-// AppendDBPointer will append ns and oid to using key to db.doc
-func (db *DocumentBuilder) AppendDBPointer(key string, ns string, oid objectID) *DocumentBuilder {
-	db.doc = AppendDBPointerElement(db.doc, key, ns, oid)
-	return db
-}
-
-// AppendJavaScript will append js using the provided key to db.doc
-func (db *DocumentBuilder) AppendJavaScript(key, js string) *DocumentBuilder {
-	db.doc = AppendJavaScriptElement(db.doc, key, js)
-	return db
-}
-
-// AppendSymbol will append a BSON symbol element using key and symbol db.doc
-func (db *DocumentBuilder) AppendSymbol(key, symbol string) *DocumentBuilder {
-	db.doc = AppendSymbolElement(db.doc, key, symbol)
-	return db
-}
-
-// AppendCodeWithScope will append code and scope using key to db.doc
-func (db *DocumentBuilder) AppendCodeWithScope(key string, code string, scope Document) *DocumentBuilder {
-	db.doc = AppendCodeWithScopeElement(db.doc, key, code, scope)
-	return db
-}
-
-// AppendTimestamp will append t and i to db.doc using provided key
-func (db *DocumentBuilder) AppendTimestamp(key string, t, i uint32) *DocumentBuilder {
-	db.doc = AppendTimestampElement(db.doc, key, t, i)
-	return db
-}
-
-// AppendInt64 will append i64 to dst using key to db.doc
-func (db *DocumentBuilder) AppendInt64(key string, i64 int64) *DocumentBuilder {
-	db.doc = AppendInt64Element(db.doc, key, i64)
-	return db
-}
-
-// AppendDecimal128 will append d128 to db.doc using provided key
-func (db *DocumentBuilder) AppendDecimal128(key string, high, low uint64) *DocumentBuilder {
-	db.doc = AppendDecimal128Element(db.doc, key, high, low)
-	return db
-}
-
-// AppendMaxKey will append a max key element using key to db.doc
-func (db *DocumentBuilder) AppendMaxKey(key string) *DocumentBuilder {
-	db.doc = AppendMaxKeyElement(db.doc, key)
-	return db
-}
-
-// AppendMinKey will append a min key element using key to db.doc
-func (db *DocumentBuilder) AppendMinKey(key string) *DocumentBuilder {
-	db.doc = AppendMinKeyElement(db.doc, key)
-	return db
-}
-
-// AppendValue will append a BSON element with the provided key and value to the document.
-func (db *DocumentBuilder) AppendValue(key string, val Value) *DocumentBuilder {
-	db.doc = AppendValueElement(db.doc, key, val)
-	return db
-}
-
-// StartDocument starts building an inline document element with the provided key
-// After this document is completed, the user must call finishDocument
-func (db *DocumentBuilder) StartDocument(key string) *DocumentBuilder {
-	db.doc = AppendHeader(db.doc, TypeEmbeddedDocument, key)
-	db = db.startDocument()
-	return db
-}
-
-// FinishDocument builds the most recent document created
-func (db *DocumentBuilder) FinishDocument() *DocumentBuilder {
-	db.doc = db.Build()
-	return db
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bsoncore.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bsoncore.go
deleted file mode 100644
index 13219ee5..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/bsoncore.go
+++ /dev/null
@@ -1,842 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bsoncore
-
-import (
-	"bytes"
-	"encoding/binary"
-	"fmt"
-	"math"
-	"strconv"
-	"strings"
-	"time"
-)
-
-const (
-	// EmptyDocumentLength is the length of a document that has been started/ended but has no elements.
-	EmptyDocumentLength = 5
-	// nullTerminator is a string version of the 0 byte that is appended at the end of cstrings.
-	nullTerminator       = string(byte(0))
-	invalidKeyPanicMsg   = "BSON element keys cannot contain null bytes"
-	invalidRegexPanicMsg = "BSON regex values cannot contain null bytes"
-)
-
-type objectID = [12]byte
-
-// AppendType will append t to dst and return the extended buffer.
-func AppendType(dst []byte, t Type) []byte { return append(dst, byte(t)) }
-
-// AppendKey will append key to dst and return the extended buffer.
-func AppendKey(dst []byte, key string) []byte { return append(dst, key+nullTerminator...) }
-
-// AppendHeader will append Type t and key to dst and return the extended
-// buffer.
-func AppendHeader(dst []byte, t Type, key string) []byte {
-	if !isValidCString(key) {
-		panic(invalidKeyPanicMsg)
-	}
-
-	dst = AppendType(dst, t)
-	dst = append(dst, key...)
-	return append(dst, 0x00)
-	// return append(AppendType(dst, t), key+string(0x00)...)
-}
-
-// TODO(skriptble): All of the Read* functions should return src resliced to start just after what was read.
-
-// ReadType will return the first byte of the provided []byte as a type. If
-// there is no available byte, false is returned.
-func ReadType(src []byte) (Type, []byte, bool) {
-	if len(src) < 1 {
-		return 0, src, false
-	}
-	return Type(src[0]), src[1:], true
-}
-
-// ReadKey will read a key from src. The 0x00 byte will not be present
-// in the returned string. If there are not enough bytes available, false is
-// returned.
-func ReadKey(src []byte) (string, []byte, bool) { return readcstring(src) }
-
-// ReadKeyBytes will read a key from src as bytes. The 0x00 byte will
-// not be present in the returned string. If there are not enough bytes
-// available, false is returned.
-func ReadKeyBytes(src []byte) ([]byte, []byte, bool) { return readcstringbytes(src) }
-
-// ReadHeader will read a type byte and a key from src. If both of these
-// values cannot be read, false is returned.
-func ReadHeader(src []byte) (t Type, key string, rem []byte, ok bool) {
-	t, rem, ok = ReadType(src)
-	if !ok {
-		return 0, "", src, false
-	}
-	key, rem, ok = ReadKey(rem)
-	if !ok {
-		return 0, "", src, false
-	}
-
-	return t, key, rem, true
-}
-
-// ReadHeaderBytes will read a type and a key from src and the remainder of the bytes
-// are returned as rem. If either the type or key cannot be red, ok will be false.
-func ReadHeaderBytes(src []byte) (header []byte, rem []byte, ok bool) {
-	if len(src) < 1 {
-		return nil, src, false
-	}
-	idx := bytes.IndexByte(src[1:], 0x00)
-	if idx == -1 {
-		return nil, src, false
-	}
-	return src[:idx], src[idx+1:], true
-}
-
-// ReadElement reads the next full element from src. It returns the element, the remaining bytes in
-// the slice, and a boolean indicating if the read was successful.
-func ReadElement(src []byte) (Element, []byte, bool) {
-	if len(src) < 1 {
-		return nil, src, false
-	}
-	t := Type(src[0])
-	idx := 1
-	for idx < len(src) && src[idx] != 0x00 {
-		idx++
-	}
-	if idx >= len(src) {
-		return nil, src, false
-	}
-	idx++ // Move past the null byte
-	length, ok := valueLength(src[idx:], t)
-	if !ok {
-		return nil, src, false
-	}
-	elemLength := idx + int(length)
-	if elemLength > len(src) {
-		return nil, src, false
-	}
-	return src[:elemLength], src[elemLength:], true
-}
-
-// AppendValueElement appends value to dst as an element using key as the element's key.
-func AppendValueElement(dst []byte, key string, value Value) []byte {
-	dst = AppendHeader(dst, value.Type, key)
-	dst = append(dst, value.Data...)
-	return dst
-}
-
-// ReadValue reads the next value as the provided types and returns a Value, the remaining bytes,
-// and a boolean indicating if the read was successful.
-func ReadValue(src []byte, t Type) (Value, []byte, bool) {
-	data, rem, ok := readValue(src, t)
-	if !ok {
-		return Value{}, src, false
-	}
-	return Value{Type: t, Data: data}, rem, true
-}
-
-// AppendDouble will append f to dst and return the extended buffer.
-func AppendDouble(dst []byte, f float64) []byte {
-	return appendu64(dst, math.Float64bits(f))
-}
-
-// AppendDoubleElement will append a BSON double element using key and f to dst
-// and return the extended buffer.
-func AppendDoubleElement(dst []byte, key string, f float64) []byte {
-	return AppendDouble(AppendHeader(dst, TypeDouble, key), f)
-}
-
-// ReadDouble will read a float64 from src. If there are not enough bytes it
-// will return false.
-func ReadDouble(src []byte) (float64, []byte, bool) {
-	bits, src, ok := readu64(src)
-	if !ok {
-		return 0, src, false
-	}
-	return math.Float64frombits(bits), src, true
-}
-
-// AppendString will append s to dst and return the extended buffer.
-func AppendString(dst []byte, s string) []byte {
-	return appendstring(dst, s)
-}
-
-// AppendStringElement will append a BSON string element using key and val to dst
-// and return the extended buffer.
-func AppendStringElement(dst []byte, key, val string) []byte {
-	return AppendString(AppendHeader(dst, TypeString, key), val)
-}
-
-// ReadString will read a string from src. If there are not enough bytes it
-// will return false.
-func ReadString(src []byte) (string, []byte, bool) {
-	return readstring(src)
-}
-
-// AppendDocumentStart reserves a document's length and returns the index where the length begins.
-// This index can later be used to write the length of the document.
-func AppendDocumentStart(dst []byte) (index int32, b []byte) {
-	// TODO(skriptble): We really need AppendDocumentStart and AppendDocumentEnd.  AppendDocumentStart would handle calling
-	// TODO ReserveLength and providing the index of the start of the document. AppendDocumentEnd would handle taking that
-	// TODO start index, adding the null byte, calculating the length, and filling in the length at the start of the
-	// TODO document.
-	return ReserveLength(dst)
-}
-
-// AppendDocumentStartInline functions the same as AppendDocumentStart but takes a pointer to the
-// index int32 which allows this function to be used inline.
-func AppendDocumentStartInline(dst []byte, index *int32) []byte {
-	idx, doc := AppendDocumentStart(dst)
-	*index = idx
-	return doc
-}
-
-// AppendDocumentElementStart writes a document element header and then reserves the length bytes.
-func AppendDocumentElementStart(dst []byte, key string) (index int32, b []byte) {
-	return AppendDocumentStart(AppendHeader(dst, TypeEmbeddedDocument, key))
-}
-
-// AppendDocumentEnd writes the null byte for a document and updates the length of the document.
-// The index should be the beginning of the document's length bytes.
-func AppendDocumentEnd(dst []byte, index int32) ([]byte, error) {
-	if int(index) > len(dst)-4 {
-		return dst, fmt.Errorf("not enough bytes available after index to write length")
-	}
-	dst = append(dst, 0x00)
-	dst = UpdateLength(dst, index, int32(len(dst[index:])))
-	return dst, nil
-}
-
-// AppendDocument will append doc to dst and return the extended buffer.
-func AppendDocument(dst []byte, doc []byte) []byte { return append(dst, doc...) }
-
-// AppendDocumentElement will append a BSON embedded document element using key
-// and doc to dst and return the extended buffer.
-func AppendDocumentElement(dst []byte, key string, doc []byte) []byte {
-	return AppendDocument(AppendHeader(dst, TypeEmbeddedDocument, key), doc)
-}
-
-// BuildDocument will create a document with the given slice of elements and will append
-// it to dst and return the extended buffer.
-func BuildDocument(dst []byte, elems ...[]byte) []byte {
-	idx, dst := ReserveLength(dst)
-	for _, elem := range elems {
-		dst = append(dst, elem...)
-	}
-	dst = append(dst, 0x00)
-	dst = UpdateLength(dst, idx, int32(len(dst[idx:])))
-	return dst
-}
-
-// BuildDocumentValue creates an Embedded Document value from the given elements.
-func BuildDocumentValue(elems ...[]byte) Value {
-	return Value{Type: TypeEmbeddedDocument, Data: BuildDocument(nil, elems...)}
-}
-
-// BuildDocumentElement will append a BSON embedded document element using key and the provided
-// elements and return the extended buffer.
-func BuildDocumentElement(dst []byte, key string, elems ...[]byte) []byte {
-	return BuildDocument(AppendHeader(dst, TypeEmbeddedDocument, key), elems...)
-}
-
-// BuildDocumentFromElements is an alaias for the BuildDocument function.
-var BuildDocumentFromElements = BuildDocument
-
-// ReadDocument will read a document from src. If there are not enough bytes it
-// will return false.
-func ReadDocument(src []byte) (doc Document, rem []byte, ok bool) { return readLengthBytes(src) }
-
-// AppendArrayStart appends the length bytes to an array and then returns the index of the start
-// of those length bytes.
-func AppendArrayStart(dst []byte) (index int32, b []byte) { return ReserveLength(dst) }
-
-// AppendArrayElementStart appends an array element header and then the length bytes for an array,
-// returning the index where the length starts.
-func AppendArrayElementStart(dst []byte, key string) (index int32, b []byte) {
-	return AppendArrayStart(AppendHeader(dst, TypeArray, key))
-}
-
-// AppendArrayEnd appends the null byte to an array and calculates the length, inserting that
-// calculated length starting at index.
-func AppendArrayEnd(dst []byte, index int32) ([]byte, error) { return AppendDocumentEnd(dst, index) }
-
-// AppendArray will append arr to dst and return the extended buffer.
-func AppendArray(dst []byte, arr []byte) []byte { return append(dst, arr...) }
-
-// AppendArrayElement will append a BSON array element using key and arr to dst
-// and return the extended buffer.
-func AppendArrayElement(dst []byte, key string, arr []byte) []byte {
-	return AppendArray(AppendHeader(dst, TypeArray, key), arr)
-}
-
-// BuildArray will append a BSON array to dst built from values.
-func BuildArray(dst []byte, values ...Value) []byte {
-	idx, dst := ReserveLength(dst)
-	for pos, val := range values {
-		dst = AppendValueElement(dst, strconv.Itoa(pos), val)
-	}
-	dst = append(dst, 0x00)
-	dst = UpdateLength(dst, idx, int32(len(dst[idx:])))
-	return dst
-}
-
-// BuildArrayElement will create an array element using the provided values.
-func BuildArrayElement(dst []byte, key string, values ...Value) []byte {
-	return BuildArray(AppendHeader(dst, TypeArray, key), values...)
-}
-
-// ReadArray will read an array from src. If there are not enough bytes it
-// will return false.
-func ReadArray(src []byte) (arr Array, rem []byte, ok bool) { return readLengthBytes(src) }
-
-// AppendBinary will append subtype and b to dst and return the extended buffer.
-func AppendBinary(dst []byte, subtype byte, b []byte) []byte {
-	if subtype == 0x02 {
-		return appendBinarySubtype2(dst, subtype, b)
-	}
-	dst = append(appendLength(dst, int32(len(b))), subtype)
-	return append(dst, b...)
-}
-
-// AppendBinaryElement will append a BSON binary element using key, subtype, and
-// b to dst and return the extended buffer.
-func AppendBinaryElement(dst []byte, key string, subtype byte, b []byte) []byte {
-	return AppendBinary(AppendHeader(dst, TypeBinary, key), subtype, b)
-}
-
-// ReadBinary will read a subtype and bin from src. If there are not enough bytes it
-// will return false.
-func ReadBinary(src []byte) (subtype byte, bin []byte, rem []byte, ok bool) {
-	length, rem, ok := ReadLength(src)
-	if !ok {
-		return 0x00, nil, src, false
-	}
-	if len(rem) < 1 { // subtype
-		return 0x00, nil, src, false
-	}
-	subtype, rem = rem[0], rem[1:]
-
-	if len(rem) < int(length) {
-		return 0x00, nil, src, false
-	}
-
-	if subtype == 0x02 {
-		length, rem, ok = ReadLength(rem)
-		if !ok || len(rem) < int(length) {
-			return 0x00, nil, src, false
-		}
-	}
-
-	return subtype, rem[:length], rem[length:], true
-}
-
-// AppendUndefinedElement will append a BSON undefined element using key to dst
-// and return the extended buffer.
-func AppendUndefinedElement(dst []byte, key string) []byte {
-	return AppendHeader(dst, TypeUndefined, key)
-}
-
-// AppendObjectID will append oid to dst and return the extended buffer.
-func AppendObjectID(dst []byte, oid objectID) []byte { return append(dst, oid[:]...) }
-
-// AppendObjectIDElement will append a BSON ObjectID element using key and oid to dst
-// and return the extended buffer.
-func AppendObjectIDElement(dst []byte, key string, oid objectID) []byte {
-	return AppendObjectID(AppendHeader(dst, TypeObjectID, key), oid)
-}
-
-// ReadObjectID will read an ObjectID from src. If there are not enough bytes it
-// will return false.
-func ReadObjectID(src []byte) (objectID, []byte, bool) {
-	var oid objectID
-	idLen := cap(oid)
-	if len(src) < idLen {
-		return oid, src, false
-	}
-	copy(oid[:], src[0:idLen])
-	return oid, src[idLen:], true
-}
-
-// AppendBoolean will append b to dst and return the extended buffer.
-func AppendBoolean(dst []byte, b bool) []byte {
-	if b {
-		return append(dst, 0x01)
-	}
-	return append(dst, 0x00)
-}
-
-// AppendBooleanElement will append a BSON boolean element using key and b to dst
-// and return the extended buffer.
-func AppendBooleanElement(dst []byte, key string, b bool) []byte {
-	return AppendBoolean(AppendHeader(dst, TypeBoolean, key), b)
-}
-
-// ReadBoolean will read a bool from src. If there are not enough bytes it
-// will return false.
-func ReadBoolean(src []byte) (bool, []byte, bool) {
-	if len(src) < 1 {
-		return false, src, false
-	}
-
-	return src[0] == 0x01, src[1:], true
-}
-
-// AppendDateTime will append dt to dst and return the extended buffer.
-func AppendDateTime(dst []byte, dt int64) []byte { return appendi64(dst, dt) }
-
-// AppendDateTimeElement will append a BSON datetime element using key and dt to dst
-// and return the extended buffer.
-func AppendDateTimeElement(dst []byte, key string, dt int64) []byte {
-	return AppendDateTime(AppendHeader(dst, TypeDateTime, key), dt)
-}
-
-// ReadDateTime will read an int64 datetime from src. If there are not enough bytes it
-// will return false.
-func ReadDateTime(src []byte) (int64, []byte, bool) { return readi64(src) }
-
-// AppendTime will append time as a BSON DateTime to dst and return the extended buffer.
-func AppendTime(dst []byte, t time.Time) []byte {
-	return AppendDateTime(dst, t.Unix()*1000+int64(t.Nanosecond()/1e6))
-}
-
-// AppendTimeElement will append a BSON datetime element using key and dt to dst
-// and return the extended buffer.
-func AppendTimeElement(dst []byte, key string, t time.Time) []byte {
-	return AppendTime(AppendHeader(dst, TypeDateTime, key), t)
-}
-
-// ReadTime will read an time.Time datetime from src. If there are not enough bytes it
-// will return false.
-func ReadTime(src []byte) (time.Time, []byte, bool) {
-	dt, rem, ok := readi64(src)
-	return time.Unix(dt/1e3, dt%1e3*1e6), rem, ok
-}
-
-// AppendNullElement will append a BSON null element using key to dst
-// and return the extended buffer.
-func AppendNullElement(dst []byte, key string) []byte { return AppendHeader(dst, TypeNull, key) }
-
-// AppendRegex will append pattern and options to dst and return the extended buffer.
-func AppendRegex(dst []byte, pattern, options string) []byte {
-	if !isValidCString(pattern) || !isValidCString(options) {
-		panic(invalidRegexPanicMsg)
-	}
-
-	return append(dst, pattern+nullTerminator+options+nullTerminator...)
-}
-
-// AppendRegexElement will append a BSON regex element using key, pattern, and
-// options to dst and return the extended buffer.
-func AppendRegexElement(dst []byte, key, pattern, options string) []byte {
-	return AppendRegex(AppendHeader(dst, TypeRegex, key), pattern, options)
-}
-
-// ReadRegex will read a pattern and options from src. If there are not enough bytes it
-// will return false.
-func ReadRegex(src []byte) (pattern, options string, rem []byte, ok bool) {
-	pattern, rem, ok = readcstring(src)
-	if !ok {
-		return "", "", src, false
-	}
-	options, rem, ok = readcstring(rem)
-	if !ok {
-		return "", "", src, false
-	}
-	return pattern, options, rem, true
-}
-
-// AppendDBPointer will append ns and oid to dst and return the extended buffer.
-func AppendDBPointer(dst []byte, ns string, oid objectID) []byte {
-	return append(appendstring(dst, ns), oid[:]...)
-}
-
-// AppendDBPointerElement will append a BSON DBPointer element using key, ns,
-// and oid to dst and return the extended buffer.
-func AppendDBPointerElement(dst []byte, key, ns string, oid objectID) []byte {
-	return AppendDBPointer(AppendHeader(dst, TypeDBPointer, key), ns, oid)
-}
-
-// ReadDBPointer will read a ns and oid from src. If there are not enough bytes it
-// will return false.
-func ReadDBPointer(src []byte) (ns string, oid objectID, rem []byte, ok bool) {
-	ns, rem, ok = readstring(src)
-	if !ok {
-		return "", objectID{}, src, false
-	}
-	oid, rem, ok = ReadObjectID(rem)
-	if !ok {
-		return "", objectID{}, src, false
-	}
-	return ns, oid, rem, true
-}
-
-// AppendJavaScript will append js to dst and return the extended buffer.
-func AppendJavaScript(dst []byte, js string) []byte { return appendstring(dst, js) }
-
-// AppendJavaScriptElement will append a BSON JavaScript element using key and
-// js to dst and return the extended buffer.
-func AppendJavaScriptElement(dst []byte, key, js string) []byte {
-	return AppendJavaScript(AppendHeader(dst, TypeJavaScript, key), js)
-}
-
-// ReadJavaScript will read a js string from src. If there are not enough bytes it
-// will return false.
-func ReadJavaScript(src []byte) (js string, rem []byte, ok bool) { return readstring(src) }
-
-// AppendSymbol will append symbol to dst and return the extended buffer.
-func AppendSymbol(dst []byte, symbol string) []byte { return appendstring(dst, symbol) }
-
-// AppendSymbolElement will append a BSON symbol element using key and symbol to dst
-// and return the extended buffer.
-func AppendSymbolElement(dst []byte, key, symbol string) []byte {
-	return AppendSymbol(AppendHeader(dst, TypeSymbol, key), symbol)
-}
-
-// ReadSymbol will read a symbol string from src. If there are not enough bytes it
-// will return false.
-func ReadSymbol(src []byte) (symbol string, rem []byte, ok bool) { return readstring(src) }
-
-// AppendCodeWithScope will append code and scope to dst and return the extended buffer.
-func AppendCodeWithScope(dst []byte, code string, scope []byte) []byte {
-	length := int32(4 + 4 + len(code) + 1 + len(scope)) // length of cws, length of code, code, 0x00, scope
-	dst = appendLength(dst, length)
-
-	return append(appendstring(dst, code), scope...)
-}
-
-// AppendCodeWithScopeElement will append a BSON code with scope element using
-// key, code, and scope to dst
-// and return the extended buffer.
-func AppendCodeWithScopeElement(dst []byte, key, code string, scope []byte) []byte {
-	return AppendCodeWithScope(AppendHeader(dst, TypeCodeWithScope, key), code, scope)
-}
-
-// ReadCodeWithScope will read code and scope from src. If there are not enough bytes it
-// will return false.
-func ReadCodeWithScope(src []byte) (code string, scope []byte, rem []byte, ok bool) {
-	length, rem, ok := ReadLength(src)
-	if !ok || len(src) < int(length) {
-		return "", nil, src, false
-	}
-
-	code, rem, ok = readstring(rem)
-	if !ok {
-		return "", nil, src, false
-	}
-
-	scope, rem, ok = ReadDocument(rem)
-	if !ok {
-		return "", nil, src, false
-	}
-	return code, scope, rem, true
-}
-
-// AppendInt32 will append i32 to dst and return the extended buffer.
-func AppendInt32(dst []byte, i32 int32) []byte { return appendi32(dst, i32) }
-
-// AppendInt32Element will append a BSON int32 element using key and i32 to dst
-// and return the extended buffer.
-func AppendInt32Element(dst []byte, key string, i32 int32) []byte {
-	return AppendInt32(AppendHeader(dst, TypeInt32, key), i32)
-}
-
-// ReadInt32 will read an int32 from src. If there are not enough bytes it
-// will return false.
-func ReadInt32(src []byte) (int32, []byte, bool) { return readi32(src) }
-
-// AppendTimestamp will append t and i to dst and return the extended buffer.
-func AppendTimestamp(dst []byte, t, i uint32) []byte {
-	return appendu32(appendu32(dst, i), t) // i is the lower 4 bytes, t is the higher 4 bytes
-}
-
-// AppendTimestampElement will append a BSON timestamp element using key, t, and
-// i to dst and return the extended buffer.
-func AppendTimestampElement(dst []byte, key string, t, i uint32) []byte {
-	return AppendTimestamp(AppendHeader(dst, TypeTimestamp, key), t, i)
-}
-
-// ReadTimestamp will read t and i from src. If there are not enough bytes it
-// will return false.
-func ReadTimestamp(src []byte) (t, i uint32, rem []byte, ok bool) {
-	i, rem, ok = readu32(src)
-	if !ok {
-		return 0, 0, src, false
-	}
-	t, rem, ok = readu32(rem)
-	if !ok {
-		return 0, 0, src, false
-	}
-	return t, i, rem, true
-}
-
-// AppendInt64 will append i64 to dst and return the extended buffer.
-func AppendInt64(dst []byte, i64 int64) []byte { return appendi64(dst, i64) }
-
-// AppendInt64Element will append a BSON int64 element using key and i64 to dst
-// and return the extended buffer.
-func AppendInt64Element(dst []byte, key string, i64 int64) []byte {
-	return AppendInt64(AppendHeader(dst, TypeInt64, key), i64)
-}
-
-// ReadInt64 will read an int64 from src. If there are not enough bytes it
-// will return false.
-func ReadInt64(src []byte) (int64, []byte, bool) { return readi64(src) }
-
-// AppendDecimal128 will append high and low parts of a d128 to dst and return the extended buffer.
-func AppendDecimal128(dst []byte, high, low uint64) []byte {
-	return appendu64(appendu64(dst, low), high)
-}
-
-// AppendDecimal128Element will append high and low parts of a BSON bson.Decimal128 element using key and
-// d128 to dst and return the extended buffer.
-func AppendDecimal128Element(dst []byte, key string, high, low uint64) []byte {
-	return AppendDecimal128(AppendHeader(dst, TypeDecimal128, key), high, low)
-}
-
-// ReadDecimal128 will read high and low parts of a bson.Decimal128 from src. If there are not enough bytes it
-// will return false.
-func ReadDecimal128(src []byte) (high uint64, low uint64, rem []byte, ok bool) {
-	low, rem, ok = readu64(src)
-	if !ok {
-		return 0, 0, src, false
-	}
-
-	high, rem, ok = readu64(rem)
-	if !ok {
-		return 0, 0, src, false
-	}
-
-	return high, low, rem, true
-}
-
-// AppendMaxKeyElement will append a BSON max key element using key to dst
-// and return the extended buffer.
-func AppendMaxKeyElement(dst []byte, key string) []byte {
-	return AppendHeader(dst, TypeMaxKey, key)
-}
-
-// AppendMinKeyElement will append a BSON min key element using key to dst
-// and return the extended buffer.
-func AppendMinKeyElement(dst []byte, key string) []byte {
-	return AppendHeader(dst, TypeMinKey, key)
-}
-
-// EqualValue will return true if the two values are equal.
-func EqualValue(t1, t2 Type, v1, v2 []byte) bool {
-	if t1 != t2 {
-		return false
-	}
-	v1, _, ok := readValue(v1, t1)
-	if !ok {
-		return false
-	}
-	v2, _, ok = readValue(v2, t2)
-	if !ok {
-		return false
-	}
-	return bytes.Equal(v1, v2)
-}
-
-// valueLength will determine the length of the next value contained in src as if it
-// is type t. The returned bool will be false if there are not enough bytes in src for
-// a value of type t.
-func valueLength(src []byte, t Type) (int32, bool) {
-	var length int32
-	ok := true
-	switch t {
-	case TypeArray, TypeEmbeddedDocument, TypeCodeWithScope:
-		length, _, ok = ReadLength(src)
-	case TypeBinary:
-		length, _, ok = ReadLength(src)
-		length += 4 + 1 // binary length + subtype byte
-	case TypeBoolean:
-		length = 1
-	case TypeDBPointer:
-		length, _, ok = ReadLength(src)
-		length += 4 + 12 // string length + ObjectID length
-	case TypeDateTime, TypeDouble, TypeInt64, TypeTimestamp:
-		length = 8
-	case TypeDecimal128:
-		length = 16
-	case TypeInt32:
-		length = 4
-	case TypeJavaScript, TypeString, TypeSymbol:
-		length, _, ok = ReadLength(src)
-		length += 4
-	case TypeMaxKey, TypeMinKey, TypeNull, TypeUndefined:
-		length = 0
-	case TypeObjectID:
-		length = 12
-	case TypeRegex:
-		regex := bytes.IndexByte(src, 0x00)
-		if regex < 0 {
-			ok = false
-			break
-		}
-		pattern := bytes.IndexByte(src[regex+1:], 0x00)
-		if pattern < 0 {
-			ok = false
-			break
-		}
-		length = int32(int64(regex) + 1 + int64(pattern) + 1)
-	default:
-		ok = false
-	}
-
-	return length, ok
-}
-
-func readValue(src []byte, t Type) ([]byte, []byte, bool) {
-	length, ok := valueLength(src, t)
-	if !ok || int(length) > len(src) {
-		return nil, src, false
-	}
-
-	return src[:length], src[length:], true
-}
-
-// ReserveLength reserves the space required for length and returns the index where to write the length
-// and the []byte with reserved space.
-func ReserveLength(dst []byte) (int32, []byte) {
-	index := len(dst)
-	return int32(index), append(dst, 0x00, 0x00, 0x00, 0x00)
-}
-
-// UpdateLength updates the length at index with length and returns the []byte.
-func UpdateLength(dst []byte, index, length int32) []byte {
-	binary.LittleEndian.PutUint32(dst[index:], uint32(length))
-	return dst
-}
-
-func appendLength(dst []byte, l int32) []byte { return appendi32(dst, l) }
-
-func appendi32(dst []byte, i32 int32) []byte {
-	b := []byte{0, 0, 0, 0}
-	binary.LittleEndian.PutUint32(b, uint32(i32))
-	return append(dst, b...)
-}
-
-// ReadLength reads an int32 length from src and returns the length and the remaining bytes. If
-// there aren't enough bytes to read a valid length, src is returned unomdified and the returned
-// bool will be false.
-func ReadLength(src []byte) (int32, []byte, bool) {
-	ln, src, ok := readi32(src)
-	if ln < 0 {
-		return ln, src, false
-	}
-	return ln, src, ok
-}
-
-func readi32(src []byte) (int32, []byte, bool) {
-	if len(src) < 4 {
-		return 0, src, false
-	}
-	return int32(binary.LittleEndian.Uint32(src)), src[4:], true
-}
-
-func appendi64(dst []byte, i64 int64) []byte {
-	b := []byte{0, 0, 0, 0, 0, 0, 0, 0}
-	binary.LittleEndian.PutUint64(b, uint64(i64))
-	return append(dst, b...)
-}
-
-func readi64(src []byte) (int64, []byte, bool) {
-	if len(src) < 8 {
-		return 0, src, false
-	}
-	return int64(binary.LittleEndian.Uint64(src)), src[8:], true
-}
-
-func appendu32(dst []byte, u32 uint32) []byte {
-	b := []byte{0, 0, 0, 0}
-	binary.LittleEndian.PutUint32(b, u32)
-	return append(dst, b...)
-}
-
-func readu32(src []byte) (uint32, []byte, bool) {
-	if len(src) < 4 {
-		return 0, src, false
-	}
-
-	return binary.LittleEndian.Uint32(src), src[4:], true
-}
-
-func appendu64(dst []byte, u64 uint64) []byte {
-	b := []byte{0, 0, 0, 0, 0, 0, 0, 0}
-	binary.LittleEndian.PutUint64(b, u64)
-	return append(dst, b...)
-}
-
-func readu64(src []byte) (uint64, []byte, bool) {
-	if len(src) < 8 {
-		return 0, src, false
-	}
-	return binary.LittleEndian.Uint64(src), src[8:], true
-}
-
-// keep in sync with readcstringbytes
-func readcstring(src []byte) (string, []byte, bool) {
-	idx := bytes.IndexByte(src, 0x00)
-	if idx < 0 {
-		return "", src, false
-	}
-	return string(src[:idx]), src[idx+1:], true
-}
-
-// keep in sync with readcstring
-func readcstringbytes(src []byte) ([]byte, []byte, bool) {
-	idx := bytes.IndexByte(src, 0x00)
-	if idx < 0 {
-		return nil, src, false
-	}
-	return src[:idx], src[idx+1:], true
-}
-
-func appendstring(dst []byte, s string) []byte {
-	l := int32(len(s) + 1)
-	dst = appendLength(dst, l)
-	dst = append(dst, s...)
-	return append(dst, 0x00)
-}
-
-func readstring(src []byte) (string, []byte, bool) {
-	l, rem, ok := ReadLength(src)
-	if !ok {
-		return "", src, false
-	}
-	if len(src[4:]) < int(l) || l == 0 {
-		return "", src, false
-	}
-
-	return string(rem[:l-1]), rem[l:], true
-}
-
-// readLengthBytes attempts to read a length and that number of bytes. This
-// function requires that the length include the four bytes for itself.
-func readLengthBytes(src []byte) ([]byte, []byte, bool) {
-	l, _, ok := ReadLength(src)
-	if !ok {
-		return nil, src, false
-	}
-	if l < 4 {
-		return nil, src, false
-	}
-	if len(src) < int(l) {
-		return nil, src, false
-	}
-	return src[:l], src[l:], true
-}
-
-func appendBinarySubtype2(dst []byte, subtype byte, b []byte) []byte {
-	dst = appendLength(dst, int32(len(b)+4)) // The bytes we'll encode need to be 4 larger for the length bytes
-	dst = append(dst, subtype)
-	dst = appendLength(dst, int32(len(b)))
-	return append(dst, b...)
-}
-
-func isValidCString(cs string) bool {
-	return !strings.ContainsRune(cs, '\x00')
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/doc.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/doc.go
deleted file mode 100644
index f68e1da1..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/doc.go
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2022-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-// Package bsoncore is intended for internal use only. It is made available to
-// facilitate use cases that require access to internal MongoDB driver
-// functionality and state. The API of this package is not stable and there is
-// no backward compatibility guarantee.
-//
-// WARNING: THIS PACKAGE IS EXPERIMENTAL AND MAY BE MODIFIED OR REMOVED WITHOUT
-// NOTICE! USE WITH EXTREME CAUTION!
-//
-// Package bsoncore contains functions that can be used to encode and decode
-// BSON elements and values to or from a slice of bytes. These functions are
-// aimed at allowing low level manipulation of BSON and can be used to build a
-// higher level BSON library.
-//
-// The Read* functions within this package return the values of the element and
-// a boolean indicating if the values are valid. A boolean was used instead of
-// an error because any error that would be returned would be the same: not
-// enough bytes. This library attempts to do no validation, it will only return
-// false if there are not enough bytes for an item to be read. For example, the
-// ReadDocument function checks the length, if that length is larger than the
-// number of bytes available, it will return false, if there are enough bytes,
-// it will return those bytes and true. It is the consumers responsibility to
-// validate those bytes.
-//
-// The Append* functions within this package will append the type value to the
-// given dst slice. If the slice has enough capacity, it will not grow the
-// slice. The Append*Element functions within this package operate in the same
-// way, but additionally append the BSON type and the key before the value.
-package bsoncore
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/document.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/document.go
deleted file mode 100644
index 6a59908d..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/document.go
+++ /dev/null
@@ -1,411 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bsoncore
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"strconv"
-	"strings"
-
-	"go.mongodb.org/mongo-driver/v2/internal/bsoncoreutil"
-)
-
-// ValidationError is an error type returned when attempting to validate a document or array.
-type ValidationError string
-
-func (ve ValidationError) Error() string { return string(ve) }
-
-// NewDocumentLengthError creates and returns an error for when the length of a document exceeds the
-// bytes available.
-func NewDocumentLengthError(length, rem int) error {
-	return lengthError("document", length, rem)
-}
-
-func lengthError(bufferType string, length, rem int) error {
-	return ValidationError(fmt.Sprintf("%v length exceeds available bytes. length=%d remainingBytes=%d",
-		bufferType, length, rem))
-}
-
-// InsufficientBytesError indicates that there were not enough bytes to read the next component.
-type InsufficientBytesError struct {
-	Source    []byte
-	Remaining []byte
-}
-
-// NewInsufficientBytesError creates a new InsufficientBytesError with the given Document and
-// remaining bytes.
-func NewInsufficientBytesError(src, rem []byte) InsufficientBytesError {
-	return InsufficientBytesError{Source: src, Remaining: rem}
-}
-
-// Error implements the error interface.
-func (ibe InsufficientBytesError) Error() string {
-	return "too few bytes to read next component"
-}
-
-// Equal checks that err2 also is an ErrTooSmall.
-func (ibe InsufficientBytesError) Equal(err2 error) bool {
-	switch err2.(type) {
-	case InsufficientBytesError:
-		return true
-	default:
-		return false
-	}
-}
-
-// InvalidDepthTraversalError is returned when attempting a recursive Lookup when one component of
-// the path is neither an embedded document nor an array.
-type InvalidDepthTraversalError struct {
-	Key  string
-	Type Type
-}
-
-func (idte InvalidDepthTraversalError) Error() string {
-	return fmt.Sprintf(
-		"attempt to traverse into %s, but it's type is %s, not %s nor %s",
-		idte.Key, idte.Type, TypeEmbeddedDocument, TypeArray,
-	)
-}
-
-// ErrMissingNull is returned when a document or array's last byte is not null.
-const ErrMissingNull ValidationError = "document or array end is missing null byte"
-
-// ErrInvalidLength indicates that a length in a binary representation of a BSON document or array
-// is invalid.
-const ErrInvalidLength ValidationError = "document or array length is invalid"
-
-// ErrNilReader indicates that an operation was attempted on a nil io.Reader.
-var ErrNilReader = errors.New("nil reader")
-
-// ErrEmptyKey indicates that no key was provided to a Lookup method.
-var ErrEmptyKey = errors.New("empty key provided")
-
-// ErrElementNotFound indicates that an Element matching a certain condition does not exist.
-var ErrElementNotFound = errors.New("element not found")
-
-// ErrOutOfBounds indicates that an index provided to access something was invalid.
-var ErrOutOfBounds = errors.New("out of bounds")
-
-// Document is a raw bytes representation of a BSON document.
-type Document []byte
-
-// NewDocumentFromReader reads a document from r. This function will only validate the length is
-// correct and that the document ends with a null byte.
-func NewDocumentFromReader(r io.Reader) (Document, error) {
-	return newBufferFromReader(r)
-}
-
-func newBufferFromReader(r io.Reader) ([]byte, error) {
-	if r == nil {
-		return nil, ErrNilReader
-	}
-
-	var lengthBytes [4]byte
-
-	// ReadFull guarantees that we will have read at least len(lengthBytes) if err == nil
-	_, err := io.ReadFull(r, lengthBytes[:])
-	if err != nil {
-		return nil, err
-	}
-
-	length, _, _ := readi32(lengthBytes[:]) // ignore ok since we always have enough bytes to read a length
-	if length < 0 {
-		return nil, ErrInvalidLength
-	}
-	buffer := make([]byte, length)
-
-	copy(buffer, lengthBytes[:])
-
-	_, err = io.ReadFull(r, buffer[4:])
-	if err != nil {
-		return nil, err
-	}
-
-	if buffer[length-1] != 0x00 {
-		return nil, ErrMissingNull
-	}
-
-	return buffer, nil
-}
-
-// Lookup searches the document, potentially recursively, for the given key. If there are multiple
-// keys provided, this method will recurse down, as long as the top and intermediate nodes are
-// either documents or arrays. If an error occurs or if the value doesn't exist, an empty Value is
-// returned.
-func (d Document) Lookup(key ...string) Value {
-	val, _ := d.LookupErr(key...)
-	return val
-}
-
-// LookupErr is the same as Lookup, except it returns an error in addition to an empty Value.
-func (d Document) LookupErr(key ...string) (Value, error) {
-	if len(key) < 1 {
-		return Value{}, ErrEmptyKey
-	}
-	length, rem, ok := ReadLength(d)
-	if !ok {
-		return Value{}, NewInsufficientBytesError(d, rem)
-	}
-
-	length -= 4
-
-	var elem Element
-	for length > 1 {
-		elem, rem, ok = ReadElement(rem)
-		length -= int32(len(elem))
-		if !ok {
-			return Value{}, NewInsufficientBytesError(d, rem)
-		}
-		// We use `KeyBytes` rather than `Key` to avoid a needless string alloc.
-		if string(elem.KeyBytes()) != key[0] {
-			continue
-		}
-		if len(key) > 1 {
-			tt := Type(elem[0])
-			switch tt {
-			case TypeEmbeddedDocument:
-				val, err := elem.Value().Document().LookupErr(key[1:]...)
-				if err != nil {
-					return Value{}, err
-				}
-				return val, nil
-			case TypeArray:
-				// Convert to Document to continue Lookup recursion.
-				val, err := Document(elem.Value().Array()).LookupErr(key[1:]...)
-				if err != nil {
-					return Value{}, err
-				}
-				return val, nil
-			default:
-				return Value{}, InvalidDepthTraversalError{Key: elem.Key(), Type: tt}
-			}
-		}
-		return elem.ValueErr()
-	}
-	return Value{}, ErrElementNotFound
-}
-
-// Index searches for and retrieves the element at the given index. This method will panic if
-// the document is invalid or if the index is out of bounds.
-func (d Document) Index(index uint) Element {
-	elem, err := d.IndexErr(index)
-	if err != nil {
-		panic(err)
-	}
-	return elem
-}
-
-// IndexErr searches for and retrieves the element at the given index.
-func (d Document) IndexErr(index uint) (Element, error) {
-	return indexErr(d, index)
-}
-
-func indexErr(b []byte, index uint) (Element, error) {
-	length, rem, ok := ReadLength(b)
-	if !ok {
-		return nil, NewInsufficientBytesError(b, rem)
-	}
-
-	length -= 4
-
-	var current uint
-	var elem Element
-	for length > 1 {
-		elem, rem, ok = ReadElement(rem)
-		length -= int32(len(elem))
-		if !ok {
-			return nil, NewInsufficientBytesError(b, rem)
-		}
-		if current != index {
-			current++
-			continue
-		}
-		return elem, nil
-	}
-	return nil, ErrOutOfBounds
-}
-
-// DebugString outputs a human readable version of Document. It will attempt to stringify the
-// valid components of the document even if the entire document is not valid.
-func (d Document) DebugString() string {
-	if len(d) < 5 {
-		return "<malformed>"
-	}
-	var buf strings.Builder
-	buf.WriteString("Document")
-	length, rem, _ := ReadLength(d) // We know we have enough bytes to read the length
-	buf.WriteByte('(')
-	buf.WriteString(strconv.Itoa(int(length)))
-	length -= 4
-	buf.WriteString("){")
-	var elem Element
-	var ok bool
-	for length > 1 {
-		elem, rem, ok = ReadElement(rem)
-		length -= int32(len(elem))
-		if !ok {
-			buf.WriteString(fmt.Sprintf("<malformed (%d)>", length))
-			break
-		}
-		buf.WriteString(elem.DebugString())
-	}
-	buf.WriteByte('}')
-
-	return buf.String()
-}
-
-// String outputs an ExtendedJSON version of Document. If the document is not valid, this method
-// returns an empty string.
-func (d Document) String() string {
-	return d.StringN(math.MaxInt)
-}
-
-// StringN stringifies a document upto N bytes
-func (d Document) StringN(n int) string {
-	if len(d) < 5 || n <= 0 {
-		return ""
-	}
-
-	var buf strings.Builder
-
-	buf.WriteByte('{')
-
-	length, rem, _ := ReadLength(d)
-	length -= 4
-
-	var elem Element
-	var ok bool
-
-	first := true
-	truncated := false
-
-	if n > 0 {
-		for length > 1 {
-			if !first {
-				buf.WriteByte(',')
-			}
-			elem, rem, ok = ReadElement(rem)
-			length -= int32(len(elem))
-			if !ok {
-				return ""
-			}
-
-			str := elem.StringN(n)
-			if buf.Len()+len(str) > n {
-				truncatedStr := bsoncoreutil.Truncate(str, n-buf.Len())
-				buf.WriteString(truncatedStr)
-
-				truncated = true
-				break
-			}
-
-			buf.WriteString(str)
-			first = false
-		}
-	}
-
-	if !truncated {
-		buf.WriteByte('}')
-	}
-
-	return buf.String()
-}
-
-// Elements returns this document as a slice of elements. The returned slice will contain valid
-// elements. If the document is not valid, the elements up to the invalid point will be returned
-// along with an error.
-func (d Document) Elements() ([]Element, error) {
-	length, rem, ok := ReadLength(d)
-	if !ok {
-		return nil, NewInsufficientBytesError(d, rem)
-	}
-
-	length -= 4
-
-	var elem Element
-	var elems []Element
-	for length > 1 {
-		elem, rem, ok = ReadElement(rem)
-		length -= int32(len(elem))
-		if !ok {
-			return elems, NewInsufficientBytesError(d, rem)
-		}
-		if err := elem.Validate(); err != nil {
-			return elems, err
-		}
-		elems = append(elems, elem)
-	}
-	return elems, nil
-}
-
-// Values returns this document as a slice of values. The returned slice will contain valid values.
-// If the document is not valid, the values up to the invalid point will be returned along with an
-// error.
-func (d Document) Values() ([]Value, error) {
-	return values(d)
-}
-
-func values(b []byte) ([]Value, error) {
-	length, rem, ok := ReadLength(b)
-	if !ok {
-		return nil, NewInsufficientBytesError(b, rem)
-	}
-
-	length -= 4
-
-	var elem Element
-	var vals []Value
-	for length > 1 {
-		elem, rem, ok = ReadElement(rem)
-		length -= int32(len(elem))
-		if !ok {
-			return vals, NewInsufficientBytesError(b, rem)
-		}
-		if err := elem.Value().Validate(); err != nil {
-			return vals, err
-		}
-		vals = append(vals, elem.Value())
-	}
-	return vals, nil
-}
-
-// Validate validates the document and ensures the elements contained within are valid.
-func (d Document) Validate() error {
-	length, rem, ok := ReadLength(d)
-	if !ok {
-		return NewInsufficientBytesError(d, rem)
-	}
-	if int(length) > len(d) {
-		return NewDocumentLengthError(int(length), len(d))
-	}
-	if d[length-1] != 0x00 {
-		return ErrMissingNull
-	}
-
-	length -= 4
-	var elem Element
-
-	for length > 1 {
-		elem, rem, ok = ReadElement(rem)
-		length -= int32(len(elem))
-		if !ok {
-			return NewInsufficientBytesError(d, rem)
-		}
-		err := elem.Validate()
-		if err != nil {
-			return err
-		}
-	}
-
-	if len(rem) < 1 || rem[0] != 0x00 {
-		return ErrMissingNull
-	}
-	return nil
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/element.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/element.go
deleted file mode 100644
index dcb5e86e..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/element.go
+++ /dev/null
@@ -1,166 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bsoncore
-
-import (
-	"bytes"
-	"fmt"
-	"math"
-)
-
-// MalformedElementError represents a class of errors that RawElement methods return.
-type MalformedElementError string
-
-func (mee MalformedElementError) Error() string { return string(mee) }
-
-// ErrElementMissingKey is returned when a RawElement is missing a key.
-const ErrElementMissingKey MalformedElementError = "element is missing key"
-
-// ErrElementMissingType is returned when a RawElement is missing a type.
-const ErrElementMissingType MalformedElementError = "element is missing type"
-
-// Element is a raw bytes representation of a BSON element.
-type Element []byte
-
-// Key returns the key for this element. If the element is not valid, this method returns an empty
-// string. If knowing if the element is valid is important, use KeyErr.
-func (e Element) Key() string {
-	key, _ := e.KeyErr()
-	return key
-}
-
-// KeyBytes returns the key for this element as a []byte. If the element is not valid, this method
-// returns an empty string. If knowing if the element is valid is important, use KeyErr. This method
-// will not include the null byte at the end of the key in the slice of bytes.
-func (e Element) KeyBytes() []byte {
-	key, _ := e.KeyBytesErr()
-	return key
-}
-
-// KeyErr returns the key for this element, returning an error if the element is not valid.
-func (e Element) KeyErr() (string, error) {
-	key, err := e.KeyBytesErr()
-	return string(key), err
-}
-
-// KeyBytesErr returns the key for this element as a []byte, returning an error if the element is
-// not valid.
-func (e Element) KeyBytesErr() ([]byte, error) {
-	if len(e) == 0 {
-		return nil, ErrElementMissingType
-	}
-	idx := bytes.IndexByte(e[1:], 0x00)
-	if idx == -1 {
-		return nil, ErrElementMissingKey
-	}
-	return e[1 : idx+1], nil
-}
-
-// Validate ensures the element is a valid BSON element.
-func (e Element) Validate() error {
-	if len(e) < 1 {
-		return ErrElementMissingType
-	}
-	idx := bytes.IndexByte(e[1:], 0x00)
-	if idx == -1 {
-		return ErrElementMissingKey
-	}
-	return Value{Type: Type(e[0]), Data: e[idx+2:]}.Validate()
-}
-
-// CompareKey will compare this element's key to key. This method makes it easy to compare keys
-// without needing to allocate a string. The key may be null terminated. If a valid key cannot be
-// read this method will return false.
-func (e Element) CompareKey(key []byte) bool {
-	if len(e) < 2 {
-		return false
-	}
-	idx := bytes.IndexByte(e[1:], 0x00)
-	if idx == -1 {
-		return false
-	}
-	if index := bytes.IndexByte(key, 0x00); index > -1 {
-		key = key[:index]
-	}
-	return bytes.Equal(e[1:idx+1], key)
-}
-
-// Value returns the value of this element. If the element is not valid, this method returns an
-// empty Value. If knowing if the element is valid is important, use ValueErr.
-func (e Element) Value() Value {
-	val, _ := e.ValueErr()
-	return val
-}
-
-// ValueErr returns the value for this element, returning an error if the element is not valid.
-func (e Element) ValueErr() (Value, error) {
-	if len(e) == 0 {
-		return Value{}, ErrElementMissingType
-	}
-	idx := bytes.IndexByte(e[1:], 0x00)
-	if idx == -1 {
-		return Value{}, ErrElementMissingKey
-	}
-
-	val, rem, exists := ReadValue(e[idx+2:], Type(e[0]))
-	if !exists {
-		return Value{}, NewInsufficientBytesError(e, rem)
-	}
-	return val, nil
-}
-
-// String implements the fmt.String interface. The output will be in extended JSON format.
-func (e Element) String() string {
-	return e.StringN(math.MaxInt)
-}
-
-// StringN implements the fmt.String interface for upto N bytes. The output will be in extended JSON format.
-func (e Element) StringN(n int) string {
-	if len(e) == 0 {
-		return ""
-	}
-	t := Type(e[0])
-	idx := bytes.IndexByte(e[1:], 0x00)
-	if idx == -1 {
-		return ""
-	}
-	key, valBytes := []byte(e[1:idx+1]), []byte(e[idx+2:])
-	val, _, valid := ReadValue(valBytes, t)
-	if !valid {
-		return ""
-	}
-
-	var str string
-	if _, ok := val.StringValueOK(); ok {
-		str = val.StringN(n)
-	} else if arr, ok := val.ArrayOK(); ok {
-		str = arr.StringN(n)
-	} else {
-		str = val.String()
-	}
-
-	return "\"" + string(key) + "\": " + str
-}
-
-// DebugString outputs a human readable version of RawElement. It will attempt to stringify the
-// valid components of the element even if the entire element is not valid.
-func (e Element) DebugString() string {
-	if len(e) == 0 {
-		return "<malformed>"
-	}
-	t := Type(e[0])
-	idx := bytes.IndexByte(e[1:], 0x00)
-	if idx == -1 {
-		return fmt.Sprintf(`bson.Element{[%s]<malformed>}`, t)
-	}
-	key, valBytes := []byte(e[1:idx+1]), []byte(e[idx+2:])
-	val, _, valid := ReadValue(valBytes, t)
-	if !valid {
-		return fmt.Sprintf(`bson.Element{[%s]"%s": <malformed>}`, t, key)
-	}
-	return fmt.Sprintf(`bson.Element{[%s]"%s": %v}`, t, key, val)
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/iterator.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/iterator.go
deleted file mode 100644
index 9c8ea5b8..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/iterator.go
+++ /dev/null
@@ -1,113 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2022-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bsoncore
-
-import (
-	"errors"
-	"fmt"
-	"io"
-)
-
-// errCorruptedDocument is returned when a full document couldn't be read from
-// the sequence.
-var errCorruptedDocument = errors.New("invalid DocumentSequence: corrupted document")
-
-// Iterator maintains a list of BSON values and keeps track of the current
-// position in relation to its Next() method.
-type Iterator struct {
-	List Array // List of BSON values
-	pos  int   // The position of the iterator in the list in reference to Next()
-}
-
-// Count returned the number of elements in the iterator's list.
-func (iter *Iterator) Count() int {
-	if iter == nil {
-		return 0
-	}
-
-	_, rem, ok := ReadLength(iter.List)
-	if !ok {
-		return 0
-	}
-
-	var count int
-	for len(rem) > 1 {
-		_, rem, ok = ReadElement(rem)
-		if !ok {
-			return 0
-		}
-		count++
-	}
-	return count
-}
-
-// Empty returns true if the iterator's list is empty.
-func (iter *Iterator) Empty() bool {
-	return len(iter.List) <= 5
-}
-
-// Reset will reset the iteration point for the Next method to the beginning of
-// the list.
-func (iter *Iterator) Reset() {
-	iter.pos = 0
-}
-
-// Documents traverses the list as documents and returns them. This method
-// assumes that the underlying list is composed of documents and will return
-// an error otherwise.
-func (iter *Iterator) Documents() ([]Document, error) {
-	if iter == nil || len(iter.List) == 0 {
-		return nil, nil
-	}
-
-	vals, err := iter.List.Values()
-	if err != nil {
-		return nil, errCorruptedDocument
-	}
-
-	docs := make([]Document, 0, len(vals))
-	for _, v := range vals {
-		if v.Type != TypeEmbeddedDocument {
-			return nil, fmt.Errorf("invalid DocumentSequence: a non-document value was found in sequence")
-		}
-
-		docs = append(docs, v.Data)
-	}
-
-	return docs, nil
-}
-
-// Next retrieves the next value from the list and returns it. This method will
-// return io.EOF when it has reached the end of the list.
-func (iter *Iterator) Next() (*Value, error) {
-	if iter == nil || iter.pos >= len(iter.List) {
-		return nil, io.EOF
-	}
-
-	if iter.pos < 4 {
-		if len(iter.List) < 4 {
-			return nil, errCorruptedDocument
-		}
-
-		iter.pos = 4 // Skip the length of the document
-	}
-
-	rem := iter.List[iter.pos:]
-	if len(rem) == 1 && rem[0] == 0x00 {
-		return nil, io.EOF // At the end of the document
-	}
-
-	elem, _, ok := ReadElement(rem)
-	if !ok {
-		return nil, errCorruptedDocument
-	}
-
-	iter.pos += len(elem)
-	val := elem.Value()
-
-	return &val, nil
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/tables.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/tables.go
deleted file mode 100644
index 9fd903fd..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/tables.go
+++ /dev/null
@@ -1,223 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-//
-// Based on github.com/golang/go by The Go Authors
-// See THIRD-PARTY-NOTICES for original license terms.
-
-package bsoncore
-
-import "unicode/utf8"
-
-// safeSet holds the value true if the ASCII character with the given array
-// position can be represented inside a JSON string without any further
-// escaping.
-//
-// All values are true except for the ASCII control characters (0-31), the
-// double quote ("), and the backslash character ("\").
-var safeSet = [utf8.RuneSelf]bool{
-	' ':      true,
-	'!':      true,
-	'"':      false,
-	'#':      true,
-	'$':      true,
-	'%':      true,
-	'&':      true,
-	'\'':     true,
-	'(':      true,
-	')':      true,
-	'*':      true,
-	'+':      true,
-	',':      true,
-	'-':      true,
-	'.':      true,
-	'/':      true,
-	'0':      true,
-	'1':      true,
-	'2':      true,
-	'3':      true,
-	'4':      true,
-	'5':      true,
-	'6':      true,
-	'7':      true,
-	'8':      true,
-	'9':      true,
-	':':      true,
-	';':      true,
-	'<':      true,
-	'=':      true,
-	'>':      true,
-	'?':      true,
-	'@':      true,
-	'A':      true,
-	'B':      true,
-	'C':      true,
-	'D':      true,
-	'E':      true,
-	'F':      true,
-	'G':      true,
-	'H':      true,
-	'I':      true,
-	'J':      true,
-	'K':      true,
-	'L':      true,
-	'M':      true,
-	'N':      true,
-	'O':      true,
-	'P':      true,
-	'Q':      true,
-	'R':      true,
-	'S':      true,
-	'T':      true,
-	'U':      true,
-	'V':      true,
-	'W':      true,
-	'X':      true,
-	'Y':      true,
-	'Z':      true,
-	'[':      true,
-	'\\':     false,
-	']':      true,
-	'^':      true,
-	'_':      true,
-	'`':      true,
-	'a':      true,
-	'b':      true,
-	'c':      true,
-	'd':      true,
-	'e':      true,
-	'f':      true,
-	'g':      true,
-	'h':      true,
-	'i':      true,
-	'j':      true,
-	'k':      true,
-	'l':      true,
-	'm':      true,
-	'n':      true,
-	'o':      true,
-	'p':      true,
-	'q':      true,
-	'r':      true,
-	's':      true,
-	't':      true,
-	'u':      true,
-	'v':      true,
-	'w':      true,
-	'x':      true,
-	'y':      true,
-	'z':      true,
-	'{':      true,
-	'|':      true,
-	'}':      true,
-	'~':      true,
-	'\u007f': true,
-}
-
-// htmlSafeSet holds the value true if the ASCII character with the given
-// array position can be safely represented inside a JSON string, embedded
-// inside of HTML <script> tags, without any additional escaping.
-//
-// All values are true except for the ASCII control characters (0-31), the
-// double quote ("), the backslash character ("\"), HTML opening and closing
-// tags ("<" and ">"), and the ampersand ("&").
-var htmlSafeSet = [utf8.RuneSelf]bool{
-	' ':      true,
-	'!':      true,
-	'"':      false,
-	'#':      true,
-	'$':      true,
-	'%':      true,
-	'&':      false,
-	'\'':     true,
-	'(':      true,
-	')':      true,
-	'*':      true,
-	'+':      true,
-	',':      true,
-	'-':      true,
-	'.':      true,
-	'/':      true,
-	'0':      true,
-	'1':      true,
-	'2':      true,
-	'3':      true,
-	'4':      true,
-	'5':      true,
-	'6':      true,
-	'7':      true,
-	'8':      true,
-	'9':      true,
-	':':      true,
-	';':      true,
-	'<':      false,
-	'=':      true,
-	'>':      false,
-	'?':      true,
-	'@':      true,
-	'A':      true,
-	'B':      true,
-	'C':      true,
-	'D':      true,
-	'E':      true,
-	'F':      true,
-	'G':      true,
-	'H':      true,
-	'I':      true,
-	'J':      true,
-	'K':      true,
-	'L':      true,
-	'M':      true,
-	'N':      true,
-	'O':      true,
-	'P':      true,
-	'Q':      true,
-	'R':      true,
-	'S':      true,
-	'T':      true,
-	'U':      true,
-	'V':      true,
-	'W':      true,
-	'X':      true,
-	'Y':      true,
-	'Z':      true,
-	'[':      true,
-	'\\':     false,
-	']':      true,
-	'^':      true,
-	'_':      true,
-	'`':      true,
-	'a':      true,
-	'b':      true,
-	'c':      true,
-	'd':      true,
-	'e':      true,
-	'f':      true,
-	'g':      true,
-	'h':      true,
-	'i':      true,
-	'j':      true,
-	'k':      true,
-	'l':      true,
-	'm':      true,
-	'n':      true,
-	'o':      true,
-	'p':      true,
-	'q':      true,
-	'r':      true,
-	's':      true,
-	't':      true,
-	'u':      true,
-	'v':      true,
-	'w':      true,
-	'x':      true,
-	'y':      true,
-	'z':      true,
-	'{':      true,
-	'|':      true,
-	'}':      true,
-	'~':      true,
-	'\u007f': true,
-}
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/type.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/type.go
deleted file mode 100644
index 30b6cc43..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/type.go
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bsoncore
-
-// Type represents a BSON type.
-type Type byte
-
-// String returns the string representation of the BSON type's name.
-func (bt Type) String() string {
-	switch bt {
-	case '\x01':
-		return "double"
-	case '\x02':
-		return "string"
-	case '\x03':
-		return "embedded document"
-	case '\x04':
-		return "array"
-	case '\x05':
-		return "binary"
-	case '\x06':
-		return "undefined"
-	case '\x07':
-		return "objectID"
-	case '\x08':
-		return "boolean"
-	case '\x09':
-		return "UTC datetime"
-	case '\x0A':
-		return "null"
-	case '\x0B':
-		return "regex"
-	case '\x0C':
-		return "dbPointer"
-	case '\x0D':
-		return "javascript"
-	case '\x0E':
-		return "symbol"
-	case '\x0F':
-		return "code with scope"
-	case '\x10':
-		return "32-bit integer"
-	case '\x11':
-		return "timestamp"
-	case '\x12':
-		return "64-bit integer"
-	case '\x13':
-		return "128-bit decimal"
-	case '\x7F':
-		return "max key"
-	case '\xFF':
-		return "min key"
-	default:
-		return "invalid"
-	}
-}
-
-// BSON element types as described in https://bsonspec.org/spec.html.
-const (
-	TypeDouble           Type = 0x01
-	TypeString           Type = 0x02
-	TypeEmbeddedDocument Type = 0x03
-	TypeArray            Type = 0x04
-	TypeBinary           Type = 0x05
-	TypeUndefined        Type = 0x06
-	TypeObjectID         Type = 0x07
-	TypeBoolean          Type = 0x08
-	TypeDateTime         Type = 0x09
-	TypeNull             Type = 0x0A
-	TypeRegex            Type = 0x0B
-	TypeDBPointer        Type = 0x0C
-	TypeJavaScript       Type = 0x0D
-	TypeSymbol           Type = 0x0E
-	TypeCodeWithScope    Type = 0x0F
-	TypeInt32            Type = 0x10
-	TypeTimestamp        Type = 0x11
-	TypeInt64            Type = 0x12
-	TypeDecimal128       Type = 0x13
-	TypeMaxKey           Type = 0x7F
-	TypeMinKey           Type = 0xFF
-)
diff --git a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/value.go b/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/value.go
deleted file mode 100644
index b0fd9074..00000000
--- a/vendor/go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore/value.go
+++ /dev/null
@@ -1,986 +0,0 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-package bsoncore
-
-import (
-	"bytes"
-	"encoding/base64"
-	"encoding/hex"
-	"fmt"
-	"math"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-	"unicode/utf8"
-
-	"go.mongodb.org/mongo-driver/v2/internal/bsoncoreutil"
-	"go.mongodb.org/mongo-driver/v2/internal/decimal128"
-)
-
-// ElementTypeError specifies that a method to obtain a BSON value an incorrect type was called on a bson.Value.
-type ElementTypeError struct {
-	Method string
-	Type   Type
-}
-
-// Error implements the error interface.
-func (ete ElementTypeError) Error() string {
-	return "Call of " + ete.Method + " on " + ete.Type.String() + " type"
-}
-
-// Value represents a BSON value with a type and raw bytes.
-type Value struct {
-	Type Type
-	Data []byte
-}
-
-// Validate ensures the value is a valid BSON value.
-func (v Value) Validate() error {
-	_, _, valid := readValue(v.Data, v.Type)
-	if !valid {
-		return NewInsufficientBytesError(v.Data, v.Data)
-	}
-	return nil
-}
-
-// IsNumber returns true if the type of v is a numeric BSON type.
-func (v Value) IsNumber() bool {
-	switch v.Type {
-	case TypeDouble, TypeInt32, TypeInt64, TypeDecimal128:
-		return true
-	default:
-		return false
-	}
-}
-
-// AsInt32 returns a BSON number as an int32. If the BSON type is not a numeric one, this method
-// will panic.
-func (v Value) AsInt32() int32 {
-	if !v.IsNumber() {
-		panic(ElementTypeError{"bsoncore.Value.AsInt32", v.Type})
-	}
-	var i32 int32
-	switch v.Type {
-	case TypeDouble:
-		f64, _, ok := ReadDouble(v.Data)
-		if !ok {
-			panic(NewInsufficientBytesError(v.Data, v.Data))
-		}
-		i32 = int32(f64)
-	case TypeInt32:
-		var ok bool
-		i32, _, ok = ReadInt32(v.Data)
-		if !ok {
-			panic(NewInsufficientBytesError(v.Data, v.Data))
-		}
-	case TypeInt64:
-		i64, _, ok := ReadInt64(v.Data)
-		if !ok {
-			panic(NewInsufficientBytesError(v.Data, v.Data))
-		}
-		i32 = int32(i64)
-	case TypeDecimal128:
-		panic(ElementTypeError{"bsoncore.Value.AsInt32", v.Type})
-	}
-	return i32
-}
-
-// AsInt32OK functions the same as AsInt32 but returns a boolean instead of panicking. False
-// indicates an error.
-func (v Value) AsInt32OK() (int32, bool) {
-	if !v.IsNumber() {
-		return 0, false
-	}
-	var i32 int32
-	switch v.Type {
-	case TypeDouble:
-		f64, _, ok := ReadDouble(v.Data)
-		if !ok {
-			return 0, false
-		}
-		i32 = int32(f64)
-	case TypeInt32:
-		var ok bool
-		i32, _, ok = ReadInt32(v.Data)
-		if !ok {
-			return 0, false
-		}
-	case TypeInt64:
-		i64, _, ok := ReadInt64(v.Data)
-		if !ok {
-			return 0, false
-		}
-		i32 = int32(i64)
-	case TypeDecimal128:
-		return 0, false
-	}
-	return i32, true
-}
-
-// AsInt64 returns a BSON number as an int64. If the BSON type is not a numeric one, this method
-// will panic.
-func (v Value) AsInt64() int64 {
-	if !v.IsNumber() {
-		panic(ElementTypeError{"bsoncore.Value.AsInt64", v.Type})
-	}
-	var i64 int64
-	switch v.Type {
-	case TypeDouble:
-		f64, _, ok := ReadDouble(v.Data)
-		if !ok {
-			panic(NewInsufficientBytesError(v.Data, v.Data))
-		}
-		i64 = int64(f64)
-	case TypeInt32:
-		var ok bool
-		i32, _, ok := ReadInt32(v.Data)
-		if !ok {
-			panic(NewInsufficientBytesError(v.Data, v.Data))
-		}
-		i64 = int64(i32)
-	case TypeInt64:
-		var ok bool
-		i64, _, ok = ReadInt64(v.Data)
-		if !ok {
-			panic(NewInsufficientBytesError(v.Data, v.Data))
-		}
-	case TypeDecimal128:
-		panic(ElementTypeError{"bsoncore.Value.AsInt64", v.Type})
-	}
-	return i64
-}
-
-// AsInt64OK functions the same as AsInt64 but returns a boolean instead of panicking. False
-// indicates an error.
-func (v Value) AsInt64OK() (int64, bool) {
-	if !v.IsNumber() {
-		return 0, false
-	}
-	var i64 int64
-	switch v.Type {
-	case TypeDouble:
-		f64, _, ok := ReadDouble(v.Data)
-		if !ok {
-			return 0, false
-		}
-		i64 = int64(f64)
-	case TypeInt32:
-		var ok bool
-		i32, _, ok := ReadInt32(v.Data)
-		if !ok {
-			return 0, false
-		}
-		i64 = int64(i32)
-	case TypeInt64:
-		var ok bool
-		i64, _, ok = ReadInt64(v.Data)
-		if !ok {
-			return 0, false
-		}
-	case TypeDecimal128:
-		return 0, false
-	}
-	return i64, true
-}
-
-// AsFloat64 returns a BSON number as an float64. If the BSON type is not a numeric one, this method
-// will panic.
-//
-// TODO(GODRIVER-2751): Implement AsFloat64.
-// func (v Value) AsFloat64() float64
-
-// AsFloat64OK functions the same as AsFloat64 but returns a boolean instead of panicking. False
-// indicates an error.
-//
-// TODO(GODRIVER-2751): Implement AsFloat64OK.
-// func (v Value) AsFloat64OK() (float64, bool)
-
-// Equal compaes v to v2 and returns true if they are equal.
-func (v Value) Equal(v2 Value) bool {
-	if v.Type != v2.Type {
-		return false
-	}
-
-	return bytes.Equal(v.Data, v2.Data)
-}
-
-func idHex(id [12]byte) string {
-	var buf [24]byte
-	hex.Encode(buf[:], id[:])
-	return string(buf[:])
-}
-
-// String implements the fmt.String interface. This method will return values in extended JSON
-// format. If the value is not valid, this returns an empty string
-func (v Value) String() string {
-	return v.StringN(math.MaxInt)
-}
-
-// StringN implements the fmt.String interface. This method will return values in extended JSON
-// format that will stringify a value upto N bytes. If the value is not valid, this returns an empty string
-func (v Value) StringN(n int) string {
-	if n <= 0 {
-		return ""
-	}
-
-	switch v.Type {
-	case TypeString:
-		str, ok := v.StringValueOK()
-		if !ok {
-			return ""
-		}
-		str = escapeString(str)
-		if len(str) > n {
-			truncatedStr := bsoncoreutil.Truncate(str, n)
-			return truncatedStr
-		}
-		return str
-	case TypeEmbeddedDocument:
-		doc, ok := v.DocumentOK()
-		if !ok {
-			return ""
-		}
-		return doc.StringN(n)
-	case TypeArray:
-		arr, ok := v.ArrayOK()
-		if !ok {
-			return ""
-		}
-		return arr.StringN(n)
-	case TypeDouble:
-		f64, ok := v.DoubleOK()
-		if !ok {
-			return ""
-		}
-		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$numberDouble":"%s"}`, formatDouble(f64)), n)
-	case TypeBinary:
-		subtype, data, ok := v.BinaryOK()
-		if !ok {
-			return ""
-		}
-		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$binary":{"base64":"%s","subType":"%02x"}}`, base64.StdEncoding.EncodeToString(data), subtype), n)
-	case TypeUndefined:
-		return bsoncoreutil.Truncate(`{"$undefined":true}`, n)
-	case TypeObjectID:
-		oid, ok := v.ObjectIDOK()
-		if !ok {
-			return ""
-		}
-		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$oid":"%s"}`, idHex(oid)), n)
-	case TypeBoolean:
-		b, ok := v.BooleanOK()
-		if !ok {
-			return ""
-		}
-		return bsoncoreutil.Truncate(strconv.FormatBool(b), n)
-	case TypeDateTime:
-		dt, ok := v.DateTimeOK()
-		if !ok {
-			return ""
-		}
-		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$date":{"$numberLong":"%d"}}`, dt), n)
-	case TypeNull:
-		return bsoncoreutil.Truncate("null", n)
-	case TypeRegex:
-		pattern, options, ok := v.RegexOK()
-		if !ok {
-			return ""
-		}
-		return bsoncoreutil.Truncate(fmt.Sprintf(
-			`{"$regularExpression":{"pattern":%s,"options":"%s"}}`,
-			escapeString(pattern), sortStringAlphebeticAscending(options),
-		), n)
-	case TypeDBPointer:
-		ns, pointer, ok := v.DBPointerOK()
-		if !ok {
-			return ""
-		}
-		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$dbPointer":{"$ref":%s,"$id":{"$oid":"%s"}}}`, escapeString(ns), idHex(pointer)), n)
-	case TypeJavaScript:
-		js, ok := v.JavaScriptOK()
-		if !ok {
-			return ""
-		}
-		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$code":%s}`, escapeString(js)), n)
-	case TypeSymbol:
-		symbol, ok := v.SymbolOK()
-		if !ok {
-			return ""
-		}
-		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$symbol":%s}`, escapeString(symbol)), n)
-	case TypeCodeWithScope:
-		code, scope, ok := v.CodeWithScopeOK()
-		if !ok {
-			return ""
-		}
-		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$code":%s,"$scope":%s}`, code, scope), n)
-	case TypeInt32:
-		i32, ok := v.Int32OK()
-		if !ok {
-			return ""
-		}
-		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$numberInt":"%d"}`, i32), n)
-	case TypeTimestamp:
-		t, i, ok := v.TimestampOK()
-		if !ok {
-			return ""
-		}
-		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$timestamp":{"t":%v,"i":%v}}`, t, i), n)
-	case TypeInt64:
-		i64, ok := v.Int64OK()
-		if !ok {
-			return ""
-		}
-		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$numberLong":"%d"}`, i64), n)
-	case TypeDecimal128:
-		h, l, ok := v.Decimal128OK()
-		if !ok {
-			return ""
-		}
-		return bsoncoreutil.Truncate(fmt.Sprintf(`{"$numberDecimal":"%s"}`, decimal128.String(h, l)), n)
-	case TypeMinKey:
-		return bsoncoreutil.Truncate(`{"$minKey":1}`, n)
-	case TypeMaxKey:
-		return bsoncoreutil.Truncate(`{"$maxKey":1}`, n)
-	default:
-		return ""
-	}
-}
-
-// DebugString outputs a human readable version of Document. It will attempt to stringify the
-// valid components of the document even if the entire document is not valid.
-func (v Value) DebugString() string {
-	switch v.Type {
-	case TypeString:
-		str, ok := v.StringValueOK()
-		if !ok {
-			return "<malformed>"
-		}
-		return escapeString(str)
-	case TypeEmbeddedDocument:
-		doc, ok := v.DocumentOK()
-		if !ok {
-			return "<malformed>"
-		}
-		return doc.DebugString()
-	case TypeArray:
-		arr, ok := v.ArrayOK()
-		if !ok {
-			return "<malformed>"
-		}
-		return arr.DebugString()
-	case TypeCodeWithScope:
-		code, scope, ok := v.CodeWithScopeOK()
-		if !ok {
-			return ""
-		}
-		return fmt.Sprintf(`{"$code":%s,"$scope":%s}`, code, scope.DebugString())
-	default:
-		str := v.String()
-		if str == "" {
-			return "<malformed>"
-		}
-		return str
-	}
-}
-
-// Double returns the float64 value for this element.
-// It panics if e's BSON type is not TypeDouble.
-func (v Value) Double() float64 {
-	if v.Type != TypeDouble {
-		panic(ElementTypeError{"bsoncore.Value.Double", v.Type})
-	}
-	f64, _, ok := ReadDouble(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return f64
-}
-
-// DoubleOK is the same as Double, but returns a boolean instead of panicking.
-func (v Value) DoubleOK() (float64, bool) {
-	if v.Type != TypeDouble {
-		return 0, false
-	}
-	f64, _, ok := ReadDouble(v.Data)
-	if !ok {
-		return 0, false
-	}
-	return f64, true
-}
-
-// StringValue returns the string balue for this element.
-// It panics if e's BSON type is not TypeString.
-//
-// NOTE: This method is called StringValue to avoid a collision with the String method which
-// implements the fmt.Stringer interface.
-func (v Value) StringValue() string {
-	if v.Type != TypeString {
-		panic(ElementTypeError{"bsoncore.Value.StringValue", v.Type})
-	}
-	str, _, ok := ReadString(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return str
-}
-
-// StringValueOK is the same as StringValue, but returns a boolean instead of
-// panicking.
-func (v Value) StringValueOK() (string, bool) {
-	if v.Type != TypeString {
-		return "", false
-	}
-	str, _, ok := ReadString(v.Data)
-	if !ok {
-		return "", false
-	}
-	return str, true
-}
-
-// Document returns the BSON document the Value represents as a Document. It panics if the
-// value is a BSON type other than document.
-func (v Value) Document() Document {
-	if v.Type != TypeEmbeddedDocument {
-		panic(ElementTypeError{"bsoncore.Value.Document", v.Type})
-	}
-	doc, _, ok := ReadDocument(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return doc
-}
-
-// DocumentOK is the same as Document, except it returns a boolean
-// instead of panicking.
-func (v Value) DocumentOK() (Document, bool) {
-	if v.Type != TypeEmbeddedDocument {
-		return nil, false
-	}
-	doc, _, ok := ReadDocument(v.Data)
-	if !ok {
-		return nil, false
-	}
-	return doc, true
-}
-
-// Array returns the BSON array the Value represents as an Array. It panics if the
-// value is a BSON type other than array.
-func (v Value) Array() Array {
-	if v.Type != TypeArray {
-		panic(ElementTypeError{"bsoncore.Value.Array", v.Type})
-	}
-	arr, _, ok := ReadArray(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return arr
-}
-
-// ArrayOK is the same as Array, except it returns a boolean instead
-// of panicking.
-func (v Value) ArrayOK() (Array, bool) {
-	if v.Type != TypeArray {
-		return nil, false
-	}
-	arr, _, ok := ReadArray(v.Data)
-	if !ok {
-		return nil, false
-	}
-	return arr, true
-}
-
-// Binary returns the BSON binary value the Value represents. It panics if the value is a BSON type
-// other than binary.
-func (v Value) Binary() (subtype byte, data []byte) {
-	if v.Type != TypeBinary {
-		panic(ElementTypeError{"bsoncore.Value.Binary", v.Type})
-	}
-	subtype, data, _, ok := ReadBinary(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return subtype, data
-}
-
-// BinaryOK is the same as Binary, except it returns a boolean instead of
-// panicking.
-func (v Value) BinaryOK() (subtype byte, data []byte, ok bool) {
-	if v.Type != TypeBinary {
-		return 0x00, nil, false
-	}
-	subtype, data, _, ok = ReadBinary(v.Data)
-	if !ok {
-		return 0x00, nil, false
-	}
-	return subtype, data, true
-}
-
-// ObjectID returns the BSON objectid value the Value represents. It panics if the value is a BSON
-// type other than objectid.
-func (v Value) ObjectID() objectID {
-	if v.Type != TypeObjectID {
-		panic(ElementTypeError{"bsoncore.Value.ObjectID", v.Type})
-	}
-	oid, _, ok := ReadObjectID(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return oid
-}
-
-// ObjectIDOK is the same as ObjectID, except it returns a boolean instead of
-// panicking.
-func (v Value) ObjectIDOK() (objectID, bool) {
-	if v.Type != TypeObjectID {
-		return objectID{}, false
-	}
-	oid, _, ok := ReadObjectID(v.Data)
-	if !ok {
-		return objectID{}, false
-	}
-	return oid, true
-}
-
-// Boolean returns the boolean value the Value represents. It panics if the
-// value is a BSON type other than boolean.
-func (v Value) Boolean() bool {
-	if v.Type != TypeBoolean {
-		panic(ElementTypeError{"bsoncore.Value.Boolean", v.Type})
-	}
-	b, _, ok := ReadBoolean(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return b
-}
-
-// BooleanOK is the same as Boolean, except it returns a boolean instead of
-// panicking.
-func (v Value) BooleanOK() (bool, bool) {
-	if v.Type != TypeBoolean {
-		return false, false
-	}
-	b, _, ok := ReadBoolean(v.Data)
-	if !ok {
-		return false, false
-	}
-	return b, true
-}
-
-// DateTime returns the BSON datetime value the Value represents as a
-// unix timestamp. It panics if the value is a BSON type other than datetime.
-func (v Value) DateTime() int64 {
-	if v.Type != TypeDateTime {
-		panic(ElementTypeError{"bsoncore.Value.DateTime", v.Type})
-	}
-	dt, _, ok := ReadDateTime(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return dt
-}
-
-// DateTimeOK is the same as DateTime, except it returns a boolean instead of
-// panicking.
-func (v Value) DateTimeOK() (int64, bool) {
-	if v.Type != TypeDateTime {
-		return 0, false
-	}
-	dt, _, ok := ReadDateTime(v.Data)
-	if !ok {
-		return 0, false
-	}
-	return dt, true
-}
-
-// Time returns the BSON datetime value the Value represents. It panics if the value is a BSON
-// type other than datetime.
-func (v Value) Time() time.Time {
-	if v.Type != TypeDateTime {
-		panic(ElementTypeError{"bsoncore.Value.Time", v.Type})
-	}
-	dt, _, ok := ReadDateTime(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return time.Unix(dt/1000, dt%1000*1000000)
-}
-
-// TimeOK is the same as Time, except it returns a boolean instead of
-// panicking.
-func (v Value) TimeOK() (time.Time, bool) {
-	if v.Type != TypeDateTime {
-		return time.Time{}, false
-	}
-	dt, _, ok := ReadDateTime(v.Data)
-	if !ok {
-		return time.Time{}, false
-	}
-	return time.Unix(dt/1000, dt%1000*1000000), true
-}
-
-// Regex returns the BSON regex value the Value represents. It panics if the value is a BSON
-// type other than regex.
-func (v Value) Regex() (pattern, options string) {
-	if v.Type != TypeRegex {
-		panic(ElementTypeError{"bsoncore.Value.Regex", v.Type})
-	}
-	pattern, options, _, ok := ReadRegex(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return pattern, options
-}
-
-// RegexOK is the same as Regex, except it returns a boolean instead of
-// panicking.
-func (v Value) RegexOK() (pattern, options string, ok bool) {
-	if v.Type != TypeRegex {
-		return "", "", false
-	}
-	pattern, options, _, ok = ReadRegex(v.Data)
-	if !ok {
-		return "", "", false
-	}
-	return pattern, options, true
-}
-
-// DBPointer returns the BSON dbpointer value the Value represents. It panics if the value is a BSON
-// type other than DBPointer.
-func (v Value) DBPointer() (string, objectID) {
-	if v.Type != TypeDBPointer {
-		panic(ElementTypeError{"bsoncore.Value.DBPointer", v.Type})
-	}
-	ns, pointer, _, ok := ReadDBPointer(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return ns, pointer
-}
-
-// DBPointerOK is the same as DBPoitner, except that it returns a boolean
-// instead of panicking.
-func (v Value) DBPointerOK() (string, objectID, bool) {
-	if v.Type != TypeDBPointer {
-		return "", objectID{}, false
-	}
-	ns, pointer, _, ok := ReadDBPointer(v.Data)
-	if !ok {
-		return "", objectID{}, false
-	}
-	return ns, pointer, true
-}
-
-// JavaScript returns the BSON JavaScript code value the Value represents. It panics if the value is
-// a BSON type other than JavaScript code.
-func (v Value) JavaScript() string {
-	if v.Type != TypeJavaScript {
-		panic(ElementTypeError{"bsoncore.Value.JavaScript", v.Type})
-	}
-	js, _, ok := ReadJavaScript(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return js
-}
-
-// JavaScriptOK is the same as Javascript, excepti that it returns a boolean
-// instead of panicking.
-func (v Value) JavaScriptOK() (string, bool) {
-	if v.Type != TypeJavaScript {
-		return "", false
-	}
-	js, _, ok := ReadJavaScript(v.Data)
-	if !ok {
-		return "", false
-	}
-	return js, true
-}
-
-// Symbol returns the BSON symbol value the Value represents. It panics if the value is a BSON
-// type other than symbol.
-func (v Value) Symbol() string {
-	if v.Type != TypeSymbol {
-		panic(ElementTypeError{"bsoncore.Value.Symbol", v.Type})
-	}
-	symbol, _, ok := ReadSymbol(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return symbol
-}
-
-// SymbolOK is the same as Symbol, excepti that it returns a boolean
-// instead of panicking.
-func (v Value) SymbolOK() (string, bool) {
-	if v.Type != TypeSymbol {
-		return "", false
-	}
-	symbol, _, ok := ReadSymbol(v.Data)
-	if !ok {
-		return "", false
-	}
-	return symbol, true
-}
-
-// CodeWithScope returns the BSON JavaScript code with scope the Value represents.
-// It panics if the value is a BSON type other than JavaScript code with scope.
-func (v Value) CodeWithScope() (string, Document) {
-	if v.Type != TypeCodeWithScope {
-		panic(ElementTypeError{"bsoncore.Value.CodeWithScope", v.Type})
-	}
-	code, scope, _, ok := ReadCodeWithScope(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return code, scope
-}
-
-// CodeWithScopeOK is the same as CodeWithScope, except that it returns a boolean instead of
-// panicking.
-func (v Value) CodeWithScopeOK() (string, Document, bool) {
-	if v.Type != TypeCodeWithScope {
-		return "", nil, false
-	}
-	code, scope, _, ok := ReadCodeWithScope(v.Data)
-	if !ok {
-		return "", nil, false
-	}
-	return code, scope, true
-}
-
-// Int32 returns the int32 the Value represents. It panics if the value is a BSON type other than
-// int32.
-func (v Value) Int32() int32 {
-	if v.Type != TypeInt32 {
-		panic(ElementTypeError{"bsoncore.Value.Int32", v.Type})
-	}
-	i32, _, ok := ReadInt32(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return i32
-}
-
-// Int32OK is the same as Int32, except that it returns a boolean instead of
-// panicking.
-func (v Value) Int32OK() (int32, bool) {
-	if v.Type != TypeInt32 {
-		return 0, false
-	}
-	i32, _, ok := ReadInt32(v.Data)
-	if !ok {
-		return 0, false
-	}
-	return i32, true
-}
-
-// Timestamp returns the BSON timestamp value the Value represents. It panics if the value is a
-// BSON type other than timestamp.
-func (v Value) Timestamp() (t, i uint32) {
-	if v.Type != TypeTimestamp {
-		panic(ElementTypeError{"bsoncore.Value.Timestamp", v.Type})
-	}
-	t, i, _, ok := ReadTimestamp(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return t, i
-}
-
-// TimestampOK is the same as Timestamp, except that it returns a boolean
-// instead of panicking.
-func (v Value) TimestampOK() (t, i uint32, ok bool) {
-	if v.Type != TypeTimestamp {
-		return 0, 0, false
-	}
-	t, i, _, ok = ReadTimestamp(v.Data)
-	if !ok {
-		return 0, 0, false
-	}
-	return t, i, true
-}
-
-// Int64 returns the int64 the Value represents. It panics if the value is a BSON type other than
-// int64.
-func (v Value) Int64() int64 {
-	if v.Type != TypeInt64 {
-		panic(ElementTypeError{"bsoncore.Value.Int64", v.Type})
-	}
-	i64, _, ok := ReadInt64(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return i64
-}
-
-// Int64OK is the same as Int64, except that it returns a boolean instead of
-// panicking.
-func (v Value) Int64OK() (int64, bool) {
-	if v.Type != TypeInt64 {
-		return 0, false
-	}
-	i64, _, ok := ReadInt64(v.Data)
-	if !ok {
-		return 0, false
-	}
-	return i64, true
-}
-
-// Decimal128 returns the decimal the Value represents. It panics if the value is a BSON type other than
-// decimal.
-func (v Value) Decimal128() (uint64, uint64) {
-	if v.Type != TypeDecimal128 {
-		panic(ElementTypeError{"bsoncore.Value.Decimal128", v.Type})
-	}
-	h, l, _, ok := ReadDecimal128(v.Data)
-	if !ok {
-		panic(NewInsufficientBytesError(v.Data, v.Data))
-	}
-	return h, l
-}
-
-// Decimal128OK is the same as Decimal128, except that it returns a boolean
-// instead of panicking.
-func (v Value) Decimal128OK() (uint64, uint64, bool) {
-	if v.Type != TypeDecimal128 {
-		return 0, 0, false
-	}
-	h, l, _, ok := ReadDecimal128(v.Data)
-	if !ok {
-		return 0, 0, false
-	}
-	return h, l, true
-}
-
-var hexChars = "0123456789abcdef"
-
-func escapeString(s string) string {
-	escapeHTML := true
-	var buf bytes.Buffer
-	buf.WriteByte('"')
-	start := 0
-	for i := 0; i < len(s); {
-		if b := s[i]; b < utf8.RuneSelf {
-			if htmlSafeSet[b] || (!escapeHTML && safeSet[b]) {
-				i++
-				continue
-			}
-			if start < i {
-				buf.WriteString(s[start:i])
-			}
-			switch b {
-			case '\\', '"':
-				buf.WriteByte('\\')
-				buf.WriteByte(b)
-			case '\n':
-				buf.WriteByte('\\')
-				buf.WriteByte('n')
-			case '\r':
-				buf.WriteByte('\\')
-				buf.WriteByte('r')
-			case '\t':
-				buf.WriteByte('\\')
-				buf.WriteByte('t')
-			case '\b':
-				buf.WriteByte('\\')
-				buf.WriteByte('b')
-			case '\f':
-				buf.WriteByte('\\')
-				buf.WriteByte('f')
-			default:
-				// This encodes bytes < 0x20 except for \t, \n and \r.
-				// If escapeHTML is set, it also escapes <, >, and &
-				// because they can lead to security holes when
-				// user-controlled strings are rendered into JSON
-				// and served to some browsers.
-				buf.WriteString(`\u00`)
-				buf.WriteByte(hexChars[b>>4])
-				buf.WriteByte(hexChars[b&0xF])
-			}
-			i++
-			start = i
-			continue
-		}
-		c, size := utf8.DecodeRuneInString(s[i:])
-		if c == utf8.RuneError && size == 1 {
-			if start < i {
-				buf.WriteString(s[start:i])
-			}
-			buf.WriteString(`\ufffd`)
-			i += size
-			start = i
-			continue
-		}
-		// U+2028 is LINE SEPARATOR.
-		// U+2029 is PARAGRAPH SEPARATOR.
-		// They are both technically valid characters in JSON strings,
-		// but don't work in JSONP, which has to be evaluated as JavaScript,
-		// and can lead to security holes there. It is valid JSON to
-		// escape them, so we do so unconditionally.
-		// See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
-		if c == '\u2028' || c == '\u2029' {
-			if start < i {
-				buf.WriteString(s[start:i])
-			}
-			buf.WriteString(`\u202`)
-			buf.WriteByte(hexChars[c&0xF])
-			i += size
-			start = i
-			continue
-		}
-		i += size
-	}
-	if start < len(s) {
-		buf.WriteString(s[start:])
-	}
-	buf.WriteByte('"')
-	return buf.String()
-}
-
-func formatDouble(f float64) string {
-	var s string
-	switch {
-	case math.IsInf(f, 1):
-		s = "Infinity"
-	case math.IsInf(f, -1):
-		s = "-Infinity"
-	case math.IsNaN(f):
-		s = "NaN"
-	default:
-		// Print exactly one decimalType place for integers; otherwise, print as many are necessary to
-		// perfectly represent it.
-		s = strconv.FormatFloat(f, 'G', -1, 64)
-		if !strings.ContainsRune(s, '.') {
-			s += ".0"
-		}
-	}
-
-	return s
-}
-
-type sortableString []rune
-
-func (ss sortableString) Len() int {
-	return len(ss)
-}
-
-func (ss sortableString) Less(i, j int) bool {
-	return ss[i] < ss[j]
-}
-
-func (ss sortableString) Swap(i, j int) {
-	ss[i], ss[j] = ss[j], ss[i]
-}
-
-func sortStringAlphebeticAscending(s string) string {
-	ss := sortableString([]rune(s))
-	sort.Sort(ss)
-	return string([]rune(ss))
-}
diff --git a/vendor/golang.org/x/sys/cpu/asm_darwin_x86_gc.s b/vendor/golang.org/x/sys/cpu/asm_darwin_x86_gc.s
deleted file mode 100644
index ec2acfe5..00000000
--- a/vendor/golang.org/x/sys/cpu/asm_darwin_x86_gc.s
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build darwin && amd64 && gc
-
-#include "textflag.h"
-
-TEXT libc_sysctl_trampoline<>(SB),NOSPLIT,$0-0
-	JMP	libc_sysctl(SB)
-GLOBL	·libc_sysctl_trampoline_addr(SB), RODATA, $8
-DATA	·libc_sysctl_trampoline_addr(SB)/8, $libc_sysctl_trampoline<>(SB)
-
-TEXT libc_sysctlbyname_trampoline<>(SB),NOSPLIT,$0-0
-	JMP	libc_sysctlbyname(SB)
-GLOBL	·libc_sysctlbyname_trampoline_addr(SB), RODATA, $8
-DATA	·libc_sysctlbyname_trampoline_addr(SB)/8, $libc_sysctlbyname_trampoline<>(SB)
diff --git a/vendor/golang.org/x/sys/cpu/cpu_darwin_x86.go b/vendor/golang.org/x/sys/cpu/cpu_darwin_x86.go
deleted file mode 100644
index b838cb9e..00000000
--- a/vendor/golang.org/x/sys/cpu/cpu_darwin_x86.go
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build darwin && amd64 && gc
-
-package cpu
-
-// darwinSupportsAVX512 checks Darwin kernel for AVX512 support via sysctl
-// call (see issue 43089). It also restricts AVX512 support for Darwin to
-// kernel version 21.3.0 (MacOS 12.2.0) or later (see issue 49233).
-//
-// Background:
-// Darwin implements a special mechanism to economize on thread state when
-// AVX512 specific registers are not in use. This scheme minimizes state when
-// preempting threads that haven't yet used any AVX512 instructions, but adds
-// special requirements to check for AVX512 hardware support at runtime (e.g.
-// via sysctl call or commpage inspection). See issue 43089 and link below for
-// full background:
-// https://github.com/apple-oss-distributions/xnu/blob/xnu-11215.1.10/osfmk/i386/fpu.c#L214-L240
-//
-// Additionally, all versions of the Darwin kernel from 19.6.0 through 21.2.0
-// (corresponding to MacOS 10.15.6 - 12.1) have a bug that can cause corruption
-// of the AVX512 mask registers (K0-K7) upon signal return. For this reason
-// AVX512 is considered unsafe to use on Darwin for kernel versions prior to
-// 21.3.0, where a fix has been confirmed. See issue 49233 for full background.
-func darwinSupportsAVX512() bool {
-	return darwinSysctlEnabled([]byte("hw.optional.avx512f\x00")) && darwinKernelVersionCheck(21, 3, 0)
-}
-
-// Ensure Darwin kernel version is at least major.minor.patch, avoiding dependencies
-func darwinKernelVersionCheck(major, minor, patch int) bool {
-	var release [256]byte
-	err := darwinOSRelease(&release)
-	if err != nil {
-		return false
-	}
-
-	var mmp [3]int
-	c := 0
-Loop:
-	for _, b := range release[:] {
-		switch {
-		case b >= '0' && b <= '9':
-			mmp[c] = 10*mmp[c] + int(b-'0')
-		case b == '.':
-			c++
-			if c > 2 {
-				return false
-			}
-		case b == 0:
-			break Loop
-		default:
-			return false
-		}
-	}
-	if c != 2 {
-		return false
-	}
-	return mmp[0] > major || mmp[0] == major && (mmp[1] > minor || mmp[1] == minor && mmp[2] >= patch)
-}
diff --git a/vendor/golang.org/x/sys/cpu/cpu_gc_x86.s b/vendor/golang.org/x/sys/cpu/cpu_gc_x86.s
deleted file mode 100644
index ce208ce6..00000000
--- a/vendor/golang.org/x/sys/cpu/cpu_gc_x86.s
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build (386 || amd64 || amd64p32) && gc
-
-#include "textflag.h"
-
-// func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32)
-TEXT ·cpuid(SB), NOSPLIT, $0-24
-	MOVL eaxArg+0(FP), AX
-	MOVL ecxArg+4(FP), CX
-	CPUID
-	MOVL AX, eax+8(FP)
-	MOVL BX, ebx+12(FP)
-	MOVL CX, ecx+16(FP)
-	MOVL DX, edx+20(FP)
-	RET
-
-// func xgetbv() (eax, edx uint32)
-TEXT ·xgetbv(SB), NOSPLIT, $0-8
-	MOVL $0, CX
-	XGETBV
-	MOVL AX, eax+0(FP)
-	MOVL DX, edx+4(FP)
-	RET
diff --git a/vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go b/vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go
deleted file mode 100644
index cb4a0c57..00000000
--- a/vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go
+++ /dev/null
@@ -1,137 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package cpu
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-// RISC-V extension discovery code for Linux. The approach here is to first try the riscv_hwprobe
-// syscall falling back to HWCAP to check for the C extension if riscv_hwprobe is not available.
-//
-// A note on detection of the Vector extension using HWCAP.
-//
-// Support for the Vector extension version 1.0 was added to the Linux kernel in release 6.5.
-// Support for the riscv_hwprobe syscall was added in 6.4. It follows that if the riscv_hwprobe
-// syscall is not available then neither is the Vector extension (which needs kernel support).
-// The riscv_hwprobe syscall should then be all we need to detect the Vector extension.
-// However, some RISC-V board manufacturers ship boards with an older kernel on top of which
-// they have back-ported various versions of the Vector extension patches but not the riscv_hwprobe
-// patches. These kernels advertise support for the Vector extension using HWCAP. Falling
-// back to HWCAP to detect the Vector extension, if riscv_hwprobe is not available, or simply not
-// bothering with riscv_hwprobe at all and just using HWCAP may then seem like an attractive option.
-//
-// Unfortunately, simply checking the 'V' bit in AT_HWCAP will not work as this bit is used by
-// RISC-V board and cloud instance providers to mean different things. The Lichee Pi 4A board
-// and the Scaleway RV1 cloud instances use the 'V' bit to advertise their support for the unratified
-// 0.7.1 version of the Vector Specification. The Banana Pi BPI-F3 and the CanMV-K230 board use
-// it to advertise support for 1.0 of the Vector extension. Versions 0.7.1 and 1.0 of the Vector
-// extension are binary incompatible. HWCAP can then not be used in isolation to populate the
-// HasV field as this field indicates that the underlying CPU is compatible with RVV 1.0.
-//
-// There is a way at runtime to distinguish between versions 0.7.1 and 1.0 of the Vector
-// specification by issuing a RVV 1.0 vsetvli instruction and checking the vill bit of the vtype
-// register. This check would allow us to safely detect version 1.0 of the Vector extension
-// with HWCAP, if riscv_hwprobe were not available. However, the check cannot
-// be added until the assembler supports the Vector instructions.
-//
-// Note the riscv_hwprobe syscall does not suffer from these ambiguities by design as all of the
-// extensions it advertises support for are explicitly versioned. It's also worth noting that
-// the riscv_hwprobe syscall is the only way to detect multi-letter RISC-V extensions, e.g., Zba.
-// These cannot be detected using HWCAP and so riscv_hwprobe must be used to detect the majority
-// of RISC-V extensions.
-//
-// Please see https://docs.kernel.org/arch/riscv/hwprobe.html for more information.
-
-// golang.org/x/sys/cpu is not allowed to depend on golang.org/x/sys/unix so we must
-// reproduce the constants, types and functions needed to make the riscv_hwprobe syscall
-// here.
-
-const (
-	// Copied from golang.org/x/sys/unix/ztypes_linux_riscv64.go.
-	riscv_HWPROBE_KEY_IMA_EXT_0   = 0x4
-	riscv_HWPROBE_IMA_C           = 0x2
-	riscv_HWPROBE_IMA_V           = 0x4
-	riscv_HWPROBE_EXT_ZBA         = 0x8
-	riscv_HWPROBE_EXT_ZBB         = 0x10
-	riscv_HWPROBE_EXT_ZBS         = 0x20
-	riscv_HWPROBE_KEY_CPUPERF_0   = 0x5
-	riscv_HWPROBE_MISALIGNED_FAST = 0x3
-	riscv_HWPROBE_MISALIGNED_MASK = 0x7
-)
-
-const (
-	// sys_RISCV_HWPROBE is copied from golang.org/x/sys/unix/zsysnum_linux_riscv64.go.
-	sys_RISCV_HWPROBE = 258
-)
-
-// riscvHWProbePairs is copied from golang.org/x/sys/unix/ztypes_linux_riscv64.go.
-type riscvHWProbePairs struct {
-	key   int64
-	value uint64
-}
-
-const (
-	// CPU features
-	hwcap_RISCV_ISA_C = 1 << ('C' - 'A')
-)
-
-func doinit() {
-	// A slice of key/value pair structures is passed to the RISCVHWProbe syscall. The key
-	// field should be initialised with one of the key constants defined above, e.g.,
-	// RISCV_HWPROBE_KEY_IMA_EXT_0. The syscall will set the value field to the appropriate value.
-	// If the kernel does not recognise a key it will set the key field to -1 and the value field to 0.
-
-	pairs := []riscvHWProbePairs{
-		{riscv_HWPROBE_KEY_IMA_EXT_0, 0},
-		{riscv_HWPROBE_KEY_CPUPERF_0, 0},
-	}
-
-	// This call only indicates that extensions are supported if they are implemented on all cores.
-	if riscvHWProbe(pairs, 0) {
-		if pairs[0].key != -1 {
-			v := uint(pairs[0].value)
-			RISCV64.HasC = isSet(v, riscv_HWPROBE_IMA_C)
-			RISCV64.HasV = isSet(v, riscv_HWPROBE_IMA_V)
-			RISCV64.HasZba = isSet(v, riscv_HWPROBE_EXT_ZBA)
-			RISCV64.HasZbb = isSet(v, riscv_HWPROBE_EXT_ZBB)
-			RISCV64.HasZbs = isSet(v, riscv_HWPROBE_EXT_ZBS)
-		}
-		if pairs[1].key != -1 {
-			v := pairs[1].value & riscv_HWPROBE_MISALIGNED_MASK
-			RISCV64.HasFastMisaligned = v == riscv_HWPROBE_MISALIGNED_FAST
-		}
-	}
-
-	// Let's double check with HWCAP if the C extension does not appear to be supported.
-	// This may happen if we're running on a kernel older than 6.4.
-
-	if !RISCV64.HasC {
-		RISCV64.HasC = isSet(hwCap, hwcap_RISCV_ISA_C)
-	}
-}
-
-func isSet(hwc uint, value uint) bool {
-	return hwc&value != 0
-}
-
-// riscvHWProbe is a simplified version of the generated wrapper function found in
-// golang.org/x/sys/unix/zsyscall_linux_riscv64.go. We simplify it by removing the
-// cpuCount and cpus parameters which we do not need. We always want to pass 0 for
-// these parameters here so the kernel only reports the extensions that are present
-// on all cores.
-func riscvHWProbe(pairs []riscvHWProbePairs, flags uint) bool {
-	var _zero uintptr
-	var p0 unsafe.Pointer
-	if len(pairs) > 0 {
-		p0 = unsafe.Pointer(&pairs[0])
-	} else {
-		p0 = unsafe.Pointer(&_zero)
-	}
-
-	_, _, e1 := syscall.Syscall6(sys_RISCV_HWPROBE, uintptr(p0), uintptr(len(pairs)), uintptr(0), uintptr(0), uintptr(flags), 0)
-	return e1 == 0
-}
diff --git a/vendor/golang.org/x/sys/cpu/cpu_other_x86.go b/vendor/golang.org/x/sys/cpu/cpu_other_x86.go
deleted file mode 100644
index a0fd7e2f..00000000
--- a/vendor/golang.org/x/sys/cpu/cpu_other_x86.go
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build 386 || amd64p32 || (amd64 && (!darwin || !gc))
-
-package cpu
-
-func darwinSupportsAVX512() bool {
-	panic("only implemented for gc && amd64 && darwin")
-}
diff --git a/vendor/golang.org/x/sys/cpu/syscall_darwin_x86_gc.go b/vendor/golang.org/x/sys/cpu/syscall_darwin_x86_gc.go
deleted file mode 100644
index 4d0888b0..00000000
--- a/vendor/golang.org/x/sys/cpu/syscall_darwin_x86_gc.go
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Minimal copy of x/sys/unix so the cpu package can make a
-// system call on Darwin without depending on x/sys/unix.
-
-//go:build darwin && amd64 && gc
-
-package cpu
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-type _C_int int32
-
-// adapted from unix.Uname() at x/sys/unix/syscall_darwin.go L419
-func darwinOSRelease(release *[256]byte) error {
-	// from x/sys/unix/zerrors_openbsd_amd64.go
-	const (
-		CTL_KERN       = 0x1
-		KERN_OSRELEASE = 0x2
-	)
-
-	mib := []_C_int{CTL_KERN, KERN_OSRELEASE}
-	n := unsafe.Sizeof(*release)
-
-	return sysctl(mib, &release[0], &n, nil, 0)
-}
-
-type Errno = syscall.Errno
-
-var _zero uintptr // Single-word zero for use when we need a valid pointer to 0 bytes.
-
-// from x/sys/unix/zsyscall_darwin_amd64.go L791-807
-func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) error {
-	var _p0 unsafe.Pointer
-	if len(mib) > 0 {
-		_p0 = unsafe.Pointer(&mib[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	if _, _, err := syscall_syscall6(
-		libc_sysctl_trampoline_addr,
-		uintptr(_p0),
-		uintptr(len(mib)),
-		uintptr(unsafe.Pointer(old)),
-		uintptr(unsafe.Pointer(oldlen)),
-		uintptr(unsafe.Pointer(new)),
-		uintptr(newlen),
-	); err != 0 {
-		return err
-	}
-
-	return nil
-}
-
-var libc_sysctl_trampoline_addr uintptr
-
-// adapted from internal/cpu/cpu_arm64_darwin.go
-func darwinSysctlEnabled(name []byte) bool {
-	out := int32(0)
-	nout := unsafe.Sizeof(out)
-	if ret := sysctlbyname(&name[0], (*byte)(unsafe.Pointer(&out)), &nout, nil, 0); ret != nil {
-		return false
-	}
-	return out > 0
-}
-
-//go:cgo_import_dynamic libc_sysctl sysctl "/usr/lib/libSystem.B.dylib"
-
-var libc_sysctlbyname_trampoline_addr uintptr
-
-// adapted from runtime/sys_darwin.go in the pattern of sysctl() above, as defined in x/sys/unix
-func sysctlbyname(name *byte, old *byte, oldlen *uintptr, new *byte, newlen uintptr) error {
-	if _, _, err := syscall_syscall6(
-		libc_sysctlbyname_trampoline_addr,
-		uintptr(unsafe.Pointer(name)),
-		uintptr(unsafe.Pointer(old)),
-		uintptr(unsafe.Pointer(oldlen)),
-		uintptr(unsafe.Pointer(new)),
-		uintptr(newlen),
-		0,
-	); err != 0 {
-		return err
-	}
-
-	return nil
-}
-
-//go:cgo_import_dynamic libc_sysctlbyname sysctlbyname "/usr/lib/libSystem.B.dylib"
-
-// Implemented in the runtime package (runtime/sys_darwin.go)
-func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
-
-//go:linkname syscall_syscall6 syscall.syscall6
diff --git a/vendor/golang.org/x/sys/unix/auxv.go b/vendor/golang.org/x/sys/unix/auxv.go
deleted file mode 100644
index 37a82528..00000000
--- a/vendor/golang.org/x/sys/unix/auxv.go
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2025 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build go1.21 && (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos)
-
-package unix
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-//go:linkname runtime_getAuxv runtime.getAuxv
-func runtime_getAuxv() []uintptr
-
-// Auxv returns the ELF auxiliary vector as a sequence of key/value pairs.
-// The returned slice is always a fresh copy, owned by the caller.
-// It returns an error on non-ELF platforms, or if the auxiliary vector cannot be accessed,
-// which happens in some locked-down environments and build modes.
-func Auxv() ([][2]uintptr, error) {
-	vec := runtime_getAuxv()
-	vecLen := len(vec)
-
-	if vecLen == 0 {
-		return nil, syscall.ENOENT
-	}
-
-	if vecLen%2 != 0 {
-		return nil, syscall.EINVAL
-	}
-
-	result := make([]uintptr, vecLen)
-	copy(result, vec)
-	return unsafe.Slice((*[2]uintptr)(unsafe.Pointer(&result[0])), vecLen/2), nil
-}
diff --git a/vendor/golang.org/x/sys/unix/auxv_unsupported.go b/vendor/golang.org/x/sys/unix/auxv_unsupported.go
deleted file mode 100644
index 1200487f..00000000
--- a/vendor/golang.org/x/sys/unix/auxv_unsupported.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2025 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build !go1.21 && (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos)
-
-package unix
-
-import "syscall"
-
-func Auxv() ([][2]uintptr, error) {
-	return nil, syscall.ENOTSUP
-}
diff --git a/vendor/golang.org/x/sys/unix/vgetrandom_linux.go b/vendor/golang.org/x/sys/unix/vgetrandom_linux.go
deleted file mode 100644
index 07ac8e09..00000000
--- a/vendor/golang.org/x/sys/unix/vgetrandom_linux.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build linux && go1.24
-
-package unix
-
-import _ "unsafe"
-
-//go:linkname vgetrandom runtime.vgetrandom
-//go:noescape
-func vgetrandom(p []byte, flags uint32) (ret int, supported bool)
diff --git a/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go b/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go
deleted file mode 100644
index 297e97bc..00000000
--- a/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build !linux || !go1.24
-
-package unix
-
-func vgetrandom(p []byte, flags uint32) (ret int, supported bool) {
-	return -1, false
-}

From f28c72fabece00a8f94ac5780c7db1ac65e41f2f Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Tue, 19 Aug 2025 14:03:15 -0400
Subject: [PATCH 21/32] =?UTF-8?q?=E2=80=9Ctrue=E2=80=9D=20doc=20key?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 dockey/agg.go                        |  4 ++--
 internal/verifier/compare.go         | 15 ++++++++++++---
 internal/verifier/dockey_agg_test.go |  2 +-
 3 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/dockey/agg.go b/dockey/agg.go
index 9db17a0c..af5ba076 100644
--- a/dockey/agg.go
+++ b/dockey/agg.go
@@ -12,13 +12,13 @@ import (
 	"go.mongodb.org/mongo-driver/bson"
 )
 
-// ExtractDocKeyAgg returns an aggregation expression that extracts the
+// ExtractTrueDocKeyAgg returns an aggregation expression that extracts the
 // document key from the document to which the `docExpr` refers.
 //
 // NB: This avoids the problem documented in SERVER-109340; as a result,
 // the returned key may not always match the change stream’s `documentKey`
 // (because the server misreports its own sharding logic).
-func ExtractDocKeyAgg(fieldNames []string, docExpr string) bson.D {
+func ExtractTrueDocKeyAgg(fieldNames []string, docExpr string) bson.D {
 	var docKeyNumKeys bson.D
 	numToKeyLookup := map[string]string{}
 
diff --git a/internal/verifier/compare.go b/internal/verifier/compare.go
index d90e179c..86a2c2e6 100644
--- a/internal/verifier/compare.go
+++ b/internal/verifier/compare.go
@@ -378,12 +378,15 @@ func getDocKeyValues(
 
 	switch docCompareMethod {
 	case DocCompareBinary, DocCompareIgnoreOrder:
+		// If we have the full document, create the document key manually:
 		var err error
-		docKey, err = extractDocKeyFromDoc(fieldNames, doc)
+		docKey, err = extractTrueDocKeyFromDoc(fieldNames, doc)
 		if err != nil {
 			return nil, err
 		}
 	case DocCompareToHashedIndexKey:
+		// If we have a hash, then the aggregation should have extracted the
+		// document key for us.
 		docKeyVal, err := doc.LookupErr(docKeyInHashedCompare)
 		if err != nil {
 			return nil, errors.Wrapf(err, "fetching %#q from doc %v", docKeyInHashedCompare, doc)
@@ -425,15 +428,21 @@ func getDocKeyValues(
 // NB: This avoids the problem documented in SERVER-109340; as a result,
 // the returned key may not always match the change stream’s `documentKey`
 // (because the server misreports its own sharding logic).
-func extractDocKeyFromDoc(
+func extractTrueDocKeyFromDoc(
 	fieldNames []string,
 	doc bson.Raw,
 ) (bson.Raw, error) {
 	var dk bson.D
 	for _, field := range fieldNames {
+
+		// This is how sharding routes documents: it always
+		// splits on the dot and looks deeply into the document.
 		parts := strings.Split(field, ".")
 		val, err := doc.LookupErr(parts...)
+
 		if errors.Is(err, bsoncore.ErrElementNotFound) {
+			// If the document lacks a value for this field
+			// then don’t add it to the document key.
 			continue
 		} else if err == nil {
 			dk = append(dk, bson.E{field, val})
@@ -713,7 +722,7 @@ func transformPipelineForToHashedIndexKey(
 		slices.Clone(in),
 		bson.D{{"$replaceWith", bson.D{
 			// Single-letter field names minimize the document size.
-			{docKeyInHashedCompare, dockey.ExtractDocKeyAgg(
+			{docKeyInHashedCompare, dockey.ExtractTrueDocKeyAgg(
 				task.QueryFilter.GetDocKeyFields(),
 				"$$ROOT",
 			)},
diff --git a/internal/verifier/dockey_agg_test.go b/internal/verifier/dockey_agg_test.go
index 26d719c3..8ae8244f 100644
--- a/internal/verifier/dockey_agg_test.go
+++ b/internal/verifier/dockey_agg_test.go
@@ -128,7 +128,7 @@ func (suite *IntegrationTestSuite) TestExtractDocKeyAgg() {
 	).Err(),
 	)
 
-	computedDocKeyAgg := dockey.ExtractDocKeyAgg(
+	computedDocKeyAgg := dockey.ExtractTrueDocKeyAgg(
 		mslices.Of("foo.bar.baz", "_id"),
 		"$$ROOT.fullDocument",
 	)

From 0300b8b4cb71161d2a2ce47d3c7dd577a415101f Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Tue, 19 Aug 2025 14:10:59 -0400
Subject: [PATCH 22/32] fix DB name

---
 internal/verifier/dockey_agg_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/verifier/dockey_agg_test.go b/internal/verifier/dockey_agg_test.go
index 8ae8244f..ebf4c27c 100644
--- a/internal/verifier/dockey_agg_test.go
+++ b/internal/verifier/dockey_agg_test.go
@@ -98,7 +98,7 @@ func (suite *IntegrationTestSuite) TestExtractDocKeyAgg() {
 		t.Skip("Skipping against pre-v6 cluster.")
 	}
 
-	db := client.Database(t.Name())
+	db := client.Database(suite.DBNameForTest())
 	defer func() {
 		err := db.Drop(ctx)
 		if err != nil {

From 7c12d883b065b7191c542ea7f139c7519195ceaa Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Tue, 19 Aug 2025 14:36:56 -0400
Subject: [PATCH 23/32] fix test

---
 internal/verifier/dockey_agg_test.go | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/internal/verifier/dockey_agg_test.go b/internal/verifier/dockey_agg_test.go
index ebf4c27c..14482ae2 100644
--- a/internal/verifier/dockey_agg_test.go
+++ b/internal/verifier/dockey_agg_test.go
@@ -20,6 +20,7 @@ var testCases = []struct {
 }{
 	{
 		doc: bson.D{
+			{"_id", "abc"},
 			{"foo", bson.D{
 				{"bar", bson.D{{"baz", 1}}},
 				{"bar.baz", 2},
@@ -28,11 +29,13 @@ var testCases = []struct {
 			{"foo.bar.baz", 4},
 		},
 		docKey: bson.D{
+			{"_id", "abc"},
 			{"foo.bar.baz", int32(1)},
 		},
 	},
 	{
 		doc: bson.D{
+			{"_id", "bbb"},
 			{"foo", bson.D{
 				{"bar", bson.D{{"baz", 1}}},
 				{"bar.baz", 2},
@@ -40,27 +43,31 @@ var testCases = []struct {
 			{"foo.bar", bson.D{{"baz", 3}}},
 		},
 		docKey: bson.D{
+			{"_id", "bbb"},
 			{"foo.bar.baz", int32(1)},
 		},
 	},
 	{
 		doc: bson.D{
+			{"_id", "ccc"},
 			{"foo", bson.D{
 				{"bar.baz", 2},
 			}},
 			{"foo.bar", bson.D{{"baz", 3}}},
 		},
 		docKey: bson.D{
-			{}, // _id only
+			{"_id", "ccc"},
 		},
 	},
 	{
 		doc: bson.D{
+			{"_id", "ddd"},
 			{"foo", bson.D{
 				{"bar", bson.D{{"baz", nil}}},
 			}},
 		},
 		docKey: bson.D{
+			{"_id", "ddd"},
 			{"foo.bar.baz", nil},
 		},
 	},
@@ -129,8 +136,8 @@ func (suite *IntegrationTestSuite) TestExtractDocKeyAgg() {
 	)
 
 	computedDocKeyAgg := dockey.ExtractTrueDocKeyAgg(
-		mslices.Of("foo.bar.baz", "_id"),
-		"$$ROOT.fullDocument",
+		mslices.Of("_id", "foo.bar.baz"),
+		"$fullDocument",
 	)
 
 	ejson, _ := bson.MarshalExtJSON(computedDocKeyAgg, true, false)
@@ -172,7 +179,7 @@ func (suite *IntegrationTestSuite) TestExtractDocKeyAgg() {
 
 			assert.Equal(
 				t,
-				event.DocumentKey,
+				curCase.docKey,
 				event.ComputedDocKey,
 				"checking computed doc key for %v against server",
 				curCase.doc,

From ac2b99a12c14c07858400325445a1e7322a393ff Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Tue, 19 Aug 2025 14:53:00 -0400
Subject: [PATCH 24/32] compat with pre-v6

---
 internal/verifier/migration_verifier_test.go | 26 +++++++++++---------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/internal/verifier/migration_verifier_test.go b/internal/verifier/migration_verifier_test.go
index 2793e8e2..1bbe0c1c 100644
--- a/internal/verifier/migration_verifier_test.go
+++ b/internal/verifier/migration_verifier_test.go
@@ -152,27 +152,31 @@ func (suite *IntegrationTestSuite) TestVerifier_Dotted_Shard_Key() {
 		shardIds := getShardIds(suite.T(), client)
 
 		admin := client.Database("admin")
-		splitKey := bson.D{{"foo.bar.baz", 150}}
+		keyField := "foo.bar.baz"
+		splitKey := bson.D{{keyField, 150}}
+
 		require.NoError(
 			admin.RunCommand(ctx, bson.D{
-				{"moveRange", db.Name() + "." + coll.Name()},
-				{"toShard", shardIds[0]},
-				{"max", splitKey},
+				{"split", db.Name() + "." + coll.Name()},
+				{"middle", splitKey},
 			}).Err(),
 		)
 
 		require.NoError(
 			admin.RunCommand(ctx, bson.D{
-				{"moveRange", db.Name() + "." + coll.Name()},
-				{"toShard", shardIds[1]},
-				{"min", splitKey},
+				{"moveChunk", db.Name() + "." + coll.Name()},
+				{"to", shardIds[0]},
+				{"find", bson.D{{keyField, primitive.MinKey{}}}},
 			}).Err(),
 		)
 
-		fmt.Printf("inserting: %v\n\n", docs)
-
-		//fmt.Printf("-------- apused\n")
-		//time.Sleep(15 * time.Second)
+		require.NoError(
+			admin.RunCommand(ctx, bson.D{
+				{"moveChunk", db.Name() + "." + coll.Name()},
+				{"to", shardIds[1]},
+				{"find", bson.D{{keyField, primitive.MaxKey{}}}},
+			}).Err(),
+		)
 
 		_, err := coll.InsertMany(ctx, lo.ToAnySlice(lo.Shuffle(docs)))
 		require.NoError(err, "should insert all docs")

From 7bcddaaf913e6cd23fba3170c0f25bc351754f48 Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Tue, 19 Aug 2025 15:00:19 -0400
Subject: [PATCH 25/32] only sharded for now

---
 .github/workflows/all.yml                    | 16 ++++++++--------
 internal/verifier/migration_verifier_test.go |  4 ++--
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/all.yml b/.github/workflows/all.yml
index ced7c10d..36436ba0 100644
--- a/.github/workflows/all.yml
+++ b/.github/workflows/all.yml
@@ -61,14 +61,14 @@ jobs:
         toHashedIndexKey: [true, false]
 
         topology:
-          - name: replset
-            srcConnStr: mongodb://localhost:27020,localhost:27021,localhost:27022
-            dstConnStr: mongodb://localhost:27030,localhost:27031,localhost:27032
-
-          - name: replset-to-sharded
-            dstArgs: --sharded 2
-            srcConnStr: mongodb://localhost:27020,localhost:27021,localhost:27022
-            dstConnStr: mongodb://localhost:27030
+          #- name: replset
+          #  srcConnStr: mongodb://localhost:27020,localhost:27021,localhost:27022
+          #  dstConnStr: mongodb://localhost:27030,localhost:27031,localhost:27032
+#
+#          - name: replset-to-sharded
+#            dstArgs: --sharded 2
+#            srcConnStr: mongodb://localhost:27020,localhost:27021,localhost:27022
+#            dstConnStr: mongodb://localhost:27030
 
           - name: sharded
             srcArgs: --sharded 2
diff --git a/internal/verifier/migration_verifier_test.go b/internal/verifier/migration_verifier_test.go
index 1bbe0c1c..05928d58 100644
--- a/internal/verifier/migration_verifier_test.go
+++ b/internal/verifier/migration_verifier_test.go
@@ -166,7 +166,7 @@ func (suite *IntegrationTestSuite) TestVerifier_Dotted_Shard_Key() {
 			admin.RunCommand(ctx, bson.D{
 				{"moveChunk", db.Name() + "." + coll.Name()},
 				{"to", shardIds[0]},
-				{"find", bson.D{{keyField, primitive.MinKey{}}}},
+				{"find", bson.D{{keyField, 149}}},
 			}).Err(),
 		)
 
@@ -174,7 +174,7 @@ func (suite *IntegrationTestSuite) TestVerifier_Dotted_Shard_Key() {
 			admin.RunCommand(ctx, bson.D{
 				{"moveChunk", db.Name() + "." + coll.Name()},
 				{"to", shardIds[1]},
-				{"find", bson.D{{keyField, primitive.MaxKey{}}}},
+				{"find", bson.D{{keyField, 151}}},
 			}).Err(),
 		)
 

From 9f01a5fae69f757bbbc1ff202ee9ade0a75495c6 Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Tue, 19 Aug 2025 15:08:12 -0400
Subject: [PATCH 26/32] all CI

---
 .github/workflows/all.yml | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/all.yml b/.github/workflows/all.yml
index 36436ba0..ced7c10d 100644
--- a/.github/workflows/all.yml
+++ b/.github/workflows/all.yml
@@ -61,14 +61,14 @@ jobs:
         toHashedIndexKey: [true, false]
 
         topology:
-          #- name: replset
-          #  srcConnStr: mongodb://localhost:27020,localhost:27021,localhost:27022
-          #  dstConnStr: mongodb://localhost:27030,localhost:27031,localhost:27032
-#
-#          - name: replset-to-sharded
-#            dstArgs: --sharded 2
-#            srcConnStr: mongodb://localhost:27020,localhost:27021,localhost:27022
-#            dstConnStr: mongodb://localhost:27030
+          - name: replset
+            srcConnStr: mongodb://localhost:27020,localhost:27021,localhost:27022
+            dstConnStr: mongodb://localhost:27030,localhost:27031,localhost:27032
+
+          - name: replset-to-sharded
+            dstArgs: --sharded 2
+            srcConnStr: mongodb://localhost:27020,localhost:27021,localhost:27022
+            dstConnStr: mongodb://localhost:27030
 
           - name: sharded
             srcArgs: --sharded 2

From 54d347afba7ff6dc6294200ce7252e806700faef Mon Sep 17 00:00:00 2001
From: Felipe Gasper <FGasper@users.noreply.github.com>
Date: Tue, 19 Aug 2025 15:59:29 -0400
Subject: [PATCH 27/32] Update internal/verifier/dockey_agg_test.go

Co-authored-by: Michael McClimon <michael@mcclimon.org>
---
 internal/verifier/dockey_agg_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/verifier/dockey_agg_test.go b/internal/verifier/dockey_agg_test.go
index 14482ae2..e617b71f 100644
--- a/internal/verifier/dockey_agg_test.go
+++ b/internal/verifier/dockey_agg_test.go
@@ -170,7 +170,7 @@ func (suite *IntegrationTestSuite) TestExtractDocKeyAgg() {
 			require.NoError(bson.Unmarshal(changes.Current, &event))
 
 			if event.OperationType != "insert" {
-				t.Logf("Ignoring irrelevant-seeing event: %v", changes.Current)
+				t.Logf("Ignoring irrelevant-seeming event: %v", changes.Current)
 				continue
 			}
 

From 877a9ccb0d6c379a9dc6ca8b9a7009938df7d3ee Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Tue, 19 Aug 2025 16:33:13 -0400
Subject: [PATCH 28/32] refactor & add more tests

---
 dockey/raw.go                        |  45 +++++++
 dockey/raw_test.go                   |  35 +++++
 dockey/test/cases.go                 |  75 +++++++++++
 internal/verifier/compare.go         |  40 +-----
 internal/verifier/dockey_agg_test.go | 188 +++++----------------------
 5 files changed, 189 insertions(+), 194 deletions(-)
 create mode 100644 dockey/raw.go
 create mode 100644 dockey/raw_test.go
 create mode 100644 dockey/test/cases.go

diff --git a/dockey/raw.go b/dockey/raw.go
new file mode 100644
index 00000000..2c22cdd2
--- /dev/null
+++ b/dockey/raw.go
@@ -0,0 +1,45 @@
+package dockey
+
+import (
+	"strings"
+
+	"github.com/pkg/errors"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/x/bsonx/bsoncore"
+)
+
+// This extracts the document key from a document gets its field names.
+//
+// NB: This avoids the problem documented in SERVER-109340; as a result,
+// the returned key may not always match the change stream’s `documentKey`
+// (because the server misreports its own sharding logic).
+func ExtractTrueDocKeyFromDoc(
+	fieldNames []string,
+	doc bson.Raw,
+) (bson.Raw, error) {
+	var dk bson.D
+	for _, field := range fieldNames {
+
+		// This is how sharding routes documents: it always
+		// splits on the dot and looks deeply into the document.
+		parts := strings.Split(field, ".")
+		val, err := doc.LookupErr(parts...)
+
+		if errors.Is(err, bsoncore.ErrElementNotFound) || errors.As(err, &bsoncore.InvalidDepthTraversalError{}) {
+			// If the document lacks a value for this field
+			// then don’t add it to the document key.
+			continue
+		} else if err == nil {
+			dk = append(dk, bson.E{field, val})
+		} else {
+			return nil, errors.Wrapf(err, "extracting doc key field %#q from doc %+v", field, doc)
+		}
+	}
+
+	docKey, err := bson.Marshal(dk)
+	if err != nil {
+		return nil, errors.Wrapf(err, "marshaling doc key %v from doc %v", dk, docKey)
+	}
+
+	return docKey, nil
+}
diff --git a/dockey/raw_test.go b/dockey/raw_test.go
new file mode 100644
index 00000000..cc061f7a
--- /dev/null
+++ b/dockey/raw_test.go
@@ -0,0 +1,35 @@
+package dockey
+
+import (
+	"testing"
+
+	"github.com/10gen/migration-verifier/dockey/test"
+	"github.com/10gen/migration-verifier/mslices"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.mongodb.org/mongo-driver/bson"
+)
+
+func TestExtractTrueDocKeyFromDoc(t *testing.T) {
+	for _, curCase := range test.TestCases {
+		raw, err := bson.Marshal(curCase.Doc)
+		require.NoError(t, err)
+
+		computedRaw, err := ExtractTrueDocKeyFromDoc(
+			mslices.Of("_id", "foo.bar.baz"),
+			raw,
+		)
+		require.NoError(t, err)
+
+		var computedDocKey bson.D
+		require.NoError(t, bson.Unmarshal(computedRaw, &computedDocKey))
+
+		assert.Equal(
+			t,
+			curCase.DocKey,
+			computedDocKey,
+			"doc key for %v (got %v; expected %v)",
+			bson.Raw(raw),
+		)
+	}
+}
diff --git a/dockey/test/cases.go b/dockey/test/cases.go
new file mode 100644
index 00000000..455613d4
--- /dev/null
+++ b/dockey/test/cases.go
@@ -0,0 +1,75 @@
+package test
+
+import (
+	"go.mongodb.org/mongo-driver/bson"
+)
+
+type TestCase struct {
+	Doc    bson.D
+	DocKey bson.D
+}
+
+var TestCases = []TestCase{
+	{
+		Doc: bson.D{
+			{"_id", "abc"},
+			{"foo", bson.D{
+				{"bar", bson.D{{"baz", 1}}},
+				{"bar.baz", 2},
+			}},
+			{"foo.bar", bson.D{{"baz", 3}}},
+			{"foo.bar.baz", 4},
+		},
+		DocKey: bson.D{
+			{"_id", "abc"},
+			{"foo.bar.baz", int32(1)},
+		},
+	},
+	{
+		Doc: bson.D{
+			{"_id", "bbb"},
+			{"foo", bson.D{
+				{"bar", bson.D{{"baz", 1}}},
+				{"bar.baz", 2},
+			}},
+			{"foo.bar", bson.D{{"baz", 3}}},
+		},
+		DocKey: bson.D{
+			{"_id", "bbb"},
+			{"foo.bar.baz", int32(1)},
+		},
+	},
+	{
+		Doc: bson.D{
+			{"_id", "ccc"},
+			{"foo", bson.D{
+				{"bar.baz", 2},
+			}},
+			{"foo.bar", bson.D{{"baz", 3}}},
+		},
+		DocKey: bson.D{
+			{"_id", "ccc"},
+		},
+	},
+	{
+		Doc: bson.D{
+			{"_id", "ddd"},
+			{"foo", bson.D{
+				{"bar", bson.D{{"baz", nil}}},
+			}},
+		},
+		DocKey: bson.D{
+			{"_id", "ddd"},
+			{"foo.bar.baz", nil},
+		},
+	},
+	{
+		Doc: bson.D{
+			{"_id", "eee"},
+			{"foo", "bar"},
+		},
+		DocKey: bson.D{
+			{"_id", "eee"},
+		},
+	},
+}
diff --git a/internal/verifier/compare.go b/internal/verifier/compare.go
index 86a2c2e6..288d6c7e 100644
--- a/internal/verifier/compare.go
+++ b/internal/verifier/compare.go
@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 	"fmt"
-	"strings"
 	"time"
 
 	"github.com/10gen/migration-verifier/chanutil"
@@ -21,7 +20,6 @@ import (
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
 	"go.mongodb.org/mongo-driver/mongo/readpref"
-	"go.mongodb.org/mongo-driver/x/bsonx/bsoncore"
 	"golang.org/x/exp/slices"
 )
 
@@ -380,7 +378,7 @@ func getDocKeyValues(
 	case DocCompareBinary, DocCompareIgnoreOrder:
 		// If we have the full document, create the document key manually:
 		var err error
-		docKey, err = extractTrueDocKeyFromDoc(fieldNames, doc)
+		docKey, err = dockey.ExtractTrueDocKeyFromDoc(fieldNames, doc)
 		if err != nil {
 			return nil, err
 		}
@@ -423,42 +421,6 @@ func getDocKeyValues(
 	return values, nil
 }
 
-// This extracts the document key from a document gets its field names.
-//
-// NB: This avoids the problem documented in SERVER-109340; as a result,
-// the returned key may not always match the change stream’s `documentKey`
-// (because the server misreports its own sharding logic).
-func extractTrueDocKeyFromDoc(
-	fieldNames []string,
-	doc bson.Raw,
-) (bson.Raw, error) {
-	var dk bson.D
-	for _, field := range fieldNames {
-
-		// This is how sharding routes documents: it always
-		// splits on the dot and looks deeply into the document.
-		parts := strings.Split(field, ".")
-		val, err := doc.LookupErr(parts...)
-
-		if errors.Is(err, bsoncore.ErrElementNotFound) {
-			// If the document lacks a value for this field
-			// then don’t add it to the document key.
-			continue
-		} else if err == nil {
-			dk = append(dk, bson.E{field, val})
-		} else {
-			return nil, errors.Wrapf(err, "extracting doc key field %#q from doc %+v", field, doc)
-		}
-	}
-
-	docKey, err := bson.Marshal(dk)
-	if err != nil {
-		return nil, errors.Wrapf(err, "marshaling doc key %v from doc %v", dk, docKey)
-	}
-
-	return docKey, nil
-}
-
 func simpleTimerReset(t *time.Timer, dur time.Duration) {
 	if !t.Stop() {
 		<-t.C
diff --git a/internal/verifier/dockey_agg_test.go b/internal/verifier/dockey_agg_test.go
index 14482ae2..b3cc09b8 100644
--- a/internal/verifier/dockey_agg_test.go
+++ b/internal/verifier/dockey_agg_test.go
@@ -1,109 +1,24 @@
 package verifier
 
 import (
-	"os"
-
 	"github.com/10gen/migration-verifier/dockey"
-	"github.com/10gen/migration-verifier/internal/logger"
-	"github.com/10gen/migration-verifier/internal/util"
+	"github.com/10gen/migration-verifier/dockey/test"
 	"github.com/10gen/migration-verifier/mslices"
+	"github.com/samber/lo"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
-	"go.mongodb.org/mongo-driver/mongo/options"
 )
 
-var testCases = []struct {
-	doc    bson.D
-	docKey bson.D
-}{
-	{
-		doc: bson.D{
-			{"_id", "abc"},
-			{"foo", bson.D{
-				{"bar", bson.D{{"baz", 1}}},
-				{"bar.baz", 2},
-			}},
-			{"foo.bar", bson.D{{"baz", 3}}},
-			{"foo.bar.baz", 4},
-		},
-		docKey: bson.D{
-			{"_id", "abc"},
-			{"foo.bar.baz", int32(1)},
-		},
-	},
-	{
-		doc: bson.D{
-			{"_id", "bbb"},
-			{"foo", bson.D{
-				{"bar", bson.D{{"baz", 1}}},
-				{"bar.baz", 2},
-			}},
-			{"foo.bar", bson.D{{"baz", 3}}},
-		},
-		docKey: bson.D{
-			{"_id", "bbb"},
-			{"foo.bar.baz", int32(1)},
-		},
-	},
-	{
-		doc: bson.D{
-			{"_id", "ccc"},
-			{"foo", bson.D{
-				{"bar.baz", 2},
-			}},
-			{"foo.bar", bson.D{{"baz", 3}}},
-		},
-		docKey: bson.D{
-			{"_id", "ccc"},
-		},
-	},
-	{
-		doc: bson.D{
-			{"_id", "ddd"},
-			{"foo", bson.D{
-				{"bar", bson.D{{"baz", nil}}},
-			}},
-		},
-		docKey: bson.D{
-			{"_id", "ddd"},
-			{"foo.bar.baz", nil},
-		},
-	},
-}
-
-func (suite *IntegrationTestSuite) TestExtractDocKeyAgg() {
+func (suite *IntegrationTestSuite) TestExtractTrueDocKeyAgg() {
 	t := suite.T()
 
 	ctx := t.Context()
 
 	require := require.New(t)
 
-	cs := os.Getenv("MVTEST_DST")
-	require.NotEmpty(t, cs, "need MVTEST_DST env")
-
-	client, err := mongo.Connect(
-		ctx,
-		options.Client().ApplyURI(cs),
-	)
-	require.NoError(err, "should connect")
-
-	clusterInfo, err := util.GetClusterInfo(
-		ctx,
-		logger.NewDefaultLogger(),
-		client,
-	)
-	require.NoError(err, "should fetch topology")
-	if clusterInfo.Topology != util.TopologySharded {
-		t.Skip("Skipping against unsharded cluster.")
-	}
-
-	// Pre-v6 clusters’ `documentKey` in the change stream is unreliable.
-	// See SERVER-61892.
-	if clusterInfo.VersionArray[0] < 6 {
-		t.Skip("Skipping against pre-v6 cluster.")
-	}
+	client := suite.srcMongoClient
 
 	db := client.Database(suite.DBNameForTest())
 	defer func() {
@@ -117,79 +32,42 @@ func (suite *IntegrationTestSuite) TestExtractDocKeyAgg() {
 
 	coll := db.Collection("stuff")
 
-	// For sharded, pre-v8 clusters we need to create the collection first.
-	require.NoError(db.CreateCollection(ctx, coll.Name()))
-	require.NoError(client.Database("admin").RunCommand(
+	_, err := coll.InsertMany(
 		ctx,
-		bson.D{{"enableSharding", db.Name()}},
-	).Err())
-
-	require.NoError(client.Database("admin").RunCommand(
-		ctx,
-		bson.D{
-			{"shardCollection", db.Name() + "." + coll.Name()},
-			{"key", bson.D{
-				{"foo.bar.baz", 1},
-			}},
-		},
-	).Err(),
+		lo.Map(
+			test.TestCases,
+			func(tc test.TestCase, _ int) any {
+				return tc.Doc
+			},
+		),
 	)
+	require.NoError(err, "should insert")
 
 	computedDocKeyAgg := dockey.ExtractTrueDocKeyAgg(
 		mslices.Of("_id", "foo.bar.baz"),
-		"$fullDocument",
+		"$$ROOT",
 	)
 
-	ejson, _ := bson.MarshalExtJSON(computedDocKeyAgg, true, false)
-	t.Logf("computed doc key agg: %s", string(ejson))
-
-	for _, curCase := range testCases {
-		changes, err := coll.Watch(
-			ctx,
-			mongo.Pipeline{
-				{
-					{"$addFields", bson.D{
-						{"computedDocKey", computedDocKeyAgg},
-					}},
-				},
-			},
+	cursor, err := coll.Aggregate(
+		ctx,
+		mongo.Pipeline{
+			{{"$replaceWith", computedDocKeyAgg}},
+		},
+	)
+	require.NoError(err, "should open cursor to agg")
+	defer cursor.Close(ctx)
+
+	var computedDocKeys []bson.D
+	require.NoError(cursor.All(ctx, &computedDocKeys))
+	require.Len(computedDocKeys, len(test.TestCases))
+
+	for c, curCase := range test.TestCases {
+		assert.Equal(
+			suite.T(),
+			curCase.DocKey,
+			computedDocKeys[c],
+			"doc key for %+v",
+			curCase.Doc,
 		)
-		require.NoError(err, "should open change stream")
-
-		_, err = coll.InsertOne(ctx, curCase.doc)
-		require.NoError(err, "should insert doc")
-
-		for changes.Next(ctx) {
-			var event struct {
-				OperationType  string
-				FullDocument   bson.D
-				DocumentKey    bson.D
-				ComputedDocKey bson.D
-			}
-
-			require.NoError(bson.Unmarshal(changes.Current, &event))
-
-			if event.OperationType != "insert" {
-				t.Logf("Ignoring irrelevant-seeing event: %v", changes.Current)
-				continue
-			}
-
-			ejson, _ := bson.MarshalExtJSON(changes.Current, true, false)
-			t.Logf("Event: %s", string(ejson))
-
-			assert.Equal(
-				t,
-				curCase.docKey,
-				event.ComputedDocKey,
-				"checking computed doc key for %v against server",
-				curCase.doc,
-			)
-
-			break
-		}
-
-		require.NoError(changes.Err(), "change stream should not fail")
-
-		changes.Close(ctx)
 	}
 }

From 5c01288dbe30bad00f3b0b41105c31c91a51a406 Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Tue, 19 Aug 2025 16:35:20 -0400
Subject: [PATCH 29/32] comment

---
 internal/verifier/dockey_agg_test.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/internal/verifier/dockey_agg_test.go b/internal/verifier/dockey_agg_test.go
index b3cc09b8..aaf50a29 100644
--- a/internal/verifier/dockey_agg_test.go
+++ b/internal/verifier/dockey_agg_test.go
@@ -30,6 +30,8 @@ func (suite *IntegrationTestSuite) TestExtractTrueDocKeyAgg() {
 		}
 	}()
 
+	// Insert into a real collection so that we can test on
+	// server versions that lack the $documents aggregation stage.
 	coll := db.Collection("stuff")
 
 	_, err := coll.InsertMany(

From 035fd766712ca11af369023ff0ca62ff1f3f525a Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Wed, 20 Aug 2025 09:32:32 -0400
Subject: [PATCH 30/32] check reverse

---
 dockey/raw_test.go                   | 57 ++++++++++++++++++----------
 dockey/test/cases.go                 |  3 ++
 internal/verifier/dockey_agg_test.go | 24 ++++++++++--
 3 files changed, 60 insertions(+), 24 deletions(-)

diff --git a/dockey/raw_test.go b/dockey/raw_test.go
index cc061f7a..ff82caab 100644
--- a/dockey/raw_test.go
+++ b/dockey/raw_test.go
@@ -1,35 +1,50 @@
 package dockey
 
 import (
+	"slices"
 	"testing"
 
 	"github.com/10gen/migration-verifier/dockey/test"
-	"github.com/10gen/migration-verifier/mslices"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.mongodb.org/mongo-driver/bson"
 )
 
 func TestExtractTrueDocKeyFromDoc(t *testing.T) {
-	for _, curCase := range test.TestCases {
-		raw, err := bson.Marshal(curCase.Doc)
-		require.NoError(t, err)
-
-		computedRaw, err := ExtractTrueDocKeyFromDoc(
-			mslices.Of("_id", "foo.bar.baz"),
-			raw,
-		)
-		require.NoError(t, err)
-
-		var computedDocKey bson.D
-		require.NoError(t, bson.Unmarshal(computedRaw, &computedDocKey))
-
-		assert.Equal(
-			t,
-			curCase.DocKey,
-			computedDocKey,
-			"doc key for %v (got %v; expected %v)",
-			bson.Raw(raw),
-		)
+	for _, reverseYN := range []bool{false, true} {
+		fieldNames := slices.Clone(test.FieldNames)
+
+		if reverseYN {
+			slices.Reverse(fieldNames)
+		}
+
+		for _, curCase := range test.TestCases {
+			raw, err := bson.Marshal(curCase.Doc)
+			require.NoError(t, err)
+
+			computedRaw, err := ExtractTrueDocKeyFromDoc(
+				fieldNames,
+				raw,
+			)
+			require.NoError(t, err)
+
+			var computedDocKey bson.D
+			require.NoError(t, bson.Unmarshal(computedRaw, &computedDocKey))
+
+			expectedDocKey := slices.Clone(curCase.DocKey)
+			if reverseYN {
+				slices.Reverse(expectedDocKey)
+			}
+
+			assert.Equal(
+				t,
+				expectedDocKey,
+				computedDocKey,
+				"doc key for %v (fieldNames: %v)",
+				bson.Raw(raw),
+				fieldNames,
+			)
+		}
 	}
+
 }
diff --git a/dockey/test/cases.go b/dockey/test/cases.go
index 455613d4..a59e2cbd 100644
--- a/dockey/test/cases.go
+++ b/dockey/test/cases.go
@@ -1,6 +1,7 @@
 package test
 
 import (
+	"github.com/10gen/migration-verifier/mslices"
 	"go.mongodb.org/mongo-driver/bson"
 )
 
@@ -9,6 +10,8 @@ type TestCase struct {
 	DocKey bson.D
 }
 
+var FieldNames = mslices.Of("_id", "foo.bar.baz")
+
 var TestCases = []TestCase{
 	{
 		Doc: bson.D{
diff --git a/internal/verifier/dockey_agg_test.go b/internal/verifier/dockey_agg_test.go
index aaf50a29..8031f2f1 100644
--- a/internal/verifier/dockey_agg_test.go
+++ b/internal/verifier/dockey_agg_test.go
@@ -3,15 +3,23 @@ package verifier
 import (
 	"github.com/10gen/migration-verifier/dockey"
 	"github.com/10gen/migration-verifier/dockey/test"
-	"github.com/10gen/migration-verifier/mslices"
 	"github.com/samber/lo"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
+	"golang.org/x/exp/slices"
 )
 
 func (suite *IntegrationTestSuite) TestExtractTrueDocKeyAgg() {
+	suite.testExtractTrueDocKeyAgg(false)
+}
+
+func (suite *IntegrationTestSuite) TestExtractTrueDocKeyAgg_Reverse() {
+	suite.testExtractTrueDocKeyAgg(true)
+}
+
+func (suite *IntegrationTestSuite) testExtractTrueDocKeyAgg(reverseYN bool) {
 	t := suite.T()
 
 	ctx := t.Context()
@@ -45,8 +53,13 @@ func (suite *IntegrationTestSuite) TestExtractTrueDocKeyAgg() {
 	)
 	require.NoError(err, "should insert")
 
+	fieldNames := slices.Clone(test.FieldNames)
+	if reverseYN {
+		slices.Reverse(fieldNames)
+	}
+
 	computedDocKeyAgg := dockey.ExtractTrueDocKeyAgg(
-		mslices.Of("_id", "foo.bar.baz"),
+		fieldNames,
 		"$$ROOT",
 	)
 
@@ -64,9 +77,14 @@ func (suite *IntegrationTestSuite) TestExtractTrueDocKeyAgg() {
 	require.Len(computedDocKeys, len(test.TestCases))
 
 	for c, curCase := range test.TestCases {
+		expectedDocKey := slices.Clone(curCase.DocKey)
+		if reverseYN {
+			slices.Reverse(expectedDocKey)
+		}
+
 		assert.Equal(
 			suite.T(),
-			curCase.DocKey,
+			expectedDocKey,
 			computedDocKeys[c],
 			"doc key for %+v",
 			curCase.Doc,

From ed0aa0d0f0c6902c102965367aa992f82c32b75a Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Wed, 20 Aug 2025 09:38:05 -0400
Subject: [PATCH 31/32] panic & assert in tests

---
 dockey/agg.go      |  2 ++
 dockey/agg_test.go | 20 ++++++++++++++++++++
 dockey/raw.go      | 10 ++++++++++
 dockey/raw_test.go | 10 ++++++++++
 4 files changed, 42 insertions(+)
 create mode 100644 dockey/agg_test.go

diff --git a/dockey/agg.go b/dockey/agg.go
index af5ba076..19400029 100644
--- a/dockey/agg.go
+++ b/dockey/agg.go
@@ -19,6 +19,8 @@ import (
 // the returned key may not always match the change stream’s `documentKey`
 // (because the server misreports its own sharding logic).
 func ExtractTrueDocKeyAgg(fieldNames []string, docExpr string) bson.D {
+	assertFieldNameUniqueness(fieldNames)
+
 	var docKeyNumKeys bson.D
 	numToKeyLookup := map[string]string{}
 
diff --git a/dockey/agg_test.go b/dockey/agg_test.go
new file mode 100644
index 00000000..5a4d3ec5
--- /dev/null
+++ b/dockey/agg_test.go
@@ -0,0 +1,20 @@
+package dockey
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAggPanic(t *testing.T) {
+	assert.Panics(
+		t,
+		func() {
+			ExtractTrueDocKeyAgg(
+				[]string{"foo", "bar", "foo"},
+				"$$ROOT",
+			)
+		},
+		"duplicate field name should cause panic",
+	)
+}
diff --git a/dockey/raw.go b/dockey/raw.go
index 2c22cdd2..0338100a 100644
--- a/dockey/raw.go
+++ b/dockey/raw.go
@@ -1,9 +1,11 @@
 package dockey
 
 import (
+	"fmt"
 	"strings"
 
 	"github.com/pkg/errors"
+	"github.com/samber/lo"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/x/bsonx/bsoncore"
 )
@@ -17,6 +19,8 @@ func ExtractTrueDocKeyFromDoc(
 	fieldNames []string,
 	doc bson.Raw,
 ) (bson.Raw, error) {
+	assertFieldNameUniqueness(fieldNames)
+
 	var dk bson.D
 	for _, field := range fieldNames {
 
@@ -43,3 +47,9 @@ func ExtractTrueDocKeyFromDoc(
 
 	return docKey, nil
 }
+
+func assertFieldNameUniqueness(fieldNames []string) {
+	if len(lo.Uniq(fieldNames)) != len(fieldNames) {
+		panic(fmt.Sprintf("Duplicate field names: %v", fieldNames))
+	}
+}
diff --git a/dockey/raw_test.go b/dockey/raw_test.go
index ff82caab..9a517f54 100644
--- a/dockey/raw_test.go
+++ b/dockey/raw_test.go
@@ -47,4 +47,14 @@ func TestExtractTrueDocKeyFromDoc(t *testing.T) {
 		}
 	}
 
+	assert.Panics(
+		t,
+		func() {
+			ExtractTrueDocKeyFromDoc(
+				[]string{"foo", "bar", "foo"},
+				bson.Raw{0},
+			)
+		},
+		"duplicate field name should cause panic",
+	)
 }

From b86061eb77880c0701a6ac2496db446a7dd5519b Mon Sep 17 00:00:00 2001
From: Felipe Gasper <felipe@felipegasper.com>
Date: Wed, 20 Aug 2025 10:12:56 -0400
Subject: [PATCH 32/32] no error check

---
 dockey/raw_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dockey/raw_test.go b/dockey/raw_test.go
index 9a517f54..3e5a9652 100644
--- a/dockey/raw_test.go
+++ b/dockey/raw_test.go
@@ -50,7 +50,7 @@ func TestExtractTrueDocKeyFromDoc(t *testing.T) {
 	assert.Panics(
 		t,
 		func() {
-			ExtractTrueDocKeyFromDoc(
+			_, _ = ExtractTrueDocKeyFromDoc(
 				[]string{"foo", "bar", "foo"},
 				bson.Raw{0},
 			)