@pawover/kit 0.0.0-beta.3 → 0.0.0-beta.30

package/dist/utils-RGh-N7TJ.js

@@ -0,0 +1,2037 @@
+//#region src/utils/typeof/types.ts
+const PROTOTYPE_TAGS = {
+	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]",
+	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 (!isObject(enumeration)) return [false, false];
+	const keys = Object.keys(enumeration);
+	if (!keys.length) return [false, false];
+	const values = Object.values(enumeration);
+	if (!values.every((v) => typeof v === "string" || typeof v === "number")) return [false, false];
+	return [true, keys.every((k) => values.some((v) => v.toString() === k))];
+}
+
+//#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) {
+	if (Object.is(x, y)) return true;
+	if (isDate(x) && isDate(y)) return x.getTime() === y.getTime();
+	if (isRegExp(x) && isRegExp(y)) return x.toString() === y.toString();
+	if (typeof x !== "object" || x === null || typeof y !== "object" || y === null) return false;
+	const keysX = Reflect.ownKeys(x);
+	const keysY = Reflect.ownKeys(y);
+	if (keysX.length !== keysY.length) return false;
+	for (const key of keysX) {
+		if (!Reflect.has(y, key)) return false;
+		if (!isEqual(x[key], y[key])) return false;
+	}
+	return true;
+}
+
+//#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 === "0n");
+}
+
+//#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(new Date()); // false (because prototype is not Object.prototype)
+* isObject(new Date(), false); // true (is object type)
+* ```
+*/
+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
+/**
+* Checks if a value is a WHATWG ReadableStream instance.
+*
+* - 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.
+*/
+/**
+* 检查 value 是否为 ReadableStream
+* @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
+/**
+* 求数组交集
+* - 返回在 `initialList` 和 `diffList` 中都存在的元素
+*
+* @param initialList 初始数组
+* @param diffList 对比数组
+* @param match 匹配函数
+* @returns 交集数组
+* @example
+* ```ts
+* arrayIntersection([1, 2], [2, 3]); // [2]
+* arrayIntersection([{ id: 1 }, { id: 2 }], [{ id: 2 }], (x) => x.id); // [{ id: 2 }]
+* ```
+*/
+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
+/**
+* 数组合并
+* - 如果未提供 `match` 函数，则合并两个数组并去重（Union）
+* - 如果提供了 `match` 函数，则仅更新 `initialList` 中匹配到的项（Left Join Update），不会追加 `mergeList` 中新增的项
+*
+* @param initialList 初始数组
+* @param mergeList 待合并数组
+* @param match 匹配函数
+* @returns 合并后的数组
+* @example
+* ```ts
+* // 基础合并去重
+* arrayMerge([1, 2], [2, 3]); // [1, 2, 3]
+*
+* // 按条件更新
+* const source = [{ id: 1, val: "a" }, { id: 2, val: "b" }];
+* const update = [{ id: 2, val: "new" }, { id: 3, val: "c" }];
+* arrayMerge(source, update, (x) => x.id);
+* // [{ id: 1, val: "a" }, { id: 2, val: "new" }] -> id:3 被忽略
+* ```
+*/
+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
+/**
+* 数组项替换
+* - 在给定的数组中，替换符合匹配函数结果的项目
+* - 只替换第一个匹配项
+*
+* @param initialList 初始数组
+* @param newItem 替换项
+* @param match 匹配函数
+* @returns 替换后的新数组
+* @example
+* ```ts
+* arrayReplace([1, 2, 3], 4, (n) => n === 2); // [1, 4, 3]
+* ```
+*/
+function arrayReplace(initialList, newItem, match) {
+	if (!isArray(initialList) || !initialList.length) return [];
+	if (newItem === void 0 || !isFunction(match)) return [...initialList];
+	for (let i = 0; i < initialList.length; i++) {
+		const item = initialList[i];
+		if (item !== void 0 && 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 (newItem === void 0 || !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 [];
+	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 = {
+				...err,
+				...errorExt
+			};
+			if (err instanceof Error) {
+				parsedError["message"] = err.message;
+				parsedError["stack"] = err.stack;
+			}
+			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 "";
+	const cleaned = input.replace(R1$2, "");
+	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/toMathBignumber.ts
+/**
+* 将任意类型的值转换为 `math.bignumber`
+*
+* @param mathJsInstance mathJs 实例
+* @param value 任意类型的值
+* @param saveValue 安全值
+* @returns 转换后的 BigNumber
+* @example
+* ```ts
+* import { create, all } from "mathjs";
+* const math = create(all);
+* toMathBignumber(math, "0.1");
+* ```
+*/
+function toMathBignumber(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/toMathDecimal.ts
+function toMathDecimal(mathJsInstance, value, precision, isFormat = true) {
+	const bigNumber = toMathBignumber(mathJsInstance, value);
+	return isFormat ? mathJsInstance.format(bigNumber, {
+		notation: "fixed",
+		precision
+	}) : bigNumber;
+}
+
+//#endregion
+//#region src/utils/math/toMathEvaluate.ts
+/**
+* 数学表达式求值
+*
+* @param mathJsInstance mathJs 实例
+* @param expr 表达式
+* @param scope 键值映射
+* @returns 计算结果的字符串表示
+* @example
+* ```ts
+* toMathEvaluate(math, "a + b", { a: 1, b: 2 }); // "3"
+* ```
+*/
+function toMathEvaluate(mathJsInstance, expr, scope) {
+	const evaluateValue = `${mathJsInstance.evaluate(expr, scope || {})}`;
+	return mathJsInstance.format(toMathBignumber(mathJsInstance, evaluateValue), { notation: "fixed" });
+}
+
+//#endregion
+//#region src/utils/number/isWithinInterval.ts
+/**
+* 数字区间检查函数
+*
+* @param input 待检查数字
+* @param interval 由两个数字组成的元组 [left, right]
+* @param includeLeft 是否包含左边界（默认 true）
+* @param includeRight 是否包含右边界（默认 false）
+* @returns 是否在区间内
+* @example
+* ```ts
+* isWithinInterval(5, [1, 10]); // true
+* isWithinInterval(1, [1, 10], false); // false
+* ```
+*/
+function isWithinInterval(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/cloneDeep.ts
+const defaultCloneStrategy = {
+	cloneMap,
+	cloneSet,
+	cloneDate,
+	cloneArray,
+	cloneObject,
+	cloneOther
+};
+function cloneMap(input, track, clone) {
+	const output = track(/* @__PURE__ */ new Map());
+	for (const [key, value] of input) output.set(key, clone(value));
+	return output;
+}
+function cloneSet(input, track, clone) {
+	const output = track(/* @__PURE__ */ new Set());
+	for (const value of input) output.add(clone(value));
+	return output;
+}
+function cloneDate(input, track) {
+	return track(new Date(input));
+}
+function cloneArray(input, track, clone) {
+	const output = track(new Array(input.length));
+	input.forEach((value, index) => {
+		output[index] = clone(value);
+	});
+	return output;
+}
+function cloneObject(input, track, clone) {
+	const output = track(Object.create(Object.getPrototypeOf(input)));
+	for (const key of Reflect.ownKeys(input)) {
+		const descriptor = Object.getOwnPropertyDescriptor(input, key);
+		if ("value" in descriptor) descriptor.value = clone(descriptor.value);
+		Object.defineProperty(output, key, descriptor);
+	}
+	return output;
+}
+function cloneOther(input, track) {
+	return track(input);
+}
+/**
+* 深度拷贝对象
+* - 支持 Array, Object, Map, Set
+* - 自动处理循环引用
+*
+* @param root 需要拷贝的对象
+* @param customStrategy 自定义拷贝策略
+* @returns 拷贝后的对象
+* @example
+* ```ts
+* const original = { a: 1, b: { c: 2 } };
+* const copy = cloneDeep(original);
+* copy.b.c = 3;
+* // original.b.c === 2
+* ```
+* @reference https://github.com/radashi-org/radashi/blob/main/src/object/cloneDeep.ts
+*/
+function cloneDeep(root, customStrategy) {
+	const strategy = {
+		...defaultCloneStrategy,
+		...customStrategy
+	};
+	const tracked = /* @__PURE__ */ new Map();
+	const track = (parent, newParent) => {
+		tracked.set(parent, newParent);
+		return newParent;
+	};
+	const clone = (value) => {
+		return value && typeof value === "object" ? tracked.get(value) ?? cloneDeep$1(value, strategy) : value;
+	};
+	const cloneDeep$1 = (parent, strategy$1) => {
+		const newParent = (isObject(parent) ? strategy$1.cloneObject : isArray(parent) ? strategy$1.cloneArray : isMap(parent) ? strategy$1.cloneMap : isSet(parent) ? strategy$1.cloneSet : isDate(parent, false) ? strategy$1.cloneDate : strategy$1.cloneOther)(parent, track.bind(null, parent), clone);
+		if (!newParent) return cloneDeep$1(parent, defaultCloneStrategy);
+		tracked.set(parent, newParent);
+		return newParent;
+	};
+	return cloneDeep$1(root, strategy);
+}
+
+//#endregion
+//#region src/utils/object/enumEntries.ts
+function enumEntries(enumeration) {
+	const [isEnum, isTwoWayEnum] = isEnumeration(enumeration);
+	if (!isEnum) throw Error("function enumEntries expected parameter is a enum, and requires at least one member");
+	const entries = objectEntries(enumeration);
+	if (isTwoWayEnum) return entries.splice(entries.length / 2, entries.length / 2);
+	return entries;
+}
+
+//#endregion
+//#region src/utils/object/enumKeys.ts
+function enumKeys(enumeration) {
+	const [isEnum, isTwoWayEnum] = isEnumeration(enumeration);
+	if (!isEnum) throw Error("function enumKeys expected parameter is a enum, and requires at least one member");
+	const keys = objectKeys(enumeration);
+	if (isTwoWayEnum) return keys.splice(keys.length / 2, keys.length / 2);
+	return keys;
+}
+
+//#endregion
+//#region src/utils/object/enumValues.ts
+function enumValues(enumeration) {
+	const [isEnum, isTwoWayEnum] = isEnumeration(enumeration);
+	if (!isEnum) throw Error("function enumValues expected parameter is a enum, and requires at least one member");
+	const values = objectValues(enumeration);
+	if (isTwoWayEnum) 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/mapEntries.ts
+/**
+* 映射对象条目
+* - 将对象的键值对映射为新的键值对
+*
+* @param obj 对象
+* @param toEntry 映射函数
+* @returns 映射后的新对象
+* @example
+* ```ts
+* const obj = { a: 1, b: 2 };
+* mapEntries(obj, (k, v) => [k, v * 2]); // { a: 2, b: 4 }
+* ```
+*/
+function mapEntries(obj, toEntry) {
+	const defaultResult = {};
+	if (!obj) return defaultResult;
+	return objectEntries(obj).reduce((acc, [key, value]) => {
+		const [newKey, newValue] = toEntry(key, value);
+		acc[newKey] = newValue;
+		return acc;
+	}, defaultResult);
+}
+
+//#endregion
+//#region src/utils/object/objectAssign.ts
+function objectAssign(initial, override) {
+	if (!isObject(initial) || !isObject(override)) return initial ?? override ?? {};
+	const proto = Object.getPrototypeOf(initial);
+	const assigned = proto ? { ...initial } : Object.assign(Object.create(proto), initial);
+	for (const key of Object.keys(override)) assigned[key] = isObject(initial[key]) && isObject(override[key]) ? objectAssign(initial[key], override[key]) : override[key];
+	return assigned;
+}
+
+//#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;
+/**
+* 字符串模板替换
+*
+/**
+* 字符串模板替换
+*
+* @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 "";
+	let result = "";
+	let from = 0;
+	let match;
+	while (match = regex.exec(input)) {
+		result += input.slice(from, match.index) + template[match[1]];
+		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 风格
+*
+/**
+* 将路径转换为 POSIX 风格
+* - 统一使用正斜杠
+* - 处理 Windows 盘符
+*
+* @param input 待处理字符串
+* @param removeLeadingSlash 是否移除开头斜杠，默认为 `false`
+* @returns 转换后的路径
+* @example
+* ```ts
+* stringToPosix("C:\\Windows\\System32"); // "/Windows/System32"
+* ```
+*/
+function stringToPosix(input, removeLeadingSlash = false) {
+	if (!isString(input, true)) return "";
+	let normalized = input.replace(/^[A-Za-z]:[\\/]?/, "").replace(/^[\\/]+/, "/");
+	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 "";
+	if (!isPositiveInteger(maxLength)) return input;
+	if (input.length <= maxLength) return input;
+	const truncated = input.slice(0, maxLength - ellipsis.length);
+	return truncated.length > 0 ? truncated + 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 { arrayCounting as $, toMathEvaluate as A, isEnumeration as At, arrayZipToObject as B, isBigInt as Bt, mapEntries as C, isMap as Ct, enumEntries as D, isFalsyLike as Dt, enumKeys as E, isFalsy as Et, isTablet as F, isFunction as Ft, arrayReplace as G, arrayZip as H, isTypedArray as Ht, isIOSMobile as I, isGeneratorFunction as It, arrayLast as J, arrayPick as K, isMobile as L, isBoolean as Lt, toMathBignumber as M, isClass as Mt, stringToNumber as N, isAsyncFunction as Nt, cloneDeep as O, isError as Ot, to as P, isAsyncGeneratorFunction as Pt, arrayDifference as Q, isBrowser as R, isBlob as Rt, objectAssign as S, isNull as St, enumValues as T, isIterable as Tt, arraySplit as U, isAbortSignal as Ut, arrayUnzip as V, isArray as Vt, arrayReplaceMove as W, arrayFork as X, arrayIntersection as Y, arrayFirst as Z, objectPick as _, isInteger as _t, treeFind as a, isUndefined as at, objectInvert as b, isNumber as bt, stringTruncate as c, isWeakSet as ct, stringToPosix as d, isReadableStream as dt, arrayCompete as et, stringToJson as f, isPromise as ft, objectValues as g, isInfinityLike as gt, stringInitialCase as h, isInfinity as ht, treeForEach as i, isURLSearchParams as it, toMathDecimal as j, isDate as jt, isWithinInterval as k, isEqual as kt, stringTrim as l, isRegExp as lt, stringReplace as m, isObject as mt, rowsToTree as n, isWindow as nt, treeFilter as o, isSymbol as ot, stringTemplate as p, isPromiseLike as pt, arrayMerge as q, treeMap as r, isWebSocket as rt, getTimeZone as s, isSet as st, treeToRows as t, arrayCast as tt, stringToValues as u, isString as ut, objectOmit as v, isNaN as vt, objectEntries as w, isWeakMap as wt, objectCrush as x, isPositiveInteger as xt, objectKeys as y, isNegativeInteger as yt, isWebWorker as z, isFile as zt };
+//# sourceMappingURL=utils-RGh-N7TJ.js.map