@pawover/kit 0.0.0-beta.4 → 0.0.0-beta.40

package/dist/utils-DbMbll5L.js

@@ -0,0 +1,2004 @@
+import { clone, cloneDeep, cloneDeepWith } from "lodash-es";
+
+//#region src/utils/typeof/types.ts
+const PROTOTYPE_TAGS = Object.freeze({
+	abortSignal: "[object AbortSignal]",
+	array: "[object Array]",
+	asyncFunction: "[object AsyncFunction]",
+	asyncGeneratorFunction: "[object AsyncGeneratorFunction]",
+	bigInt: "[object BigInt]",
+	blob: "[object Blob]",
+	boolean: "[object Boolean]",
+	date: "[object Date]",
+	error: "[object Error]",
+	file: "[object File]",
+	function: "[object Function]",
+	generatorFunction: "[object GeneratorFunction]",
+	global: "[object global]",
+	iframe: "[object HTMLIFrameElement]",
+	map: "[object Map]",
+	null: "[object Null]",
+	number: "[object Number]",
+	object: "[object Object]",
+	promise: "[object Promise]",
+	readableStream: "[object ReadableStream]",
+	regExp: "[object RegExp]",
+	set: "[object Set]",
+	string: "[object String]",
+	symbol: "[object Symbol]",
+	undefined: "[object Undefined]",
+	URLSearchParams: "[object URLSearchParams]",
+	weakMap: "[object WeakMap]",
+	weakSet: "[object WeakSet]",
+	webSocket: "[object WebSocket]",
+	window: "[object Window]"
+});
+const TYPED_ARRAY_TAGS = new Set([
+	"[object Int8Array]",
+	"[object Uint8Array]",
+	"[object Uint8ClampedArray]",
+	"[object Int16Array]",
+	"[object Uint16Array]",
+	"[object Int32Array]",
+	"[object Uint32Array]",
+	"[object Float32Array]",
+	"[object Float64Array]",
+	"[object BigInt64Array]",
+	"[object BigUint64Array]"
+]);
+function resolvePrototypeString(value) {
+	return Object.prototype.toString.call(value);
+}
+
+//#endregion
+//#region src/utils/typeof/isAbortSignal.ts
+/**
+* 检查 value 是否为 AbortSignal
+* @param value 待检查值
+* @returns 是否为 AbortSignal
+*/
+function isAbortSignal(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.abortSignal;
+}
+
+//#endregion
+//#region src/utils/typeof/isArray.ts
+/**
+* 检查 value 是否为数组
+*
+* @param value 待检查值
+* @returns 是否为数组
+* @example
+* ```ts
+* isArray([]); // true
+* ```
+*/
+function isArray(value) {
+	return Array.isArray(value);
+}
+/**
+* 检查 value 是否为 TypedArray
+*
+* @param value 待检查值
+* @returns 是否为 TypedArray
+* @example
+* ```ts
+* isTypedArray(new Int8Array()); // true
+* ```
+*/
+function isTypedArray(value) {
+	return typeof value === "object" && value !== null && TYPED_ARRAY_TAGS.has(resolvePrototypeString(value));
+}
+
+//#endregion
+//#region src/utils/typeof/isBigInt.ts
+/**
+* 检查 value 是否为 BigInt
+* @param value 待检查值
+* @returns 是否为 BigInt
+*/
+function isBigInt(value) {
+	return typeof value === "bigint";
+}
+
+//#endregion
+//#region src/utils/typeof/isBlob.ts
+/**
+* 检查 value 是否为 Blob
+* @param value 待检查值
+* @returns 是否为 Blob
+*/
+function isBlob(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.blob;
+}
+function isFile(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.file;
+}
+
+//#endregion
+//#region src/utils/typeof/isBoolean.ts
+/**
+* 检查 value 是否为 Boolean
+* @param value 待检查值
+* @returns 是否为 Boolean
+*/
+function isBoolean(value) {
+	return typeof value === "boolean";
+}
+
+//#endregion
+//#region src/utils/typeof/isFunction.ts
+/**
+* 检查 value 是否为 Function
+* @param value 待检查值
+* @returns 是否为 Function
+*/
+function isFunction(value) {
+	return typeof value === "function";
+}
+/**
+* 检查 value 是否为 AsyncFunction
+* @param value 待检查值
+* @returns 是否为 AsyncFunction
+*/
+function isAsyncFunction(value) {
+	return isFunction(value) && resolvePrototypeString(value) === PROTOTYPE_TAGS.asyncFunction;
+}
+/**
+* 检查 value 是否为 GeneratorFunction
+* @param value 待检查值
+* @returns 是否为 GeneratorFunction
+*/
+function isGeneratorFunction(value) {
+	return isFunction(value) && resolvePrototypeString(value) === PROTOTYPE_TAGS.generatorFunction;
+}
+/**
+* 检查 value 是否为 AsyncGeneratorFunction
+* @param value 待检查值
+* @returns 是否为 AsyncGeneratorFunction
+*/
+function isAsyncGeneratorFunction(value) {
+	return isFunction(value) && resolvePrototypeString(value) === PROTOTYPE_TAGS.asyncGeneratorFunction;
+}
+
+//#endregion
+//#region src/utils/typeof/isClass.ts
+function isConstructable(fn) {
+	try {
+		Reflect.construct(fn, []);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 检查 value 是否为 Class
+*
+* @param value 待检查值
+* @returns 是否为 Class
+* @example
+* ```ts
+* class A {}
+* isClass(A); // true
+* isClass(() => {}); // false
+* ```
+*/
+function isClass(value) {
+	return isFunction(value) && !isAsyncFunction(value) && Function.prototype.toString.call(value).startsWith("class ") && isConstructable(value) && value.prototype !== void 0;
+}
+
+//#endregion
+//#region src/utils/typeof/isDate.ts
+/**
+* 检查 value 是否为 Date 对象
+*
+* @param value 待检查值
+* @param invalidCheck 是否要求日期有效（非 Invalid Date）。默认 true
+*   - true: 仅当是有效 Date 对象时返回 true（排除 new Date('invalid')）
+*   - false: 只要 [[Prototype]] 是 Date 即返回 true（包含 Invalid Date）
+* @returns 是否为 Date 对象，根据 invalidCheck 返回不同语义的 Date 判定
+*
+* @example
+* ```ts
+* isDate(new Date()); // true
+* isDate(new Date('invalid')); // false
+* isDate(new Date('invalid'), false); // true
+* isDate(null); // false
+* isDate({}); // false
+* ```
+*/
+function isDate(value, invalidCheck = true) {
+	if (!value || typeof value !== "object") return false;
+	if (resolvePrototypeString(value) !== PROTOTYPE_TAGS.date) return false;
+	if (!invalidCheck) return true;
+	try {
+		const time = value.getTime();
+		return typeof time === "number" && !Number.isNaN(time);
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/utils/typeof/isEnumeration.ts
+/**
+* 判断一个对象是否为有效的枚举
+* - 枚举成员不能为空
+* - 枚举成员的键不能具有数值名
+* - 枚举成员的值必须类型一致且为 `string` 或 `number` 类型
+* - 枚举成员的值不能重复
+* - 枚举成员的值必须全部为双向映射或非双向映射
+*
+* @param enumeration 待检查值
+* @returns [是否为有效的枚举, 是否为双向枚举]
+*/
+function isEnumeration(enumeration) {
+	if (typeof enumeration !== "object" || enumeration === null) return [false, false];
+	const keys = Object.keys(enumeration);
+	if (keys.length === 0) return [false, false];
+	const originalKeys = [];
+	const numericKeys = [];
+	for (const key of keys) if (/^\d+$/.test(key)) numericKeys.push(key);
+	else originalKeys.push(key);
+	if (originalKeys.length === 0) return [false, false];
+	let valueType = null;
+	const values = [];
+	for (const key of originalKeys) {
+		const value = enumeration[key];
+		const type = typeof value;
+		if (type !== "string" && type !== "number") return [false, false];
+		if (valueType === null) valueType = type;
+		else if (type !== valueType) return [false, false];
+		values.push(value);
+	}
+	if (new Set(values).size !== values.length) return [false, false];
+	let isBidirectional = false;
+	if (numericKeys.length > 0) {
+		if (numericKeys.length !== originalKeys.length) return [false, false];
+		const reverseMappedNames = /* @__PURE__ */ new Set();
+		for (const numKey of numericKeys) {
+			const reverseValue = enumeration[numKey];
+			if (typeof reverseValue !== "string") return [false, false];
+			if (!originalKeys.includes(reverseValue)) return [false, false];
+			reverseMappedNames.add(reverseValue);
+		}
+		if (reverseMappedNames.size !== originalKeys.length) return [false, false];
+		isBidirectional = true;
+	}
+	return [true, isBidirectional];
+}
+
+//#endregion
+//#region src/utils/typeof/isEqual.ts
+/**
+* 深度比较两个值是否相等
+*
+* @param value 待比较值 A
+* @param other 待比较值 B
+* @returns 是否相等
+* @example
+* ```ts
+* isEqual({ a: 1 }, { a: 1 }); // true
+* ```
+*/
+function isEqual(x, y) {
+	const seen = /* @__PURE__ */ new WeakMap();
+	function _isEqual(a, b) {
+		if (Object.is(a, b)) return true;
+		if (isDate(a) && isDate(b)) return a.getTime() === b.getTime();
+		if (isRegExp(a) && isRegExp(b)) return a.toString() === b.toString();
+		if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) return false;
+		if (seen.has(a)) {
+			if (seen.get(a).has(b)) return true;
+		} else seen.set(a, /* @__PURE__ */ new Set());
+		seen.get(a).add(b);
+		const keysA = Reflect.ownKeys(a);
+		const keysB = Reflect.ownKeys(b);
+		if (keysA.length !== keysB.length) return false;
+		for (const key of keysA) {
+			if (!Reflect.has(b, key)) return false;
+			if (!_isEqual(a[key], b[key])) return false;
+		}
+		return true;
+	}
+	return _isEqual(x, y);
+}
+
+//#endregion
+//#region src/utils/typeof/isError.ts
+/**
+* 检查 value 是否为 Error 对象
+* @param value 待检查值
+* @returns 是否为 Error
+*/
+function isError(value) {
+	return value instanceof Error || resolvePrototypeString(value) === PROTOTYPE_TAGS.error;
+}
+
+//#endregion
+//#region src/utils/typeof/isFalsy.ts
+/**
+* 检查 value 是否为 Falsy 值 (false, 0, "", null, undefined, NaN)
+* @param value 待检查值
+* @returns 是否为 Falsy
+*/
+function isFalsy(value) {
+	if (isNaN(value) || isNull(value) || isUndefined(value)) return true;
+	return value === false || value === 0 || value === 0n || value === "";
+}
+function isFalsyLike(value) {
+	if (isFalsy(value)) return true;
+	return typeof value === "string" && (value === "null" || value === "undefined" || value === "NaN" || value === "false" || value === "0" || value === "-0" || value === "0n");
+}
+
+//#endregion
+//#region src/utils/typeof/isIframe.ts
+/**
+* 检查 value 是否为 HTMLIFrameElement
+* @param value 待检查值
+* @returns 是否为 HTMLIFrameElement
+*/
+function isIframe(value) {
+	if (typeof window === "undefined") return false;
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.iframe;
+}
+function isInIframe() {
+	if (typeof window === "undefined") return false;
+	try {
+		return window.top !== window.self;
+	} catch (error) {
+		if (error.name === "SecurityError") return true;
+		return false;
+	}
+}
+
+//#endregion
+//#region src/utils/typeof/isIterable.ts
+/**
+* 检查 value 是否为可迭代对象 (Iterable)
+* @param value 待检查值
+* @returns 是否为 Iterable
+*/
+function isIterable(value) {
+	return !!value && typeof value[Symbol.iterator] === "function";
+}
+
+//#endregion
+//#region src/utils/typeof/isMap.ts
+/**
+* 检查 value 是否为 Map
+* @param value 待检查值
+* @returns 是否为 Map
+*/
+function isMap(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.map;
+}
+/**
+* 检查 value 是否为 WeakMap
+* @param value 待检查值
+* @returns 是否为 WeakMap
+*/
+function isWeakMap(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.weakMap;
+}
+
+//#endregion
+//#region src/utils/typeof/isNull.ts
+/**
+* 检查 value 是否为 null
+* @param value 待检查值
+* @returns 是否为 null
+*/
+function isNull(value) {
+	return value === null;
+}
+
+//#endregion
+//#region src/utils/typeof/isNumber.ts
+/**
+* 检查 value 是否为 number 类型
+*
+* @param value 待检查值
+* @param NaNCheck 是否排除 `NaN`，默认为 `true`
+* @returns 是否为 number
+* @example
+* ```ts
+* isNumber(1); // true
+* isNumber(NaN); // false (default)
+* isNumber(NaN, false); // true
+* ```
+*/
+function isNumber(value, NaNCheck = true) {
+	return typeof value === "number" && (!NaNCheck || !isNaN(value));
+}
+/**
+* 检查 value 是否为 NaN
+*
+* @param value 待检查值
+* @returns 是否为 NaN
+*/
+function isNaN(value) {
+	return Number.isNaN(value);
+}
+/**
+* 检查 value 是否为整数
+*
+* @param value 待检查值
+* @param safeCheck 是否附加安全整数检查
+* @returns 是否为整数
+*/
+function isInteger(value, safeCheck = true) {
+	const check = Number.isInteger(value);
+	return safeCheck ? check && Number.isSafeInteger(value) : check;
+}
+/**
+* 检查 value 是否为正整数
+* - 此函数中 `0` 不被视为正整数
+*
+* @param value 待检查值
+* @param safeCheck 是否附加安全整数检查
+*/
+function isPositiveInteger(value, safeCheck = true) {
+	return isInteger(value, safeCheck) && value > 0;
+}
+/**
+* 检查 value 是否为负整数
+* - 此函数中 `0` 不被视为负整数
+*
+* @param value 待检查值
+* @param safeCheck 是否附加安全整数检查
+*/
+function isNegativeInteger(value, safeCheck = true) {
+	return isInteger(value, safeCheck) && value < 0;
+}
+/**
+* 检查 value 是否为 Infinity
+* - 排除 `NaN`
+*
+* @param value 待检查值
+*/
+function isInfinity(value) {
+	return isNumber(value) && (Number.POSITIVE_INFINITY === value || Number.NEGATIVE_INFINITY === value);
+}
+/**
+* 检查 value 是否类似 Infinity
+* - 排除 `NaN`
+*
+* @param value 待检查值
+*/
+function isInfinityLike(value) {
+	const check = isInfinity(value);
+	if (check) return check;
+	if (typeof value === "string") {
+		const v = value.trim().toLowerCase();
+		return v === "infinity" || v === "-infinity" || v === "+infinity";
+	}
+	return false;
+}
+
+//#endregion
+//#region src/utils/typeof/isObject.ts
+/**
+* 判断是否为普通对象类型
+* - 可选是否检查原型为 `Object.prototype`，防止原型链污染
+*
+* @param value 待检查值
+* @param prototypeCheck 是否进行原型检查，默认 `true`
+* @returns 是否为 Plain Object (当 checkPrototype=true) 或 object
+* @example
+* ```ts
+* isObject({}); // true
+* isObject([]); // false
+* isObject(new Date()); // false (because prototype is not Object.prototype)
+* isObject(new Date(), false); // true (is object type)
+* isObject(Object.create(null)) // false
+* isObject(Object.create(null), false) // true
+* ```
+*/
+function isObject(value, prototypeCheck = true) {
+	const check = resolvePrototypeString(value) === PROTOTYPE_TAGS.object;
+	return prototypeCheck ? check && Object.getPrototypeOf(value) === Object.prototype : check;
+}
+
+//#endregion
+//#region src/utils/typeof/isPromise.ts
+/**
+* 检查 value 是否为 Promise
+* @param value 待检查值
+* @returns 是否为 Promise
+*/
+function isPromise(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.promise;
+}
+/**
+* 检查 value 是否为 PromiseLike (thenable)
+* @param value 待检查值
+* @returns 是否为 PromiseLike
+*/
+function isPromiseLike(value) {
+	return isPromise(value) || isObject(value) && isFunction(value["then"]);
+}
+
+//#endregion
+//#region src/utils/typeof/isReadableStream.ts
+/**
+* 检查 value 是否为 ReadableStream
+* - Uses `Object.prototype.toString` where supported (modern browsers, Node.js ≥18).
+* - Falls back to duck-typing in older environments.
+* - Resistant to basic forgery, but not 100% secure in all polyfill scenarios.
+* - ⚠️ Note: In older Node.js (<18) or with non-compliant polyfills, this may return false positives or negatives.
+*
+* @param value 待检查值
+* @returns 是否为 ReadableStream
+*/
+function isReadableStream(value) {
+	if (resolvePrototypeString(value) === PROTOTYPE_TAGS.readableStream) return true;
+	return isObject(value) && isFunction(value["getReader"]) && isFunction(value["pipeThrough"]);
+}
+
+//#endregion
+//#region src/utils/typeof/isString.ts
+/**
+* 检查 value 是否为 string 类型
+*
+* @param value 待检查值
+* @param checkEmpty 是否排除空字符串
+* @returns 是否为字符串
+* @example
+* ```ts
+* isString("abc"); // true
+* isString(""); // true
+* isString("", true); // false
+* ```
+*/
+function isString(value, checkEmpty = false) {
+	return typeof value === "string" && (!checkEmpty || !!value.length);
+}
+
+//#endregion
+//#region src/utils/typeof/isRegExp.ts
+/**
+* 检查 value 是否为 RegExp
+* @param value 待检查值
+* @returns 是否为 RegExp
+*/
+function isRegExp(value) {
+	if (typeof value !== "object" || value === null) return false;
+	try {
+		const regex = value;
+		return resolvePrototypeString(value) === PROTOTYPE_TAGS.regExp && isString(regex.source) && isString(regex.flags) && isBoolean(regex.global) && isFunction(regex.test);
+	} catch (error) {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/utils/typeof/isSet.ts
+/**
+* 检查 value 是否为 Set
+* @param value 待检查值
+* @returns 是否为 Set
+*/
+function isSet(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.set;
+}
+/**
+* 检查 value 是否为 WeakSet
+* @param value 待检查值
+* @returns 是否为 WeakSet
+*/
+function isWeakSet(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.weakSet;
+}
+
+//#endregion
+//#region src/utils/typeof/isSymbol.ts
+/**
+* 检查 value 是否为 Symbol
+* @param value 待检查值
+* @returns 是否为 Symbol
+*/
+function isSymbol(value) {
+	return typeof value === "symbol";
+}
+
+//#endregion
+//#region src/utils/typeof/isUndefined.ts
+/**
+* 检查 value 是否为 undefined
+* @param value 待检查值
+* @returns 是否为 undefined
+*/
+function isUndefined(value) {
+	return typeof value === "undefined";
+}
+
+//#endregion
+//#region src/utils/typeof/isURLSearchParams.ts
+/**
+* 检查 value 是否为 URLSearchParams
+* @param value 待检查值
+* @returns 是否为 URLSearchParams
+*/
+function isURLSearchParams(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.URLSearchParams;
+}
+
+//#endregion
+//#region src/utils/typeof/isWebSocket.ts
+/**
+* 检查 value 是否为 WebSocket
+* @param value 待检查值
+* @returns 是否为 WebSocket
+*/
+function isWebSocket(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.webSocket;
+}
+
+//#endregion
+//#region src/utils/typeof/isWindow.ts
+/**
+* 检查 value 是否为 Window
+* @param value 待检查值
+* @returns 是否为 Window
+*/
+function isWindow(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.window;
+}
+
+//#endregion
+//#region src/utils/array/arrayCast.ts
+function arrayCast(candidate, checkEmpty = true) {
+	if (checkEmpty && (isUndefined(candidate) || isNull(candidate))) return [];
+	return isArray(candidate) ? [...candidate] : [candidate];
+}
+
+//#endregion
+//#region src/utils/array/arrayCompete.ts
+/**
+* 数组竞争
+* - 返回在匹配函数的比较条件中获胜的最终项目，适用于更复杂的最小值/最大值计算
+*
+* @param initialList 数组
+* @param match 匹配函数
+* @returns 获胜的元素，如果数组为空或参数无效则返回 `null`
+* @example
+* ```ts
+* const list = [1, 10, 5];
+* arrayCompete(list, (a, b) => (a > b ? a : b)); // 10
+* arrayCompete(list, (a, b) => (a < b ? a : b)); // 1
+* ```
+*/
+function arrayCompete(initialList, match) {
+	if (!isArray(initialList) || initialList.length === 0 || !isFunction(match)) return null;
+	return initialList.reduce(match);
+}
+
+//#endregion
+//#region src/utils/array/arrayCounting.ts
+/**
+* 统计数组的项目出现次数
+* - 通过给定的标识符匹配函数，返回一个对象，其中键是回调函数返回的 key 值，每个值是一个整数，表示该 key 出现的次数
+*
+* @param initialList 初始数组
+* @param match 匹配函数
+* @returns 统计对象
+* @example
+* ```ts
+* const list = ["a", "b", "a", "c"];
+* arrayCounting(list, (x) => x); // { a: 2, b: 1, c: 1 }
+*
+* const users = [{ id: 1, group: "A" }, { id: 2, group: "B" }, { id: 3, group: "A" }];
+* arrayCounting(users, (u) => u.group); // { A: 2, B: 1 }
+* ```
+*/
+function arrayCounting(initialList, match) {
+	if (!isArray(initialList) || !isFunction(match)) return {};
+	return initialList.reduce((prev, curr, index) => {
+		const id = match(curr, index).toString();
+		prev[id] = (prev[id] ?? 0) + 1;
+		return prev;
+	}, {});
+}
+
+//#endregion
+//#region src/utils/array/arrayDifference.ts
+/**
+* 求数组差集
+* - 返回在 `initialList` 中存在，但在 `diffList` 中不存在的元素
+*
+* @param initialList 初始数组
+* @param diffList 对比数组
+* @param match 匹配函数
+* @returns 差集数组
+* @example
+* ```ts
+* arrayDifference([1, 2, 3], [2, 3, 4]); // [1]
+* arrayDifference([{ id: 1 }, { id: 2 }], [{ id: 2 }], (x) => x.id); // [{ id: 1 }]
+* ```
+*/
+function arrayDifference(initialList, diffList, match) {
+	if (!isArray(initialList) && !isArray(diffList)) return [];
+	if (!isArray(initialList) || !initialList.length) return [];
+	if (!isArray(diffList) || !diffList.length) return [...initialList];
+	if (!isFunction(match)) {
+		const arraySet = new Set(diffList);
+		return Array.from(new Set(initialList.filter((item) => !arraySet.has(item))));
+	}
+	const map = /* @__PURE__ */ new Map();
+	diffList.forEach((item, index) => {
+		map.set(match(item, index), true);
+	});
+	return initialList.filter((item, index) => !map.get(match(item, index)));
+}
+
+//#endregion
+//#region src/utils/array/arrayFirst.ts
+function arrayFirst(initialList, saveValue) {
+	if (!isArray(initialList) || initialList.length === 0) return saveValue;
+	return initialList[0];
+}
+
+//#endregion
+//#region src/utils/array/arrayFork.ts
+/**
+* 数组分组过滤
+* - 给定一个数组和一个条件，返回一个由两个数组组成的元组，其中第一个数组包含所有满足条件的项，第二个数组包含所有不满足条件的项
+*
+* @param initialList 初始数组
+* @param match 条件匹配函数
+* @returns [满足条件的项[], 不满足条件的项[]]
+* @example
+* ```ts
+* arrayFork([1, 2, 3, 4], (n) => n % 2 === 0); // [[2, 4], [1, 3]]
+* ```
+*/
+function arrayFork(initialList, match) {
+	const forked = [[], []];
+	if (isArray(initialList)) initialList.forEach((item, index) => {
+		forked[match(item, index) ? 0 : 1].push(item);
+	});
+	return forked;
+}
+
+//#endregion
+//#region src/utils/array/arrayIntersection.ts
+function arrayIntersection(initialList, diffList, match) {
+	if (!isArray(initialList) || !isArray(diffList)) return [];
+	if (!initialList.length || !diffList.length) return [];
+	if (!isFunction(match)) {
+		const diffSet = new Set(diffList);
+		return initialList.filter((item) => diffSet.has(item));
+	}
+	const diffKeys = new Set(diffList.map((item, index) => match(item, index)));
+	return initialList.filter((item, index) => diffKeys.has(match(item, index)));
+}
+
+//#endregion
+//#region src/utils/array/arrayLast.ts
+function arrayLast(initialList, saveValue) {
+	if (!isArray(initialList) || initialList.length === 0) return saveValue;
+	return initialList[initialList.length - 1];
+}
+
+//#endregion
+//#region src/utils/array/arrayMerge.ts
+function arrayMerge(initialList, mergeList, match) {
+	if (!isArray(initialList)) return [];
+	if (!isArray(mergeList)) return [...initialList];
+	if (!isFunction(match)) return Array.from(new Set([...initialList, ...mergeList]));
+	const keys = /* @__PURE__ */ new Map();
+	mergeList.forEach((item, index) => {
+		keys.set(match(item, index), item);
+	});
+	return initialList.map((prevItem, index) => {
+		const key = match(prevItem, index);
+		return keys.has(key) ? keys.get(key) : prevItem;
+	});
+}
+
+//#endregion
+//#region src/utils/array/arrayPick.ts
+function arrayPick(initialList, filter, mapper) {
+	if (!isArray(initialList)) return [];
+	if (!isFunction(filter)) return [...initialList];
+	const hasMapper = isFunction(mapper);
+	return initialList.reduce((prev, curr, index) => {
+		if (!filter(curr, index)) return prev;
+		if (hasMapper) prev.push(mapper(curr, index));
+		else prev.push(curr);
+		return prev;
+	}, []);
+}
+
+//#endregion
+//#region src/utils/array/arrayReplace.ts
+function arrayReplace(initialList, newItem, match) {
+	if (!isArray(initialList) || !initialList.length) return [];
+	if (!isFunction(match)) return [...initialList];
+	for (let i = 0; i < initialList.length; i++) {
+		const item = initialList[i];
+		if (match(item, i)) return [
+			...initialList.slice(0, i),
+			newItem,
+			...initialList.slice(i + 1, initialList.length)
+		];
+	}
+	return [...initialList];
+}
+
+//#endregion
+//#region src/utils/array/arrayReplaceMove.ts
+/**
+* 数组项替换并移动
+* - 在给定的数组中，替换并移动符合匹配函数结果的项目
+* - 只替换和移动第一个匹配项
+* - 未匹配时，根据 `position` 在指定位置插入 `newItem`
+*
+* @param initialList 初始数组
+* @param newItem 替换项
+* @param match 匹配函数
+* @param position 移动位置，可选 `start` | `end` | 索引位置， 默认为 `end`
+* @returns
+* @example
+* ```ts
+* arrayReplaceMove([1, 2, 3, 4], 5, (n) => n === 2, 0); // [5, 1, 3, 4]
+* arrayReplaceMove([1, 2, 3, 4], 5, (n) => n === 2, 2); // [1, 3, 5, 4]
+* arrayReplaceMove([1, 2, 3, 4], 5, (n) => n === 2, "start"); // [5, 1, 3, 4]
+* arrayReplaceMove([1, 2, 3, 4], 5, (n) => n === 2); // [1, 3, 4, 5]
+* ```
+*/
+function arrayReplaceMove(initialList, newItem, match, position) {
+	if (!isArray(initialList)) return [];
+	if (!initialList.length) return [newItem];
+	if (!isFunction(match)) return [...initialList];
+	const result = [...initialList];
+	const matchIndex = initialList.findIndex(match);
+	if (matchIndex !== -1) result.splice(matchIndex, 1);
+	if (position === "start") result.unshift(newItem);
+	else if (position === 0 || isPositiveInteger(position, false)) result.splice(Math.min(position, result.length), 0, newItem);
+	else result.push(newItem);
+	return result;
+}
+
+//#endregion
+//#region src/utils/array/arraySplit.ts
+/**
+* 数组切分
+* - 将数组以指定的长度切分后，组合在高维数组中
+*
+* @param initialList 初始数组
+* @param size 分割尺寸，默认 `10`
+* @returns 切分后的二维数组
+* @example
+* ```ts
+* arraySplit([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]
+* ```
+*/
+function arraySplit(initialList, size = 10) {
+	if (!isArray(initialList)) return [];
+	if (!isPositiveInteger(size, false)) return [];
+	const count = Math.ceil(initialList.length / size);
+	return Array.from({ length: count }).fill(null).map((_c, i) => {
+		return initialList.slice(i * size, i * size + size);
+	});
+}
+
+//#endregion
+//#region src/utils/array/arrayZip.ts
+/**
+* 数组解压
+* - `arrayZip` 的反向操作
+*
+* @param arrays 压缩后的数组
+* @returns 解压后的二维数组
+* @example
+* ```ts
+* arrayUnzip([[1, "a"], [2, "b"]]); // [[1, 2], ["a", "b"]]
+* ```
+*/
+function arrayUnzip(arrays) {
+	if (!isArray(arrays) || !arrays.length) return [];
+	const out = new Array(arrays.reduce((max, arr) => Math.max(max, arr.length), 0));
+	let index = 0;
+	const get = (array) => array[index];
+	for (; index < out.length; index++) out[index] = Array.from(arrays, get);
+	return out;
+}
+function arrayZip(...arrays) {
+	return arrayUnzip(arrays);
+}
+
+//#endregion
+//#region src/utils/array/arrayZipToObject.ts
+function arrayZipToObject(keys, values) {
+	const result = {};
+	if (!isArray(keys) || !keys.length) return result;
+	const getValue = isFunction(values) ? values : isArray(values) ? (_k, i) => values[i] : (_k, _i) => values;
+	return keys.reduce((acc, key, idx) => {
+		acc[key] = getValue(key, idx);
+		return acc;
+	}, result);
+}
+
+//#endregion
+//#region src/utils/device/isBrowser.ts
+function isBrowser() {
+	return typeof window !== "undefined" && isFunction(window?.document?.createElement);
+}
+function isWebWorker() {
+	return typeof window === "undefined" && typeof self !== "undefined" && "importScripts" in self;
+}
+
+//#endregion
+//#region src/utils/device/isMobile.ts
+/**
+* 检测当前设备是否为移动设备
+*
+* @param maxWidth - 移动设备最大宽度（默认 768px）
+* @param dpi - 标准 DPI 基准（默认 160）
+* @returns 是否为移动设备
+* @example
+* ```ts
+* // 假设 window.innerWidth = 500
+* isMobile(); // true
+* ```
+*/
+function isMobile(maxWidth = 768, dpi = 160) {
+	if (typeof window === "undefined" || !isPositiveInteger(maxWidth)) return false;
+	return !isTablet(maxWidth, 1200, dpi);
+}
+/**
+* 检测当前设备是否为IOS移动设备
+*
+* @param maxWidth - 移动设备最大宽度（默认 768px）
+* @param dpi - 标准 DPI 基准（默认 160）
+* @returns 是否为 iOS 移动设备 (iPhone/iPad/iPod 且非平板)
+* @example
+* ```ts
+* // UA contains iPhone
+* isIOSMobile(); // true
+* ```
+*/
+function isIOSMobile(maxWidth = 768, dpi = 160) {
+	if (typeof navigator === "undefined" || !navigator.userAgent || !isPositiveInteger(maxWidth)) return false;
+	return /iPhone|iPad|iPod/i.test(navigator.userAgent) && !isTablet(maxWidth, 1200, dpi);
+}
+
+//#endregion
+//#region src/utils/device/isTablet.ts
+/**
+* 检测当前设备是否为平板
+*
+* @param minWidth - 平板最小宽度（默认 768px）
+* @param maxWidth - 平板最大宽度（默认 1200px）
+* @param dpi - 标准 DPI 基准（默认 160）
+* @returns 是否为平板设备
+* @example
+* ```ts
+* // 假设 window.innerWidth = 1000
+* isTablet(); // true
+* ```
+*/
+function isTablet(minWidth = 768, maxWidth = 1200, dpi = 160) {
+	if (typeof window === "undefined" || !isPositiveInteger(minWidth) || !isPositiveInteger(maxWidth)) return false;
+	const width = window.innerWidth;
+	const isWithinWidthRange = width >= minWidth && width <= maxWidth;
+	try {
+		const widthPx = window.screen.width;
+		const heightPx = window.screen.height;
+		const DPI = dpi * (window.devicePixelRatio || 1);
+		const widthInch = widthPx / DPI;
+		const heightInch = heightPx / DPI;
+		const screenInches = Math.sqrt(widthInch ** 2 + heightInch ** 2);
+		return isWithinWidthRange || screenInches >= 7;
+	} catch {
+		return isWithinWidthRange;
+	}
+}
+
+//#endregion
+//#region src/utils/function/to.ts
+/**
+*将 Promise 转换为 `[err, result]` 格式，方便 async/await 错误处理
+*
+* @param promise 待处理的 Promise
+* @param errorExt 附加到 error 对象的扩展信息（注意：如果原 error 是 Error 实例，扩展属性可能会覆盖或无法正确合并非枚举属性）
+* @returns `[err, null]` 或 `[null, data]`
+* @example
+* ```ts
+* const [err, data] = await to(someAsyncFunc());
+* if (err) return;
+* console.log(data);
+* ```
+*/
+function to(promise, errorExt) {
+	return promise.then((data) => [null, data]).catch((err) => {
+		if (errorExt) {
+			const parsedError = {
+				name: "",
+				message: "",
+				stack: ""
+			};
+			if (err instanceof Error) {
+				parsedError.message = err.message;
+				parsedError.name = err.name;
+				parsedError.stack = err.stack;
+				Object.getOwnPropertyNames(err).forEach((key) => {
+					if (!(key in parsedError)) parsedError[key] = err[key];
+				});
+			} else Object.assign(parsedError, err);
+			Object.assign(parsedError, errorExt);
+			return [parsedError, void 0];
+		}
+		return [err ? err : /* @__PURE__ */ new Error("defaultError"), void 0];
+	});
+}
+
+//#endregion
+//#region src/utils/string/stringToNumber.ts
+const R1$2 = /[^0-9.-]/g;
+/**
+* 从字符串中提取数字字符串
+* - 移除非数字字符，保留符号和小数点
+*
+* @param input 待处理字符串
+* @returns 提取出的数字字符串
+* @example
+* ```ts
+* stringToNumber("$1,234.56"); // "1234.56"
+* stringToNumber("abc-123"); // "-123"
+* ```
+*/
+function stringToNumber(input) {
+	if (!isString(input, true)) return "0";
+	const cleaned = input.replace(R1$2, "");
+	if (!cleaned) return "0";
+	let isDecimal = false;
+	let signCount = 0;
+	let firstIndex = -1;
+	const stringList = cleaned.split("").map((s, i) => {
+		if (s === ".") {
+			if (isDecimal) return "";
+			isDecimal = true;
+			return ".";
+		}
+		if (s === "-") {
+			firstIndex === -1 && signCount++;
+			return "";
+		}
+		firstIndex === -1 && (firstIndex = i);
+		return s;
+	});
+	const sign = signCount % 2 === 1 ? "-" : "";
+	if (firstIndex === -1) return sign + "0";
+	let result = stringList.join("");
+	if (result.startsWith(".")) result = "0" + result;
+	if (result.endsWith(".")) result = result.slice(0, -1);
+	return sign + result;
+}
+
+//#endregion
+//#region src/utils/math/mathToBignumber.ts
+/**
+* 将任意类型的值转换为 `math.bignumber`
+*
+* @param mathJsInstance mathJs 实例
+* @param value 任意类型的值
+* @param saveValue 安全值
+* @returns 转换后的 BigNumber
+* @example
+* ```ts
+* import { create, all } from "mathjs";
+* const math = create(all);
+* mathToBignumber(math, "0.1");
+* ```
+*/
+function mathToBignumber(mathJsInstance, value, saveValue) {
+	const errorValue = saveValue ?? mathJsInstance.bignumber(0);
+	if (isFalsyLike(value) || isInfinityLike(value)) return errorValue;
+	try {
+		return mathJsInstance.bignumber(stringToNumber(`${value}`));
+	} catch (error) {
+		return errorValue;
+	}
+}
+
+//#endregion
+//#region src/utils/math/mathToDecimal.ts
+function mathToDecimal(mathJsInstance, value, precision, isFormat = true) {
+	const bigNumber = mathToBignumber(mathJsInstance, value);
+	return isFormat ? mathJsInstance.format(bigNumber, {
+		notation: "fixed",
+		precision
+	}) : bigNumber;
+}
+
+//#endregion
+//#region src/utils/math/mathToEvaluate.ts
+/**
+* 数学表达式求值
+*
+* @param mathJsInstance mathJs 实例
+* @param expr 表达式
+* @param scope 键值映射
+* @returns 计算结果的字符串表示
+* @example
+* ```ts
+* mathToEvaluate(math, "a + b", { a: 1, b: 2 }); // "3"
+* ```
+*/
+function mathToEvaluate(mathJsInstance, expr, scope) {
+	const evaluateValue = `${mathJsInstance.evaluate(expr, scope || {})}`;
+	return mathJsInstance.format(mathToBignumber(mathJsInstance, evaluateValue), { notation: "fixed" });
+}
+
+//#endregion
+//#region src/utils/number/numberWithin.ts
+/**
+* 数字区间检查函数
+*
+* @param input 待检查数字
+* @param interval 由两个数字组成的元组 [left, right]
+* @param includeLeft 是否包含左边界（默认 true）
+* @param includeRight 是否包含右边界（默认 false）
+* @returns 是否在区间内
+* @example
+* ```ts
+* numberWithin(5, [1, 10]); // true
+* numberWithin(1, [1, 10], false); // false
+* ```
+*/
+function numberWithin(input, interval, includeLeft = true, includeRight = false) {
+	if (!isNumber(input)) throw new Error("params [input] mast be a number.");
+	if (isInfinity(input)) throw new Error("params [input] mast be a finite number.");
+	const [left, right] = interval;
+	if (left > right) throw new Error(`Invalid interval: left (${left}) must be <= right (${right}).`);
+	if (includeLeft && includeRight) return input >= left && input <= right;
+	else if (includeLeft) return input >= left && input < right;
+	else if (includeRight) return input > left && input <= right;
+	else return input > left && input < right;
+}
+
+//#endregion
+//#region src/utils/object/enumEntries.ts
+function enumEntries(enumeration) {
+	const [isEnum, isBidirectionalEnum] = isEnumeration(enumeration);
+	if (!isEnum) throw Error("function enumEntries expected parameter is a enum, and requires at least one member");
+	const entries = objectEntries(enumeration);
+	if (isBidirectionalEnum) return entries.splice(entries.length / 2, entries.length / 2);
+	return entries;
+}
+
+//#endregion
+//#region src/utils/object/enumKeys.ts
+function enumKeys(enumeration) {
+	const [isEnum, isBidirectionalEnum] = isEnumeration(enumeration);
+	if (!isEnum) throw Error("function enumKeys expected parameter is a enum, and requires at least one member");
+	const keys = objectKeys(enumeration);
+	if (isBidirectionalEnum) return keys.splice(keys.length / 2, keys.length / 2);
+	return keys;
+}
+
+//#endregion
+//#region src/utils/object/enumValues.ts
+function enumValues(enumeration) {
+	const [isEnum, isBidirectionalEnum] = isEnumeration(enumeration);
+	if (!isEnum) throw Error("function enumValues expected parameter is a enum, and requires at least one member");
+	const values = objectValues(enumeration);
+	if (isBidirectionalEnum) return values.splice(values.length / 2, values.length / 2);
+	return values;
+}
+
+//#endregion
+//#region src/utils/object/objectEntries.ts
+function objectEntries(value) {
+	return Object.entries(value);
+}
+
+//#endregion
+//#region src/utils/object/objectMapEntries.ts
+/**
+* 映射对象条目
+* - 将对象的键值对映射为新的键值对
+*
+* @param plainObject 对象
+* @param toEntry 映射函数
+* @returns 映射后的新对象
+* @example
+* ```ts
+* const obj = { a: 1, b: 2 };
+* objectMapEntries(obj, (k, v) => [k, v * 2]); // { a: 2, b: 4 }
+* ```
+*/
+function objectMapEntries(plainObject, toEntry) {
+	const defaultResult = {};
+	if (!isObject(plainObject)) return defaultResult;
+	return objectEntries(plainObject).reduce((acc, [key, value]) => {
+		const [newKey, newValue] = toEntry(key, value);
+		acc[newKey] = newValue;
+		return acc;
+	}, defaultResult);
+}
+
+//#endregion
+//#region src/utils/object/objectAssign.ts
+const OBJECT_PROTO = Object.prototype;
+/**
+* 为对象创建一个具有相同原型的新副本
+* 这个辅助函数是保留原型的关键。
+*/
+function cloneWithProto(obj) {
+	const proto = Object.getPrototypeOf(obj);
+	return proto === OBJECT_PROTO ? { ...obj } : Object.assign(Object.create(proto), obj);
+}
+function _objectAssign(initial, override, _seen) {
+	if (!isObject(initial, false) && !isObject(override, false)) return {};
+	if (!isObject(initial, false)) return cloneWithProto(override);
+	if (!isObject(override, false)) return cloneWithProto(initial);
+	if (_seen.has(initial)) return cloneWithProto(override);
+	_seen.add(initial);
+	const assigned = cloneWithProto(initial);
+	for (const key of Object.keys(override)) if (isObject(initial[key]) && isObject(override[key])) assigned[key] = _objectAssign(initial[key], override[key], _seen);
+	else assigned[key] = override[key];
+	_seen.delete(initial);
+	return assigned;
+}
+function objectAssign(initial, override) {
+	return _objectAssign(initial, override, /* @__PURE__ */ new WeakSet());
+}
+
+//#endregion
+//#region src/utils/object/objectCrush.ts
+function objectCrush(obj) {
+	if (!obj) return {};
+	function crushReducer(crushed, value, path) {
+		if (isObject(value) || isArray(value)) for (const [prop, propValue] of Object.entries(value)) crushReducer(crushed, propValue, path ? `${path}.${prop}` : prop);
+		else crushed[path] = value;
+		return crushed;
+	}
+	return crushReducer({}, obj, "");
+}
+
+//#endregion
+//#region src/utils/object/objectInvert.ts
+function objectInvert(obj) {
+	const result = {};
+	if (!isObject(obj)) return result;
+	for (const [k, v] of objectEntries(obj)) if (isString(v) || isNumber(v) || isSymbol(v)) result[v] = k;
+	return result;
+}
+
+//#endregion
+//#region src/utils/object/objectKeys.ts
+function objectKeys(value) {
+	return Object.keys(value);
+}
+
+//#endregion
+//#region src/utils/object/objectOmit.ts
+function objectOmit(obj, keys) {
+	const result = {};
+	if (!isObject(obj)) return result;
+	if (!isArray(keys)) return obj;
+	const keysToOmit = new Set(keys);
+	return Object.keys(obj).reduce((acc, key) => {
+		if (!keysToOmit.has(key)) acc[key] = obj[key];
+		return acc;
+	}, result);
+}
+
+//#endregion
+//#region src/utils/object/objectPick.ts
+function objectPick(obj, keys) {
+	const result = {};
+	if (!isObject(obj)) return result;
+	if (!isArray(keys)) return obj;
+	return keys.reduce((acc, key) => {
+		if (key in obj) acc[key] = obj[key];
+		return acc;
+	}, result);
+}
+
+//#endregion
+//#region src/utils/object/objectValues.ts
+function objectValues(value) {
+	return Object.values(value);
+}
+
+//#endregion
+//#region src/utils/string/stringInitialCase.ts
+const R1$1 = /\S+/g;
+const R2 = /[^a-zA-Z\u00C0-\u017F]/;
+/**
+* 字符串首字母大小写
+* - 包含非西欧字母字符时，不处理
+* - 纯字母且全大写时，不处理
+* - 纯字母且非全大写时，首字母小写，其余保留
+* - 纯字母且非全大写时，首字母大写，其余保留
+*
+/**
+* 字符串首字母大小写
+* - 包含非西欧字母字符时，不处理
+* - 纯字母且全大写时，不处理
+* - 纯字母且非全大写时，首字母小写，其余保留
+* - 纯字母且非全大写时，首字母大写，其余保留
+*
+* @param input 待处理字符串
+* @param caseType 大小写类型
+* @returns 处理后的字符串
+* @example
+* ```ts
+* stringInitialCase("Hello", "lower"); // "hello"
+* stringInitialCase("hello", "upper"); // "Hello"
+* ```
+*/
+function stringInitialCase(input, caseType) {
+	if (!isString(input, true)) return "";
+	return input.replace(R1$1, (word) => {
+		if (R2.test(word)) return word;
+		if (word === word.toLocaleUpperCase()) return word;
+		if (caseType === "lower" && word[0]) return word[0].toLocaleLowerCase() + word.slice(1);
+		if (caseType === "upper" && word[0]) return word[0].toLocaleUpperCase() + word.slice(1);
+		return word;
+	});
+}
+
+//#endregion
+//#region src/utils/string/stringReplace.ts
+/**
+* 字符串替换
+* - 替换第一个匹配项
+*
+/**
+* 字符串替换
+* - 替换第一个匹配项
+*
+* @param input 待处理字符串
+* @param search 匹配项
+* @param replacement 替换项
+* @returns 替换后的字符串
+* @example
+* ```ts
+* stringReplace("hello world", "world", "context"); // "hello context"
+* ```
+*/
+function stringReplace(input, search, replacement) {
+	if (!isString(input, true)) return "";
+	return input.replace(search, replacement);
+}
+
+//#endregion
+//#region src/utils/string/stringTemplate.ts
+const R1 = /\{\{(.+?)\}\}/g;
+/**
+* 字符串模板替换
+* - 使用对象的属性值替换字符串中的 {{key}} 模板
+*
+* @param input 待处理字符串
+* @param template 模板对象
+* @param regex 模板匹配正则 (默认: `\{\{(.+?)\}\}`)
+* @returns 替换后的字符串
+* @example
+* ```ts
+* stringTemplate("Hello {{name}}", { name: "World" }); // "Hello World"
+* ```
+*/
+function stringTemplate(input, template, regex = R1) {
+	if (!isString(input, true)) return "";
+	regex.lastIndex = 0;
+	let result = "";
+	let from = 0;
+	let match;
+	while (match = regex.exec(input)) {
+		const replacement = template[match[1]];
+		const valueToInsert = replacement === null || replacement === void 0 ? match[0] : replacement;
+		result += input.slice(from, match.index) + valueToInsert;
+		from = regex.lastIndex;
+	}
+	return result + input.slice(from);
+}
+
+//#endregion
+//#region src/utils/string/stringToJson.ts
+/**
+* 处理 JSON 字符串
+*
+/**
+* 处理 JSON 字符串
+*
+* @param input 待处理字符串
+* @param safeValue 安全值 (当解析失败或输入无效时返回)
+* @returns 解析后的对象 或 安全值
+* @example
+* ```ts
+* stringToJson('{"a": 1}', {}); // { a: 1 }
+* stringToJson('invalid', {}); // {}
+* ```
+*/
+function stringToJson(input, safeValue) {
+	if (!isString(input, true)) return safeValue;
+	try {
+		return JSON.parse(input);
+	} catch (error) {
+		return safeValue;
+	}
+}
+
+//#endregion
+//#region src/utils/string/stringToPosix.ts
+/**
+* 将路径转换为 POSIX 风格
+* - 统一使用正斜杠 (/)
+* - 可选移除 Windows 盘符 (如 C:)
+* - 可选移除开头的斜杠
+* - 规范化连续斜杠为单个斜杠
+*
+* @param input 待处理字符串
+* @param removeLeadingSlash 是否移除开头斜杠，默认为 `false`。如果移除了盘符，路径通常会以 / 开头，此参数可控制是否保留该 /
+* @returns 转换后的路径，如果输入无效则返回空字符串
+*
+* @example
+* ```ts
+* stringToPosix("C:\\Windows\\System32");
+* // 默认: "/Windows/System32" (移除了 C: 并标准化)
+*
+* stringToPosix("C:\\Windows\\System32", true);
+* // 移除开头斜杠: "Windows/System32"
+*
+* stringToPosix("\\\\server\\share\\file.txt");
+* // UNC 路径: "/server/share/file.txt"
+*
+* stringToPosix("folder\\subfolder\\file.txt");
+* // 相对路径: "folder/subfolder/file.txt"
+* ```
+*/
+function stringToPosix(input, removeLeadingSlash = false) {
+	if (!isString(input, true)) return "";
+	let normalized = input.replace(/^[A-Za-z]:([\\/])?/, (_, separator) => {
+		return separator ? "/" : "";
+	});
+	normalized = normalized.replace(/\\/g, "/");
+	normalized = normalized.replace(/\/+/g, "/");
+	if (removeLeadingSlash && normalized.startsWith("/")) normalized = normalized.substring(1);
+	return normalized;
+}
+
+//#endregion
+//#region src/utils/string/stringToValues.ts
+function stringToValues(input, valueType = "number", splitSymbol = ",") {
+	if (!isString(input, true)) return [];
+	try {
+		const values = input.split(splitSymbol);
+		if (valueType === "number") return values.map((d) => Number(d));
+		return values;
+	} catch (error) {
+		return [];
+	}
+}
+
+//#endregion
+//#region src/utils/string/stringTrim.ts
+/**
+* 从字符串中裁切掉所有的前缀和后缀字符
+*
+* @param input 待处理字符串
+* @param charsToTrim 裁切字符，默认为 `" "`
+* @returns 裁切后的字符串
+* @example
+* ```ts
+* stringTrim("  hello  "); // "hello"
+* stringTrim("__hello__", "_"); // "hello"
+* ```
+*/
+function stringTrim(input, charsToTrim = " ") {
+	if (!isString(input, true)) return "";
+	const toTrim = charsToTrim.replace(/[\W]{1}/g, "\\$&");
+	const regex = new RegExp(`^[${toTrim}]+|[${toTrim}]+$`, "g");
+	return input.replace(regex, "");
+}
+
+//#endregion
+//#region src/utils/string/stringTruncate.ts
+/**
+* 截取字符串
+* - 支持自定义省略符，不会截断在汉字中间（因为JS字符串本身按字符处理）
+*
+* @param input 待处理字符串
+* @param maxLength 最大长度 (包含省略符)
+* @param ellipsis 省略符，默认为 `...`
+* @returns 截取后的字符串
+* @example
+* ```ts
+* stringTruncate("hello world", 8); // "hello..."
+* ```
+*/
+function stringTruncate(input, maxLength, ellipsis = "...") {
+	if (!isString(input, true)) return "";
+	const codePoints = Array.from(input);
+	if (!isInteger(maxLength) || maxLength < 0) return input;
+	if (codePoints.length <= maxLength) return input;
+	const availableLength = maxLength - ellipsis.length;
+	if (availableLength <= 0) return "";
+	return codePoints.slice(0, availableLength).join("") + ellipsis;
+}
+
+//#endregion
+//#region src/utils/time/timeZone.ts
+/**
+* 获取当前时区信息
+*
+* @returns 时区信息对象 (UTC偏移和时区名称)
+* @example
+* ```ts
+* getTimeZone(); // { UTC: "UTC+8", timeZone: "Asia/Shanghai" }
+* ```
+*/
+function getTimeZone() {
+	const hour = 0 - (/* @__PURE__ */ new Date()).getTimezoneOffset() / 60;
+	return {
+		UTC: "UTC" + (hour >= 0 ? "+" + hour : hour),
+		timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone
+	};
+}
+
+//#endregion
+//#region src/utils/tree/types.ts
+function getFinalChildrenKey(tree, meta, options) {
+	if (isFunction(options.getChildrenKey)) {
+		const dynamicChildrenKey = options.getChildrenKey(tree, meta);
+		if (dynamicChildrenKey && dynamicChildrenKey !== null) return dynamicChildrenKey;
+	}
+	return options.childrenKey;
+}
+
+//#endregion
+//#region src/utils/tree/treeFilter.ts
+function preImpl$3(row, callback, options) {
+	if (!callback(row, options)) return;
+	const finalChildrenKey = getFinalChildrenKey(row, options, options);
+	const children = row[finalChildrenKey];
+	let newChildren;
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		newChildren = children.map((c) => preImpl$3(c, callback, nextLevelOptions)).filter((c) => !!c);
+	}
+	return {
+		...row,
+		[finalChildrenKey]: newChildren
+	};
+}
+function postImpl$3(row, callback, options) {
+	const finalChildrenKey = getFinalChildrenKey(row, options, options);
+	const children = row[finalChildrenKey];
+	let newChildren;
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		newChildren = children.map((c) => preImpl$3(c, callback, nextLevelOptions)).filter((c) => !!c);
+	}
+	if (!callback(row, options)) return;
+	return {
+		...row,
+		[finalChildrenKey]: newChildren
+	};
+}
+function breadthImpl$3(row, callback, options) {
+	const queue = [{
+		queueRow: row,
+		queueOptions: options
+	}];
+	const resultCache = /* @__PURE__ */ new WeakMap();
+	const newNodeCache = /* @__PURE__ */ new WeakMap();
+	const childrenKeyCache = /* @__PURE__ */ new WeakMap();
+	let result;
+	const runQueue = () => {
+		if (queue.length === 0) return result;
+		const { queueRow, queueOptions } = queue.shift();
+		const finalChildrenKey = getFinalChildrenKey(queueRow, queueOptions, queueOptions);
+		const children = queueRow[finalChildrenKey];
+		if (isArray(children)) {
+			const nextLevelOptions = {
+				...queueOptions,
+				parents: [...queueOptions.parents, queueRow],
+				depth: queueOptions.depth + 1
+			};
+			const subQueueItems = children.map((queueRow$1) => ({
+				queueRow: queueRow$1,
+				queueOptions: nextLevelOptions
+			}));
+			queue.push(...subQueueItems);
+		}
+		const parent = arrayLast(queueOptions.parents);
+		const isTopNode = queueOptions.depth === 0;
+		const parentResult = parent && resultCache.get(parent);
+		if (!isTopNode && !parentResult) return runQueue();
+		const callbackResult = callback(queueRow, queueOptions);
+		if (isTopNode && !callbackResult) return;
+		const newNode = {
+			...queueRow,
+			[finalChildrenKey]: void 0
+		};
+		if (isTopNode) result = newNode;
+		resultCache.set(queueRow, callbackResult);
+		newNodeCache.set(queueRow, newNode);
+		childrenKeyCache.set(queueRow, finalChildrenKey);
+		if (callbackResult && parent) {
+			const parentNewNode = newNodeCache.get(parent);
+			const parentChildrenKey = childrenKeyCache.get(parent);
+			if (parentNewNode && parentChildrenKey) {
+				if (!parentNewNode[parentChildrenKey]) parentNewNode[parentChildrenKey] = [];
+				parentNewNode[parentChildrenKey].push(newNode);
+			}
+		}
+		return runQueue();
+	};
+	return runQueue();
+}
+const strategies$3 = {
+	pre: preImpl$3,
+	post: postImpl$3,
+	breadth: breadthImpl$3
+};
+function treeFilter(tree, callback, options = {}) {
+	const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+	const traversalMethod = strategies$3[strategy];
+	const innerOptions = {
+		childrenKey,
+		depth: 0,
+		parents: [],
+		getChildrenKey
+	};
+	return isArray(tree) ? tree.map((row) => traversalMethod(row, callback, innerOptions)).filter((t) => !!t) : traversalMethod(tree, callback, innerOptions) || [];
+}
+
+//#endregion
+//#region src/utils/tree/treeFind.ts
+const strategies$2 = {
+	pre: preImpl$2,
+	post: postImpl$2,
+	breadth: breadthImpl$2
+};
+function preImpl$2(row, callback, options) {
+	if (callback(row, options)) return row;
+	const children = row[getFinalChildrenKey(row, options, options)];
+	if (isArray(children)) for (const child of children) {
+		const result = preImpl$2(child, callback, {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		});
+		if (result) return result;
+	}
+}
+function postImpl$2(row, callback, options) {
+	const children = row[getFinalChildrenKey(row, options, options)];
+	if (isArray(children)) for (const child of children) {
+		const result = postImpl$2(child, callback, {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		});
+		if (result) return result;
+	}
+	if (callback(row, options)) return row;
+}
+function breadthImpl$2(row, callback, options) {
+	const queue = [{
+		queueRow: row,
+		queueOptions: options
+	}];
+	const runQueue = () => {
+		if (queue.length === 0) return;
+		const { queueRow, queueOptions } = queue.shift();
+		const children = queueRow[getFinalChildrenKey(queueRow, queueOptions, queueOptions)];
+		if (isArray(children)) {
+			const nextLevelOptions = {
+				...queueOptions,
+				parents: [...queueOptions.parents, queueRow],
+				depth: queueOptions.depth + 1
+			};
+			const subQueueItems = children.map((queueRow$1) => ({
+				queueRow: queueRow$1,
+				queueOptions: nextLevelOptions
+			}));
+			queue.push(...subQueueItems);
+		}
+		if (callback(queueRow, queueOptions)) return queueRow;
+		return runQueue();
+	};
+	return runQueue();
+}
+/**
+* 查找树节点
+* - 返回第一个回调返回 true 的节点
+*
+* @param tree 树结构数据
+* @param callback 回调函数
+* @param options 配置项
+* @returns 找到的节点，未找到则返回 undefined
+* @example
+* ```ts
+* const tree = [{ id: 1, children: [{ id: 2 }] }];
+* treeFind(tree, (node) => node.id === 2); // { id: 2, ... }
+* ```
+*/
+function treeFind(tree, callback, options = {}) {
+	const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+	const traversalMethod = strategies$2[strategy];
+	const innerOptions = {
+		childrenKey,
+		depth: 0,
+		parents: [],
+		getChildrenKey
+	};
+	if (isArray(tree)) {
+		for (const row of tree) {
+			const result = traversalMethod(row, callback, innerOptions);
+			if (result) return result;
+		}
+		return;
+	}
+	return traversalMethod(tree, callback, innerOptions);
+}
+
+//#endregion
+//#region src/utils/tree/treeForEach.ts
+const strategies$1 = {
+	pre: preImpl$1,
+	post: postImpl$1,
+	breadth: breadthImpl$1
+};
+function preImpl$1(row, callback, options) {
+	callback(row, options);
+	const children = row[getFinalChildrenKey(row, options, options)];
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		for (const child of children) preImpl$1(child, callback, nextLevelOptions);
+	}
+}
+function postImpl$1(row, callback, options) {
+	const children = row[getFinalChildrenKey(row, options, options)];
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		for (const child of children) postImpl$1(child, callback, nextLevelOptions);
+	}
+	callback(row, options);
+}
+function breadthImpl$1(row, callback, options) {
+	const queue = [{
+		queueRow: row,
+		queueOptions: options
+	}];
+	const runQueue = () => {
+		if (queue.length === 0) return;
+		const { queueRow, queueOptions } = queue.shift();
+		const children = queueRow[getFinalChildrenKey(queueRow, queueOptions, queueOptions)];
+		if (isArray(children)) {
+			const nextLevelOptions = {
+				...queueOptions,
+				parents: [...queueOptions.parents, queueRow],
+				depth: queueOptions.depth + 1
+			};
+			const subQueueItems = children.map((queueRow$1) => ({
+				queueRow: queueRow$1,
+				queueOptions: nextLevelOptions
+			}));
+			queue.push(...subQueueItems);
+		}
+		callback(queueRow, queueOptions);
+		runQueue();
+	};
+	runQueue();
+}
+/**
+* 遍历树节点
+*
+* @param tree 树结构数据
+* @param callback 回调函数
+* @param options 配置项
+* @example
+* ```ts
+* const tree = [{ id: 1, children: [{ id: 2 }] }];
+* const ids: number[] = [];
+* treeForEach(tree, (node) => ids.push(node.id));
+* // ids: [1, 2] (pre-order default)
+* ```
+*/
+function treeForEach(tree, callback, options = {}) {
+	const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+	const traversalMethod = strategies$1[strategy];
+	const innerOptions = {
+		childrenKey,
+		depth: 0,
+		parents: [],
+		getChildrenKey
+	};
+	if (isArray(tree)) for (const row of tree) traversalMethod(row, callback, innerOptions);
+	else traversalMethod(tree, callback, innerOptions);
+}
+
+//#endregion
+//#region src/utils/tree/treeMap.ts
+const strategies = {
+	pre: preImpl,
+	post: postImpl,
+	breadth: breadthImpl
+};
+function preImpl(row, callback, options) {
+	const finalChildrenKey = getFinalChildrenKey(row, options, options);
+	const result = callback(row, options);
+	const children = row[finalChildrenKey];
+	let newChildren;
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		newChildren = children.map((c) => preImpl(c, callback, nextLevelOptions));
+	}
+	return {
+		...result,
+		[finalChildrenKey]: newChildren
+	};
+}
+function postImpl(row, callback, options) {
+	const finalChildrenKey = getFinalChildrenKey(row, options, options);
+	const children = row[finalChildrenKey];
+	let newChildren;
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		newChildren = children.map((c) => postImpl(c, callback, nextLevelOptions));
+	}
+	return {
+		...callback(row, options),
+		[finalChildrenKey]: newChildren
+	};
+}
+function breadthImpl(row, callback, options) {
+	const queue = [{
+		queueRow: row,
+		queueOptions: options
+	}];
+	const cache = /* @__PURE__ */ new WeakMap();
+	const childrenKeyCache = /* @__PURE__ */ new WeakMap();
+	let result;
+	const runQueue = () => {
+		if (queue.length === 0) return result;
+		const { queueRow, queueOptions } = queue.shift();
+		const finalChildrenKey = getFinalChildrenKey(queueRow, queueOptions, queueOptions);
+		const children = queueRow[finalChildrenKey];
+		if (isArray(children)) {
+			const nextLevelOptions = {
+				...queueOptions,
+				parents: [...queueOptions.parents, queueRow],
+				depth: queueOptions.depth + 1
+			};
+			const subQueueItems = children.map((queueRow$1) => ({
+				queueRow: queueRow$1,
+				queueOptions: nextLevelOptions
+			}));
+			queue.push(...subQueueItems);
+		}
+		const res = callback(queueRow, queueOptions);
+		cache.set(queueRow, res);
+		childrenKeyCache.set(queueRow, finalChildrenKey);
+		const parent = arrayLast(queueOptions.parents);
+		if (parent) {
+			const newParent = cache.get(parent);
+			const parentChildrenKey = childrenKeyCache.get(parent);
+			if (newParent && parentChildrenKey) if (newParent[parentChildrenKey]) newParent[parentChildrenKey].push(res);
+			else newParent[parentChildrenKey] = [res];
+		}
+		if (queueOptions.depth === 0) result = res;
+		return runQueue();
+	};
+	return runQueue();
+}
+function treeMap(tree, callback, options = {}) {
+	const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+	const traversalMethod = strategies[strategy];
+	const innerOptions = {
+		childrenKey,
+		depth: 0,
+		parents: [],
+		getChildrenKey
+	};
+	return isArray(tree) ? tree.map((row) => traversalMethod(row, callback, innerOptions)) : traversalMethod(tree, callback, innerOptions);
+}
+
+//#endregion
+//#region src/utils/tree/rowsToTree.ts
+/**
+* 行结构 转 树结构
+* - 将平铺的数组转换为树形结构
+*
+* @param rows 行数据数组
+* @param options 配置项
+* @returns 树结构数组
+* @example
+* ```ts
+* const rows = [
+*   { id: 1, parentId: null },
+*   { id: 2, parentId: 1 },
+* ];
+* rowsToTree(rows);
+* // [{ id: 1, parentId: null, children: [{ id: 2, parentId: 1 }] }]
+* ```
+*/
+function rowsToTree(rows, options) {
+	const { parentIdKey = "parentId", rowKey = "id", childrenKey = "children" } = options || {};
+	const result = [];
+	const map = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const id = row[rowKey];
+		if (!map.get(id)) map.set(id, row);
+	}
+	for (const row of rows) {
+		const parentId = row[parentIdKey];
+		const parent = map.get(parentId);
+		if (!parent || !parentId) {
+			result.push(row);
+			continue;
+		}
+		const siblings = parent[childrenKey];
+		if (isNull(siblings) || isUndefined(siblings)) parent[childrenKey] = [row];
+		else if (Array.isArray(siblings)) siblings.push(row);
+		else {
+			const message = `The key "${childrenKey.toString()}" in parent item is not an array.`;
+			throw new Error(message);
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/utils/tree/treeToRows.ts
+/**
+* 树结构 转 行结构
+* - 将树形结构扁平化为数组
+*
+* @param tree 树结构数据 (单个节点或节点数组)
+* @param options 配置项
+* @returns 扁平化后的数组
+* @example
+* ```ts
+* const tree = [{ id: 1, children: [{ id: 2 }] }];
+* treeToRows(tree);
+* // [{ id: 1, children: undefined }, { id: 2, children: undefined }]
+* ```
+*/
+function treeToRows(tree, options = {}) {
+	const { childrenKey = "children" } = options;
+	const result = [];
+	if (!tree) return result;
+	treeForEach(tree, (t) => result.push({
+		...t,
+		[childrenKey]: void 0
+	}), options);
+	return result;
+}
+
+//#endregion
+export { arrayFirst as $, mathToDecimal as A, isFalsy as At, isBrowser as B, isGeneratorFunction as Bt, objectMapEntries as C, isPositiveInteger as Ct, enumEntries as D, isIterable as Dt, enumKeys as E, isWeakMap as Et, cloneDeepWith as F, isDate as Ft, arraySplit as G, isArray as Gt, arrayZipToObject as H, isBlob as Ht, to as I, isClass as It, arrayPick as J, arrayReplaceMove as K, isTypedArray as Kt, isTablet as L, isAsyncFunction as Lt, stringToNumber as M, isError as Mt, clone as N, isEqual as Nt, numberWithin as O, isIframe as Ot, cloneDeep as P, isEnumeration as Pt, arrayFork as Q, isIOSMobile as R, isAsyncGeneratorFunction as Rt, objectAssign as S, isNumber as St, enumValues as T, isMap as Tt, arrayUnzip as U, isFile as Ut, isWebWorker as V, isBoolean as Vt, arrayZip as W, isBigInt as Wt, arrayLast as X, arrayMerge as Y, arrayIntersection as Z, objectPick as _, isInfinity as _t, treeFind as a, isWebSocket as at, objectInvert as b, isNaN as bt, stringTruncate as c, isSymbol as ct, stringToPosix as d, isRegExp as dt, arrayDifference as et, stringToJson as f, isString as ft, objectValues as g, isObject as gt, stringInitialCase as h, isPromiseLike as ht, treeForEach as i, isWindow as it, mathToBignumber as j, isFalsyLike as jt, mathToEvaluate as k, isInIframe as kt, stringTrim as l, isSet as lt, stringReplace as m, isPromise as mt, rowsToTree as n, arrayCompete as nt, treeFilter as o, isURLSearchParams as ot, stringTemplate as p, isReadableStream as pt, arrayReplace as q, isAbortSignal as qt, treeMap as r, arrayCast as rt, getTimeZone as s, isUndefined as st, treeToRows as t, arrayCounting as tt, stringToValues as u, isWeakSet as ut, objectOmit as v, isInfinityLike as vt, objectEntries as w, isNull as wt, objectCrush as x, isNegativeInteger as xt, objectKeys as y, isInteger as yt, isMobile as z, isFunction as zt };
+//# sourceMappingURL=utils-DbMbll5L.js.map