v0.0.608

.idea/copilot.data.migration.agent.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AgentMigrationStateService">
+    <option name="migrationStatus" value="COMPLETED" />
+  </component>
+</project>

.idea/copilot.data.migration.ask.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AskMigrationStateService">
+    <option name="migrationStatus" value="COMPLETED" />
+  </component>
+</project>

.idea/copilot.data.migration.ask2agent.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Ask2AgentMigrationStateService">
+    <option name="migrationStatus" value="COMPLETED" />
+  </component>
+</project>

.idea/copilot.data.migration.edit.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="EditMigrationStateService">
+    <option name="migrationStatus" value="COMPLETED" />
+  </component>
+</project>

README.md

@@ -5,7 +5,7 @@ A collection of general & useful library methods
 
 This should not have any heavy dependencies (gin, mongo, etc) and add missing basic language features...
 
-Potentially needs `export GOPRIVATE="gogs.mikescher.com"`
+Potentially needs `export GOPRIVATE="git.blackforestbytes.com"`
 
 
 ## Packages:

bfcodegen/csid-generate.go

@@ -6,10 +6,10 @@ import (
 	"errors"
 	"fmt"
 	"go/format"
-	"gogs.mikescher.com/BlackForestBytes/goext"
+	"git.blackforestbytes.com/BlackForestBytes/goext"
-	"gogs.mikescher.com/BlackForestBytes/goext/cryptext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/cryptext"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/rext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/rext"
 	"io"
 	"os"
 	"path"

bfcodegen/csid-generate.template

@@ -7,9 +7,9 @@ import "crypto/sha256"
 import "fmt"
 import "github.com/go-playground/validator/v10"
 import "github.com/rs/zerolog/log"
-import "gogs.mikescher.com/BlackForestBytes/goext/exerr"
+import "git.blackforestbytes.com/BlackForestBytes/goext/exerr"
-import "gogs.mikescher.com/BlackForestBytes/goext/langext"
+import "git.blackforestbytes.com/BlackForestBytes/goext/langext"
-import "gogs.mikescher.com/BlackForestBytes/goext/rext"
+import "git.blackforestbytes.com/BlackForestBytes/goext/rext"
 import "math/big"
 import "reflect"
 import "regexp"
@@ -183,6 +183,10 @@ func (id {{.Name}}) CheckString() string {
 	return getCheckString(prefix{{.Name}}, string(id))
 }
 
+func (id {{.Name}}) IsZero() bool {
+	return id == ""
+}
+
 func (id {{.Name}}) Regex() rext.Regex {
 	return regex{{.Name}}
 }

bfcodegen/csid-generate_test.go

@@ -3,9 +3,9 @@ package bfcodegen
 import (
 	_ "embed"
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/cmdext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/cmdext"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"os"
 	"path/filepath"
 	"testing"

bfcodegen/enum-generate.go

@@ -6,11 +6,11 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"git.blackforestbytes.com/BlackForestBytes/goext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/cryptext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/rext"
 	"go/format"
-	"gogs.mikescher.com/BlackForestBytes/goext"
-	"gogs.mikescher.com/BlackForestBytes/goext/cryptext"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/rext"
 	"io"
 	"os"
 	"path"
@@ -46,7 +46,7 @@ var rexEnumPackage = rext.W(regexp.MustCompile(`^package\s+(?P<name>[A-Za-z0-9_]
 
 var rexEnumDef = rext.W(regexp.MustCompile(`^\s*type\s+(?P<name>[A-Za-z0-9_]+)\s+(?P<type>[A-Za-z0-9_]+)\s*//\s*(@enum:type).*$`))
 
-var rexEnumValueDef = rext.W(regexp.MustCompile(`^\s*(?P<name>[A-Za-z0-9_]+)\s+(?P<type>[A-Za-z0-9_]+)\s*=\s*(?P<value>("[A-Za-z0-9_:\s\-.]*"|[0-9]+))\s*(//(?P<comm>.*))?.*$`))
+var rexEnumValueDef = rext.W(regexp.MustCompile(`^\s*(?P<name>[A-Za-z0-9_]+)\s+(?P<type>[A-Za-z0-9_]+)\s*=\s*(?P<value>("[/@A-Za-z0-9_:\s\-.]*"|[0-9]+))\s*(//(?P<comm>.*))?.*$`))
 
 var rexEnumChecksumConst = rext.W(regexp.MustCompile(`const ChecksumEnumGenerator = "(?P<cs>[A-Za-z0-9_]*)"`))
 

bfcodegen/enum-generate.template

@@ -2,8 +2,8 @@
 
 package {{.PkgName}}
 
-import "gogs.mikescher.com/BlackForestBytes/goext/langext"
+import "git.blackforestbytes.com/BlackForestBytes/goext/langext"
-import "gogs.mikescher.com/BlackForestBytes/goext/enums"
+import "git.blackforestbytes.com/BlackForestBytes/goext/enums"
 
 const ChecksumEnumGenerator = "{{.Checksum}}" // GoExtVersion: {{.GoextVersion}}
 
@@ -117,6 +117,20 @@ func (e {{.EnumTypeName}}) DescriptionMeta() enums.EnumDescriptionMetaValue {
 }
 {{end}}
 
+{{if $hasData}}
+func (e {{.EnumTypeName}}) DataMeta() enums.EnumDataMetaValue {
+    return enums.EnumDataMetaValue{
+        VarName: e.VarName(),
+        Value: e,
+        {{if $hasDescr}} Description: langext.Ptr(e.Description()), {{else}} Description: nil, {{end}}
+        Data: map[string]any{
+            {{ range $datakey, $datatype := $enumdef | generalDataKeys  }} "{{ $datakey }}": e.Data().{{ $datakey | godatakey }},
+            {{ end }}
+        },
+    }
+}
+{{end}}
+
 func Parse{{.EnumTypeName}}(vv string) ({{.EnumTypeName}}, bool) {
 	for _, ev := range __{{.EnumTypeName}}Values {
 		if string(ev) == vv {
@@ -136,6 +150,12 @@ func {{.EnumTypeName}}ValuesMeta() []enums.EnumMetaValue {
 	}
 }
 
+func {{.EnumTypeName}}ValuesDataMeta() []enums.EnumMetaValue {
+	return []enums.EnumDataMetaValue{ {{range .Values}}
+            {{.VarName}}.DataMeta(), {{end}}
+	}
+}
+
 {{if $hasDescr}}
 func {{.EnumTypeName}}ValuesDescriptionMeta() []enums.EnumDescriptionMetaValue {
 	return []enums.EnumDescriptionMetaValue{ {{range .Values}}

bfcodegen/enum-generate_test.go

@@ -3,9 +3,9 @@ package bfcodegen
 import (
 	_ "embed"
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/cmdext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/cmdext"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"os"
 	"path/filepath"
 	"testing"

bfcodegen/id-generate.go

@@ -6,10 +6,10 @@ import (
 	"errors"
 	"fmt"
 	"go/format"
-	"gogs.mikescher.com/BlackForestBytes/goext"
+	"git.blackforestbytes.com/BlackForestBytes/goext"
-	"gogs.mikescher.com/BlackForestBytes/goext/cryptext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/cryptext"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/rext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/rext"
 	"io"
 	"os"
 	"path"

bfcodegen/id-generate.template

@@ -5,7 +5,7 @@ package {{.PkgName}}
 import "go.mongodb.org/mongo-driver/bson"
 import "go.mongodb.org/mongo-driver/bson/bsontype"
 import "go.mongodb.org/mongo-driver/bson/primitive"
-import "gogs.mikescher.com/BlackForestBytes/goext/exerr"
+import "git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 
 const ChecksumIDGenerator = "{{.Checksum}}" // GoExtVersion: {{.GoextVersion}}
 
@@ -38,8 +38,17 @@ func (i {{.Name}}) Valid() bool {
 func (i {{.Name}}) AsAny() {{$.AnyDef.Name}} {
 	return {{$.AnyDef.Name}}(i)
 }
+
+func (i {{.Name}}) AsAnyPtr() *{{$.AnyDef.Name}} {
+    v := {{$.AnyDef.Name}}(i)
+	return &v
+}
 {{end}}
 
+func (i {{.Name}}) IsZero() bool {
+	return i == ""
+}
+
 func New{{.Name}}() {{.Name}} {
 	return {{.Name}}(primitive.NewObjectID().Hex())
 }

bfcodegen/id-generate_test.go

@@ -3,9 +3,9 @@ package bfcodegen
 import (
 	_ "embed"
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/cmdext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/cmdext"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"os"
 	"path/filepath"
 	"testing"

cmdext/builder.go

@@ -2,7 +2,7 @@ package cmdext
 
 import (
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"time"
 )
 

cmdext/cmdrunner.go

@@ -2,9 +2,9 @@ package cmdext
 
 import (
 	"errors"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/mathext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/mathext"
-	"gogs.mikescher.com/BlackForestBytes/goext/syncext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/syncext"
 	"os/exec"
 	"time"
 )

cmdext/pipereader.go

@@ -2,7 +2,7 @@ package cmdext
 
 import (
 	"bufio"
-	"gogs.mikescher.com/BlackForestBytes/goext/syncext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/syncext"
 	"io"
 	"sync"
 )

confext/confParser.go

@@ -3,7 +3,7 @@ package confext
 import (
 	"errors"
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/timeext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/timeext"
 	"math/bits"
 	"os"
 	"reflect"

confext/confParser_test.go

@@ -1,8 +1,8 @@
 package confext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/timeext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/timeext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 	"time"
 )

cryptext/aes_test.go

@@ -2,7 +2,7 @@ package cryptext
 
 import (
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 )
 

cryptext/hash_test.go

@@ -1,7 +1,7 @@
 package cryptext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 )
 

cryptext/passHash.go

@@ -6,13 +6,15 @@ import (
 	"crypto/sha512"
 	"encoding/base64"
 	"encoding/hex"
+	"encoding/json"
 	"errors"
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/totpext"
-	"golang.org/x/crypto/bcrypt"
 	"strconv"
 	"strings"
+
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/totpext"
+	"golang.org/x/crypto/bcrypt"
 )
 
 const LatestPassHashVersion = 5
@@ -317,6 +319,13 @@ func (ph PassHash) String() string {
 	return string(ph)
 }
 
+func (ph PassHash) MarshalJSON() ([]byte, error) {
+	if ph == "" {
+		return json.Marshal("")
+	}
+	return json.Marshal("*****")
+}
+
 func HashPassword(plainpass string, totpSecret []byte) (PassHash, error) {
 	return HashPasswordV5(plainpass, totpSecret)
 }

cryptext/passHash_test.go

@@ -1,9 +1,9 @@
 package cryptext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/totpext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/totpext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 )
 

cursortoken/token.go

@@ -3,7 +3,7 @@ package cursortoken
 import (
 	"encoding/base32"
 	"encoding/json"
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"strconv"
 	"strings"
 	"time"

dataext/broadcaster.go

@@ -0,0 +1,230 @@
+package dataext
+
+import (
+	"context"
+	"iter"
+	"sync"
+	"time"
+
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/syncext"
+	"github.com/rs/xid"
+)
+
+// Broadcaster is a simple Broadcaster channel
+// This is a simpler interface over Broadcaster - which does not have distinct namespaces
+type Broadcaster[TData any] struct {
+	masterLock *sync.Mutex
+
+	subscriptions []*broadcastSubscription[TData]
+}
+
+type BroadcastSubscription interface {
+	Unsubscribe()
+}
+
+type broadcastSubscription[TData any] struct {
+	ID string
+
+	parent *Broadcaster[TData]
+
+	subLock *sync.Mutex
+
+	Func func(TData)
+	Chan chan TData
+
+	UnsubChan chan bool
+}
+
+func (p *broadcastSubscription[TData]) Unsubscribe() {
+	p.parent.unsubscribe(p)
+}
+
+func NewBroadcaster[TData any](capacity int) *Broadcaster[TData] {
+	return &Broadcaster[TData]{
+		masterLock:    &sync.Mutex{},
+		subscriptions: make([]*broadcastSubscription[TData], 0, capacity),
+	}
+}
+
+func (bb *Broadcaster[TData]) SubscriberCount() int {
+	bb.masterLock.Lock()
+	defer bb.masterLock.Unlock()
+
+	return len(bb.subscriptions)
+}
+
+// Publish sends `data` to all subscriber
+// But unbuffered - if one is currently not listening, we skip (the actualReceiver < subscriber)
+func (bb *Broadcaster[TData]) Publish(data TData) (subscriber int, actualReceiver int) {
+	bb.masterLock.Lock()
+	subs := langext.ArrCopy(bb.subscriptions)
+	bb.masterLock.Unlock()
+
+	subscriber = len(subs)
+	actualReceiver = 0
+
+	for _, sub := range subs {
+		func() {
+			sub.subLock.Lock()
+			defer sub.subLock.Unlock()
+
+			if sub.Func != nil {
+				go func() { sub.Func(data) }()
+				actualReceiver++
+			} else if sub.Chan != nil {
+				msgSent := syncext.WriteNonBlocking(sub.Chan, data)
+				if msgSent {
+					actualReceiver++
+				}
+			}
+		}()
+	}
+
+	return subscriber, actualReceiver
+}
+
+// PublishWithContext sends `data` to all subscriber
+// buffered - if one is currently not listening, we wait (but error out when the context runs out)
+func (bb *Broadcaster[TData]) PublishWithContext(ctx context.Context, data TData) (subscriber int, actualReceiver int, err error) {
+	bb.masterLock.Lock()
+	subs := langext.ArrCopy(bb.subscriptions)
+	bb.masterLock.Unlock()
+
+	subscriber = len(subs)
+	actualReceiver = 0
+
+	for _, sub := range subs {
+		err := func() error {
+			sub.subLock.Lock()
+			defer sub.subLock.Unlock()
+
+			if err := ctx.Err(); err != nil {
+				return err
+			}
+
+			if sub.Func != nil {
+				go func() { sub.Func(data) }()
+				actualReceiver++
+			} else if sub.Chan != nil {
+				err := syncext.WriteChannelWithContext(ctx, sub.Chan, data)
+				if err != nil {
+					return err
+				}
+				actualReceiver++
+			}
+
+			return nil
+		}()
+		if err != nil {
+			return subscriber, actualReceiver, err
+		}
+	}
+
+	return subscriber, actualReceiver, nil
+}
+
+// PublishWithTimeout sends `data` to all subscriber
+// buffered - if one is currently not listening, we wait (but wait at most `timeout` - if the timeout is exceeded then actualReceiver < subscriber)
+func (bb *Broadcaster[TData]) PublishWithTimeout(data TData, timeout time.Duration) (subscriber int, actualReceiver int) {
+	bb.masterLock.Lock()
+	subs := langext.ArrCopy(bb.subscriptions)
+	bb.masterLock.Unlock()
+
+	subscriber = len(subs)
+	actualReceiver = 0
+
+	for _, sub := range subs {
+		func() {
+			sub.subLock.Lock()
+			defer sub.subLock.Unlock()
+
+			if sub.Func != nil {
+				go func() { sub.Func(data) }()
+				actualReceiver++
+			} else if sub.Chan != nil {
+				ok := syncext.WriteChannelWithTimeout(sub.Chan, data, timeout)
+				if ok {
+					actualReceiver++
+				}
+			}
+		}()
+	}
+
+	return subscriber, actualReceiver
+}
+
+func (bb *Broadcaster[TData]) SubscribeByCallback(fn func(TData)) BroadcastSubscription {
+	bb.masterLock.Lock()
+	defer bb.masterLock.Unlock()
+
+	sub := &broadcastSubscription[TData]{ID: xid.New().String(), parent: bb, subLock: &sync.Mutex{}, Func: fn, UnsubChan: nil}
+
+	bb.subscriptions = append(bb.subscriptions, sub)
+
+	return sub
+}
+
+func (bb *Broadcaster[TData]) SubscribeByChan(chanBufferSize int) (chan TData, BroadcastSubscription) {
+	bb.masterLock.Lock()
+	defer bb.masterLock.Unlock()
+
+	msgCh := make(chan TData, chanBufferSize)
+
+	sub := &broadcastSubscription[TData]{ID: xid.New().String(), parent: bb, subLock: &sync.Mutex{}, Chan: msgCh, UnsubChan: nil}
+
+	bb.subscriptions = append(bb.subscriptions, sub)
+
+	return msgCh, sub
+}
+
+func (bb *Broadcaster[TData]) SubscribeByIter(chanBufferSize int) (iter.Seq[TData], BroadcastSubscription) {
+	bb.masterLock.Lock()
+	defer bb.masterLock.Unlock()
+
+	msgCh := make(chan TData, chanBufferSize)
+	unsubChan := make(chan bool, 8)
+
+	sub := &broadcastSubscription[TData]{ID: xid.New().String(), parent: bb, subLock: &sync.Mutex{}, Chan: msgCh, UnsubChan: unsubChan}
+
+	bb.subscriptions = append(bb.subscriptions, sub)
+
+	iterFun := func(yield func(TData) bool) {
+		for {
+			select {
+			case msg := <-msgCh:
+				if !yield(msg) {
+					sub.Unsubscribe()
+					return
+				}
+			case <-sub.UnsubChan:
+				sub.Unsubscribe()
+				return
+			}
+		}
+	}
+
+	return iterFun, sub
+}
+
+func (bb *Broadcaster[TData]) unsubscribe(p *broadcastSubscription[TData]) {
+	bb.masterLock.Lock()
+	defer bb.masterLock.Unlock()
+
+	p.subLock.Lock()
+	defer p.subLock.Unlock()
+
+	if p.Chan != nil {
+		close(p.Chan)
+		p.Chan = nil
+	}
+	if p.UnsubChan != nil {
+		syncext.WriteNonBlocking(p.UnsubChan, true)
+		close(p.UnsubChan)
+		p.UnsubChan = nil
+	}
+
+	bb.subscriptions = langext.ArrFilter(bb.subscriptions, func(v *broadcastSubscription[TData]) bool {
+		return v.ID != p.ID
+	})
+}

dataext/broadcaster_test.go

@@ -0,0 +1,332 @@
+package dataext
+
+import (
+	"context"
+	"sync"
+	"testing"
+	"time"
+)
+
+func TestNewBroadcast(t *testing.T) {
+	bb := NewBroadcaster[string](10)
+	if bb == nil {
+		t.Fatal("NewBroadcaster returned nil")
+	}
+	if bb.masterLock == nil {
+		t.Fatal("masterLock is nil")
+	}
+	if bb.subscriptions == nil {
+		t.Fatal("subscriptions is nil")
+	}
+}
+
+func TestBroadcast_SubscribeByCallback(t *testing.T) {
+	bb := NewBroadcaster[string](10)
+
+	var received string
+	var wg sync.WaitGroup
+	wg.Add(1)
+
+	callback := func(msg string) {
+		received = msg
+		wg.Done()
+	}
+
+	sub := bb.SubscribeByCallback(callback)
+	defer sub.Unsubscribe()
+
+	// Publish a message
+	subs, receivers := bb.Publish("hello")
+
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+
+	if receivers != 1 {
+		t.Fatalf("Expected 1 receiver, got %d", receivers)
+	}
+
+	// Wait for the callback to be executed
+	wg.Wait()
+
+	if received != "hello" {
+		t.Fatalf("Expected to receive 'hello', got '%s'", received)
+	}
+}
+
+func TestBroadcast_SubscribeByChan(t *testing.T) {
+	bb := NewBroadcaster[string](10)
+
+	ch, sub := bb.SubscribeByChan(1)
+	defer sub.Unsubscribe()
+
+	// Publish a message
+	subs, receivers := bb.Publish("hello")
+
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+
+	if receivers != 1 {
+		t.Fatalf("Expected 1 receiver, got %d", receivers)
+	}
+
+	// Read from the channel with a timeout to avoid blocking
+	select {
+	case msg := <-ch:
+		if msg != "hello" {
+			t.Fatalf("Expected to receive 'hello', got '%s'", msg)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("Timed out waiting for message")
+	}
+}
+
+func TestBroadcast_SubscribeByIter(t *testing.T) {
+	bb := NewBroadcaster[string](10)
+
+	iterSeq, sub := bb.SubscribeByIter(1)
+	defer sub.Unsubscribe()
+
+	// Channel to communicate when message is received
+	done := make(chan bool)
+	received := false
+
+	// Start a goroutine to use the iterator
+	go func() {
+		for msg := range iterSeq {
+			if msg == "hello" {
+				received = true
+				done <- true
+				return // Stop iteration
+			}
+		}
+	}()
+
+	// Give time for the iterator to start
+	time.Sleep(100 * time.Millisecond)
+
+	// Publish a message
+	bb.Publish("hello")
+
+	// Wait for the message to be received or timeout
+	select {
+	case <-done:
+		if !received {
+			t.Fatal("Message was received but not 'hello'")
+		}
+	case <-time.After(time.Second):
+		t.Fatal("Timed out waiting for message")
+	}
+
+	subCount := bb.SubscriberCount()
+	if subCount != 0 {
+		t.Fatalf("Expected 0 receivers, got %d", subCount)
+	}
+}
+
+func TestBroadcast_Publish(t *testing.T) {
+	bb := NewBroadcaster[string](10)
+
+	// Test publishing with no subscribers
+	subs, receivers := bb.Publish("hello")
+	if subs != 0 {
+		t.Fatalf("Expected 0 subscribers, got %d", subs)
+	}
+	if receivers != 0 {
+		t.Fatalf("Expected 0 receivers, got %d", receivers)
+	}
+
+	// Add a subscriber
+	ch, sub := bb.SubscribeByChan(1)
+	defer sub.Unsubscribe()
+
+	// Publish a message
+	subs, receivers = bb.Publish("hello")
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+	if receivers != 1 {
+		t.Fatalf("Expected 1 receiver, got %d", receivers)
+	}
+
+	// Verify the message was received
+	select {
+	case msg := <-ch:
+		if msg != "hello" {
+			t.Fatalf("Expected to receive 'hello', got '%s'", msg)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("Timed out waiting for message")
+	}
+
+	// Test non-blocking behavior with a full channel
+	// First fill the channel
+	bb.Publish("fill")
+
+	// Now publish again - this should not block but may skip the receiver
+	subs, receivers = bb.Publish("overflow")
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+	_ = receivers // may be 0 if channel is full
+
+	// Drain the channel
+	<-ch
+}
+
+func TestBroadcast_PublishWithTimeout(t *testing.T) {
+	bb := NewBroadcaster[string](10)
+
+	// Add a subscriber with a channel
+	ch, sub := bb.SubscribeByChan(1)
+	defer sub.Unsubscribe()
+
+	// Publish with a timeout
+	subs, receivers := bb.PublishWithTimeout("hello", 100*time.Millisecond)
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+	if receivers != 1 {
+		t.Fatalf("Expected 1 receiver, got %d", receivers)
+	}
+
+	// Verify the message was received
+	select {
+	case msg := <-ch:
+		if msg != "hello" {
+			t.Fatalf("Expected to receive 'hello', got '%s'", msg)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("Timed out waiting for message")
+	}
+
+	// Fill the channel
+	bb.Publish("fill")
+
+	// Test timeout behavior with a full channel
+	start := time.Now()
+	subs, receivers = bb.PublishWithTimeout("timeout-test", 50*time.Millisecond)
+	elapsed := time.Since(start)
+
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+
+	// The receiver count should be 0 if the timeout occurred
+	if elapsed < 50*time.Millisecond {
+		t.Fatalf("Expected to wait at least 50ms, only waited %v", elapsed)
+	}
+
+	// Drain the channel
+	<-ch
+}
+
+func TestBroadcast_PublishWithContext(t *testing.T) {
+	bb := NewBroadcaster[string](10)
+
+	// Add a subscriber with a channel
+	ch, sub := bb.SubscribeByChan(1)
+	defer sub.Unsubscribe()
+
+	// Create a context
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+	defer cancel()
+
+	// Publish with context
+	subs, receivers, err := bb.PublishWithContext(ctx, "hello")
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+	if receivers != 1 {
+		t.Fatalf("Expected 1 receiver, got %d", receivers)
+	}
+
+	// Verify the message was received
+	select {
+	case msg := <-ch:
+		if msg != "hello" {
+			t.Fatalf("Expected to receive 'hello', got '%s'", msg)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("Timed out waiting for message")
+	}
+
+	// Fill the channel
+	bb.Publish("fill")
+
+	// Test context cancellation with a full channel
+	ctx, cancel = context.WithCancel(context.Background())
+
+	// Cancel the context after a short delay
+	go func() {
+		time.Sleep(50 * time.Millisecond)
+		cancel()
+	}()
+
+	start := time.Now()
+	subs, receivers, err = bb.PublishWithContext(ctx, "context-test")
+	elapsed := time.Since(start)
+
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+
+	// Should get a context canceled error
+	if err == nil {
+		t.Fatal("Expected context canceled error, got nil")
+	}
+
+	if elapsed < 50*time.Millisecond {
+		t.Fatalf("Expected to wait at least 50ms, only waited %v", elapsed)
+	}
+
+	// Drain the channel
+	<-ch
+}
+
+func TestBroadcast_Unsubscribe(t *testing.T) {
+	bb := NewBroadcaster[string](10)
+
+	// Add a subscriber
+	ch, sub := bb.SubscribeByChan(1)
+
+	// Publish a message
+	subs, receivers := bb.Publish("hello")
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+	if receivers != 1 {
+		t.Fatalf("Expected 1 receiver, got %d", receivers)
+	}
+
+	// Verify the message was received
+	select {
+	case msg := <-ch:
+		if msg != "hello" {
+			t.Fatalf("Expected to receive 'hello', got '%s'", msg)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("Timed out waiting for message")
+	}
+
+	// Unsubscribe
+	sub.Unsubscribe()
+
+	// Publish again
+	subs, receivers = bb.Publish("after-unsub")
+	if subs != 0 {
+		t.Fatalf("Expected 0 subscribers after unsubscribe, got %d", subs)
+	}
+	if receivers != 0 {
+		t.Fatalf("Expected 0 receivers after unsubscribe, got %d", receivers)
+	}
+
+	// Check that the subscriber count is 0
+	if bb.SubscriberCount() != 0 {
+		t.Fatalf("Expected SubscriberCount() == 0, got %d", bb.SubscriberCount())
+	}
+}

dataext/delayedCombiningInvoker.go

@@ -0,0 +1,202 @@
+package dataext
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/syncext"
+)
+
+// DelayedCombiningInvoker is a utility to combine multiple consecutive requests into a single execution
+//
+// Requests are made with Request(), and consecutive requests are combined during the `delay` period.
+//
+// Can be used, e.g., for search-controls, where we want to init the search when teh user stops typing
+// Or generally to queue an execution once a burst of requests is over.
+type DelayedCombiningInvoker struct {
+	syncLock           sync.Mutex
+	triggerChan        chan bool
+	cancelChan         chan bool
+	execNowChan        chan bool
+	action             func()
+	delay              time.Duration
+	maxDelay           time.Duration
+	executorRunning    *syncext.AtomicBool
+	pendingRequests    *syncext.Atomic[int]
+	lastRequestTime    time.Time
+	initialRequestTime time.Time
+
+	onExecutionStart []func(immediately bool)          // listener ( actual execution of action starts )
+	onExecutionDone  []func()                          // listener ( actual execution of action finished )
+	onRequest        []func(pending int, initial bool) // listener ( a request came in, waiting for execution )
+}
+
+func NewDelayedCombiningInvoker(action func(), delay time.Duration, maxDelay time.Duration) *DelayedCombiningInvoker {
+	return &DelayedCombiningInvoker{
+		action:             action,
+		delay:              delay,
+		maxDelay:           maxDelay,
+		executorRunning:    syncext.NewAtomicBool(false),
+		pendingRequests:    syncext.NewAtomic[int](0),
+		triggerChan:        make(chan bool),
+		cancelChan:         make(chan bool, 1),
+		execNowChan:        make(chan bool, 1),
+		lastRequestTime:    time.Now(),
+		initialRequestTime: time.Now(),
+		onExecutionStart:   make([]func(bool), 0),
+		onExecutionDone:    make([]func(), 0),
+		onRequest:          make([]func(int, bool), 0),
+	}
+}
+
+func (d *DelayedCombiningInvoker) Request() {
+	now := time.Now()
+
+	d.syncLock.Lock()
+	defer d.syncLock.Unlock()
+
+	if d.executorRunning.Get() {
+		d.lastRequestTime = now
+		d.pendingRequests.Update(func(v int) int { return v + 1 })
+
+		for _, fn := range d.onRequest {
+			_ = langext.RunPanicSafe(func() { fn(d.pendingRequests.Get(), true) })
+		}
+
+		d.triggerChan <- true
+	} else {
+		d.initialRequestTime = now
+		d.lastRequestTime = now
+
+		d.executorRunning.Set(true)
+		d.pendingRequests.Set(1)
+		syncext.ReadNonBlocking(d.triggerChan) // clear the channel
+		syncext.ReadNonBlocking(d.cancelChan)  // clear the channel
+		syncext.ReadNonBlocking(d.execNowChan) // clear the channel
+
+		for _, fn := range d.onRequest {
+			_ = langext.RunPanicSafe(func() { fn(d.pendingRequests.Get(), false) })
+		}
+
+		go d.run()
+	}
+}
+
+func (d *DelayedCombiningInvoker) run() {
+
+	needsExecutorRunningCleanup := true
+	defer func() {
+		if needsExecutorRunningCleanup {
+			d.syncLock.Lock()
+			d.executorRunning.Set(false)
+			d.syncLock.Unlock()
+		}
+	}()
+
+	for {
+		d.syncLock.Lock()
+		timeOut := min(d.maxDelay-time.Since(d.initialRequestTime), d.delay-time.Since(d.lastRequestTime))
+		if timeOut < 0 {
+			timeOut = 0
+		}
+		d.syncLock.Unlock()
+
+		immediately := false
+
+		select {
+		case <-d.execNowChan:
+			// run immediately
+			immediately = true
+			break
+		case <-d.triggerChan:
+			// external trigger - needs to re-evaluate
+			break
+		case <-d.cancelChan:
+			// cancel
+			return
+		case <-time.After(timeOut):
+			// time elapsed - check for execution
+			break
+
+		}
+
+		d.syncLock.Lock()
+		execute := immediately || time.Since(d.lastRequestTime) >= d.delay || time.Since(d.initialRequestTime) >= d.maxDelay
+		if !execute {
+			d.syncLock.Unlock()
+			continue
+		}
+
+		d.pendingRequests.Set(0)
+
+		for _, fn := range d.onExecutionStart {
+			_ = langext.RunPanicSafe(func() { fn(immediately) })
+		}
+
+		// =================================================
+		_ = langext.RunPanicSafe(d.action)
+		// =================================================
+
+		d.executorRunning.Set(false) // ensure HasPendingRequests returns fals ein onExecutionDone listener
+		needsExecutorRunningCleanup = false
+
+		for _, fn := range d.onExecutionDone {
+			_ = langext.RunPanicSafe(fn)
+		}
+
+		d.syncLock.Unlock()
+
+		return
+	}
+}
+
+func (d *DelayedCombiningInvoker) CancelPendingRequests() {
+	d.syncLock.Lock()
+	defer d.syncLock.Unlock()
+
+	syncext.WriteNonBlocking(d.cancelChan, true)
+}
+
+func (d *DelayedCombiningInvoker) HasPendingRequests() bool {
+	return d.executorRunning.Get()
+}
+
+func (d *DelayedCombiningInvoker) CountPendingRequests() int {
+	return d.pendingRequests.Get()
+}
+
+func (d *DelayedCombiningInvoker) ExecuteNow() bool {
+	d.syncLock.Lock()
+	defer d.syncLock.Unlock()
+
+	if d.executorRunning.Get() {
+		syncext.WriteNonBlocking(d.execNowChan, true)
+		return true
+	} else {
+		return false
+	}
+}
+
+func (d *DelayedCombiningInvoker) WaitForCompletion(ctx context.Context) error {
+	return d.executorRunning.WaitWithContext(ctx, false)
+}
+
+func (d *DelayedCombiningInvoker) RegisterOnExecutionStart(fn func(immediately bool)) {
+	d.syncLock.Lock()
+	defer d.syncLock.Unlock()
+	d.onExecutionStart = append(d.onExecutionStart, fn)
+}
+
+func (d *DelayedCombiningInvoker) RegisterOnExecutionDone(fn func()) {
+	d.syncLock.Lock()
+	defer d.syncLock.Unlock()
+	d.onExecutionDone = append(d.onExecutionDone, fn)
+}
+
+func (d *DelayedCombiningInvoker) RegisterOnRequest(fn func(pending int, initial bool)) {
+	d.syncLock.Lock()
+	defer d.syncLock.Unlock()
+	d.onRequest = append(d.onRequest, fn)
+}

dataext/lruMap_test.go

@@ -1,7 +1,7 @@
 package dataext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"math/rand"
 	"strconv"
 	"testing"

dataext/merge_test.go

@@ -1,8 +1,8 @@
 package dataext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 )
 

dataext/optional.go

@@ -3,7 +3,7 @@ package dataext
 import (
 	"encoding/json"
 	"errors"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 )
 
 type JsonOpt[T any] struct {

dataext/pubsub.go

@@ -0,0 +1,241 @@
+package dataext
+
+import (
+	"context"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/syncext"
+	"github.com/rs/xid"
+	"iter"
+	"sync"
+	"time"
+)
+
+// PubSub is a simple Pub/Sub Broker
+// Clients can subscribe to a namespace and receive published messages on this namespace
+// Messages are broadcast to all subscribers
+type PubSub[TNamespace comparable, TData any] struct {
+	masterLock *sync.Mutex
+
+	subscriptions map[TNamespace][]*pubSubSubscription[TNamespace, TData]
+}
+
+type PubSubSubscription interface {
+	Unsubscribe()
+}
+
+type pubSubSubscription[TNamespace comparable, TData any] struct {
+	ID string
+
+	parent    *PubSub[TNamespace, TData]
+	namespace TNamespace
+
+	subLock *sync.Mutex
+
+	Func func(TData)
+	Chan chan TData
+
+	UnsubChan chan bool
+}
+
+func (p *pubSubSubscription[TNamespace, TData]) Unsubscribe() {
+	p.parent.unsubscribe(p)
+}
+
+func NewPubSub[TNamespace comparable, TData any](capacity int) *PubSub[TNamespace, TData] {
+	return &PubSub[TNamespace, TData]{
+		masterLock:    &sync.Mutex{},
+		subscriptions: make(map[TNamespace][]*pubSubSubscription[TNamespace, TData], capacity),
+	}
+}
+
+func (ps *PubSub[TNamespace, TData]) Namespaces() []TNamespace {
+	ps.masterLock.Lock()
+	defer ps.masterLock.Unlock()
+
+	return langext.MapKeyArr(ps.subscriptions)
+}
+
+func (ps *PubSub[TNamespace, TData]) SubscriberCount(ns TNamespace) int {
+	ps.masterLock.Lock()
+	defer ps.masterLock.Unlock()
+
+	return len(ps.subscriptions[ns])
+}
+
+// Publish sends `data` to all subscriber
+// But unbuffered - if one is currently not listening, we skip (the actualReceiver < subscriber)
+func (ps *PubSub[TNamespace, TData]) Publish(ns TNamespace, data TData) (subscriber int, actualReceiver int) {
+	ps.masterLock.Lock()
+	subs := langext.ArrCopy(ps.subscriptions[ns])
+	ps.masterLock.Unlock()
+
+	subscriber = len(subs)
+	actualReceiver = 0
+
+	for _, sub := range subs {
+		func() {
+			sub.subLock.Lock()
+			defer sub.subLock.Unlock()
+
+			if sub.Func != nil {
+				go func() { sub.Func(data) }()
+				actualReceiver++
+			} else if sub.Chan != nil {
+				msgSent := syncext.WriteNonBlocking(sub.Chan, data)
+				if msgSent {
+					actualReceiver++
+				}
+			}
+		}()
+	}
+
+	return subscriber, actualReceiver
+}
+
+// PublishWithContext sends `data` to all subscriber
+// buffered - if one is currently not listening, we wait (but error out when the context runs out)
+func (ps *PubSub[TNamespace, TData]) PublishWithContext(ctx context.Context, ns TNamespace, data TData) (subscriber int, actualReceiver int, err error) {
+	ps.masterLock.Lock()
+	subs := langext.ArrCopy(ps.subscriptions[ns])
+	ps.masterLock.Unlock()
+
+	subscriber = len(subs)
+	actualReceiver = 0
+
+	for _, sub := range subs {
+		err := func() error {
+			sub.subLock.Lock()
+			defer sub.subLock.Unlock()
+
+			if err := ctx.Err(); err != nil {
+				return err
+			}
+
+			if sub.Func != nil {
+				go func() { sub.Func(data) }()
+				actualReceiver++
+			} else if sub.Chan != nil {
+				err := syncext.WriteChannelWithContext(ctx, sub.Chan, data)
+				if err != nil {
+					return err
+				}
+				actualReceiver++
+			}
+
+			return nil
+		}()
+		if err != nil {
+			return subscriber, actualReceiver, err
+		}
+	}
+
+	return subscriber, actualReceiver, nil
+}
+
+// PublishWithTimeout sends `data` to all subscriber
+// buffered - if one is currently not listening, we wait (but wait at most `timeout` - if the timeout is exceeded then actualReceiver < subscriber)
+func (ps *PubSub[TNamespace, TData]) PublishWithTimeout(ns TNamespace, data TData, timeout time.Duration) (subscriber int, actualReceiver int) {
+	ps.masterLock.Lock()
+	subs := langext.ArrCopy(ps.subscriptions[ns])
+	ps.masterLock.Unlock()
+
+	subscriber = len(subs)
+	actualReceiver = 0
+
+	for _, sub := range subs {
+		func() {
+			sub.subLock.Lock()
+			defer sub.subLock.Unlock()
+
+			if sub.Func != nil {
+				go func() { sub.Func(data) }()
+				actualReceiver++
+			} else if sub.Chan != nil {
+				ok := syncext.WriteChannelWithTimeout(sub.Chan, data, timeout)
+				if ok {
+					actualReceiver++
+				}
+			}
+		}()
+	}
+
+	return subscriber, actualReceiver
+}
+
+func (ps *PubSub[TNamespace, TData]) SubscribeByCallback(ns TNamespace, fn func(TData)) PubSubSubscription {
+	ps.masterLock.Lock()
+	defer ps.masterLock.Unlock()
+
+	sub := &pubSubSubscription[TNamespace, TData]{ID: xid.New().String(), namespace: ns, parent: ps, subLock: &sync.Mutex{}, Func: fn, UnsubChan: nil}
+
+	ps.subscriptions[ns] = append(ps.subscriptions[ns], sub)
+
+	return sub
+}
+
+func (ps *PubSub[TNamespace, TData]) SubscribeByChan(ns TNamespace, chanBufferSize int) (chan TData, PubSubSubscription) {
+	ps.masterLock.Lock()
+	defer ps.masterLock.Unlock()
+
+	msgCh := make(chan TData, chanBufferSize)
+
+	sub := &pubSubSubscription[TNamespace, TData]{ID: xid.New().String(), namespace: ns, parent: ps, subLock: &sync.Mutex{}, Chan: msgCh, UnsubChan: nil}
+
+	ps.subscriptions[ns] = append(ps.subscriptions[ns], sub)
+
+	return msgCh, sub
+}
+
+func (ps *PubSub[TNamespace, TData]) SubscribeByIter(ns TNamespace, chanBufferSize int) (iter.Seq[TData], PubSubSubscription) {
+	ps.masterLock.Lock()
+	defer ps.masterLock.Unlock()
+
+	msgCh := make(chan TData, chanBufferSize)
+	unsubChan := make(chan bool, 8)
+
+	sub := &pubSubSubscription[TNamespace, TData]{ID: xid.New().String(), namespace: ns, parent: ps, subLock: &sync.Mutex{}, Chan: msgCh, UnsubChan: unsubChan}
+
+	ps.subscriptions[ns] = append(ps.subscriptions[ns], sub)
+
+	iterFun := func(yield func(TData) bool) {
+		for {
+			select {
+			case msg := <-msgCh:
+				if !yield(msg) {
+					sub.Unsubscribe()
+					return
+				}
+			case <-sub.UnsubChan:
+				sub.Unsubscribe()
+				return
+			}
+		}
+	}
+
+	return iterFun, sub
+}
+
+func (ps *PubSub[TNamespace, TData]) unsubscribe(p *pubSubSubscription[TNamespace, TData]) {
+	ps.masterLock.Lock()
+	defer ps.masterLock.Unlock()
+
+	p.subLock.Lock()
+	defer p.subLock.Unlock()
+
+	if p.Chan != nil {
+		close(p.Chan)
+		p.Chan = nil
+	}
+	if p.UnsubChan != nil {
+		syncext.WriteNonBlocking(p.UnsubChan, true)
+		close(p.UnsubChan)
+		p.UnsubChan = nil
+	}
+
+	ps.subscriptions[p.namespace] = langext.ArrFilter(ps.subscriptions[p.namespace], func(v *pubSubSubscription[TNamespace, TData]) bool {
+		return v.ID != p.ID
+	})
+	if len(ps.subscriptions[p.namespace]) == 0 {
+		delete(ps.subscriptions, p.namespace)
+	}
+}

dataext/pubsub_test.go

@@ -0,0 +1,428 @@
+package dataext
+
+import (
+	"context"
+	"sync"
+	"testing"
+	"time"
+)
+
+func TestNewPubSub(t *testing.T) {
+	ps := NewPubSub[string, string](10)
+	if ps == nil {
+		t.Fatal("NewPubSub returned nil")
+	}
+	if ps.masterLock == nil {
+		t.Fatal("masterLock is nil")
+	}
+	if ps.subscriptions == nil {
+		t.Fatal("subscriptions is nil")
+	}
+}
+
+func TestPubSub_Namespaces(t *testing.T) {
+	ps := NewPubSub[string, string](10)
+
+	// Initially no namespaces
+	namespaces := ps.Namespaces()
+	if len(namespaces) != 0 {
+		t.Fatalf("Expected 0 namespaces, got %d", len(namespaces))
+	}
+
+	// Add a subscription to create a namespace
+	_, sub1 := ps.SubscribeByChan("test-ns1", 1)
+	defer sub1.Unsubscribe()
+
+	// Add another subscription to a different namespace
+	_, sub2 := ps.SubscribeByChan("test-ns2", 1)
+	defer sub2.Unsubscribe()
+
+	// Check namespaces
+	namespaces = ps.Namespaces()
+	if len(namespaces) != 2 {
+		t.Fatalf("Expected 2 namespaces, got %d", len(namespaces))
+	}
+
+	// Check if namespaces contain the expected values
+	found1, found2 := false, false
+	for _, ns := range namespaces {
+		if ns == "test-ns1" {
+			found1 = true
+		}
+		if ns == "test-ns2" {
+			found2 = true
+		}
+	}
+
+	if !found1 || !found2 {
+		t.Fatalf("Expected to find both namespaces, found ns1: %v, ns2: %v", found1, found2)
+	}
+}
+
+func TestPubSub_SubscribeByCallback(t *testing.T) {
+	ps := NewPubSub[string, string](10)
+
+	var received string
+	var wg sync.WaitGroup
+	wg.Add(1)
+
+	callback := func(msg string) {
+		received = msg
+		wg.Done()
+	}
+
+	sub := ps.SubscribeByCallback("test-ns", callback)
+	defer sub.Unsubscribe()
+
+	// Publish a message
+	subs, receivers := ps.Publish("test-ns", "hello")
+
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+
+	if receivers != 1 {
+		t.Fatalf("Expected 1 receiver, got %d", receivers)
+	}
+
+	// Wait for the callback to be executed
+	wg.Wait()
+
+	if received != "hello" {
+		t.Fatalf("Expected to receive 'hello', got '%s'", received)
+	}
+}
+
+func TestPubSub_SubscribeByChan(t *testing.T) {
+	ps := NewPubSub[string, string](10)
+
+	ch, sub := ps.SubscribeByChan("test-ns", 1)
+	defer sub.Unsubscribe()
+
+	// Publish a message
+	subs, receivers := ps.Publish("test-ns", "hello")
+
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+
+	if receivers != 1 {
+		t.Fatalf("Expected 1 receiver, got %d", receivers)
+	}
+
+	// Read from the channel with a timeout to avoid blocking
+	select {
+	case msg := <-ch:
+		if msg != "hello" {
+			t.Fatalf("Expected to receive 'hello', got '%s'", msg)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("Timed out waiting for message")
+	}
+}
+
+func TestPubSub_SubscribeByIter(t *testing.T) {
+	ps := NewPubSub[string, string](10)
+
+	iterSeq, sub := ps.SubscribeByIter("test-ns", 1)
+	defer sub.Unsubscribe()
+
+	// Channel to communicate when message is received
+	done := make(chan bool)
+	received := false
+
+	// Start a goroutine to use the iterator
+	go func() {
+		for msg := range iterSeq {
+			if msg == "hello" {
+				received = true
+				done <- true
+				return // Stop iteration
+			}
+		}
+	}()
+
+	// Give time for the iterator to start
+	time.Sleep(100 * time.Millisecond)
+
+	// Publish a message
+	ps.Publish("test-ns", "hello")
+
+	// Wait for the message to be received or timeout
+	select {
+	case <-done:
+		if !received {
+			t.Fatal("Message was received but not 'hello'")
+		}
+	case <-time.After(time.Second):
+		t.Fatal("Timed out waiting for message")
+	}
+
+	subCount := ps.SubscriberCount("test-ns")
+	if subCount != 0 {
+		t.Fatalf("Expected 0 receivers, got %d", subCount)
+	}
+}
+
+func TestPubSub_Publish(t *testing.T) {
+	ps := NewPubSub[string, string](10)
+
+	// Test publishing to a namespace with no subscribers
+	subs, receivers := ps.Publish("empty-ns", "hello")
+	if subs != 0 {
+		t.Fatalf("Expected 0 subscribers, got %d", subs)
+	}
+	if receivers != 0 {
+		t.Fatalf("Expected 0 receivers, got %d", receivers)
+	}
+
+	// Add a subscriber
+	ch, sub := ps.SubscribeByChan("test-ns", 1)
+	defer sub.Unsubscribe()
+
+	// Publish a message
+	subs, receivers = ps.Publish("test-ns", "hello")
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+	if receivers != 1 {
+		t.Fatalf("Expected 1 receiver, got %d", receivers)
+	}
+
+	// Verify the message was received
+	select {
+	case msg := <-ch:
+		if msg != "hello" {
+			t.Fatalf("Expected to receive 'hello', got '%s'", msg)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("Timed out waiting for message")
+	}
+
+	// Test non-blocking behavior with a full channel
+	// First fill the channel
+	ps.Publish("test-ns", "fill")
+
+	// Now publish again - this should not block but skip the receiver
+	subs, receivers = ps.Publish("test-ns", "overflow")
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+	// The receiver count might be 0 if the channel is full
+
+	// Drain the channel
+	<-ch
+}
+
+func TestPubSub_PublishWithTimeout(t *testing.T) {
+	ps := NewPubSub[string, string](10)
+
+	// Add a subscriber with a channel
+	ch, sub := ps.SubscribeByChan("test-ns", 1)
+	defer sub.Unsubscribe()
+
+	// Publish with a timeout
+	subs, receivers := ps.PublishWithTimeout("test-ns", "hello", 100*time.Millisecond)
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+	if receivers != 1 {
+		t.Fatalf("Expected 1 receiver, got %d", receivers)
+	}
+
+	// Verify the message was received
+	select {
+	case msg := <-ch:
+		if msg != "hello" {
+			t.Fatalf("Expected to receive 'hello', got '%s'", msg)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("Timed out waiting for message")
+	}
+
+	// Fill the channel
+	ps.Publish("test-ns", "fill")
+
+	// Test timeout behavior with a full channel
+	start := time.Now()
+	subs, receivers = ps.PublishWithTimeout("test-ns", "timeout-test", 50*time.Millisecond)
+	elapsed := time.Since(start)
+
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+
+	// The receiver count should be 0 if the timeout occurred
+	if elapsed < 50*time.Millisecond {
+		t.Fatalf("Expected to wait at least 50ms, only waited %v", elapsed)
+	}
+
+	// Drain the channel
+	<-ch
+}
+
+func TestPubSub_PublishWithContext(t *testing.T) {
+	ps := NewPubSub[string, string](10)
+
+	// Add a subscriber with a channel
+	ch, sub := ps.SubscribeByChan("test-ns", 1)
+	defer sub.Unsubscribe()
+
+	// Create a context
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+	defer cancel()
+
+	// Publish with context
+	subs, receivers, err := ps.PublishWithContext(ctx, "test-ns", "hello")
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+	if receivers != 1 {
+		t.Fatalf("Expected 1 receiver, got %d", receivers)
+	}
+
+	// Verify the message was received
+	select {
+	case msg := <-ch:
+		if msg != "hello" {
+			t.Fatalf("Expected to receive 'hello', got '%s'", msg)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("Timed out waiting for message")
+	}
+
+	// Fill the channel
+	ps.Publish("test-ns", "fill")
+
+	// Test context cancellation with a full channel
+	ctx, cancel = context.WithCancel(context.Background())
+
+	// Cancel the context after a short delay
+	go func() {
+		time.Sleep(50 * time.Millisecond)
+		cancel()
+	}()
+
+	start := time.Now()
+	subs, receivers, err = ps.PublishWithContext(ctx, "test-ns", "context-test")
+	elapsed := time.Since(start)
+
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+
+	// Should get a context canceled error
+	if err == nil {
+		t.Fatal("Expected context canceled error, got nil")
+	}
+
+	if elapsed < 50*time.Millisecond {
+		t.Fatalf("Expected to wait at least 50ms, only waited %v", elapsed)
+	}
+
+	// Drain the channel
+	<-ch
+}
+
+func TestPubSub_Unsubscribe(t *testing.T) {
+	ps := NewPubSub[string, string](10)
+
+	// Add a subscriber
+	ch, sub := ps.SubscribeByChan("test-ns", 1)
+
+	// Publish a message
+	subs, receivers := ps.Publish("test-ns", "hello")
+	if subs != 1 {
+		t.Fatalf("Expected 1 subscriber, got %d", subs)
+	}
+	if receivers != 1 {
+		t.Fatalf("Expected 1 receiver, got %d", receivers)
+	}
+
+	// Verify the message was received
+	select {
+	case msg := <-ch:
+		if msg != "hello" {
+			t.Fatalf("Expected to receive 'hello', got '%s'", msg)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("Timed out waiting for message")
+	}
+
+	// Unsubscribe
+	sub.Unsubscribe()
+
+	// Publish again
+	subs, receivers = ps.Publish("test-ns", "after-unsub")
+	if subs != 0 {
+		t.Fatalf("Expected 0 subscribers after unsubscribe, got %d", subs)
+	}
+	if receivers != 0 {
+		t.Fatalf("Expected 0 receivers after unsubscribe, got %d", receivers)
+	}
+
+	// Check that the namespace is removed
+	namespaces := ps.Namespaces()
+	if len(namespaces) != 0 {
+		t.Fatalf("Expected 0 namespaces after unsubscribe, got %d", len(namespaces))
+	}
+}
+
+func TestPubSub_MultipleSubscribers(t *testing.T) {
+	ps := NewPubSub[string, string](10)
+
+	// Add multiple subscribers
+	ch1, sub1 := ps.SubscribeByChan("test-ns", 1)
+	defer sub1.Unsubscribe()
+
+	ch2, sub2 := ps.SubscribeByChan("test-ns", 1)
+	defer sub2.Unsubscribe()
+
+	var received string
+	var wg sync.WaitGroup
+	wg.Add(1)
+
+	sub3 := ps.SubscribeByCallback("test-ns", func(msg string) {
+		received = msg
+		wg.Done()
+	})
+	defer sub3.Unsubscribe()
+
+	// Publish a message
+	subs, receivers := ps.Publish("test-ns", "hello")
+	if subs != 3 {
+		t.Fatalf("Expected 3 subscribers, got %d", subs)
+	}
+	if receivers != 3 {
+		t.Fatalf("Expected 3 receivers, got %d", receivers)
+	}
+
+	// Verify the message was received by all subscribers
+	select {
+	case msg := <-ch1:
+		if msg != "hello" {
+			t.Fatalf("Expected ch1 to receive 'hello', got '%s'", msg)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("Timed out waiting for message on ch1")
+	}
+
+	select {
+	case msg := <-ch2:
+		if msg != "hello" {
+			t.Fatalf("Expected ch2 to receive 'hello', got '%s'", msg)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("Timed out waiting for message on ch2")
+	}
+
+	// Wait for the callback
+	wg.Wait()
+
+	if received != "hello" {
+		t.Fatalf("Expected callback to receive 'hello', got '%s'", received)
+	}
+}

dataext/stack.go

@@ -2,7 +2,7 @@ package dataext
 
 import (
 	"errors"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"sync"
 )
 

dataext/structHash.go

@@ -6,7 +6,7 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"hash"
 	"io"
 	"reflect"

dataext/structHash_test.go

@@ -1,8 +1,8 @@
 package dataext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 )
 

dataext/syncMap.go

@@ -2,6 +2,8 @@ package dataext
 
 import "sync"
 
+// SyncMap is a thread-safe map implementation for generic key-value pairs.
+// All functions aresafe to be called in parallel.
 type SyncMap[TKey comparable, TData any] struct {
 	data map[TKey]TData
 	lock sync.Mutex
@@ -11,6 +13,7 @@ func NewSyncMap[TKey comparable, TData any]() *SyncMap[TKey, TData] {
 	return &SyncMap[TKey, TData]{data: make(map[TKey]TData), lock: sync.Mutex{}}
 }
 
+// Set sets the value for the provided key
 func (s *SyncMap[TKey, TData]) Set(key TKey, data TData) {
 	s.lock.Lock()
 	defer s.lock.Unlock()
@@ -22,6 +25,7 @@ func (s *SyncMap[TKey, TData]) Set(key TKey, data TData) {
 	s.data[key] = data
 }
 
+// SetIfNotContains sets the value for the provided key if it does not already exist
 func (s *SyncMap[TKey, TData]) SetIfNotContains(key TKey, data TData) bool {
 	s.lock.Lock()
 	defer s.lock.Unlock()
@@ -39,6 +43,7 @@ func (s *SyncMap[TKey, TData]) SetIfNotContains(key TKey, data TData) bool {
 	return true
 }
 
+// SetIfNotContainsFunc sets the value for the provided key using the provided function
 func (s *SyncMap[TKey, TData]) SetIfNotContainsFunc(key TKey, data func() TData) bool {
 	s.lock.Lock()
 	defer s.lock.Unlock()
@@ -56,6 +61,7 @@ func (s *SyncMap[TKey, TData]) SetIfNotContainsFunc(key TKey, data func() TData)
 	return true
 }
 
+// Get retrieves the value for the provided key
 func (s *SyncMap[TKey, TData]) Get(key TKey) (TData, bool) {
 	s.lock.Lock()
 	defer s.lock.Unlock()
@@ -71,6 +77,8 @@ func (s *SyncMap[TKey, TData]) Get(key TKey) (TData, bool) {
 	}
 }
 
+// GetAndSetIfNotContains returns the existing value if the key exists.
+// Otherwise, it sets the provided value and returns it.
 func (s *SyncMap[TKey, TData]) GetAndSetIfNotContains(key TKey, data TData) TData {
 	s.lock.Lock()
 	defer s.lock.Unlock()
@@ -87,6 +95,8 @@ func (s *SyncMap[TKey, TData]) GetAndSetIfNotContains(key TKey, data TData) TDat
 	}
 }
 
+// GetAndSetIfNotContainsFunc returns the existing value if the key exists.
+// Otherwise, it calls the provided function to generate the value, sets it, and returns it.
 func (s *SyncMap[TKey, TData]) GetAndSetIfNotContainsFunc(key TKey, data func() TData) TData {
 	s.lock.Lock()
 	defer s.lock.Unlock()
@@ -104,6 +114,7 @@ func (s *SyncMap[TKey, TData]) GetAndSetIfNotContainsFunc(key TKey, data func()
 	}
 }
 
+// Delete removes the entry with the provided key and returns true if the key existed before.
 func (s *SyncMap[TKey, TData]) Delete(key TKey) bool {
 	s.lock.Lock()
 	defer s.lock.Unlock()
@@ -119,6 +130,70 @@ func (s *SyncMap[TKey, TData]) Delete(key TKey) bool {
 	return ok
 }
 
+// DeleteIf deletes all entries that match the provided function and returns the number of removed entries.
+func (s *SyncMap[TKey, TData]) DeleteIf(fn func(key TKey, data TData) bool) int {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TKey]TData)
+	}
+
+	rm := 0
+	for k, v := range s.data {
+		if fn(k, v) {
+			delete(s.data, k)
+			rm++
+		}
+	}
+
+	return rm
+}
+
+// UpdateIfExists updates the value if the key exists, otherwise it does nothing.
+func (s *SyncMap[TKey, TData]) UpdateIfExists(key TKey, fn func(data TData) TData) bool {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TKey]TData)
+	}
+
+	if v, ok := s.data[key]; ok {
+		s.data[key] = fn(v)
+		return true
+	} else {
+		return false
+	}
+}
+
+// UpdateOrInsert updates the value if the key exists, otherwise it inserts the provided `insertValue`.
+func (s *SyncMap[TKey, TData]) UpdateOrInsert(key TKey, fn func(data TData) TData, insertValue TData) bool {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TKey]TData)
+	}
+
+	if v, ok := s.data[key]; ok {
+		s.data[key] = fn(v)
+		return true
+	} else {
+		s.data[key] = insertValue
+		return false
+	}
+}
+
+// Clear removes all entries from the map.
+func (s *SyncMap[TKey, TData]) Clear() {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	s.data = make(map[TKey]TData)
+}
+
+// Contains checks if the map contains the provided key.
 func (s *SyncMap[TKey, TData]) Contains(key TKey) bool {
 	s.lock.Lock()
 	defer s.lock.Unlock()
@@ -132,6 +207,7 @@ func (s *SyncMap[TKey, TData]) Contains(key TKey) bool {
 	return ok
 }
 
+// GetAllKeys returns a copy (!) of all keys in the map.
 func (s *SyncMap[TKey, TData]) GetAllKeys() []TKey {
 	s.lock.Lock()
 	defer s.lock.Unlock()
@@ -149,6 +225,7 @@ func (s *SyncMap[TKey, TData]) GetAllKeys() []TKey {
 	return r
 }
 
+// GetAllValues returns a copy (!) of all values in the map.
 func (s *SyncMap[TKey, TData]) GetAllValues() []TData {
 	s.lock.Lock()
 	defer s.lock.Unlock()
@@ -165,3 +242,15 @@ func (s *SyncMap[TKey, TData]) GetAllValues() []TData {
 
 	return r
 }
+
+// Count returns the number of entries in the map.
+func (s *SyncMap[TKey, TData]) Count() int {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TKey]TData)
+	}
+
+	return len(s.data)
+}

enums/enum.go

@@ -1,5 +1,7 @@
 package enums
 
+import "encoding/json"
+
 type Enum interface {
 	Valid() bool
 	ValuesAny() []any
@@ -31,3 +33,25 @@ type EnumDescriptionMetaValue struct {
 	Value       Enum   `json:"value"`
 	Description string `json:"description"`
 }
+
+type EnumDataMetaValue struct {
+	VarName     string  `json:"varName"`
+	Value       Enum    `json:"value"`
+	Description *string `json:"description"`
+
+	Data map[string]any `json:"-"` //handled by MarshalJSON
+}
+
+func (v EnumDataMetaValue) MarshalJSON() ([]byte, error) {
+	m := make(map[string]any, 8)
+
+	for k, dv := range v.Data {
+		m[k] = dv
+	}
+
+	m["varName"] = v.VarName
+	m["value"] = v.Value
+	m["description"] = v.Description
+
+	return json.Marshal(m)
+}

exerr/builder.go

@@ -5,17 +5,18 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"github.com/gin-gonic/gin"
-	"github.com/rs/zerolog"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
-	"gogs.mikescher.com/BlackForestBytes/goext/enums"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"net/http"
 	"os"
 	"runtime/debug"
 	"strings"
 	"time"
+
+	"git.blackforestbytes.com/BlackForestBytes/goext/dataext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/enums"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"github.com/gin-gonic/gin"
+	"github.com/rs/zerolog"
+	"go.mongodb.org/mongo-driver/bson/primitive"
 )
 
 //
@@ -319,6 +320,7 @@ func (b *Builder) GinReq(ctx context.Context, g *gin.Context, req *http.Request)
 		}
 	}
 	b.Str("gin_method", req.Method)
+	b.Str("gin_host", req.Host)
 	b.Str("gin_path", g.FullPath())
 	b.Strs("gin_header", extractHeader(g.Request.Header))
 	if req.URL != nil {
@@ -429,12 +431,22 @@ func (b *Builder) BuildAsExerr(ctxs ...context.Context) *ExErr {
 		return FromError(b.wrappedErr)
 	}
 
-	if pkgconfig.ZeroLogErrTraces && !b.noLog && (b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal) {
+	if pkgconfig.ZeroLogErrTraces && !b.noLog {
-		b.errorData.ShortLog(pkgconfig.ZeroLogger.Error())
+		if b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal {
-	} else if pkgconfig.ZeroLogAllTraces && !b.noLog {
+			b.errorData.ShortLog(pkgconfig.ZeroLogger.Error())
-		b.errorData.ShortLog(pkgconfig.ZeroLogger.Error())
+		} else if b.errorData.Severity == SevWarn {
-	}
+			b.errorData.ShortLog(pkgconfig.ZeroLogger.Warn())
+		} else if b.errorData.Severity == SevInfo {
+			b.errorData.ShortLog(pkgconfig.ZeroLogger.Info())
+		} else if b.errorData.Severity == SevDebug {
+			b.errorData.ShortLog(pkgconfig.ZeroLogger.Debug())
+		} else if b.errorData.Severity == SevTrace {
+			b.errorData.ShortLog(pkgconfig.ZeroLogger.Trace())
+		} else {
+			b.errorData.ShortLog(pkgconfig.ZeroLogger.Error()) // ?!? unknown severity
+		}
 
+	}
 	b.errorData.CallListener(MethodBuild, ListenerOpt{NoLog: b.noLog})
 
 	return b.errorData
@@ -444,6 +456,8 @@ func (b *Builder) BuildAsExerr(ctxs ...context.Context) *ExErr {
 // The error also gets printed to stdout/stderr
 // If the error is SevErr|SevFatal we also send it to the error-service
 func (b *Builder) Output(ctx context.Context, g *gin.Context) {
+	warnOnPkgConfigNotInitialized()
+
 	if !b.containsGinData && g.Request != nil {
 		// Auto-Add gin metadata if the caller hasn't already done it
 		b.GinReq(ctx, g, g.Request)
@@ -451,6 +465,21 @@ func (b *Builder) Output(ctx context.Context, g *gin.Context) {
 
 	b.CtxData(MethodOutput, ctx)
 
+	// this is only here to add one level to the trace
+	// so that .Build() and .Output() and .Print() have the same depth and our stack-skip logger can have the same skip-count
+	b.doGinOutput(ctx, g)
+}
+
+// OutputRaw works teh same as Output() - but does not depend on gin and works with a raw http.ResponseWriter
+func (b *Builder) OutputRaw(w http.ResponseWriter) {
+	warnOnPkgConfigNotInitialized()
+
+	// this is only here to add one level to the trace
+	// so that .Build() and .Output() and .Print() have the same depth and our stack-skip logger can have the same skip-count
+	b.doRawOutput(w)
+}
+
+func (b *Builder) doGinOutput(ctx context.Context, g *gin.Context) {
 	b.errorData.Output(g)
 
 	if (b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal) && (pkgconfig.ZeroLogErrGinOutput || pkgconfig.ZeroLogAllGinOutput) {
@@ -462,6 +491,18 @@ func (b *Builder) Output(ctx context.Context, g *gin.Context) {
 	b.errorData.CallListener(MethodOutput, ListenerOpt{NoLog: b.noLog})
 }
 
+func (b *Builder) doRawOutput(w http.ResponseWriter) {
+	b.errorData.OutputRaw(w)
+
+	if (b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal) && (pkgconfig.ZeroLogErrGinOutput || pkgconfig.ZeroLogAllGinOutput) {
+		b.errorData.Log(pkgconfig.ZeroLogger.Error())
+	} else if (b.errorData.Severity == SevWarn) && (pkgconfig.ZeroLogAllGinOutput) {
+		b.errorData.Log(pkgconfig.ZeroLogger.Warn())
+	}
+
+	b.errorData.CallListener(MethodOutput, ListenerOpt{NoLog: b.noLog})
+}
+
 // Print prints the error
 // If the error is SevErr we also send it to the error-service
 func (b *Builder) Print(ctxs ...context.Context) Proxy {
@@ -471,14 +512,24 @@ func (b *Builder) Print(ctxs ...context.Context) Proxy {
 		b.CtxData(MethodPrint, dctx)
 	}
 
+	// this is only here to add one level to the trace
+	// so that .Build() and .Output() and .Print() have the same depth and our stack-skip logger can have the same skip-count
+	return b.doPrint()
+}
+
+func (b *Builder) doPrint() Proxy {
 	if b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal {
 		b.errorData.Log(pkgconfig.ZeroLogger.Error())
 	} else if b.errorData.Severity == SevWarn {
 		b.errorData.ShortLog(pkgconfig.ZeroLogger.Warn())
 	} else if b.errorData.Severity == SevInfo {
 		b.errorData.ShortLog(pkgconfig.ZeroLogger.Info())
-	} else {
+	} else if b.errorData.Severity == SevDebug {
 		b.errorData.ShortLog(pkgconfig.ZeroLogger.Debug())
+	} else if b.errorData.Severity == SevTrace {
+		b.errorData.ShortLog(pkgconfig.ZeroLogger.Trace())
+	} else {
+		b.errorData.Log(pkgconfig.ZeroLogger.Error()) // ?!? unknown severity
 	}
 
 	b.errorData.CallListener(MethodPrint, ListenerOpt{NoLog: b.noLog})
@@ -500,13 +551,19 @@ func (b *Builder) Fatal(ctxs ...context.Context) {
 		b.CtxData(MethodFatal, dctx)
 	}
 
-	b.errorData.Log(pkgconfig.ZeroLogger.WithLevel(zerolog.FatalLevel))
+	// this is only here to add one level to the trace
+	// so that .Build() and .Output() and .Print() have the same depth and our stack-skip logger can have the same skip-count
+	b.doLogFatal()
 
 	b.errorData.CallListener(MethodFatal, ListenerOpt{NoLog: b.noLog})
 
 	os.Exit(1)
 }
 
+func (b *Builder) doLogFatal() {
+	b.errorData.Log(pkgconfig.ZeroLogger.WithLevel(zerolog.FatalLevel))
+}
+
 // ----------------------------------------------------------------------------
 
 func (b *Builder) addMeta(key string, mdtype metaDataType, val interface{}) *Builder {

exerr/constructor.go

@@ -4,7 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"go.mongodb.org/mongo-driver/bson/primitive"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"reflect"
 	"time"
 )

exerr/dataType.go

@@ -8,8 +8,8 @@ import (
 	"go.mongodb.org/mongo-driver/bson/bsoncodec"
 	"go.mongodb.org/mongo-driver/bson/bsonrw"
 	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/dataext"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"reflect"
 )
 

exerr/data_test.go

@@ -6,7 +6,7 @@ import (
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 	"time"
 )

exerr/errinit.go

@@ -3,9 +3,9 @@ package exerr
 import (
 	"context"
 	"fmt"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"github.com/gin-gonic/gin"
 	"github.com/rs/zerolog"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"net/http"
 	"os"
 )
@@ -119,7 +119,7 @@ func newDefaultLogger() zerolog.Logger {
 
 	multi := zerolog.MultiLevelWriter(cw)
 
-	return zerolog.New(multi).With().Timestamp().CallerWithSkipFrameCount(4).Logger()
+	return zerolog.New(multi).With().Timestamp().CallerWithSkipFrameCount(5).Logger()
 }
 
 func Initialized() bool {

exerr/exerr.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"github.com/rs/xid"
 	"github.com/rs/zerolog"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"reflect"
 	"strings"
 	"time"

exerr/exerr_test.go

@@ -2,8 +2,8 @@ package exerr
 
 import (
 	"errors"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"os"
 	"testing"
 )

exerr/gin.go

@@ -1,9 +1,9 @@
 package exerr
 
 import (
+	json "git.blackforestbytes.com/BlackForestBytes/goext/gojson"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"github.com/gin-gonic/gin"
-	json "gogs.mikescher.com/BlackForestBytes/goext/gojson"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"net/http"
 	"time"
 )
@@ -68,7 +68,6 @@ func (ee *ExErr) ToDefaultAPIJson() (string, error) {
 	gjr := json.GoJsonRender{Data: ee.ToAPIJson(true, pkgconfig.ExtendedGinOutput, pkgconfig.IncludeMetaInGinOutput), NilSafeSlices: true, NilSafeMaps: true}
 
 	r, err := gjr.RenderString()
-
 	if err != nil {
 		return "", err
 	}
@@ -143,3 +142,34 @@ func (ee *ExErr) Output(g *gin.Context) {
 
 	g.Render(statuscode, json.GoJsonRender{Data: ginOutput, NilSafeSlices: true, NilSafeMaps: true})
 }
+
+func (ee *ExErr) OutputRaw(w http.ResponseWriter) {
+
+	warnOnPkgConfigNotInitialized()
+
+	var statuscode = http.StatusInternalServerError
+
+	var baseCat = ee.RecursiveCategory()
+	var baseType = ee.RecursiveType()
+	var baseStatuscode = ee.RecursiveStatuscode()
+
+	if baseCat == CatUser {
+		statuscode = http.StatusBadRequest
+	} else if baseCat == CatSystem {
+		statuscode = http.StatusInternalServerError
+	}
+
+	if baseStatuscode != nil {
+		statuscode = *ee.StatusCode
+	} else if baseType.DefaultStatusCode != nil {
+		statuscode = *baseType.DefaultStatusCode
+	}
+
+	ginOutput, err := ee.ToDefaultAPIJson()
+	if err != nil {
+		panic(err) // cannot happen
+	}
+
+	w.WriteHeader(statuscode)
+	_, _ = w.Write([]byte(ginOutput))
+}

exerr/meta.go

@@ -5,10 +5,10 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"github.com/rs/zerolog"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"math"
 	"strconv"
 	"strings"
@@ -720,6 +720,9 @@ func (mm MetaMap) FormatMultiLine(indentFront string, indentKeys string, maxLenV
 		if key == "gin.body" {
 			continue
 		}
+		if key == "gin_body" {
+			continue
+		}
 
 		r += indentFront
 		r += indentKeys

exerr/typeWrapper.go

@@ -4,8 +4,8 @@ import (
 	"encoding/json"
 	"fmt"
 	"github.com/rs/zerolog/log"
-	"gogs.mikescher.com/BlackForestBytes/goext/enums"
+	"git.blackforestbytes.com/BlackForestBytes/goext/enums"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"strings"
 )
 

ginext/commonMiddlewares.go

@@ -2,7 +2,7 @@ package ginext
 
 import (
 	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/dataext"
 )
 
 func BodyBuffer(g *gin.Context) {

ginext/engine.go

@@ -4,9 +4,9 @@ import (
 	"fmt"
 	"github.com/gin-gonic/gin"
 	"github.com/rs/zerolog/log"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/mathext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/mathext"
-	"gogs.mikescher.com/BlackForestBytes/goext/rext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/rext"
 	"net"
 	"net/http"
 	"net/http/httptest"

ginext/funcWrapper.go

@@ -2,8 +2,9 @@ package ginext
 
 import (
 	"fmt"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"net/http"
 )
 
 type WHandlerFunc func(PreContext) HTTPResponse
@@ -58,3 +59,31 @@ func Wrap(w *GinWrapper, fn WHandlerFunc) gin.HandlerFunc {
 		}
 	}
 }
+
+func WrapHTTPHandler(w *GinWrapper, fn http.Handler) gin.HandlerFunc {
+	return func(g *gin.Context) {
+		for _, lstr := range w.listenerBeforeRequest {
+			lstr(g)
+		}
+
+		fn.ServeHTTP(g.Writer, g.Request)
+
+		for _, lstr := range w.listenerAfterRequest {
+			lstr(g, nil)
+		}
+	}
+}
+
+func WrapHTTPHandlerFunc(w *GinWrapper, fn http.HandlerFunc) gin.HandlerFunc {
+	return func(g *gin.Context) {
+		for _, lstr := range w.listenerBeforeRequest {
+			lstr(g)
+		}
+
+		fn(g.Writer, g.Request)
+
+		for _, lstr := range w.listenerAfterRequest {
+			lstr(g, nil)
+		}
+	}
+}

ginext/preContext.go

@@ -6,9 +6,9 @@ import (
 	"fmt"
 	"github.com/gin-gonic/gin"
 	"github.com/gin-gonic/gin/binding"
-	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/dataext"
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"io"
 	"runtime/debug"
 	"time"

ginext/response.go

@@ -2,7 +2,7 @@ package ginext
 
 import (
 	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 )
 
 type cookieval struct {

ginext/responseData.go

@@ -2,7 +2,7 @@ package ginext
 
 import (
 	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 )
 
 type dataHTTPResponse struct {

ginext/responseDownload.go

@@ -3,7 +3,7 @@ package ginext
 import (
 	"fmt"
 	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 )
 
 type downloadDataHTTPResponse struct {

ginext/responseEmpty.go

@@ -2,7 +2,7 @@ package ginext
 
 import (
 	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 )
 
 type emptyHTTPResponse struct {

ginext/responseFile.go

@@ -3,7 +3,7 @@ package ginext
 import (
 	"fmt"
 	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"os"
 )
 

ginext/responseJson.go

@@ -2,8 +2,8 @@ package ginext
 
 import (
 	"github.com/gin-gonic/gin"
-	json "gogs.mikescher.com/BlackForestBytes/goext/gojson"
+	json "git.blackforestbytes.com/BlackForestBytes/goext/gojson"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 )
 
 type jsonHTTPResponse struct {

ginext/responseJsonAPI.go

@@ -3,8 +3,8 @@ package ginext
 import (
 	"context"
 	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 )
 
 type jsonAPIErrResponse struct {

ginext/responseRedirect.go

@@ -2,7 +2,7 @@ package ginext
 
 import (
 	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 )
 
 type redirectHTTPResponse struct {

ginext/responseSeekable.go

@@ -2,8 +2,8 @@ package ginext
 
 import (
 	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"io"
 	"net/http"
 	"time"

ginext/responseText.go

@@ -2,7 +2,7 @@ package ginext
 
 import (
 	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 )
 
 type textHTTPResponse struct {

ginext/routes.go

@@ -1,8 +1,8 @@
 package ginext
 
 import (
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"net/http"
 	"path"
 	"reflect"
@@ -148,6 +148,68 @@ func (w *GinRouteBuilder) Handle(handler WHandlerFunc) {
 	})
 }
 
+func (w *GinRouteBuilder) HandleRawHTTPHandler(f http.Handler) {
+	if w.routes.wrapper.bufferBody {
+		arr := make([]gin.HandlerFunc, 0, len(w.handlers)+1)
+		arr = append(arr, BodyBuffer)
+		arr = append(arr, w.handlers...)
+		w.handlers = arr
+	}
+
+	middlewareNames := langext.ArrMap(w.handlers, func(v gin.HandlerFunc) string { return nameOfFunction(v) })
+
+	w.handlers = append(w.handlers, WrapHTTPHandler(w.routes.wrapper, f))
+
+	methodName := w.method
+
+	if w.method == "*" {
+		methodName = "ANY"
+		for _, method := range anyMethods {
+			w.routes.routes.Handle(method, w.relPath, w.handlers...)
+		}
+	} else {
+		w.routes.routes.Handle(w.method, w.relPath, w.handlers...)
+	}
+
+	w.routes.wrapper.routeSpecs = append(w.routes.wrapper.routeSpecs, ginRouteSpec{
+		Method:      methodName,
+		URL:         w.absPath,
+		Middlewares: middlewareNames,
+		Handler:     "[HTTPHandler]",
+	})
+}
+
+func (w *GinRouteBuilder) HandleRawHTTPHandlerFunc(f http.HandlerFunc) {
+	if w.routes.wrapper.bufferBody {
+		arr := make([]gin.HandlerFunc, 0, len(w.handlers)+1)
+		arr = append(arr, BodyBuffer)
+		arr = append(arr, w.handlers...)
+		w.handlers = arr
+	}
+
+	middlewareNames := langext.ArrMap(w.handlers, func(v gin.HandlerFunc) string { return nameOfFunction(v) })
+
+	w.handlers = append(w.handlers, WrapHTTPHandlerFunc(w.routes.wrapper, f))
+
+	methodName := w.method
+
+	if w.method == "*" {
+		methodName = "ANY"
+		for _, method := range anyMethods {
+			w.routes.routes.Handle(method, w.relPath, w.handlers...)
+		}
+	} else {
+		w.routes.routes.Handle(w.method, w.relPath, w.handlers...)
+	}
+
+	w.routes.wrapper.routeSpecs = append(w.routes.wrapper.routeSpecs, ginRouteSpec{
+		Method:      methodName,
+		URL:         w.absPath,
+		Middlewares: middlewareNames,
+		Handler:     "[HTTPHandlerFunc]",
+	})
+}
+
 func (w *GinWrapper) NoRoute(handler WHandlerFunc) {
 
 	handlers := make([]gin.HandlerFunc, 0)

go.mod

@@ -1,63 +1,68 @@
-module gogs.mikescher.com/BlackForestBytes/goext
+module git.blackforestbytes.com/BlackForestBytes/goext
 
-go 1.23.0
+go 1.24.0
-
-toolchain go1.24.0
 
 require (
-	github.com/gin-gonic/gin v1.10.0
+	github.com/gin-gonic/gin v1.11.0
 	github.com/glebarez/go-sqlite v1.22.0 // only needed for tests -.-
 	github.com/jmoiron/sqlx v1.4.0
 	github.com/rs/xid v1.6.0
 	github.com/rs/zerolog v1.34.0
-	go.mongodb.org/mongo-driver v1.17.3
+	go.mongodb.org/mongo-driver v1.17.4
-	golang.org/x/crypto v0.37.0
+	golang.org/x/crypto v0.42.0
-	golang.org/x/sys v0.32.0
+	golang.org/x/sys v0.36.0
-	golang.org/x/term v0.31.0
+	golang.org/x/term v0.35.0
 )
 
 require (
 	github.com/disintegration/imaging v1.6.2
 	github.com/jung-kurt/gofpdf v1.16.2
-	golang.org/x/sync v0.13.0
+	golang.org/x/net v0.44.0
+	golang.org/x/sync v0.17.0
 )
 
 require (
-	github.com/bytedance/sonic v1.13.2 // indirect
+	github.com/bytedance/gopkg v0.1.3 // indirect
-	github.com/bytedance/sonic/loader v0.2.4 // indirect
+	github.com/bytedance/sonic v1.14.1 // indirect
-	github.com/cloudwego/base64x v0.1.5 // indirect
+	github.com/bytedance/sonic/loader v0.3.0 // indirect
+	github.com/cloudwego/base64x v0.1.6 // indirect
 	github.com/cloudwego/iasm v0.2.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.8 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.10 // indirect
-	github.com/gin-contrib/sse v1.0.0 // indirect
+	github.com/gin-contrib/sse v1.1.0 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.26.0 // indirect
+	github.com/go-playground/validator/v10 v10.27.0 // indirect
 	github.com/goccy/go-json v0.10.5 // indirect
+	github.com/goccy/go-yaml v1.18.0 // indirect
 	github.com/golang/snappy v1.0.0 // indirect
 	github.com/google/uuid v1.5.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/compress v1.18.0 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
+	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/montanaflynn/stats v0.7.1 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.3 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
+	github.com/quic-go/qpack v0.5.1 // indirect
+	github.com/quic-go/quic-go v0.55.0 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
-	github.com/ugorji/go/codec v1.2.12 // indirect
+	github.com/ugorji/go/codec v1.3.0 // indirect
 	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
 	github.com/xdg-go/scram v1.1.2 // indirect
 	github.com/xdg-go/stringprep v1.0.4 // indirect
 	github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
-	golang.org/x/arch v0.16.0 // indirect
+	go.uber.org/mock v0.6.0 // indirect
-	golang.org/x/image v0.26.0 // indirect
+	golang.org/x/arch v0.21.0 // indirect
-	golang.org/x/net v0.38.0 // indirect
+	golang.org/x/image v0.31.0 // indirect
-	golang.org/x/text v0.24.0 // indirect
+	golang.org/x/mod v0.28.0 // indirect
-	google.golang.org/protobuf v1.36.6 // indirect
+	golang.org/x/text v0.29.0 // indirect
+	golang.org/x/tools v0.37.0 // indirect
+	google.golang.org/protobuf v1.36.10 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	modernc.org/libc v1.37.6 // indirect
 	modernc.org/mathutil v1.6.0 // indirect

go.sum

@@ -1,6 +1,8 @@
 filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
 filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
 github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
+github.com/bytedance/gopkg v0.1.3 h1:TPBSwH8RsouGCBcMBktLt1AymVo2TVsBVCY4b6TnZ/M=
+github.com/bytedance/gopkg v0.1.3/go.mod h1:576VvJ+eJgyCzdjS+c4+77QF3p7ubbtiKARP3TxducM=
 github.com/bytedance/sonic v1.12.3 h1:W2MGa7RCU1QTeYRTPE3+88mVC0yXmsRQRChiyVocVjU=
 github.com/bytedance/sonic v1.12.3/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk=
 github.com/bytedance/sonic v1.12.4 h1:9Csb3c9ZJhfUWeMtpCDCq6BUoH5ogfDFLUgQ/jG+R0k=
@@ -21,6 +23,12 @@ github.com/bytedance/sonic v1.13.1 h1:Jyd5CIvdFnkOWuKXr+wm4Nyk2h0yAFsr8ucJgEasO3
 github.com/bytedance/sonic v1.13.1/go.mod h1:o68xyaF9u2gvVBuGHPlUVCy+ZfmNNO5ETf1+KgkJhz4=
 github.com/bytedance/sonic v1.13.2 h1:8/H1FempDZqC4VqjptGo14QQlJx8VdZJegxs6wwfqpQ=
 github.com/bytedance/sonic v1.13.2/go.mod h1:o68xyaF9u2gvVBuGHPlUVCy+ZfmNNO5ETf1+KgkJhz4=
+github.com/bytedance/sonic v1.13.3 h1:MS8gmaH16Gtirygw7jV91pDCN33NyMrPbN7qiYhEsF0=
+github.com/bytedance/sonic v1.13.3/go.mod h1:o68xyaF9u2gvVBuGHPlUVCy+ZfmNNO5ETf1+KgkJhz4=
+github.com/bytedance/sonic v1.14.0 h1:/OfKt8HFw0kh2rj8N0F6C/qPGRESq0BbaNZgcNXXzQQ=
+github.com/bytedance/sonic v1.14.0/go.mod h1:WoEbx8WTcFJfzCe0hbmyTGrfjt8PzNEBdxlNUO24NhA=
+github.com/bytedance/sonic v1.14.1 h1:FBMC0zVz5XUmE4z9wF4Jey0An5FueFvOsTKKKtwIl7w=
+github.com/bytedance/sonic v1.14.1/go.mod h1:gi6uhQLMbTdeP0muCnrjHLeCUPyb70ujhnNlhOylAFc=
 github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
 github.com/bytedance/sonic/loader v0.2.0 h1:zNprn+lsIP06C/IqCHs3gPQIvnvpKbbxyXQP1iU4kWM=
 github.com/bytedance/sonic/loader v0.2.0/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
@@ -32,10 +40,14 @@ github.com/bytedance/sonic/loader v0.2.3 h1:yctD0Q3v2NOGfSWPLPvG2ggA2kV6TS6s4wio
 github.com/bytedance/sonic/loader v0.2.3/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
 github.com/bytedance/sonic/loader v0.2.4 h1:ZWCw4stuXUsn1/+zQDqeE7JKP+QO47tz7QCNan80NzY=
 github.com/bytedance/sonic/loader v0.2.4/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
+github.com/bytedance/sonic/loader v0.3.0 h1:dskwH8edlzNMctoruo8FPTJDF3vLtDT0sXZwvZJyqeA=
+github.com/bytedance/sonic/loader v0.3.0/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
 github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
 github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
 github.com/cloudwego/base64x v0.1.5 h1:XPciSp1xaq2VCSt6lF0phncD4koWyULpl5bUxbfCyP4=
 github.com/cloudwego/base64x v0.1.5/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
+github.com/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M=
+github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU=
 github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
 github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
@@ -54,12 +66,22 @@ github.com/gabriel-vasile/mimetype v1.4.7 h1:SKFKl7kD0RiPdbht0s7hFtjl489WcQ1VyPW
 github.com/gabriel-vasile/mimetype v1.4.7/go.mod h1:GDlAgAyIRT27BhFl53XNAFtfjzOkLaF35JdEG0P7LtU=
 github.com/gabriel-vasile/mimetype v1.4.8 h1:FfZ3gj38NjllZIeJAmMhr+qKL8Wu+nOoI3GqacKw1NM=
 github.com/gabriel-vasile/mimetype v1.4.8/go.mod h1:ByKUIKGjh1ODkGM1asKUbQZOLGrPjydw3hYPU2YU9t8=
+github.com/gabriel-vasile/mimetype v1.4.9 h1:5k+WDwEsD9eTLL8Tz3L0VnmVh9QxGjRmjBvAG7U/oYY=
+github.com/gabriel-vasile/mimetype v1.4.9/go.mod h1:WnSQhFKJuBlRyLiKohA/2DtIlPFAbguNaG7QCHcyGok=
+github.com/gabriel-vasile/mimetype v1.4.10 h1:zyueNbySn/z8mJZHLt6IPw0KoZsiQNszIpU+bX4+ZK0=
+github.com/gabriel-vasile/mimetype v1.4.10/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
 github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
 github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
 github.com/gin-contrib/sse v1.0.0 h1:y3bT1mUWUxDpW4JLQg/HnTqV4rozuW4tC9eFKTxYI9E=
 github.com/gin-contrib/sse v1.0.0/go.mod h1:zNuFdwarAygJBht0NTKiSi3jRf6RbqeILZ9Sp6Slhe0=
+github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
+github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
 github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
 github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
+github.com/gin-gonic/gin v1.10.1 h1:T0ujvqyCSqRopADpgPgiTT63DUQVSfojyME59Ei63pQ=
+github.com/gin-gonic/gin v1.10.1/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
+github.com/gin-gonic/gin v1.11.0 h1:OW/6PLjyusp2PPXtyxKHU0RbX6I/l28FTdDlae5ueWk=
+github.com/gin-gonic/gin v1.11.0/go.mod h1:+iq/FyxlGzII0KHiBGjuNn4UNENUlKbGlNmc+W50Dls=
 github.com/glebarez/go-sqlite v1.22.0 h1:uAcMJhaA6r3LHMTFgP0SifzgXg46yJkgxqyuyec+ruQ=
 github.com/glebarez/go-sqlite v1.22.0/go.mod h1:PlBIdHe0+aUEFn+r2/uthrWq4FxbzugL0L8Li6yQJbc=
 github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
@@ -78,6 +100,8 @@ github.com/go-playground/validator/v10 v10.25.0 h1:5Dh7cjvzR7BRZadnsVOzPhWsrwUr0
 github.com/go-playground/validator/v10 v10.25.0/go.mod h1:GGzBIJMuE98Ic/kJsBXbz1x/7cByt++cQ+YOuDM5wus=
 github.com/go-playground/validator/v10 v10.26.0 h1:SP05Nqhjcvz81uJaRfEV0YBSSSGMc/iMaVtFbr3Sw2k=
 github.com/go-playground/validator/v10 v10.26.0/go.mod h1:I5QpIEbmr8On7W0TktmJAumgzX4CA1XNl4ZmDuVHKKo=
+github.com/go-playground/validator/v10 v10.27.0 h1:w8+XrWVMhGkxOaaowyKH35gFydVHOvC0/uWoy2Fzwn4=
+github.com/go-playground/validator/v10 v10.27.0/go.mod h1:I5QpIEbmr8On7W0TktmJAumgzX4CA1XNl4ZmDuVHKKo=
 github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
 github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
 github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA=
@@ -86,6 +110,8 @@ github.com/goccy/go-json v0.10.4 h1:JSwxQzIqKfmFX1swYPpUThQZp/Ka4wzJdK0LWVytLPM=
 github.com/goccy/go-json v0.10.4/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
 github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
 github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
+github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
+github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
@@ -118,6 +144,10 @@ github.com/klauspost/cpuid/v2 v2.2.9 h1:66ze0taIn2H33fBvCkXuv9BmCwDfafmiIVpKV9kK
 github.com/klauspost/cpuid/v2 v2.2.9/go.mod h1:rqkxqrZ1EhYM9G+hXH7YdowN5R5RGN6NK4QwQ3WMXF8=
 github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
 github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/klauspost/cpuid/v2 v2.2.11 h1:0OwqZRYI2rFrjS4kvkDnqJkKHdHaRnCm68/DY4OxRzU=
+github.com/klauspost/cpuid/v2 v2.2.11/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
+github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
 github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
 github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
 github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
@@ -142,11 +172,21 @@ github.com/montanaflynn/stats v0.7.1 h1:etflOAAHORrCC44V+aR6Ftzort912ZU+YLiSTuV8
 github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow=
 github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M=
 github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc=
+github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
+github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
 github.com/phpdave11/gofpdi v1.0.7/go.mod h1:vBmVV0Do6hSBHC8uKUQ71JGW+ZGQq74llk/7bXwjDoI=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/quic-go/qpack v0.5.1 h1:giqksBPnT/HDtZ6VhtFKgoLOWmlyo9Ei6u9PqzIMbhI=
+github.com/quic-go/qpack v0.5.1/go.mod h1:+PC4XFrEskIVkcLzpEkbLqq1uCoxPhQuvK5rH1ZgaEg=
+github.com/quic-go/quic-go v0.54.0 h1:6s1YB9QotYI6Ospeiguknbp2Znb/jZYjZLRXn9kMQBg=
+github.com/quic-go/quic-go v0.54.0/go.mod h1:e68ZEaCdyviluZmy44P6Iey98v/Wfz6HCjQEm+l8zTY=
+github.com/quic-go/quic-go v0.54.1 h1:4ZAWm0AhCb6+hE+l5Q1NAL0iRn/ZrMwqHRGQiFwj2eg=
+github.com/quic-go/quic-go v0.54.1/go.mod h1:e68ZEaCdyviluZmy44P6Iey98v/Wfz6HCjQEm+l8zTY=
+github.com/quic-go/quic-go v0.55.0 h1:zccPQIqYCXDt5NmcEabyYvOnomjs8Tlwl7tISjJh9Mk=
+github.com/quic-go/quic-go v0.55.0/go.mod h1:DR51ilwU1uE164KuWXhinFcKWGlEjzys2l8zUl5Ss1U=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
@@ -175,6 +215,10 @@ github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
 github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+github.com/ugorji/go/codec v1.2.14 h1:yOQvXCBc3Ij46LRkRoh4Yd5qK6LVOgi0bYOXfb7ifjw=
+github.com/ugorji/go/codec v1.2.14/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+github.com/ugorji/go/codec v1.3.0 h1:Qd2W2sQawAfG8XSvzwhBeoGq71zXOC/Q1E9y/wUcsUA=
+github.com/ugorji/go/codec v1.3.0/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4=
 github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c=
 github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
 github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY=
@@ -190,6 +234,10 @@ go.mongodb.org/mongo-driver v1.17.2 h1:gvZyk8352qSfzyZ2UMWcpDpMSGEr1eqE4T793Sqyh
 go.mongodb.org/mongo-driver v1.17.2/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ=
 go.mongodb.org/mongo-driver v1.17.3 h1:TQyXhnsWfWtgAhMtOgtYHMTkZIfBTpMTsMnd9ZBeHxQ=
 go.mongodb.org/mongo-driver v1.17.3/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ=
+go.mongodb.org/mongo-driver v1.17.4 h1:jUorfmVzljjr0FLzYQsGP8cgN/qzzxlY9Vh0C9KFXVw=
+go.mongodb.org/mongo-driver v1.17.4/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ=
+go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y=
+go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU=
 golang.org/x/arch v0.11.0 h1:KXV8WWKCXm6tRpLirl2szsO5j/oOODwZf4hATmGVNs4=
 golang.org/x/arch v0.11.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
 golang.org/x/arch v0.12.0 h1:UsYJhbzPYGsT0HbEdmYcqtCv8UNGvnaL561NnIUvaKg=
@@ -202,6 +250,16 @@ golang.org/x/arch v0.15.0 h1:QtOrQd0bTUnhNVNndMpLHNWrDmYzZ2KDqSrEymqInZw=
 golang.org/x/arch v0.15.0/go.mod h1:JmwW7aLIoRUKgaTzhkiEFxvcEiQGyOg9BMonBJUS7EE=
 golang.org/x/arch v0.16.0 h1:foMtLTdyOmIniqWCHjY6+JxuC54XP1fDwx4N0ASyW+U=
 golang.org/x/arch v0.16.0/go.mod h1:JmwW7aLIoRUKgaTzhkiEFxvcEiQGyOg9BMonBJUS7EE=
+golang.org/x/arch v0.17.0 h1:4O3dfLzd+lQewptAHqjewQZQDyEdejz3VwgeYwkZneU=
+golang.org/x/arch v0.17.0/go.mod h1:bdwinDaKcfZUGpH09BB7ZmOfhalA8lQdzl62l8gGWsk=
+golang.org/x/arch v0.18.0 h1:WN9poc33zL4AzGxqf8VtpKUnGvMi8O9lhNyBMF/85qc=
+golang.org/x/arch v0.18.0/go.mod h1:bdwinDaKcfZUGpH09BB7ZmOfhalA8lQdzl62l8gGWsk=
+golang.org/x/arch v0.19.0 h1:LmbDQUodHThXE+htjrnmVD73M//D9GTH6wFZjyDkjyU=
+golang.org/x/arch v0.19.0/go.mod h1:bdwinDaKcfZUGpH09BB7ZmOfhalA8lQdzl62l8gGWsk=
+golang.org/x/arch v0.20.0 h1:dx1zTU0MAE98U+TQ8BLl7XsJbgze2WnNKF/8tGp/Q6c=
+golang.org/x/arch v0.20.0/go.mod h1:bdwinDaKcfZUGpH09BB7ZmOfhalA8lQdzl62l8gGWsk=
+golang.org/x/arch v0.21.0 h1:iTC9o7+wP6cPWpDWkivCvQFGAHDQ59SrSxsLPcnkArw=
+golang.org/x/arch v0.21.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.28.0 h1:GBDwsMXVQi34v5CCYUm2jkJvu4cbtru2U4TN2PSyQnw=
@@ -222,6 +280,16 @@ golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
 golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
 golang.org/x/crypto v0.37.0 h1:kJNSjF/Xp7kU0iB2Z+9viTPMW4EqqsrywMXLJOOsXSE=
 golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc=
+golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
+golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
+golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=
+golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=
+golang.org/x/crypto v0.40.0 h1:r4x+VvoG5Fm+eJcxMaY8CQM7Lb0l1lsmjGBQ6s8BfKM=
+golang.org/x/crypto v0.40.0/go.mod h1:Qr1vMER5WyS2dfPHAlsOj01wgLbsyWtFn/aY+5+ZdxY=
+golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4=
+golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=
+golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
+golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
 golang.org/x/image v0.0.0-20190910094157-69e4b8554b2a/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/image v0.21.0 h1:c5qV36ajHpdj4Qi0GnE0jUc/yuo33OLFaa0d+crTD5s=
@@ -236,7 +304,19 @@ golang.org/x/image v0.25.0 h1:Y6uW6rH1y5y/LK1J8BPWZtr6yZ7hrsy6hFrXjgsc2fQ=
 golang.org/x/image v0.25.0/go.mod h1:tCAmOEGthTtkalusGp1g3xa2gke8J6c2N565dTyl9Rs=
 golang.org/x/image v0.26.0 h1:4XjIFEZWQmCZi6Wv8BoxsDhRU3RVnLX04dToTDAEPlY=
 golang.org/x/image v0.26.0/go.mod h1:lcxbMFAovzpnJxzXS3nyL83K27tmqtKzIJpctK8YO5c=
+golang.org/x/image v0.27.0 h1:C8gA4oWU/tKkdCfYT6T2u4faJu3MeNS5O8UPWlPF61w=
+golang.org/x/image v0.27.0/go.mod h1:xbdrClrAUway1MUTEZDq9mz/UpRwYAkFFNUslZtcB+g=
+golang.org/x/image v0.28.0 h1:gdem5JW1OLS4FbkWgLO+7ZeFzYtL3xClb97GaUzYMFE=
+golang.org/x/image v0.28.0/go.mod h1:GUJYXtnGKEUgggyzh+Vxt+AviiCcyiwpsl8iQ8MvwGY=
+golang.org/x/image v0.29.0 h1:HcdsyR4Gsuys/Axh0rDEmlBmB68rW1U9BUdB3UVHsas=
+golang.org/x/image v0.29.0/go.mod h1:RVJROnf3SLK8d26OW91j4FrIHGbsJ8QnbEocVTOWQDA=
+golang.org/x/image v0.30.0 h1:jD5RhkmVAnjqaCUXfbGBrn3lpxbknfN9w2UhHHU+5B4=
+golang.org/x/image v0.30.0/go.mod h1:SAEUTxCCMWSrJcCy/4HwavEsfZZJlYxeHLc6tTiAe/c=
+golang.org/x/image v0.31.0 h1:mLChjE2MV6g1S7oqbXC0/UcKijjm5fnJLUYKIYrLESA=
+golang.org/x/image v0.31.0/go.mod h1:R9ec5Lcp96v9FTF+ajwaH3uGxPH4fKfHHAVbUILxghA=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.28.0 h1:gQBtGhjxykdjY9YhZpSlZIsbnaE2+PgjfLWUQTnoZ1U=
+golang.org/x/mod v0.28.0/go.mod h1:yfB/L0NOf/kmEbXjzCPOx1iK1fRutOydrCMsqRhEBxI=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
@@ -256,6 +336,18 @@ golang.org/x/net v0.37.0 h1:1zLorHbz+LYj7MQlSf1+2tPIIgibq2eL5xkrGk6f+2c=
 golang.org/x/net v0.37.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
 golang.org/x/net v0.38.0 h1:vRMAPTMaeGqVhG5QyLJHqNDwecKTomGeqbnfZyKlBI8=
 golang.org/x/net v0.38.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
+golang.org/x/net v0.39.0 h1:ZCu7HMWDxpXpaiKdhzIfaltL9Lp31x/3fCP11bc6/fY=
+golang.org/x/net v0.39.0/go.mod h1:X7NRbYVEA+ewNkCNyJ513WmMdQ3BineSwVtN2zD/d+E=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
+golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
+golang.org/x/net v0.42.0 h1:jzkYrhi3YQWD6MLBJcsklgQsoAcw89EcZbJw8Z614hs=
+golang.org/x/net v0.42.0/go.mod h1:FF1RA5d3u7nAYA4z2TkclSCKh68eSXtiFwcWQpPXdt8=
+golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
+golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.44.0 h1:evd8IRDyfNBMBTTY5XRF1vaZlD+EmWx6x8PkhR04H/I=
+golang.org/x/net v0.44.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
@@ -270,6 +362,14 @@ golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=
 golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sync v0.13.0 h1:AauUjRAJ9OSnvULf/ARrrVywoJDy0YS2AwQ98I37610=
 golang.org/x/sync v0.13.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ=
+golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
+golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
+golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
+golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -293,6 +393,14 @@ golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
 golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
 golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.34.0 h1:H5Y5sJ2L2JRdyv7ROF1he/lPdvFsd0mJHFw2ThKHxLA=
+golang.org/x/sys v0.34.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
+golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.25.0 h1:WtHI/ltw4NvSUig5KARz9h521QvRC8RmF/cuYqifU24=
@@ -309,6 +417,14 @@ golang.org/x/term v0.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y=
 golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g=
 golang.org/x/term v0.31.0 h1:erwDkOK1Msy6offm1mOgvspSkslFnIGsFnxOKoufg3o=
 golang.org/x/term v0.31.0/go.mod h1:R4BeIy7D95HzImkxGkTW1UQTtP54tio2RyHz7PwK0aw=
+golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
+golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
+golang.org/x/term v0.33.0 h1:NuFncQrRcaRvVmgRkvM3j/F00gWIAlcmlB8ACEKmGIg=
+golang.org/x/term v0.33.0/go.mod h1:s18+ql9tYWp1IfpV9DmCtQDDSRBUjKaw9M1eAv5UeF0=
+golang.org/x/term v0.34.0 h1:O/2T7POpk0ZZ7MAzMeWFSg6S5IpWd/RXDlM9hgM3DR4=
+golang.org/x/term v0.34.0/go.mod h1:5jC53AEywhIVebHgPVeg0mj8OD3VO9OzclacVrqpaAw=
+golang.org/x/term v0.35.0 h1:bZBVKBudEyhRcajGcNc3jIfWPqV4y/Kt2XcoigOWtDQ=
+golang.org/x/term v0.35.0/go.mod h1:TPGtkTLesOwf2DE8CgVYiZinHAOuy5AYUYT1lENIZnA=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
@@ -325,9 +441,21 @@ golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
 golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
 golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
 golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
+golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
+golang.org/x/text v0.27.0 h1:4fGWRpyh641NLlecmyl4LOe6yDdfaYNrGb2zdfo4JV4=
+golang.org/x/text v0.27.0/go.mod h1:1D28KMCvyooCX9hBiosv5Tz/+YLxj0j7XhWjpSUF7CU=
+golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
+golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
+golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.37.0 h1:DVSRzp7FwePZW356yEAChSdNcQo6Nsp+fex1SUW09lE=
+golang.org/x/tools v0.37.0/go.mod h1:MBN5QPQtLMHVdvsbtarmTNukZDdgwdwlO5qGacAzF0w=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
 google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
@@ -345,6 +473,14 @@ google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwl
 google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
 google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
 google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
+google.golang.org/protobuf v1.36.7 h1:IgrO7UwFQGJdRNXH/sQux4R1Dj1WAKcLElzeeRaXV2A=
+google.golang.org/protobuf v1.36.7/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
+google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc=
+google.golang.org/protobuf v1.36.8/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
+google.golang.org/protobuf v1.36.9 h1:w2gp2mA27hUeUzj9Ex9FBjsBm40zfaDtEWow293U7Iw=
+google.golang.org/protobuf v1.36.9/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
+google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
+google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

goextVersion.go

@@ -1,5 +1,5 @@
 package goext
 
-const GoextVersion = "0.0.569"
+const GoextVersion = "0.0.608"
 
-const GoextVersionTimestamp = "2025-04-07T15:47:50+0200"
+const GoextVersionTimestamp = "2025-10-04T00:27:41+0200"

gojson/gionic.go

@@ -27,11 +27,11 @@ func (r GoJsonRender) Render(w http.ResponseWriter) error {
 	}
 	jsonBytes, err := MarshalSafeCollections(r.Data, r.NilSafeSlices, r.NilSafeMaps, r.Indent, r.Filter)
 	if err != nil {
-		panic(err)
+		return err
 	}
 	_, err = w.Write(jsonBytes)
 	if err != nil {
-		panic(err)
+		return err
 	}
 	return nil
 }
@@ -39,7 +39,7 @@ func (r GoJsonRender) Render(w http.ResponseWriter) error {
 func (r GoJsonRender) RenderString() (string, error) {
 	jsonBytes, err := MarshalSafeCollections(r.Data, r.NilSafeSlices, r.NilSafeMaps, r.Indent, r.Filter)
 	if err != nil {
-		panic(err)
+		return "", err
 	}
 	return string(jsonBytes), nil
 }

googleapi/mimeMessage.go

@@ -1,7 +1,7 @@
 package googleapi
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"mime"
 	"strings"
 	"time"

googleapi/mimeMessage_test.go

@@ -1,7 +1,7 @@
 package googleapi
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"os"
 	"testing"
 )

googleapi/oAuth.go

@@ -3,9 +3,9 @@ package googleapi
 import (
 	"encoding/json"
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/timeext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/timeext"
 	"io"
 	"net/http"
 	"sync"

googleapi/sendMail.go

@@ -6,9 +6,9 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext"
+	"git.blackforestbytes.com/BlackForestBytes/goext"
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"io"
 	"net/http"
 )

googleapi/sendMail_test.go

@@ -3,9 +3,9 @@ package googleapi
 import (
 	"context"
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"os"
 	"testing"
 )

imageext/enums_gen.go

@@ -2,8 +2,8 @@
 
 package imageext
 
-import "gogs.mikescher.com/BlackForestBytes/goext/langext"
+import "git.blackforestbytes.com/BlackForestBytes/goext/langext"
-import "gogs.mikescher.com/BlackForestBytes/goext/enums"
+import "git.blackforestbytes.com/BlackForestBytes/goext/enums"
 
 const ChecksumEnumGenerator = "1da5383c33ee442fd0b899369053f66bdc85bed2dbf906949d3edfeedfe13340" // GoExtVersion: 0.0.449
 

imageext/image.go

@@ -4,8 +4,8 @@ import (
 	"bytes"
 	"fmt"
 	"github.com/disintegration/imaging"
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
-	"gogs.mikescher.com/BlackForestBytes/goext/mathext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/mathext"
 	"image"
 	"image/color"
 	"image/draw"

langext/array_test.go

@@ -1,7 +1,7 @@
 package langext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"strings"
 	"testing"
 )

langext/base58_test.go

@@ -1,7 +1,7 @@
 package langext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 )
 

langext/base64.go

@@ -0,0 +1,23 @@
+package langext
+
+import (
+	"encoding/base64"
+	"strings"
+)
+
+// DecodeBase64Any decodes a base64 encoded string
+// Works with all variants (std, url, imap), padded and unpadded and even ignores linrebreaks and indents
+func DecodeBase64Any(data string) ([]byte, error) {
+	data = strings.ReplaceAll(data, "\n", "") // remove linebreaks and indents
+	data = strings.ReplaceAll(data, "\t", "") // remove linebreaks and indents
+	data = strings.ReplaceAll(data, " ", "")  // remove linebreaks and indents
+
+	data = strings.ReplaceAll(data, ",", "/") // base64_imap --> base64_std
+
+	data = strings.ReplaceAll(data, "_", "/") // base64_url --> base64_std
+	data = strings.ReplaceAll(data, "-", "+") // base64_url --> base64_std
+
+	data = strings.ReplaceAll(data, "=", "") // no padding
+
+	return base64.RawStdEncoding.DecodeString(data)
+}

langext/base64_test.go

@@ -0,0 +1,246 @@
+package langext
+
+import (
+	"testing"
+)
+
+func TestDecodeBase64Any_StandardPadded(t *testing.T) {
+	input := "SGVsbG8gV29ybGQ=" // "Hello World" in standard Base64 (padded)
+	expected := "Hello World"
+
+	result, err := DecodeBase64Any(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if string(result) != expected {
+		t.Errorf("expected %q, got %q", expected, string(result))
+	}
+}
+
+func TestDecodeBase64Any_StandardUnpadded(t *testing.T) {
+	input := "SGVsbG8gV29ybGQ" // "Hello World" in standard Base64 (unpadded)
+	expected := "Hello World"
+
+	result, err := DecodeBase64Any(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if string(result) != expected {
+		t.Errorf("expected %q, got %q", expected, string(result))
+	}
+}
+
+func TestDecodeBase64Any_URLPadded(t *testing.T) {
+	input := "SGVsbG8tV29ybGQ=" // "Hello-World" in Base64 URL (padded)
+	expected := "Hello-World"
+
+	result, err := DecodeBase64Any(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if string(result) != expected {
+		t.Errorf("expected %q, got %q", expected, string(result))
+	}
+}
+
+func TestDecodeBase64Any_URLUnpadded(t *testing.T) {
+	input := "SGVsbG8tV29ybGQ" // "Hello-World" in Base64 URL (unpadded)
+	expected := "Hello-World"
+
+	result, err := DecodeBase64Any(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if string(result) != expected {
+		t.Errorf("expected %q, got %q", expected, string(result))
+	}
+}
+
+func TestDecodeBase64Any_IMAPPadded(t *testing.T) {
+	input := "SGVsbG8,V29ybGQ=" // "Hello/World" in Base64 IMAP (padded)
+	expected := "Hello?World"
+
+	result, err := DecodeBase64Any(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if string(result) != expected {
+		t.Errorf("expected %q, got %q", expected, string(result))
+	}
+}
+
+func TestDecodeBase64Any_IMAPUnpadded(t *testing.T) {
+	input := "SGVsbG8,V29ybGQ" // "Hello/World" in Base64 IMAP (unpadded)
+	expected := "Hello?World"
+
+	result, err := DecodeBase64Any(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if string(result) != expected {
+		t.Errorf("expected %q, got %q", expected, string(result))
+	}
+}
+
+func TestDecodeBase64Any_InvalidInput(t *testing.T) {
+	input := "Invalid@@Base64" // Invalid Base64 input
+
+	_, err := DecodeBase64Any(input)
+	if err == nil {
+		t.Fatal("expected an error, but got none")
+	}
+}
+
+func TestDecodeBase64Any_EmptyInput(t *testing.T) {
+	input := "" // Empty input
+
+	result, err := DecodeBase64Any(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(result) != 0 {
+		t.Errorf("expected empty result, got %q", string(result))
+	}
+}
+
+func TestDecodeBase64Any_WhitespaceInput(t *testing.T) {
+	input := "  SGVsbG8gV29ybGQ=  " // Input with leading and trailing spaces
+	expected := "Hello World"
+
+	result, err := DecodeBase64Any(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if string(result) != expected {
+		t.Errorf("expected %q, got %q", expected, string(result))
+	}
+}
+
+func TestDecodeBase64Any_LineBreaksInput(t *testing.T) {
+	input := "SGVs\nbG8g\nV29y\nbGQ=" // Input with line breaks
+	expected := "Hello World"
+
+	result, err := DecodeBase64Any(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if string(result) != expected {
+		t.Errorf("expected %q, got %q", expected, string(result))
+	}
+}
+
+func TestDecodeBase64Any_TabCharactersInput(t *testing.T) {
+	input := "SGVsbG8g\tV29ybGQ=" // Input with tab characters
+	expected := "Hello World"
+
+	result, err := DecodeBase64Any(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if string(result) != expected {
+		t.Errorf("expected %q, got %q", expected, string(result))
+	}
+}
+
+func TestDecodeBase64Any_SpecialCharactersIgnored(t *testing.T) {
+	input := "SGVsbG8gV29ybGQ=!!" // Input with ignored special characters
+
+	_, err := DecodeBase64Any(input)
+	if err == nil {
+		t.Fatal("expected an error, but got none")
+	}
+}
+
+func TestDecodeBase64Any_SingleCharacterInput(t *testing.T) {
+	input := "QQ==" // "A" in Base64
+	expected := "A"
+
+	result, err := DecodeBase64Any(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if string(result) != expected {
+		t.Errorf("expected %q, got %q", expected, string(result))
+	}
+}
+
+func TestDecodeBase64Any_LongInput(t *testing.T) {
+	input := "U29tZSB2ZXJ5IGxvbmcgc3RyaW5nIHdpdGggbXVsdGlwbGUgbGluZXMgYW5kIHNwYWNlcy4=" // Long Base64 string
+	expected := "Some very long string with multiple lines and spaces."
+
+	result, err := DecodeBase64Any(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if string(result) != expected {
+		t.Errorf("expected %q, got %q", expected, string(result))
+	}
+}
+
+func TestDecodeBase64Any_Standard63And64(t *testing.T) {
+	input := "Pz8/Pw==" // "???" in standard Base64 (63 = '+', 64 = '/')
+	expected := "????"
+
+	result, err := DecodeBase64Any(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if string(result) != expected {
+		t.Errorf("expected %q, got %q", expected, string(result))
+	}
+}
+
+func TestDecodeBase64Any_Standard63And64_NoPad(t *testing.T) {
+	input := "Pz8/Pw" // "???" in standard Base64 (63 = '+', 64 = '/')
+	expected := "????"
+
+	result, err := DecodeBase64Any(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if string(result) != expected {
+		t.Errorf("expected %q, got %q", expected, string(result))
+	}
+}
+
+func TestDecodeBase64Any_URL63And64(t *testing.T) {
+	input := "Pz8_Pw==" // "???" in Base64 URL-safe (63 = '_', 64 = '-')
+	expected := "????"
+
+	result, err := DecodeBase64Any(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if string(result) != expected {
+		t.Errorf("expected %q, got %q", expected, string(result))
+	}
+}
+
+func TestDecodeBase64Any_URL63And64_NoPad(t *testing.T) {
+	input := "Pz8_Pw==" // "???" in Base64 URL-safe (63 = '_', 64 = '-')
+	expected := "????"
+
+	result, err := DecodeBase64Any(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if string(result) != expected {
+		t.Errorf("expected %q, got %q", expected, string(result))
+	}
+}

langext/baseAny_test.go

@@ -1,7 +1,7 @@
 package langext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 )
 

langext/maps.go

@@ -1,5 +1,7 @@
 package langext
 
+import "encoding/json"
+
 type MapEntry[T comparable, V any] struct {
 	Key   T
 	Value V
@@ -72,6 +74,19 @@ func ForceMap[K comparable, V any](v map[K]V) map[K]V {
 	}
 }
 
+func ForceJsonMapOrPanic(v any) map[string]any {
+	data, err := json.Marshal(v)
+	if err != nil {
+		panic(err)
+	}
+	var result map[string]any
+	err = json.Unmarshal(data, &result)
+	if err != nil {
+		panic(err)
+	}
+	return result
+}
+
 func MapMerge[K comparable, V any](base map[K]V, arr ...map[K]V) map[K]V {
 	res := make(map[K]V, len(base)*(1+len(arr)))
 

langext/url.go

@@ -6,7 +6,9 @@ import (
 )
 
 func BuildUrl(url, path string, params *map[string]string) string {
-	if path[:1] == "/" && url[len(url)-1:] == "/" {
+	if len(url) == 0 || len(path) == 0 {
+		url += path
+	} else if path[:1] == "/" && url[len(url)-1:] == "/" {
 		url += path[1:]
 	} else if path[:1] != "/" && url[len(url)-1:] != "/" {
 		url += "/" + path

langext/url_test.go

@@ -1,7 +1,7 @@
 package langext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 )
 

mathext/clamp.go

@@ -1,6 +1,6 @@
 package mathext
 
-import "gogs.mikescher.com/BlackForestBytes/goext/langext"
+import "git.blackforestbytes.com/BlackForestBytes/goext/langext"
 
 func ClampInt(v int, lo int, hi int) int {
 	if v < lo {

mathext/math.go

@@ -1,6 +1,6 @@
 package mathext
 
-import "gogs.mikescher.com/BlackForestBytes/goext/langext"
+import "git.blackforestbytes.com/BlackForestBytes/goext/langext"
 
 func AvgFloat64(arr []float64) float64 {
 	return SumFloat64(arr) / float64(len(arr))

mathext/statistics.go

@@ -1,8 +1,8 @@
 package mathext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 )
 
 func Sum[T langext.NumberConstraint](v []T) T {

mongoext/registry.go

@@ -1,57 +1,51 @@
 package mongoext
 
 import (
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/rfctime"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
 	"go.mongodb.org/mongo-driver/bson/primitive"
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/rfctime"
 	"reflect"
 )
 
 func CreateGoExtBsonRegistry() *bsoncodec.Registry {
-	rb := bsoncodec.NewRegistryBuilder()
+	reg := bson.NewRegistry()
 
-	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.RFC3339Time{}), rfctime.RFC3339Time{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(rfctime.RFC3339Time{}), rfctime.RFC3339Time{})
-	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.RFC3339Time{}), rfctime.RFC3339Time{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(&rfctime.RFC3339Time{}), rfctime.RFC3339Time{})
 
-	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.RFC3339NanoTime{}), rfctime.RFC3339NanoTime{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(rfctime.RFC3339NanoTime{}), rfctime.RFC3339NanoTime{})
-	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.RFC3339NanoTime{}), rfctime.RFC3339NanoTime{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(&rfctime.RFC3339NanoTime{}), rfctime.RFC3339NanoTime{})
 
-	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.UnixTime{}), rfctime.UnixTime{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(rfctime.UnixTime{}), rfctime.UnixTime{})
-	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.UnixTime{}), rfctime.UnixTime{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(&rfctime.UnixTime{}), rfctime.UnixTime{})
 
-	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.UnixMilliTime{}), rfctime.UnixMilliTime{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(rfctime.UnixMilliTime{}), rfctime.UnixMilliTime{})
-	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.UnixMilliTime{}), rfctime.UnixMilliTime{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(&rfctime.UnixMilliTime{}), rfctime.UnixMilliTime{})
 
-	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.UnixNanoTime{}), rfctime.UnixNanoTime{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(rfctime.UnixNanoTime{}), rfctime.UnixNanoTime{})
-	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.UnixNanoTime{}), rfctime.UnixNanoTime{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(&rfctime.UnixNanoTime{}), rfctime.UnixNanoTime{})
 
-	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.Date{}), rfctime.Date{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(rfctime.Date{}), rfctime.Date{})
-	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.Date{}), rfctime.Date{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(&rfctime.Date{}), rfctime.Date{})
 
-	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.SecondsF64(0)), rfctime.SecondsF64(0))
+	reg.RegisterTypeDecoder(reflect.TypeOf(rfctime.SecondsF64(0)), rfctime.SecondsF64(0))
-	rb.RegisterTypeDecoder(reflect.TypeOf(langext.Ptr(rfctime.SecondsF64(0))), rfctime.SecondsF64(0))
+	reg.RegisterTypeDecoder(reflect.TypeOf(langext.Ptr(rfctime.SecondsF64(0))), rfctime.SecondsF64(0))
 
-	rb.RegisterTypeDecoder(reflect.TypeOf(exerr.ErrorCategory{}), exerr.ErrorCategory{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(exerr.ErrorCategory{}), exerr.ErrorCategory{})
-	rb.RegisterTypeDecoder(reflect.TypeOf(langext.Ptr(exerr.ErrorCategory{})), exerr.ErrorCategory{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(langext.Ptr(exerr.ErrorCategory{})), exerr.ErrorCategory{})
 
-	rb.RegisterTypeDecoder(reflect.TypeOf(exerr.ErrorSeverity{}), exerr.ErrorSeverity{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(exerr.ErrorSeverity{}), exerr.ErrorSeverity{})
-	rb.RegisterTypeDecoder(reflect.TypeOf(langext.Ptr(exerr.ErrorSeverity{})), exerr.ErrorSeverity{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(langext.Ptr(exerr.ErrorSeverity{})), exerr.ErrorSeverity{})
 
-	rb.RegisterTypeDecoder(reflect.TypeOf(exerr.ErrorType{}), exerr.ErrorType{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(exerr.ErrorType{}), exerr.ErrorType{})
-	rb.RegisterTypeDecoder(reflect.TypeOf(langext.Ptr(exerr.ErrorType{})), exerr.ErrorType{})
+	reg.RegisterTypeDecoder(reflect.TypeOf(langext.Ptr(exerr.ErrorType{})), exerr.ErrorType{})
-
-	bsoncodec.DefaultValueEncoders{}.RegisterDefaultEncoders(rb)
-	bsoncodec.DefaultValueDecoders{}.RegisterDefaultDecoders(rb)
-
-	bson.PrimitiveCodecs{}.RegisterPrimitiveCodecs(rb)
 
 	// otherwise we get []primitve.E when unmarshalling into any
 	// which will result in {'key': .., 'value': ...}[] json when json-marshalling
-	rb.RegisterTypeMapEntry(bsontype.EmbeddedDocument, reflect.TypeOf(primitive.M{}))
+	reg.RegisterTypeMapEntry(bson.TypeEmbeddedDocument, reflect.TypeOf(primitive.M{}))
 
-	return rb.Build()
+	return reg
 }

reflectext/convertToMap.go

@@ -2,7 +2,7 @@ package reflectext
 
 import (
 	"encoding/json"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"reflect"
 	"strings"
 )

reflectext/convertToMap_test.go

@@ -2,7 +2,7 @@ package reflectext
 
 import (
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"testing"
 	"time"
 )

reflectext/mapAccess_test.go

@@ -2,7 +2,7 @@ package reflectext
 
 import (
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 )
 

reflectext/primStrSer.go

@@ -4,7 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"go.mongodb.org/mongo-driver/bson/primitive"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"reflect"
 	"strconv"
 	"strings"

reflectext/primitiveStringSerializer.go

@@ -3,7 +3,7 @@ package reflectext
 import (
 	"errors"
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"reflect"
 )
 

reflectext/structAccess.go

@@ -2,7 +2,7 @@ package reflectext
 
 import (
 	"errors"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"reflect"
 	"strconv"
 	"strings"

rext/wrapper.go

@@ -1,7 +1,7 @@
 package rext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"regexp"
 )
 

rext/wrapper_test.go

@@ -1,7 +1,7 @@
 package rext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"regexp"
 	"testing"
 )

rfctime/interface.go

@@ -10,7 +10,8 @@ type RFCTime interface {
 
 	After(u AnyTime) bool
 	Before(u AnyTime) bool
-	Equal(u AnyTime) bool
+
+	EqualAny(u AnyTime) bool
 
 	Sub(u AnyTime) time.Duration
 }
@@ -49,45 +50,15 @@ type AnyTime interface {
 }
 
 type RFCDuration interface {
-	Time() time.Time
+	Hours() float64
-	Serialize() string
+	Minutes() float64
-
+	Seconds() float64
-	UnmarshalJSON(bytes []byte) error
+	Microseconds() int64
-	MarshalJSON() ([]byte, error)
+	Milliseconds() int64
-
+	Nanoseconds() int64
-	MarshalBinary() ([]byte, error)
-	UnmarshalBinary(data []byte) error
-
-	GobEncode() ([]byte, error)
-	GobDecode(data []byte) error
-
-	MarshalText() ([]byte, error)
-	UnmarshalText(data []byte) error
-
-	After(u AnyTime) bool
-	Before(u AnyTime) bool
-	Equal(u AnyTime) bool
-	IsZero() bool
-	Date() (year int, month time.Month, day int)
-	Year() int
-	Month() time.Month
-	Day() int
-	Weekday() time.Weekday
-	ISOWeek() (year, week int)
-	Clock() (hour, min, sec int)
-	Hour() int
-	Minute() int
-	Second() int
-	Nanosecond() int
-	YearDay() int
-	Sub(u AnyTime) time.Duration
-	Unix() int64
-	UnixMilli() int64
-	UnixMicro() int64
-	UnixNano() int64
-	Format(layout string) string
-	GoString() string
 	String() string
+
+	Duration() time.Duration
 }
 
 func tt(v AnyTime) time.Time {

rfctime/interface_test.go

@@ -1,7 +1,7 @@
 package rfctime
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 	"time"
 )

rfctime/rfc3339.go

@@ -4,11 +4,11 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/bsoncodec"
 	"go.mongodb.org/mongo-driver/bson/bsonrw"
 	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"reflect"
 	"time"
 )
@@ -142,7 +142,14 @@ func (t RFC3339Time) Before(u AnyTime) bool {
 	return t.Time().Before(tt(u))
 }
 
-func (t RFC3339Time) Equal(u AnyTime) bool {
+func (t RFC3339Time) Equal(u RFC3339Time) bool {
+	return t.Time().Equal(u.Time())
+}
+
+func (t RFC3339Time) EqualAny(u AnyTime) bool {
+	if u == nil {
+		return false
+	}
 	return t.Time().Equal(tt(u))
 }
 

rfctime/rfc3339Nano.go

@@ -4,11 +4,11 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/bsoncodec"
 	"go.mongodb.org/mongo-driver/bson/bsonrw"
 	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"reflect"
 	"time"
 )
@@ -142,7 +142,14 @@ func (t RFC3339NanoTime) Before(u AnyTime) bool {
 	return t.Time().Before(tt(u))
 }
 
-func (t RFC3339NanoTime) Equal(u AnyTime) bool {
+func (t RFC3339NanoTime) Equal(u RFC3339NanoTime) bool {
+	return t.Time().Equal(u.Time())
+}
+
+func (t RFC3339NanoTime) EqualAny(u AnyTime) bool {
+	if u == nil {
+		return false
+	}
 	return t.Time().Equal(tt(u))
 }
 

rfctime/rfc3339Nano_test.go

@@ -2,10 +2,11 @@ package rfctime
 
 import (
 	"encoding/json"
-	"gogs.mikescher.com/BlackForestBytes/goext/timeext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
 	"testing"
 	"time"
+
+	"git.blackforestbytes.com/BlackForestBytes/goext/timeext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 )
 
 func TestRoundtrip(t *testing.T) {
@@ -23,8 +24,8 @@ func TestRoundtrip(t *testing.T) {
 	}
 
 	if string(jstr1) != "{\"v\":\"2023-02-09T15:05:56.820915171+01:00\"}" {
-		t.Errorf(string(jstr1))
+		t.Error(string(jstr1))
-		t.Errorf("repr differs")
+		t.Error("repr differs")
 	}
 
 	w2 := Wrap{}
@@ -41,7 +42,7 @@ func TestRoundtrip(t *testing.T) {
 
 	tst.AssertEqual(t, string(jstr1), string(jstr2))
 
-	if !w1.Value.Equal(&w2.Value) {
+	if !w1.Value.EqualAny(&w2.Value) {
 		t.Errorf("time differs")
 	}
 

rfctime/seconds.go

@@ -4,11 +4,11 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"git.blackforestbytes.com/BlackForestBytes/goext/timeext"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/bsoncodec"
 	"go.mongodb.org/mongo-driver/bson/bsonrw"
 	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"gogs.mikescher.com/BlackForestBytes/goext/timeext"
 	"reflect"
 	"time"
 )

rfctime/time.go

@@ -2,7 +2,7 @@ package rfctime
 
 import (
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"strconv"
 	"strings"
 	"time"