[chore] update dependencies (#4386)

- codeberg.org/gruf/go-bytesize v1.0.3 -> v1.0.4
- codeberg.org/gruf/go-kv/v2 v2.0.6 -> v2.0.7
- codeberg.org/gruf/go-mutexes v1.5.2 -> v1.5.3
- codeberg.org/gruf/go-structr v0.9.7 -> v0.9.8
- codeberg.org/gruf/go-ffmpreg v0.6.8 -> v0.6.9
- github.com/tomnomnom/linkheader HEAD@2018 -> HEAD@2025

all of the above codeberg.org/gruf updates are in preparation for Go1.25, except for bytesize, and also ffmpreg which is a rebuild with the latest version of ffmpeg (v5.1.7)

Reviewed-on: https://codeberg.org/superseriousbusiness/gotosocial/pulls/4386
Co-authored-by: kim <grufwub@gmail.com>
Co-committed-by: kim <grufwub@gmail.com>

1 files changed, 0 insertions, 130 deletions

diff --git a/vendor/codeberg.org/gruf/go-mangler/mangle.go b/vendor/codeberg.org/gruf/go-mangler/mangle.go
deleted file mode 100644
index 576286682..000000000
--- a/vendor/codeberg.org/gruf/go-mangler/mangle.go
+++ /dev/null
@@ -1,130 +0,0 @@
-package mangler
-
-import (
-	"reflect"
-	"sync"
-	"unsafe"
-)
-
-// manglers is a map of runtime
-// type ptrs => Mangler functions.
-var manglers sync.Map
-
-// Mangler is a function that will take an input interface value of known
-// type, and append it in mangled serialized form to the given byte buffer.
-// While the value type is an interface, the Mangler functions are accessed
-// by the value's runtime type pointer, allowing the input value type to be known.
-type Mangler func(buf []byte, ptr unsafe.Pointer) []byte
-
-// Get will fetch the Mangler function for given runtime type.
-// Note that the returned mangler will be a no-op in the case
-// that an incorrect type is passed as the value argument.
-func Get(t reflect.Type) Mangler {
-	var mng Mangler
-
-	// Get raw runtime type ptr
-	uptr := uintptr(eface_data(t))
-
-	// Look for a cached mangler
-	v, ok := manglers.Load(uptr)
-
-	if !ok {
-		// Load mangler function
-		mng = loadMangler(t)
-	} else {
-		// cast cached value
-		mng = v.(Mangler)
-	}
-
-	return func(buf []byte, ptr unsafe.Pointer) []byte {
-		// First write the type ptr (this adds
-		// a unique prefix for each runtime type).
-		buf = append_uint64(buf, uint64(uptr))
-
-		// Finally, mangle value
-		return mng(buf, ptr)
-	}
-}
-
-// Register will register the given Mangler function for use with vars of given runtime type. This allows
-// registering performant manglers for existing types not implementing Mangled (e.g. std library types).
-// NOTE: panics if there already exists a Mangler function for given type. Register on init().
-func Register(t reflect.Type, m Mangler) {
-	if t == nil {
-		// Nil interface{} types cannot be searched by, do not accept
-		panic("cannot register mangler for nil interface{} type")
-	}
-
-	// Get raw runtime type ptr
-	uptr := uintptr(eface_data(t))
-
-	// Ensure this is a unique encoder
-	if _, ok := manglers.Load(uptr); ok {
-		panic("already registered mangler for type: " + t.String())
-	}
-
-	// Cache this encoder func
-	manglers.Store(uptr, m)
-}
-
-// Append will append the mangled form of input value 'a' to buffer 'b'.
-// See mangler.String() for more information on mangled output.
-func Append(b []byte, a any) []byte {
-	var mng Mangler
-
-	// Get reflect type of 'a'
-	t := reflect.TypeOf(a)
-
-	// Get raw runtime type ptr
-	uptr := uintptr(eface_data(t))
-
-	// Look for a cached mangler
-	v, ok := manglers.Load(uptr)
-
-	if !ok {
-		// Load into cache
-		mng = loadMangler(t)
-		manglers.Store(uptr, mng)
-	} else {
-		// cast cached value
-		mng = v.(Mangler)
-	}
-
-	// First write the type ptr (this adds
-	// a unique prefix for each runtime type).
-	b = append_uint64(b, uint64(uptr))
-
-	// Finally, mangle value
-	ptr := eface_data(a)
-	return mng(b, ptr)
-}
-
-// String will return the mangled format of input value 'a'. This
-// mangled output will be unique for all default supported input types
-// during a single runtime instance. Uniqueness cannot be guaranteed
-// between separate runtime instances (whether running concurrently, or
-// the same application running at different times).
-//
-// The exact formatting of the output data should not be relied upon,
-// only that it is unique given the above constraints. Generally though,
-// the mangled output is the binary formatted text of given input data.
-//
-// Uniqueness is guaranteed for similar input data of differing types
-// (e.g. string("hello world") vs. []byte("hello world")) by prefixing
-// mangled output with the input data's runtime type pointer.
-//
-// Default supported types include:
-// - string
-// - bool
-// - int,int8,int16,int32,int64
-// - uint,uint8,uint16,uint32,uint64,uintptr
-// - float32,float64
-// - complex64,complex128
-// - arbitrary structs
-// - all type aliases of above
-// - all pointers to the above
-// - all slices / arrays of the above
-func String(a any) string {
-	b := Append(make([]byte, 0, 32), a)
-	return *(*string)(unsafe.Pointer(&b))
-}