slidge-whatsapp 0.2.7__cp311-cp311-manylinux_2_36_aarch64.whl → 0.3.0b0__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/github.com/beeper/argo-go/header/header.go

@@ -0,0 +1,135 @@
+package header
+
+import (
+	"fmt"
+
+	"github.com/beeper/argo-go/pkg/bitset"
+	"github.com/beeper/argo-go/pkg/buf"
+)
+
+// Public constants for header flags
+const (
+	HeaderInlineEverythingFlag      = 0
+	HeaderSelfDescribingFlag        = 1
+	HeaderOutOfBandFieldErrorsFlag  = 2
+	HeaderSelfDescribingErrorsFlag  = 3
+	HeaderNullTerminatedStringsFlag = 4
+	HeaderNoDeduplicationFlag       = 5
+	HeaderHasUserFlagsFlag          = 6
+)
+
+// Header represents the Argo message header.
+type Header struct {
+	flags     *bitset.BitSet
+	userFlags *bitset.BitSet
+}
+
+// NewHeader creates a new Header.
+func NewHeader() *Header {
+	return &Header{
+		flags: bitset.NewBitSet(),
+	}
+}
+
+// GetFlag returns the boolean value of a given header flag.
+func (h *Header) GetFlag(flag int) bool {
+	if h.flags == nil {
+		return false
+	}
+	return h.flags.GetBit(flag)
+}
+
+// SetFlag sets the boolean value of a given header flag.
+func (h *Header) SetFlag(flag int, value bool) {
+	if h.flags == nil {
+		h.flags = bitset.NewBitSet()
+	}
+	if value {
+		h.flags.SetBit(flag)
+	} else {
+		h.flags.UnsetBit(flag)
+	}
+}
+
+// Read reads the header from the provided Read buffer.
+// It updates the Header's internal state (flags, userFlags).
+// It also advances the position of the buffer.
+func (h *Header) Read(reader buf.Read) error {
+	if reader == nil {
+		return fmt.Errorf("reader is nil, cannot read header")
+	}
+
+	var vbs bitset.VarBitSet
+	_, flags, err := vbs.Read(reader) // Read standard flags using VarBitSet.Read
+	if err != nil {
+		return fmt.Errorf("failed to read standard header flags: %w", err)
+	}
+	h.flags = flags
+
+	// Check based on the just-read standard flags
+	if h.GetFlag(HeaderHasUserFlagsFlag) { // Use new GetFlag method
+		_, userFlags, err := vbs.Read(reader) // Read user flags using VarBitSet.Read
+		if err != nil {
+			return fmt.Errorf("failed to read user header flags: %w", err)
+		}
+		h.userFlags = userFlags
+	} else {
+		h.userFlags = nil // Ensure userFlags is nil if HasUserFlags is false
+	}
+	return nil
+}
+
+// Write writes the header to the provided Write buffer.
+func (h *Header) Write(writer buf.Write) error {
+	if writer == nil {
+		return fmt.Errorf("writer is nil, cannot write header")
+	}
+	flagBytes, err := (&bitset.VarBitSet{}).Write(h.flags, 0)
+	if err != nil {
+		return fmt.Errorf("failed to write flags: %w", err)
+	}
+
+	var userFlagBytes []byte
+	if h.GetFlag(HeaderHasUserFlagsFlag) { // Use new GetFlag method
+		userFlagBytes, err = (&bitset.VarBitSet{}).Write(h.userFlags, 0)
+		if err != nil {
+			return fmt.Errorf("failed to write userFlags: %w", err)
+		}
+	}
+
+	if _, err := writer.Write(flagBytes); err != nil {
+		return fmt.Errorf("buffer write error for flags: %w", err)
+	}
+	if userFlagBytes != nil {
+		if _, err := writer.Write(userFlagBytes); err != nil {
+			return fmt.Errorf("buffer write error for userFlags: %w", err)
+		}
+	}
+	return nil
+}
+
+// AsBytes serializes the header to a byte slice.
+func (h *Header) AsBytes() ([]byte, error) {
+	tempBuf := buf.NewBuf(0) // Use argo.Buf which implements Write
+	err := h.Write(tempBuf)
+	if err != nil {
+		return nil, err // Propagate error from Write
+	}
+	return tempBuf.Bytes(), nil
+}
+
+// UserFlags returns the user flags BitSet.
+func (h *Header) UserFlags() *bitset.BitSet {
+	return h.userFlags
+}
+
+// SetUserFlags sets the user flags BitSet.
+// This also sets or unsets the HeaderHasUserFlagsFlag bit accordingly.
+func (h *Header) SetUserFlags(bs *bitset.BitSet) {
+	h.userFlags = bs
+	if h.flags == nil { // Ensure flags is initialized
+		h.flags = bitset.NewBitSet()
+	}
+	hasUserFlagsSet := bs != nil && len(bs.Bytes()) > 0
+	h.SetFlag(HeaderHasUserFlagsFlag, hasUserFlagsSet) // Use new SetFlag method
+}

slidge_whatsapp/vendor/github.com/beeper/argo-go/internal/util/util.go

@@ -0,0 +1,133 @@
+// Package util provides miscellaneous utility functions used across the argo-go library.
+package util
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/elliotchance/orderedmap/v3"
+	"github.com/vektah/gqlparser/v2/ast"
+)
+
+// GroupBy groups elements of a slice into a map based on a key extracted from each element.
+func GroupBy[T any, K comparable](array []T, extract func(T) K) map[K][]T {
+	grouped := make(map[K][]T)
+	for _, element := range array {
+		key := extract(element)
+		grouped[key] = append(grouped[key], element)
+	}
+	return grouped
+}
+
+// AddPathIndex appends an integer index to an ast.Path.
+func AddPathIndex(p ast.Path, i int) ast.Path {
+	path := make(ast.Path, len(p), len(p)+1)
+	copy(path, p)
+	path = append(path, ast.PathIndex(i))
+	return path
+}
+
+// AddPathName appends a string name to an ast.Path.
+func AddPathName(p ast.Path, s string) ast.Path {
+	path := make(ast.Path, len(p), len(p)+1)
+	copy(path, p)
+	path = append(path, ast.PathName(s))
+	return path
+}
+
+func FormatPath(p ast.Path) string {
+	if p == nil {
+		return "<nil>"
+	}
+	var parts []string
+	for _, el := range p {
+		switch v := el.(type) {
+		case ast.PathName:
+			parts = append(parts, string(v))
+		case ast.PathIndex:
+			parts = append(parts, strconv.Itoa(int(v)))
+		default:
+			parts = append(parts, fmt.Sprintf("%v", v))
+		}
+	}
+	return strings.Join(parts, ".")
+}
+
+// NewOrderedMapJSON creates a new OrderedMapJSON wrapper.
+func NewOrderedMapJSON[K comparable, V any](om *orderedmap.OrderedMap[K, V]) *OrderedMapJSON[K, V] {
+	return &OrderedMapJSON[K, V]{om}
+}
+
+// OrderedMapJSON is a wrapper around orderedmap.OrderedMap to allow custom JSON marshalling.
+// It needs to be generic to match the orderedmap.OrderedMap it wraps.
+type OrderedMapJSON[K comparable, V any] struct {
+	*orderedmap.OrderedMap[K, V]
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+// This method will be called by json.Marshal and json.MarshalIndent.
+func (omj OrderedMapJSON[K, V]) MarshalJSON() ([]byte, error) {
+	if omj.OrderedMap == nil {
+		return []byte("null"), nil
+	}
+
+	var buf bytes.Buffer
+	buf.WriteString("{")
+
+	first := true
+	for key := range omj.Keys() { // Keys() returns keys in order
+		value, _ := omj.Get(key)
+
+		if !first {
+			buf.WriteString(",")
+		}
+		first = false
+
+		// Marshal key
+		keyBytes, keyErr := json.Marshal(key)
+		if keyErr != nil {
+			return nil, fmt.Errorf("failed to marshal ordered map key (%v): %w", key, keyErr)
+		}
+		buf.Write(keyBytes)
+
+		buf.WriteString(":")
+
+		// Marshal value
+		var valBytes []byte
+		var valErr error
+
+		// Convert value (type V) to interface{} to perform dynamic type assertion
+		valAsInterface := interface{}(value)
+
+		// Check if the value is specifically an *orderedmap.OrderedMap[string, any]
+		if subMap, ok := valAsInterface.(*orderedmap.OrderedMap[string, any]); ok {
+			// For this specific project structure where maps are *orderedmap.OrderedMap[string, any],
+			// we can create a new wrapper for the sub-map.
+			wrappedSubMap := NewOrderedMapJSON[string, any](subMap)
+			valBytes, valErr = wrappedSubMap.MarshalJSON() // Recursive call to our MarshalJSON
+		} else {
+			// Standard marshalling for other types
+			valBytes, valErr = json.Marshal(valAsInterface)
+		}
+
+		if valErr != nil {
+			return nil, fmt.Errorf("failed to marshal ordered map value for key (%v): %w", key, valErr)
+		}
+		buf.Write(valBytes)
+	}
+
+	buf.WriteString("}")
+	return buf.Bytes(), nil
+}
+
+// MustMarshalJSON calls MarshalJSON and panics if an error occurs.
+func (omj OrderedMapJSON[K, V]) MustMarshalJSON() []byte {
+	data, err := omj.MarshalJSON()
+	if err != nil {
+		panic(fmt.Errorf("failed to marshal OrderedMapJSON to JSON: %w", err))
+	}
+	return data
+}

slidge_whatsapp/vendor/github.com/beeper/argo-go/label/label.go

@@ -0,0 +1,384 @@
+// Package label defines the Label type and its associated operations for Argo.
+// Labels are signed variable-length integers (encoded using ZigZag ULEB128)
+// that serve multiple purposes in the Argo binary format:
+//   - Encoding lengths of data segments (e.g., string length, array size).
+//   - Representing special marker values like Null, Absent, or Error.
+//   - Encoding backreferences to previously seen values for data deduplication.
+//
+// The package provides constants for common marker labels (Null, Absent, True, False, etc.),
+// functions to create labels from integer values, methods to determine a label's kind
+// (Length, Null, Backreference, etc.), and functions for encoding labels to and
+// decoding labels from byte streams.
+package label
+
+import (
+	"errors"
+	"fmt"
+	"math/big"
+
+	"github.com/beeper/argo-go/pkg/buf"
+	"github.com/beeper/argo-go/pkg/varint"
+)
+
+// LabelKind categorizes a Label based on its numerical value and Argo semantics.
+// Different kinds determine how the label (and potentially associated data) is interpreted.
+type LabelKind int
+
+const (
+	// LabelKindNull (-1) indicates a null or missing value where the field itself is present.
+	LabelKindNull LabelKind = iota
+	// LabelKindAbsent (-2) indicates a field or array entry that is entirely absent or omitted.
+	LabelKindAbsent
+	// LabelKindError (-3) indicates that an error occurred at this position in the data structure.
+	// The error details may follow or be found in a separate error list.
+	LabelKindError
+	// LabelKindBackreference (negative, < -3) indicates a reference to a previously encountered value.
+	// The specific negative value is used to calculate an offset to the original value.
+	LabelKindBackreference
+	// LabelKindLength (non-negative, >= 0) indicates the length of a subsequent data value (e.g., string bytes, array elements).
+	// It can also represent boolean true (1) or false/non-null marker (0) in specific contexts.
+	LabelKindLength
+)
+
+// String returns a human-readable name for the LabelKind.
+func (lk LabelKind) String() string {
+	switch lk {
+	case LabelKindNull:
+		return "Null"
+	case LabelKindAbsent:
+		return "Absent"
+	case LabelKindError:
+		return "Error"
+	case LabelKindBackreference:
+		return "Backreference"
+	case LabelKindLength:
+		// This covers lengths, true (1), false (0), and non-null (0).
+		return "Length/Boolean/Marker"
+	default:
+		return fmt.Sprintf("UnknownLabelKind(%d)", int(lk))
+	}
+}
+
+// Label wraps a *big.Int to represent an Argo label.
+// Its value determines its kind (length, null, backreference, etc.) and specific meaning.
+// Labels are immutable once created; their underlying *big.Int should not be modified
+// after creation, especially for the global Label constants.
+type Label struct {
+	value *big.Int
+}
+
+// New creates a new Label from the provided *big.Int.
+// The caller should not modify `val` after passing it to New, especially if it's
+// not a fresh *big.Int, to avoid unintended side effects on the Label.
+// If `val` is nil, a Label with a *big.Int value of 0 is created.
+func New(val *big.Int) Label {
+	if val == nil {
+		// Ensure value is never nil internally to prevent panics on method calls.
+		// Default to 0 if nil is passed; callers should ideally avoid passing nil.
+		return Label{value: big.NewInt(0)}
+	}
+	return Label{value: val}
+}
+
+// NewFromInt64 creates a new Label from an int64 value.
+// This is a convenience constructor for creating labels from standard integer types.
+func NewFromInt64(val int64) Label {
+	return Label{value: big.NewInt(val)}
+}
+
+// Value returns the underlying *big.Int of the Label.
+// Callers must not modify the returned *big.Int, as it may be shared by
+// predefined Label constants (e.g., NullMarker, TrueMarker) or other Label instances.
+// To perform arithmetic, create a new *big.Int (e.g., `new(big.Int).Set(l.Value())`).
+func (l Label) Value() *big.Int {
+	return l.value
+}
+
+// String returns the decimal string representation of the Label's underlying *big.Int value.
+func (l Label) String() string {
+	if l.value == nil {
+		// This case should ideally not be reached if constructors always ensure a non-nil l.value.
+		return "<uninitialized_label>"
+	}
+	return l.value.String()
+}
+
+// --- Internal *big.Int constants for special label values ---
+// These are unexported and used to initialize the exported Label constants and for comparisons.
+var (
+	trueMarkerBigInt    *big.Int // Represents boolean True (value 1)
+	falseMarkerBigInt   *big.Int // Represents boolean False (value 0), also used as NonNull marker
+	nonNullMarkerBigInt *big.Int // Represents a NonNull marker (value 0), indicating presence for non-labeled types
+	nullMarkerBigInt    *big.Int // Represents a Null value (value -1)
+	absentMarkerBigInt  *big.Int // Represents an Absent field/item (value -2)
+	errorMarkerBigInt   *big.Int // Represents an Error marker (value -3)
+
+	// lowestReservedBigInt is the numerically largest (i.e., closest to zero) negative *big.Int
+	// that has a special, non-backreference meaning. Values numerically smaller than this
+	// (e.g., -4, -5, ...) are considered backreferences.
+	lowestReservedBigInt *big.Int
+)
+
+// --- Exported Label constants ---
+// These provide convenient access to common, predefined label values.
+var (
+	TrueMarker          Label // Label for boolean True (value 1).
+	FalseMarker         Label // Label for boolean False (value 0).
+	NonNullMarker       Label // Label for NonNull marker (value 0); alias for FalseMarker.
+	NullMarker          Label // Label for Null (value -1).
+	AbsentMarker        Label // Label for Absent (value -2).
+	ErrorMarker         Label // Label for Error (value -3).
+	LowestReservedValue Label // Label instance for the lowest reserved non-backreference value (-3).
+)
+
+// --- Exported pre-encoded byte slices for common Label values ---
+// These are the ZigZag ULEB128 encoded forms of the marker labels.
+var (
+	Null    []byte // Encoded form of NullMarker (-1).
+	Absent  []byte // Encoded form of AbsentMarker (-2).
+	Error   []byte // Encoded form of ErrorMarker (-3).
+	Zero    []byte // Encoded form of 0 (used for FalseMarker, NonNullMarker, and length 0).
+	NonNull []byte // Encoded form of NonNullMarker (0); alias for Zero.
+	False   []byte // Encoded form of FalseMarker (0); alias for Zero.
+	True    []byte // Encoded form of TrueMarker (1).
+)
+
+// labelToOffsetFactor is used in the calculation of backreference offsets.
+// It is derived from `lowestReservedBigInt` and ensures that backreference IDs
+// map correctly to array/slice offsets.
+// Specifically, offset = -NumericValue(backreference_label) + labelToOffsetFactor.
+// If lowestReservedBigInt is -3, factor is -3 - 1 = -4.
+var labelToOffsetFactor int64
+
+func init() {
+	// Initialize *big.Int marker values.
+	trueMarkerBigInt = big.NewInt(1)
+	falseMarkerBigInt = big.NewInt(0)
+	nonNullMarkerBigInt = big.NewInt(0) // By spec, NonNull is 0, same as False.
+	nullMarkerBigInt = big.NewInt(-1)
+	absentMarkerBigInt = big.NewInt(-2)
+	errorMarkerBigInt = big.NewInt(-3)
+	// lowestReservedBigInt is set to errorMarkerBigInt (-3). Values less than this are backrefs.
+	lowestReservedBigInt = new(big.Int).Set(errorMarkerBigInt) // Use a copy for safety, though *big.Ints from NewInt are new.
+
+	// Initialize exported Label struct constants using the *big.Int markers.
+	TrueMarker = New(trueMarkerBigInt)
+	FalseMarker = New(falseMarkerBigInt)
+	NonNullMarker = New(nonNullMarkerBigInt) // Effectively New(big.NewInt(0))
+	NullMarker = New(nullMarkerBigInt)
+	AbsentMarker = New(absentMarkerBigInt)
+	ErrorMarker = New(errorMarkerBigInt)
+	LowestReservedValue = New(lowestReservedBigInt) // Label for -3
+
+	// Initialize pre-encoded byte slices for common labels.
+	Null = varint.ZigZagEncode(nullMarkerBigInt)     // ZigZag(-1)
+	Absent = varint.ZigZagEncode(absentMarkerBigInt) // ZigZag(-2)
+	Error = varint.ZigZagEncode(errorMarkerBigInt)   // ZigZag(-3)
+	Zero = varint.ZigZagEncode(big.NewInt(0))        // ZigZag(0)
+	NonNull = Zero                                   // NonNull is 0.
+	False = Zero                                     // False is 0.
+	True = varint.ZigZagEncode(big.NewInt(1))        // ZigZag(1)
+
+	// Calculate labelToOffsetFactor for backreference processing.
+	// This factor adjusts the negated backreference label value to yield a 0-indexed offset.
+	// Argo JS: labelToOffsetFactor = Number(LowestReservedValue) - 1
+	// Since LowestReservedValue is -3, labelToOffsetFactor becomes -3 - 1 = -4.
+	if !lowestReservedBigInt.IsInt64() {
+		// This should not happen as -3 is well within int64 range.
+		panic("label: internal error - lowestReservedBigInt cannot be represented as int64 during init")
+	}
+	labelToOffsetFactor = lowestReservedBigInt.Int64() - 1
+}
+
+// Kind determines and returns the semantic LabelKind of the Label (e.g., Null, Length, Backreference).
+// The kind is derived from the label's numerical value according to Argo rules.
+func (l Label) Kind() LabelKind {
+	if l.value == nil { // Should ideally not occur due to constructors ensuring non-nil.
+		// Consider this an internal error or undefined state.
+		// Returning LabelKindError or panicking might be alternatives.
+		// For now, assuming it implies an error state if reached.
+		return LabelKindError
+	}
+	if l.value.Sign() >= 0 { // Non-negative values (0, 1, lengths) are LabelKindLength.
+		return LabelKindLength
+	}
+
+	// Negative values: compare with specific marker *big.Int values.
+	if l.value.Cmp(nullMarkerBigInt) == 0 { // -1
+		return LabelKindNull
+	}
+	if l.value.Cmp(absentMarkerBigInt) == 0 { // -2
+		return LabelKindAbsent
+	}
+	if l.value.Cmp(errorMarkerBigInt) == 0 { // -3
+		return LabelKindError
+	}
+	// Any other negative value (i.e., value < -3) is a backreference.
+	return LabelKindBackreference
+}
+
+// IsNull checks if the label represents a Null value (i.e., its value is -1).
+func (l Label) IsNull() bool {
+	if l.value == nil {
+		return false // An uninitialized label is not NullMarker.
+	}
+	return l.value.Cmp(nullMarkerBigInt) == 0
+}
+
+// IsAbsent checks if the label represents an Absent value (i.e., its value is -2).
+func (l Label) IsAbsent() bool {
+	if l.value == nil {
+		return false // An uninitialized label is not AbsentMarker.
+	}
+	return l.value.Cmp(absentMarkerBigInt) == 0
+}
+
+// IsError checks if the label represents an Error marker (i.e., its value is -3).
+func (l Label) IsError() bool {
+	if l.value == nil {
+		return false // An uninitialized label is not ErrorMarker.
+	}
+	return l.value.Cmp(errorMarkerBigInt) == 0
+}
+
+// IsLength checks if the label represents a length or a non-negative marker (i.e., its value >= 0).
+// This includes actual lengths, TrueMarker (1), FalseMarker (0), and NonNullMarker (0).
+func (l Label) IsLength() bool {
+	if l.value == nil {
+		return false // An uninitialized label is not a length.
+	}
+	return l.value.Sign() >= 0
+}
+
+// IsBackref checks if the label represents a backreference.
+// A backreference label has a value numerically less than `lowestReservedBigInt` (i.e., < -3).
+func (l Label) IsBackref() bool {
+	if l.value == nil {
+		return false // An uninitialized label is not a backreference.
+	}
+	// A label is a backreference if its value is negative and not one of the special
+	// negative markers (Null, Absent, Error). This is equivalent to being < lowestReservedBigInt.
+	return l.value.Cmp(lowestReservedBigInt) < 0
+}
+
+// Encode converts the Label into its ZigZag ULEB128 encoded byte representation.
+// For common marker labels (Null, Absent, Error), it returns their pre-encoded global byte slices.
+// Otherwise, it performs ZigZag encoding on the label's *big.Int value.
+func (l Label) Encode() []byte {
+	if l.value == nil {
+		// This handles the case of an uninitialized Label struct (e.g. var lbl Label).
+		// Defaulting to encoding Null seems a reasonable, albeit potentially masking, behavior.
+		// A stricter approach might panic or return an error.
+		return Null
+	}
+
+	// Use the label's Kind to efficiently select pre-encoded values for markers.
+	switch l.Kind() {
+	case LabelKindNull:
+		return Null // Use pre-encoded global constant.
+	case LabelKindAbsent:
+		return Absent // Use pre-encoded global constant.
+	case LabelKindError:
+		return Error // Use pre-encoded global constant.
+	case LabelKindLength, LabelKindBackreference:
+		// This path handles positive numbers (lengths), zero (False/NonNull/Length 0),
+		// and true backreferences (negative values numerically smaller than errorMarkerBigInt).
+		// If l.value was, for example, exactly nullMarkerBigInt, l.Kind() would be LabelKindNull,
+		// correctly taking that path to use the pre-encoded `Null` slice.
+		return varint.ZigZagEncode(l.value)
+	default:
+		// This case should ideally not be reached if Kind() is comprehensive and l.value is valid.
+		// If an unknown or unexpected Kind were somehow produced, panicking might be appropriate
+		// as it indicates an internal logic inconsistency.
+		// For robustness in unexpected scenarios, falling back to direct encoding could be done,
+		// but it implies an issue that should be investigated.
+		// Assuming Kind() correctly categorizes all valid label values, this default is defensive.
+		// Consider logging an internal error if this path is ever taken in a production system.
+		// As a fallback, encode the raw value. This might occur if l.value was somehow
+		// set to nil *after* construction and Kind() returned an unexpected default.
+		fmt.Printf("label.Encode: warning - unexpected LabelKind, falling back to direct ZigZagEncode for value: %s\n", l.String())
+		return varint.ZigZagEncode(l.value)
+	}
+}
+
+// Read decodes a label from a buffer `b` that implements the `buf.Read` interface.
+// It reads a ZigZag ULEB128 encoded number from the buffer at its current position,
+// advances the buffer's position by the number of bytes read, and returns the decoded Label.
+// Any errors encountered during varint decoding are propagated.
+func Read(b buf.Read) (Label, error) {
+	bufferBytes := b.Bytes()
+	currentPosition := b.Position()
+
+	if currentPosition < 0 {
+		return Label{value: big.NewInt(0)}, errors.New("label: buffer position is negative, cannot read")
+	}
+
+	// Ensure currentPosition is int for slice indexing, though ZigZagDecode expects int offset.
+	// This cast is safe if b.Position() is within typical buffer size ranges.
+	// varint.ZigZagDecode will handle bounds checking against len(bufferBytes).
+	decodedBigInt, numBytesRead, err := varint.ZigZagDecode(bufferBytes, int(currentPosition))
+	if err != nil {
+		// Return a zero-value Label on error, along with the error itself.
+		return Label{value: big.NewInt(0)}, fmt.Errorf("label.Read: failed to decode varint: %w", err)
+	}
+
+	b.IncrementPosition(int64(numBytesRead))
+	return New(decodedBigInt), nil
+}
+
+// ToOffset converts a backreference Label into a 0-indexed array/slice offset.
+// The Label must represent a valid backreference (i.e., its Kind must be LabelKindBackreference).
+// An error is returned if the Label is not a valid backreference (e.g., it's non-negative
+// or one of the special markers like Null, Absent, Error), or if its value is too large
+// to be represented as an int64 after transformation (highly unlikely for practical offsets).
+// The formula used is: offset = -NumericValue(label) + labelToOffsetFactor.
+// For example, if labelToOffsetFactor is -4:
+//   - A label of -4 (smallest valid backref value) gives offset: -(-4) + (-4) = 4 - 4 = 0.
+//   - A label of -5 gives offset: -(-5) + (-4) = 5 - 4 = 1.
+func (l Label) ToOffset() (int64, error) {
+	if l.value == nil {
+		return 0, errors.New("label: ToOffset called on uninitialized Label")
+	}
+	// A label must be a true backreference to be converted to an offset.
+	// This means its value must be < lowestReservedBigInt (-3).
+	if l.Kind() != LabelKindBackreference {
+		return 0, fmt.Errorf("label: cannot convert label of kind '%s' (value %s) to offset; must be a backreference", l.Kind(), l.String())
+	}
+
+	// Perform the calculation: offset = -labelValue + labelToOffsetFactor
+	negatedLabelVal := new(big.Int).Neg(l.value)
+
+	if !negatedLabelVal.IsInt64() {
+		// This is extremely unlikely for a backreference offset but check for safety.
+		return 0, fmt.Errorf("label: negated backreference value %s too large for int64 conversion in ToOffset", negatedLabelVal.String())
+	}
+
+	offset := negatedLabelVal.Int64() + labelToOffsetFactor
+	if offset < 0 {
+		// This would indicate an issue with labelToOffsetFactor or the input label value,
+		// as valid backreferences should produce non-negative offsets.
+		return 0, fmt.Errorf("label: calculated offset %d is negative for label %s; internal logic error or invalid backreference", offset, l.String())
+	}
+	return offset, nil
+}
+
+// Is checks if this label (l) has the same numerical value as another label (other).
+// It compares their underlying *big.Int values.
+// Handles cases where one or both labels might be uninitialized (value is nil),
+// although constructors aim to prevent l.value from being nil.
+func (l Label) Is(other Label) bool {
+	val1 := l.Value() // Use Value() to respect potential nil internal value.
+	val2 := other.Value()
+
+	if val1 == nil && val2 == nil {
+		// Both are uninitialized (e.g. zero value Label struct not passed through New*).
+		// Or if New(nil) resulted in Label{value:nil} (though current New(nil) makes it 0).
+		return true
+	}
+	if val1 == nil || val2 == nil {
+		// One is initialized, the other is not (or became nil post-construction).
+		return false
+	}
+	// Both have non-nil *big.Int values, compare them.
+	return val1.Cmp(val2) == 0
+}

slidge_whatsapp/vendor/github.com/beeper/argo-go/label/wiremarkers.go

@@ -0,0 +1,37 @@
+package label
+
+var (
+	WireTypeMarkerString     Label
+	WireTypeMarkerBoolean    Label
+	WireTypeMarkerVarint     Label
+	WireTypeMarkerFloat64    Label
+	WireTypeMarkerBytes      Label
+	WireTypeMarkerFixed      Label
+	WireTypeMarkerBlock      Label
+	WireTypeMarkerNullable   Label
+	WireTypeMarkerArray      Label
+	WireTypeMarkerRecord     Label
+	WireTypeMarkerDesc       Label
+	WireTypeMarkerError      Label
+	WireTypeMarkerPath       Label
+	WireTypeMarkerUnion      Label
+	WireTypeMarkerExtensions Label
+)
+
+func init() {
+	WireTypeMarkerString = NewFromInt64(-1)
+	WireTypeMarkerBoolean = NewFromInt64(-2)
+	WireTypeMarkerVarint = NewFromInt64(-3)
+	WireTypeMarkerFloat64 = NewFromInt64(-4)
+	WireTypeMarkerBytes = NewFromInt64(-5)
+	WireTypeMarkerFixed = NewFromInt64(-6)
+	WireTypeMarkerBlock = NewFromInt64(-7)
+	WireTypeMarkerNullable = NewFromInt64(-8)
+	WireTypeMarkerArray = NewFromInt64(-9)
+	WireTypeMarkerRecord = NewFromInt64(-10)
+	WireTypeMarkerDesc = NewFromInt64(-11)
+	WireTypeMarkerError = NewFromInt64(-12)
+	WireTypeMarkerPath = NewFromInt64(-13)
+	WireTypeMarkerUnion = NewFromInt64(-14)
+	WireTypeMarkerExtensions = NewFromInt64(-15)
+}