Minor dependency updates.

## [Unreleased]

### Changed

- RPC now allows omitting the `unwrap` parameter for requests with empty payloads.

- Upgrade GRPC dependency.

## [3.18.0] - 2023-10-24

### Added

go 1.20

require (

	github.com/bits-and-blooms/bitset v1.5.0

	github.com/blugelabs/bluge v0.2.2

	github.com/blugelabs/bluge_segment_api v0.2.0

	github.com/blugelabs/query_string v0.3.0

	golang.org/x/crypto v0.11.0

	golang.org/x/oauth2 v0.10.0

	google.golang.org/genproto/googleapis/api v0.0.0-20230530153820-e85fd2cbaebc

	google.golang.org/grpc v1.56.2

	google.golang.org/grpc v1.57.0

	google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.3.0

	google.golang.org/protobuf v1.31.0

	gopkg.in/natefinch/lumberjack.v2 v2.0.0-20230206193814-4cb27fcfbb0f

	github.com/RoaringBitmap/roaring v0.9.4 // indirect

	github.com/axiomhq/hyperloglog v0.0.0-20191112132149-a4c4c47bc57f // indirect

	github.com/beorn7/perks v1.0.1 // indirect

	github.com/bits-and-blooms/bitset v1.2.0 // indirect

	github.com/blevesearch/go-porterstemmer v1.0.3 // indirect

	github.com/blevesearch/mmap-go v1.0.4 // indirect

	github.com/blevesearch/segment v0.9.0 // indirect

github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=

github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=

github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=

github.com/bits-and-blooms/bitset v1.2.0 h1:Kn4yilvwNtMACtf1eYDlG8H77R07mZSPbMjLyS07ChA=

github.com/bits-and-blooms/bitset v1.2.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA=

github.com/bits-and-blooms/bitset v1.5.0 h1:NpE8frKRLGHIcEzkR+gZhiioW1+WbYV6fKwD6ZIpQT8=

github.com/bits-and-blooms/bitset v1.5.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA=

github.com/bketelsen/crypt v0.0.4/go.mod h1:aI6NrJ0pMGgvZKL1iVgXLnfIFJtfV+bKCoqOes/6LfM=

github.com/blevesearch/go-porterstemmer v1.0.3 h1:GtmsqID0aZdCSNiY8SkuPJ12pD4jI+DdXTAn4YRcHCo=

github.com/blevesearch/go-porterstemmer v1.0.3/go.mod h1:angGc5Ht+k2xhJdZi511LtmxuEf0OVpvUUNrwmM1P7M=

google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=

google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=

google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=

google.golang.org/grpc v1.56.2 h1:fVRFRnXvU+x6C4IlHZewvJOVHoOv1TUuQyoRsYnB4bI=

google.golang.org/grpc v1.56.2/go.mod h1:I9bI3vqKfayGqPUAwGdOSu7kt6oIJLixfffKrpXqQ9s=

google.golang.org/grpc v1.57.0 h1:kfzNeI/klCGD2YPMUlaGNT3pxvYfga7smW3Vth8Zsiw=

google.golang.org/grpc v1.57.0/go.mod h1:Sd+9RMTACXwmub0zcNY2c4arhtrbBYD1AUHI/dt16Mo=

google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.3.0 h1:rNBFJjBCOgVr9pWD7rs/knKL4FRTKgpZmsRfV214zcA=

google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.3.0/go.mod h1:Dk1tviKTvMCz5tvh7t+fh94dhmQVHuCt2OzJB3CTW9Y=

google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=

	"go.uber.org/zap/zapcore"

	"google.golang.org/protobuf/encoding/protojson"

	_ "github.com/bits-and-blooms/bitset"

	_ "github.com/go-gorp/gorp/v3"

	_ "github.com/golang/snappy"

	_ "github.com/prometheus/client_golang/prometheus"

As an alternative to BitSets, one should check out the 'big' package,

which provides a (less set-theoretical) view of bitsets.

*/

package bitset

	return b.set

}

// SetBitsetFrom fills the bitset with an array of integers without creating a new BitSet instance

func (b *BitSet) SetBitsetFrom(buf []uint64) {

	b.length = uint(len(buf)) * 64

	b.set = buf

}

// From is a constructor used to create a BitSet from an array of integers

func From(buf []uint64) *BitSet {

	return &BitSet{uint(len(buf)) * 64, buf}

	return FromWithLength(uint(len(buf))*64, buf)

}

// FromWithLength constructs from an array of integers and length.

func FromWithLength(len uint, set []uint64) *BitSet {

	return &BitSet{len, set}

}

// Bytes returns the bitset as array of integers

	return int((i + (wordSize - 1)) >> log2WordSize)

}

// wordsNeededUnbound calculates the number of words needed for i bits, possibly exceeding the capacity.

// This function is useful if you know that the capacity cannot be exceeded (e.g., you have an existing bitmap).

func wordsNeededUnbound(i uint) int {

	return int((i + (wordSize - 1)) >> log2WordSize)

}

// wordsIndex calculates the index of words in a `uint64`

func wordsIndex(i uint) uint {

	return i & (wordSize - 1)

}

// New creates a new BitSet with a hint that length bits will be required

func New(length uint) (bset *BitSet) {

	defer func() {

	return b.length

}

// extendSetMaybe adds additional words to incorporate new bits if needed

func (b *BitSet) extendSetMaybe(i uint) {

	if i >= b.length { // if we need more bits, make 'em

// extendSet adds additional words to incorporate new bits if needed

func (b *BitSet) extendSet(i uint) {

	if i >= Cap() {

		panic("You are exceeding the capacity")

	}

	}

	b.length = i + 1

}

}

// Test whether bit i is set.

func (b *BitSet) Test(i uint) bool {

	if i >= b.length {

		return false

	}

	return b.set[i>>log2WordSize]&(1<<(i&(wordSize-1))) != 0

	return b.set[i>>log2WordSize]&(1<<wordsIndex(i)) != 0

}

// Set bit i to 1, the capacity of the bitset is automatically

// may lead to a memory shortage and a panic: the caller is responsible

// for providing sensible parameters in line with their memory capacity.

func (b *BitSet) Set(i uint) *BitSet {

	b.extendSetMaybe(i)

	b.set[i>>log2WordSize] |= 1 << (i & (wordSize - 1))

	if i >= b.length { // if we need more bits, make 'em

		b.extendSet(i)

	}

	b.set[i>>log2WordSize] |= 1 << wordsIndex(i)

	return b

}

	if i >= b.length {

		return b

	}

	b.set[i>>log2WordSize] &^= 1 << (i & (wordSize - 1))

	b.set[i>>log2WordSize] &^= 1 << wordsIndex(i)

	return b

}

	if i >= b.length {

		return b.Set(i)

	}

	b.set[i>>log2WordSize] ^= 1 << (i & (wordSize - 1))

	b.set[i>>log2WordSize] ^= 1 << wordsIndex(i)

	return b

}

	if start >= end {

		return b

	}

	b.extendSetMaybe(end - 1)

	if end-1 >= b.length { // if we need more bits, make 'em

		b.extendSet(end - 1)

	}

	var startWord uint = start >> log2WordSize

	var endWord uint = end >> log2WordSize

	b.set[startWord] ^= ^(^uint64(0) << (start & (wordSize - 1)))

	b.set[startWord] ^= ^(^uint64(0) << wordsIndex(start))

	for i := startWord; i < endWord; i++ {

		b.set[i] = ^b.set[i]

	}

	b.set[endWord] ^= ^uint64(0) >> (-end & (wordSize - 1))

	if end&(wordSize-1) != 0 {

		b.set[endWord] ^= ^uint64(0) >> wordsIndex(-end)

	}

	return b

}

	copy(shrunk, b.set[:idx])

	b.set = shrunk

	b.length = length

	b.set[idx-1] &= (allBits >> (uint64(64) - uint64(length&(wordSize-1))))

	lastWordUsedBits := length % 64

	if lastWordUsedBits != 0 {

		b.set[idx-1] &= allBits >> uint64(64-wordsIndex(lastWordUsedBits))

	}

	return b

}

// this method could be extremely slow and in some cases might cause the entire BitSet

// to be recopied.

func (b *BitSet) InsertAt(idx uint) *BitSet {

	insertAtElement := (idx >> log2WordSize)

	insertAtElement := idx >> log2WordSize

	// if length of set is a multiple of wordSize we need to allocate more space first

	if b.isLenExactMultiple() {

	// generate a mask to extract the data that we need to shift left

	// within the element where we insert a bit

	dataMask := ^(uint64(1)<<uint64(idx&(wordSize-1)) - 1)

	dataMask := uint64(1)<<uint64(wordsIndex(idx)) - 1

	// extract that data that we'll shift

	data := b.set[i] & dataMask

	data := b.set[i] & (^dataMask)

	// set the positions of the data mask to 0 in the element where we insert

	b.set[i] &= ^dataMask

	b.set[i] &= dataMask

	// shift data mask to the left and insert its data to the slice element

	b.set[i] |= data << 1

	// generate a mask for the data that needs to be shifted right

	// within that slice element that gets modified

	dataMask := ^((uint64(1) << (i & (wordSize - 1))) - 1)

	dataMask := ^((uint64(1) << wordsIndex(i)) - 1)

	// extract the data that we'll shift right from the slice element

	data := b.set[deleteAtElement] & dataMask

		return 0, false

	}

	w := b.set[x]

	w = w >> (i & (wordSize - 1))

	w = w >> wordsIndex(i)

	if w != 0 {

		return i + trailingZeroes64(w), true

	}

//	 j += 1

//	}

//

//

// It is possible to retrieve all set bits as follow:

//

//	indices := make([]uint, bitmap.Count())

	if x >= len(b.set) || capacity == 0 {

		return 0, myanswer[:0]

	}

	skip := i & (wordSize - 1)

	skip := wordsIndex(i)

	word := b.set[x] >> skip

	myanswer = myanswer[:capacity]

	size := int(0)

		return 0, false

	}

	w := b.set[x]

	w = w >> (i & (wordSize - 1))

	wA := allBits >> (i & (wordSize - 1))

	w = w >> wordsIndex(i)

	wA := allBits >> wordsIndex(i)

	index := i + trailingZeroes64(^w)

	if w != wA && index < b.length {

		return index, true

// wordCount returns the number of words used in a bit set

func (b *BitSet) wordCount() int {

	return len(b.set)

	return wordsNeededUnbound(b.length)

}

// Clone this BitSet

	return c

}

// Copy into a destination BitSet

// Returning the size of the destination BitSet

// like array copy

// Copy into a destination BitSet using the Go array copy semantics:

// the number of bits copied is the minimum of the number of bits in the current

// BitSet (Len()) and the destination Bitset.

// We return the number of bits copied in the destination BitSet.

func (b *BitSet) Copy(c *BitSet) (count uint) {

	if c == nil {

		return

	if b.length < c.length {

		count = b.length

	}

	// Cleaning the last word is needed to keep the invariant that other functions, such as Count, require

	// that any bits in the last word that would exceed the length of the bitmask are set to 0.

	c.cleanLastWord()

	return

}

// CopyFull copies into a destination BitSet such that the destination is

// identical to the source after the operation, allocating memory if necessary.

func (b *BitSet) CopyFull(c *BitSet) {

	if c == nil {

		return

	}

	c.length = b.length

	if len(b.set) == 0 {

		if c.set != nil {

			c.set = c.set[:0]

		}

	} else {

		if cap(c.set) < len(b.set) {

			c.set = make([]uint64, len(b.set))

		} else {

			c.set = c.set[:len(b.set)]

		}

		copy(c.set, b.set)

	}

}

// Count (number of set bits).

// Also known as "popcount" or "population count".

	if b.length == 0 { // if they have both length == 0, then could have nil set

		return true

	}

	// testing for equality shoud not transform the bitset (no call to safeSet)

	for p, v := range b.set {

		if c.set[p] != v {

	wn := b.wordCount()

	for p:= 0; p < wn; p++ {

		if c.set[p] != b.set[p] {

			return false

		}

	}

		b.set[i] = 0

	}

	if compare.length > 0 {

		b.extendSetMaybe(compare.length - 1)

		if compare.length-1 >= b.length {

			b.extendSet(compare.length - 1)

		}

	}

}

	if l > int(b.wordCount()) {

		l = int(b.wordCount())

	}

	if compare.length > 0 {

		b.extendSetMaybe(compare.length - 1)

	if compare.length > 0 && compare.length-1 >= b.length {

		b.extendSet(compare.length - 1)

	}

	for i := 0; i < l; i++ {

		b.set[i] |= compare.set[i]

	if l > int(b.wordCount()) {

		l = int(b.wordCount())

	}

	if compare.length > 0 {

		b.extendSetMaybe(compare.length - 1)

	if compare.length > 0 && compare.length-1 >= b.length {

		b.extendSet(compare.length - 1)

	}

	for i := 0; i < l; i++ {

		b.set[i] ^= compare.set[i]

// Is the length an exact multiple of word sizes?

func (b *BitSet) isLenExactMultiple() bool {

	return b.length%wordSize == 0

	return wordsIndex(b.length) == 0

}

// Clean last word by setting unused bits to 0

func (b *BitSet) cleanLastWord() {

	if !b.isLenExactMultiple() {

		b.set[len(b.set)-1] &= allBits >> (wordSize - b.length%wordSize)

		b.set[len(b.set)-1] &= allBits >> (wordSize - wordsIndex(b.length))

	}

}

// Complement computes the (local) complement of a biset (up to length bits)

// Complement computes the (local) complement of a bitset (up to length bits)

func (b *BitSet) Complement() (result *BitSet) {

	panicIfNull(b)

	result = New(b.length)

				return false

			}

		}

		return true

	}

	return true

}

// BinaryStorageSize returns the binary storage requirements

func (b *BitSet) BinaryStorageSize() int {

	return binary.Size(uint64(0)) + binary.Size(b.set)

	nWords := b.wordCount()

	return binary.Size(uint64(0)) + binary.Size(b.set[:nWords])

}

// WriteTo writes a BitSet to a stream

	}

	// Write set

	err = binary.Write(stream, binaryOrder, b.set)

	// current implementation of bufio.Writer is more memory efficient than

	// binary.Write for large set

	writer := bufio.NewWriter(stream)

	var item = make([]byte, binary.Size(uint64(0))) // for serializing one uint64

	nWords := b.wordCount()

	for i := range b.set[:nWords] {

		binaryOrder.PutUint64(item, b.set[i])

		if nn, err := writer.Write(item); err != nil {

			return int64(i*binary.Size(uint64(0)) + nn), err

		}

	}

	err = writer.Flush()

	return int64(b.BinaryStorageSize()), err

}

	// Read length first

	err := binary.Read(stream, binaryOrder, &length)

	if err != nil {

		if err == io.EOF {

			err = io.ErrUnexpectedEOF

		}

		return 0, err

	}

	newset := New(uint(length))

		return 0, errors.New("unmarshalling error: type mismatch")

	}

	// Read remaining bytes as set

	err = binary.Read(stream, binaryOrder, newset.set)

	if err != nil {

	var item [8]byte

	nWords := wordsNeeded(uint(length))

	reader := bufio.NewReader(io.LimitReader(stream, 8*int64(nWords)))

	for i := 0; i < nWords; i++ {

		if _, err := io.ReadFull(reader, item[:]); err != nil {

			if err == io.EOF {

				err = io.ErrUnexpectedEOF

			}

			return 0, err

		}

		newset.set[i] = binaryOrder.Uint64(item[:])

	}

	*b = *newset

	return int64(b.BinaryStorageSize()), nil

// MarshalBinary encodes a BitSet into a binary form and returns the result.

func (b *BitSet) MarshalBinary() ([]byte, error) {

	var buf bytes.Buffer

	writer := bufio.NewWriter(&buf)

	_, err := b.WriteTo(writer)

	_, err := b.WriteTo(&buf)

	if err != nil {

		return []byte{}, err

	}

	err = writer.Flush()

	return buf.Bytes(), err

}

// UnmarshalBinary decodes the binary form generated by MarshalBinary.

func (b *BitSet) UnmarshalBinary(data []byte) error {

	buf := bytes.NewReader(data)

	reader := bufio.NewReader(buf)

	_, err := b.ReadFrom(reader)

	_, err := b.ReadFrom(buf)

	return err

}