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

slidge_whatsapp/vendor/go.mau.fi/libsignal/session/SessionCipher.go

@@ -2,6 +2,7 @@ package session
 
 import (
 	"context"
+	"errors"
 	"fmt"
 
 	"go.mau.fi/libsignal/cipher"
@@ -253,12 +254,16 @@ func (d *Cipher) DecryptWithRecord(ctx context.Context, sessionRecord *record.Se
 
 	// If we received an error using the current session state, loop
 	// through all previous states.
-	if err != nil {
+	if errors.Is(err, signalerror.ErrOldCounter) {
+		return nil, nil, err
+	} else if err != nil {
 		logger.Warning(err)
 		for i, state := range previousStates {
 			// Try decrypting the message with previous states
 			plaintext, messageKeys, err = d.DecryptWithState(ctx, state, ciphertext)
-			if err != nil {
+			if errors.Is(err, signalerror.ErrOldCounter) {
+				return nil, nil, err
+			} else if err != nil {
 				continue
 			}
 

slidge_whatsapp/vendor/go.mau.fi/util/dbutil/log.go

@@ -115,6 +115,7 @@ func (z zeroLogger) QueryTiming(ctx context.Context, method, query string, args
 	if duration >= 1*time.Second {
 		evt := log.Warn().
 			Float64("duration_seconds", duration.Seconds()).
+			AnErr("result_error", err).
 			Str("method", method).
 			Str("query", query)
 		if z.Caller {

slidge_whatsapp/vendor/go.mau.fi/util/dbutil/module.go

@@ -0,0 +1,119 @@
+// Package dbutil provides a simple framework for in-process database
+// migrations. You provide the SQL files and they are run to upgrade
+// the database. A versions table is automatically created in the
+// database to track which migrations have been applied. There is
+// support for multiple migration pathways, for example v0->v2 versus
+// v0->v1->v2, and the shorter one is prioritized if both are
+// provided.
+//
+// Example usage from Go:
+//
+//	package main
+//
+//	import (
+//		"context"
+//		"database/sql"
+//		"embed"
+//
+//		"go.mau.fi/util/dbutil"
+//	)
+//
+//	//go:embed *.sql
+//	var upgrades embed.FS
+//
+//	func mainE() error {
+//		ctx := context.Background()
+//		rawDB, err := sql.Open("sqlite3", "./hotdogs.db")
+//		if err != nil {
+//			return err
+//		}
+//		db, err := dbutil.NewWithDB(rawDB, "sqlite3")
+//		if err != nil {
+//			return err
+//		}
+//		table := dbutil.UpgradeTable{}
+//		table.RegisterFS(upgrades)
+//		err = db.Upgrade(ctx)
+//		if err != nil {
+//			return err
+//		}
+//		// db has been upgraded to latest version
+//		return nil
+//	}
+//
+// In dbutil, the database is understood to have a monotonic integer
+// sequence of versions starting at v0, v1, v2, etc. By providing
+// migrations you define a directed acyclic graph (DAG) that allows
+// dbutil to find a path from the current recorded database version to
+// the latest version available.
+//
+// Each SQL migration file has a mandatory comment header that
+// identifies which database versions it upgrades between. For example
+// this is a migration that upgrades from v0 to v2:
+//
+//	-- v0 -> v2: Do some things
+//
+// You can omit the first version for the common case of upgrading to
+// a version from the previous version. For example this is a
+// migration that upgrades from v1 to v2:
+//
+//	-- v2: Do fewer things
+//
+// By providing "v1" and "v2" migrations, a v0 database would be
+// upgraded to v1 and then v2, while by providing an additional "v0 ->
+// v2" migration a v0 database would be upgraded directly to v2 as it
+// is a more direct path. With that migration provided the "v1"
+// migration is no longer needed.
+//
+// By default, when running migrations, if a more recent database
+// version is live than the current code knows about (for example,
+// from running a previous version of the application), dbutil will
+// error out. However, many database migrations are backwards
+// compatible. You can therefore indicate this when writing a
+// migration, and previous versions of the application will accept a
+// database with that migration applied, even if they are unaware of
+// its contents. For example, if the migration from v1 to v2 was
+// backwards compatible, you could provide this migration:
+//
+//	-- v2 (compatible with v1+): Do fewer things
+//
+// When applying the migration, the compatibility level (v1) is saved
+// to the versions table in the database, so that older versions of
+// the application which only know about v1 will see that v2 of the
+// database is still OK to use. If the compatibility level is not set,
+// then it defaults to the same as the target version for the
+// migration, which achieves the default behavior described in the
+// previous paragraph.
+//
+// You can provide additional flags immediately following the header
+// line. To disable wrapping the upgrade in a single transaction, put
+// "transaction: off" on the second line.
+//
+//	-- v5: Upgrade without transaction
+//	-- transaction: off
+//	// do dangerous stuff
+//
+// Within migrations, there is special syntax that can be used to
+// filter parts of the SQL to apply only with specific dialects. To
+// limit the next line to one dialect:
+//
+//	-- only: postgres
+//
+// To limit the next N lines:
+//
+//	-- only: sqlite for next 123 lines
+//
+// To limit a block of code, fenced by another directive:
+//
+//	-- only: sqlite until "end only"
+//	QUERY;
+//	ANOTHER QUERY;
+//	-- end only sqlite
+//
+// If the single-line limit is on the second line of the file, the
+// whole file is limited to that dialect.
+//
+// If the filter ends with `(lines commented)`, then ALL lines chosen
+// by the filter will be uncommented. The `--` comment prefix must be
+// at the beginning of the line with no whitespace ahead of it.
+package dbutil

slidge_whatsapp/vendor/go.mau.fi/util/dbutil/upgradetable.go

@@ -60,24 +60,8 @@ func (ut *UpgradeTable) Register(from, to, compat int, message string, txn TxnMo
 	(*ut)[from] = upg
 }
 
-// Syntax is either
-//
-//	-- v0 -> v1: Message
-//
-// or
-//
-//	-- v1: Message
-//
-// Both syntaxes may also have a compatibility notice before the colon:
-//
-//	-- v5 (compatible with v3+): Upgrade with backwards compatibility
 var upgradeHeaderRegex = regexp.MustCompile(`^-- (?:v(\d+) -> )?v(\d+)(?: \(compatible with v(\d+)\+\))?: (.+)$`)
 
-// To disable wrapping the upgrade in a single transaction, put `--transaction: off` on the second line.
-//
-//	-- v5: Upgrade without transaction
-//	-- transaction: off
-//	// do dangerous stuff
 var transactionDisableRegex = regexp.MustCompile(`^-- transaction: ([a-z-]*)`)
 
 func parseFileHeader(file []byte) (from, to, compat int, message string, txn TxnMode, lines [][]byte, err error) {
@@ -123,24 +107,6 @@ func parseFileHeader(file []byte) (from, to, compat int, message string, txn Txn
 	return
 }
 
-// To limit the next line to one dialect:
-//
-//	-- only: postgres
-//
-// To limit the next N lines:
-//
-//	-- only: sqlite for next 123 lines
-//
-// To limit a block of code, fenced by another directive:
-//
-//	-- only: sqlite until "end only"
-//	QUERY;
-//	ANOTHER QUERY;
-//	-- end only sqlite
-//
-// If the single-line limit is on the second line of the file, the whole file is limited to that dialect.
-//
-// If the filter ends with `(lines commented)`, then ALL lines chosen by the filter will be uncommented.
 var dialectLineFilter = regexp.MustCompile(`^\s*-- only: (postgres|sqlite)(?: for next (\d+) lines| until "(end) only")?(?: \(lines? (commented)\))?`)
 
 // Constants used to make parseDialectFilter clearer
@@ -207,6 +173,9 @@ func (db *Database) filterSQLUpgrade(lines [][]byte) (string, error) {
 				}
 				if dialect == db.Dialect {
 					if uncomment {
+						if !bytes.HasPrefix(lines[i], []byte("--")) {
+							return "", fmt.Errorf("line %d isn't commented even though the dialect filter claimed it is (-- must be at beginning of line)", i+1)
+						}
 						output = append(output, bytes.TrimPrefix(lines[i], []byte("--")))
 					} else {
 						output = append(output, lines[i])

slidge_whatsapp/vendor/go.mau.fi/util/exbytes/string.go

@@ -0,0 +1,20 @@
+// 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 exbytes
+
+import (
+	"unsafe"
+)
+
+// UnsafeString returns a string that points to the same memory as the input byte slice.
+//
+// The input byte slice must not be modified after this function is called.
+//
+// See [go.mau.fi/util/exstrings.UnsafeBytes] for the reverse operation.
+func UnsafeString(b []byte) string {
+	return unsafe.String(unsafe.SliceData(b), len(b))
+}

slidge_whatsapp/vendor/go.mau.fi/util/exbytes/writer.go

@@ -0,0 +1,78 @@
+// Copyright (c) 2024 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 exbytes
+
+import (
+	"errors"
+	"fmt"
+	"io"
+)
+
+// Writer is a simple byte writer that does not allow extending the buffer.
+//
+// Writes always go after the current len() and will fail if the slice capacity is too low.
+//
+// The correct way to use this is to create a slice with sufficient capacity and zero length:
+//
+//	x := make([]byte, 0, 11)
+//	w := (*Writer)(&x)
+//	w.Write([]byte("hello"))
+//	w.WriteByte(' ')
+//	w.WriteString("world")
+//	fmt.Println(string(x)) // "hello world"
+type Writer []byte
+
+var ErrWriterBufferFull = errors.New("exbytes.Writer: buffer full")
+
+var (
+	_ io.Writer       = (*Writer)(nil)
+	_ io.StringWriter = (*Writer)(nil)
+	_ io.ByteWriter   = (*Writer)(nil)
+)
+
+func (w *Writer) extendLen(n int) (int, error) {
+	ptr := len(*w)
+	if ptr+n > cap(*w) {
+		return 0, fmt.Errorf("%w (%d + %d > %d)", ErrWriterBufferFull, ptr, n, cap(*w))
+	}
+	*w = (*w)[:ptr+n]
+	return ptr, nil
+}
+
+func (w *Writer) Write(b []byte) (n int, err error) {
+	ptr, err := w.extendLen(len(b))
+	if err != nil {
+		return 0, err
+	}
+	copy((*w)[ptr:], b)
+	return len(b), nil
+}
+
+func (w *Writer) WriteString(s string) (n int, err error) {
+	ptr, err := w.extendLen(len(s))
+	if err != nil {
+		return 0, err
+	}
+	copy((*w)[ptr:], s)
+	return len(s), nil
+}
+
+func (w *Writer) WriteByte(r byte) error {
+	ptr, err := w.extendLen(1)
+	if err != nil {
+		return err
+	}
+	(*w)[ptr] = r
+	return nil
+}
+
+func (w *Writer) String() string {
+	if w == nil {
+		return "<nil>"
+	}
+	return string(*w)
+}

slidge_whatsapp/vendor/go.mau.fi/util/exslices/cast.go

@@ -0,0 +1,42 @@
+// Copyright (c) 2024 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 exslices
+
+func CastFunc[To, From any](source []From, conv func(From) To) []To {
+	result := make([]To, len(source))
+	for i, v := range source {
+		result[i] = conv(v)
+	}
+	return result
+}
+
+func CastFuncFilter[To, From any](source []From, conv func(From) (To, bool)) []To {
+	result := make([]To, 0, len(source))
+	for _, v := range source {
+		res, ok := conv(v)
+		if ok {
+			result = append(result, res)
+		}
+	}
+	return result
+}
+
+func CastToString[To, From ~string](source []From) []To {
+	result := make([]To, len(source))
+	for i, v := range source {
+		result[i] = To(v)
+	}
+	return result
+}
+
+func CastToAny[From any](source []From) []any {
+	result := make([]any, len(source))
+	for i, v := range source {
+		result[i] = v
+	}
+	return result
+}

slidge_whatsapp/vendor/go.mau.fi/util/exslices/chunk.go

@@ -0,0 +1,28 @@
+// Copyright (c) 2024 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 exslices
+
+// Chunk splits a slice into chunks of the given size.
+//
+// From https://github.com/golang/go/issues/53987#issuecomment-1224367139
+//
+// TODO remove this after slices.Chunk can be used (it'll probably be added in Go 1.23, so it can be used after 1.22 is EOL)
+func Chunk[T any](slice []T, size int) (chunks [][]T) {
+	if size < 1 {
+		panic("chunk size cannot be less than 1")
+	}
+	for i := 0; ; i++ {
+		next := i * size
+		if len(slice[next:]) > size {
+			end := next + size
+			chunks = append(chunks, slice[next:end:end])
+		} else {
+			chunks = append(chunks, slice[i*size:])
+			return
+		}
+	}
+}

slidge_whatsapp/vendor/go.mau.fi/util/exslices/deduplicate.go

@@ -0,0 +1,67 @@
+// Copyright (c) 2024 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 exslices
+
+// DeduplicateUnsorted removes duplicates from the given slice without requiring that the input slice is sorted.
+// The order of the output will be the same as the input. The input slice will not be modified.
+//
+// If you don't care about the order of the output, it's recommended to sort the list and then use [slices.Compact].
+func DeduplicateUnsorted[T comparable](s []T) []T {
+	return deduplicateUnsortedInto(s, make([]T, 0, len(s)))
+}
+
+// DeduplicateUnsortedOverwrite removes duplicates from the given slice without requiring that the input slice is sorted.
+// The input slice will be modified and used as the output slice to avoid extra allocations.
+//
+// If you don't care about the order of the output, it's recommended to sort the list and then use [slices.Compact].
+func DeduplicateUnsortedOverwrite[T comparable](s []T) []T {
+	out := deduplicateUnsortedInto(s, s[:0])
+	clear(s[len(out):])
+	return out
+}
+
+func deduplicateUnsortedInto[T comparable](s, result []T) []T {
+	seen := make(map[T]struct{}, len(s))
+	for _, item := range s {
+		if _, ok := seen[item]; !ok {
+			seen[item] = struct{}{}
+			result = append(result, item)
+		}
+	}
+	return result
+}
+
+// DeduplicateUnsortedFunc removes duplicates from the given slice using the given key function without requiring
+// that the input slice is sorted. The order of the output will be the same as the input.
+//
+// If you don't care about the order of the output, it's recommended to sort the list and then use [slices.CompactFunc].
+func DeduplicateUnsortedFunc[T any, K comparable](s []T, getKey func(T) K) []T {
+	return deduplicateUnsortedFuncInto(s, make([]T, 0, len(s)), getKey)
+}
+
+// DeduplicateUnsortedOverwriteFunc removes duplicates from the given slice using the given key function
+// without requiring that the input slice is sorted. The order of the output will be the same as the input.
+// The input slice will be modified and used as the output slice to avoid extra allocations.
+//
+// If you don't care about the order of the output, it's recommended to sort the list and then use [slices.CompactFunc].
+func DeduplicateUnsortedOverwriteFunc[T any, K comparable](s []T, getKey func(T) K) []T {
+	out := deduplicateUnsortedFuncInto(s, s[:0], getKey)
+	clear(s[len(out):])
+	return out
+}
+
+func deduplicateUnsortedFuncInto[T any, K comparable](s, result []T, getKey func(T) K) []T {
+	seen := make(map[K]struct{}, len(s))
+	for _, item := range s {
+		key := getKey(item)
+		if _, ok := seen[key]; !ok {
+			seen[key] = struct{}{}
+			result = append(result, item)
+		}
+	}
+	return result
+}

slidge_whatsapp/vendor/go.mau.fi/util/exslices/diff.go

@@ -0,0 +1,63 @@
+// Copyright (c) 2023 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 exslices
+
+// SortedDiff returns the difference between two already-sorted slices, with the help of the given comparison function.
+// The output will be in the same order as the input, which means it'll be sorted.
+func SortedDiff[T any](a, b []T, compare func(a, b T) int) (uniqueToA, uniqueToB []T) {
+	uniqueToA = make([]T, 0, len(a))
+	uniqueToB = make([]T, 0, len(b))
+
+	var i, j int
+	for {
+		if j >= len(b) {
+			uniqueToA = append(uniqueToA, a[i:]...)
+			break
+		} else if i >= len(a) {
+			uniqueToB = append(uniqueToB, b[j:]...)
+			break
+		}
+		c := compare(a[i], b[j])
+		if c < 0 {
+			uniqueToA = append(uniqueToA, a[i])
+			i++
+		} else if c > 0 {
+			uniqueToB = append(uniqueToB, b[j])
+			j++
+		} else {
+			i++
+			j++
+		}
+	}
+	return
+}
+
+// Diff returns the difference between two slices. The slices may contain duplicates and don't need to be sorted.
+// The output will not be sorted, but is guaranteed to not contain any duplicates.
+func Diff[T comparable](a, b []T) (uniqueToA, uniqueToB []T) {
+	maxLen := len(a)
+	if len(b) > maxLen {
+		maxLen = len(b)
+	}
+	collector := make(map[T]uint8, maxLen)
+	for _, item := range a {
+		collector[item] |= 0b01
+	}
+	for _, item := range b {
+		collector[item] |= 0b10
+	}
+	uniqueToA = make([]T, 0, maxLen)
+	uniqueToB = make([]T, 0, maxLen)
+	for item, mask := range collector {
+		if mask == 0b01 {
+			uniqueToA = append(uniqueToA, item)
+		} else if mask == 0b10 {
+			uniqueToB = append(uniqueToB, item)
+		}
+	}
+	return
+}

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

@@ -8,6 +8,7 @@ package exsync
 
 import (
 	"context"
+	"fmt"
 	"sync"
 	"time"
 )
@@ -50,7 +51,7 @@ func (e *Event) Wait(ctx context.Context) error {
 	}
 }
 
-// WaitTimeout waits for either the event to happen within the given timeout.
+// WaitTimeout waits for the event to happen within the given timeout.
 // If the timeout expires first, the return value is false, otherwise it's true.
 func (e *Event) WaitTimeout(timeout time.Duration) bool {
 	select {
@@ -61,6 +62,19 @@ func (e *Event) WaitTimeout(timeout time.Duration) bool {
 	}
 }
 
+// WaitTimeoutCtx waits for the event to happen, the timeout to expire, or the given context to be done.
+// If the context or timeout is done first, an error is returned, otherwise the return value is nil.
+func (e *Event) WaitTimeoutCtx(ctx context.Context, timeout time.Duration) error {
+	select {
+	case <-e.GetChan():
+		return nil
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-time.After(timeout):
+		return fmt.Errorf("exsync.Event: wait timeout")
+	}
+}
+
 // IsSet returns true if the event has been set.
 func (e *Event) IsSet() bool {
 	e.l.RLock()

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

@@ -6,7 +6,11 @@
 
 package exsync
 
-import "sync"
+import (
+	"iter"
+	"maps"
+	"sync"
+)
 
 // Map is a simple map with a built-in mutex.
 type Map[Key comparable, Value any] struct {
@@ -15,8 +19,13 @@ type Map[Key comparable, Value any] struct {
 }
 
 func NewMap[Key comparable, Value any]() *Map[Key, Value] {
+	return NewMapWithData(make(map[Key]Value))
+}
+
+// NewMapWithData constructs a Map with the given map as data. Accessing the map directly after passing it here is not safe.
+func NewMapWithData[Key comparable, Value any](data map[Key]Value) *Map[Key, Value] {
 	return &Map[Key, Value]{
-		data: make(map[Key]Value),
+		data: data,
 	}
 }
 
@@ -77,18 +86,50 @@ func (sm *Map[Key, Value]) GetOrSet(key Key, value Value) (actual Value, wasGet
 	return
 }
 
+// Clear removes all items from the map.
+func (sm *Map[Key, Value]) Clear() {
+	sm.lock.Lock()
+	clear(sm.data)
+	sm.lock.Unlock()
+}
+
+// Len returns the number of items in the map.
+func (sm *Map[Key, Value]) Len() int {
+	sm.lock.RLock()
+	l := len(sm.data)
+	sm.lock.RUnlock()
+	return l
+}
+
+// CopyFrom copies all key/value pairs from the given map into this map, overriding any existing keys.
+// Keys present in this map but not in the given map are not removed.
+func (sm *Map[Key, Value]) CopyFrom(other map[Key]Value) {
+	sm.lock.Lock()
+	maps.Copy(sm.data, other)
+	sm.lock.Unlock()
+}
+
 // Clone returns a copy of the map.
 func (sm *Map[Key, Value]) Clone() *Map[Key, Value] {
-	return &Map[Key, Value]{data: sm.CopyData()}
+	return NewMapWithData(sm.CopyData())
 }
 
 // CopyData returns a copy of the data in the map as a normal (non-atomic) map.
 func (sm *Map[Key, Value]) CopyData() map[Key]Value {
 	sm.lock.RLock()
-	copied := make(map[Key]Value, len(sm.data))
-	for key, value := range sm.data {
-		copied[key] = value
-	}
+	copied := maps.Clone(sm.data)
 	sm.lock.RUnlock()
 	return copied
 }
+
+func (sm *Map[Key, Value]) Iter() iter.Seq2[Key, Value] {
+	return func(yield func(Key, Value) bool) {
+		sm.lock.RLock()
+		defer sm.lock.RUnlock()
+		for k, v := range sm.data {
+			if !yield(k, v) {
+				return
+			}
+		}
+	}
+}

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

@@ -7,6 +7,7 @@
 package exsync
 
 import (
+	"iter"
 	"sync"
 )
 
@@ -134,3 +135,15 @@ func (s *Set[T]) AsList() []T {
 	s.l.RUnlock()
 	return list
 }
+
+func (s *Set[T]) Iter() iter.Seq[T] {
+	return func(yield func(T) bool) {
+		s.l.RLock()
+		defer s.l.RUnlock()
+		for item := range s.m {
+			if !yield(item) {
+				return
+			}
+		}
+	}
+}