Switch remote deploy to vendored source builds

Move remote deployment to a vendored source bundle built on the target host via Docker so redeploys no longer require local cross-compilation or host Go installation.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

vendor/github.com/samber/lo/.gitignore

@@ -0,0 +1,38 @@
+
+# Created by https://www.toptal.com/developers/gitignore/api/go
+# Edit at https://www.toptal.com/developers/gitignore?templates=go
+
+### Go ###
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
+
+### Go Patch ###
+/vendor/
+/Godeps/
+
+# End of https://www.toptal.com/developers/gitignore/api/go
+
+cover.out
+cover.html
+.vscode
+
+.idea/

vendor/github.com/samber/lo/Dockerfile

@@ -0,0 +1,8 @@
+
+FROM golang:1.23.1
+
+WORKDIR /go/src/github.com/samber/lo
+
+COPY Makefile go.* ./
+
+RUN make tools

vendor/github.com/samber/lo/LICENSE

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

vendor/github.com/samber/lo/Makefile

@@ -0,0 +1,42 @@
+
+build:
+	go build -v ./...
+
+test:
+	go test -race -v ./...
+watch-test:
+	reflex -t 50ms -s -- sh -c 'gotest -race -v ./...'
+
+bench:
+	go test -benchmem -count 3 -bench ./...
+watch-bench:
+	reflex -t 50ms -s -- sh -c 'go test -benchmem -count 3 -bench ./...'
+
+coverage:
+	go test -v -coverprofile=cover.out -covermode=atomic ./...
+	go tool cover -html=cover.out -o cover.html
+
+# tools
+tools:
+	go install github.com/cespare/reflex@latest
+	go install github.com/rakyll/gotest@latest
+	go install github.com/psampaz/go-mod-outdated@latest
+	go install github.com/jondot/goweight@latest
+	go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
+	go get -t -u golang.org/x/tools/cmd/cover
+	go install github.com/sonatype-nexus-community/nancy@latest
+	go mod tidy
+
+lint:
+	golangci-lint run --timeout 60s --max-same-issues 50 ./...
+lint-fix:
+	golangci-lint run --timeout 60s --max-same-issues 50 --fix ./...
+
+audit: tools
+	go list -json -m all | nancy sleuth
+
+outdated: tools
+	go list -u -m -json all | go-mod-outdated -update -direct
+
+weight: tools
+	goweight

vendor/github.com/samber/lo/channel.go

@@ -0,0 +1,314 @@
+package lo
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"github.com/samber/lo/internal/rand"
+)
+
+type DispatchingStrategy[T any] func(msg T, index uint64, channels []<-chan T) int
+
+// ChannelDispatcher distributes messages from input channels into N child channels.
+// Close events are propagated to children.
+// Underlying channels can have a fixed buffer capacity or be unbuffered when cap is 0.
+func ChannelDispatcher[T any](stream <-chan T, count int, channelBufferCap int, strategy DispatchingStrategy[T]) []<-chan T {
+	children := createChannels[T](count, channelBufferCap)
+
+	roChildren := channelsToReadOnly(children)
+
+	go func() {
+		// propagate channel closing to children
+		defer closeChannels(children)
+
+		var i uint64 = 0
+
+		for {
+			msg, ok := <-stream
+			if !ok {
+				return
+			}
+
+			destination := strategy(msg, i, roChildren) % count
+			children[destination] <- msg
+
+			i++
+		}
+	}()
+
+	return roChildren
+}
+
+func createChannels[T any](count int, channelBufferCap int) []chan T {
+	children := make([]chan T, 0, count)
+
+	for i := 0; i < count; i++ {
+		children = append(children, make(chan T, channelBufferCap))
+	}
+
+	return children
+}
+
+func channelsToReadOnly[T any](children []chan T) []<-chan T {
+	roChildren := make([]<-chan T, 0, len(children))
+
+	for i := range children {
+		roChildren = append(roChildren, children[i])
+	}
+
+	return roChildren
+}
+
+func closeChannels[T any](children []chan T) {
+	for i := 0; i < len(children); i++ {
+		close(children[i])
+	}
+}
+
+func channelIsNotFull[T any](ch <-chan T) bool {
+	return cap(ch) == 0 || len(ch) < cap(ch)
+}
+
+// DispatchingStrategyRoundRobin distributes messages in a rotating sequential manner.
+// If the channel capacity is exceeded, the next channel will be selected and so on.
+func DispatchingStrategyRoundRobin[T any](msg T, index uint64, channels []<-chan T) int {
+	for {
+		i := int(index % uint64(len(channels)))
+		if channelIsNotFull(channels[i]) {
+			return i
+		}
+
+		index++
+		time.Sleep(10 * time.Microsecond) // prevent CPU from burning 🔥
+	}
+}
+
+// DispatchingStrategyRandom distributes messages in a random manner.
+// If the channel capacity is exceeded, another random channel will be selected and so on.
+func DispatchingStrategyRandom[T any](msg T, index uint64, channels []<-chan T) int {
+	for {
+		i := rand.IntN(len(channels))
+		if channelIsNotFull(channels[i]) {
+			return i
+		}
+
+		time.Sleep(10 * time.Microsecond) // prevent CPU from burning 🔥
+	}
+}
+
+// DispatchingStrategyWeightedRandom distributes messages in a weighted manner.
+// If the channel capacity is exceeded, another random channel will be selected and so on.
+func DispatchingStrategyWeightedRandom[T any](weights []int) DispatchingStrategy[T] {
+	seq := []int{}
+
+	for i := 0; i < len(weights); i++ {
+		for j := 0; j < weights[i]; j++ {
+			seq = append(seq, i)
+		}
+	}
+
+	return func(msg T, index uint64, channels []<-chan T) int {
+		for {
+			i := seq[rand.IntN(len(seq))]
+			if channelIsNotFull(channels[i]) {
+				return i
+			}
+
+			time.Sleep(10 * time.Microsecond) // prevent CPU from burning 🔥
+		}
+	}
+}
+
+// DispatchingStrategyFirst distributes messages in the first non-full channel.
+// If the capacity of the first channel is exceeded, the second channel will be selected and so on.
+func DispatchingStrategyFirst[T any](msg T, index uint64, channels []<-chan T) int {
+	for {
+		for i := range channels {
+			if channelIsNotFull(channels[i]) {
+				return i
+			}
+		}
+
+		time.Sleep(10 * time.Microsecond) // prevent CPU from burning 🔥
+	}
+}
+
+// DispatchingStrategyLeast distributes messages in the emptiest channel.
+func DispatchingStrategyLeast[T any](msg T, index uint64, channels []<-chan T) int {
+	seq := Range(len(channels))
+
+	return MinBy(seq, func(item int, min int) bool {
+		return len(channels[item]) < len(channels[min])
+	})
+}
+
+// DispatchingStrategyMost distributes messages in the fullest channel.
+// If the channel capacity is exceeded, the next channel will be selected and so on.
+func DispatchingStrategyMost[T any](msg T, index uint64, channels []<-chan T) int {
+	seq := Range(len(channels))
+
+	return MaxBy(seq, func(item int, max int) bool {
+		return len(channels[item]) > len(channels[max]) && channelIsNotFull(channels[item])
+	})
+}
+
+// SliceToChannel returns a read-only channels of collection elements.
+func SliceToChannel[T any](bufferSize int, collection []T) <-chan T {
+	ch := make(chan T, bufferSize)
+
+	go func() {
+		for i := range collection {
+			ch <- collection[i]
+		}
+
+		close(ch)
+	}()
+
+	return ch
+}
+
+// ChannelToSlice returns a slice built from channels items. Blocks until channel closes.
+func ChannelToSlice[T any](ch <-chan T) []T {
+	collection := []T{}
+
+	for item := range ch {
+		collection = append(collection, item)
+	}
+
+	return collection
+}
+
+// Generator implements the generator design pattern.
+func Generator[T any](bufferSize int, generator func(yield func(T))) <-chan T {
+	ch := make(chan T, bufferSize)
+
+	go func() {
+		// WARNING: infinite loop
+		generator(func(t T) {
+			ch <- t
+		})
+
+		close(ch)
+	}()
+
+	return ch
+}
+
+// Buffer creates a slice of n elements from a channel. Returns the slice and the slice length.
+// @TODO: we should probably provide an helper that reuse the same buffer.
+func Buffer[T any](ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool) {
+	buffer := make([]T, 0, size)
+	index := 0
+	now := time.Now()
+
+	for ; index < size; index++ {
+		item, ok := <-ch
+		if !ok {
+			return buffer, index, time.Since(now), false
+		}
+
+		buffer = append(buffer, item)
+	}
+
+	return buffer, index, time.Since(now), true
+}
+
+// Batch creates a slice of n elements from a channel. Returns the slice and the slice length.
+//
+// Deprecated: Use [Buffer] instead.
+func Batch[T any](ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool) {
+	return Buffer(ch, size)
+}
+
+// BufferWithContext creates a slice of n elements from a channel, with context. Returns the slice and the slice length.
+// @TODO: we should probably provide an helper that reuse the same buffer.
+func BufferWithContext[T any](ctx context.Context, ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool) {
+	buffer := make([]T, 0, size)
+	now := time.Now()
+
+	for index := 0; index < size; index++ {
+		select {
+		case item, ok := <-ch:
+			if !ok {
+				return buffer, index, time.Since(now), false
+			}
+
+			buffer = append(buffer, item)
+
+		case <-ctx.Done():
+			return buffer, index, time.Since(now), true
+		}
+	}
+
+	return buffer, size, time.Since(now), true
+}
+
+// BufferWithTimeout creates a slice of n elements from a channel, with timeout. Returns the slice and the slice length.
+func BufferWithTimeout[T any](ch <-chan T, size int, timeout time.Duration) (collection []T, length int, readTime time.Duration, ok bool) {
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+	return BufferWithContext(ctx, ch, size)
+}
+
+// BatchWithTimeout creates a slice of n elements from a channel, with timeout. Returns the slice and the slice length.
+//
+// Deprecated: Use [BufferWithTimeout] instead.
+func BatchWithTimeout[T any](ch <-chan T, size int, timeout time.Duration) (collection []T, length int, readTime time.Duration, ok bool) {
+	return BufferWithTimeout(ch, size, timeout)
+}
+
+// FanIn collects messages from multiple input channels into a single buffered channel.
+// Output messages has no priority. When all upstream channels reach EOF, downstream channel closes.
+func FanIn[T any](channelBufferCap int, upstreams ...<-chan T) <-chan T {
+	out := make(chan T, channelBufferCap)
+	var wg sync.WaitGroup
+
+	// Start an output goroutine for each input channel in upstreams.
+	wg.Add(len(upstreams))
+	for i := range upstreams {
+		go func(index int) {
+			for n := range upstreams[index] {
+				out <- n
+			}
+			wg.Done()
+		}(i)
+	}
+
+	// Start a goroutine to close out once all the output goroutines are done.
+	go func() {
+		wg.Wait()
+		close(out)
+	}()
+	return out
+}
+
+// ChannelMerge collects messages from multiple input channels into a single buffered channel.
+// Output messages has no priority. When all upstream channels reach EOF, downstream channel closes.
+//
+// Deprecated: Use [FanIn] instead.
+func ChannelMerge[T any](channelBufferCap int, upstreams ...<-chan T) <-chan T {
+	return FanIn(channelBufferCap, upstreams...)
+}
+
+// FanOut broadcasts all the upstream messages to multiple downstream channels.
+// When upstream channel reach EOF, downstream channels close. If any downstream
+// channels is full, broadcasting is paused.
+func FanOut[T any](count int, channelsBufferCap int, upstream <-chan T) []<-chan T {
+	downstreams := createChannels[T](count, channelsBufferCap)
+
+	go func() {
+		for msg := range upstream {
+			for i := range downstreams {
+				downstreams[i] <- msg
+			}
+		}
+
+		// Close out once all the output goroutines are done.
+		for i := range downstreams {
+			close(downstreams[i])
+		}
+	}()
+
+	return channelsToReadOnly(downstreams)
+}

vendor/github.com/samber/lo/concurrency.go

@@ -0,0 +1,136 @@
+package lo
+
+import (
+	"context"
+	"sync"
+	"time"
+)
+
+type synchronize struct {
+	locker sync.Locker
+}
+
+func (s *synchronize) Do(cb func()) {
+	s.locker.Lock()
+	Try0(cb)
+	s.locker.Unlock()
+}
+
+// Synchronize wraps the underlying callback in a mutex. It receives an optional mutex.
+func Synchronize(opt ...sync.Locker) *synchronize {
+	if len(opt) > 1 {
+		panic("unexpected arguments")
+	} else if len(opt) == 0 {
+		opt = append(opt, &sync.Mutex{})
+	}
+
+	return &synchronize{
+		locker: opt[0],
+	}
+}
+
+// Async executes a function in a goroutine and returns the result in a channel.
+func Async[A any](f func() A) <-chan A {
+	ch := make(chan A, 1)
+	go func() {
+		ch <- f()
+	}()
+	return ch
+}
+
+// Async0 executes a function in a goroutine and returns a channel set once the function finishes.
+func Async0(f func()) <-chan struct{} {
+	ch := make(chan struct{}, 1)
+	go func() {
+		f()
+		ch <- struct{}{}
+	}()
+	return ch
+}
+
+// Async1 is an alias to Async.
+func Async1[A any](f func() A) <-chan A {
+	return Async(f)
+}
+
+// Async2 has the same behavior as Async, but returns the 2 results as a tuple inside the channel.
+func Async2[A, B any](f func() (A, B)) <-chan Tuple2[A, B] {
+	ch := make(chan Tuple2[A, B], 1)
+	go func() {
+		ch <- T2(f())
+	}()
+	return ch
+}
+
+// Async3 has the same behavior as Async, but returns the 3 results as a tuple inside the channel.
+func Async3[A, B, C any](f func() (A, B, C)) <-chan Tuple3[A, B, C] {
+	ch := make(chan Tuple3[A, B, C], 1)
+	go func() {
+		ch <- T3(f())
+	}()
+	return ch
+}
+
+// Async4 has the same behavior as Async, but returns the 4 results as a tuple inside the channel.
+func Async4[A, B, C, D any](f func() (A, B, C, D)) <-chan Tuple4[A, B, C, D] {
+	ch := make(chan Tuple4[A, B, C, D], 1)
+	go func() {
+		ch <- T4(f())
+	}()
+	return ch
+}
+
+// Async5 has the same behavior as Async, but returns the 5 results as a tuple inside the channel.
+func Async5[A, B, C, D, E any](f func() (A, B, C, D, E)) <-chan Tuple5[A, B, C, D, E] {
+	ch := make(chan Tuple5[A, B, C, D, E], 1)
+	go func() {
+		ch <- T5(f())
+	}()
+	return ch
+}
+
+// Async6 has the same behavior as Async, but returns the 6 results as a tuple inside the channel.
+func Async6[A, B, C, D, E, F any](f func() (A, B, C, D, E, F)) <-chan Tuple6[A, B, C, D, E, F] {
+	ch := make(chan Tuple6[A, B, C, D, E, F], 1)
+	go func() {
+		ch <- T6(f())
+	}()
+	return ch
+}
+
+// WaitFor runs periodically until a condition is validated.
+func WaitFor(condition func(i int) bool, timeout time.Duration, heartbeatDelay time.Duration) (totalIterations int, elapsed time.Duration, conditionFound bool) {
+	conditionWithContext := func(_ context.Context, currentIteration int) bool {
+		return condition(currentIteration)
+	}
+	return WaitForWithContext(context.Background(), conditionWithContext, timeout, heartbeatDelay)
+}
+
+// WaitForWithContext runs periodically until a condition is validated or context is canceled.
+func WaitForWithContext(ctx context.Context, condition func(ctx context.Context, currentIteration int) bool, timeout time.Duration, heartbeatDelay time.Duration) (totalIterations int, elapsed time.Duration, conditionFound bool) {
+	start := time.Now()
+
+	if ctx.Err() != nil {
+		return totalIterations, time.Since(start), false
+	}
+
+	ctx, cleanCtx := context.WithTimeout(ctx, timeout)
+	ticker := time.NewTicker(heartbeatDelay)
+
+	defer func() {
+		cleanCtx()
+		ticker.Stop()
+	}()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return totalIterations, time.Since(start), false
+		case <-ticker.C:
+			totalIterations++
+			if condition(ctx, totalIterations-1) {
+				return totalIterations, time.Since(start), true
+			}
+		}
+	}
+}

vendor/github.com/samber/lo/condition.go

@@ -0,0 +1,150 @@
+package lo
+
+// Ternary is a 1 line if/else statement.
+// Play: https://go.dev/play/p/t-D7WBL44h2
+func Ternary[T any](condition bool, ifOutput T, elseOutput T) T {
+	if condition {
+		return ifOutput
+	}
+
+	return elseOutput
+}
+
+// TernaryF is a 1 line if/else statement whose options are functions
+// Play: https://go.dev/play/p/AO4VW20JoqM
+func TernaryF[T any](condition bool, ifFunc func() T, elseFunc func() T) T {
+	if condition {
+		return ifFunc()
+	}
+
+	return elseFunc()
+}
+
+type ifElse[T any] struct {
+	result T
+	done   bool
+}
+
+// If.
+// Play: https://go.dev/play/p/WSw3ApMxhyW
+func If[T any](condition bool, result T) *ifElse[T] {
+	if condition {
+		return &ifElse[T]{result, true}
+	}
+
+	var t T
+	return &ifElse[T]{t, false}
+}
+
+// IfF.
+// Play: https://go.dev/play/p/WSw3ApMxhyW
+func IfF[T any](condition bool, resultF func() T) *ifElse[T] {
+	if condition {
+		return &ifElse[T]{resultF(), true}
+	}
+
+	var t T
+	return &ifElse[T]{t, false}
+}
+
+// ElseIf.
+// Play: https://go.dev/play/p/WSw3ApMxhyW
+func (i *ifElse[T]) ElseIf(condition bool, result T) *ifElse[T] {
+	if !i.done && condition {
+		i.result = result
+		i.done = true
+	}
+
+	return i
+}
+
+// ElseIfF.
+// Play: https://go.dev/play/p/WSw3ApMxhyW
+func (i *ifElse[T]) ElseIfF(condition bool, resultF func() T) *ifElse[T] {
+	if !i.done && condition {
+		i.result = resultF()
+		i.done = true
+	}
+
+	return i
+}
+
+// Else.
+// Play: https://go.dev/play/p/WSw3ApMxhyW
+func (i *ifElse[T]) Else(result T) T {
+	if i.done {
+		return i.result
+	}
+
+	return result
+}
+
+// ElseF.
+// Play: https://go.dev/play/p/WSw3ApMxhyW
+func (i *ifElse[T]) ElseF(resultF func() T) T {
+	if i.done {
+		return i.result
+	}
+
+	return resultF()
+}
+
+type switchCase[T comparable, R any] struct {
+	predicate T
+	result    R
+	done      bool
+}
+
+// Switch is a pure functional switch/case/default statement.
+// Play: https://go.dev/play/p/TGbKUMAeRUd
+func Switch[T comparable, R any](predicate T) *switchCase[T, R] {
+	var result R
+
+	return &switchCase[T, R]{
+		predicate,
+		result,
+		false,
+	}
+}
+
+// Case.
+// Play: https://go.dev/play/p/TGbKUMAeRUd
+func (s *switchCase[T, R]) Case(val T, result R) *switchCase[T, R] {
+	if !s.done && s.predicate == val {
+		s.result = result
+		s.done = true
+	}
+
+	return s
+}
+
+// CaseF.
+// Play: https://go.dev/play/p/TGbKUMAeRUd
+func (s *switchCase[T, R]) CaseF(val T, cb func() R) *switchCase[T, R] {
+	if !s.done && s.predicate == val {
+		s.result = cb()
+		s.done = true
+	}
+
+	return s
+}
+
+// Default.
+// Play: https://go.dev/play/p/TGbKUMAeRUd
+func (s *switchCase[T, R]) Default(result R) R {
+	if !s.done {
+		s.result = result
+	}
+
+	return s.result
+}
+
+// DefaultF.
+// Play: https://go.dev/play/p/TGbKUMAeRUd
+func (s *switchCase[T, R]) DefaultF(cb func() R) R {
+	if !s.done {
+		s.result = cb()
+	}
+
+	return s.result
+}

vendor/github.com/samber/lo/constraints.go

@@ -0,0 +1,6 @@
+package lo
+
+// Clonable defines a constraint of types having Clone() T method.
+type Clonable[T any] interface {
+	Clone() T
+}

vendor/github.com/samber/lo/errors.go

@@ -0,0 +1,354 @@
+package lo
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+// Validate is a helper that creates an error when a condition is not met.
+// Play: https://go.dev/play/p/vPyh51XpCBt
+func Validate(ok bool, format string, args ...any) error {
+	if !ok {
+		return fmt.Errorf(format, args...)
+	}
+	return nil
+}
+
+func messageFromMsgAndArgs(msgAndArgs ...any) string {
+	if len(msgAndArgs) == 1 {
+		if msgAsStr, ok := msgAndArgs[0].(string); ok {
+			return msgAsStr
+		}
+		return fmt.Sprintf("%+v", msgAndArgs[0])
+	}
+	if len(msgAndArgs) > 1 {
+		return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...)
+	}
+	return ""
+}
+
+// must panics if err is error or false.
+func must(err any, messageArgs ...any) {
+	if err == nil {
+		return
+	}
+
+	switch e := err.(type) {
+	case bool:
+		if !e {
+			message := messageFromMsgAndArgs(messageArgs...)
+			if message == "" {
+				message = "not ok"
+			}
+
+			panic(message)
+		}
+
+	case error:
+		message := messageFromMsgAndArgs(messageArgs...)
+		if message != "" {
+			panic(message + ": " + e.Error())
+		} else {
+			panic(e.Error())
+		}
+
+	default:
+		panic("must: invalid err type '" + reflect.TypeOf(err).Name() + "', should either be a bool or an error")
+	}
+}
+
+// Must is a helper that wraps a call to a function returning a value and an error
+// and panics if err is error or false.
+// Play: https://go.dev/play/p/TMoWrRp3DyC
+func Must[T any](val T, err any, messageArgs ...any) T {
+	must(err, messageArgs...)
+	return val
+}
+
+// Must0 has the same behavior as Must, but callback returns no variable.
+// Play: https://go.dev/play/p/TMoWrRp3DyC
+func Must0(err any, messageArgs ...any) {
+	must(err, messageArgs...)
+}
+
+// Must1 is an alias to Must
+// Play: https://go.dev/play/p/TMoWrRp3DyC
+func Must1[T any](val T, err any, messageArgs ...any) T {
+	return Must(val, err, messageArgs...)
+}
+
+// Must2 has the same behavior as Must, but callback returns 2 variables.
+// Play: https://go.dev/play/p/TMoWrRp3DyC
+func Must2[T1, T2 any](val1 T1, val2 T2, err any, messageArgs ...any) (T1, T2) {
+	must(err, messageArgs...)
+	return val1, val2
+}
+
+// Must3 has the same behavior as Must, but callback returns 3 variables.
+// Play: https://go.dev/play/p/TMoWrRp3DyC
+func Must3[T1, T2, T3 any](val1 T1, val2 T2, val3 T3, err any, messageArgs ...any) (T1, T2, T3) {
+	must(err, messageArgs...)
+	return val1, val2, val3
+}
+
+// Must4 has the same behavior as Must, but callback returns 4 variables.
+// Play: https://go.dev/play/p/TMoWrRp3DyC
+func Must4[T1, T2, T3, T4 any](val1 T1, val2 T2, val3 T3, val4 T4, err any, messageArgs ...any) (T1, T2, T3, T4) {
+	must(err, messageArgs...)
+	return val1, val2, val3, val4
+}
+
+// Must5 has the same behavior as Must, but callback returns 5 variables.
+// Play: https://go.dev/play/p/TMoWrRp3DyC
+func Must5[T1, T2, T3, T4, T5 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, err any, messageArgs ...any) (T1, T2, T3, T4, T5) {
+	must(err, messageArgs...)
+	return val1, val2, val3, val4, val5
+}
+
+// Must6 has the same behavior as Must, but callback returns 6 variables.
+// Play: https://go.dev/play/p/TMoWrRp3DyC
+func Must6[T1, T2, T3, T4, T5, T6 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, val6 T6, err any, messageArgs ...any) (T1, T2, T3, T4, T5, T6) {
+	must(err, messageArgs...)
+	return val1, val2, val3, val4, val5, val6
+}
+
+// Try calls the function and return false in case of error.
+func Try(callback func() error) (ok bool) {
+	ok = true
+
+	defer func() {
+		if r := recover(); r != nil {
+			ok = false
+		}
+	}()
+
+	err := callback()
+	if err != nil {
+		ok = false
+	}
+
+	return
+}
+
+// Try0 has the same behavior as Try, but callback returns no variable.
+// Play: https://go.dev/play/p/mTyyWUvn9u4
+func Try0(callback func()) bool {
+	return Try(func() error {
+		callback()
+		return nil
+	})
+}
+
+// Try1 is an alias to Try.
+// Play: https://go.dev/play/p/mTyyWUvn9u4
+func Try1(callback func() error) bool {
+	return Try(callback)
+}
+
+// Try2 has the same behavior as Try, but callback returns 2 variables.
+// Play: https://go.dev/play/p/mTyyWUvn9u4
+func Try2[T any](callback func() (T, error)) bool {
+	return Try(func() error {
+		_, err := callback()
+		return err
+	})
+}
+
+// Try3 has the same behavior as Try, but callback returns 3 variables.
+// Play: https://go.dev/play/p/mTyyWUvn9u4
+func Try3[T, R any](callback func() (T, R, error)) bool {
+	return Try(func() error {
+		_, _, err := callback()
+		return err
+	})
+}
+
+// Try4 has the same behavior as Try, but callback returns 4 variables.
+// Play: https://go.dev/play/p/mTyyWUvn9u4
+func Try4[T, R, S any](callback func() (T, R, S, error)) bool {
+	return Try(func() error {
+		_, _, _, err := callback()
+		return err
+	})
+}
+
+// Try5 has the same behavior as Try, but callback returns 5 variables.
+// Play: https://go.dev/play/p/mTyyWUvn9u4
+func Try5[T, R, S, Q any](callback func() (T, R, S, Q, error)) bool {
+	return Try(func() error {
+		_, _, _, _, err := callback()
+		return err
+	})
+}
+
+// Try6 has the same behavior as Try, but callback returns 6 variables.
+// Play: https://go.dev/play/p/mTyyWUvn9u4
+func Try6[T, R, S, Q, U any](callback func() (T, R, S, Q, U, error)) bool {
+	return Try(func() error {
+		_, _, _, _, _, err := callback()
+		return err
+	})
+}
+
+// TryOr has the same behavior as Must, but returns a default value in case of error.
+// Play: https://go.dev/play/p/B4F7Wg2Zh9X
+func TryOr[A any](callback func() (A, error), fallbackA A) (A, bool) {
+	return TryOr1(callback, fallbackA)
+}
+
+// TryOr1 has the same behavior as Must, but returns a default value in case of error.
+// Play: https://go.dev/play/p/B4F7Wg2Zh9X
+func TryOr1[A any](callback func() (A, error), fallbackA A) (A, bool) {
+	ok := false
+
+	Try0(func() {
+		a, err := callback()
+		if err == nil {
+			fallbackA = a
+			ok = true
+		}
+	})
+
+	return fallbackA, ok
+}
+
+// TryOr2 has the same behavior as Must, but returns a default value in case of error.
+// Play: https://go.dev/play/p/B4F7Wg2Zh9X
+func TryOr2[A, B any](callback func() (A, B, error), fallbackA A, fallbackB B) (A, B, bool) {
+	ok := false
+
+	Try0(func() {
+		a, b, err := callback()
+		if err == nil {
+			fallbackA = a
+			fallbackB = b
+			ok = true
+		}
+	})
+
+	return fallbackA, fallbackB, ok
+}
+
+// TryOr3 has the same behavior as Must, but returns a default value in case of error.
+// Play: https://go.dev/play/p/B4F7Wg2Zh9X
+func TryOr3[A, B, C any](callback func() (A, B, C, error), fallbackA A, fallbackB B, fallbackC C) (A, B, C, bool) {
+	ok := false
+
+	Try0(func() {
+		a, b, c, err := callback()
+		if err == nil {
+			fallbackA = a
+			fallbackB = b
+			fallbackC = c
+			ok = true
+		}
+	})
+
+	return fallbackA, fallbackB, fallbackC, ok
+}
+
+// TryOr4 has the same behavior as Must, but returns a default value in case of error.
+// Play: https://go.dev/play/p/B4F7Wg2Zh9X
+func TryOr4[A, B, C, D any](callback func() (A, B, C, D, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D) (A, B, C, D, bool) {
+	ok := false
+
+	Try0(func() {
+		a, b, c, d, err := callback()
+		if err == nil {
+			fallbackA = a
+			fallbackB = b
+			fallbackC = c
+			fallbackD = d
+			ok = true
+		}
+	})
+
+	return fallbackA, fallbackB, fallbackC, fallbackD, ok
+}
+
+// TryOr5 has the same behavior as Must, but returns a default value in case of error.
+// Play: https://go.dev/play/p/B4F7Wg2Zh9X
+func TryOr5[A, B, C, D, E any](callback func() (A, B, C, D, E, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D, fallbackE E) (A, B, C, D, E, bool) {
+	ok := false
+
+	Try0(func() {
+		a, b, c, d, e, err := callback()
+		if err == nil {
+			fallbackA = a
+			fallbackB = b
+			fallbackC = c
+			fallbackD = d
+			fallbackE = e
+			ok = true
+		}
+	})
+
+	return fallbackA, fallbackB, fallbackC, fallbackD, fallbackE, ok
+}
+
+// TryOr6 has the same behavior as Must, but returns a default value in case of error.
+// Play: https://go.dev/play/p/B4F7Wg2Zh9X
+func TryOr6[A, B, C, D, E, F any](callback func() (A, B, C, D, E, F, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D, fallbackE E, fallbackF F) (A, B, C, D, E, F, bool) {
+	ok := false
+
+	Try0(func() {
+		a, b, c, d, e, f, err := callback()
+		if err == nil {
+			fallbackA = a
+			fallbackB = b
+			fallbackC = c
+			fallbackD = d
+			fallbackE = e
+			fallbackF = f
+			ok = true
+		}
+	})
+
+	return fallbackA, fallbackB, fallbackC, fallbackD, fallbackE, fallbackF, ok
+}
+
+// TryWithErrorValue has the same behavior as Try, but also returns value passed to panic.
+// Play: https://go.dev/play/p/Kc7afQIT2Fs
+func TryWithErrorValue(callback func() error) (errorValue any, ok bool) {
+	ok = true
+
+	defer func() {
+		if r := recover(); r != nil {
+			ok = false
+			errorValue = r
+		}
+	}()
+
+	err := callback()
+	if err != nil {
+		ok = false
+		errorValue = err
+	}
+
+	return
+}
+
+// TryCatch has the same behavior as Try, but calls the catch function in case of error.
+// Play: https://go.dev/play/p/PnOON-EqBiU
+func TryCatch(callback func() error, catch func()) {
+	if !Try(callback) {
+		catch()
+	}
+}
+
+// TryCatchWithErrorValue has the same behavior as TryWithErrorValue, but calls the catch function in case of error.
+// Play: https://go.dev/play/p/8Pc9gwX_GZO
+func TryCatchWithErrorValue(callback func() error, catch func(any)) {
+	if err, ok := TryWithErrorValue(callback); !ok {
+		catch(err)
+	}
+}
+
+// ErrorsAs is a shortcut for errors.As(err, &&T).
+// Play: https://go.dev/play/p/8wk5rH8UfrE
+func ErrorsAs[T error](err error) (T, bool) {
+	var t T
+	ok := errors.As(err, &t)
+	return t, ok
+}

vendor/github.com/samber/lo/find.go

@@ -0,0 +1,628 @@
+package lo
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/samber/lo/internal/constraints"
+	"github.com/samber/lo/internal/rand"
+)
+
+// IndexOf returns the index at which the first occurrence of a value is found in an array or return -1
+// if the value cannot be found.
+func IndexOf[T comparable](collection []T, element T) int {
+	for i := range collection {
+		if collection[i] == element {
+			return i
+		}
+	}
+
+	return -1
+}
+
+// LastIndexOf returns the index at which the last occurrence of a value is found in an array or return -1
+// if the value cannot be found.
+func LastIndexOf[T comparable](collection []T, element T) int {
+	length := len(collection)
+
+	for i := length - 1; i >= 0; i-- {
+		if collection[i] == element {
+			return i
+		}
+	}
+
+	return -1
+}
+
+// Find search an element in a slice based on a predicate. It returns element and true if element was found.
+func Find[T any](collection []T, predicate func(item T) bool) (T, bool) {
+	for i := range collection {
+		if predicate(collection[i]) {
+			return collection[i], true
+		}
+	}
+
+	var result T
+	return result, false
+}
+
+// FindIndexOf searches an element in a slice based on a predicate and returns the index and true.
+// It returns -1 and false if the element is not found.
+func FindIndexOf[T any](collection []T, predicate func(item T) bool) (T, int, bool) {
+	for i := range collection {
+		if predicate(collection[i]) {
+			return collection[i], i, true
+		}
+	}
+
+	var result T
+	return result, -1, false
+}
+
+// FindLastIndexOf searches last element in a slice based on a predicate and returns the index and true.
+// It returns -1 and false if the element is not found.
+func FindLastIndexOf[T any](collection []T, predicate func(item T) bool) (T, int, bool) {
+	length := len(collection)
+
+	for i := length - 1; i >= 0; i-- {
+		if predicate(collection[i]) {
+			return collection[i], i, true
+		}
+	}
+
+	var result T
+	return result, -1, false
+}
+
+// FindOrElse search an element in a slice based on a predicate. It returns the element if found or a given fallback value otherwise.
+func FindOrElse[T any](collection []T, fallback T, predicate func(item T) bool) T {
+	for i := range collection {
+		if predicate(collection[i]) {
+			return collection[i]
+		}
+	}
+
+	return fallback
+}
+
+// FindKey returns the key of the first value matching.
+func FindKey[K comparable, V comparable](object map[K]V, value V) (K, bool) {
+	for k := range object {
+		if object[k] == value {
+			return k, true
+		}
+	}
+
+	return Empty[K](), false
+}
+
+// FindKeyBy returns the key of the first element predicate returns truthy for.
+func FindKeyBy[K comparable, V any](object map[K]V, predicate func(key K, value V) bool) (K, bool) {
+	for k := range object {
+		if predicate(k, object[k]) {
+			return k, true
+		}
+	}
+
+	return Empty[K](), false
+}
+
+// FindUniques returns a slice with all the unique elements of the collection.
+// The order of result values is determined by the order they occur in the collection.
+func FindUniques[T comparable, Slice ~[]T](collection Slice) Slice {
+	isDupl := make(map[T]bool, len(collection))
+
+	for i := range collection {
+		duplicated, ok := isDupl[collection[i]]
+		if !ok {
+			isDupl[collection[i]] = false
+		} else if !duplicated {
+			isDupl[collection[i]] = true
+		}
+	}
+
+	result := make(Slice, 0, len(collection)-len(isDupl))
+
+	for i := range collection {
+		if duplicated := isDupl[collection[i]]; !duplicated {
+			result = append(result, collection[i])
+		}
+	}
+
+	return result
+}
+
+// FindUniquesBy returns a slice with all the unique elements of the collection.
+// The order of result values is determined by the order they occur in the array. It accepts `iteratee` which is
+// invoked for each element in array to generate the criterion by which uniqueness is computed.
+func FindUniquesBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) Slice {
+	isDupl := make(map[U]bool, len(collection))
+
+	for i := range collection {
+		key := iteratee(collection[i])
+
+		duplicated, ok := isDupl[key]
+		if !ok {
+			isDupl[key] = false
+		} else if !duplicated {
+			isDupl[key] = true
+		}
+	}
+
+	result := make(Slice, 0, len(collection)-len(isDupl))
+
+	for i := range collection {
+		key := iteratee(collection[i])
+
+		if duplicated := isDupl[key]; !duplicated {
+			result = append(result, collection[i])
+		}
+	}
+
+	return result
+}
+
+// FindDuplicates returns a slice with the first occurrence of each duplicated elements of the collection.
+// The order of result values is determined by the order they occur in the collection.
+func FindDuplicates[T comparable, Slice ~[]T](collection Slice) Slice {
+	isDupl := make(map[T]bool, len(collection))
+
+	for i := range collection {
+		duplicated, ok := isDupl[collection[i]]
+		if !ok {
+			isDupl[collection[i]] = false
+		} else if !duplicated {
+			isDupl[collection[i]] = true
+		}
+	}
+
+	result := make(Slice, 0, len(collection)-len(isDupl))
+
+	for i := range collection {
+		if duplicated := isDupl[collection[i]]; duplicated {
+			result = append(result, collection[i])
+			isDupl[collection[i]] = false
+		}
+	}
+
+	return result
+}
+
+// FindDuplicatesBy returns a slice with the first occurrence of each duplicated elements of the collection.
+// The order of result values is determined by the order they occur in the array. It accepts `iteratee` which is
+// invoked for each element in array to generate the criterion by which uniqueness is computed.
+func FindDuplicatesBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) Slice {
+	isDupl := make(map[U]bool, len(collection))
+
+	for i := range collection {
+		key := iteratee(collection[i])
+
+		duplicated, ok := isDupl[key]
+		if !ok {
+			isDupl[key] = false
+		} else if !duplicated {
+			isDupl[key] = true
+		}
+	}
+
+	result := make(Slice, 0, len(collection)-len(isDupl))
+
+	for i := range collection {
+		key := iteratee(collection[i])
+
+		if duplicated := isDupl[key]; duplicated {
+			result = append(result, collection[i])
+			isDupl[key] = false
+		}
+	}
+
+	return result
+}
+
+// Min search the minimum value of a collection.
+// Returns zero value when the collection is empty.
+func Min[T constraints.Ordered](collection []T) T {
+	var min T
+
+	if len(collection) == 0 {
+		return min
+	}
+
+	min = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		item := collection[i]
+
+		if item < min {
+			min = item
+		}
+	}
+
+	return min
+}
+
+// MinIndex search the minimum value of a collection and the index of the minimum value.
+// Returns (zero value, -1) when the collection is empty.
+func MinIndex[T constraints.Ordered](collection []T) (T, int) {
+	var (
+		min   T
+		index int
+	)
+
+	if len(collection) == 0 {
+		return min, -1
+	}
+
+	min = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		item := collection[i]
+
+		if item < min {
+			min = item
+			index = i
+		}
+	}
+
+	return min, index
+}
+
+// MinBy search the minimum value of a collection using the given comparison function.
+// If several values of the collection are equal to the smallest value, returns the first such value.
+// Returns zero value when the collection is empty.
+func MinBy[T any](collection []T, comparison func(a T, b T) bool) T {
+	var min T
+
+	if len(collection) == 0 {
+		return min
+	}
+
+	min = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		item := collection[i]
+
+		if comparison(item, min) {
+			min = item
+		}
+	}
+
+	return min
+}
+
+// MinIndexBy search the minimum value of a collection using the given comparison function and the index of the minimum value.
+// If several values of the collection are equal to the smallest value, returns the first such value.
+// Returns (zero value, -1) when the collection is empty.
+func MinIndexBy[T any](collection []T, comparison func(a T, b T) bool) (T, int) {
+	var (
+		min   T
+		index int
+	)
+
+	if len(collection) == 0 {
+		return min, -1
+	}
+
+	min = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		item := collection[i]
+
+		if comparison(item, min) {
+			min = item
+			index = i
+		}
+	}
+
+	return min, index
+}
+
+// Earliest search the minimum time.Time of a collection.
+// Returns zero value when the collection is empty.
+func Earliest(times ...time.Time) time.Time {
+	var min time.Time
+
+	if len(times) == 0 {
+		return min
+	}
+
+	min = times[0]
+
+	for i := 1; i < len(times); i++ {
+		item := times[i]
+
+		if item.Before(min) {
+			min = item
+		}
+	}
+
+	return min
+}
+
+// EarliestBy search the minimum time.Time of a collection using the given iteratee function.
+// Returns zero value when the collection is empty.
+func EarliestBy[T any](collection []T, iteratee func(item T) time.Time) T {
+	var earliest T
+
+	if len(collection) == 0 {
+		return earliest
+	}
+
+	earliest = collection[0]
+	earliestTime := iteratee(collection[0])
+
+	for i := 1; i < len(collection); i++ {
+		itemTime := iteratee(collection[i])
+
+		if itemTime.Before(earliestTime) {
+			earliest = collection[i]
+			earliestTime = itemTime
+		}
+	}
+
+	return earliest
+}
+
+// Max searches the maximum value of a collection.
+// Returns zero value when the collection is empty.
+func Max[T constraints.Ordered](collection []T) T {
+	var max T
+
+	if len(collection) == 0 {
+		return max
+	}
+
+	max = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		item := collection[i]
+
+		if item > max {
+			max = item
+		}
+	}
+
+	return max
+}
+
+// MaxIndex searches the maximum value of a collection and the index of the maximum value.
+// Returns (zero value, -1) when the collection is empty.
+func MaxIndex[T constraints.Ordered](collection []T) (T, int) {
+	var (
+		max   T
+		index int
+	)
+
+	if len(collection) == 0 {
+		return max, -1
+	}
+
+	max = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		item := collection[i]
+
+		if item > max {
+			max = item
+			index = i
+		}
+	}
+
+	return max, index
+}
+
+// MaxBy search the maximum value of a collection using the given comparison function.
+// If several values of the collection are equal to the greatest value, returns the first such value.
+// Returns zero value when the collection is empty.
+func MaxBy[T any](collection []T, comparison func(a T, b T) bool) T {
+	var max T
+
+	if len(collection) == 0 {
+		return max
+	}
+
+	max = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		item := collection[i]
+
+		if comparison(item, max) {
+			max = item
+		}
+	}
+
+	return max
+}
+
+// MaxIndexBy search the maximum value of a collection using the given comparison function and the index of the maximum value.
+// If several values of the collection are equal to the greatest value, returns the first such value.
+// Returns (zero value, -1) when the collection is empty.
+func MaxIndexBy[T any](collection []T, comparison func(a T, b T) bool) (T, int) {
+	var (
+		max   T
+		index int
+	)
+
+	if len(collection) == 0 {
+		return max, -1
+	}
+
+	max = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		item := collection[i]
+
+		if comparison(item, max) {
+			max = item
+			index = i
+		}
+	}
+
+	return max, index
+}
+
+// Latest search the maximum time.Time of a collection.
+// Returns zero value when the collection is empty.
+func Latest(times ...time.Time) time.Time {
+	var max time.Time
+
+	if len(times) == 0 {
+		return max
+	}
+
+	max = times[0]
+
+	for i := 1; i < len(times); i++ {
+		item := times[i]
+
+		if item.After(max) {
+			max = item
+		}
+	}
+
+	return max
+}
+
+// LatestBy search the maximum time.Time of a collection using the given iteratee function.
+// Returns zero value when the collection is empty.
+func LatestBy[T any](collection []T, iteratee func(item T) time.Time) T {
+	var latest T
+
+	if len(collection) == 0 {
+		return latest
+	}
+
+	latest = collection[0]
+	latestTime := iteratee(collection[0])
+
+	for i := 1; i < len(collection); i++ {
+		itemTime := iteratee(collection[i])
+
+		if itemTime.After(latestTime) {
+			latest = collection[i]
+			latestTime = itemTime
+		}
+	}
+
+	return latest
+}
+
+// First returns the first element of a collection and check for availability of the first element.
+func First[T any](collection []T) (T, bool) {
+	length := len(collection)
+
+	if length == 0 {
+		var t T
+		return t, false
+	}
+
+	return collection[0], true
+}
+
+// FirstOrEmpty returns the first element of a collection or zero value if empty.
+func FirstOrEmpty[T any](collection []T) T {
+	i, _ := First(collection)
+	return i
+}
+
+// FirstOr returns the first element of a collection or the fallback value if empty.
+func FirstOr[T any](collection []T, fallback T) T {
+	i, ok := First(collection)
+	if !ok {
+		return fallback
+	}
+
+	return i
+}
+
+// Last returns the last element of a collection or error if empty.
+func Last[T any](collection []T) (T, bool) {
+	length := len(collection)
+
+	if length == 0 {
+		var t T
+		return t, false
+	}
+
+	return collection[length-1], true
+}
+
+// LastOrEmpty returns the last element of a collection or zero value if empty.
+func LastOrEmpty[T any](collection []T) T {
+	i, _ := Last(collection)
+	return i
+}
+
+// LastOr returns the last element of a collection or the fallback value if empty.
+func LastOr[T any](collection []T, fallback T) T {
+	i, ok := Last(collection)
+	if !ok {
+		return fallback
+	}
+
+	return i
+}
+
+// Nth returns the element at index `nth` of collection. If `nth` is negative, the nth element
+// from the end is returned. An error is returned when nth is out of slice bounds.
+func Nth[T any, N constraints.Integer](collection []T, nth N) (T, error) {
+	n := int(nth)
+	l := len(collection)
+	if n >= l || -n > l {
+		var t T
+		return t, fmt.Errorf("nth: %d out of slice bounds", n)
+	}
+
+	if n >= 0 {
+		return collection[n], nil
+	}
+	return collection[l+n], nil
+}
+
+// randomIntGenerator is a function that should return a random integer in the range [0, n)
+// where n is the parameter passed to the randomIntGenerator.
+type randomIntGenerator func(n int) int
+
+// Sample returns a random item from collection.
+func Sample[T any](collection []T) T {
+	result := SampleBy(collection, rand.IntN)
+	return result
+}
+
+// SampleBy returns a random item from collection, using randomIntGenerator as the random index generator.
+func SampleBy[T any](collection []T, randomIntGenerator randomIntGenerator) T {
+	size := len(collection)
+	if size == 0 {
+		return Empty[T]()
+	}
+	return collection[randomIntGenerator(size)]
+}
+
+// Samples returns N random unique items from collection.
+func Samples[T any, Slice ~[]T](collection Slice, count int) Slice {
+	results := SamplesBy(collection, count, rand.IntN)
+	return results
+}
+
+// SamplesBy returns N random unique items from collection, using randomIntGenerator as the random index generator.
+func SamplesBy[T any, Slice ~[]T](collection Slice, count int, randomIntGenerator randomIntGenerator) Slice {
+	size := len(collection)
+
+	copy := append(Slice{}, collection...)
+
+	results := Slice{}
+
+	for i := 0; i < size && i < count; i++ {
+		copyLength := size - i
+
+		index := randomIntGenerator(size - i)
+		results = append(results, copy[index])
+
+		// Removes element.
+		// It is faster to swap with last element and remove it.
+		copy[index] = copy[copyLength-1]
+		copy = copy[:copyLength-1]
+	}
+
+	return results
+}

vendor/github.com/samber/lo/func.go

@@ -0,0 +1,41 @@
+package lo
+
+// Partial returns new function that, when called, has its first argument set to the provided value.
+func Partial[T1, T2, R any](f func(a T1, b T2) R, arg1 T1) func(T2) R {
+	return func(t2 T2) R {
+		return f(arg1, t2)
+	}
+}
+
+// Partial1 returns new function that, when called, has its first argument set to the provided value.
+func Partial1[T1, T2, R any](f func(T1, T2) R, arg1 T1) func(T2) R {
+	return Partial(f, arg1)
+}
+
+// Partial2 returns new function that, when called, has its first argument set to the provided value.
+func Partial2[T1, T2, T3, R any](f func(T1, T2, T3) R, arg1 T1) func(T2, T3) R {
+	return func(t2 T2, t3 T3) R {
+		return f(arg1, t2, t3)
+	}
+}
+
+// Partial3 returns new function that, when called, has its first argument set to the provided value.
+func Partial3[T1, T2, T3, T4, R any](f func(T1, T2, T3, T4) R, arg1 T1) func(T2, T3, T4) R {
+	return func(t2 T2, t3 T3, t4 T4) R {
+		return f(arg1, t2, t3, t4)
+	}
+}
+
+// Partial4 returns new function that, when called, has its first argument set to the provided value.
+func Partial4[T1, T2, T3, T4, T5, R any](f func(T1, T2, T3, T4, T5) R, arg1 T1) func(T2, T3, T4, T5) R {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5) R {
+		return f(arg1, t2, t3, t4, t5)
+	}
+}
+
+// Partial5 returns new function that, when called, has its first argument set to the provided value
+func Partial5[T1, T2, T3, T4, T5, T6, R any](f func(T1, T2, T3, T4, T5, T6) R, arg1 T1) func(T2, T3, T4, T5, T6) R {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) R {
+		return f(arg1, t2, t3, t4, t5, t6)
+	}
+}

vendor/github.com/samber/lo/internal/constraints/constraints.go

@@ -0,0 +1,42 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package constraints defines a set of useful constraints to be used
+// with type parameters.
+package constraints
+
+// Signed is a constraint that permits any signed integer type.
+// If future releases of Go add new predeclared signed integer types,
+// this constraint will be modified to include them.
+type Signed interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64
+}
+
+// Unsigned is a constraint that permits any unsigned integer type.
+// If future releases of Go add new predeclared unsigned integer types,
+// this constraint will be modified to include them.
+type Unsigned interface {
+	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
+}
+
+// Integer is a constraint that permits any integer type.
+// If future releases of Go add new predeclared integer types,
+// this constraint will be modified to include them.
+type Integer interface {
+	Signed | Unsigned
+}
+
+// Float is a constraint that permits any floating-point type.
+// If future releases of Go add new predeclared floating-point types,
+// this constraint will be modified to include them.
+type Float interface {
+	~float32 | ~float64
+}
+
+// Complex is a constraint that permits any complex numeric type.
+// If future releases of Go add new predeclared complex numeric types,
+// this constraint will be modified to include them.
+type Complex interface {
+	~complex64 | ~complex128
+}

vendor/github.com/samber/lo/internal/constraints/ordered_go118.go

@@ -0,0 +1,11 @@
+//go:build !go1.21
+
+package constraints
+
+// Ordered is a constraint that permits any ordered type: any type
+// that supports the operators < <= >= >.
+// If future releases of Go add new ordered types,
+// this constraint will be modified to include them.
+type Ordered interface {
+	Integer | Float | ~string
+}

vendor/github.com/samber/lo/internal/constraints/ordered_go121.go

@@ -0,0 +1,9 @@
+//go:build go1.21
+
+package constraints
+
+import (
+	"cmp"
+)
+
+type Ordered = cmp.Ordered

vendor/github.com/samber/lo/internal/rand/ordered_go118.go

@@ -0,0 +1,26 @@
+//go:build !go1.22
+
+package rand
+
+import "math/rand"
+
+func Shuffle(n int, swap func(i, j int)) {
+	rand.Shuffle(n, swap)
+}
+
+func IntN(n int) int {
+	// bearer:disable go_gosec_crypto_weak_random
+	return rand.Intn(n)
+}
+
+func Int64() int64 {
+	// bearer:disable go_gosec_crypto_weak_random
+	n := rand.Int63()
+    
+	// bearer:disable go_gosec_crypto_weak_random
+	if rand.Intn(2) == 0 {
+		return -n
+	}
+
+	return n
+}

vendor/github.com/samber/lo/internal/rand/ordered_go122.go

@@ -0,0 +1,17 @@
+//go:build go1.22
+
+package rand
+
+import "math/rand/v2"
+
+func Shuffle(n int, swap func(i, j int)) {
+	rand.Shuffle(n, swap)
+}
+
+func IntN(n int) int {
+	return rand.IntN(n)
+}
+
+func Int64() int64 {
+	return rand.Int64()
+}

vendor/github.com/samber/lo/intersect.go

@@ -0,0 +1,227 @@
+package lo
+
+// Contains returns true if an element is present in a collection.
+func Contains[T comparable](collection []T, element T) bool {
+	for i := range collection {
+		if collection[i] == element {
+			return true
+		}
+	}
+
+	return false
+}
+
+// ContainsBy returns true if predicate function return true.
+func ContainsBy[T any](collection []T, predicate func(item T) bool) bool {
+	for i := range collection {
+		if predicate(collection[i]) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// Every returns true if all elements of a subset are contained into a collection or if the subset is empty.
+func Every[T comparable](collection []T, subset []T) bool {
+	for i := range subset {
+		if !Contains(collection, subset[i]) {
+			return false
+		}
+	}
+
+	return true
+}
+
+// EveryBy returns true if the predicate returns true for all elements in the collection or if the collection is empty.
+func EveryBy[T any](collection []T, predicate func(item T) bool) bool {
+	for i := range collection {
+		if !predicate(collection[i]) {
+			return false
+		}
+	}
+
+	return true
+}
+
+// Some returns true if at least 1 element of a subset is contained into a collection.
+// If the subset is empty Some returns false.
+func Some[T comparable](collection []T, subset []T) bool {
+	for i := range subset {
+		if Contains(collection, subset[i]) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// SomeBy returns true if the predicate returns true for any of the elements in the collection.
+// If the collection is empty SomeBy returns false.
+func SomeBy[T any](collection []T, predicate func(item T) bool) bool {
+	for i := range collection {
+		if predicate(collection[i]) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// None returns true if no element of a subset are contained into a collection or if the subset is empty.
+func None[T comparable](collection []T, subset []T) bool {
+	for i := range subset {
+		if Contains(collection, subset[i]) {
+			return false
+		}
+	}
+
+	return true
+}
+
+// NoneBy returns true if the predicate returns true for none of the elements in the collection or if the collection is empty.
+func NoneBy[T any](collection []T, predicate func(item T) bool) bool {
+	for i := range collection {
+		if predicate(collection[i]) {
+			return false
+		}
+	}
+
+	return true
+}
+
+// Intersect returns the intersection between two collections.
+func Intersect[T comparable, Slice ~[]T](list1 Slice, list2 Slice) Slice {
+	result := Slice{}
+	seen := map[T]struct{}{}
+
+	for i := range list1 {
+		seen[list1[i]] = struct{}{}
+	}
+
+	for i := range list2 {
+		if _, ok := seen[list2[i]]; ok {
+			result = append(result, list2[i])
+		}
+	}
+
+	return result
+}
+
+// Difference returns the difference between two collections.
+// The first value is the collection of element absent of list2.
+// The second value is the collection of element absent of list1.
+func Difference[T comparable, Slice ~[]T](list1 Slice, list2 Slice) (Slice, Slice) {
+	left := Slice{}
+	right := Slice{}
+
+	seenLeft := map[T]struct{}{}
+	seenRight := map[T]struct{}{}
+
+	for i := range list1 {
+		seenLeft[list1[i]] = struct{}{}
+	}
+
+	for i := range list2 {
+		seenRight[list2[i]] = struct{}{}
+	}
+
+	for i := range list1 {
+		if _, ok := seenRight[list1[i]]; !ok {
+			left = append(left, list1[i])
+		}
+	}
+
+	for i := range list2 {
+		if _, ok := seenLeft[list2[i]]; !ok {
+			right = append(right, list2[i])
+		}
+	}
+
+	return left, right
+}
+
+// Union returns all distinct elements from given collections.
+// result returns will not change the order of elements relatively.
+func Union[T comparable, Slice ~[]T](lists ...Slice) Slice {
+	var capLen int
+
+	for _, list := range lists {
+		capLen += len(list)
+	}
+
+	result := make(Slice, 0, capLen)
+	seen := make(map[T]struct{}, capLen)
+
+	for i := range lists {
+		for j := range lists[i] {
+			if _, ok := seen[lists[i][j]]; !ok {
+				seen[lists[i][j]] = struct{}{}
+				result = append(result, lists[i][j])
+			}
+		}
+	}
+
+	return result
+}
+
+// Without returns slice excluding all given values.
+func Without[T comparable, Slice ~[]T](collection Slice, exclude ...T) Slice {
+	excludeMap := make(map[T]struct{}, len(exclude))
+	for i := range exclude {
+		excludeMap[exclude[i]] = struct{}{}
+	}
+
+	result := make(Slice, 0, len(collection))
+	for i := range collection {
+		if _, ok := excludeMap[collection[i]]; !ok {
+			result = append(result, collection[i])
+		}
+	}
+	return result
+}
+
+// WithoutBy filters a slice by excluding elements whose extracted keys match any in the exclude list.
+// It returns a new slice containing only the elements whose keys are not in the exclude list.
+func WithoutBy[T any, K comparable](collection []T, iteratee func(item T) K, exclude ...K) []T {
+	excludeMap := make(map[K]struct{}, len(exclude))
+	for _, e := range exclude {
+		excludeMap[e] = struct{}{}
+	}
+
+	result := make([]T, 0, len(collection))
+	for _, item := range collection {
+		if _, ok := excludeMap[iteratee(item)]; !ok {
+			result = append(result, item)
+		}
+	}
+	return result
+}
+
+// WithoutEmpty returns slice excluding zero values.
+//
+// Deprecated: Use lo.Compact instead.
+func WithoutEmpty[T comparable, Slice ~[]T](collection Slice) Slice {
+	return Compact(collection)
+}
+
+// WithoutNth returns slice excluding nth value.
+func WithoutNth[T comparable, Slice ~[]T](collection Slice, nths ...int) Slice {
+	length := len(collection)
+
+	toRemove := make(map[int]struct{}, len(nths))
+	for i := range nths {
+		if nths[i] >= 0 && nths[i] <= length-1 {
+			toRemove[nths[i]] = struct{}{}
+		}
+	}
+
+	result := make(Slice, 0, len(collection))
+	for i := range collection {
+		if _, ok := toRemove[i]; !ok {
+			result = append(result, collection[i])
+		}
+	}
+
+	return result
+}

vendor/github.com/samber/lo/map.go

@@ -0,0 +1,327 @@
+package lo
+
+// Keys creates an array of the map keys.
+// Play: https://go.dev/play/p/Uu11fHASqrU
+func Keys[K comparable, V any](in ...map[K]V) []K {
+	size := 0
+	for i := range in {
+		size += len(in[i])
+	}
+	result := make([]K, 0, size)
+
+	for i := range in {
+		for k := range in[i] {
+			result = append(result, k)
+		}
+	}
+
+	return result
+}
+
+// UniqKeys creates an array of unique keys in the map.
+// Play: https://go.dev/play/p/TPKAb6ILdHk
+func UniqKeys[K comparable, V any](in ...map[K]V) []K {
+	size := 0
+	for i := range in {
+		size += len(in[i])
+	}
+
+	seen := make(map[K]struct{}, size)
+	result := make([]K, 0)
+
+	for i := range in {
+		for k := range in[i] {
+			if _, exists := seen[k]; exists {
+				continue
+			}
+			seen[k] = struct{}{}
+			result = append(result, k)
+		}
+	}
+
+	return result
+}
+
+// HasKey returns whether the given key exists.
+// Play: https://go.dev/play/p/aVwubIvECqS
+func HasKey[K comparable, V any](in map[K]V, key K) bool {
+	_, ok := in[key]
+	return ok
+}
+
+// Values creates an array of the map values.
+// Play: https://go.dev/play/p/nnRTQkzQfF6
+func Values[K comparable, V any](in ...map[K]V) []V {
+	size := 0
+	for i := range in {
+		size += len(in[i])
+	}
+	result := make([]V, 0, size)
+
+	for i := range in {
+		for k := range in[i] {
+			result = append(result, in[i][k])
+		}
+	}
+
+	return result
+}
+
+// UniqValues creates an array of unique values in the map.
+// Play: https://go.dev/play/p/nf6bXMh7rM3
+func UniqValues[K comparable, V comparable](in ...map[K]V) []V {
+	size := 0
+	for i := range in {
+		size += len(in[i])
+	}
+
+	seen := make(map[V]struct{}, size)
+	result := make([]V, 0)
+
+	for i := range in {
+		for k := range in[i] {
+			val := in[i][k]
+			if _, exists := seen[val]; exists {
+				continue
+			}
+			seen[val] = struct{}{}
+			result = append(result, val)
+		}
+	}
+
+	return result
+}
+
+// ValueOr returns the value of the given key or the fallback value if the key is not present.
+// Play: https://go.dev/play/p/bAq9mHErB4V
+func ValueOr[K comparable, V any](in map[K]V, key K, fallback V) V {
+	if v, ok := in[key]; ok {
+		return v
+	}
+	return fallback
+}
+
+// PickBy returns same map type filtered by given predicate.
+// Play: https://go.dev/play/p/kdg8GR_QMmf
+func PickBy[K comparable, V any, Map ~map[K]V](in Map, predicate func(key K, value V) bool) Map {
+	r := Map{}
+	for k := range in {
+		if predicate(k, in[k]) {
+			r[k] = in[k]
+		}
+	}
+	return r
+}
+
+// PickByKeys returns same map type filtered by given keys.
+// Play: https://go.dev/play/p/R1imbuci9qU
+func PickByKeys[K comparable, V any, Map ~map[K]V](in Map, keys []K) Map {
+	r := Map{}
+	for i := range keys {
+		if v, ok := in[keys[i]]; ok {
+			r[keys[i]] = v
+		}
+	}
+	return r
+}
+
+// PickByValues returns same map type filtered by given values.
+// Play: https://go.dev/play/p/1zdzSvbfsJc
+func PickByValues[K comparable, V comparable, Map ~map[K]V](in Map, values []V) Map {
+	r := Map{}
+	for k := range in {
+		if Contains(values, in[k]) {
+			r[k] = in[k]
+		}
+	}
+	return r
+}
+
+// OmitBy returns same map type filtered by given predicate.
+// Play: https://go.dev/play/p/EtBsR43bdsd
+func OmitBy[K comparable, V any, Map ~map[K]V](in Map, predicate func(key K, value V) bool) Map {
+	r := Map{}
+	for k := range in {
+		if !predicate(k, in[k]) {
+			r[k] = in[k]
+		}
+	}
+	return r
+}
+
+// OmitByKeys returns same map type filtered by given keys.
+// Play: https://go.dev/play/p/t1QjCrs-ysk
+func OmitByKeys[K comparable, V any, Map ~map[K]V](in Map, keys []K) Map {
+	r := Map{}
+	for k := range in {
+		r[k] = in[k]
+	}
+	for i := range keys {
+		delete(r, keys[i])
+	}
+	return r
+}
+
+// OmitByValues returns same map type filtered by given values.
+// Play: https://go.dev/play/p/9UYZi-hrs8j
+func OmitByValues[K comparable, V comparable, Map ~map[K]V](in Map, values []V) Map {
+	r := Map{}
+	for k := range in {
+		if !Contains(values, in[k]) {
+			r[k] = in[k]
+		}
+	}
+	return r
+}
+
+// Entries transforms a map into array of key/value pairs.
+// Play:
+func Entries[K comparable, V any](in map[K]V) []Entry[K, V] {
+	entries := make([]Entry[K, V], 0, len(in))
+
+	for k := range in {
+		entries = append(entries, Entry[K, V]{
+			Key:   k,
+			Value: in[k],
+		})
+	}
+
+	return entries
+}
+
+// ToPairs transforms a map into array of key/value pairs.
+// Alias of Entries().
+// Play: https://go.dev/play/p/3Dhgx46gawJ
+func ToPairs[K comparable, V any](in map[K]V) []Entry[K, V] {
+	return Entries(in)
+}
+
+// FromEntries transforms an array of key/value pairs into a map.
+// Play: https://go.dev/play/p/oIr5KHFGCEN
+func FromEntries[K comparable, V any](entries []Entry[K, V]) map[K]V {
+	out := make(map[K]V, len(entries))
+
+	for i := range entries {
+		out[entries[i].Key] = entries[i].Value
+	}
+
+	return out
+}
+
+// FromPairs transforms an array of key/value pairs into a map.
+// Alias of FromEntries().
+// Play: https://go.dev/play/p/oIr5KHFGCEN
+func FromPairs[K comparable, V any](entries []Entry[K, V]) map[K]V {
+	return FromEntries(entries)
+}
+
+// Invert creates a map composed of the inverted keys and values. If map
+// contains duplicate values, subsequent values overwrite property assignments
+// of previous values.
+// Play: https://go.dev/play/p/rFQ4rak6iA1
+func Invert[K comparable, V comparable](in map[K]V) map[V]K {
+	out := make(map[V]K, len(in))
+
+	for k := range in {
+		out[in[k]] = k
+	}
+
+	return out
+}
+
+// Assign merges multiple maps from left to right.
+// Play: https://go.dev/play/p/VhwfJOyxf5o
+func Assign[K comparable, V any, Map ~map[K]V](maps ...Map) Map {
+	count := 0
+	for i := range maps {
+		count += len(maps[i])
+	}
+
+	out := make(Map, count)
+	for i := range maps {
+		for k := range maps[i] {
+			out[k] = maps[i][k]
+		}
+	}
+
+	return out
+}
+
+// ChunkEntries splits a map into an array of elements in groups of a length equal to its size. If the map cannot be split evenly,
+// the final chunk will contain the remaining elements.
+func ChunkEntries[K comparable, V any](m map[K]V, size int) []map[K]V {
+	if size <= 0 {
+		panic("The chunk size must be greater than 0")
+	}
+
+	count := len(m)
+	if count == 0 {
+		return []map[K]V{}
+	}
+
+	chunksNum := count / size
+	if count%size != 0 {
+		chunksNum += 1
+	}
+
+	result := make([]map[K]V, 0, chunksNum)
+
+	for k, v := range m {
+		if len(result) == 0 || len(result[len(result)-1]) == size {
+			result = append(result, make(map[K]V, size))
+		}
+
+		result[len(result)-1][k] = v
+	}
+
+	return result
+}
+
+// MapKeys manipulates a map keys and transforms it to a map of another type.
+// Play: https://go.dev/play/p/9_4WPIqOetJ
+func MapKeys[K comparable, V any, R comparable](in map[K]V, iteratee func(value V, key K) R) map[R]V {
+	result := make(map[R]V, len(in))
+
+	for k := range in {
+		result[iteratee(in[k], k)] = in[k]
+	}
+
+	return result
+}
+
+// MapValues manipulates a map values and transforms it to a map of another type.
+// Play: https://go.dev/play/p/T_8xAfvcf0W
+func MapValues[K comparable, V any, R any](in map[K]V, iteratee func(value V, key K) R) map[K]R {
+	result := make(map[K]R, len(in))
+
+	for k := range in {
+		result[k] = iteratee(in[k], k)
+	}
+
+	return result
+}
+
+// MapEntries manipulates a map entries and transforms it to a map of another type.
+// Play: https://go.dev/play/p/VuvNQzxKimT
+func MapEntries[K1 comparable, V1 any, K2 comparable, V2 any](in map[K1]V1, iteratee func(key K1, value V1) (K2, V2)) map[K2]V2 {
+	result := make(map[K2]V2, len(in))
+
+	for k1 := range in {
+		k2, v2 := iteratee(k1, in[k1])
+		result[k2] = v2
+	}
+
+	return result
+}
+
+// MapToSlice transforms a map into a slice based on specific iteratee
+// Play: https://go.dev/play/p/ZuiCZpDt6LD
+func MapToSlice[K comparable, V any, R any](in map[K]V, iteratee func(key K, value V) R) []R {
+	result := make([]R, 0, len(in))
+
+	for k := range in {
+		result = append(result, iteratee(k, in[k]))
+	}
+
+	return result
+}

vendor/github.com/samber/lo/math.go

@@ -0,0 +1,142 @@
+package lo
+
+import (
+	"github.com/samber/lo/internal/constraints"
+)
+
+// Range creates an array of numbers (positive and/or negative) with given length.
+// Play: https://go.dev/play/p/0r6VimXAi9H
+func Range(elementNum int) []int {
+	length := If(elementNum < 0, -elementNum).Else(elementNum)
+	result := make([]int, length)
+	step := If(elementNum < 0, -1).Else(1)
+	for i, j := 0, 0; i < length; i, j = i+1, j+step {
+		result[i] = j
+	}
+	return result
+}
+
+// RangeFrom creates an array of numbers from start with specified length.
+// Play: https://go.dev/play/p/0r6VimXAi9H
+func RangeFrom[T constraints.Integer | constraints.Float](start T, elementNum int) []T {
+	length := If(elementNum < 0, -elementNum).Else(elementNum)
+	result := make([]T, length)
+	step := If(elementNum < 0, -1).Else(1)
+	for i, j := 0, start; i < length; i, j = i+1, j+T(step) {
+		result[i] = j
+	}
+	return result
+}
+
+// RangeWithSteps creates an array of numbers (positive and/or negative) progressing from start up to, but not including end.
+// step set to zero will return empty array.
+// Play: https://go.dev/play/p/0r6VimXAi9H
+func RangeWithSteps[T constraints.Integer | constraints.Float](start, end, step T) []T {
+	result := []T{}
+	if start == end || step == 0 {
+		return result
+	}
+	if start < end {
+		if step < 0 {
+			return result
+		}
+		for i := start; i < end; i += step {
+			result = append(result, i)
+		}
+		return result
+	}
+	if step > 0 {
+		return result
+	}
+	for i := start; i > end; i += step {
+		result = append(result, i)
+	}
+	return result
+}
+
+// Clamp clamps number within the inclusive lower and upper bounds.
+// Play: https://go.dev/play/p/RU4lJNC2hlI
+func Clamp[T constraints.Ordered](value T, min T, max T) T {
+	if value < min {
+		return min
+	} else if value > max {
+		return max
+	}
+	return value
+}
+
+// Sum sums the values in a collection. If collection is empty 0 is returned.
+// Play: https://go.dev/play/p/upfeJVqs4Bt
+func Sum[T constraints.Float | constraints.Integer | constraints.Complex](collection []T) T {
+	var sum T = 0
+	for i := range collection {
+		sum += collection[i]
+	}
+	return sum
+}
+
+// SumBy summarizes the values in a collection using the given return value from the iteration function. If collection is empty 0 is returned.
+// Play: https://go.dev/play/p/Dz_a_7jN_ca
+func SumBy[T any, R constraints.Float | constraints.Integer | constraints.Complex](collection []T, iteratee func(item T) R) R {
+	var sum R = 0
+	for i := range collection {
+		sum = sum + iteratee(collection[i])
+	}
+	return sum
+}
+
+// Product gets the product of the values in a collection. If collection is empty 0 is returned.
+// Play: https://go.dev/play/p/2_kjM_smtAH
+func Product[T constraints.Float | constraints.Integer | constraints.Complex](collection []T) T {
+	if collection == nil {
+		return 1
+	}
+
+	if len(collection) == 0 {
+		return 1
+	}
+
+	var product T = 1
+	for i := range collection {
+		product *= collection[i]
+	}
+	return product
+}
+
+// ProductBy summarizes the values in a collection using the given return value from the iteration function. If collection is empty 0 is returned.
+// Play: https://go.dev/play/p/wadzrWr9Aer
+func ProductBy[T any, R constraints.Float | constraints.Integer | constraints.Complex](collection []T, iteratee func(item T) R) R {
+	if collection == nil {
+		return 1
+	}
+
+	if len(collection) == 0 {
+		return 1
+	}
+
+	var product R = 1
+	for i := range collection {
+		product = product * iteratee(collection[i])
+	}
+	return product
+}
+
+// Mean calculates the mean of a collection of numbers.
+func Mean[T constraints.Float | constraints.Integer](collection []T) T {
+	var length = T(len(collection))
+	if length == 0 {
+		return 0
+	}
+	var sum = Sum(collection)
+	return sum / length
+}
+
+// MeanBy calculates the mean of a collection of numbers using the given return value from the iteration function.
+func MeanBy[T any, R constraints.Float | constraints.Integer](collection []T, iteratee func(item T) R) R {
+	var length = R(len(collection))
+	if length == 0 {
+		return 0
+	}
+	var sum = SumBy(collection, iteratee)
+	return sum / length
+}

vendor/github.com/samber/lo/mutable/slice.go

@@ -0,0 +1,23 @@
+package mutable
+
+import "github.com/samber/lo/internal/rand"
+
+// Shuffle returns an array of shuffled values. Uses the Fisher-Yates shuffle algorithm.
+// Play: https://go.dev/play/p/ZTGG7OUCdnp
+func Shuffle[T any, Slice ~[]T](collection Slice) {
+	rand.Shuffle(len(collection), func(i, j int) {
+		collection[i], collection[j] = collection[j], collection[i]
+	})
+}
+
+// Reverse reverses array so that the first element becomes the last, the second element becomes the second to last, and so on.
+// Play: https://go.dev/play/p/iv2e9jslfBM
+func Reverse[T any, Slice ~[]T](collection Slice) {
+	length := len(collection)
+	half := length / 2
+
+	for i := 0; i < half; i = i + 1 {
+		j := length - 1 - i
+		collection[i], collection[j] = collection[j], collection[i]
+	}
+}

vendor/github.com/samber/lo/retry.go

@@ -0,0 +1,375 @@
+package lo
+
+import (
+	"sync"
+	"time"
+)
+
+type debounce struct {
+	after     time.Duration
+	mu        *sync.Mutex
+	timer     *time.Timer
+	done      bool
+	callbacks []func()
+}
+
+func (d *debounce) reset() {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	if d.done {
+		return
+	}
+
+	if d.timer != nil {
+		d.timer.Stop()
+	}
+
+	d.timer = time.AfterFunc(d.after, func() {
+		for i := range d.callbacks {
+			d.callbacks[i]()
+		}
+	})
+}
+
+func (d *debounce) cancel() {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	if d.timer != nil {
+		d.timer.Stop()
+		d.timer = nil
+	}
+
+	d.done = true
+}
+
+// NewDebounce creates a debounced instance that delays invoking functions given until after wait milliseconds have elapsed.
+// Play: https://go.dev/play/p/mz32VMK2nqe
+func NewDebounce(duration time.Duration, f ...func()) (func(), func()) {
+	d := &debounce{
+		after:     duration,
+		mu:        new(sync.Mutex),
+		timer:     nil,
+		done:      false,
+		callbacks: f,
+	}
+
+	return func() {
+		d.reset()
+	}, d.cancel
+}
+
+type debounceByItem struct {
+	mu    *sync.Mutex
+	timer *time.Timer
+	count int
+}
+
+type debounceBy[T comparable] struct {
+	after     time.Duration
+	mu        *sync.Mutex
+	items     map[T]*debounceByItem
+	callbacks []func(key T, count int)
+}
+
+func (d *debounceBy[T]) reset(key T) {
+	d.mu.Lock()
+	if _, ok := d.items[key]; !ok {
+		d.items[key] = &debounceByItem{
+			mu:    new(sync.Mutex),
+			timer: nil,
+		}
+	}
+
+	item := d.items[key]
+
+	d.mu.Unlock()
+
+	item.mu.Lock()
+	defer item.mu.Unlock()
+
+	item.count++
+
+	if item.timer != nil {
+		item.timer.Stop()
+	}
+
+	item.timer = time.AfterFunc(d.after, func() {
+		item.mu.Lock()
+		count := item.count
+		item.count = 0
+		item.mu.Unlock()
+
+		for i := range d.callbacks {
+			d.callbacks[i](key, count)
+		}
+	})
+}
+
+func (d *debounceBy[T]) cancel(key T) {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	if item, ok := d.items[key]; ok {
+		item.mu.Lock()
+
+		if item.timer != nil {
+			item.timer.Stop()
+			item.timer = nil
+		}
+
+		item.mu.Unlock()
+
+		delete(d.items, key)
+	}
+}
+
+// NewDebounceBy creates a debounced instance for each distinct key, that delays invoking functions given until after wait milliseconds have elapsed.
+// Play: https://go.dev/play/p/d3Vpt6pxhY8
+func NewDebounceBy[T comparable](duration time.Duration, f ...func(key T, count int)) (func(key T), func(key T)) {
+	d := &debounceBy[T]{
+		after:     duration,
+		mu:        new(sync.Mutex),
+		items:     map[T]*debounceByItem{},
+		callbacks: f,
+	}
+
+	return func(key T) {
+		d.reset(key)
+	}, d.cancel
+}
+
+// Attempt invokes a function N times until it returns valid output. Returns either the caught error or nil.
+// When the first argument is less than `1`, the function runs until a successful response is returned.
+// Play: https://go.dev/play/p/3ggJZ2ZKcMj
+func Attempt(maxIteration int, f func(index int) error) (int, error) {
+	var err error
+
+	for i := 0; maxIteration <= 0 || i < maxIteration; i++ {
+		// for retries >= 0 {
+		err = f(i)
+		if err == nil {
+			return i + 1, nil
+		}
+	}
+
+	return maxIteration, err
+}
+
+// AttemptWithDelay invokes a function N times until it returns valid output,
+// with a pause between each call. Returns either the caught error or nil.
+// When the first argument is less than `1`, the function runs until a successful
+// response is returned.
+// Play: https://go.dev/play/p/tVs6CygC7m1
+func AttemptWithDelay(maxIteration int, delay time.Duration, f func(index int, duration time.Duration) error) (int, time.Duration, error) {
+	var err error
+
+	start := time.Now()
+
+	for i := 0; maxIteration <= 0 || i < maxIteration; i++ {
+		err = f(i, time.Since(start))
+		if err == nil {
+			return i + 1, time.Since(start), nil
+		}
+
+		if maxIteration <= 0 || i+1 < maxIteration {
+			time.Sleep(delay)
+		}
+	}
+
+	return maxIteration, time.Since(start), err
+}
+
+// AttemptWhile invokes a function N times until it returns valid output.
+// Returns either the caught error or nil, along with a bool value to determine
+// whether the function should be invoked again. It will terminate the invoke
+// immediately if the second return value is false. When the first
+// argument is less than `1`, the function runs until a successful response is
+// returned.
+func AttemptWhile(maxIteration int, f func(int) (error, bool)) (int, error) {
+	var err error
+	var shouldContinueInvoke bool
+
+	for i := 0; maxIteration <= 0 || i < maxIteration; i++ {
+		// for retries >= 0 {
+		err, shouldContinueInvoke = f(i)
+		if !shouldContinueInvoke { // if shouldContinueInvoke is false, then return immediately
+			return i + 1, err
+		}
+		if err == nil {
+			return i + 1, nil
+		}
+	}
+
+	return maxIteration, err
+}
+
+// AttemptWhileWithDelay invokes a function N times until it returns valid output,
+// with a pause between each call. Returns either the caught error or nil, along
+// with a bool value to determine whether the function should be invoked again.
+// It will terminate the invoke immediately if the second return value is false.
+// When the first argument is less than `1`, the function runs until a successful
+// response is returned.
+func AttemptWhileWithDelay(maxIteration int, delay time.Duration, f func(int, time.Duration) (error, bool)) (int, time.Duration, error) {
+	var err error
+	var shouldContinueInvoke bool
+
+	start := time.Now()
+
+	for i := 0; maxIteration <= 0 || i < maxIteration; i++ {
+		err, shouldContinueInvoke = f(i, time.Since(start))
+		if !shouldContinueInvoke { // if shouldContinueInvoke is false, then return immediately
+			return i + 1, time.Since(start), err
+		}
+		if err == nil {
+			return i + 1, time.Since(start), nil
+		}
+
+		if maxIteration <= 0 || i+1 < maxIteration {
+			time.Sleep(delay)
+		}
+	}
+
+	return maxIteration, time.Since(start), err
+}
+
+type transactionStep[T any] struct {
+	exec       func(T) (T, error)
+	onRollback func(T) T
+}
+
+// NewTransaction instantiate a new transaction.
+func NewTransaction[T any]() *Transaction[T] {
+	return &Transaction[T]{
+		steps: []transactionStep[T]{},
+	}
+}
+
+// Transaction implements a Saga pattern
+type Transaction[T any] struct {
+	steps []transactionStep[T]
+}
+
+// Then adds a step to the chain of callbacks. It returns the same Transaction.
+func (t *Transaction[T]) Then(exec func(T) (T, error), onRollback func(T) T) *Transaction[T] {
+	t.steps = append(t.steps, transactionStep[T]{
+		exec:       exec,
+		onRollback: onRollback,
+	})
+
+	return t
+}
+
+// Process runs the Transaction steps and rollbacks in case of errors.
+func (t *Transaction[T]) Process(state T) (T, error) {
+	var i int
+	var err error
+
+	for i < len(t.steps) {
+		state, err = t.steps[i].exec(state)
+		if err != nil {
+			break
+		}
+
+		i++
+	}
+
+	if err == nil {
+		return state, nil
+	}
+
+	for i > 0 {
+		i--
+		state = t.steps[i].onRollback(state)
+	}
+
+	return state, err
+}
+
+// @TODO: single mutex per key ?
+type throttleBy[T comparable] struct {
+	mu         *sync.Mutex
+	timer      *time.Timer
+	interval   time.Duration
+	callbacks  []func(key T)
+	countLimit int
+	count      map[T]int
+}
+
+func (th *throttleBy[T]) throttledFunc(key T) {
+	th.mu.Lock()
+	defer th.mu.Unlock()
+
+	if _, ok := th.count[key]; !ok {
+		th.count[key] = 0
+	}
+
+	if th.count[key] < th.countLimit {
+		th.count[key]++
+
+		for _, f := range th.callbacks {
+			f(key)
+		}
+
+	}
+	if th.timer == nil {
+		th.timer = time.AfterFunc(th.interval, func() {
+			th.reset()
+		})
+	}
+}
+
+func (th *throttleBy[T]) reset() {
+	th.mu.Lock()
+	defer th.mu.Unlock()
+
+	if th.timer != nil {
+		th.timer.Stop()
+	}
+
+	th.count = map[T]int{}
+	th.timer = nil
+}
+
+// NewThrottle creates a throttled instance that invokes given functions only once in every interval.
+// This returns 2 functions, First one is throttled function and Second one is a function to reset interval
+func NewThrottle(interval time.Duration, f ...func()) (throttle func(), reset func()) {
+	return NewThrottleWithCount(interval, 1, f...)
+}
+
+// NewThrottleWithCount is NewThrottle with count limit, throttled function will be invoked count times in every interval.
+func NewThrottleWithCount(interval time.Duration, count int, f ...func()) (throttle func(), reset func()) {
+	callbacks := Map(f, func(item func(), _ int) func(struct{}) {
+		return func(struct{}) {
+			item()
+		}
+	})
+
+	throttleFn, reset := NewThrottleByWithCount[struct{}](interval, count, callbacks...)
+	return func() {
+		throttleFn(struct{}{})
+	}, reset
+}
+
+// NewThrottleBy creates a throttled instance that invokes given functions only once in every interval.
+// This returns 2 functions, First one is throttled function and Second one is a function to reset interval
+func NewThrottleBy[T comparable](interval time.Duration, f ...func(key T)) (throttle func(key T), reset func()) {
+	return NewThrottleByWithCount[T](interval, 1, f...)
+}
+
+// NewThrottleByWithCount is NewThrottleBy with count limit, throttled function will be invoked count times in every interval.
+func NewThrottleByWithCount[T comparable](interval time.Duration, count int, f ...func(key T)) (throttle func(key T), reset func()) {
+	if count <= 0 {
+		count = 1
+	}
+
+	th := &throttleBy[T]{
+		mu:         new(sync.Mutex),
+		interval:   interval,
+		callbacks:  f,
+		countLimit: count,
+		count:      map[T]int{},
+	}
+	return th.throttledFunc, th.reset
+}

vendor/github.com/samber/lo/slice.go

@@ -0,0 +1,732 @@
+package lo
+
+import (
+	"sort"
+
+	"github.com/samber/lo/internal/constraints"
+	"github.com/samber/lo/mutable"
+)
+
+// Filter iterates over elements of collection, returning an array of all elements predicate returns truthy for.
+// Play: https://go.dev/play/p/Apjg3WeSi7K
+func Filter[T any, Slice ~[]T](collection Slice, predicate func(item T, index int) bool) Slice {
+	result := make(Slice, 0, len(collection))
+
+	for i := range collection {
+		if predicate(collection[i], i) {
+			result = append(result, collection[i])
+		}
+	}
+
+	return result
+}
+
+// Map manipulates a slice and transforms it to a slice of another type.
+// Play: https://go.dev/play/p/OkPcYAhBo0D
+func Map[T any, R any](collection []T, iteratee func(item T, index int) R) []R {
+	result := make([]R, len(collection))
+
+	for i := range collection {
+		result[i] = iteratee(collection[i], i)
+	}
+
+	return result
+}
+
+// UniqMap manipulates a slice and transforms it to a slice of another type with unique values.
+func UniqMap[T any, R comparable](collection []T, iteratee func(item T, index int) R) []R {
+	result := make([]R, 0, len(collection))
+	seen := make(map[R]struct{}, len(collection))
+
+	for i, item := range collection {
+		r := iteratee(item, i)
+		if _, ok := seen[r]; !ok {
+			result = append(result, r)
+			seen[r] = struct{}{}
+		}
+	}
+	return result
+}
+
+// FilterMap returns a slice which obtained after both filtering and mapping using the given callback function.
+// The callback function should return two values:
+//   - the result of the mapping operation and
+//   - whether the result element should be included or not.
+//
+// Play: https://go.dev/play/p/-AuYXfy7opz
+func FilterMap[T any, R any](collection []T, callback func(item T, index int) (R, bool)) []R {
+	result := []R{}
+
+	for i := range collection {
+		if r, ok := callback(collection[i], i); ok {
+			result = append(result, r)
+		}
+	}
+
+	return result
+}
+
+// FlatMap manipulates a slice and transforms and flattens it to a slice of another type.
+// The transform function can either return a slice or a `nil`, and in the `nil` case
+// no value is added to the final slice.
+// Play: https://go.dev/play/p/YSoYmQTA8-U
+func FlatMap[T any, R any](collection []T, iteratee func(item T, index int) []R) []R {
+	result := make([]R, 0, len(collection))
+
+	for i := range collection {
+		result = append(result, iteratee(collection[i], i)...)
+	}
+
+	return result
+}
+
+// Reduce reduces collection to a value which is the accumulated result of running each element in collection
+// through accumulator, where each successive invocation is supplied the return value of the previous.
+// Play: https://go.dev/play/p/R4UHXZNaaUG
+func Reduce[T any, R any](collection []T, accumulator func(agg R, item T, index int) R, initial R) R {
+	for i := range collection {
+		initial = accumulator(initial, collection[i], i)
+	}
+
+	return initial
+}
+
+// ReduceRight helper is like Reduce except that it iterates over elements of collection from right to left.
+// Play: https://go.dev/play/p/Fq3W70l7wXF
+func ReduceRight[T any, R any](collection []T, accumulator func(agg R, item T, index int) R, initial R) R {
+	for i := len(collection) - 1; i >= 0; i-- {
+		initial = accumulator(initial, collection[i], i)
+	}
+
+	return initial
+}
+
+// ForEach iterates over elements of collection and invokes iteratee for each element.
+// Play: https://go.dev/play/p/oofyiUPRf8t
+func ForEach[T any](collection []T, iteratee func(item T, index int)) {
+	for i := range collection {
+		iteratee(collection[i], i)
+	}
+}
+
+// ForEachWhile iterates over elements of collection and invokes iteratee for each element
+// collection return value decide to continue or break, like do while().
+// Play: https://go.dev/play/p/QnLGt35tnow
+func ForEachWhile[T any](collection []T, iteratee func(item T, index int) (goon bool)) {
+	for i := range collection {
+		if !iteratee(collection[i], i) {
+			break
+		}
+	}
+}
+
+// Times invokes the iteratee n times, returning an array of the results of each invocation.
+// The iteratee is invoked with index as argument.
+// Play: https://go.dev/play/p/vgQj3Glr6lT
+func Times[T any](count int, iteratee func(index int) T) []T {
+	result := make([]T, count)
+
+	for i := 0; i < count; i++ {
+		result[i] = iteratee(i)
+	}
+
+	return result
+}
+
+// Uniq returns a duplicate-free version of an array, in which only the first occurrence of each element is kept.
+// The order of result values is determined by the order they occur in the array.
+// Play: https://go.dev/play/p/DTzbeXZ6iEN
+func Uniq[T comparable, Slice ~[]T](collection Slice) Slice {
+	result := make(Slice, 0, len(collection))
+	seen := make(map[T]struct{}, len(collection))
+
+	for i := range collection {
+		if _, ok := seen[collection[i]]; ok {
+			continue
+		}
+
+		seen[collection[i]] = struct{}{}
+		result = append(result, collection[i])
+	}
+
+	return result
+}
+
+// UniqBy returns a duplicate-free version of an array, in which only the first occurrence of each element is kept.
+// The order of result values is determined by the order they occur in the array. It accepts `iteratee` which is
+// invoked for each element in array to generate the criterion by which uniqueness is computed.
+// Play: https://go.dev/play/p/g42Z3QSb53u
+func UniqBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) Slice {
+	result := make(Slice, 0, len(collection))
+	seen := make(map[U]struct{}, len(collection))
+
+	for i := range collection {
+		key := iteratee(collection[i])
+
+		if _, ok := seen[key]; ok {
+			continue
+		}
+
+		seen[key] = struct{}{}
+		result = append(result, collection[i])
+	}
+
+	return result
+}
+
+// GroupBy returns an object composed of keys generated from the results of running each element of collection through iteratee.
+// Play: https://go.dev/play/p/XnQBd_v6brd
+func GroupBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) map[U]Slice {
+	result := map[U]Slice{}
+
+	for i := range collection {
+		key := iteratee(collection[i])
+
+		result[key] = append(result[key], collection[i])
+	}
+
+	return result
+}
+
+// Chunk returns an array of elements split into groups the length of size. If array can't be split evenly,
+// the final chunk will be the remaining elements.
+// Play: https://go.dev/play/p/EeKl0AuTehH
+func Chunk[T any, Slice ~[]T](collection Slice, size int) []Slice {
+	if size <= 0 {
+		panic("Second parameter must be greater than 0")
+	}
+
+	chunksNum := len(collection) / size
+	if len(collection)%size != 0 {
+		chunksNum += 1
+	}
+
+	result := make([]Slice, 0, chunksNum)
+
+	for i := 0; i < chunksNum; i++ {
+		last := (i + 1) * size
+		if last > len(collection) {
+			last = len(collection)
+		}
+		result = append(result, collection[i*size:last:last])
+	}
+
+	return result
+}
+
+// PartitionBy returns an array of elements split into groups. The order of grouped values is
+// determined by the order they occur in collection. The grouping is generated from the results
+// of running each element of collection through iteratee.
+// Play: https://go.dev/play/p/NfQ_nGjkgXW
+func PartitionBy[T any, K comparable, Slice ~[]T](collection Slice, iteratee func(item T) K) []Slice {
+	result := []Slice{}
+	seen := map[K]int{}
+
+	for i := range collection {
+		key := iteratee(collection[i])
+
+		resultIndex, ok := seen[key]
+		if !ok {
+			resultIndex = len(result)
+			seen[key] = resultIndex
+			result = append(result, Slice{})
+		}
+
+		result[resultIndex] = append(result[resultIndex], collection[i])
+	}
+
+	return result
+
+	// unordered:
+	// groups := GroupBy[T, K](collection, iteratee)
+	// return Values[K, []T](groups)
+}
+
+// Flatten returns an array a single level deep.
+// Play: https://go.dev/play/p/rbp9ORaMpjw
+func Flatten[T any, Slice ~[]T](collection []Slice) Slice {
+	totalLen := 0
+	for i := range collection {
+		totalLen += len(collection[i])
+	}
+
+	result := make(Slice, 0, totalLen)
+	for i := range collection {
+		result = append(result, collection[i]...)
+	}
+
+	return result
+}
+
+// Interleave round-robin alternating input slices and sequentially appending value at index into result
+// Play: https://go.dev/play/p/-RJkTLQEDVt
+func Interleave[T any, Slice ~[]T](collections ...Slice) Slice {
+	if len(collections) == 0 {
+		return Slice{}
+	}
+
+	maxSize := 0
+	totalSize := 0
+	for i := range collections {
+		size := len(collections[i])
+		totalSize += size
+		if size > maxSize {
+			maxSize = size
+		}
+	}
+
+	if maxSize == 0 {
+		return Slice{}
+	}
+
+	result := make(Slice, totalSize)
+
+	resultIdx := 0
+	for i := 0; i < maxSize; i++ {
+		for j := range collections {
+			if len(collections[j])-1 < i {
+				continue
+			}
+
+			result[resultIdx] = collections[j][i]
+			resultIdx++
+		}
+	}
+
+	return result
+}
+
+// Shuffle returns an array of shuffled values. Uses the Fisher-Yates shuffle algorithm.
+// Play: https://go.dev/play/p/ZTGG7OUCdnp
+//
+// Deprecated: use mutable.Shuffle() instead.
+func Shuffle[T any, Slice ~[]T](collection Slice) Slice {
+	mutable.Shuffle(collection)
+	return collection
+}
+
+// Reverse reverses array so that the first element becomes the last, the second element becomes the second to last, and so on.
+// Play: https://go.dev/play/p/iv2e9jslfBM
+//
+// Deprecated: use mutable.Reverse() instead.
+func Reverse[T any, Slice ~[]T](collection Slice) Slice {
+	mutable.Reverse(collection)
+	return collection
+}
+
+// Fill fills elements of array with `initial` value.
+// Play: https://go.dev/play/p/VwR34GzqEub
+func Fill[T Clonable[T], Slice ~[]T](collection Slice, initial T) Slice {
+	result := make(Slice, 0, len(collection))
+
+	for range collection {
+		result = append(result, initial.Clone())
+	}
+
+	return result
+}
+
+// Repeat builds a slice with N copies of initial value.
+// Play: https://go.dev/play/p/g3uHXbmc3b6
+func Repeat[T Clonable[T]](count int, initial T) []T {
+	result := make([]T, 0, count)
+
+	for i := 0; i < count; i++ {
+		result = append(result, initial.Clone())
+	}
+
+	return result
+}
+
+// RepeatBy builds a slice with values returned by N calls of callback.
+// Play: https://go.dev/play/p/ozZLCtX_hNU
+func RepeatBy[T any](count int, predicate func(index int) T) []T {
+	result := make([]T, 0, count)
+
+	for i := 0; i < count; i++ {
+		result = append(result, predicate(i))
+	}
+
+	return result
+}
+
+// KeyBy transforms a slice or an array of structs to a map based on a pivot callback.
+// Play: https://go.dev/play/p/mdaClUAT-zZ
+func KeyBy[K comparable, V any](collection []V, iteratee func(item V) K) map[K]V {
+	result := make(map[K]V, len(collection))
+
+	for i := range collection {
+		k := iteratee(collection[i])
+		result[k] = collection[i]
+	}
+
+	return result
+}
+
+// Associate returns a map containing key-value pairs provided by transform function applied to elements of the given slice.
+// If any of two pairs would have the same key the last one gets added to the map.
+// The order of keys in returned map is not specified and is not guaranteed to be the same from the original array.
+// Play: https://go.dev/play/p/WHa2CfMO3Lr
+func Associate[T any, K comparable, V any](collection []T, transform func(item T) (K, V)) map[K]V {
+	result := make(map[K]V, len(collection))
+
+	for i := range collection {
+		k, v := transform(collection[i])
+		result[k] = v
+	}
+
+	return result
+}
+
+// SliceToMap returns a map containing key-value pairs provided by transform function applied to elements of the given slice.
+// If any of two pairs would have the same key the last one gets added to the map.
+// The order of keys in returned map is not specified and is not guaranteed to be the same from the original array.
+// Alias of Associate().
+// Play: https://go.dev/play/p/WHa2CfMO3Lr
+func SliceToMap[T any, K comparable, V any](collection []T, transform func(item T) (K, V)) map[K]V {
+	return Associate(collection, transform)
+}
+
+// FilterSliceToMap returns a map containing key-value pairs provided by transform function applied to elements of the given slice.
+// If any of two pairs would have the same key the last one gets added to the map.
+// The order of keys in returned map is not specified and is not guaranteed to be the same from the original array.
+// The third return value of the transform function is a boolean that indicates whether the key-value pair should be included in the map.
+func FilterSliceToMap[T any, K comparable, V any](collection []T, transform func(item T) (K, V, bool)) map[K]V {
+	result := make(map[K]V, len(collection))
+
+	for i := range collection {
+		k, v, ok := transform(collection[i])
+		if ok {
+			result[k] = v
+		}
+	}
+
+	return result
+}
+
+// Keyify returns a map with each unique element of the slice as a key.
+func Keyify[T comparable, Slice ~[]T](collection Slice) map[T]struct{} {
+	result := make(map[T]struct{}, len(collection))
+
+	for _, item := range collection {
+		result[item] = struct{}{}
+	}
+
+	return result
+}
+
+// Drop drops n elements from the beginning of a slice or array.
+// Play: https://go.dev/play/p/JswS7vXRJP2
+func Drop[T any, Slice ~[]T](collection Slice, n int) Slice {
+	if len(collection) <= n {
+		return make(Slice, 0)
+	}
+
+	result := make(Slice, 0, len(collection)-n)
+
+	return append(result, collection[n:]...)
+}
+
+// DropRight drops n elements from the end of a slice or array.
+// Play: https://go.dev/play/p/GG0nXkSJJa3
+func DropRight[T any, Slice ~[]T](collection Slice, n int) Slice {
+	if len(collection) <= n {
+		return Slice{}
+	}
+
+	result := make(Slice, 0, len(collection)-n)
+	return append(result, collection[:len(collection)-n]...)
+}
+
+// DropWhile drops elements from the beginning of a slice or array while the predicate returns true.
+// Play: https://go.dev/play/p/7gBPYw2IK16
+func DropWhile[T any, Slice ~[]T](collection Slice, predicate func(item T) bool) Slice {
+	i := 0
+	for ; i < len(collection); i++ {
+		if !predicate(collection[i]) {
+			break
+		}
+	}
+
+	result := make(Slice, 0, len(collection)-i)
+	return append(result, collection[i:]...)
+}
+
+// DropRightWhile drops elements from the end of a slice or array while the predicate returns true.
+// Play: https://go.dev/play/p/3-n71oEC0Hz
+func DropRightWhile[T any, Slice ~[]T](collection Slice, predicate func(item T) bool) Slice {
+	i := len(collection) - 1
+	for ; i >= 0; i-- {
+		if !predicate(collection[i]) {
+			break
+		}
+	}
+
+	result := make(Slice, 0, i+1)
+	return append(result, collection[:i+1]...)
+}
+
+// DropByIndex drops elements from a slice or array by the index.
+// A negative index will drop elements from the end of the slice.
+// Play: https://go.dev/play/p/bPIH4npZRxS
+func DropByIndex[T any](collection []T, indexes ...int) []T {
+	initialSize := len(collection)
+	if initialSize == 0 {
+		return make([]T, 0)
+	}
+
+	for i := range indexes {
+		if indexes[i] < 0 {
+			indexes[i] = initialSize + indexes[i]
+		}
+	}
+
+	indexes = Uniq(indexes)
+	sort.Ints(indexes)
+
+	result := make([]T, 0, initialSize)
+	result = append(result, collection...)
+
+	for i := range indexes {
+		if indexes[i]-i < 0 || indexes[i]-i >= initialSize-i {
+			continue
+		}
+
+		result = append(result[:indexes[i]-i], result[indexes[i]-i+1:]...)
+	}
+
+	return result
+}
+
+// Reject is the opposite of Filter, this method returns the elements of collection that predicate does not return truthy for.
+// Play: https://go.dev/play/p/YkLMODy1WEL
+func Reject[T any, Slice ~[]T](collection Slice, predicate func(item T, index int) bool) Slice {
+	result := Slice{}
+
+	for i := range collection {
+		if !predicate(collection[i], i) {
+			result = append(result, collection[i])
+		}
+	}
+
+	return result
+}
+
+// RejectMap is the opposite of FilterMap, this method returns a slice which obtained after both filtering and mapping using the given callback function.
+// The callback function should return two values:
+//   - the result of the mapping operation and
+//   - whether the result element should be included or not.
+func RejectMap[T any, R any](collection []T, callback func(item T, index int) (R, bool)) []R {
+	result := []R{}
+
+	for i := range collection {
+		if r, ok := callback(collection[i], i); !ok {
+			result = append(result, r)
+		}
+	}
+
+	return result
+}
+
+// FilterReject mixes Filter and Reject, this method returns two slices, one for the elements of collection that
+// predicate returns truthy for and one for the elements that predicate does not return truthy for.
+func FilterReject[T any, Slice ~[]T](collection Slice, predicate func(T, int) bool) (kept Slice, rejected Slice) {
+	kept = make(Slice, 0, len(collection))
+	rejected = make(Slice, 0, len(collection))
+
+	for i := range collection {
+		if predicate(collection[i], i) {
+			kept = append(kept, collection[i])
+		} else {
+			rejected = append(rejected, collection[i])
+		}
+	}
+
+	return kept, rejected
+}
+
+// Count counts the number of elements in the collection that compare equal to value.
+// Play: https://go.dev/play/p/Y3FlK54yveC
+func Count[T comparable](collection []T, value T) (count int) {
+	for i := range collection {
+		if collection[i] == value {
+			count++
+		}
+	}
+
+	return count
+}
+
+// CountBy counts the number of elements in the collection for which predicate is true.
+// Play: https://go.dev/play/p/ByQbNYQQi4X
+func CountBy[T any](collection []T, predicate func(item T) bool) (count int) {
+	for i := range collection {
+		if predicate(collection[i]) {
+			count++
+		}
+	}
+
+	return count
+}
+
+// CountValues counts the number of each element in the collection.
+// Play: https://go.dev/play/p/-p-PyLT4dfy
+func CountValues[T comparable](collection []T) map[T]int {
+	result := make(map[T]int)
+
+	for i := range collection {
+		result[collection[i]]++
+	}
+
+	return result
+}
+
+// CountValuesBy counts the number of each element return from mapper function.
+// Is equivalent to chaining lo.Map and lo.CountValues.
+// Play: https://go.dev/play/p/2U0dG1SnOmS
+func CountValuesBy[T any, U comparable](collection []T, mapper func(item T) U) map[U]int {
+	result := make(map[U]int)
+
+	for i := range collection {
+		result[mapper(collection[i])]++
+	}
+
+	return result
+}
+
+// Subset returns a copy of a slice from `offset` up to `length` elements. Like `slice[start:start+length]`, but does not panic on overflow.
+// Play: https://go.dev/play/p/tOQu1GhFcog
+func Subset[T any, Slice ~[]T](collection Slice, offset int, length uint) Slice {
+	size := len(collection)
+
+	if offset < 0 {
+		offset = size + offset
+		if offset < 0 {
+			offset = 0
+		}
+	}
+
+	if offset > size {
+		return Slice{}
+	}
+
+	if length > uint(size)-uint(offset) {
+		length = uint(size - offset)
+	}
+
+	return collection[offset : offset+int(length)]
+}
+
+// Slice returns a copy of a slice from `start` up to, but not including `end`. Like `slice[start:end]`, but does not panic on overflow.
+// Play: https://go.dev/play/p/8XWYhfMMA1h
+func Slice[T any, Slice ~[]T](collection Slice, start int, end int) Slice {
+	size := len(collection)
+
+	if start >= end {
+		return Slice{}
+	}
+
+	if start > size {
+		start = size
+	}
+	if start < 0 {
+		start = 0
+	}
+
+	if end > size {
+		end = size
+	}
+	if end < 0 {
+		end = 0
+	}
+
+	return collection[start:end]
+}
+
+// Replace returns a copy of the slice with the first n non-overlapping instances of old replaced by new.
+// Play: https://go.dev/play/p/XfPzmf9gql6
+func Replace[T comparable, Slice ~[]T](collection Slice, old T, new T, n int) Slice {
+	result := make(Slice, len(collection))
+	copy(result, collection)
+
+	for i := range result {
+		if result[i] == old && n != 0 {
+			result[i] = new
+			n--
+		}
+	}
+
+	return result
+}
+
+// ReplaceAll returns a copy of the slice with all non-overlapping instances of old replaced by new.
+// Play: https://go.dev/play/p/a9xZFUHfYcV
+func ReplaceAll[T comparable, Slice ~[]T](collection Slice, old T, new T) Slice {
+	return Replace(collection, old, new, -1)
+}
+
+// Compact returns a slice of all non-zero elements.
+// Play: https://go.dev/play/p/tXiy-iK6PAc
+func Compact[T comparable, Slice ~[]T](collection Slice) Slice {
+	var zero T
+
+	result := make(Slice, 0, len(collection))
+
+	for i := range collection {
+		if collection[i] != zero {
+			result = append(result, collection[i])
+		}
+	}
+
+	return result
+}
+
+// IsSorted checks if a slice is sorted.
+// Play: https://go.dev/play/p/mc3qR-t4mcx
+func IsSorted[T constraints.Ordered](collection []T) bool {
+	for i := 1; i < len(collection); i++ {
+		if collection[i-1] > collection[i] {
+			return false
+		}
+	}
+
+	return true
+}
+
+// IsSortedByKey checks if a slice is sorted by iteratee.
+// Play: https://go.dev/play/p/wiG6XyBBu49
+func IsSortedByKey[T any, K constraints.Ordered](collection []T, iteratee func(item T) K) bool {
+	size := len(collection)
+
+	for i := 0; i < size-1; i++ {
+		if iteratee(collection[i]) > iteratee(collection[i+1]) {
+			return false
+		}
+	}
+
+	return true
+}
+
+// Splice inserts multiple elements at index i. A negative index counts back
+// from the end of the slice. The helper is protected against overflow errors.
+// Play: https://go.dev/play/p/G5_GhkeSUBA
+func Splice[T any, Slice ~[]T](collection Slice, i int, elements ...T) Slice {
+	sizeCollection := len(collection)
+	sizeElements := len(elements)
+	output := make(Slice, 0, sizeCollection+sizeElements) // preallocate memory for the output slice
+
+	if sizeElements == 0 {
+		return append(output, collection...) // simple copy
+	} else if i > sizeCollection {
+		// positive overflow
+		return append(append(output, collection...), elements...)
+	} else if i < -sizeCollection {
+		// negative overflow
+		return append(append(output, elements...), collection...)
+	} else if i < 0 {
+		// backward
+		i = sizeCollection + i
+	}
+
+	return append(append(append(output, collection[:i]...), elements...), collection[i:]...)
+}

vendor/github.com/samber/lo/string.go

@@ -0,0 +1,231 @@
+package lo
+
+import (
+	"github.com/samber/lo/internal/rand"
+	"math"
+	"regexp"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+
+	"golang.org/x/text/cases"
+	"golang.org/x/text/language"
+)
+
+var (
+	LowerCaseLettersCharset = []rune("abcdefghijklmnopqrstuvwxyz")
+	UpperCaseLettersCharset = []rune("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+	LettersCharset          = append(LowerCaseLettersCharset, UpperCaseLettersCharset...)
+	NumbersCharset          = []rune("0123456789")
+	AlphanumericCharset     = append(LettersCharset, NumbersCharset...)
+	SpecialCharset          = []rune("!@#$%^&*()_+-=[]{}|;':\",./<>?")
+	AllCharset              = append(AlphanumericCharset, SpecialCharset...)
+
+	// bearer:disable go_lang_permissive_regex_validation
+	splitWordReg = regexp.MustCompile(`([a-z])([A-Z0-9])|([a-zA-Z])([0-9])|([0-9])([a-zA-Z])|([A-Z])([A-Z])([a-z])`)
+	// bearer:disable go_lang_permissive_regex_validation
+	splitNumberLetterReg = regexp.MustCompile(`([0-9])([a-zA-Z])`)
+	maximumCapacity      = math.MaxInt>>1 + 1
+)
+
+// RandomString return a random string.
+// Play: https://go.dev/play/p/rRseOQVVum4
+func RandomString(size int, charset []rune) string {
+	if size <= 0 {
+		panic("lo.RandomString: Size parameter must be greater than 0")
+	}
+	if len(charset) <= 0 {
+		panic("lo.RandomString: Charset parameter must not be empty")
+	}
+
+	// see https://stackoverflow.com/questions/22892120/how-to-generate-a-random-string-of-a-fixed-length-in-go
+	sb := strings.Builder{}
+	sb.Grow(size)
+	// Calculate the number of bits required to represent the charset,
+	// e.g., for 62 characters, it would need 6 bits (since 62 -> 64 = 2^6)
+	letterIdBits := int(math.Log2(float64(nearestPowerOfTwo(len(charset)))))
+	// Determine the corresponding bitmask,
+	// e.g., for 62 characters, the bitmask would be 111111.
+	var letterIdMask int64 = 1<<letterIdBits - 1
+	// Available count, since rand.Int64() returns a non-negative number, the first bit is fixed, so there are 63 random bits
+	// e.g., for 62 characters, this value is 10 (63 / 6).
+	letterIdMax := 63 / letterIdBits
+	// Generate the random string in a loop.
+	for i, cache, remain := size-1, rand.Int64(), letterIdMax; i >= 0; {
+		// Regenerate the random number if all available bits have been used
+		if remain == 0 {
+			cache, remain = rand.Int64(), letterIdMax
+		}
+		// Select a character from the charset
+		if idx := int(cache & letterIdMask); idx < len(charset) {
+			sb.WriteRune(charset[idx])
+			i--
+		}
+		// Shift the bits to the right to prepare for the next character selection,
+		// e.g., for 62 characters, shift by 6 bits.
+		cache >>= letterIdBits
+		// Decrease the remaining number of uses for the current random number.
+		remain--
+	}
+	return sb.String()
+}
+
+// nearestPowerOfTwo returns the nearest power of two.
+func nearestPowerOfTwo(cap int) int {
+	n := cap - 1
+	n |= n >> 1
+	n |= n >> 2
+	n |= n >> 4
+	n |= n >> 8
+	n |= n >> 16
+	if n < 0 {
+		return 1
+	}
+	if n >= maximumCapacity {
+		return maximumCapacity
+	}
+	return n + 1
+}
+
+// Substring return part of a string.
+// Play: https://go.dev/play/p/TQlxQi82Lu1
+func Substring[T ~string](str T, offset int, length uint) T {
+	rs := []rune(str)
+	size := len(rs)
+
+	if offset < 0 {
+		offset = size + offset
+		if offset < 0 {
+			offset = 0
+		}
+	}
+
+	if offset >= size {
+		return Empty[T]()
+	}
+
+	if length > uint(size)-uint(offset) {
+		length = uint(size - offset)
+	}
+
+	return T(strings.Replace(string(rs[offset:offset+int(length)]), "\x00", "", -1))
+}
+
+// ChunkString returns an array of strings split into groups the length of size. If array can't be split evenly,
+// the final chunk will be the remaining elements.
+// Play: https://go.dev/play/p/__FLTuJVz54
+func ChunkString[T ~string](str T, size int) []T {
+	if size <= 0 {
+		panic("lo.ChunkString: Size parameter must be greater than 0")
+	}
+
+	if len(str) == 0 {
+		return []T{""}
+	}
+
+	if size >= len(str) {
+		return []T{str}
+	}
+
+	var chunks = make([]T, 0, ((len(str)-1)/size)+1)
+	currentLen := 0
+	currentStart := 0
+	for i := range str {
+		if currentLen == size {
+			chunks = append(chunks, str[currentStart:i])
+			currentLen = 0
+			currentStart = i
+		}
+		currentLen++
+	}
+	chunks = append(chunks, str[currentStart:])
+	return chunks
+}
+
+// RuneLength is an alias to utf8.RuneCountInString which returns the number of runes in string.
+// Play: https://go.dev/play/p/tuhgW_lWY8l
+func RuneLength(str string) int {
+	return utf8.RuneCountInString(str)
+}
+
+// PascalCase converts string to pascal case.
+func PascalCase(str string) string {
+	items := Words(str)
+	for i := range items {
+		items[i] = Capitalize(items[i])
+	}
+	return strings.Join(items, "")
+}
+
+// CamelCase converts string to camel case.
+func CamelCase(str string) string {
+	items := Words(str)
+	for i, item := range items {
+		item = strings.ToLower(item)
+		if i > 0 {
+			item = Capitalize(item)
+		}
+		items[i] = item
+	}
+	return strings.Join(items, "")
+}
+
+// KebabCase converts string to kebab case.
+func KebabCase(str string) string {
+	items := Words(str)
+	for i := range items {
+		items[i] = strings.ToLower(items[i])
+	}
+	return strings.Join(items, "-")
+}
+
+// SnakeCase converts string to snake case.
+func SnakeCase(str string) string {
+	items := Words(str)
+	for i := range items {
+		items[i] = strings.ToLower(items[i])
+	}
+	return strings.Join(items, "_")
+}
+
+// Words splits string into an array of its words.
+func Words(str string) []string {
+	str = splitWordReg.ReplaceAllString(str, `$1$3$5$7 $2$4$6$8$9`)
+	// example: Int8Value => Int 8Value => Int 8 Value
+	str = splitNumberLetterReg.ReplaceAllString(str, "$1 $2")
+	var result strings.Builder
+	for _, r := range str {
+		if unicode.IsLetter(r) || unicode.IsDigit(r) {
+			result.WriteRune(r)
+		} else {
+			result.WriteRune(' ')
+		}
+	}
+	return strings.Fields(result.String())
+}
+
+// Capitalize converts the first character of string to upper case and the remaining to lower case.
+func Capitalize(str string) string {
+	return cases.Title(language.English).String(str)
+}
+
+// Ellipsis trims and truncates a string to a specified length and appends an ellipsis if truncated.
+func Ellipsis(str string, length int) string {
+	str = strings.TrimSpace(str)
+
+	if len(str) > length {
+		if len(str) < 3 || length < 3 {
+			return "..."
+		}
+		return strings.TrimSpace(str[0:length-3]) + "..."
+	}
+
+	return str
+}
+
+// Elipse trims and truncates a string to a specified length and appends an ellipsis if truncated.
+//
+// Deprecated: Use Ellipsis instead.
+func Elipse(str string, length int) string {
+	return Ellipsis(str, length)
+}

vendor/github.com/samber/lo/time.go

@@ -0,0 +1,85 @@
+package lo
+
+import "time"
+
+// Duration returns the time taken to execute a function.
+func Duration(cb func()) time.Duration {
+	return Duration0(cb)
+}
+
+// Duration0 returns the time taken to execute a function.
+func Duration0(cb func()) time.Duration {
+	start := time.Now()
+	cb()
+	return time.Since(start)
+}
+
+// Duration1 returns the time taken to execute a function.
+func Duration1[A any](cb func() A) (A, time.Duration) {
+	start := time.Now()
+	a := cb()
+	return a, time.Since(start)
+}
+
+// Duration2 returns the time taken to execute a function.
+func Duration2[A, B any](cb func() (A, B)) (A, B, time.Duration) {
+	start := time.Now()
+	a, b := cb()
+	return a, b, time.Since(start)
+}
+
+// Duration3 returns the time taken to execute a function.
+func Duration3[A, B, C any](cb func() (A, B, C)) (A, B, C, time.Duration) {
+	start := time.Now()
+	a, b, c := cb()
+	return a, b, c, time.Since(start)
+}
+
+// Duration4 returns the time taken to execute a function.
+func Duration4[A, B, C, D any](cb func() (A, B, C, D)) (A, B, C, D, time.Duration) {
+	start := time.Now()
+	a, b, c, d := cb()
+	return a, b, c, d, time.Since(start)
+}
+
+// Duration5 returns the time taken to execute a function.
+func Duration5[A, B, C, D, E any](cb func() (A, B, C, D, E)) (A, B, C, D, E, time.Duration) {
+	start := time.Now()
+	a, b, c, d, e := cb()
+	return a, b, c, d, e, time.Since(start)
+}
+
+// Duration6 returns the time taken to execute a function.
+func Duration6[A, B, C, D, E, F any](cb func() (A, B, C, D, E, F)) (A, B, C, D, E, F, time.Duration) {
+	start := time.Now()
+	a, b, c, d, e, f := cb()
+	return a, b, c, d, e, f, time.Since(start)
+}
+
+// Duration7 returns the time taken to execute a function.
+func Duration7[A, B, C, D, E, F, G any](cb func() (A, B, C, D, E, F, G)) (A, B, C, D, E, F, G, time.Duration) {
+	start := time.Now()
+	a, b, c, d, e, f, g := cb()
+	return a, b, c, d, e, f, g, time.Since(start)
+}
+
+// Duration8 returns the time taken to execute a function.
+func Duration8[A, B, C, D, E, F, G, H any](cb func() (A, B, C, D, E, F, G, H)) (A, B, C, D, E, F, G, H, time.Duration) {
+	start := time.Now()
+	a, b, c, d, e, f, g, h := cb()
+	return a, b, c, d, e, f, g, h, time.Since(start)
+}
+
+// Duration9 returns the time taken to execute a function.
+func Duration9[A, B, C, D, E, F, G, H, I any](cb func() (A, B, C, D, E, F, G, H, I)) (A, B, C, D, E, F, G, H, I, time.Duration) {
+	start := time.Now()
+	a, b, c, d, e, f, g, h, i := cb()
+	return a, b, c, d, e, f, g, h, i, time.Since(start)
+}
+
+// Duration10 returns the time taken to execute a function.
+func Duration10[A, B, C, D, E, F, G, H, I, J any](cb func() (A, B, C, D, E, F, G, H, I, J)) (A, B, C, D, E, F, G, H, I, J, time.Duration) {
+	start := time.Now()
+	a, b, c, d, e, f, g, h, i, j := cb()
+	return a, b, c, d, e, f, g, h, i, j, time.Since(start)
+}

vendor/github.com/samber/lo/type_manipulation.go

@@ -0,0 +1,189 @@
+package lo
+
+import "reflect"
+
+// IsNil checks if a value is nil or if it's a reference type with a nil underlying value.
+func IsNil(x any) bool {
+	defer func() { recover() }() // nolint:errcheck
+	return x == nil || reflect.ValueOf(x).IsNil()
+}
+
+// IsNotNil checks if a value is not nil or if it's not a reference type with a nil underlying value.
+func IsNotNil(x any) bool {
+	return !IsNil(x)
+}
+
+// ToPtr returns a pointer copy of value.
+func ToPtr[T any](x T) *T {
+	return &x
+}
+
+// Nil returns a nil pointer of type.
+func Nil[T any]() *T {
+	return nil
+}
+
+// EmptyableToPtr returns a pointer copy of value if it's nonzero.
+// Otherwise, returns nil pointer.
+func EmptyableToPtr[T any](x T) *T {
+	// 🤮
+	isZero := reflect.ValueOf(&x).Elem().IsZero()
+	if isZero {
+		return nil
+	}
+
+	return &x
+}
+
+// FromPtr returns the pointer value or empty.
+func FromPtr[T any](x *T) T {
+	if x == nil {
+		return Empty[T]()
+	}
+
+	return *x
+}
+
+// FromPtrOr returns the pointer value or the fallback value.
+func FromPtrOr[T any](x *T, fallback T) T {
+	if x == nil {
+		return fallback
+	}
+
+	return *x
+}
+
+// ToSlicePtr returns a slice of pointer copy of value.
+func ToSlicePtr[T any](collection []T) []*T {
+	result := make([]*T, len(collection))
+
+	for i := range collection {
+		result[i] = &collection[i]
+	}
+	return result
+}
+
+// FromSlicePtr returns a slice with the pointer values.
+// Returns a zero value in case of a nil pointer element.
+func FromSlicePtr[T any](collection []*T) []T {
+	return Map(collection, func(x *T, _ int) T {
+		if x == nil {
+			return Empty[T]()
+		}
+		return *x
+	})
+}
+
+// FromSlicePtrOr returns a slice with the pointer values or the fallback value.
+// Play: https://go.dev/play/p/lbunFvzlUDX
+func FromSlicePtrOr[T any](collection []*T, fallback T) []T {
+	return Map(collection, func(x *T, _ int) T {
+		if x == nil {
+			return fallback
+		}
+		return *x
+	})
+}
+
+// ToAnySlice returns a slice with all elements mapped to `any` type
+func ToAnySlice[T any](collection []T) []any {
+	result := make([]any, len(collection))
+	for i := range collection {
+		result[i] = collection[i]
+	}
+	return result
+}
+
+// FromAnySlice returns an `any` slice with all elements mapped to a type.
+// Returns false in case of type conversion failure.
+func FromAnySlice[T any](in []any) (out []T, ok bool) {
+	defer func() {
+		if r := recover(); r != nil {
+			out = []T{}
+			ok = false
+		}
+	}()
+
+	result := make([]T, len(in))
+	for i := range in {
+		result[i] = in[i].(T)
+	}
+	return result, true
+}
+
+// Empty returns the zero value (https://go.dev/ref/spec#The_zero_value).
+func Empty[T any]() T {
+	var zero T
+	return zero
+}
+
+// IsEmpty returns true if argument is a zero value.
+func IsEmpty[T comparable](v T) bool {
+	var zero T
+	return zero == v
+}
+
+// IsNotEmpty returns true if argument is not a zero value.
+func IsNotEmpty[T comparable](v T) bool {
+	var zero T
+	return zero != v
+}
+
+// Coalesce returns the first non-empty arguments. Arguments must be comparable.
+func Coalesce[T comparable](values ...T) (result T, ok bool) {
+	for i := range values {
+		if values[i] != result {
+			result = values[i]
+			ok = true
+			return
+		}
+	}
+
+	return
+}
+
+// CoalesceOrEmpty returns the first non-empty arguments. Arguments must be comparable.
+func CoalesceOrEmpty[T comparable](v ...T) T {
+	result, _ := Coalesce(v...)
+	return result
+}
+
+// CoalesceSlice returns the first non-zero slice.
+func CoalesceSlice[T any](v ...[]T) ([]T, bool) {
+	for i := range v {
+		if v[i] != nil && len(v[i]) > 0 {
+			return v[i], true
+		}
+	}
+	return []T{}, false
+}
+
+// CoalesceSliceOrEmpty returns the first non-zero slice.
+func CoalesceSliceOrEmpty[T any](v ...[]T) []T {
+	for i := range v {
+		if v[i] != nil && len(v[i]) > 0 {
+			return v[i]
+		}
+	}
+	return []T{}
+}
+
+// CoalesceMap returns the first non-zero map.
+func CoalesceMap[K comparable, V any](v ...map[K]V) (map[K]V, bool) {
+	for i := range v {
+		if v[i] != nil && len(v[i]) > 0 {
+			return v[i], true
+		}
+	}
+	return map[K]V{}, false
+}
+
+// CoalesceMapOrEmpty returns the first non-zero map.
+func CoalesceMapOrEmpty[K comparable, V any](v ...map[K]V) map[K]V {
+	for i := range v {
+		if v[i] != nil && len(v[i]) > 0 {
+			return v[i]
+		}
+	}
+	return map[K]V{}
+}

vendor/github.com/samber/lo/types.go

@@ -0,0 +1,123 @@
+package lo
+
+// Entry defines a key/value pairs.
+type Entry[K comparable, V any] struct {
+	Key   K
+	Value V
+}
+
+// Tuple2 is a group of 2 elements (pair).
+type Tuple2[A, B any] struct {
+	A A
+	B B
+}
+
+// Unpack returns values contained in tuple.
+func (t Tuple2[A, B]) Unpack() (A, B) {
+	return t.A, t.B
+}
+
+// Tuple3 is a group of 3 elements.
+type Tuple3[A, B, C any] struct {
+	A A
+	B B
+	C C
+}
+
+// Unpack returns values contained in tuple.
+func (t Tuple3[A, B, C]) Unpack() (A, B, C) {
+	return t.A, t.B, t.C
+}
+
+// Tuple4 is a group of 4 elements.
+type Tuple4[A, B, C, D any] struct {
+	A A
+	B B
+	C C
+	D D
+}
+
+// Unpack returns values contained in tuple.
+func (t Tuple4[A, B, C, D]) Unpack() (A, B, C, D) {
+	return t.A, t.B, t.C, t.D
+}
+
+// Tuple5 is a group of 5 elements.
+type Tuple5[A, B, C, D, E any] struct {
+	A A
+	B B
+	C C
+	D D
+	E E
+}
+
+// Unpack returns values contained in tuple.
+func (t Tuple5[A, B, C, D, E]) Unpack() (A, B, C, D, E) {
+	return t.A, t.B, t.C, t.D, t.E
+}
+
+// Tuple6 is a group of 6 elements.
+type Tuple6[A, B, C, D, E, F any] struct {
+	A A
+	B B
+	C C
+	D D
+	E E
+	F F
+}
+
+// Unpack returns values contained in tuple.
+func (t Tuple6[A, B, C, D, E, F]) Unpack() (A, B, C, D, E, F) {
+	return t.A, t.B, t.C, t.D, t.E, t.F
+}
+
+// Tuple7 is a group of 7 elements.
+type Tuple7[A, B, C, D, E, F, G any] struct {
+	A A
+	B B
+	C C
+	D D
+	E E
+	F F
+	G G
+}
+
+// Unpack returns values contained in tuple.
+func (t Tuple7[A, B, C, D, E, F, G]) Unpack() (A, B, C, D, E, F, G) {
+	return t.A, t.B, t.C, t.D, t.E, t.F, t.G
+}
+
+// Tuple8 is a group of 8 elements.
+type Tuple8[A, B, C, D, E, F, G, H any] struct {
+	A A
+	B B
+	C C
+	D D
+	E E
+	F F
+	G G
+	H H
+}
+
+// Unpack returns values contained in tuple.
+func (t Tuple8[A, B, C, D, E, F, G, H]) Unpack() (A, B, C, D, E, F, G, H) {
+	return t.A, t.B, t.C, t.D, t.E, t.F, t.G, t.H
+}
+
+// Tuple9 is a group of 9 elements.
+type Tuple9[A, B, C, D, E, F, G, H, I any] struct {
+	A A
+	B B
+	C C
+	D D
+	E E
+	F F
+	G G
+	H H
+	I I
+}
+
+// Unpack returns values contained in tuple.
+func (t Tuple9[A, B, C, D, E, F, G, H, I]) Unpack() (A, B, C, D, E, F, G, H, I) {
+	return t.A, t.B, t.C, t.D, t.E, t.F, t.G, t.H, t.I
+}