Bump github.com/gookit/config/v2 from 2.2.3 to 2.2.4

Bumps [github.com/gookit/config/v2](https://github.com/gookit/config) from 2.2.3 to 2.2.4.
- [Release notes](https://github.com/gookit/config/releases)
- [Commits](https://github.com/gookit/config/compare/v2.2.3...v2.2.4)

---
updated-dependencies:
- dependency-name: github.com/gookit/config/v2
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

vendor/github.com/gookit/goutil/arrutil/process.go

@@ -0,0 +1,102 @@
+package arrutil
+
+import (
+	"reflect"
+
+	"github.com/gookit/goutil/comdef"
+)
+
+// Reverse any T slice.
+//
+// eg: []string{"site", "user", "info", "0"} -> []string{"0", "info", "user", "site"}
+func Reverse[T any](ls []T) {
+	ln := len(ls)
+	for i := 0; i < ln/2; i++ {
+		li := ln - i - 1
+		ls[i], ls[li] = ls[li], ls[i]
+	}
+}
+
+// Remove give element from slice []T.
+//
+// eg: []string{"site", "user", "info", "0"} -> []string{"site", "user", "info"}
+func Remove[T comdef.Compared](ls []T, val T) []T {
+	return Filter(ls, func(el T) bool {
+		return el != val
+	})
+}
+
+// Filter given slice, default will filter zero value.
+//
+// Usage:
+//
+//	// output: [a, b]
+//	ss := arrutil.Filter([]string{"a", "", "b", ""})
+func Filter[T any](ls []T, filter ...comdef.MatchFunc[T]) []T {
+	var fn comdef.MatchFunc[T]
+	if len(filter) > 0 && filter[0] != nil {
+		fn = filter[0]
+	} else {
+		fn = func(el T) bool {
+			return !reflect.ValueOf(el).IsZero()
+		}
+	}
+
+	newLs := make([]T, 0, len(ls))
+	for _, el := range ls {
+		if fn(el) {
+			newLs = append(newLs, el)
+		}
+	}
+	return newLs
+}
+
+// MapFn map handle function type.
+type MapFn[T any, V any] func(input T) (target V, find bool)
+
+// Map a list to new list
+//
+// eg: mapping [object0{},object1{},...] to flatten list [object0.someKey, object1.someKey, ...]
+func Map[T any, V any](list []T, mapFn MapFn[T, V]) []V {
+	flatArr := make([]V, 0, len(list))
+
+	for _, obj := range list {
+		if target, ok := mapFn(obj); ok {
+			flatArr = append(flatArr, target)
+		}
+	}
+	return flatArr
+}
+
+// Column alias of Map func
+func Column[T any, V any](list []T, mapFn func(obj T) (val V, find bool)) []V {
+	return Map(list, mapFn)
+}
+
+// Unique value in the given slice data.
+func Unique[T ~string | comdef.XintOrFloat](list []T) []T {
+	if len(list) < 2 {
+		return list
+	}
+
+	valMap := make(map[T]struct{}, len(list))
+	uniArr := make([]T, 0, len(list))
+
+	for _, t := range list {
+		if _, ok := valMap[t]; !ok {
+			valMap[t] = struct{}{}
+			uniArr = append(uniArr, t)
+		}
+	}
+	return uniArr
+}
+
+// IndexOf value in given slice.
+func IndexOf[T ~string | comdef.XintOrFloat](val T, list []T) int {
+	for i, v := range list {
+		if v == val {
+			return i
+		}
+	}
+	return -1
+}