slidge-whatsapp 0.2.5__cp311-cp311-manylinux_2_36_aarch64.whl → 0.2.7__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/github.com/petermattis/goid/runtime_gccgo_go1.8.go

@@ -0,0 +1,17 @@
+//go:build gccgo && go1.8
+// +build gccgo,go1.8
+
+package goid
+
+// https://github.com/gcc-mirror/gcc/blob/releases/gcc-7/libgo/go/runtime/runtime2.go#L329-L354
+
+type g struct {
+	_panic       uintptr
+	_defer       uintptr
+	m            uintptr
+	syscallsp    uintptr
+	syscallpc    uintptr
+	param        uintptr
+	atomicstatus uint32
+	goid         int64 // Here it is!
+}

slidge_whatsapp/vendor/github.com/petermattis/goid/runtime_go1.23.go

@@ -0,0 +1,38 @@
+//go:build gc && go1.23
+// +build gc,go1.23
+
+package goid
+
+type stack struct {
+	lo uintptr
+	hi uintptr
+}
+
+type gobuf struct {
+	sp   uintptr
+	pc   uintptr
+	g    uintptr
+	ctxt uintptr
+	ret  uintptr
+	lr   uintptr
+	bp   uintptr
+}
+
+type g struct {
+	stack       stack
+	stackguard0 uintptr
+	stackguard1 uintptr
+
+	_panic       uintptr
+	_defer       uintptr
+	m            uintptr
+	sched        gobuf
+	syscallsp    uintptr
+	syscallpc    uintptr
+	syscallbp    uintptr
+	stktopsp     uintptr
+	param        uintptr
+	atomicstatus uint32
+	stackLock    uint32
+	goid         int64 // Here it is!
+}

slidge_whatsapp/vendor/github.com/petermattis/goid/runtime_go1.5.go

@@ -0,0 +1,57 @@
+// Copyright 2016 Peter Mattis.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+// implied. See the License for the specific language governing
+// permissions and limitations under the License. See the AUTHORS file
+// for names of contributors.
+
+//go:build go1.5 && !go1.6
+// +build go1.5,!go1.6
+
+package goid
+
+// Just enough of the structs from runtime/runtime2.go to get the offset to goid.
+// See https://github.com/golang/go/blob/release-branch.go1.5/src/runtime/runtime2.go
+
+type stack struct {
+	lo uintptr
+	hi uintptr
+}
+
+type gobuf struct {
+	sp   uintptr
+	pc   uintptr
+	g    uintptr
+	ctxt uintptr
+	ret  uintptr
+	lr   uintptr
+	bp   uintptr
+}
+
+type g struct {
+	stack       stack
+	stackguard0 uintptr
+	stackguard1 uintptr
+
+	_panic       uintptr
+	_defer       uintptr
+	m            uintptr
+	stackAlloc   uintptr
+	sched        gobuf
+	syscallsp    uintptr
+	syscallpc    uintptr
+	stkbar       []uintptr
+	stkbarPos    uintptr
+	param        uintptr
+	atomicstatus uint32
+	stackLock    uint32
+	goid         int64 // Here it is!
+}

slidge_whatsapp/vendor/github.com/petermattis/goid/runtime_go1.6.go

@@ -0,0 +1,43 @@
+//go:build gc && go1.6 && !go1.9
+// +build gc,go1.6,!go1.9
+
+package goid
+
+// Just enough of the structs from runtime/runtime2.go to get the offset to goid.
+// See https://github.com/golang/go/blob/release-branch.go1.6/src/runtime/runtime2.go
+
+type stack struct {
+	lo uintptr
+	hi uintptr
+}
+
+type gobuf struct {
+	sp   uintptr
+	pc   uintptr
+	g    uintptr
+	ctxt uintptr
+	ret  uintptr
+	lr   uintptr
+	bp   uintptr
+}
+
+type g struct {
+	stack       stack
+	stackguard0 uintptr
+	stackguard1 uintptr
+
+	_panic       uintptr
+	_defer       uintptr
+	m            uintptr
+	stackAlloc   uintptr
+	sched        gobuf
+	syscallsp    uintptr
+	syscallpc    uintptr
+	stkbar       []uintptr
+	stkbarPos    uintptr
+	stktopsp     uintptr
+	param        uintptr
+	atomicstatus uint32
+	stackLock    uint32
+	goid         int64 // Here it is!
+}

slidge_whatsapp/vendor/github.com/petermattis/goid/runtime_go1.9.go

@@ -0,0 +1,37 @@
+//go:build gc && go1.9 && !go1.23
+// +build gc,go1.9,!go1.23
+
+package goid
+
+type stack struct {
+	lo uintptr
+	hi uintptr
+}
+
+type gobuf struct {
+	sp   uintptr
+	pc   uintptr
+	g    uintptr
+	ctxt uintptr
+	ret  uintptr
+	lr   uintptr
+	bp   uintptr
+}
+
+type g struct {
+	stack       stack
+	stackguard0 uintptr
+	stackguard1 uintptr
+
+	_panic       uintptr
+	_defer       uintptr
+	m            uintptr
+	sched        gobuf
+	syscallsp    uintptr
+	syscallpc    uintptr
+	stktopsp     uintptr
+	param        uintptr
+	atomicstatus uint32
+	stackLock    uint32
+	goid         int64 // Here it is!
+}

slidge_whatsapp/vendor/github.com/rs/zerolog/CONTRIBUTING.md

@@ -0,0 +1,43 @@
+# Contributing to Zerolog
+
+Thank you for your interest in contributing to **Zerolog**!
+
+Zerolog is a **feature-complete**, high-performance logging library designed to be **lean** and **non-bloated**. The focus of ongoing development is on **bug fixes**, **performance improvements**, and **modernization efforts** (such as keeping up with Go best practices and compatibility with newer Go versions).
+
+## What We're Looking For
+
+We welcome contributions in the following areas:
+
+- **Bug Fixes**: If you find an issue or unexpected behavior, please open an issue and/or submit a fix.
+- **Performance Optimizations**: Improvements that reduce memory usage, allocation count, or CPU cycles without introducing complexity are appreciated.
+- **Modernization**: Compatibility updates for newer Go versions or idiomatic improvements that do not increase library size or complexity.
+- **Documentation Enhancements**: Corrections, clarifications, and improvements to documentation or code comments.
+
+## What We're *Not* Looking For
+
+Zerolog is intended to remain **minimalistic and efficient**. Therefore, we are **not accepting**:
+
+- New features that add optional behaviors or extend API surface area.
+- Built-in support for frameworks or external systems (e.g., bindings, integrations).
+- General-purpose abstractions or configuration helpers.
+
+If you're unsure whether a change aligns with the project's philosophy, feel free to open an issue for discussion before submitting a PR.
+
+## Contributing Guidelines
+
+1. **Fork the repository**
+2. **Create a branch** for your fix or improvement
+3. **Write tests** to cover your changes
+4. Ensure `go test ./...` passes
+5. Run `go fmt` and `go vet` to ensure code consistency
+6. **Submit a pull request** with a clear explanation of the motivation and impact
+
+## Code Style
+
+- Keep the code simple, efficient, and idiomatic.
+- Avoid introducing new dependencies.
+- Preserve backwards compatibility unless explicitly discussed.
+
+---
+
+We appreciate your effort in helping us keep Zerolog fast, minimal, and reliable!

slidge_whatsapp/vendor/github.com/rs/zerolog/README.md

@@ -366,6 +366,37 @@ log.Info().Str("foo", "bar").Msg("Hello World")
 // Output: 2006-01-02T15:04:05Z07:00 | INFO  | ***Hello World**** foo:BAR
 ```
 
+To use custom advanced formatting:
+
+```go
+output := zerolog.ConsoleWriter{Out: os.Stdout, NoColor: true,
+    PartsOrder:    []string{"level", "one", "two", "three", "message"},
+    FieldsExclude: []string{"one", "two", "three"}}
+output.FormatLevel = func(i interface{}) string { return strings.ToUpper(fmt.Sprintf("%-6s", i)) }
+output.FormatFieldName = func(i interface{}) string { return fmt.Sprintf("%s:", i) }
+output.FormatPartValueByName = func(i interface{}, s string) string {
+    var ret string
+    switch s {
+    case "one":
+        ret = strings.ToUpper(fmt.Sprintf("%s", i))
+    case "two":
+        ret = strings.ToLower(fmt.Sprintf("%s", i))
+    case "three":
+        ret = strings.ToLower(fmt.Sprintf("(%s)", i))
+    }
+    return ret
+}
+log := zerolog.New(output)
+
+log.Info().Str("foo", "bar").
+    Str("two", "TEST_TWO").
+    Str("one", "test_one").
+    Str("three", "test_three").
+    Msg("Hello World")
+    
+// Output: INFO   TEST_ONE test_two (test_three) Hello World foo:bar
+```
+
 ### Sub dictionary
 
 ```go

slidge_whatsapp/vendor/github.com/rs/zerolog/console.go

@@ -47,6 +47,10 @@ const (
 // Formatter transforms the input into a formatted string.
 type Formatter func(interface{}) string
 
+// FormatterByFieldName transforms the input into a formatted string,
+// being able to differentiate formatting based on field name.
+type FormatterByFieldName func(interface{}, string) string
+
 // ConsoleWriter parses the JSON input and writes it in an
 // (optionally) colorized, human-friendly format to Out.
 type ConsoleWriter struct {
@@ -85,6 +89,9 @@ type ConsoleWriter struct {
 	FormatFieldValue    Formatter
 	FormatErrFieldName  Formatter
 	FormatErrFieldValue Formatter
+	// If this is configured it is used for "part" values and
+	// has precedence on FormatFieldValue
+	FormatPartValueByName FormatterByFieldName
 
 	FormatExtra func(map[string]interface{}, *bytes.Buffer) error
 
@@ -282,8 +289,9 @@ func (w ConsoleWriter) writeFields(evt map[string]interface{}, buf *bytes.Buffer
 // writePart appends a formatted part to buf.
 func (w ConsoleWriter) writePart(buf *bytes.Buffer, evt map[string]interface{}, p string) {
 	var f Formatter
+	var fvn FormatterByFieldName
 
-	if w.PartsExclude != nil && len(w.PartsExclude) > 0 {
+	if len(w.PartsExclude) > 0 {
 		for _, exclude := range w.PartsExclude {
 			if exclude == p {
 				return
@@ -317,14 +325,21 @@ func (w ConsoleWriter) writePart(buf *bytes.Buffer, evt map[string]interface{},
 			f = w.FormatCaller
 		}
 	default:
-		if w.FormatFieldValue == nil {
-			f = consoleDefaultFormatFieldValue
-		} else {
+		if w.FormatPartValueByName != nil {
+			fvn = w.FormatPartValueByName
+		} else if w.FormatFieldValue != nil {
 			f = w.FormatFieldValue
+		} else {
+			f = consoleDefaultFormatFieldValue
 		}
 	}
 
-	var s = f(evt[p])
+	var s string
+	if f == nil {
+		s = fvn(evt[p], p)
+	} else {
+		s = f(evt[p])
+	}
 
 	if len(s) > 0 {
 		if buf.Len() > 0 {

slidge_whatsapp/vendor/github.com/rs/zerolog/log/log.go

@@ -0,0 +1,131 @@
+// Package log provides a global logger for zerolog.
+package log
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/rs/zerolog"
+)
+
+// Logger is the global logger.
+var Logger = zerolog.New(os.Stderr).With().Timestamp().Logger()
+
+// Output duplicates the global logger and sets w as its output.
+func Output(w io.Writer) zerolog.Logger {
+	return Logger.Output(w)
+}
+
+// With creates a child logger with the field added to its context.
+func With() zerolog.Context {
+	return Logger.With()
+}
+
+// Level creates a child logger with the minimum accepted level set to level.
+func Level(level zerolog.Level) zerolog.Logger {
+	return Logger.Level(level)
+}
+
+// Sample returns a logger with the s sampler.
+func Sample(s zerolog.Sampler) zerolog.Logger {
+	return Logger.Sample(s)
+}
+
+// Hook returns a logger with the h Hook.
+func Hook(h zerolog.Hook) zerolog.Logger {
+	return Logger.Hook(h)
+}
+
+// Err starts a new message with error level with err as a field if not nil or
+// with info level if err is nil.
+//
+// You must call Msg on the returned event in order to send the event.
+func Err(err error) *zerolog.Event {
+	return Logger.Err(err)
+}
+
+// Trace starts a new message with trace level.
+//
+// You must call Msg on the returned event in order to send the event.
+func Trace() *zerolog.Event {
+	return Logger.Trace()
+}
+
+// Debug starts a new message with debug level.
+//
+// You must call Msg on the returned event in order to send the event.
+func Debug() *zerolog.Event {
+	return Logger.Debug()
+}
+
+// Info starts a new message with info level.
+//
+// You must call Msg on the returned event in order to send the event.
+func Info() *zerolog.Event {
+	return Logger.Info()
+}
+
+// Warn starts a new message with warn level.
+//
+// You must call Msg on the returned event in order to send the event.
+func Warn() *zerolog.Event {
+	return Logger.Warn()
+}
+
+// Error starts a new message with error level.
+//
+// You must call Msg on the returned event in order to send the event.
+func Error() *zerolog.Event {
+	return Logger.Error()
+}
+
+// Fatal starts a new message with fatal level. The os.Exit(1) function
+// is called by the Msg method.
+//
+// You must call Msg on the returned event in order to send the event.
+func Fatal() *zerolog.Event {
+	return Logger.Fatal()
+}
+
+// Panic starts a new message with panic level. The message is also sent
+// to the panic function.
+//
+// You must call Msg on the returned event in order to send the event.
+func Panic() *zerolog.Event {
+	return Logger.Panic()
+}
+
+// WithLevel starts a new message with level.
+//
+// You must call Msg on the returned event in order to send the event.
+func WithLevel(level zerolog.Level) *zerolog.Event {
+	return Logger.WithLevel(level)
+}
+
+// Log starts a new message with no level. Setting zerolog.GlobalLevel to
+// zerolog.Disabled will still disable events produced by this method.
+//
+// You must call Msg on the returned event in order to send the event.
+func Log() *zerolog.Event {
+	return Logger.Log()
+}
+
+// Print sends a log event using debug level and no extra field.
+// Arguments are handled in the manner of fmt.Print.
+func Print(v ...interface{}) {
+	Logger.Debug().CallerSkipFrame(1).Msg(fmt.Sprint(v...))
+}
+
+// Printf sends a log event using debug level and no extra field.
+// Arguments are handled in the manner of fmt.Printf.
+func Printf(format string, v ...interface{}) {
+	Logger.Debug().CallerSkipFrame(1).Msgf(format, v...)
+}
+
+// Ctx returns the Logger associated with the ctx. If no logger
+// is associated, a disabled logger is returned.
+func Ctx(ctx context.Context) *zerolog.Logger {
+	return zerolog.Ctx(ctx)
+}

slidge_whatsapp/vendor/github.com/rs/zerolog/log.go

@@ -494,7 +494,7 @@ func (l *Logger) newEvent(level Level, done func(string)) *Event {
 	if level != NoLevel && LevelFieldName != "" {
 		e.Str(LevelFieldName, LevelFieldMarshalFunc(level))
 	}
-	if l.context != nil && len(l.context) > 1 {
+	if len(l.context) > 1 {
 		e.buf = enc.AppendObjectData(e.buf, l.context)
 	}
 	if l.stack {

slidge_whatsapp/vendor/github.com/rs/zerolog/sampler.go

@@ -47,6 +47,9 @@ type BasicSampler struct {
 // Sample implements the Sampler interface.
 func (s *BasicSampler) Sample(lvl Level) bool {
 	n := s.N
+	if n == 0 {
+		return false
+	}
 	if n == 1 {
 		return true
 	}
@@ -87,7 +90,7 @@ func (s *BurstSampler) inc() uint32 {
 	now := TimestampFunc().UnixNano()
 	resetAt := atomic.LoadInt64(&s.resetAt)
 	var c uint32
-	if now > resetAt {
+	if now >= resetAt {
 		c = 1
 		atomic.StoreUint32(&s.counter, c)
 		newResetAt := now + s.Period.Nanoseconds()

slidge_whatsapp/vendor/github.com/rs/zerolog/writer.go

@@ -213,6 +213,15 @@ func (w *FilteredLevelWriter) WriteLevel(level Level, p []byte) (int, error) {
 	return len(p), nil
 }
 
+// Call the underlying writer's Close method if it is an io.Closer. Otherwise
+// does nothing.
+func (w *FilteredLevelWriter) Close() error {
+	if closer, ok := w.Writer.(io.Closer); ok {
+		return closer.Close()
+	}
+	return nil
+}
+
 var triggerWriterPool = &sync.Pool{
 	New: func() interface{} {
 		return bytes.NewBuffer(make([]byte, 0, 1024))

slidge_whatsapp/vendor/go.mau.fi/libsignal/groups/GroupCipher.go

@@ -1,6 +1,7 @@
 package groups
 
 import (
+	"context"
 	"fmt"
 
 	"go.mau.fi/libsignal/cipher"
@@ -34,9 +35,12 @@ type GroupCipher struct {
 }
 
 // Encrypt will take the given message in bytes and return encrypted bytes.
-func (c *GroupCipher) Encrypt(plaintext []byte) (protocol.GroupCiphertextMessage, error) {
+func (c *GroupCipher) Encrypt(ctx context.Context, plaintext []byte) (protocol.GroupCiphertextMessage, error) {
 	// Load the sender key based on id from our store.
-	keyRecord := c.senderKeyStore.LoadSenderKey(c.senderKeyID)
+	keyRecord, err := c.senderKeyStore.LoadSenderKey(ctx, c.senderKeyID)
+	if err != nil {
+		return nil, err
+	}
 	senderKeyState, err := keyRecord.SenderKeyState()
 	if err != nil {
 		return nil, err
@@ -63,15 +67,20 @@ func (c *GroupCipher) Encrypt(plaintext []byte) (protocol.GroupCiphertextMessage
 	)
 
 	senderKeyState.SetSenderChainKey(senderKeyState.SenderChainKey().Next())
-	c.senderKeyStore.StoreSenderKey(c.senderKeyID, keyRecord)
+	if err := c.senderKeyStore.StoreSenderKey(ctx, c.senderKeyID, keyRecord); err != nil {
+		return nil, err
+	}
 
 	return senderKeyMessage, nil
 }
 
 // Decrypt decrypts the given message using an existing session that
 // is stored in the senderKey store.
-func (c *GroupCipher) Decrypt(senderKeyMessage *protocol.SenderKeyMessage) ([]byte, error) {
-	keyRecord := c.senderKeyStore.LoadSenderKey(c.senderKeyID)
+func (c *GroupCipher) Decrypt(ctx context.Context, senderKeyMessage *protocol.SenderKeyMessage) ([]byte, error) {
+	keyRecord, err := c.senderKeyStore.LoadSenderKey(ctx, c.senderKeyID)
+	if err != nil {
+		return nil, err
+	}
 
 	if keyRecord.IsEmpty() {
 		return nil, fmt.Errorf("%w for %s in %s", signalerror.ErrNoSenderKeyForUser, c.senderKeyID.Sender().String(), c.senderKeyID.GroupID())
@@ -101,7 +110,9 @@ func (c *GroupCipher) Decrypt(senderKeyMessage *protocol.SenderKeyMessage) ([]by
 	}
 
 	// Store the sender key by id.
-	c.senderKeyStore.StoreSenderKey(c.senderKeyID, keyRecord)
+	if err := c.senderKeyStore.StoreSenderKey(ctx, c.senderKeyID, keyRecord); err != nil {
+		return nil, err
+	}
 
 	return plaintext, nil
 }

slidge_whatsapp/vendor/go.mau.fi/libsignal/groups/GroupSessionBuilder.go

@@ -9,6 +9,8 @@
 package groups
 
 import (
+	"context"
+
 	"go.mau.fi/libsignal/groups/state/record"
 	"go.mau.fi/libsignal/groups/state/store"
 	"go.mau.fi/libsignal/protocol"
@@ -34,21 +36,27 @@ type SessionBuilder struct {
 
 // Process will process an incoming group message and set up the corresponding
 // session for it.
-func (b *SessionBuilder) Process(senderKeyName *protocol.SenderKeyName,
-	msg *protocol.SenderKeyDistributionMessage) {
+func (b *SessionBuilder) Process(ctx context.Context, senderKeyName *protocol.SenderKeyName,
+	msg *protocol.SenderKeyDistributionMessage) error {
 
-	senderKeyRecord := b.senderKeyStore.LoadSenderKey(senderKeyName)
+	senderKeyRecord, err := b.senderKeyStore.LoadSenderKey(ctx, senderKeyName)
+	if err != nil {
+		return err
+	}
 	if senderKeyRecord == nil {
 		senderKeyRecord = record.NewSenderKey(b.serializer.SenderKeyRecord, b.serializer.SenderKeyState)
 	}
 	senderKeyRecord.AddSenderKeyState(msg.ID(), msg.Iteration(), msg.ChainKey(), msg.SignatureKey())
-	b.senderKeyStore.StoreSenderKey(senderKeyName, senderKeyRecord)
+	return b.senderKeyStore.StoreSenderKey(ctx, senderKeyName, senderKeyRecord)
 }
 
 // Create will create a new group session for the given name.
-func (b *SessionBuilder) Create(senderKeyName *protocol.SenderKeyName) (*protocol.SenderKeyDistributionMessage, error) {
+func (b *SessionBuilder) Create(ctx context.Context, senderKeyName *protocol.SenderKeyName) (*protocol.SenderKeyDistributionMessage, error) {
 	// Load the senderkey by name
-	senderKeyRecord := b.senderKeyStore.LoadSenderKey(senderKeyName)
+	senderKeyRecord, err := b.senderKeyStore.LoadSenderKey(ctx, senderKeyName)
+	if err != nil {
+		return nil, err
+	}
 
 	// If the record is empty, generate new keys.
 	if senderKeyRecord == nil || senderKeyRecord.IsEmpty() {
@@ -62,7 +70,9 @@ func (b *SessionBuilder) Create(senderKeyName *protocol.SenderKeyName) (*protoco
 			keyhelper.GenerateSenderKey(),
 			signingKey,
 		)
-		b.senderKeyStore.StoreSenderKey(senderKeyName, senderKeyRecord)
+		if err := b.senderKeyStore.StoreSenderKey(ctx, senderKeyName, senderKeyRecord); err != nil {
+			return nil, err
+		}
 	}
 
 	// Get the senderkey state.

slidge_whatsapp/vendor/go.mau.fi/libsignal/groups/state/store/SenderKeyStore.go

@@ -1,11 +1,13 @@
 package store
 
 import (
+	"context"
+
 	"go.mau.fi/libsignal/groups/state/record"
 	"go.mau.fi/libsignal/protocol"
 )
 
 type SenderKey interface {
-	StoreSenderKey(senderKeyName *protocol.SenderKeyName, keyRecord *record.SenderKey)
-	LoadSenderKey(senderKeyName *protocol.SenderKeyName) *record.SenderKey
+	StoreSenderKey(ctx context.Context, senderKeyName *protocol.SenderKeyName, keyRecord *record.SenderKey) error
+	LoadSenderKey(ctx context.Context, senderKeyName *protocol.SenderKeyName) (*record.SenderKey, error)
 }

slidge_whatsapp/vendor/go.mau.fi/libsignal/keys/chain/ChainKey.go

@@ -4,6 +4,7 @@ package chain
 import (
 	"crypto/hmac"
 	"crypto/sha256"
+
 	"go.mau.fi/libsignal/kdf"
 	"go.mau.fi/libsignal/keys/message"
 )

slidge_whatsapp/vendor/go.mau.fi/libsignal/keys/identity/IdentityKey.go

@@ -4,6 +4,7 @@ package identity
 
 import (
 	"encoding/hex"
+
 	"go.mau.fi/libsignal/ecc"
 )
 

slidge_whatsapp/vendor/go.mau.fi/libsignal/logger/DefaultLogger.go

@@ -77,9 +77,9 @@ func (d *defaultLogger) Error(caller, msg string) {
 // allows granular logging of different go files.
 //
 // Example:
-//   logger.Configure("RootKey.go,Curve.go")
-//   logger.Configure("all")
 //
+//	logger.Configure("RootKey.go,Curve.go")
+//	logger.Configure("all")
 func (d *defaultLogger) Configure(settings string) {
 	d.namespaces = strings.Split(settings, ",")
 }

slidge_whatsapp/vendor/go.mau.fi/libsignal/serialize/FingerprintProtocol.pb.go

@@ -9,10 +9,11 @@
 package serialize
 
 import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	reflect "reflect"
 	sync "sync"
+
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 )
 
 const (