slidge-whatsapp 0.2.6__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/wirecodec/decode.go

@@ -0,0 +1,341 @@
+package wirecodec
+
+import (
+	"encoding/binary"
+	"fmt"
+	"math"
+
+	"github.com/beeper/argo-go/block"
+	"github.com/beeper/argo-go/codec"
+	"github.com/beeper/argo-go/header"
+	"github.com/beeper/argo-go/label"
+	"github.com/beeper/argo-go/pkg/buf"
+	"github.com/beeper/argo-go/wire"
+)
+
+type anyBlockReader interface {
+	Read(parent buf.Read) (interface{}, error)
+}
+
+type genericBlockReaderWrapper struct {
+	coreRead        func(parentBuf buf.Read) (interface{}, error)
+	blockDataBuffer buf.Read
+}
+
+func (g *genericBlockReaderWrapper) Read(parentBuf buf.Read) (interface{}, error) {
+	return g.coreRead(parentBuf)
+}
+
+type Decoder struct {
+	r       buf.Read
+	slicer  *codec.MessageSlicer
+	readers map[wire.BlockKey]anyBlockReader
+}
+
+func NewFromSlicer(s *codec.MessageSlicer) *Decoder {
+	return &Decoder{
+		r:       s.Core(),
+		slicer:  s,
+		readers: make(map[wire.BlockKey]anyBlockReader),
+	}
+}
+
+func (d *Decoder) DecodeWireType() (wire.Type, error) {
+	lbl, err := label.Read(d.r)
+	if err != nil {
+		return nil, err
+	}
+
+	switch {
+	// ---------- scalars ----------
+	case label.WireTypeMarkerString.Is(lbl):
+		return wire.String, nil
+	case label.WireTypeMarkerBoolean.Is(lbl):
+		return wire.Boolean, nil
+	case label.WireTypeMarkerVarint.Is(lbl):
+		return wire.Varint, nil
+	case label.WireTypeMarkerFloat64.Is(lbl):
+		return wire.Float64, nil
+	case label.WireTypeMarkerBytes.Is(lbl):
+		return wire.Bytes, nil
+	case label.WireTypeMarkerFixed.Is(lbl):
+		lengthLbl, err := label.Read(d.r)
+		if err != nil {
+			return nil, err
+		}
+		n := int(lengthLbl.Value().Int64())
+		if n < 0 {
+			return nil, fmt.Errorf("wirecodec: negative FIXED length %d", n)
+		}
+		return wire.FixedType{Length: n}, nil
+
+	// ---------- block ----------
+	case label.WireTypeMarkerBlock.Is(lbl):
+		// Only scalar/desc allowed for block element
+		elem, err := d.decodeScalarWireType()
+		if err != nil {
+			return nil, err
+		}
+		key, err := d.readBlockString()
+		if err != nil {
+			return nil, err
+		}
+		dedupe, err := d.readBlockBool()
+		if err != nil {
+			return nil, err
+		}
+		return wire.NewBlockType(elem, wire.BlockKey(key), dedupe), nil
+
+	// ---------- wrappers ----------
+	case label.WireTypeMarkerNullable.Is(lbl):
+		of, err := d.DecodeWireType()
+		if err != nil {
+			return nil, err
+		}
+		return wire.NewNullableType(of), nil
+
+	case label.WireTypeMarkerArray.Is(lbl):
+		of, err := d.DecodeWireType()
+		if err != nil {
+			return nil, err
+		}
+		return wire.ArrayType{Of: of}, nil
+
+	// ---------- record ----------
+	case label.WireTypeMarkerRecord.Is(lbl):
+		lenLbl, err := label.Read(d.r)
+		if err != nil {
+			return nil, err
+		}
+		n := int(lenLbl.Value().Int64())
+		if n < 0 {
+			return nil, fmt.Errorf("wirecodec: negative record-field count %d", n)
+		}
+		return d.decodeRecord(n)
+
+	// ---------- simple markers ----------
+	case label.WireTypeMarkerDesc.Is(lbl):
+		return wire.Desc, nil
+	case label.WireTypeMarkerError.Is(lbl):
+		return wire.Error, nil
+	case label.WireTypeMarkerPath.Is(lbl):
+		return wire.Path, nil
+	case label.WireTypeMarkerExtensions.Is(lbl):
+		return wire.Extensions, nil
+	}
+
+	return nil, fmt.Errorf("wirecodec: unknown wire-type label %s", lbl.Value().String())
+}
+
+func (d *Decoder) DecodeWireTypeStore() (map[string]wire.Type, error) {
+	objLbl, err := label.Read(d.r)
+	if err != nil {
+		return nil, err
+	}
+	if !wire.SelfDescribingTypeMarkerObject.Is(objLbl) {
+		return nil, fmt.Errorf("wirecodec: expected object marker, found %v", objLbl.Value())
+	}
+
+	cntLbl, err := label.Read(d.r)
+	if err != nil {
+		return nil, err
+	}
+	n := int(cntLbl.Value().Int64())
+	if n < 0 {
+		return nil, fmt.Errorf("wirecodec: negative type-store length %d", n)
+	}
+
+	out := make(map[string]wire.Type, n)
+	for i := 0; i < n; i++ {
+		name, err := d.readBlockString()
+		if err != nil {
+			return nil, fmt.Errorf("wirecodec: read store name: %w", err)
+		}
+		wt, err := d.DecodeWireType()
+		if err != nil {
+			return nil, fmt.Errorf("wirecodec: decode type %q: %w", name, err)
+		}
+		out[name] = wt
+	}
+	return out, nil
+}
+
+func (d *Decoder) decodeScalarWireType() (wire.Type, error) {
+	lbl, err := label.Read(d.r)
+	if err != nil {
+		return nil, err
+	}
+
+	switch {
+	case label.WireTypeMarkerString.Is(lbl):
+		return wire.String, nil
+	case label.WireTypeMarkerBoolean.Is(lbl):
+		return wire.Boolean, nil
+	case label.WireTypeMarkerVarint.Is(lbl):
+		return wire.Varint, nil
+	case label.WireTypeMarkerFloat64.Is(lbl):
+		return wire.Float64, nil
+	case label.WireTypeMarkerBytes.Is(lbl):
+		return wire.Bytes, nil
+	case label.WireTypeMarkerFixed.Is(lbl):
+		lenLbl, err := label.Read(d.r)
+		if err != nil {
+			return nil, err
+		}
+		n := int(lenLbl.Value().Int64())
+		if n < 0 {
+			return nil, fmt.Errorf("wirecodec: negative FIXED length %d", n)
+		}
+		return wire.FixedType{Length: n}, nil
+	case label.WireTypeMarkerDesc.Is(lbl):
+		return wire.Desc, nil
+	}
+	return nil, fmt.Errorf("wirecodec: invalid scalar wire-type label %s", lbl.Value().String())
+}
+
+func (d *Decoder) decodeRecord(length int) (wire.Type, error) {
+	if length < 0 {
+		return nil, fmt.Errorf("wirecodec: negative record-field count %d", length)
+	}
+	fields := make([]wire.Field, 0, length)
+	for i := 0; i < length; i++ {
+		name, err := d.readBlockString()
+		if err != nil {
+			return nil, fmt.Errorf("record field %d name: %w", i, err)
+		}
+		ft, err := d.DecodeWireType()
+		if err != nil {
+			return nil, fmt.Errorf("record field %q type: %w", name, err)
+		}
+		omit, err := d.readBlockBool()
+		if err != nil {
+			return nil, fmt.Errorf("record field %q omittable: %w", name, err)
+		}
+		fields = append(fields, wire.Field{Name: name, Of: ft, Omittable: omit})
+	}
+	return wire.RecordType{Fields: fields}, nil
+}
+
+func (d *Decoder) readBlockString() (string, error) {
+	key := wire.BlockKey("String")
+	elem, ok := wire.SelfDescribingBlocks[key]
+	if !ok {
+		return "", fmt.Errorf("wirecodec: self-describing String block not found")
+	}
+	blk := wire.NewBlockType(elem, key, wire.MustDeduplicateByDefault(elem))
+
+	r, err := d.getBlockReader(blk, wire.String)
+	if err != nil {
+		return "", fmt.Errorf("wirecodec: get String block reader: %w", err)
+	}
+	v, err := r.Read(d.r)
+	if err != nil {
+		return "", fmt.Errorf("wirecodec: read String from block: %w", err)
+	}
+	s, ok := v.(string)
+	if !ok {
+		return "", fmt.Errorf("wirecodec: String block reader returned %T", v)
+	}
+	return s, nil
+}
+
+func (d *Decoder) readBlockBool() (bool, error) {
+	lbl, err := label.Read(d.r)
+	if err != nil {
+		return false, err
+	}
+	switch {
+	case label.FalseMarker.Is(lbl):
+		return false, nil
+	case label.TrueMarker.Is(lbl):
+		return true, nil
+	default:
+		return false, fmt.Errorf("wirecodec: expected boolean marker got %v", lbl.Value())
+	}
+}
+
+func DecodeWireTypeStoreFile(msg []byte) (map[string]wire.Type, error) {
+	slicer, err := codec.NewMessageSlicer(buf.NewBufReadonly(msg))
+	if err != nil {
+		return nil, err
+	}
+	return NewFromSlicer(slicer).DecodeWireTypeStore()
+}
+
+func (d *Decoder) getBlockReader(blockDef wire.BlockType, valueWireType wire.Type) (anyBlockReader, error) {
+	if r, ok := d.readers[blockDef.Key]; ok {
+		return r, nil
+	}
+	r, err := d.makeBlockReader(valueWireType, blockDef.Dedupe, blockDef.Key)
+	if err != nil {
+		return nil, err
+	}
+	d.readers[blockDef.Key] = r
+	return r, nil
+}
+
+func (d *Decoder) makeBlockReader(valueWireType wire.Type, dedupe bool, key wire.BlockKey) (anyBlockReader, error) {
+	blockData := d.slicer.NextBlock()
+	if blockData == nil {
+		if !d.slicer.Header().GetFlag(header.HeaderInlineEverythingFlag) {
+			return nil, fmt.Errorf("wirecodec: no more block segments for key %s", key)
+		}
+		blockData = d.slicer.Core()
+		if blockData == nil {
+			return nil, fmt.Errorf("wirecodec: core buffer nil in inline-everything mode for %s", key)
+		}
+	}
+
+	var coreRead func(parentBuf buf.Read) (interface{}, error)
+
+	switch t := valueWireType.(type) {
+	case wire.StringType:
+		nt := d.slicer.Header().GetFlag(header.HeaderNullTerminatedStringsFlag)
+		fromBytes := func(b []byte) string { return string(b) }
+		if dedupe {
+			r := block.NewDeduplicatingLabelBlockReader[string](blockData, fromBytes, nt)
+			coreRead = func(p buf.Read) (interface{}, error) { return r.Read(p) }
+		} else {
+			r := block.NewLabelBlockReader[string](blockData, fromBytes, nt)
+			coreRead = func(p buf.Read) (interface{}, error) { return r.Read(p) }
+		}
+
+	case wire.BytesType:
+		fromBytes := func(b []byte) []byte { return b }
+		if dedupe {
+			r := block.NewDeduplicatingLabelBlockReader[[]byte](blockData, fromBytes, false)
+			coreRead = func(p buf.Read) (interface{}, error) { return r.Read(p) }
+		} else {
+			r := block.NewLabelBlockReader[[]byte](blockData, fromBytes, false)
+			coreRead = func(p buf.Read) (interface{}, error) { return r.Read(p) }
+		}
+
+	case wire.VarintType:
+		if dedupe {
+			return nil, fmt.Errorf("wirecodec: deduping VARINT via label blocks not supported for %s", key)
+		}
+		r := block.NewUnlabeledVarIntBlockReader(blockData)
+		coreRead = func(p buf.Read) (interface{}, error) { return r.Read(p) }
+
+	case wire.Float64Type:
+		if dedupe {
+			return nil, fmt.Errorf("wirecodec: deduping FLOAT64 not supported for %s", key)
+		}
+		fromBytes := func(b []byte) float64 { return math.Float64frombits(binary.LittleEndian.Uint64(b)) }
+		r := block.NewFixedSizeBlockReader[float64](blockData, fromBytes, 8)
+		coreRead = func(p buf.Read) (interface{}, error) { return r.Read(p) }
+
+	case wire.FixedType:
+		if dedupe {
+			return nil, fmt.Errorf("wirecodec: deduping FIXED not supported for %s", key)
+		}
+		fromBytes := func(b []byte) []byte { return b }
+		r := block.NewFixedSizeBlockReader[[]byte](blockData, fromBytes, t.Length)
+		coreRead = func(p buf.Read) (interface{}, error) { return r.Read(p) }
+
+	default:
+		return nil, fmt.Errorf("wirecodec: unsupported block value type %s for key %s", wire.Print(valueWireType), key)
+	}
+
+	return &genericBlockReaderWrapper{coreRead: coreRead, blockDataBuffer: blockData}, nil
+}

slidge_whatsapp/vendor/github.com/elliotchance/orderedmap/v3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Elliot Chance
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

slidge_whatsapp/vendor/github.com/elliotchance/orderedmap/v3/list.go

@@ -0,0 +1,95 @@
+package orderedmap
+
+// Element is an element of a null terminated (non circular) intrusive doubly linked list that contains the key of the correspondent element in the ordered map too.
+type Element[K comparable, V any] struct {
+	// Next and previous pointers in the doubly-linked list of elements.
+	// To simplify the implementation, internally a list l is implemented
+	// as a ring, such that &l.root is both the next element of the last
+	// list element (l.Back()) and the previous element of the first list
+	// element (l.Front()).
+	next, prev *Element[K, V]
+
+	// The key that corresponds to this element in the ordered map.
+	Key K
+
+	// The value stored with this element.
+	Value V
+}
+
+// Next returns the next list element or nil.
+func (e *Element[K, V]) Next() *Element[K, V] {
+	return e.next
+}
+
+// Prev returns the previous list element or nil.
+func (e *Element[K, V]) Prev() *Element[K, V] {
+	return e.prev
+}
+
+// list represents a null terminated (non circular) intrusive doubly linked list.
+// The list is immediately usable after instantiation without the need of a dedicated initialization.
+type list[K comparable, V any] struct {
+	root Element[K, V] // list head and tail
+}
+
+func (l *list[K, V]) IsEmpty() bool {
+	return l.root.next == nil
+}
+
+// Front returns the first element of list l or nil if the list is empty.
+func (l *list[K, V]) Front() *Element[K, V] {
+	return l.root.next
+}
+
+// Back returns the last element of list l or nil if the list is empty.
+func (l *list[K, V]) Back() *Element[K, V] {
+	return l.root.prev
+}
+
+// Remove removes e from its list
+func (l *list[K, V]) Remove(e *Element[K, V]) {
+	if e.prev == nil {
+		l.root.next = e.next
+	} else {
+		e.prev.next = e.next
+	}
+	if e.next == nil {
+		l.root.prev = e.prev
+	} else {
+		e.next.prev = e.prev
+	}
+	e.next = nil // avoid memory leaks
+	e.prev = nil // avoid memory leaks
+}
+
+// PushFront inserts a new element e with value v at the front of list l and returns e.
+func (l *list[K, V]) PushFront(key K, value V) *Element[K, V] {
+	e := &Element[K, V]{Key: key, Value: value}
+	if l.root.next == nil {
+		// It's the first element
+		l.root.next = e
+		l.root.prev = e
+		return e
+	}
+
+	e.next = l.root.next
+	l.root.next.prev = e
+	l.root.next = e
+	return e
+}
+
+// PushBack inserts a new element e with value v at the back of list l and returns e.
+func (l *list[K, V]) PushBack(key K, value V) *Element[K, V] {
+	e := &Element[K, V]{Key: key, Value: value}
+	if l.root.prev == nil {
+		// It's the first element
+		l.root.next = e
+		l.root.prev = e
+		return e
+	}
+
+	e.prev = l.root.prev
+	l.root.prev.next = e
+	l.root.prev = e
+	return e
+}

slidge_whatsapp/vendor/github.com/elliotchance/orderedmap/v3/orderedmap.go

@@ -0,0 +1,187 @@
+package orderedmap
+
+import "iter"
+
+type OrderedMap[K comparable, V any] struct {
+	kv map[K]*Element[K, V]
+	ll list[K, V]
+}
+
+func NewOrderedMap[K comparable, V any]() *OrderedMap[K, V] {
+	return &OrderedMap[K, V]{
+		kv: make(map[K]*Element[K, V]),
+	}
+}
+
+// NewOrderedMapWithCapacity creates a map with enough pre-allocated space to
+// hold the specified number of elements.
+func NewOrderedMapWithCapacity[K comparable, V any](capacity int) *OrderedMap[K, V] {
+	return &OrderedMap[K, V]{
+		kv: make(map[K]*Element[K, V], capacity),
+	}
+}
+
+func NewOrderedMapWithElements[K comparable, V any](els ...*Element[K, V]) *OrderedMap[K, V] {
+	om := NewOrderedMapWithCapacity[K, V](len(els))
+	for _, el := range els {
+		om.Set(el.Key, el.Value)
+	}
+	return om
+}
+
+// Get returns the value for a key. If the key does not exist, the second return
+// parameter will be false and the value will be nil.
+func (m *OrderedMap[K, V]) Get(key K) (value V, ok bool) {
+	v, ok := m.kv[key]
+	if ok {
+		value = v.Value
+	}
+
+	return
+}
+
+// Set will set (or replace) a value for a key. If the key was new, then true
+// will be returned. The returned value will be false if the value was replaced
+// (even if the value was the same).
+func (m *OrderedMap[K, V]) Set(key K, value V) bool {
+	_, alreadyExist := m.kv[key]
+	if alreadyExist {
+		m.kv[key].Value = value
+		return false
+	}
+
+	element := m.ll.PushBack(key, value)
+	m.kv[key] = element
+	return true
+}
+
+// ReplaceKey replaces an existing key with a new key while preserving order of
+// the value. This function will return true if the operation was successful, or
+// false if 'originalKey' is not found OR 'newKey' already exists (which would be an overwrite).
+func (m *OrderedMap[K, V]) ReplaceKey(originalKey, newKey K) bool {
+	element, originalExists := m.kv[originalKey]
+	_, newKeyExists := m.kv[newKey]
+	if originalExists && !newKeyExists {
+		delete(m.kv, originalKey)
+		m.kv[newKey] = element
+		element.Key = newKey
+		return true
+	}
+	return false
+}
+
+// GetOrDefault returns the value for a key. If the key does not exist, returns
+// the default value instead.
+func (m *OrderedMap[K, V]) GetOrDefault(key K, defaultValue V) V {
+	if value, ok := m.kv[key]; ok {
+		return value.Value
+	}
+
+	return defaultValue
+}
+
+// GetElement returns the element for a key. If the key does not exist, the
+// pointer will be nil.
+func (m *OrderedMap[K, V]) GetElement(key K) *Element[K, V] {
+	element, ok := m.kv[key]
+	if ok {
+		return element
+	}
+
+	return nil
+}
+
+// Len returns the number of elements in the map.
+func (m *OrderedMap[K, V]) Len() int {
+	return len(m.kv)
+}
+
+// AllFromFront returns an iterator that yields all elements in the map starting
+// at the front (oldest Set element).
+func (m *OrderedMap[K, V]) AllFromFront() iter.Seq2[K, V] {
+	return func(yield func(key K, value V) bool) {
+		for el := m.Front(); el != nil; el = el.Next() {
+			if !yield(el.Key, el.Value) {
+				return
+			}
+		}
+	}
+}
+
+// AllFromBack returns an iterator that yields all elements in the map starting
+// at the back (most recent Set element).
+func (m *OrderedMap[K, V]) AllFromBack() iter.Seq2[K, V] {
+	return func(yield func(key K, value V) bool) {
+		for el := m.Back(); el != nil; el = el.Prev() {
+			if !yield(el.Key, el.Value) {
+				return
+			}
+		}
+	}
+}
+
+// Keys returns an iterator that yields all the keys in the map starting at the
+// front (oldest Set element). To create a slice containing all the map keys,
+// use the slices.Collect function on the returned iterator.
+func (m *OrderedMap[K, V]) Keys() iter.Seq[K] {
+	return func(yield func(key K) bool) {
+		for el := m.Front(); el != nil; el = el.Next() {
+			if !yield(el.Key) {
+				return
+			}
+		}
+	}
+}
+
+// Values returns an iterator that yields all the values in the map starting at
+// the front (oldest Set element). To create a slice containing all the map
+// values, use the slices.Collect function on the returned iterator.
+func (m *OrderedMap[K, V]) Values() iter.Seq[V] {
+	return func(yield func(value V) bool) {
+		for el := m.Front(); el != nil; el = el.Next() {
+			if !yield(el.Value) {
+				return
+			}
+		}
+	}
+}
+
+// Delete will remove a key from the map. It will return true if the key was
+// removed (the key did exist).
+func (m *OrderedMap[K, V]) Delete(key K) (didDelete bool) {
+	element, ok := m.kv[key]
+	if ok {
+		m.ll.Remove(element)
+		delete(m.kv, key)
+	}
+
+	return ok
+}
+
+// Front will return the element that is the first (oldest Set element). If
+// there are no elements this will return nil.
+func (m *OrderedMap[K, V]) Front() *Element[K, V] {
+	return m.ll.Front()
+}
+
+// Back will return the element that is the last (most recent Set element). If
+// there are no elements this will return nil.
+func (m *OrderedMap[K, V]) Back() *Element[K, V] {
+	return m.ll.Back()
+}
+
+// Copy returns a new OrderedMap with the same elements.
+// Using Copy while there are concurrent writes may mangle the result.
+func (m *OrderedMap[K, V]) Copy() *OrderedMap[K, V] {
+	m2 := NewOrderedMapWithCapacity[K, V](m.Len())
+	for el := m.Front(); el != nil; el = el.Next() {
+		m2.Set(el.Key, el.Value)
+	}
+	return m2
+}
+
+// Has checks if a key exists in the map.
+func (m *OrderedMap[K, V]) Has(key K) bool {
+	_, exists := m.kv[key]
+	return exists
+}

slidge_whatsapp/vendor/github.com/gen2brain/go-fitz/fitz.go

@@ -12,6 +12,7 @@ var (
 	ErrNoSuchFile      = errors.New("fitz: no such file")
 	ErrCreateContext   = errors.New("fitz: cannot create context")
 	ErrOpenDocument    = errors.New("fitz: cannot open document")
+	ErrEmptyBytes      = errors.New("fitz: cannot send empty bytes")
 	ErrOpenMemory      = errors.New("fitz: cannot open memory")
 	ErrLoadPage        = errors.New("fitz: cannot load page")
 	ErrRunPageContents = errors.New("fitz: cannot run page contents")

slidge_whatsapp/vendor/github.com/gen2brain/go-fitz/fitz_cgo.go

@@ -125,6 +125,9 @@ func New(filename string) (f *Document, err error) {
 
 // NewFromMemory returns new fitz document from byte slice.
 func NewFromMemory(b []byte) (f *Document, err error) {
+	if len(b) == 0 {
+		return nil, ErrEmptyBytes
+	}
 	f = &Document{}
 
 	f.ctx = (*C.struct_fz_context)(unsafe.Pointer(C.fz_new_context_imp(nil, nil, C.store(MaxStore), C.fz_version)))

slidge_whatsapp/vendor/github.com/gen2brain/go-fitz/fitz_nocgo.go

@@ -64,6 +64,9 @@ func New(filename string) (f *Document, err error) {
 
 // NewFromMemory returns new fitz document from byte slice.
 func NewFromMemory(b []byte) (f *Document, err error) {
+	if len(b) == 0 {
+		return nil, ErrEmptyBytes
+	}
 	f = &Document{}
 
 	f.ctx = fzNewContextImp(nil, nil, uint64(MaxStore), FzVersion)
@@ -661,11 +664,7 @@ func (b *bundle) call(rValue unsafe.Pointer, aValues ...unsafe.Pointer) {
 
 func newBundle(name string, rType *ffi.Type, aTypes ...*ffi.Type) *bundle {
 	b := new(bundle)
-	var err error
-
-	if b.sym, err = purego.Dlsym(libmupdf, name); err != nil {
-		panic(err)
-	}
+	b.sym = procAddress(libmupdf, name)
 
 	nArgs := uint32(len(aTypes))
 

slidge_whatsapp/vendor/github.com/gen2brain/go-fitz/purego_darwin.go

@@ -19,5 +19,15 @@ func loadLibrary() uintptr {
 		panic(fmt.Errorf("cannot load library: %w", err))
 	}
 
-	return uintptr(handle)
+	return handle
+}
+
+// procAddress returns the address of symbol name.
+func procAddress(handle uintptr, procName string) uintptr {
+	addr, err := purego.Dlsym(handle, procName)
+	if err != nil {
+		panic(fmt.Errorf("cannot get proc address for %s: %w", procName, err))
+	}
+
+	return addr
 }