Bump github.com/nats-io/nats-server/v2 from 2.9.19 to 2.9.21

Bumps [github.com/nats-io/nats-server/v2](https://github.com/nats-io/nats-server) from 2.9.19 to 2.9.21.
- [Release notes](https://github.com/nats-io/nats-server/releases)
- [Changelog](https://github.com/nats-io/nats-server/blob/main/.goreleaser.yml)
- [Commits](https://github.com/nats-io/nats-server/compare/v2.9.19...v2.9.21)

---
updated-dependencies:
- dependency-name: github.com/nats-io/nats-server/v2
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

vendor/github.com/klauspost/compress/s2/encode_all.go

@@ -742,7 +742,6 @@ searchDict:
 				x := load64(src, s-2)
 				m2Hash := hash6(x, tableBits)
 				currHash := hash6(x>>8, tableBits)
-				candidate = int(table[currHash])
 				table[m2Hash] = uint32(s - 2)
 				table[currHash] = uint32(s - 1)
 				cv = load64(src, s)

vendor/github.com/klauspost/compress/s2/encode_better.go

@@ -157,7 +157,6 @@ func encodeBlockBetterGo(dst, src []byte) (d int) {
 				index0 := base + 1
 				index1 := s - 2
 
-				cv = load64(src, s)
 				for index0 < index1 {
 					cv0 := load64(src, index0)
 					cv1 := load64(src, index1)
@@ -269,18 +268,21 @@ func encodeBlockBetterGo(dst, src []byte) (d int) {
 		lTable[hash7(cv0, lTableBits)] = uint32(index0)
 		sTable[hash4(cv0>>8, sTableBits)] = uint32(index0 + 1)
 
+		// lTable could be postponed, but very minor difference.
 		lTable[hash7(cv1, lTableBits)] = uint32(index1)
 		sTable[hash4(cv1>>8, sTableBits)] = uint32(index1 + 1)
 		index0 += 1
 		index1 -= 1
 		cv = load64(src, s)
 
-		// index every second long in between.
-		for index0 < index1 {
+		// Index large values sparsely in between.
+		// We do two starting from different offsets for speed.
+		index2 := (index0 + index1 + 1) >> 1
+		for index2 < index1 {
 			lTable[hash7(load64(src, index0), lTableBits)] = uint32(index0)
-			lTable[hash7(load64(src, index1), lTableBits)] = uint32(index1)
+			lTable[hash7(load64(src, index2), lTableBits)] = uint32(index2)
 			index0 += 2
-			index1 -= 2
+			index2 += 2
 		}
 	}
 
@@ -459,12 +461,14 @@ func encodeBlockBetterSnappyGo(dst, src []byte) (d int) {
 		index1 -= 1
 		cv = load64(src, s)
 
-		// index every second long in between.
-		for index0 < index1 {
+		// Index large values sparsely in between.
+		// We do two starting from different offsets for speed.
+		index2 := (index0 + index1 + 1) >> 1
+		for index2 < index1 {
 			lTable[hash7(load64(src, index0), lTableBits)] = uint32(index0)
-			lTable[hash7(load64(src, index1), lTableBits)] = uint32(index1)
+			lTable[hash7(load64(src, index2), lTableBits)] = uint32(index2)
 			index0 += 2
-			index1 -= 2
+			index2 += 2
 		}
 	}
 
@@ -599,7 +603,6 @@ searchDict:
 					if s >= sLimit {
 						break searchDict
 					}
-					cv = load64(src, s)
 					// Index in-between
 					index0 := base + 1
 					index1 := s - 2
@@ -865,12 +868,14 @@ searchDict:
 		index1 -= 1
 		cv = load64(src, s)
 
-		// index every second long in between.
-		for index0 < index1 {
+		// Index large values sparsely in between.
+		// We do two starting from different offsets for speed.
+		index2 := (index0 + index1 + 1) >> 1
+		for index2 < index1 {
 			lTable[hash7(load64(src, index0), lTableBits)] = uint32(index0)
-			lTable[hash7(load64(src, index1), lTableBits)] = uint32(index1)
+			lTable[hash7(load64(src, index2), lTableBits)] = uint32(index2)
 			index0 += 2
-			index1 -= 2
+			index2 += 2
 		}
 	}
 
@@ -961,7 +966,6 @@ searchDict:
 				index0 := base + 1
 				index1 := s - 2
 
-				cv = load64(src, s)
 				for index0 < index1 {
 					cv0 := load64(src, index0)
 					cv1 := load64(src, index1)
@@ -1079,12 +1083,14 @@ searchDict:
 		index1 -= 1
 		cv = load64(src, s)
 
-		// index every second long in between.
-		for index0 < index1 {
+		// Index large values sparsely in between.
+		// We do two starting from different offsets for speed.
+		index2 := (index0 + index1 + 1) >> 1
+		for index2 < index1 {
 			lTable[hash7(load64(src, index0), lTableBits)] = uint32(index0)
-			lTable[hash7(load64(src, index1), lTableBits)] = uint32(index1)
+			lTable[hash7(load64(src, index2), lTableBits)] = uint32(index2)
 			index0 += 2
-			index1 -= 2
+			index2 += 2
 		}
 	}
 

vendor/github.com/klauspost/compress/s2/reader.go

@@ -147,6 +147,13 @@ type Reader struct {
 	ignoreCRC      bool
 }
 
+// GetBufferCapacity returns the capacity of the internal buffer.
+// This might be useful to know when reusing the same reader in combination
+// with the lazy buffer option.
+func (r *Reader) GetBufferCapacity() int {
+	return cap(r.buf)
+}
+
 // ensureBufferSize will ensure that the buffer can take at least n bytes.
 // If false is returned the buffer exceeds maximum allowed size.
 func (r *Reader) ensureBufferSize(n int) bool {

vendor/github.com/klauspost/compress/s2/writer.go

@@ -771,7 +771,7 @@ func (w *Writer) closeIndex(idx bool) ([]byte, error) {
 	}
 
 	var index []byte
-	if w.err(nil) == nil && w.writer != nil {
+	if w.err(err) == nil && w.writer != nil {
 		// Create index.
 		if idx {
 			compSize := int64(-1)