slidge-whatsapp 0.2.7__cp313-cp313-manylinux_2_36_aarch64.whl → 0.3.0b0__cp313-cp313-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/github.com/beeper/argo-go/pkg/bitset/bitset.go

@@ -0,0 +1,197 @@
+// Package bitset provides a BitSet data structure backed by *big.Int,
+// along with helpers for reading and writing bitsets in variable-length
+// (self-delimiting) and fixed-length formats.
+package bitset
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/beeper/argo-go/pkg/buf"
+)
+
+// BitSet implements a growable set of bits, backed by a *big.Int.
+// It provides methods to get, set, and unset individual bits.
+// The zero value of a BitSet is not ready for use; always use NewBitSet.
+type BitSet struct {
+	val *big.Int
+}
+
+// NewBitSet creates and initializes a new BitSet to zero.
+func NewBitSet() *BitSet {
+	return &BitSet{val: big.NewInt(0)}
+}
+
+// GetBit returns the boolean value of the bit at the given index.
+// It panics if the index is negative.
+func (bs *BitSet) GetBit(index int) bool {
+	if index < 0 {
+		panic("Bitset index must be positive")
+	}
+	return bs.val.Bit(index) == 1
+}
+
+// SetBit sets the bit at the given index to 1 (true).
+// It panics if the index is negative.
+// Returns the BitSet pointer for chaining.
+func (bs *BitSet) SetBit(index int) *BitSet {
+	if index < 0 {
+		panic("Bitset index must be positive")
+	}
+	bs.val.SetBit(bs.val, index, 1)
+	return bs
+}
+
+// UnsetBit sets the bit at the given index to 0 (false).
+// It panics if the index is negative.
+// Returns the BitSet pointer for chaining.
+func (bs *BitSet) UnsetBit(index int) *BitSet {
+	if index < 0 {
+		panic("Bitset index must be positive")
+	}
+	bs.val.SetBit(bs.val, index, 0)
+	return bs
+}
+
+// Bytes returns the raw byte representation of the BitSet's underlying *big.Int.
+// The bytes are in big-endian order. Returns nil if the BitSet or its internal value is nil.
+func (bs *BitSet) Bytes() []byte {
+	if bs == nil || bs.val == nil {
+		return nil
+	}
+	return bs.val.Bytes()
+}
+
+// VarBitSet provides methods for reading and writing variable-length, self-delimiting bitsets.
+// In this format, each byte encodes 7 bits of data, with the least significant bit (LSB)
+// acting as a continuation flag (1 means more bytes follow, 0 means this is the last byte).
+type VarBitSet struct{}
+
+// Read reads a variable-length, self-delimiting bitset from a buf.Read.
+// It reconstructs the BitSet from bytes where each byte contributes 7 data bits
+// and 1 continuation bit. It returns the number of bytes read, the resulting BitSet,
+// and any error encountered during reading.
+func (v *VarBitSet) Read(buf buf.Read) (int, *BitSet, error) {
+	bytesRead := 0
+	bitset := NewBitSet()
+	more := true
+	bitPos := 0
+	for more {
+		byteVal, err := buf.ReadByte()
+		if err != nil {
+			return bytesRead, nil, fmt.Errorf("failed to read byte for var bitset: %w", err)
+		}
+		bytesRead++
+		// byteVal is already a byte, no need to check if <0 or >255
+		shiftedVal := new(big.Int).Lsh(big.NewInt(int64((byteVal&0xff)>>1)), uint(bitPos))
+		bitset.val.Or(bitset.val, shiftedVal)
+		bitPos += 7
+		more = (byteVal & 1) == 1
+	}
+	return bytesRead, bitset, nil
+}
+
+// Write encodes a BitSet into a variable-length, self-delimiting byte slice.
+// Each byte in the output slice contains 7 bits of data from the BitSet and one
+// continuation bit (LSB). If the LSB is 1, more bytes follow; if 0, it's the last byte.
+// The 'padToLength' argument ensures the output byte slice has at least that many bytes,
+// padding with zero bytes (0x00, which represents zero value and no continuation) if necessary.
+// Returns an error if the BitSet contains negative values (which is not typical for bitsets).
+func (v *VarBitSet) Write(bs *BitSet, padToLength int) ([]byte, error) {
+	if bs.val.Sign() < 0 {
+		return nil, fmt.Errorf("Bitsets must only contain positive values")
+	}
+	var bytes []byte
+	// Make a copy to avoid modifying the original
+	valCopy := new(big.Int).Set(bs.val)
+	more := valCopy.Sign() > 0
+
+	for more {
+		byteValBig := new(big.Int).And(valCopy, big.NewInt(0x7f)) // Get the lowest 7 bits
+		byteVal := byteValBig.Int64() << 1                        // Shift left to make space for the 'more' bit
+
+		valCopy.Rsh(valCopy, 7) // Shift right by 7 bits
+		more = valCopy.Sign() > 0
+		if more {
+			byteVal = byteVal | 1 // Set the 'more' bit
+		}
+		bytes = append(bytes, byte(byteVal))
+	}
+
+	if len(bytes) == 0 { // If original value was 0, loop didn't run.
+		bytes = append(bytes, 0x00)
+	}
+
+	if padToLength > len(bytes) {
+		padding := make([]byte, padToLength-len(bytes))
+		bytes = append(bytes, padding...)
+	}
+	return bytes, nil
+}
+
+// FixedBitSet provides methods for reading and writing fixed-length, undelimited bitsets.
+// In this format, all 8 bits of each byte are used for data.
+// The total length of the bitset in bytes must be known beforehand for reading.
+type FixedBitSet struct{}
+
+// Write encodes a BitSet into a fixed-length, undelimited byte slice.
+// All 8 bits of each byte in the output are used for data from the BitSet.
+// The 'padToLength' argument ensures the output byte slice has at least that many bytes,
+// padding with zero bytes if necessary. The least significant bytes of the BitSet appear first.
+// Returns an error if the BitSet contains negative values.
+func (f *FixedBitSet) Write(bs *BitSet, padToLength int) ([]byte, error) {
+	if bs.val.Sign() < 0 {
+		return nil, fmt.Errorf("Bitsets must only contain positive values")
+	}
+	var bytes []byte
+	valCopy := new(big.Int).Set(bs.val)
+	more := valCopy.Sign() > 0
+
+	for more {
+		byteValBig := new(big.Int).And(valCopy, big.NewInt(0xff)) // Get the lowest 8 bits
+		byteVal := byteValBig.Uint64()
+		valCopy.Rsh(valCopy, 8) // Shift right by 8 bits
+		more = valCopy.Sign() > 0
+		bytes = append(bytes, byte(byteVal))
+	}
+
+	if len(bytes) == 0 && padToLength > 0 { // Handle case where bitset is 0
+		bytes = append(bytes, 0)
+	}
+
+	if padToLength > len(bytes) {
+		padding := make([]byte, padToLength-len(bytes))
+		bytes = append(bytes, padding...)
+	}
+	return bytes, nil
+}
+
+// Read reconstructs a BitSet from a fixed-length, undelimited sequence of bytes
+// within a larger byte slice. 'pos' specifies the starting position in 'bytes',
+// and 'length' specifies how many bytes to read to form the bitset.
+// All 8 bits of each read byte contribute to the BitSet.
+func (f *FixedBitSet) Read(bytes []byte, pos int, length int) (*BitSet, error) {
+	if pos+length > len(bytes) {
+		return nil, fmt.Errorf("not enough bytes to read fixed bitset of length %d from pos %d", length, pos)
+	}
+
+	bitset := NewBitSet()
+	bitPos := 0
+	for i := 0; i < length; i++ {
+		byteVal := bytes[pos+i]
+		shiftedVal := new(big.Int).Lsh(big.NewInt(int64(byteVal&0xff)), uint(bitPos))
+		bitset.val.Or(bitset.val, shiftedVal)
+		bitPos += 8
+	}
+	return bitset, nil
+}
+
+// BytesNeededForNumBits calculates the minimum number of bytes required to store
+// a fixed-length bitset containing 'numBits' of information.
+// This is equivalent to ceil(numBits / 8).
+func (f *FixedBitSet) BytesNeededForNumBits(numBits int) int {
+	if numBits <= 0 {
+		return 0
+	}
+	return (numBits + 7) / 8 // Equivalent to Math.ceil(numBits / 8)
+}

slidge_whatsapp/vendor/github.com/beeper/argo-go/pkg/buf/buf.go

@@ -0,0 +1,420 @@
+package buf
+
+import (
+	"errors"
+	"io"
+)
+
+// BufPosition defines an interface for types that track a position.
+type BufPosition interface {
+	Position() int64
+	SetPosition(position int64)
+	IncrementPosition(numBytes int64)
+}
+
+// Read defines an interface for readable buffers.
+type Read interface {
+	BufPosition
+	io.Reader
+	io.ByteReader
+	Get(position int64) (byte, error)
+	Bytes() []byte
+	Len() int
+	Peek(n int) ([]byte, error)
+}
+
+// Write defines an interface for writable buffers.
+type Write interface {
+	BufPosition
+	io.Writer
+	io.ByteWriter
+	Cap() int
+}
+
+// Buf is a dynamically-sized byte buffer, wrapping a []byte.
+// It manages its own position, logical length, and capacity growth.
+type Buf struct {
+	data   []byte // Underlying byte slice
+	pos    int64  // Current read/write position
+	length int64  // Logical length of the data written (number of valid bytes in data)
+}
+
+const defaultInitialBufferSize = 32 // Or a reasonable default like 16, 32, etc.
+
+// NewBuf creates a new Buf with an initial capacity.
+func NewBuf(initialCapacity int) *Buf {
+	if initialCapacity < 0 {
+		initialCapacity = defaultInitialBufferSize
+	}
+	return &Buf{
+		data:   make([]byte, 0, initialCapacity),
+		pos:    0,
+		length: 0,
+	}
+}
+
+// Reset resets the buffer to be empty,
+// but it retains the underlying storage for use by future writes by slicing data to zero length.
+// Reset also resets the position and logical length to 0.
+func (b *Buf) Reset() {
+	b.data = b.data[:0] // Keeps capacity, sets len to 0
+	b.pos = 0
+	b.length = 0
+}
+
+// Position returns the current position in the buffer.
+func (b *Buf) Position() int64 {
+	return b.pos
+}
+
+// SetPosition sets the current position in the buffer.
+// No bounds checking is performed on the position value itself,
+// but subsequent operations (Read/Write) will handle boundaries.
+func (b *Buf) SetPosition(position int64) {
+	b.pos = position
+}
+
+// IncrementPosition increments the current position by numBytes.
+func (b *Buf) IncrementPosition(numBytes int64) {
+	b.pos += numBytes
+}
+
+// ensureCapacity ensures that the buffer has at least minCapacity.
+// If the current capacity is insufficient, it grows the buffer,
+// preserving the existing content up to b.length.
+// After this call, cap(b.data) will be at least minCapacity,
+// and len(b.data) will remain b.length (the old logical length).
+func (b *Buf) ensureCapacity(minCapacity int64) {
+	currentCap := int64(cap(b.data))
+	if currentCap >= minCapacity {
+		return
+	}
+
+	newActualCap := currentCap
+	if newActualCap == 0 {
+		// If starting from zero capacity, choose a small default or minCapacity.
+		// Using a small default (e.g., 16) avoids too many small allocations
+		// if minCapacity is also very small.
+		if minCapacity < 16 {
+			newActualCap = 16
+		} else {
+			newActualCap = minCapacity
+		}
+	}
+
+	// Grow similar to Go's append strategy: double capacity until it's sufficient.
+	for newActualCap < minCapacity {
+		if newActualCap == 0 { // Should have been handled by initial assignment if currentCap was 0
+			newActualCap = minCapacity // Fallback if somehow 0
+			break
+		}
+		newActualCap *= 2
+		if newActualCap < 0 { // Overflow check
+			newActualCap = minCapacity // Max possible if overflow
+			break
+		}
+	}
+	// Final check if doubling overshot significantly but minCapacity is larger.
+	if newActualCap < minCapacity {
+		newActualCap = minCapacity
+	}
+
+	// Create new slice with new capacity, copy content up to current logical length (b.length).
+	// len of newData will be b.length.
+	newData := make([]byte, b.length, newActualCap)
+	if b.length > 0 {
+		copy(newData, b.data[:b.length])
+	}
+	b.data = newData
+}
+
+// Read reads up to len(p) bytes into p from the current position.
+// It returns the number of bytes read and any error encountered.
+// EOF is returned when no more bytes are available from the current position within the logical length.
+func (b *Buf) Read(p []byte) (n int, err error) {
+	if b.pos < 0 {
+		// Reading from a negative position is invalid.
+		return 0, io.EOF // Or a specific error like "invalid position"
+	}
+
+	// Per io.Reader contract, if len(p) == 0, Read should return n == 0 and err == nil.
+	if len(p) == 0 {
+		return 0, nil
+	}
+
+	if b.pos >= b.length {
+		// Position is at or beyond the logical end of the buffer.
+		return 0, io.EOF
+	}
+
+	readableBytes := b.length - b.pos
+	numToRead := int64(len(p))
+
+	if numToRead > readableBytes {
+		numToRead = readableBytes
+	}
+
+	// This check is now effectively for numToRead > 0 after potentially being capped by readableBytes.
+	// If readableBytes was 0, b.pos >= b.length would have caught it.
+	// If len(p) was initially > 0 but numToRead became 0 due to readableBytes, it implies EOF.
+	if numToRead <= 0 {
+		return 0, io.EOF
+	}
+
+	copy(p, b.data[b.pos:b.pos+numToRead])
+	b.pos += numToRead
+	return int(numToRead), nil
+}
+
+// WriteBuf writes the content of bb into b at the current position.
+// It updates b's position and length accordingly.
+// Returns the number of bytes written from bb and any error encountered.
+func (b *Buf) WriteBuf(bb *Buf) (n int, err error) {
+	return b.Write(bb.Bytes())
+}
+
+// Write writes len(p) bytes from p to the buffer at the current position.
+// It returns the number of bytes written and any error encountered.
+// If the write extends beyond the current logical length, the buffer's logical length is updated.
+// If the write starts beyond the current logical length, the gap is filled with zeros.
+func (b *Buf) Write(p []byte) (n int, err error) {
+	numBytesToWrite := len(p)
+	if numBytesToWrite == 0 {
+		return 0, nil
+	}
+
+	if b.pos < 0 {
+		// Writing to a negative position is invalid.
+		// Consider returning an error or panicking, as this indicates misuse.
+		return 0, errors.New("argo.Buf.Write: negative position")
+	}
+
+	endPos := b.pos + int64(numBytesToWrite)
+
+	newLogicalLength := b.length
+	if endPos > newLogicalLength {
+		newLogicalLength = endPos
+	}
+
+	if newLogicalLength > int64(cap(b.data)) {
+		b.ensureCapacity(newLogicalLength)
+		// After ensureCapacity, cap(b.data) >= newLogicalLength,
+		// and len(b.data) == b.length (the old logical length).
+	}
+
+	// Ensure len(b.data) is sufficient for the newLogicalLength.
+	// Reslicing b.data up to newLogicalLength will zero-fill any new bytes
+	// between the old b.length and newLogicalLength if newLogicalLength > len(b.data).
+	// This handles padding if b.pos > old b.length.
+	if newLogicalLength > int64(len(b.data)) {
+		b.data = b.data[:newLogicalLength]
+	}
+	// Now len(b.data) == newLogicalLength, and any extended parts are zero-initialized.
+
+	copy(b.data[b.pos:], p)
+
+	b.length = newLogicalLength
+	b.pos = endPos
+
+	return numBytesToWrite, nil
+}
+
+// ReadByte reads and returns the next byte from the current position.
+// If no byte is available, it returns error io.EOF.
+func (b *Buf) ReadByte() (byte, error) {
+	if b.pos < 0 {
+		return 0, io.EOF
+	}
+	if b.pos >= b.length {
+		return 0, io.EOF
+	}
+	val := b.data[b.pos]
+	b.pos++
+	return val, nil
+}
+
+// WriteByte writes a single byte to the buffer at the current position.
+func (b *Buf) WriteByte(c byte) error {
+	if b.pos < 0 {
+		return errors.New("argo.Buf.WriteByte: negative position")
+	}
+
+	endPos := b.pos + 1
+	newLogicalLength := b.length
+	if endPos > newLogicalLength {
+		newLogicalLength = endPos
+	}
+
+	if newLogicalLength > int64(cap(b.data)) {
+		b.ensureCapacity(newLogicalLength)
+	}
+	if newLogicalLength > int64(len(b.data)) {
+		b.data = b.data[:newLogicalLength]
+	}
+
+	b.data[b.pos] = c
+
+	b.length = newLogicalLength
+	b.pos = endPos
+	return nil
+}
+
+// Get returns the byte at the given absolute position in the buffer,
+// without advancing the current position.
+// Position is relative to the start of the buffer's logical content.
+func (b *Buf) Get(position int64) (byte, error) {
+	if position < 0 || position >= b.length {
+		return 0, io.EOF
+	}
+	return b.data[position], nil
+}
+
+// Bytes returns a slice of all logical bytes currently in the buffer.
+// The returned slice is valid until the next write operation that might cause reallocation.
+func (b *Buf) Bytes() []byte {
+	return b.data[:b.length]
+}
+
+// Len returns the current logical length of the buffer (number of bytes written).
+func (b *Buf) Len() int {
+	return int(b.length)
+}
+
+// Cap returns the current capacity of the buffer's underlying storage.
+func (b *Buf) Cap() int {
+	return cap(b.data)
+}
+
+// Peek returns the next n bytes from the current position without advancing the reader.
+// The returned slice shares the underlying array of the buffer.
+// If n is larger than the available bytes, Peek returns all available bytes.
+func (b *Buf) Peek(n int) ([]byte, error) {
+	if n < 0 {
+		return nil, errors.New("argo.Buf.Peek: count cannot be negative")
+	}
+	if n == 0 {
+		return []byte{}, nil
+	}
+
+	if b.pos < 0 || b.pos >= b.length {
+		return nil, io.EOF // No bytes to peek if position is invalid or at/past end.
+	}
+
+	available := b.length - b.pos
+
+	if int64(n) > available {
+		return b.data[b.pos : b.pos+available], nil
+	}
+	return b.data[b.pos : b.pos+int64(n)], nil
+}
+
+// BufReadonly is a read-only wrapper around a byte slice.
+// It's analogous to TypeScript's BufReadonly class.
+type BufReadonly struct {
+	bytes []byte
+	pos   int64
+}
+
+// NewBufReadonly creates a new BufReadonly wrapping the given byte slice.
+// The provided slice is used directly and should not be modified externally
+// if read-only behavior is to be guaranteed.
+func NewBufReadonly(data []byte) *BufReadonly {
+	return &BufReadonly{bytes: data, pos: 0} // Initialize pos to 0
+}
+
+// Position returns the current position in the buffer.
+func (br *BufReadonly) Position() int64 {
+	return br.pos
+}
+
+// SetPosition sets the current position in the buffer.
+func (br *BufReadonly) SetPosition(position int64) {
+	br.pos = position
+}
+
+// IncrementPosition increments the current position by numBytes.
+func (br *BufReadonly) IncrementPosition(numBytes int64) {
+	br.pos += numBytes
+}
+
+// Read reads up to len(p) bytes into p. It returns the number of bytes
+// read (0 <= n <= len(p)) and any error encountered.
+// If the buffer's read position is negative, it returns (0, io.EOF).
+func (br *BufReadonly) Read(p []byte) (n int, err error) {
+	if br.pos < 0 {
+		return 0, io.EOF
+	}
+	if br.pos >= int64(len(br.bytes)) {
+		return 0, io.EOF
+	}
+	copied := copy(p, br.bytes[br.pos:])
+	br.pos += int64(copied)
+	return copied, nil
+}
+
+// ReadByte reads and returns the next byte from the buffer.
+// If no byte is available, it returns error io.EOF.
+// If the buffer's read position is negative, it returns (0, io.EOF).
+func (br *BufReadonly) ReadByte() (byte, error) {
+	if br.pos < 0 {
+		return 0, io.EOF
+	}
+	if br.pos >= int64(len(br.bytes)) {
+		return 0, io.EOF
+	}
+	val := br.bytes[br.pos]
+	br.pos++
+	return val, nil
+}
+
+// Get returns the byte at the given absolute position in the buffer,
+// without advancing the current position.
+func (br *BufReadonly) Get(position int64) (byte, error) {
+	if position < 0 || position >= int64(len(br.bytes)) {
+		return 0, io.EOF
+	}
+	return br.bytes[position], nil
+}
+
+// Bytes returns all bytes in the buffer, regardless of position.
+func (br *BufReadonly) Bytes() []byte {
+	return br.bytes
+}
+
+// Len returns the total length of the underlying byte slice.
+func (br *BufReadonly) Len() int {
+	return len(br.bytes)
+}
+
+// Peek returns the next n bytes without advancing the reader.
+// If n is negative, an error is returned. If n is 0, Peek returns an empty slice and no error.
+// If the buffer's read position is out of bounds (negative or >= len(br.bytes)), it returns (nil, io.EOF).
+// If n is larger than the available bytes from br.pos, Peek returns all available bytes and no error.
+func (br *BufReadonly) Peek(n int) ([]byte, error) {
+	if n < 0 {
+		return nil, errors.New("argo.BufReadonly.Peek: count cannot be negative")
+	}
+	if n == 0 {
+		return []byte{}, nil
+	}
+	if br.pos < 0 || br.pos >= int64(len(br.bytes)) {
+		return nil, io.EOF
+	}
+
+	available := int64(len(br.bytes)) - br.pos
+	if available <= 0 { // Should be covered by above check, but good for safety.
+		return nil, io.EOF
+	}
+
+	if int64(n) > available {
+		return br.bytes[br.pos : br.pos+available], nil
+	}
+	return br.bytes[br.pos : br.pos+int64(n)], nil
+}
+
+// Make sure Buf implements Read and Write
+var _ Read = (*Buf)(nil)
+var _ Write = (*Buf)(nil)
+
+// Make sure BufReadonly implements Read
+var _ Read = (*BufReadonly)(nil)