slidge-whatsapp 0.2.6__cp313-cp313-manylinux_2_36_aarch64.whl → 0.3.0__cp313-cp313-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/github.com/vektah/gqlparser/v2/ast/path.go

@@ -0,0 +1,72 @@
+package ast
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+var _ json.Unmarshaler = (*Path)(nil)
+
+type Path []PathElement
+
+type PathElement interface {
+	isPathElement()
+}
+
+var (
+	_ PathElement = PathIndex(0)
+	_ PathElement = PathName("")
+)
+
+func (path Path) String() string {
+	if path == nil {
+		return ""
+	}
+	var str bytes.Buffer
+	for i, v := range path {
+		switch v := v.(type) {
+		case PathIndex:
+			str.WriteString(fmt.Sprintf("[%d]", v))
+		case PathName:
+			if i != 0 {
+				str.WriteByte('.')
+			}
+			str.WriteString(string(v))
+		default:
+			panic(fmt.Sprintf("unknown type: %T", v))
+		}
+	}
+	return str.String()
+}
+
+func (path *Path) UnmarshalJSON(b []byte) error {
+	var vs []interface{}
+	err := json.Unmarshal(b, &vs)
+	if err != nil {
+		return err
+	}
+
+	*path = make([]PathElement, 0, len(vs))
+	for _, v := range vs {
+		switch v := v.(type) {
+		case string:
+			*path = append(*path, PathName(v))
+		case int:
+			*path = append(*path, PathIndex(v))
+		case float64:
+			*path = append(*path, PathIndex(int(v)))
+		default:
+			return fmt.Errorf("unknown path element type: %T", v)
+		}
+	}
+	return nil
+}
+
+type PathIndex int
+
+func (PathIndex) isPathElement() {}
+
+type PathName string
+
+func (PathName) isPathElement() {}

slidge_whatsapp/vendor/github.com/vektah/gqlparser/v2/ast/selection.go

@@ -0,0 +1,41 @@
+package ast
+
+type SelectionSet []Selection
+
+type Selection interface {
+	isSelection()
+	GetPosition() *Position
+}
+
+func (*Field) isSelection()          {}
+func (*FragmentSpread) isSelection() {}
+func (*InlineFragment) isSelection() {}
+
+func (f *Field) GetPosition() *Position          { return f.Position }
+func (s *FragmentSpread) GetPosition() *Position { return s.Position }
+func (f *InlineFragment) GetPosition() *Position { return f.Position }
+
+type Field struct {
+	Alias        string
+	Name         string
+	Arguments    ArgumentList
+	Directives   DirectiveList
+	SelectionSet SelectionSet
+	Position     *Position `dump:"-" json:"-"`
+	Comment      *CommentGroup
+
+	// Require validation
+	Definition       *FieldDefinition
+	ObjectDefinition *Definition
+}
+
+type Argument struct {
+	Name     string
+	Value    *Value
+	Position *Position `dump:"-" json:"-"`
+	Comment  *CommentGroup
+}
+
+func (f *Field) ArgumentMap(vars map[string]interface{}) map[string]interface{} {
+	return arg2map(f.Definition.Arguments, f.Arguments, vars)
+}

slidge_whatsapp/vendor/github.com/vektah/gqlparser/v2/ast/source.go

@@ -0,0 +1,19 @@
+package ast
+
+// Source covers a single *.graphql file
+type Source struct {
+	// Name is the filename of the source
+	Name string
+	// Input is the actual contents of the source file
+	Input string
+	// BuiltIn indicate whether the source is a part of the specification
+	BuiltIn bool
+}
+
+type Position struct {
+	Start  int     // The starting position, in runes, of this token in the input.
+	End    int     // The end position, in runes, of this token in the input.
+	Line   int     // The line number at the start of this item.
+	Column int     // The column number at the start of this item.
+	Src    *Source // The source document this token belongs to
+}

slidge_whatsapp/vendor/github.com/vektah/gqlparser/v2/ast/type.go

@@ -0,0 +1,68 @@
+package ast
+
+func NonNullNamedType(named string, pos *Position) *Type {
+	return &Type{NamedType: named, NonNull: true, Position: pos}
+}
+
+func NamedType(named string, pos *Position) *Type {
+	return &Type{NamedType: named, NonNull: false, Position: pos}
+}
+
+func NonNullListType(elem *Type, pos *Position) *Type {
+	return &Type{Elem: elem, NonNull: true, Position: pos}
+}
+
+func ListType(elem *Type, pos *Position) *Type {
+	return &Type{Elem: elem, NonNull: false, Position: pos}
+}
+
+type Type struct {
+	NamedType string
+	Elem      *Type
+	NonNull   bool
+	Position  *Position `dump:"-" json:"-"`
+}
+
+func (t *Type) Name() string {
+	if t.NamedType != "" {
+		return t.NamedType
+	}
+
+	return t.Elem.Name()
+}
+
+func (t *Type) String() string {
+	nn := ""
+	if t.NonNull {
+		nn = "!"
+	}
+	if t.NamedType != "" {
+		return t.NamedType + nn
+	}
+
+	return "[" + t.Elem.String() + "]" + nn
+}
+
+func (t *Type) IsCompatible(other *Type) bool {
+	if t.NamedType != other.NamedType {
+		return false
+	}
+
+	if t.Elem != nil && other.Elem == nil {
+		return false
+	}
+
+	if t.Elem != nil && !t.Elem.IsCompatible(other.Elem) {
+		return false
+	}
+
+	if other.NonNull {
+		return t.NonNull
+	}
+
+	return true
+}
+
+func (t *Type) Dump() string {
+	return t.String()
+}

slidge_whatsapp/vendor/github.com/vektah/gqlparser/v2/ast/value.go

@@ -0,0 +1,122 @@
+package ast
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type ValueKind int
+
+const (
+	Variable ValueKind = iota
+	IntValue
+	FloatValue
+	StringValue
+	BlockValue
+	BooleanValue
+	NullValue
+	EnumValue
+	ListValue
+	ObjectValue
+)
+
+type Value struct {
+	Raw      string
+	Children ChildValueList
+	Kind     ValueKind
+	Position *Position `dump:"-" json:"-"`
+	Comment  *CommentGroup
+
+	// Require validation
+	Definition         *Definition
+	VariableDefinition *VariableDefinition
+	ExpectedType       *Type
+}
+
+type ChildValue struct {
+	Name     string
+	Value    *Value
+	Position *Position `dump:"-" json:"-"`
+	Comment  *CommentGroup
+}
+
+func (v *Value) Value(vars map[string]interface{}) (interface{}, error) {
+	if v == nil {
+		return nil, nil
+	}
+	switch v.Kind {
+	case Variable:
+		if value, ok := vars[v.Raw]; ok {
+			return value, nil
+		}
+		if v.VariableDefinition != nil && v.VariableDefinition.DefaultValue != nil {
+			return v.VariableDefinition.DefaultValue.Value(vars)
+		}
+		return nil, nil
+	case IntValue:
+		return strconv.ParseInt(v.Raw, 10, 64)
+	case FloatValue:
+		return strconv.ParseFloat(v.Raw, 64)
+	case StringValue, BlockValue, EnumValue:
+		return v.Raw, nil
+	case BooleanValue:
+		return strconv.ParseBool(v.Raw)
+	case NullValue:
+		return nil, nil
+	case ListValue:
+		var val []interface{}
+		for _, elem := range v.Children {
+			elemVal, err := elem.Value.Value(vars)
+			if err != nil {
+				return val, err
+			}
+			val = append(val, elemVal)
+		}
+		return val, nil
+	case ObjectValue:
+		val := map[string]interface{}{}
+		for _, elem := range v.Children {
+			elemVal, err := elem.Value.Value(vars)
+			if err != nil {
+				return val, err
+			}
+			val[elem.Name] = elemVal
+		}
+		return val, nil
+	default:
+		panic(fmt.Errorf("unknown value kind %d", v.Kind))
+	}
+}
+
+func (v *Value) String() string {
+	if v == nil {
+		return "<nil>"
+	}
+	switch v.Kind {
+	case Variable:
+		return "$" + v.Raw
+	case IntValue, FloatValue, EnumValue, BooleanValue, NullValue:
+		return v.Raw
+	case StringValue, BlockValue:
+		return strconv.Quote(v.Raw)
+	case ListValue:
+		var val []string
+		for _, elem := range v.Children {
+			val = append(val, elem.Value.String())
+		}
+		return "[" + strings.Join(val, ",") + "]"
+	case ObjectValue:
+		var val []string
+		for _, elem := range v.Children {
+			val = append(val, elem.Name+":"+elem.Value.String())
+		}
+		return "{" + strings.Join(val, ",") + "}"
+	default:
+		panic(fmt.Errorf("unknown value kind %d", v.Kind))
+	}
+}
+
+func (v *Value) Dump() string {
+	return v.String()
+}

slidge_whatsapp/vendor/go.mau.fi/util/exhttp/handleerrors.go

@@ -6,21 +6,29 @@
 
 package exhttp
 
-import "net/http"
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/http"
+)
 
-type ErrorBodyGenerators struct {
-	NotFound         func() []byte
-	MethodNotAllowed func() []byte
+type ErrorBodies struct {
+	NotFound         json.RawMessage
+	MethodNotAllowed json.RawMessage
 }
 
-func HandleErrors(next http.Handler, gen ErrorBodyGenerators) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		next.ServeHTTP(&bodyOverrider{
-			ResponseWriter:                      w,
-			statusNotFoundBodyGenerator:         gen.NotFound,
-			statusMethodNotAllowedBodyGenerator: gen.MethodNotAllowed,
-		}, r)
-	})
+func HandleErrors(gen ErrorBodies) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			next.ServeHTTP(&bodyOverrider{
+				ResponseWriter:             w,
+				statusNotFoundBody:         gen.NotFound,
+				statusMethodNotAllowedBody: gen.MethodNotAllowed,
+			}, r)
+		})
+	}
 }
 
 type bodyOverrider struct {
@@ -28,17 +36,26 @@ type bodyOverrider struct {
 
 	code     int
 	override bool
+	written  bool
+
+	hijacked bool
 
-	statusNotFoundBodyGenerator         func() []byte
-	statusMethodNotAllowedBodyGenerator func() []byte
+	statusNotFoundBody         json.RawMessage
+	statusMethodNotAllowedBody json.RawMessage
 }
 
-var _ http.ResponseWriter = (*bodyOverrider)(nil)
+var (
+	_ http.ResponseWriter = (*bodyOverrider)(nil)
+	_ http.Flusher        = (*bodyOverrider)(nil)
+	_ http.Hijacker       = (*bodyOverrider)(nil)
+)
 
 func (b *bodyOverrider) WriteHeader(code int) {
-	if b.Header().Get("Content-Type") == "text/plain; charset=utf-8" {
-		b.Header().Set("Content-Type", "application/json")
+	if !b.hijacked &&
+		b.Header().Get("Content-Type") == "text/plain; charset=utf-8" &&
+		(code == http.StatusNotFound || code == http.StatusMethodNotAllowed) {
 
+		b.Header().Set("Content-Type", "application/json")
 		b.override = true
 	}
 
@@ -46,19 +63,36 @@ func (b *bodyOverrider) WriteHeader(code int) {
 	b.ResponseWriter.WriteHeader(code)
 }
 
-func (b *bodyOverrider) Write(body []byte) (int, error) {
+func (b *bodyOverrider) Write(body []byte) (n int, err error) {
 	if b.override {
-		switch b.code {
-		case http.StatusNotFound:
-			if b.statusNotFoundBodyGenerator != nil {
-				body = b.statusNotFoundBodyGenerator()
-			}
-		case http.StatusMethodNotAllowed:
-			if b.statusMethodNotAllowedBodyGenerator != nil {
-				body = b.statusMethodNotAllowedBodyGenerator()
+		n = len(body)
+		if !b.written {
+			switch b.code {
+			case http.StatusNotFound:
+				_, err = b.ResponseWriter.Write(b.statusNotFoundBody)
+			case http.StatusMethodNotAllowed:
+				_, err = b.ResponseWriter.Write(b.statusMethodNotAllowedBody)
 			}
 		}
+		b.written = true
+		return
 	}
 
 	return b.ResponseWriter.Write(body)
 }
+
+func (b *bodyOverrider) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	hijacker, ok := b.ResponseWriter.(http.Hijacker)
+	if !ok {
+		return nil, nil, fmt.Errorf("HandleErrors: %T does not implement http.Hijacker", b.ResponseWriter)
+	}
+	b.hijacked = true
+	return hijacker.Hijack()
+}
+
+func (b *bodyOverrider) Flush() {
+	flusher, ok := b.ResponseWriter.(http.Flusher)
+	if ok {
+		flusher.Flush()
+	}
+}

slidge_whatsapp/vendor/go.mau.fi/util/exhttp/json.go

@@ -32,10 +32,5 @@ func WriteJSONData(w http.ResponseWriter, httpStatusCode int, data []byte) {
 }
 
 func WriteEmptyJSONResponse(w http.ResponseWriter, httpStatusCode int) {
-	if AutoAllowCORS {
-		AddCORSHeaders(w)
-	}
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(httpStatusCode)
-	_, _ = w.Write([]byte("{}"))
+	WriteJSONData(w, httpStatusCode, []byte("{}"))
 }

slidge_whatsapp/vendor/go.mau.fi/util/exhttp/networkerror.go

@@ -26,7 +26,8 @@ func IsNetworkError(err error) bool {
 			errno == syscall.ETIMEDOUT ||
 			errno == syscall.ECONNREFUSED ||
 			errno == syscall.EHOSTDOWN ||
-			errno == syscall.EHOSTUNREACH
+			errno == syscall.EHOSTUNREACH ||
+			errno == syscall.EPIPE
 	} else if netError := net.Error(nil); errors.As(err, &netError) {
 		return true
 	} else if errors.As(err, &http2.StreamError{}) {

slidge_whatsapp/vendor/go.mau.fi/util/exstrings/stringutil.go

@@ -0,0 +1,104 @@
+// Copyright (c) 2025 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exstrings
+
+import (
+	"crypto/sha256"
+	"crypto/subtle"
+	"strings"
+	"unsafe"
+)
+
+// UnsafeBytes returns a byte slice that points to the same memory as the input string.
+//
+// The returned byte slice must not be modified.
+//
+// See [go.mau.fi/util/exbytes.UnsafeString] for the reverse operation.
+func UnsafeBytes(str string) []byte {
+	return unsafe.Slice(unsafe.StringData(str), len(str))
+}
+
+// SHA256 returns the SHA-256 hash of the input string without copying the string.
+func SHA256(str string) [32]byte {
+	return sha256.Sum256(UnsafeBytes(str))
+}
+
+// ConstantTimeEqual compares two strings using [subtle.ConstantTimeCompare] without copying the strings.
+//
+// Note that ConstantTimeCompare is not constant time if the strings are of different length.
+func ConstantTimeEqual(a, b string) bool {
+	return subtle.ConstantTimeCompare(UnsafeBytes(a), UnsafeBytes(b)) == 1
+}
+
+// LongestSequenceOf returns the length of the longest contiguous sequence of a single rune in a string.
+func LongestSequenceOf(a string, b rune) int {
+	// IndexRune has some optimizations, so use it to find the starting point
+	firstIndex := strings.IndexRune(a, b)
+	if firstIndex == -1 {
+		return 0
+	}
+	count := 0
+	maxCount := 0
+	for _, r := range a[firstIndex:] {
+		if r == b {
+			count++
+			if count > maxCount {
+				maxCount = count
+			}
+		} else {
+			count = 0
+		}
+	}
+	return maxCount
+}
+
+// PrefixByteRunLength returns the number of the given byte at the start of a string.
+func PrefixByteRunLength(s string, b byte) int {
+	count := 0
+	for ; count < len(s) && s[count] == b; count++ {
+	}
+	return count
+}
+
+// CollapseSpaces replaces all runs of multiple spaces (\x20) in a string with a single space.
+func CollapseSpaces(s string) string {
+	doubleSpaceIdx := strings.Index(s, "  ")
+	if doubleSpaceIdx < 0 {
+		return s
+	}
+	var buf strings.Builder
+	buf.Grow(len(s))
+	for doubleSpaceIdx >= 0 {
+		buf.WriteString(s[:doubleSpaceIdx+1])
+		spaceCount := PrefixByteRunLength(s[doubleSpaceIdx+2:], ' ') + 2
+		s = s[doubleSpaceIdx+spaceCount:]
+		doubleSpaceIdx = strings.Index(s, "  ")
+	}
+	buf.WriteString(s)
+	return buf.String()
+}
+
+// LongestSequenceOfFunc returns the length of the longest contiguous sequence of runes in a string.
+//
+// If the provided function returns zero or higher, the return value is added to the current count.
+// If the return value is negative, the count is reset to zero.
+func LongestSequenceOfFunc(a string, fn func(b rune) int) int {
+	count := 0
+	maxCount := 0
+	for _, r := range a {
+		val := fn(r)
+		if val < 0 {
+			count = 0
+		} else {
+			count += val
+			if count > maxCount {
+				maxCount = count
+			}
+		}
+	}
+	return maxCount
+}

slidge_whatsapp/vendor/go.mau.fi/util/exsync/event.go

@@ -16,9 +16,10 @@ import (
 //
 // It's modelled after Python's asyncio.Event: https://docs.python.org/3/library/asyncio-sync.html#asyncio.Event
 type Event struct {
-	ch  chan empty
-	set bool
-	l   sync.RWMutex
+	ch      chan empty
+	set     bool
+	waiting bool
+	l       sync.RWMutex
 }
 
 // NewEvent creates a new event. It will initially be unset.
@@ -34,6 +35,7 @@ type EventChan = <-chan empty
 func (e *Event) GetChan() EventChan {
 	e.l.RLock()
 	defer e.l.RUnlock()
+	e.waiting = true
 	return e.ch
 }
 
@@ -76,6 +78,19 @@ func (e *Event) Set() {
 	}
 }
 
+// Notify notifies all waiters, but doesn't set the event.
+//
+// Calling Notify when the event is already set is a no-op.
+func (e *Event) Notify() {
+	e.l.Lock()
+	defer e.l.Unlock()
+	if !e.set && e.waiting {
+		close(e.ch)
+		e.ch = make(chan empty)
+		e.waiting = false
+	}
+}
+
 // Clear clears the event, making it unset. Future calls to Wait will now block until Set is called again.
 // If the event is not already set, this is a no-op and existing calls to Wait will keep working.
 func (e *Event) Clear() {
@@ -84,5 +99,6 @@ func (e *Event) Clear() {
 	if e.set {
 		e.ch = make(chan empty)
 		e.set = false
+		e.waiting = false
 	}
 }

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+    rev: v6.0.0
     hooks:
       - id: trailing-whitespace
         exclude_types: [markdown]
@@ -11,7 +11,7 @@ repos:
       - id: check-added-large-files
 
   - repo: https://github.com/tekwizely/pre-commit-golang
-    rev: v1.0.0-rc.1
+    rev: v1.0.0-rc.2
     hooks:
       - id: go-imports-repo
         args:
@@ -24,7 +24,7 @@ repos:
       - id: go-mod-tidy
 
   - repo: https://github.com/beeper/pre-commit-go
-    rev: v0.3.1
+    rev: v0.4.2
     hooks:
       # TODO enable this
       #- id: zerolog-ban-msgf

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/appstate/decode.go

@@ -288,7 +288,7 @@ func (proc *Processor) DecodePatches(ctx context.Context, list *PatchList, initi
 
 		if validateMACs {
 			var keys ExpandedAppStateKeys
-			keys, err = proc.validateSnapshotMAC(ctx, list.Name, currentState, patch.GetKeyID().GetID(), patch.GetSnapshotMac())
+			keys, err = proc.validateSnapshotMAC(ctx, list.Name, currentState, patch.GetKeyID().GetID(), patch.GetSnapshotMAC())
 			if err != nil {
 				return
 			}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/appstate/hash.go

@@ -80,7 +80,7 @@ func (hs *HashState) generateSnapshotMAC(name WAPatchName, key []byte) []byte {
 
 func generatePatchMAC(patch *waServerSync.SyncdPatch, name WAPatchName, key []byte, version uint64) []byte {
 	dataToHash := make([][]byte, len(patch.GetMutations())+3)
-	dataToHash[0] = patch.GetSnapshotMac()
+	dataToHash[0] = patch.GetSnapshotMAC()
 	for i, mutation := range patch.Mutations {
 		val := mutation.GetRecord().GetValue().GetBlob()
 		dataToHash[i+1] = val[len(val)-32:]

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/appstate.go

@@ -134,7 +134,11 @@ func (cli *Client) dispatchAppState(ctx context.Context, mutation appstate.Mutat
 		eventToDispatch = &events.Mute{JID: jid, Timestamp: ts, Action: act, FromFullSync: fullSync}
 		var mutedUntil time.Time
 		if act.GetMuted() {
-			mutedUntil = time.UnixMilli(act.GetMuteEndTimestamp())
+			if act.GetMuteEndTimestamp() < 0 {
+				mutedUntil = store.MutedForever
+			} else {
+				mutedUntil = time.UnixMilli(act.GetMuteEndTimestamp())
+			}
 		}
 		if cli.Store.ChatSettings != nil {
 			storeUpdateError = cli.Store.ChatSettings.PutMutedUntil(ctx, jid, mutedUntil)