From 67100809b399b60e58490fa8b1c0a72be75ac820 Mon Sep 17 00:00:00 2001
From: kim <grufwub@gmail.com>
Date: Sun, 10 Aug 2025 15:05:54 +0200
Subject: [chore] update dependencies (#4361)

- codeberg.org/gruf/go-kv/v2 v2.0.5 => v2.0.6
- github.com/coreos/go-oidc/v3 v3.14.1 => v3.15.0
- github.com/miekg/dns v1.1.67 => v1.1.68
- github.com/tdewolff/minify/v2 v2.23.9 => v2.23.11
- github.com/yuin/goldmark v1.7.12 => v1.7.13
- golang.org/x/crypto v0.40.0 => v0.41.0
- golang.org/x/image v0.29.0 => v0.30.0
- golang.org/x/net v0.42.0 => v0.43.0
- golang.org/x/sys v0.34.0 => v0.35.0
- golang.org/x/text v0.27.0 => v0.28.0
- modernc.org/sqlite v1.38.0 => v1.38.2

Reviewed-on: https://codeberg.org/superseriousbusiness/gotosocial/pulls/4361
Co-authored-by: kim <grufwub@gmail.com>
Co-committed-by: kim <grufwub@gmail.com>
---
 vendor/codeberg.org/gruf/go-xunsafe/LICENSE    |   9 ++
 vendor/codeberg.org/gruf/go-xunsafe/README.md  |   3 +
 vendor/codeberg.org/gruf/go-xunsafe/abi.go     | 109 +++++++++++++++++
 vendor/codeberg.org/gruf/go-xunsafe/reflect.go | 157 +++++++++++++++++++++++++
 vendor/codeberg.org/gruf/go-xunsafe/types.go   |  49 ++++++++
 5 files changed, 327 insertions(+)
 create mode 100644 vendor/codeberg.org/gruf/go-xunsafe/LICENSE
 create mode 100644 vendor/codeberg.org/gruf/go-xunsafe/README.md
 create mode 100644 vendor/codeberg.org/gruf/go-xunsafe/abi.go
 create mode 100644 vendor/codeberg.org/gruf/go-xunsafe/reflect.go
 create mode 100644 vendor/codeberg.org/gruf/go-xunsafe/types.go

(limited to 'vendor/codeberg.org/gruf/go-xunsafe')

diff --git a/vendor/codeberg.org/gruf/go-xunsafe/LICENSE b/vendor/codeberg.org/gruf/go-xunsafe/LICENSE
new file mode 100644
index 000000000..d6f08d0ab
--- /dev/null
+++ b/vendor/codeberg.org/gruf/go-xunsafe/LICENSE
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) gruf
+
+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.
diff --git a/vendor/codeberg.org/gruf/go-xunsafe/README.md b/vendor/codeberg.org/gruf/go-xunsafe/README.md
new file mode 100644
index 000000000..9c8031e17
--- /dev/null
+++ b/vendor/codeberg.org/gruf/go-xunsafe/README.md
@@ -0,0 +1,3 @@
+# go-xunsafe
+
+xunafe as in EXTRA UNSAFE. this exposes reflect and internal ABI package data structures in a manner that is kept up-to-date and version gated by the compile-time Go version. This package performs no validity checks on the data you provide to it, it is expected that you know what you are doing. Not to mention that some of the internal ABI data must only be exposed VERY carefully given that it is in non garbage-collected memory.
diff --git a/vendor/codeberg.org/gruf/go-xunsafe/abi.go b/vendor/codeberg.org/gruf/go-xunsafe/abi.go
new file mode 100644
index 000000000..d492f5681
--- /dev/null
+++ b/vendor/codeberg.org/gruf/go-xunsafe/abi.go
@@ -0,0 +1,109 @@
+//go:build go1.24 && !go1.26
+
+package xunsafe
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+func init() {
+	// TypeOf(reflect.Type{}) == *struct{ abi.Type{} }
+	t := reflect.TypeOf(reflect.TypeOf(0)).Elem()
+	if t.Size() != unsafe.Sizeof(Abi_Type{}) {
+		panic("Abi_Type{} not in sync with abi.Type{}")
+	}
+}
+
+const (
+	// see: go/src/internal/abi/type.go
+	Abi_KindDirectIface uint8 = 1 << 5
+	Abi_KindMask        uint8 = (1 << 5) - 1
+)
+
+// Abi_Type is a copy of the memory layout of abi.Type{}.
+//
+// see: go/src/internal/abi/type.go
+type Abi_Type struct {
+	_        uintptr
+	PtrBytes uintptr
+	_        uint32
+	_        uint8
+	_        uint8
+	_        uint8
+	Kind_    uint8
+	_        func(unsafe.Pointer, unsafe.Pointer) bool
+	_        *byte
+	_        int32
+	_        int32
+}
+
+// Abi_EmptyInterface is a copy of the memory layout of abi.EmptyInterface{},
+// which is to say also the memory layout of any method-less interface.
+//
+// see: go/src/internal/abi/iface.go
+type Abi_EmptyInterface struct {
+	Type *Abi_Type
+	Data unsafe.Pointer
+}
+
+// Abi_NonEmptyInterface is a copy of the memory layout of abi.NonEmptyInterface{},
+// which is to say also the memory layout of any interface containing method(s).
+//
+// see: go/src/internal/abi/iface.go on 1.25+
+// see: go/src/reflect/value.go on 1.24
+type Abi_NonEmptyInterface struct {
+	ITab uintptr
+	Data unsafe.Pointer
+}
+
+// see: go/src/internal/abi/type.go Type.Kind()
+func Abi_Type_Kind(t reflect.Type) uint8 {
+	iface := (*Abi_NonEmptyInterface)(unsafe.Pointer(&t))
+	atype := (*Abi_Type)(unsafe.Pointer(iface.Data))
+	return atype.Kind_ & Abi_KindMask
+}
+
+// see: go/src/internal/abi/type.go Type.IfaceIndir()
+func Abi_Type_IfaceIndir(t reflect.Type) bool {
+	iface := (*Abi_NonEmptyInterface)(unsafe.Pointer(&t))
+	atype := (*Abi_Type)(unsafe.Pointer(iface.Data))
+	return atype.Kind_&Abi_KindDirectIface == 0
+}
+
+// PackIface packs a new reflect.nonEmptyInterface{} using shielded
+// itab and data pointer, returning a pointer for caller casting.
+func PackIface(itab uintptr, word unsafe.Pointer) unsafe.Pointer {
+	return unsafe.Pointer(&Abi_NonEmptyInterface{
+		ITab: itab,
+		Data: word,
+	})
+}
+
+// GetIfaceITab generates a new value of given type,
+// casts it to the generic param interface type, and
+// returns the .itab portion of the abi.NonEmptyInterface{}.
+// this is useful for later calls to PackIface for known type.
+func GetIfaceITab[I any](t reflect.Type) uintptr {
+	s := reflect.New(t).Elem().Interface().(I)
+	i := (*Abi_NonEmptyInterface)(unsafe.Pointer(&s))
+	return i.ITab
+}
+
+// UnpackEface returns the .Data portion of an abi.EmptyInterface{}.
+func UnpackEface(a any) unsafe.Pointer {
+	return (*Abi_EmptyInterface)(unsafe.Pointer((&a))).Data
+}
+
+// see: go/src/internal/unsafeheader/unsafeheader.go
+type Unsafeheader_Slice struct {
+	Data unsafe.Pointer
+	Len  int
+	Cap  int
+}
+
+// see: go/src/internal/unsafeheader/unsafeheader.go
+type Unsafeheader_String struct {
+	Data unsafe.Pointer
+	Len  int
+}
diff --git a/vendor/codeberg.org/gruf/go-xunsafe/reflect.go b/vendor/codeberg.org/gruf/go-xunsafe/reflect.go
new file mode 100644
index 000000000..de40b2c89
--- /dev/null
+++ b/vendor/codeberg.org/gruf/go-xunsafe/reflect.go
@@ -0,0 +1,157 @@
+//go:build go1.24 && !go1.26
+
+package xunsafe
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+// see: go/src/reflect/value.go
+type Reflect_flag uintptr
+
+const (
+	// see: go/src/reflect/value.go
+	Reflect_flagKindWidth                = 5 // there are 27 kinds
+	Reflect_flagKindMask    Reflect_flag = 1<<Reflect_flagKindWidth - 1
+	Reflect_flagStickyRO    Reflect_flag = 1 << 5
+	Reflect_flagEmbedRO     Reflect_flag = 1 << 6
+	Reflect_flagIndir       Reflect_flag = 1 << 7
+	Reflect_flagAddr        Reflect_flag = 1 << 8
+	Reflect_flagMethod      Reflect_flag = 1 << 9
+	Reflect_flagMethodShift              = 10
+	Reflect_flagRO          Reflect_flag = Reflect_flagStickyRO | Reflect_flagEmbedRO
+)
+
+// ReflectIfaceElemFlags returns the reflect_flag expected of an unboxed interface element of type.
+//
+// see: go/src/reflect/value.go unpackElem()
+func ReflectIfaceElemFlags(elemType reflect.Type) Reflect_flag {
+	if elemType == nil {
+		return 0
+	}
+	flags := Reflect_flag(Abi_Type_Kind(elemType))
+	if Abi_Type_IfaceIndir(elemType) {
+		flags |= Reflect_flagIndir
+	}
+	return flags
+}
+
+// ReflectPointerElemFlags returns the reflect_flag expected of a dereferenced pointer element of type.
+//
+// see: go/src/reflect/value.go Value.Elem()
+func ReflectPointerElemFlags(ptrFlags Reflect_flag, elemType reflect.Type) Reflect_flag {
+	return ptrFlags | Reflect_flagIndir | Reflect_flagAddr | Reflect_flag(Abi_Type_Kind(elemType))
+}
+
+// ReflectArrayElemFlags returns the reflect_flag expected of an element of type in an array.
+//
+// see: go/src/reflect/value.go Value.Index()
+func ReflectArrayElemFlags(arrayFlags Reflect_flag, elemType reflect.Type) Reflect_flag {
+	return arrayFlags&(Reflect_flagIndir|Reflect_flagAddr) | Reflect_flag(Abi_Type_Kind(elemType))
+}
+
+// reflect_slice_elem_flags returns the reflect_flag expected of a slice element of type.
+//
+// see: go/src/reflect/value.go Value.Index()
+func ReflectSliceElemFlags(elemType reflect.Type) Reflect_flag {
+	return Reflect_flagAddr | Reflect_flagIndir | Reflect_flag(Abi_Type_Kind(elemType))
+}
+
+// ReflectStructFieldFlags returns the reflect_flag expected of a struct field of type.
+//
+// see: go/src/reflect/value.go Value.Field()
+func ReflectStructFieldFlags(structFlags Reflect_flag, fieldType reflect.Type) Reflect_flag {
+	return structFlags&(Reflect_flagIndir|Reflect_flagAddr) | Reflect_flag(Abi_Type_Kind(fieldType))
+}
+
+// ReflectMapKeyFlags returns the reflect_flag expected of a map key of type.
+//
+// see: go/src/reflect/map_swiss.go MapIter.Key()
+func ReflectMapKeyFlags(keyType reflect.Type) Reflect_flag {
+	return Reflect_flag(Abi_Type_Kind(keyType))
+}
+
+// ReflectMapElemFlags returns the reflect_flag expected of a map element of type.
+//
+// see: go/src/reflect/map_swiss.go MapIter.Value()
+func ReflectMapElemFlags(elemType reflect.Type) Reflect_flag {
+	return Reflect_flag(Abi_Type_Kind(elemType))
+}
+
+// reflect_Value is a copy of the memory layout of reflect.Value{}.
+//
+// see: go/src/reflect/value.go
+type reflect_Value struct {
+	typ_ unsafe.Pointer
+	ptr  unsafe.Pointer
+	Reflect_flag
+}
+
+func init() {
+	if unsafe.Sizeof(reflect_Value{}) != unsafe.Sizeof(reflect.Value{}) {
+		panic("reflect_Value{} not in sync with reflect.Value{}")
+	}
+}
+
+// reflect_type_data returns the .word from the reflect.Type{} cast
+// as the reflect.nonEmptyInterface{}, which itself will be a pointer
+// to the actual abi.Type{} that this reflect.Type{} is wrapping.
+func ReflectTypeData(t reflect.Type) unsafe.Pointer {
+	return (*Abi_NonEmptyInterface)(unsafe.Pointer(&t)).Data
+}
+
+// BuildReflectValue manually builds a reflect.Value{} by setting the internal field members.
+func BuildReflectValue(rtype reflect.Type, data unsafe.Pointer, flags Reflect_flag) reflect.Value {
+	return *(*reflect.Value)(unsafe.Pointer(&reflect_Value{ReflectTypeData(rtype), data, flags}))
+}
+
+// Reflect_MapIter is a copy of the memory layout of reflect.MapIter{}.
+//
+// see: go/src/reflect/map_swiss.go
+type Reflect_MapIter struct {
+	m     reflect.Value
+	hiter maps_Iter
+}
+
+// maps_Iter is a copy of the memory layout of maps.Iter{}.
+//
+// see: go/src/internal/runtime/maps/table.go
+type maps_Iter struct {
+	key  unsafe.Pointer
+	elem unsafe.Pointer
+	_    uintptr
+	_    uintptr
+	_    uint64
+	_    uint64
+	_    uint64
+	_    uint8
+	_    int
+	_    uintptr
+	_    struct{ _ unsafe.Pointer }
+	_    uint64
+}
+
+func init() {
+	if unsafe.Sizeof(Reflect_MapIter{}) != unsafe.Sizeof(reflect.MapIter{}) {
+		panic("Reflect_MapIter{} not in sync with reflect.MapIter{}")
+	}
+}
+
+// GetMapIter creates a new map iterator from value,
+// skipping the initial v.MapRange() type checking.
+func GetMapIter(v reflect.Value) *reflect.MapIter {
+	var i Reflect_MapIter
+	i.m = v
+	return (*reflect.MapIter)(unsafe.Pointer(&i))
+}
+
+// Map_Key returns ptr to current map key in iter.
+func Map_Key(i *reflect.MapIter) unsafe.Pointer {
+	return (*Reflect_MapIter)(unsafe.Pointer(i)).hiter.key
+}
+
+// Map_Elem returns ptr to current map element in iter.
+func Map_Elem(i *reflect.MapIter) unsafe.Pointer {
+	return (*Reflect_MapIter)(unsafe.Pointer(i)).hiter.elem
+}
diff --git a/vendor/codeberg.org/gruf/go-xunsafe/types.go b/vendor/codeberg.org/gruf/go-xunsafe/types.go
new file mode 100644
index 000000000..b17603543
--- /dev/null
+++ b/vendor/codeberg.org/gruf/go-xunsafe/types.go
@@ -0,0 +1,49 @@
+package xunsafe
+
+import "reflect"
+
+// TypeIter provides a simple wrapper for
+// a means of following reflected types.
+type TypeIter struct {
+	TypeInfo
+	Parent *TypeIter
+}
+
+// TypeInfo wraps reflect type information
+// along with flags specifying further details
+// necessary due to type nesting.
+type TypeInfo struct {
+	Type reflect.Type
+	Flag Reflect_flag
+}
+
+// ToTypeIter creates a new TypeIter{} from reflect type and flags.
+func ToTypeIter(rtype reflect.Type, flags Reflect_flag) TypeIter {
+	return TypeIter{TypeInfo: TypeInfo{rtype, flags}}
+}
+
+// TypeIterFrom creates new TypeIter from interface value type.
+// Note this will always assume the initial value passed to you
+// will be coming from an interface.
+func TypeIterFrom(a any) TypeIter {
+	rtype := reflect.TypeOf(a)
+	flags := ReflectIfaceElemFlags(rtype)
+	return ToTypeIter(rtype, flags)
+}
+
+// Indirect returns whether Reflect_flagIndir is set on receiving TypeInfo{}.Flag.
+func (t TypeInfo) Indirect() bool {
+	return t.Flag&Reflect_flagIndir != 0
+}
+
+// IfaceIndir calls Abi_Type_IfaceIndir() on receiving TypeInfo{}.Type.
+func (t TypeInfo) IfaceIndir() bool {
+	return Abi_Type_IfaceIndir(t.Type)
+}
+
+// Child returns a new TypeIter{} for given type and flags, with parent pointing to receiver.
+func (i TypeIter) Child(rtype reflect.Type, flags Reflect_flag) TypeIter {
+	child := ToTypeIter(rtype, flags)
+	child.Parent = &i
+	return child
+}
-- 
cgit v1.2.3