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

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
 }

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

@@ -20,3 +20,13 @@ func loadLibrary() uintptr {
 
 	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
+}

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

@@ -5,6 +5,8 @@ package fitz
 import (
 	"fmt"
 	"syscall"
+
+	"golang.org/x/sys/windows"
 )
 
 const (
@@ -20,3 +22,13 @@ func loadLibrary() uintptr {
 
 	return uintptr(handle)
 }
+
+// procAddress returns the address of symbol name.
+func procAddress(handle uintptr, procName string) uintptr {
+	addr, err := windows.GetProcAddress(windows.Handle(handle), procName)
+	if err != nil {
+		panic(fmt.Errorf("cannot get proc address for %s: %w", procName, err))
+	}
+
+	return addr
+}

slidge_whatsapp/vendor/github.com/jupiterrider/ffi/.gitignore

@@ -4,9 +4,7 @@
 # Binaries for programs and plugins
 *.exe
 *.exe~
-*.dll
 *.so
-*.dylib
 
 # Test binary, built with `go test -c`
 *.test

slidge_whatsapp/vendor/github.com/jupiterrider/ffi/CHANGELOG.md

@@ -5,14 +5,50 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.1] - 2025-07-29
+
+### Fixed
+
+- `DefaultAbi` had a wrong value on Windows ARM64.
+- Missing extra field attached to `Cif` (Windows/macOS ARM64).
+- Embedded libffi binaries have been updated to 3.5.1.
+
+## [0.5.0] - 2025-06-10
+
+### Added
+
+- The libffi shared libraries for Windows AMD64 and macOS AMD64/ARM64 are now embedded into this library ([#12](https://github.com/JupiterRider/ffi/issues/12)).
+  The build tag `ffi_no_embed` or the environment variable `FFI_NO_EMBED=1` can disable this feature.
+- You can now retrieve the used libffi version (requires libffi 3.5.0 or newer):
+    - `func GetVersion() string`
+    - `func GetVersionNumber() uint64`
+- Function `func GetStructOffsets(abi Abi, structType *Type, offsets *uint64) Status` implemented.
+
+### Changed
+
+- Dependency `github.com/ebitengine/purego` updated.
+
+## [0.4.1] - 2025-05-12
+
+### Fixed
+
+- The dependency `github.com/ebitengine/purego` had to be upgraded to version 0.8.3 due to a [bug](https://github.com/golang/go/issues/73617) in Go 1.23.9 and 1.24.3.
+
+## [0.4.0] - 2025-03-13
+
+### Changed
+
+- `Fun.Call` panics now, if the number of arguments doesn't match the prepared Cif.
+
 ## [0.3.0] - 2025-01-18
 
 ### Added
+
 - libffi's closure API has been implemented, which allows you to create C functions at runtime:
     - `func ClosureAlloc(size uintptr, code *unsafe.Pointer) *Closure`
     - `func ClosureFree(writable *Closure)`
     - `func PrepClosureLoc(closure *Closure, cif *Cif, fun uintptr, userData, codeLoc unsafe.Pointer) Status`
-- The new types `Fun` and `Lib` can reduce boilerplate and eliminate platform dependant code:
+- The new types `Fun` and `Lib` can reduce boilerplate and eliminate platform-dependent code:
     - `func (f Fun) Call(ret any, args ...any)`
     - `func Load(name string) (l Lib, err error)`
     - `func (l Lib) Close() error`
@@ -23,11 +59,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - [Changelog](https://github.com/JupiterRider/ffi/blob/main/CHANGELOG.md) file added.
 
 ### Changed
+
 - On Linux, libffi.so.7 was loaded when libffi.so.8 could not be found. This is no longer the case.
 
 ## [0.2.2] - 2024-12-22
 
 ### Added
+
 - Function `func NewType(elements ...*Type) Type` added.
 
 ## [0.2.1] - 2024-10-30
@@ -49,6 +87,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Dependencies `github.com/ebitengine/purego` and `golang.org/x/sys` updated.
 
+[0.5.1]: https://github.com/JupiterRider/ffi/compare/v0.5.0...v0.5.1
+[0.5.0]: https://github.com/JupiterRider/ffi/compare/v0.4.1...v0.5.0
+[0.4.1]: https://github.com/JupiterRider/ffi/compare/v0.4.0...v0.4.1
+[0.4.0]: https://github.com/JupiterRider/ffi/compare/v0.3.0...v0.4.0
+[0.3.0]: https://github.com/JupiterRider/ffi/compare/v0.2.2...v0.3.0
 [0.3.0]: https://github.com/JupiterRider/ffi/compare/v0.2.2...v0.3.0
 [0.2.2]: https://github.com/JupiterRider/ffi/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/JupiterRider/ffi/compare/v0.2.0...v0.2.1

slidge_whatsapp/vendor/github.com/jupiterrider/ffi/COPYRIGHT.txt

@@ -7,10 +7,15 @@ Comment: ffi
 Copyright: 2024-present JupiterRider
 License: Expat
 
-Files: ./examples/raylib/gopher-with-C-book.png
+Files: examples/raylib/gopher-with-C-book.png
 Copyright: egonelbre
 License: CC0-1.0
 
+Files: assets/libffi/*
+Comment: libffi
+Copyright: 1996-2025 Anthony Green, Red Hat, Inc. and others
+License: Expat
+
 License: Expat
  Permission is hereby granted, free of charge, to any person obtaining
  a copy of this software and associated documentation files (the

slidge_whatsapp/vendor/github.com/jupiterrider/ffi/README.md

@@ -6,8 +6,7 @@ A purego binding for libffi.
 ## Purpose
 You can use [purego](https://github.com/ebitengine/purego) to call C code without cgo. ffi provides extra functionality (e.g. passing and returning structs by value).
 
-## Requirements
-### OS/Architecture
+## Supported OS/Architecture
 - darwin/amd64
 - darwin/arm64
 - freebsd/amd64
@@ -17,37 +16,35 @@ You can use [purego](https://github.com/ebitengine/purego) to call C code withou
 - windows/amd64
 - windows/arm64
 
-### Software
+## Software Requirements
 [libffi](https://github.com/libffi/libffi) is preinstalled on most distributions, because it also is a dependency of Python and Ruby. If not, you can install it explicitly:
 
-#### Arch Linux
+### Arch Linux
 ```sh
 sudo pacman -S libffi
 ```
 
-#### Debian 12, Ubuntu 22.04, Ubuntu 24.04
+### Debian 12, Ubuntu 22.04, Ubuntu 24.04
 ```sh
 sudo apt install libffi8
 ```
 
-#### FreeBSD
+### Fedora
+```sh
+sudo dnf install libffi
+```
+
+### FreeBSD
 ```sh
 pkg install libffi
 ```
 Note: Use this `-gcflags="github.com/ebitengine/purego/internal/fakecgo=-std"` build flag when cross compiling or having CGO_ENABLED set to 0 (FreeBSD only).
 
-#### Windows
-You need a `libffi-8.dll` next to the executable/root folder of your project or inside C:\Windows\System32. If you don't want to build libffi from source, you can find this dll for example inside the [Windows embeddable package](https://www.python.org/downloads/windows/) of Python.
+### Windows
+The AMD64 version of libffi is already embedded into this library and gets extracted and loaded at runtime. This feature can be disabled by using the build tag `ffi_no_embed` or the environment variable `FFI_NO_EMBED=1`.
 
-#### macOS
-You can use [Homebrew](https://brew.sh/) to install libffi:
-```sh
-brew install libffi
-```
-Note: If dlopen can't find the libffi.8.dylib file, you can try setting this environment variable:
-```sh
-export DYLD_FALLBACK_LIBRARY_PATH=$DYLD_FALLBACK_LIBRARY_PATH:/opt/homebrew/opt/libffi/lib
-```
+### macOS
+No further requirements. The libffi binaries are embedded as well.
 
 ## Examples
 In this example we create our own library, which consists of two type definitions and one function:

slidge_whatsapp/vendor/github.com/jupiterrider/ffi/abi.go

@@ -1,4 +1,4 @@
-//go:build ((freebsd || linux || darwin) && arm64) || (windows && (amd64 || arm64))
+//go:build ((freebsd || linux || darwin) && arm64) || (windows && amd64)
 
 package ffi
 

slidge_whatsapp/vendor/github.com/jupiterrider/ffi/abi2.go

@@ -0,0 +1,7 @@
+//go:build ((freebsd || linux || darwin) && amd64) || (windows && arm64)
+
+package ffi
+
+const (
+	DefaultAbi Abi = 2
+)

slidge_whatsapp/vendor/github.com/jupiterrider/ffi/assets/libffi/LICENSE

@@ -0,0 +1,21 @@
+libffi - Copyright (c) 1996-2025  Anthony Green, Red Hat, Inc and others.
+See source files for details.
+
+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/jupiterrider/ffi/cif.go

@@ -0,0 +1,15 @@
+//go:build ((freebsd || linux || windows || darwin) && amd64) || ((freebsd || linux) && arm64)
+
+package ffi
+
+// Cif stands for "Call InterFace". It describes the signature of a function.
+//
+// Use [PrepCif] to initialize it.
+type Cif struct {
+	Abi      uint32
+	NArgs    uint32
+	ArgTypes **Type
+	RType    *Type
+	Bytes    uint32
+	Flags    uint32
+}

slidge_whatsapp/vendor/github.com/jupiterrider/ffi/cif_arm64.go

@@ -0,0 +1,16 @@
+//go:build windows || darwin
+
+package ffi
+
+// Cif stands for "Call InterFace". It describes the signature of a function.
+//
+// Use [PrepCif] to initialize it.
+type Cif struct {
+	Abi      uint32
+	NArgs    uint32
+	ArgTypes **Type
+	RType    *Type
+	Bytes    uint32
+	Flags    uint32
+	_        uint32
+}

slidge_whatsapp/vendor/github.com/jupiterrider/ffi/embed.go

@@ -0,0 +1,49 @@
+//go:build !ffi_no_embed && (darwin || (windows && amd64))
+
+package ffi
+
+import (
+	_ "embed"
+	"os"
+	"path/filepath"
+)
+
+const libffiVersion = "3.5.1"
+
+//go:embed assets/libffi/LICENSE
+var embeddedLicense []byte
+
+func init() {
+	if os.Getenv("FFI_NO_EMBED") == "1" {
+		return
+	}
+
+	userCacheDir, err := os.UserCacheDir()
+	if err != nil {
+		return
+	}
+
+	destDir := filepath.Join(userCacheDir, "github.com/jupiterrider/ffi/libffi", libffiVersion)
+	destLib := filepath.Join(destDir, libname)
+	destLicense := filepath.Join(destDir, "LICENSE")
+
+	if os.MkdirAll(destDir, 0755) == nil {
+		if fileInfo, err := os.Stat(destLib); err != nil {
+			if os.IsNotExist(err) {
+				if os.WriteFile(destLib, embeddedLib, 0755) == nil {
+					filename = destLib
+				}
+			}
+		} else {
+			if fileInfo != nil && !fileInfo.IsDir() {
+				filename = destLib
+			}
+		}
+
+		if _, err := os.Stat(destLicense); err != nil {
+			if os.IsNotExist(err) {
+				os.WriteFile(destLicense, embeddedLicense, 0644)
+			}
+		}
+	}
+}