@pawover/kit 0.4.1 → 0.5.1

package/packages/hooks/dist/react.js

@@ -1,4 +1,6 @@
 import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { ArrayUtil, EnvUtil, ObjectUtil, StringUtil, TypeUtil } from "@pawover/kit-utils";
+import { clone, isEqual } from "es-toolkit";
 //#region src/react/useLatest.ts
 /**
 * 返回当前最新值的 Hook
@@ -11,2017 +13,6 @@ function useLatest(value) {
 	return ref;
 }
 //#endregion
-//#region ../utils/dist/math-Cvy9HBP0.js
-/**
-* 类型工具类
-*/
-var TypeUtil = class {
-	static PROTOTYPE_TAGS = {
-		STRING: "[object String]",
-		NUMBER: "[object Number]",
-		BOOLEAN: "[object Boolean]",
-		BIGINT: "[object BigInt]",
-		SYMBOL: "[object Symbol]",
-		UNDEFINED: "[object Undefined]",
-		NULL: "[object Null]",
-		OBJECT: "[object Object]",
-		FUNCTION: "[object Function]",
-		GENERATOR_FUNCTION: "[object GeneratorFunction]",
-		ASYNC_FUNCTION: "[object AsyncFunction]",
-		ASYNC_GENERATOR_FUNCTION: "[object AsyncGeneratorFunction]",
-		PROMISE: "[object Promise]",
-		MAP: "[object Map]",
-		SET: "[object Set]",
-		WEAK_MAP: "[object WeakMap]",
-		WEAK_SET: "[object WeakSet]",
-		BLOB: "[object Blob]",
-		FILE: "[object File]",
-		READABLE_STREAM: "[object ReadableStream]",
-		GLOBAL: "[object global]",
-		WINDOW: "[object Window]",
-		IFRAME: "[object HTMLIFrameElement]",
-		DATE: "[object Date]",
-		ERROR: "[object Error]",
-		REG_EXP: "[object RegExp]",
-		WEB_SOCKET: "[object WebSocket]",
-		URL_SEARCH_PARAMS: "[object URLSearchParams]",
-		ABORT_SIGNAL: "[object AbortSignal]"
-	};
-	static TYPED_ARRAY_TAGS = /* @__PURE__ */ new Set([
-		"[object Int8Array]",
-		"[object Uint8Array]",
-		"[object Uint8ClampedArray]",
-		"[object Int16Array]",
-		"[object Uint16Array]",
-		"[object Int32Array]",
-		"[object Uint32Array]",
-		"[object Float32Array]",
-		"[object Float64Array]",
-		"[object BigInt64Array]",
-		"[object BigUint64Array]"
-	]);
-	/**
-	* 获取值的 [[Prototype]] 标签
-	*
-	* @param value - 任意 JavaScript 值
-	* @returns 标准化的类型标签字符串
-	*/
-	static getPrototypeString(value) {
-		return Object.prototype.toString.call(value);
-	}
-	static isConstructable(fn) {
-		try {
-			Reflect.construct(fn, []);
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	/**
-	* 检查 value 是否为 string 类型
-	* - 当 `checkEmpty` 为 `true` 时，会先 trim 再判断是否为空
-	*
-	* @param value 待检查值
-	* @param checkEmpty 是否检查空字符串（含空白字符串），默认为 `false`
-	* @returns 是否为字符串
-	* @example
-	* ```ts
-	* TypeUtil.isString("abc"); // true
-	* TypeUtil.isString(""); // true
-	* TypeUtil.isString("", true); // false
-	* TypeUtil.isString("   ", true); // false
-	* TypeUtil.isString(" a ", true); // true
-	* ```
-	*/
-	static isString(value, checkEmpty = false) {
-		return typeof value === "string" && (!checkEmpty || value.trim().length > 0);
-	}
-	/**
-	* 检查 value 是否为 number 类型
-	* - 默认会调用 `TypeUtil.isNaN`（内部基于 `Number.isNaN`）过滤掉 `NaN`
-	*
-	* @param value 待检查值
-	* @param checkNaN 是否检查 `NaN`，默认为 `true`
-	* @returns 是否为 number
-	* @example
-	* ```ts
-	* TypeUtil.isNumber(1); // true
-	* TypeUtil.isNumber(NaN); // false (default)
-	* TypeUtil.isNumber(NaN, false); // true
-	* ```
-	*/
-	static isNumber(value, checkNaN = true) {
-		return typeof value === "number" && (!checkNaN || !this.isNaN(value));
-	}
-	/**
-	* 检查 value 是否为 NaN
-	* - 禁止使用全局 `isNaN`，其会先进行隐式数字转换，可能导致误判（例如 `isNaN("foo") === true`）
-	* - 使用 `Number.isNaN` 仅在值本身就是 `NaN` 时返回 `true`，语义更严格且更安全
-	*
-	* @param value 待检查值
-	* @returns 是否为 NaN
-	* @example
-	* ```ts
-	* TypeUtil.isNaN(NaN); // true
-	* ```
-	*/
-	static isNaN(value) {
-		return Number.isNaN(value);
-	}
-	/**
-	* 检查 value 是否为整数
-	*
-	* @param value 待检查值
-	* @param checkSafe 是否附加安全整数检查
-	* @returns 是否为整数
-	* @example
-	* ```ts
-	* TypeUtil.isInteger(1); // true
-	* TypeUtil.isInteger(1.1); // false
-	* ```
-	*/
-	static isInteger(value, checkSafe = true) {
-		const check = Number.isInteger(value);
-		return checkSafe ? check && Number.isSafeInteger(value) : check;
-	}
-	/**
-	* 检查 value 是否为正整数
-	* - 此函数中 `0` 不被视为正整数
-	*
-	* @param value 待检查值
-	* @param checkSafe 是否附加安全整数检查
-	* @example
-	* ```ts
-	* TypeUtil.isPositiveInteger(1); // true
-	* TypeUtil.isPositiveInteger(0); // false
-	* ```
-	*/
-	static isPositiveInteger(value, checkSafe = true) {
-		return this.isInteger(value, checkSafe) && value > 0;
-	}
-	/**
-	* 检查 value 是否为负整数
-	* - 此函数中 `0` 不被视为负整数
-	*
-	* @param value 待检查值
-	* @param checkSafe 是否附加安全整数检查
-	* @example
-	* ```ts
-	* TypeUtil.isNegativeInteger(-1); // true
-	* TypeUtil.isNegativeInteger(0); // false
-	* ```
-	*/
-	static isNegativeInteger(value, checkSafe = true) {
-		return this.isInteger(value, checkSafe) && value < 0;
-	}
-	/**
-	* 检查 value 是否为 Infinity
-	* - 排除 `NaN`
-	*
-	* @param value 待检查值
-	* @example
-	* ```ts
-	* TypeUtil.isInfinity(Infinity); // true
-	* TypeUtil.isInfinity(1); // false
-	* ```
-	*/
-	static isInfinity(value) {
-		return this.isNumber(value) && (Number.POSITIVE_INFINITY === value || Number.NEGATIVE_INFINITY === value);
-	}
-	/**
-	* 检查 value 是否类似 Infinity
-	* - 排除 `NaN`
-	*
-	* @param value 待检查值
-	* @example
-	* ```ts
-	* TypeUtil.isInfinityLike("Infinity"); // true
-	* TypeUtil.isInfinityLike("123"); // false
-	* ```
-	*/
-	static isInfinityLike(value) {
-		const check = this.isInfinity(value);
-		if (check) return check;
-		if (typeof value === "string") return [
-			"infinity",
-			"-infinity",
-			"+infinity",
-			"Infinity",
-			"-Infinity",
-			"+Infinity"
-		].includes(value.trim());
-		return false;
-	}
-	/**
-	* 检查 value 是否为 Boolean
-	* @param value 待检查值
-	* @returns 是否为 Boolean
-	* @example
-	* ```ts
-	* TypeUtil.isBoolean(false); // true
-	* ```
-	*/
-	static isBoolean(value) {
-		return typeof value === "boolean";
-	}
-	/**
-	* 检查 value 是否为 BigInt
-	* @param value 待检查值
-	* @returns 是否为 BigInt
-	* @example
-	* ```ts
-	* TypeUtil.isBigInt(1n); // true
-	* ```
-	*/
-	static isBigInt(value) {
-		return typeof value === "bigint";
-	}
-	/**
-	* 检查 value 是否为 Symbol
-	* @param value 待检查值
-	* @returns 是否为 Symbol
-	* @example
-	* ```ts
-	* TypeUtil.isSymbol(Symbol("a")); // true
-	* ```
-	*/
-	static isSymbol(value) {
-		return typeof value === "symbol";
-	}
-	/**
-	* 检查 value 是否为 undefined
-	* @param value 待检查值
-	* @returns 是否为 undefined
-	* @example
-	* ```ts
-	* TypeUtil.isUndefined(undefined); // true
-	* ```
-	*/
-	static isUndefined(value) {
-		return typeof value === "undefined";
-	}
-	/**
-	* 检查 value 是否为 null
-	* @param value 待检查值
-	* @returns 是否为 null
-	* @example
-	* ```ts
-	* TypeUtil.isNull(null); // true
-	* ```
-	*/
-	static isNull(value) {
-		return value === null;
-	}
-	/**
-	* 检查 value 是否为 Function
-	* @param value 待检查值
-	* @returns 是否为 Function
-	* @example
-	* ```ts
-	* TypeUtil.isFunction(() => {}); // true
-	* ```
-	*/
-	static isFunction(value) {
-		return typeof value === "function";
-	}
-	/**
-	* 检查 value 是否为 AsyncFunction
-	* @param value 待检查值
-	* @returns 是否为 AsyncFunction
-	* @example
-	* ```ts
-	* TypeUtil.isAsyncFunction(async () => {}); // true
-	* ```
-	*/
-	static isAsyncFunction(value) {
-		return this.isFunction(value) && this.getPrototypeString(value) === this.PROTOTYPE_TAGS.ASYNC_FUNCTION;
-	}
-	/**
-	* 检查 value 是否为 GeneratorFunction
-	* @param value 待检查值
-	* @returns 是否为 GeneratorFunction
-	* @example
-	* ```ts
-	* TypeUtil.isGeneratorFunction(function * a () {}); // true
-	* ```
-	*/
-	static isGeneratorFunction(value) {
-		return this.isFunction(value) && this.getPrototypeString(value) === this.PROTOTYPE_TAGS.GENERATOR_FUNCTION;
-	}
-	/**
-	* 检查 value 是否为 AsyncGeneratorFunction
-	* @param value 待检查值
-	* @returns 是否为 AsyncGeneratorFunction
-	* @example
-	* ```ts
-	* TypeUtil.isAsyncGeneratorFunction(async function * a () {}); // true
-	* ```
-	*/
-	static isAsyncGeneratorFunction(value) {
-		return this.isFunction(value) && this.getPrototypeString(value) === this.PROTOTYPE_TAGS.ASYNC_GENERATOR_FUNCTION;
-	}
-	/**
-	* 检查 value 是否为 Promise
-	* @param value 待检查值
-	* @returns 是否为 Promise
-	* @example
-	* ```ts
-	* TypeUtil.isPromise(Promise.resolve(1)); // true
-	* ```
-	*/
-	static isPromise(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.PROMISE;
-	}
-	/**
-	* 检查 value 是否为 PromiseLike
-	* - 可识别拥有 then 方法的非 Promise 对象
-	* @param value 待检查值
-	* @returns 是否为 PromiseLike
-	* @example
-	* ```ts
-	* TypeUtil.isPromiseLike({ then: () => {} }); // true
-	* ```
-	*/
-	static isPromiseLike(value) {
-		return this.isPromise(value) || this.isPlainObject(value, false) && this.isFunction(value["then"]);
-	}
-	/**
-	* 判断是否为普通对象类型
-	* - 可选是否检查原型为 `Object.prototype`，防止原型链污染
-	*
-	* @param value 待检查值
-	* @param prototypeCheck 是否进行原型检查，默认 `true`
-	* @returns 是否为 Plain Object (当 prototypeCheck=true) 或 object
-	* @example
-	* ```ts
-	* TypeUtil.isPlainObject({}); // true
-	* TypeUtil.isPlainObject([]); // false
-	* TypeUtil.isPlainObject(new Date()); // false
-	* TypeUtil.isPlainObject(new (class {})()); // false
-	* TypeUtil.isPlainObject(new (class {})(), false); // true
-	* TypeUtil.isPlainObject(Object.create(null)) // false
-	* TypeUtil.isPlainObject(Object.create(null), false) // true
-	* ```
-	*/
-	static isPlainObject(value, prototypeCheck = true) {
-		const check = this.getPrototypeString(value) === this.PROTOTYPE_TAGS.OBJECT;
-		return prototypeCheck ? check && Object.getPrototypeOf(value) === Object.prototype : check;
-	}
-	/**
-	* 判断是否为广义对象类型
-	*
-	* @param value 待检查值
-	* @returns 是否为对象
-	* @example
-	* ```ts
-	* TypeUtil.isObject({}); // true
-	* TypeUtil.isObject([]); // true
-	* TypeUtil.isObject(new Date()); // true
-	* TypeUtil.isObject(null); // false
-	* TypeUtil.isObject("string"); // false
-	* ```
-	*/
-	static isObject(value) {
-		return typeof value === "object" && value !== null;
-	}
-	/**
-	* 判断一个对象是否为有效的枚举
-	* - 枚举成员不能为空
-	* - 枚举成员的键不能具有数值名
-	* - 枚举成员的值必须类型一致且为 `string` 或 `number` 类型
-	* - 枚举成员的值不能重复
-	* - 枚举成员的值必须全部为双向映射或非双向映射
-	*
-	* @param enumeration 待检查值
-	* @returns [是否为有效的枚举, 是否为双向枚举]
-	* @example
-	* ```ts
-	* enum A { X, Y }
-	* TypeUtil.isEnumeration(A); // [true, true]
-	* ```
-	*/
-	static 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];
-	}
-	/**
-	* 检查 value 是否为 Class
-	*
-	* @param value 待检查值
-	* @returns 是否为 Class
-	* @example
-	* ```ts
-	* class A {}
-	* TypeUtil.isClass(A); // true
-	* TypeUtil.isClass(() => {}); // false
-	* ```
-	*/
-	static isClass(value) {
-		return this.isFunction(value) && !this.isAsyncFunction(value) && Function.prototype.toString.call(value).startsWith("class ") && this.isConstructable(value) && value.prototype !== void 0;
-	}
-	/**
-	* 检查 value 是否为数组
-	*
-	* @param value 待检查值
-	* @returns 是否为数组
-	* @example
-	* ```ts
-	* TypeUtil.isArray([]); // true
-	* ```
-	*/
-	static isArray(value) {
-		return Array.isArray(value);
-	}
-	/**
-	* 检查 value 是否为 TypedArray
-	*
-	* @param value 待检查值
-	* @returns 是否为 TypedArray
-	* @example
-	* ```ts
-	* TypeUtil.isTypedArray(new Int8Array()); // true
-	* ```
-	*/
-	static isTypedArray(value) {
-		return typeof value === "object" && value !== null && this.TYPED_ARRAY_TAGS.has(this.getPrototypeString(value));
-	}
-	/**
-	* 检查 value 是否为 Map
-	* @param value 待检查值
-	* @returns 是否为 Map
-	* @example
-	* ```ts
-	* TypeUtil.isMap(new Map()); // true
-	* ```
-	*/
-	static isMap(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.MAP;
-	}
-	/**
-	* 检查 value 是否为 WeakMap
-	* @param value 待检查值
-	* @returns 是否为 WeakMap
-	* @example
-	* ```ts
-	* TypeUtil.isWeakMap(new WeakMap()); // true
-	* ```
-	*/
-	static isWeakMap(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.WEAK_MAP;
-	}
-	/**
-	* 检查 value 是否为 Set
-	* @param value 待检查值
-	* @returns 是否为 Set
-	* @example
-	* ```ts
-	* TypeUtil.isSet(new Set()); // true
-	* ```
-	*/
-	static isSet(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.SET;
-	}
-	/**
-	* 检查 value 是否为 WeakSet
-	* @param value 待检查值
-	* @returns 是否为 WeakSet
-	* @example
-	* ```ts
-	* TypeUtil.isWeakSet(new WeakSet()); // true
-	* ```
-	*/
-	static isWeakSet(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.WEAK_SET;
-	}
-	/**
-	* 检查 value 是否为 Blob
-	* @param value 待检查值
-	* @returns 是否为 Blob
-	* @example
-	* ```ts
-	* TypeUtil.isBlob(new Blob(["a"])); // true
-	* ```
-	*/
-	static isBlob(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.BLOB;
-	}
-	/**
-	* 检查 value 是否为 File
-	* @param value 待检查值
-	* @returns 是否为 File
-	* @example
-	* ```ts
-	* TypeUtil.isFile(new File(["a"], "a.txt")); // true
-	* ```
-	*/
-	static isFile(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.FILE;
-	}
-	/**
-	* 检查 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
-	* @example
-	* ```ts
-	* TypeUtil.isReadableStream(new ReadableStream()); // true
-	* ```
-	*/
-	static isReadableStream(value) {
-		if (this.getPrototypeString(value) === this.PROTOTYPE_TAGS.READABLE_STREAM) return true;
-		return this.isPlainObject(value) && this.isFunction(value["getReader"]) && this.isFunction(value["pipeThrough"]);
-	}
-	/**
-	* 检查 value 是否为 Window
-	* @param value 待检查值
-	* @returns 是否为 Window
-	* @example
-	* ```ts
-	* TypeUtil.isWindow(window); // true
-	* ```
-	*/
-	static isWindow(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.WINDOW;
-	}
-	/**
-	* 检查 value 是否为 HTMLIFrameElement
-	* @param value 待检查值
-	* @returns 是否为 HTMLIFrameElement
-	* @example
-	* ```ts
-	* TypeUtil.isIframe(document.createElement("iframe")); // true
-	* ```
-	*/
-	static isIframe(value) {
-		if (typeof window === "undefined") return false;
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.IFRAME;
-	}
-	/**
-	* 检查 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
-	* TypeUtil.isDate(new Date()); // true
-	* TypeUtil.isDate(new Date('invalid')); // false
-	* TypeUtil.isDate(new Date('invalid'), false); // true
-	* TypeUtil.isDate(null); // false
-	* TypeUtil.isDate({}); // false
-	* ```
-	*/
-	static isDate(value, invalidCheck = true) {
-		if (!value || typeof value !== "object") return false;
-		if (this.getPrototypeString(value) !== this.PROTOTYPE_TAGS.DATE) return false;
-		if (!invalidCheck) return true;
-		try {
-			const time = value.getTime();
-			return typeof time === "number" && !Number.isNaN(time);
-		} catch {
-			return false;
-		}
-	}
-	/**
-	* 检查 value 是否为 Error 对象
-	* @param value 待检查值
-	* @returns 是否为 Error
-	* @example
-	* ```ts
-	* TypeUtil.isError(new Error("x")); // true
-	* ```
-	*/
-	static isError(value) {
-		return value instanceof Error || this.getPrototypeString(value) === this.PROTOTYPE_TAGS.ERROR;
-	}
-	/**
-	* 检查 value 是否为 RegExp
-	* @param value 待检查值
-	* @returns 是否为 RegExp
-	* @example
-	* ```ts
-	* TypeUtil.isRegExp(/a/); // true
-	* ```
-	*/
-	static isRegExp(value) {
-		if (typeof value !== "object" || value === null) return false;
-		try {
-			const regex = value;
-			return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.REG_EXP && this.isString(regex.source) && this.isString(regex.flags) && this.isBoolean(regex.global) && this.isFunction(regex.test);
-		} catch (error) {
-			return false;
-		}
-	}
-	/**
-	* 检查 value 是否为 WebSocket
-	* @param value 待检查值
-	* @returns 是否为 WebSocket
-	* @example
-	* ```ts
-	* TypeUtil.isWebSocket(new WebSocket("wss://echo.websocket.events")); // true
-	* ```
-	*/
-	static isWebSocket(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.WEB_SOCKET;
-	}
-	/**
-	* 检查 value 是否为 URLSearchParams
-	* @param value 待检查值
-	* @returns 是否为 URLSearchParams
-	* @example
-	* ```ts
-	* TypeUtil.isURLSearchParams(new URLSearchParams("a=1")); // true
-	* ```
-	*/
-	static isURLSearchParams(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.URL_SEARCH_PARAMS;
-	}
-	/**
-	* 检查 value 是否为 AbortSignal
-	* @param value 待检查值
-	* @returns 是否为 AbortSignal
-	* @example
-	* ```ts
-	* TypeUtil.isAbortSignal(new AbortController().signal); // true
-	* ```
-	*/
-	static isAbortSignal(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.ABORT_SIGNAL;
-	}
-	/**
-	* 检查 value 是否为可迭代对象 (Iterable)
-	* @param value 待检查值
-	* @returns 是否为 Iterable
-	* @example
-	* ```ts
-	* TypeUtil.isIterable([1, 2]); // true
-	* ```
-	*/
-	static isIterable(value) {
-		return !!value && typeof value[Symbol.iterator] === "function";
-	}
-	/**
-	* 检查 value 是否为 Falsy 值 (false, 0, "", null, undefined, NaN)
-	* @param value 待检查值
-	* @returns 是否为 Falsy
-	* @example
-	* ```ts
-	* TypeUtil.isFalsy(0); // true
-	* ```
-	*/
-	static isFalsy(value) {
-		if (this.isNaN(value) || this.isNull(value) || this.isUndefined(value)) return true;
-		return value === false || value === 0 || value === 0n || value === "";
-	}
-	/**
-	* 检查 value 是否为 FalsyLike 值
-	* - 包含字符串形式的 `"null"`、`"undefined"`、`"false"`、`"0"` 等
-	*
-	* @param value 待检查值
-	* @returns 是否为 FalsyLike
-	* @example
-	* ```ts
-	* TypeUtil.isFalsyLike("false"); // true
-	* TypeUtil.isFalsyLike("hello"); // false
-	* ```
-	*/
-	static isFalsyLike(value) {
-		if (this.isFalsy(value)) return true;
-		return typeof value === "string" && (value === "null" || value === "undefined" || value === "NaN" || value === "false" || value === "0" || value === "-0" || value === "0n");
-	}
-};
-/**
-* 字符串工具类
-*/
-var StringUtil = class {
-	static cast(candidate, checkEmpty = true, trim = true) {
-		if (checkEmpty) {
-			if (candidate === null || candidate === void 0) return "";
-			if (typeof candidate === "string" && candidate.trim().length === 0) return "";
-		}
-		const result = String(candidate);
-		return trim ? result.trim() : result;
-	}
-	/**
-	* 从字符串中提取数字字符串
-	* - 移除非数字字符，保留符号和小数点
-	*
-	* @param input 待处理字符串
-	* @returns 提取出的数字字符串
-	* @example
-	* ```ts
-	* StringUtil.toNumber("$1,234.56"); // "1234.56"
-	* StringUtil.toNumber("abc-123"); // "-123"
-	* ```
-	*/
-	static toNumber(input) {
-		if (!TypeUtil.isString(input, true)) return "0";
-		const cleaned = input.replace(/[^0-9.-]/g, "");
-		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;
-	}
-	static toLowerCase(input) {
-		if (!TypeUtil.isString(input, true)) return "";
-		return input.toLowerCase();
-	}
-	static toUpperCase(input) {
-		if (!TypeUtil.isString(input, true)) return "";
-		return input.toUpperCase();
-	}
-	/**
-	* 字符串首字母大小写
-	* - 包含非西欧字母字符时，不处理
-	* - 纯字母且全大写时，不处理
-	* - 纯字母且非全大写时，首字母小写，其余保留
-	* - 纯字母且非全大写时，首字母大写，其余保留
-	*
-	* @param input 待处理字符串
-	* @param caseType 大小写类型
-	* @returns 处理后的字符串
-	* @example
-	* ```ts
-	* StringUtil.toInitialCase("Hello", "lower"); // "hello"
-	* StringUtil.toInitialCase("hello", "upper"); // "Hello"
-	* ```
-	*/
-	static toInitialCase(input, caseType) {
-		if (!TypeUtil.isString(input, true)) return "";
-		return input.replace(/\S+/g, (word) => {
-			if (/[^a-zA-Z\u00C0-\u017F]/.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;
-		});
-	}
-	/**
-	* 将路径转换为 POSIX 风格
-	* - 统一使用正斜杠 (/)
-	* - 可选移除 Windows 盘符 (如 C:)
-	* - 可选移除开头的斜杠
-	* - 规范化连续斜杠为单个斜杠
-	*
-	* @param input 待处理字符串
-	* @param removeLeadingSlash 是否移除开头斜杠，默认为 `false`。如果移除了盘符，路径通常会以 / 开头，此参数可控制是否保留该 /
-	* @returns 转换后的路径，如果输入无效则返回空字符串
-	*
-	* @example
-	* ```ts
-	* StringUtil.toPosix("C:\\Windows\\System32"); // 默认: "/Windows/System32" (移除了 C: 并标准化)
-	*
-	* StringUtil.toPosix("C:\\Windows\\System32", true); // 移除开头斜杠: "Windows/System32"
-	*
-	* StringUtil.toPosix("\\\\server\\share\\file.txt"); // UNC 路径: "/server/share/file.txt"
-	*
-	* StringUtil.toPosix("folder\\subfolder\\file.txt"); // 相对路径: "folder/subfolder/file.txt"
-	* ```
-	*/
-	static toPosix(input, removeLeadingSlash = false) {
-		if (!TypeUtil.isString(input, true)) return "";
-		let normalized = input.replace(/^[A-Za-z]:([\\/])?/, (_, separator) => {
-			return separator ? "/" : "";
-		});
-		normalized = normalized.replaceAll("\\", "/");
-		normalized = normalized.replaceAll(/\/+/g, "/");
-		if (removeLeadingSlash && normalized.startsWith("/")) normalized = normalized.substring(1);
-		return normalized;
-	}
-	static toJson(input, fallback) {
-		if (!TypeUtil.isString(input, true)) return fallback;
-		try {
-			return JSON.parse(input);
-		} catch (error) {
-			return fallback;
-		}
-	}
-	static toValues(input, valueType = "number", splitSymbol = ",") {
-		if (!TypeUtil.isString(input, true)) return [];
-		try {
-			const values = input.split(splitSymbol);
-			if (valueType === "number") return values.map((d) => Number(d));
-			return values;
-		} catch (error) {
-			return [];
-		}
-	}
-	/**
-	* 从字符串中裁切掉所有的前缀和后缀字符
-	*
-	* @param input 待处理字符串
-	* @param charsToTrim 裁切字符，默认为 `" "`
-	* @returns 裁切后的字符串
-	* @example
-	* ```ts
-	* StringUtil.trim("  hello  "); // "hello"
-	* StringUtil.trim("__hello__", "_"); // "hello"
-	* ```
-	*/
-	static trim(input, charsToTrim = " ") {
-		if (!TypeUtil.isString(input, true)) return "";
-		const toTrim = charsToTrim.replace(/[\W]{1}/g, "\\$&");
-		const regex = new RegExp(`^[${toTrim}]+|[${toTrim}]+$`, "g");
-		return input.replace(regex, "");
-	}
-	/**
-	* 截取字符串
-	* - 支持自定义省略符，不会截断在汉字中间（因为JS字符串本身按字符处理）
-	*
-	* @param input 待处理字符串
-	* @param maxLength 最大长度 (包含省略符)
-	* @param ellipsis 省略符，默认为 `...`
-	* @returns 截取后的字符串
-	* @example
-	* ```ts
-	* StringUtil.truncate("hello world", 8); // "hello..."
-	* ```
-	*/
-	static truncate(input, maxLength, ellipsis = "...") {
-		if (!TypeUtil.isString(input, true)) return "";
-		const codePoints = Array.from(input);
-		if (!TypeUtil.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;
-	}
-	/**
-	* 字符串模板替换
-	* - 使用对象的属性值替换字符串中的 {{key}} 模板
-	*
-	* @param input 待处理字符串
-	* @param template 模板对象
-	* @param regex 模板匹配正则 (默认: `\{\{(.+?)\}\}`)
-	* @returns 替换后的字符串
-	* @example
-	* ```ts
-	* StringUtil.template("Hello {{name}}", { name: "World" }); // "Hello World"
-	* ```
-	*/
-	static template(input, template, regex = /\{\{(.+?)\}\}/g) {
-		if (!TypeUtil.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);
-	}
-	/**
-	* 字符串替换
-	* - 替换第一个匹配项
-	*
-	* @param input 待处理字符串
-	* @param search 匹配项
-	* @param replacement 替换项
-	* @returns 替换后的字符串
-	* @example
-	* ```ts
-	* StringUtil.replace("hello world", "world", "context"); // "hello context"
-	* ```
-	*/
-	static replace(input, search, replacement) {
-		if (!TypeUtil.isString(input, true)) return "";
-		return input.replace(search, replacement);
-	}
-};
-//#endregion
-//#region ../utils/dist/index.js
-/**
-* 数组工具类
-*/
-var ArrayUtil = class {
-	static cast(candidate, checkEmpty = true) {
-		if (checkEmpty && (TypeUtil.isUndefined(candidate) || TypeUtil.isNull(candidate))) return [];
-		return TypeUtil.isArray(candidate) ? [...candidate] : [candidate];
-	}
-	static first(initialList, fallback) {
-		if (!TypeUtil.isArray(initialList) || initialList.length === 0) return fallback;
-		return initialList[0];
-	}
-	static last(initialList, fallback) {
-		if (!TypeUtil.isArray(initialList) || initialList.length === 0) return fallback;
-		return initialList[initialList.length - 1];
-	}
-	/**
-	* 数组竞选
-	* - 返回在匹配函数的比较条件中获胜的最终项目，适用于更复杂的最小值/最大值计算
-	*
-	* @param initialList 数组
-	* @param match 匹配函数
-	* @returns 获胜的元素，如果数组为空或参数无效则返回 `null`
-	* @example
-	* ```ts
-	* const list = [1, 10, 5];
-	* ArrayUtil.compete(list, (a, b) => (a > b ? a : b)); // 10
-	* ArrayUtil.compete(list, (a, b) => (a < b ? a : b)); // 1
-	* ```
-	*/
-	static compete(initialList, match) {
-		if (!TypeUtil.isArray(initialList) || initialList.length === 0 || !TypeUtil.isFunction(match)) return null;
-		return initialList.reduce(match);
-	}
-	/**
-	* 统计数组的项目出现次数
-	* - 通过给定的标识符匹配函数，返回一个对象，其中键是回调函数返回的 key 值，每个值是一个整数，表示该 key 出现的次数
-	*
-	* @param initialList 初始数组
-	* @param match 匹配函数
-	* @returns 统计对象
-	* @example
-	* ```ts
-	* const list = ["a", "b", "a", "c"];
-	* ArrayUtil.count(list, (x) => x); // { a: 2, b: 1, c: 1 }
-	*
-	* const users = [{ id: 1, group: "A" }, { id: 2, group: "B" }, { id: 3, group: "A" }];
-	* ArrayUtil.count(users, (u) => u.group); // { A: 2, B: 1 }
-	* ```
-	*/
-	static count(initialList, match) {
-		if (!TypeUtil.isArray(initialList) || !TypeUtil.isFunction(match)) return {};
-		return initialList.reduce((prev, curr, index) => {
-			const id = match(curr, index).toString();
-			prev[id] = (prev[id] ?? 0) + 1;
-			return prev;
-		}, {});
-	}
-	/**
-	* 获取数组差集
-	* - 返回在 `initialList` 中存在，但在 `diffList` 中不存在的元素
-	*
-	* @param initialList 初始数组
-	* @param diffList 对比数组
-	* @param match 匹配函数
-	* @returns 差集数组
-	* @example
-	* ```ts
-	* ArrayUtil.difference([1, 2, 3], [2, 3, 4]); // [1]
-	* ArrayUtil.difference([{ id: 1 }, { id: 2 }], [{ id: 2 }], (x) => x.id); // [{ id: 1 }]
-	* ```
-	*/
-	static difference(initialList, diffList, match) {
-		if (!TypeUtil.isArray(initialList) && !TypeUtil.isArray(diffList)) return [];
-		if (!TypeUtil.isArray(initialList) || !initialList.length) return [];
-		if (!TypeUtil.isArray(diffList) || !diffList.length) return [...initialList];
-		if (!TypeUtil.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)));
-	}
-	static intersection(initialList, diffList, match) {
-		if (!TypeUtil.isArray(initialList) || !TypeUtil.isArray(diffList)) return [];
-		if (!initialList.length || !diffList.length) return [];
-		if (!TypeUtil.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)));
-	}
-	static merge(initialList, mergeList, match) {
-		if (!TypeUtil.isArray(initialList)) return [];
-		if (!TypeUtil.isArray(mergeList)) return [...initialList];
-		if (!TypeUtil.isFunction(match)) return Array.from(/* @__PURE__ */ 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;
-		});
-	}
-	static pick(initialList, filter, mapper) {
-		if (!TypeUtil.isArray(initialList)) return [];
-		if (!TypeUtil.isFunction(filter)) return [...initialList];
-		const hasMapper = TypeUtil.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;
-		}, []);
-	}
-	static replace(initialList, newItem, match) {
-		if (!TypeUtil.isArray(initialList) || !initialList.length) return [];
-		if (!TypeUtil.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];
-	}
-	/**
-	* 数组项替换并移动
-	* - 在给定的数组中，替换并移动符合匹配函数结果的项目
-	* - 只替换和移动第一个匹配项
-	* - 未匹配时，根据 `position` 在指定位置插入 `newItem`
-	*
-	* @param initialList 初始数组
-	* @param newItem 替换项
-	* @param match 匹配函数
-	* @param position 移动位置，可选 `start` | `end` | 索引位置， 默认为 `end`
-	* @returns
-	* @example
-	* ```ts
-	* ArrayUtil.replaceMove([1, 2, 3, 4], 5, (n) => n === 2, 0); // [5, 1, 3, 4]
-	* ArrayUtil.replaceMove([1, 2, 3, 4], 5, (n) => n === 2, 2); // [1, 3, 5, 4]
-	* ArrayUtil.replaceMove([1, 2, 3, 4], 5, (n) => n === 2, "start"); // [5, 1, 3, 4]
-	* ArrayUtil.replaceMove([1, 2, 3, 4], 5, (n) => n === 2); // [1, 3, 4, 5]
-	* ```
-	*/
-	static replaceMove(initialList, newItem, match, position) {
-		if (!TypeUtil.isArray(initialList)) return [];
-		if (!initialList.length) return [newItem];
-		if (!TypeUtil.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 || TypeUtil.isPositiveInteger(position, false)) result.splice(Math.min(position, result.length), 0, newItem);
-		else result.push(newItem);
-		return result;
-	}
-	/**
-	* 数组切分
-	* - 将数组以指定的长度切分后，组合在高维数组中
-	*
-	* @param initialList 初始数组
-	* @param size 分割尺寸，默认 `10`
-	* @returns 切分后的二维数组
-	* @example
-	* ```ts
-	* ArrayUtil.split([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]
-	* ```
-	*/
-	static split(initialList, size = 10) {
-		if (!TypeUtil.isArray(initialList)) return [];
-		if (!TypeUtil.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);
-		});
-	}
-	/**
-	* 数组分组过滤
-	* - 给定一个数组和一个条件，返回一个由两个数组组成的元组，其中第一个数组包含所有满足条件的项，第二个数组包含所有不满足条件的项
-	*
-	* @param initialList 初始数组
-	* @param match 条件匹配函数
-	* @returns [满足条件的项[], 不满足条件的项[]]
-	* @example
-	* ```ts
-	* ArrayUtil.fork([1, 2, 3, 4], (n) => n % 2 === 0); // [[2, 4], [1, 3]]
-	* ```
-	*/
-	static fork(initialList, match) {
-		const forked = [[], []];
-		if (TypeUtil.isArray(initialList)) initialList.forEach((item, index) => {
-			forked[match(item, index) ? 0 : 1].push(item);
-		});
-		return forked;
-	}
-	/**
-	* 数组解压
-	* - `ArrayUtil.zip` 的反向操作
-	*
-	* @param arrayList 压缩后的数组
-	* @returns 解压后的二维数组
-	* @example
-	* ```ts
-	* ArrayUtil.unzip([[1, "a"], [2, "b"]]); // [[1, 2], ["a", "b"]]
-	* ```
-	*/
-	static unzip(arrayList) {
-		if (!TypeUtil.isArray(arrayList) || !arrayList.length) return [];
-		const out = new Array(arrayList.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(arrayList, get);
-		return out;
-	}
-	static zip(...arrays) {
-		return this.unzip(arrays);
-	}
-	static zipToObject(keys, values) {
-		const result = {};
-		if (!TypeUtil.isArray(keys) || !keys.length) return result;
-		const getValue = TypeUtil.isFunction(values) ? values : TypeUtil.isArray(values) ? (_k, i) => values[i] : (_k, _i) => values;
-		return keys.reduce((acc, key, idx) => {
-			acc[key] = getValue(key, idx);
-			return acc;
-		}, result);
-	}
-};
-(class {
-	/**
-	* 每秒的毫秒数
-	* @example
-	* ```ts
-	* DateTimeUtil.MILLISECONDS_PER_SECOND; // 1000
-	* ```
-	*/
-	static MILLISECONDS_PER_SECOND = 1e3;
-	/**
-	* 每分钟的秒数
-	* @example
-	* ```ts
-	* DateTimeUtil.SECOND_PER_MINUTE; // 60
-	* ```
-	*/
-	static SECOND_PER_MINUTE = 60;
-	/**
-	* 每小时的分钟数
-	* @example
-	* ```ts
-	* DateTimeUtil.MINUTE_PER_HOUR; // 60
-	* ```
-	*/
-	static MINUTE_PER_HOUR = 60;
-	/**
-	* 每小时的秒数
-	* @example
-	* ```ts
-	* DateTimeUtil.SECOND_PER_HOUR; // 3600
-	* ```
-	*/
-	static SECOND_PER_HOUR = this.SECOND_PER_MINUTE ** 2;
-	/**
-	* 每天小时数
-	* @example
-	* ```ts
-	* DateTimeUtil.HOUR_PER_DAY; // 24
-	* ```
-	*/
-	static HOUR_PER_DAY = 24;
-	/**
-	* 每天秒数
-	* @example
-	* ```ts
-	* DateTimeUtil.SECOND_PER_DAY; // 86400
-	* ```
-	*/
-	static SECOND_PER_DAY = this.SECOND_PER_HOUR * this.HOUR_PER_DAY;
-	/**
-	* 每周天数
-	* @example
-	* ```ts
-	* DateTimeUtil.DAY_PER_WEEK; // 7
-	* ```
-	*/
-	static DAY_PER_WEEK = 7;
-	/**
-	* 每月天数
-	* @example
-	* ```ts
-	* DateTimeUtil.DAY_PER_MONTH; // 30
-	* ```
-	*/
-	static DAY_PER_MONTH = 30;
-	/**
-	* 每年天数
-	* @example
-	* ```ts
-	* DateTimeUtil.DAY_PER_YEAR; // 365
-	* ```
-	*/
-	static DAY_PER_YEAR = 365;
-	/**
-	* 每年月数
-	* @example
-	* ```ts
-	* DateTimeUtil.MONTH_PER_YEAR; // 12
-	* ```
-	*/
-	static MONTH_PER_YEAR = 12;
-	/**
-	* 每年平均周
-	* @example
-	* ```ts
-	* DateTimeUtil.WEEK_PER_YEAR; // 52
-	* ```
-	*/
-	static WEEK_PER_YEAR = 52;
-	/**
-	* 每月平均周
-	* @example
-	* ```ts
-	* DateTimeUtil.WEEK_PER_MONTH; // 4
-	* ```
-	*/
-	static WEEK_PER_MONTH = 4;
-	/**
-	* 常用时间格式模板集合
-	*
-	* @example
-	* ```ts
-	* DateTimeUtil.FORMAT.ISO_DATE; // "yyyy-MM-dd"
-	* DateTimeUtil.FORMAT.CN_DATE_TIME; // "yyyy年MM月dd日 HH时mm分ss秒"
-	* ```
-	*/
-	static FORMAT = {
-		ISO_DATE: "yyyy-MM-dd",
-		ISO_TIME: "HH:mm:ss",
-		ISO_DATE_TIME: "yyyy-MM-dd HH:mm:ss",
-		ISO_DATE_TIME_MS: "yyyy-MM-dd HH:mm:ss.SSS",
-		ISO_DATETIME_TZ: "yyyy-MM-dd'T'HH:mm:ssXXX",
-		ISO_DATETIME_TZ_MS: "yyyy-MM-dd'T'HH:mm:ss.SSSXXX",
-		US_DATE: "MM/dd/yyyy",
-		US_DATE_TIME: "MM/dd/yyyy HH:mm:ss",
-		US_DATE_SHORT_YEAR: "MM/dd/yy",
-		EU_DATE: "dd/MM/yyyy",
-		EU_DATE_TIME: "dd/MM/yyyy HH:mm:ss",
-		CN_DATE: "yyyy年MM月dd日",
-		CN_DATE_TIME: "yyyy年MM月dd日 HH时mm分ss秒",
-		CN_DATE_WEEKDAY: "yyyy年MM月dd日 EEE",
-		CN_WEEKDAY_FULL: "EEEE",
-		SHORT_DATE: "yy-MM-dd",
-		SHORT_DATE_SLASH: "yy/MM/dd",
-		MONTH_DAY: "MM-dd",
-		MONTH_DAY_CN: "MM月dd日",
-		DATE_WITH_WEEKDAY_SHORT: "yyyy-MM-dd (EEE)",
-		DATE_WITH_WEEKDAY_FULL: "yyyy-MM-dd (EEEE)",
-		TIME_24: "HH:mm:ss",
-		TIME_24_NO_SEC: "HH:mm",
-		TIME_12: "hh:mm:ss a",
-		TIME_12_NO_SEC: "hh:mm a",
-		TIMESTAMP: "yyyyMMddHHmmss",
-		TIMESTAMP_MS: "yyyyMMddHHmmssSSS",
-		RFC2822: "EEE, dd MMM yyyy HH:mm:ss xxx",
-		READABLE_DATE: "MMM dd, yyyy",
-		READABLE_DATE_TIME: "MMM dd, yyyy HH:mm",
-		COMPACT_DATETIME: "yyyyMMdd_HHmmss"
-	};
-	/**
-	* 获取当前时区信息
-	*
-	* @returns 时区信息对象 (UTC偏移和时区名称)
-	* @example
-	* ```ts
-	* DateTimeUtil.getTimeZone(); // { UTC: "UTC+8", timeZone: "Asia/Shanghai" }
-	* ```
-	*/
-	static getTimeZone() {
-		const hour = 0 - (/* @__PURE__ */ new Date()).getTimezoneOffset() / this.MINUTE_PER_HOUR;
-		return {
-			UTC: "UTC" + (hour >= 0 ? "+" + hour : hour),
-			timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone
-		};
-	}
-});
-/**
-* 环境检查工具类
-*/
-var EnvUtil = class {
-	static _isBrowser = typeof window !== "undefined" && TypeUtil.isFunction(window?.document?.createElement);
-	static _isWebWorker = typeof window === "undefined" && typeof self !== "undefined" && "importScripts" in self;
-	static _isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
-	/**
-	* 检测是否处于浏览器环境
-	*
-	* @returns 是否为浏览器环境
-	* @example
-	* ```ts
-	* EnvUtil.isBrowser(); // true: 浏览器, false: Node.js
-	* ```
-	*/
-	static isBrowser() {
-		return this._isBrowser;
-	}
-	/**
-	* 检测是否处于 Web Worker 环境
-	*
-	* @returns 是否为 Web Worker 环境
-	* @example
-	* ```ts
-	* EnvUtil.isWebWorker(); // true: Worker, false: 主线程/Node.js
-	* ```
-	*/
-	static isWebWorker() {
-		return this._isWebWorker;
-	}
-	/**
-	* 检测是否处于 React Native 环境
-	*
-	* @returns 是否为 React Native 环境
-	* @example
-	* ```ts
-	* EnvUtil.isReactNative(); // true: React Native, false: Web/Node.js
-	* ```
-	*/
-	static isReactNative() {
-		return this._isReactNative;
-	}
-	/**
-	* 检查是否在 iframe 环境中
-	*
-	* @returns 是否在 iframe 中
-	* @example
-	* ```ts
-	* EnvUtil.isIframe(); // true: 当前页面在 iframe 中
-	* ```
-	*/
-	static isIframe() {
-		if (typeof window === "undefined") return false;
-		try {
-			return window.top !== window.self;
-		} catch (error) {
-			if (error.name === "SecurityError") return true;
-			return false;
-		}
-	}
-	/**
-	* 检测当前设备是否为桌面设备
-	*
-	* @param minWidth - 桌面设备最小宽度（默认 1200px）
-	* @param minScreenSize - 桌面设备最小屏幕尺寸（默认 10英寸）
-	* @param dpi - 标准 DPI 基准（默认 160）
-	* @returns 是否为桌面设备
-	* @example
-	* ```ts
-	* // 假设 window.innerWidth = 1920
-	* EnvUtil.isDesktop(); // true
-	*
-	* // 自定义阈值
-	* EnvUtil.isDesktop(1440, 13); // 更严格的桌面检测
-	* ```
-	*/
-	static isDesktop(minWidth = 1200, minScreenSize = 10, dpi = 160) {
-		if (typeof window === "undefined" || !TypeUtil.isPositiveInteger(minWidth) || !TypeUtil.isPositiveInteger(minScreenSize)) return false;
-		if (window.innerWidth < minWidth) return false;
-		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;
-			return Math.sqrt(widthInch ** 2 + heightInch ** 2) >= minScreenSize;
-		} catch {
-			return true;
-		}
-	}
-	/**
-	* 检测当前设备是否为 Windows 桌面设备
-	*
-	* @param minWidth - 桌面设备最小宽度（默认 1200px）
-	* @param minScreenSize - 桌面设备最小屏幕尺寸（默认 10英寸）
-	* @param dpi - 标准 DPI 基准（默认 160）
-	* @returns 是否为 Windows 桌面设备
-	* @example
-	* ```ts
-	* // UA contains Windows
-	* EnvUtil.isWindowsDesktop(); // true
-	* ```
-	*/
-	static isWindowsDesktop(minWidth = 1200, minScreenSize = 10, dpi = 160) {
-		if (typeof navigator === "undefined" || !navigator.userAgent) return false;
-		return /Windows/i.test(navigator.userAgent) && this.isDesktop(minWidth, minScreenSize, dpi);
-	}
-	/**
-	* 检测当前设备是否为 macOS 桌面设备
-	*
-	* @param minWidth - 桌面设备最小宽度（默认 1200px）
-	* @param minScreenSize - 桌面设备最小屏幕尺寸（默认 10英寸）
-	* @param dpi - 标准 DPI 基准（默认 160）
-	* @returns 是否为 macOS 桌面设备
-	* @example
-	* ```ts
-	* // UA contains Macintosh
-	* EnvUtil.isMacOSDesktop(); // true
-	* ```
-	*/
-	static isMacOSDesktop(minWidth = 1200, minScreenSize = 10, dpi = 160) {
-		if (typeof navigator === "undefined" || !navigator.userAgent) return false;
-		return /Macintosh/i.test(navigator.userAgent) && this.isDesktop(minWidth, minScreenSize, dpi);
-	}
-	/**
-	* 检测当前设备是否为移动设备
-	*
-	* @param maxWidth - 移动设备最大宽度（默认 768px）
-	* @param dpi - 标准 DPI 基准（默认 160）
-	* @returns 是否为移动设备
-	* @example
-	* ```ts
-	* // 假设 window.innerWidth = 500
-	* EnvUtil.isMobile(); // true
-	* ```
-	*/
-	static isMobile(maxWidth = 768, dpi = 160) {
-		if (typeof window === "undefined" || !TypeUtil.isPositiveInteger(maxWidth)) return false;
-		if (window.innerWidth >= maxWidth) return false;
-		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;
-			return Math.sqrt(widthInch ** 2 + heightInch ** 2) < 7;
-		} catch {
-			return true;
-		}
-	}
-	/**
-	* 检测当前设备是否为IOS移动设备
-	*
-	* @param maxWidth - 移动设备最大宽度（默认 768px）
-	* @param dpi - 标准 DPI 基准（默认 160）
-	* @returns 是否为 iOS 移动设备 (iPhone/iPod)
-	* @example
-	* ```ts
-	* // UA contains iPhone
-	* EnvUtil.isIOSMobile(); // true
-	* ```
-	*/
-	static isIOSMobile(maxWidth = 768, dpi = 160) {
-		if (typeof navigator === "undefined" || !navigator.userAgent) return false;
-		return /iPhone|iPad|iPod/i.test(navigator.userAgent) && this.isMobile(maxWidth, dpi);
-	}
-	/**
-	* 检测当前设备是否为平板
-	*
-	* @param minWidth - 平板最小宽度（默认 768px）
-	* @param maxWidth - 平板最大宽度（默认 1200px）
-	* @param dpi - 标准 DPI 基准（默认 160）
-	* @returns 是否为平板设备
-	* @example
-	* ```ts
-	* // 假设 window.innerWidth = 1000
-	* EnvUtil.isTablet(); // true
-	* ```
-	*/
-	static isTablet(minWidth = 768, maxWidth = 1200, dpi = 160) {
-		if (typeof window === "undefined" || !TypeUtil.isPositiveInteger(minWidth) || !TypeUtil.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;
-		}
-	}
-};
-/**
-* MIME 工具类
-*/
-var MimeUtil = class {
-	/**
-	* 文件类型 MIME 常量
-	* - 每个类型对应具体的文件扩展名
-	*/
-	static FILE_MIME = {
-		/** 普通文本文件（.txt） */
-		TEXT: "text/plain",
-		/** 超文本标记语言文档（.html/.htm） */
-		HTML: "text/html",
-		/** 层叠样式表文件（.css） */
-		CSS: "text/css",
-		/** 逗号分隔值文件/表格数据（.csv） */
-		CSV: "text/csv",
-		/** 制表符分隔值文件（.tsv） */
-		TSV: "text/tab-separated-values",
-		/** XML 文档（.xml） */
-		XML: "application/xml",
-		/** XML 文档/兼容值 */
-		XML_LEGACY: "text/xml",
-		/** XHTML 文档（.xhtml/.xht） */
-		XHTML: "application/xhtml+xml",
-		/** JavaScript 文件（.js） */
-		JS: "text/javascript",
-		/** TypeScript 文件（.ts） */
-		TS: "text/typescript",
-		/** Python 文件（.py） */
-		PY: "text/x-python",
-		/** Shell 脚本 (.sh) */
-		SH: "text/x-sh",
-		/** C 语言源文件（.c） */
-		C: "text/x-c",
-		/** C++ 源文件（.cpp/.cc/.cxx） */
-		CPP: "text/x-c++",
-		/** C# 源文件（.cs） */
-		CSHARP: "text/x-csharp",
-		/** Java 源文件（.java） */
-		JAVA: "text/x-java",
-		/** Go 源文件（.go） */
-		GO: "text/x-go",
-		/** Rust 源文件（.rs） */
-		RUST: "text/x-rust",
-		/** PHP 文件（.php） */
-		PHP: "text/x-php",
-		/** Ruby 文件（.rb） */
-		RUBY: "text/x-ruby",
-		/** Swift 源文件（.swift） */
-		SWIFT: "text/x-swift",
-		/** YAML 文档（.yaml/.yml） */
-		YAML: "application/yaml",
-		/** YAML 文档/兼容值 */
-		YAML_LEGACY: "text/vnd.yaml",
-		/** TOML 文档（.toml） */
-		TOML: "application/toml",
-		/** TOML 文档/兼容值 */
-		TOML_LEGACY: "text/x-toml",
-		/** SQL 脚本（.sql） */
-		SQL: "application/sql",
-		/** SQL 脚本/兼容值 */
-		SQL_LEGACY: "text/x-sql",
-		/** Markdown 格式文档（.md/.markdown） */
-		MARKDOWN: "text/markdown",
-		/** 富文本格式文档（.rtf） */
-		RTF: "application/rtf",
-		/** iCalendar 日历格式（.ics） */
-		CALENDAR: "text/calendar",
-		/** JPEG 图像（.jpg/.jpeg） */
-		JPEG: "image/jpeg",
-		/** JPG 图像（JPEG 别名，.jpg） */
-		JPG: "image/jpeg",
-		/** PNG 图像/无损压缩，支持透明（.png） */
-		PNG: "image/png",
-		/** GIF 图像/支持动画（.gif） */
-		GIF: "image/gif",
-		/** Windows 位图（.bmp） */
-		BMP: "image/bmp",
-		/** SVG 向量图形（.svg） */
-		SVG: "image/svg+xml",
-		/** APNG 动态图像（.apng） */
-		APNG: "image/apng",
-		/** AVIF 图像/高效压缩（.avif） */
-		AVIF: "image/avif",
-		/** 图标文件格式（.ico） */
-		ICO: "image/vnd.microsoft.icon",
-		/** 图标文件格式/兼容值（.ico） */
-		ICO_LEGACY: "image/x-icon",
-		/** WebP 图像/高效压缩（.webp） */
-		WEBP: "image/webp",
-		/** TIFF 图像（.tif/.tiff） */
-		TIFF: "image/tiff",
-		/** HEIC 图像/高效编码（.heic） */
-		HEIC: "image/heic",
-		/** HEIF 图像/高效编码（.heif） */
-		HEIF: "image/heif",
-		/** Adobe Photoshop 文件（.psd） */
-		PSD: "image/vnd.adobe.photoshop",
-		/** MP3 音频（.mp3） */
-		MP3: "audio/mpeg",
-		/** AAC 音频（.aac） */
-		AAC: "audio/aac",
-		/** MIDI 音乐文件（.mid/.midi） */
-		MIDI: "audio/midi",
-		/** OGG 音频（.oga） */
-		OGG_AUDIO: "audio/ogg",
-		/** Opus 音频（.opus） */
-		OPUS: "audio/opus",
-		/** FLAC 无损音频（.flac） */
-		FLAC: "audio/flac",
-		/** WAV 音频（.wav） */
-		WAV: "audio/wav",
-		/** WebM 音频（.weba） */
-		WEBM_AUDIO: "audio/webm",
-		/** RealAudio 音频（.ra/.ram） */
-		REAL_AUDIO: "audio/x-pn-realaudio",
-		/** MP4 视频（.mp4） */
-		MP4: "video/mp4",
-		/** MPEG 视频（.mpeg/.mpg） */
-		MPEG: "video/mpeg",
-		/** OGG 视频（.ogv） */
-		OGG_VIDEO: "video/ogg",
-		/** AVI 视频（.avi） */
-		AVI: "video/x-msvideo",
-		/** 3GPP 视频（.3gp） */
-		THREE_GPP: "video/3gpp",
-		/** 3GPP2 视频（.3g2） */
-		THREE_GPP2: "video/3gpp2",
-		/** WebM 视频（.webm） */
-		WEBM: "video/webm",
-		/** Matroska 视频（.mkv） */
-		MKV: "video/x-matroska",
-		/** Matroska 音频（.mka） */
-		MKA: "audio/x-matroska",
-		/** QuickTime 视频（.mov） */
-		QUICKTIME: "video/quicktime",
-		/** PDF 文档（.pdf） */
-		PDF: "application/pdf",
-		/** Word 97-2003 文档（.doc） */
-		DOC: "application/msword",
-		/** Word 2007+ 文档（.docx） */
-		DOCX: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-		/** Excel 2007+ 工作簿（.xlsx） */
-		XLSX: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-		/** 启用宏的Excel工作簿（.xlsm） */
-		XLSM: "application/vnd.ms-excel.sheet.macroEnabled.12",
-		/** Excel模板文件（.xltx） */
-		XLTX: "application/vnd.openxmlformats-officedocument.spreadsheetml.template",
-		/** PowerPoint 2007+ 演示文稿（.pptx） */
-		PPTX: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-		/** PowerPoint 97-2003 演示文稿（.ppt） */
-		PPT: "application/vnd.ms-powerpoint",
-		/** OpenDocument 文本文档（.odt） */
-		ODT: "application/vnd.oasis.opendocument.text",
-		/** OpenDocument 表格文档（.ods） */
-		ODS: "application/vnd.oasis.opendocument.spreadsheet",
-		/** OpenDocument 演示文稿（.odp） */
-		ODP: "application/vnd.oasis.opendocument.presentation",
-		/** EPUB 电子书（.epub） */
-		EPUB: "application/epub+zip",
-		/** Kindle 电子书（.azw） */
-		AZW: "application/vnd.amazon.ebook",
-		/** ZIP 压缩文件（.zip） */
-		ZIP: "application/zip",
-		/** GZIP 压缩文件（.gz） */
-		GZIP: "application/gzip",
-		/** TAR 归档文件（.tar） */
-		TAR: "application/x-tar",
-		/** BZip 归档（.bz） */
-		BZIP: "application/x-bzip",
-		/** BZip2 归档（.bz2） */
-		BZIP2: "application/x-bzip2",
-		/** 7-Zip 压缩文件（.7z） */
-		SEVEN_Z: "application/x-7z-compressed",
-		/** RAR 压缩文件（.rar） */
-		RAR: "application/vnd.rar",
-		/** XZ 压缩文件（.xz） */
-		XZ: "application/x-xz",
-		/** Zstandard 压缩文件（.zst） */
-		ZSTD: "application/zstd",
-		/** ISO 光盘镜像（.iso） */
-		ISO9660_IMAGE: "application/x-iso9660-image",
-		/** JSON 数据格式（.json） */
-		JSON: "application/json",
-		/** JSON-LD 格式（.jsonld） */
-		LD_JSON: "application/ld+json",
-		/** Web App Manifest（.webmanifest） */
-		MANIFEST: "application/manifest+json",
-		/** Java 归档文件（.jar） */
-		JAR: "application/java-archive",
-		/** WebAssembly 二进制指令格式（.wasm） */
-		WASM: "application/wasm",
-		/** MS 嵌入式 OpenType 字体（.eot） */
-		EOT: "application/vnd.ms-fontobject",
-		/** OpenType 字体（.otf） */
-		OTF: "font/otf",
-		/** WOFF 字体（.woff） */
-		WOFF: "font/woff",
-		/** WOFF2 字体（.woff2） */
-		WOFF2: "font/woff2",
-		/** TrueType 字体（.ttf） */
-		TTF: "font/ttf",
-		/** Excel 97-2003 工作簿（.xls） */
-		XLS: "application/vnd.ms-excel",
-		/** Microsoft XPS 文档（.xps） */
-		XPS: "application/vnd.ms-xpsdocument",
-		/** Word 启用宏文档（.docm） */
-		DOCM: "application/vnd.ms-word.document.macroEnabled.12"
-	};
-	/**
-	* 协议/内容类型 MIME 常量
-	* - 用于 HTTP 请求/响应内容协商，无对应文件扩展名
-	*/
-	static PROTOCOL_MIME = {
-		/** 通用二进制数据流 */
-		OCTET_STREAM: "application/octet-stream",
-		/** URL 编码表单 */
-		FORM_URLENCODED: "application/x-www-form-urlencoded",
-		/** multipart 表单 */
-		FORM_DATA: "multipart/form-data",
-		/** Server-Sent Events 数据流 */
-		EVENT_STREAM: "text/event-stream",
-		/** 问题详情 JSON（RFC 9457） */
-		PROBLEM_JSON: "application/problem+json",
-		/** JSON Patch（RFC 6902） */
-		JSON_PATCH: "application/json-patch+json",
-		/** JSON Merge Patch（RFC 7386） */
-		MERGE_PATCH_JSON: "application/merge-patch+json"
-	};
-	/**
-	* 根据文件后缀名获取对应的标准 MIME 类型（含历史兼容值）
-	* - 支持带 `.` 或不带 `.` 的后缀名，不区分大小写
-	* - 元组第一项始终为 IANA 官方标准 MIME，后续项为历史兼容值
-	* - 仅查询文件类型 MIME，不包含无后缀对应的协议类型
-	*
-	* @param extension 文件后缀名（如 `".png"` / `"png"` / `".PNG"`）
-	* @returns 标准 MIME + 兼容值的元组；如无匹配则返回 `undefined`
-	* @example
-	* ```ts
-	* MimeUtil.fromExtension(".png");  // ["image/png"]
-	* MimeUtil.fromExtension("ico");   // ["image/vnd.microsoft.icon", "image/x-icon"]
-	* MimeUtil.fromExtension(".xml");  // ["application/xml", "text/xml"]
-	* MimeUtil.fromExtension(".xyz");  // undefined
-	* ```
-	*/
-	static fromExtension(extension) {
-		const ext = StringUtil.cast(extension).toLowerCase();
-		const key = ext.startsWith(".") ? ext : `.${ext}`;
-		return EXT_TO_MIME[key];
-	}
-	/**
-	* 根据 MIME 类型获取对应的文件后缀名列表
-	* - 一个 MIME 类型可能对应多个后缀名（如 `text/html` → `.html` / `.htm`）
-	* - 兼容值和标准值映射到相同的后缀（如 `image/x-icon` 和 `image/vnd.microsoft.icon` 均返回 `[".ico"]`）
-	* - 仅查询文件类型 MIME，协议类型无对应后缀
-	*
-	* @param mime MIME 类型字符串（如 `"image/png"` / `"IMAGE/PNG"`）
-	* @returns 文件后缀名列表；如无匹配则返回 `undefined`
-	* @example
-	* ```ts
-	* MimeUtil.toExtension("IMAGE/PNG");                    // [".png"]
-	* MimeUtil.toExtension("text/html");                    // [".html", ".htm"]
-	* MimeUtil.toExtension("image/jpeg");                   // [".jpg", ".jpeg"]
-	* MimeUtil.toExtension("application/octet-stream");     // undefined
-	* ```
-	*/
-	static toExtension(mime) {
-		const m = StringUtil.cast(mime).toLowerCase();
-		return MIME_TO_EXT.get(m);
-	}
-};
-const EXT_TO_MIME = {
-	".txt": [MimeUtil.FILE_MIME.TEXT],
-	".html": [MimeUtil.FILE_MIME.HTML],
-	".htm": [MimeUtil.FILE_MIME.HTML],
-	".css": [MimeUtil.FILE_MIME.CSS],
-	".csv": [MimeUtil.FILE_MIME.CSV],
-	".tsv": [MimeUtil.FILE_MIME.TSV],
-	".xml": [MimeUtil.FILE_MIME.XML, MimeUtil.FILE_MIME.XML_LEGACY],
-	".xhtml": [MimeUtil.FILE_MIME.XHTML],
-	".xht": [MimeUtil.FILE_MIME.XHTML],
-	".js": [MimeUtil.FILE_MIME.JS],
-	".ts": [MimeUtil.FILE_MIME.TS],
-	".py": [MimeUtil.FILE_MIME.PY],
-	".sh": [MimeUtil.FILE_MIME.SH],
-	".c": [MimeUtil.FILE_MIME.C],
-	".cpp": [MimeUtil.FILE_MIME.CPP],
-	".cc": [MimeUtil.FILE_MIME.CPP],
-	".cxx": [MimeUtil.FILE_MIME.CPP],
-	".cs": [MimeUtil.FILE_MIME.CSHARP],
-	".java": [MimeUtil.FILE_MIME.JAVA],
-	".go": [MimeUtil.FILE_MIME.GO],
-	".rs": [MimeUtil.FILE_MIME.RUST],
-	".php": [MimeUtil.FILE_MIME.PHP],
-	".rb": [MimeUtil.FILE_MIME.RUBY],
-	".swift": [MimeUtil.FILE_MIME.SWIFT],
-	".yaml": [MimeUtil.FILE_MIME.YAML, MimeUtil.FILE_MIME.YAML_LEGACY],
-	".yml": [MimeUtil.FILE_MIME.YAML, MimeUtil.FILE_MIME.YAML_LEGACY],
-	".toml": [MimeUtil.FILE_MIME.TOML, MimeUtil.FILE_MIME.TOML_LEGACY],
-	".sql": [MimeUtil.FILE_MIME.SQL, MimeUtil.FILE_MIME.SQL_LEGACY],
-	".md": [MimeUtil.FILE_MIME.MARKDOWN],
-	".markdown": [MimeUtil.FILE_MIME.MARKDOWN],
-	".rtf": [MimeUtil.FILE_MIME.RTF],
-	".ics": [MimeUtil.FILE_MIME.CALENDAR],
-	".jpg": [MimeUtil.FILE_MIME.JPEG],
-	".jpeg": [MimeUtil.FILE_MIME.JPEG],
-	".png": [MimeUtil.FILE_MIME.PNG],
-	".gif": [MimeUtil.FILE_MIME.GIF],
-	".bmp": [MimeUtil.FILE_MIME.BMP],
-	".svg": [MimeUtil.FILE_MIME.SVG],
-	".apng": [MimeUtil.FILE_MIME.APNG],
-	".avif": [MimeUtil.FILE_MIME.AVIF],
-	".ico": [MimeUtil.FILE_MIME.ICO, MimeUtil.FILE_MIME.ICO_LEGACY],
-	".webp": [MimeUtil.FILE_MIME.WEBP],
-	".tif": [MimeUtil.FILE_MIME.TIFF],
-	".tiff": [MimeUtil.FILE_MIME.TIFF],
-	".heic": [MimeUtil.FILE_MIME.HEIC],
-	".heif": [MimeUtil.FILE_MIME.HEIF],
-	".psd": [MimeUtil.FILE_MIME.PSD],
-	".mp3": [MimeUtil.FILE_MIME.MP3],
-	".aac": [MimeUtil.FILE_MIME.AAC],
-	".mid": [MimeUtil.FILE_MIME.MIDI],
-	".midi": [MimeUtil.FILE_MIME.MIDI],
-	".oga": [MimeUtil.FILE_MIME.OGG_AUDIO],
-	".opus": [MimeUtil.FILE_MIME.OPUS],
-	".flac": [MimeUtil.FILE_MIME.FLAC],
-	".wav": [MimeUtil.FILE_MIME.WAV],
-	".weba": [MimeUtil.FILE_MIME.WEBM_AUDIO],
-	".ra": [MimeUtil.FILE_MIME.REAL_AUDIO],
-	".ram": [MimeUtil.FILE_MIME.REAL_AUDIO],
-	".mp4": [MimeUtil.FILE_MIME.MP4],
-	".mpeg": [MimeUtil.FILE_MIME.MPEG],
-	".mpg": [MimeUtil.FILE_MIME.MPEG],
-	".ogv": [MimeUtil.FILE_MIME.OGG_VIDEO],
-	".avi": [MimeUtil.FILE_MIME.AVI],
-	".3gp": [MimeUtil.FILE_MIME.THREE_GPP],
-	".3g2": [MimeUtil.FILE_MIME.THREE_GPP2],
-	".webm": [MimeUtil.FILE_MIME.WEBM],
-	".mkv": [MimeUtil.FILE_MIME.MKV],
-	".mka": [MimeUtil.FILE_MIME.MKA],
-	".mov": [MimeUtil.FILE_MIME.QUICKTIME],
-	".pdf": [MimeUtil.FILE_MIME.PDF],
-	".doc": [MimeUtil.FILE_MIME.DOC],
-	".docx": [MimeUtil.FILE_MIME.DOCX],
-	".xlsx": [MimeUtil.FILE_MIME.XLSX],
-	".xlsm": [MimeUtil.FILE_MIME.XLSM],
-	".xltx": [MimeUtil.FILE_MIME.XLTX],
-	".pptx": [MimeUtil.FILE_MIME.PPTX],
-	".ppt": [MimeUtil.FILE_MIME.PPT],
-	".odt": [MimeUtil.FILE_MIME.ODT],
-	".ods": [MimeUtil.FILE_MIME.ODS],
-	".odp": [MimeUtil.FILE_MIME.ODP],
-	".epub": [MimeUtil.FILE_MIME.EPUB],
-	".azw": [MimeUtil.FILE_MIME.AZW],
-	".zip": [MimeUtil.FILE_MIME.ZIP],
-	".gz": [MimeUtil.FILE_MIME.GZIP],
-	".tar": [MimeUtil.FILE_MIME.TAR],
-	".bz": [MimeUtil.FILE_MIME.BZIP],
-	".bz2": [MimeUtil.FILE_MIME.BZIP2],
-	".7z": [MimeUtil.FILE_MIME.SEVEN_Z],
-	".rar": [MimeUtil.FILE_MIME.RAR],
-	".xz": [MimeUtil.FILE_MIME.XZ],
-	".zst": [MimeUtil.FILE_MIME.ZSTD],
-	".iso": [MimeUtil.FILE_MIME.ISO9660_IMAGE],
-	".json": [MimeUtil.FILE_MIME.JSON],
-	".jsonld": [MimeUtil.FILE_MIME.LD_JSON],
-	".webmanifest": [MimeUtil.FILE_MIME.MANIFEST],
-	".jar": [MimeUtil.FILE_MIME.JAR],
-	".wasm": [MimeUtil.FILE_MIME.WASM],
-	".eot": [MimeUtil.FILE_MIME.EOT],
-	".otf": [MimeUtil.FILE_MIME.OTF],
-	".woff": [MimeUtil.FILE_MIME.WOFF],
-	".woff2": [MimeUtil.FILE_MIME.WOFF2],
-	".ttf": [MimeUtil.FILE_MIME.TTF],
-	".xls": [MimeUtil.FILE_MIME.XLS],
-	".xps": [MimeUtil.FILE_MIME.XPS],
-	".docm": [MimeUtil.FILE_MIME.DOCM]
-};
-const MIME_TO_EXT = (() => {
-	const map = /* @__PURE__ */ new Map();
-	for (const [ext, mimes] of Object.entries(EXT_TO_MIME)) for (const mime of mimes) {
-		const exts = map.get(mime);
-		if (exts) {
-			if (!exts.includes(ext)) exts.push(ext);
-		} else map.set(mime, [ext]);
-	}
-	return map;
-})();
-/**
-* 对象工具类
-*/
-var ObjectUtil = class {
-	static keys(value) {
-		return Object.keys(value);
-	}
-	static values(value) {
-		return Object.values(value);
-	}
-	static entries(value) {
-		return Object.entries(value);
-	}
-	/**
-	* 映射对象条目
-	* - 将对象的键值对映射为新的键值对
-	*
-	* @param plainObject 对象
-	* @param toEntry 映射函数
-	* @returns 映射后的新对象
-	* @example
-	* ```ts
-	* const obj = { a: 1, b: 2 };
-	*
-	* ObjectUtil.entriesMap(obj, (k, v) => [k, v * 2]); // { a: 2, b: 4 }
-	*
-	* ObjectUtil.entriesMap(obj, (k, v) => [`prefix_${String(k)}`, `${v}x`]); // { prefix_a: "1x", prefix_b: "2x" }
-	* ```
-	*/
-	static entriesMap(plainObject, toEntry) {
-		const defaultResult = {};
-		if (!TypeUtil.isPlainObject(plainObject)) return defaultResult;
-		return this.entries(plainObject).reduce((acc, [key, value]) => {
-			const [newKey, newValue] = toEntry(key, value);
-			acc[newKey] = newValue;
-			return acc;
-		}, defaultResult);
-	}
-	static pick(obj, keys) {
-		const result = {};
-		if (!TypeUtil.isPlainObject(obj)) return result;
-		if (!TypeUtil.isArray(keys)) return obj;
-		return keys.reduce((acc, key) => {
-			if (key in obj) acc[key] = obj[key];
-			return acc;
-		}, result);
-	}
-	static omit(obj, keys) {
-		const result = {};
-		if (!TypeUtil.isPlainObject(obj)) return result;
-		if (!TypeUtil.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);
-	}
-	static invert(obj) {
-		const result = {};
-		if (!TypeUtil.isPlainObject(obj)) return result;
-		for (const [k, v] of this.entries(obj)) if (TypeUtil.isString(v) || TypeUtil.isNumber(v) || TypeUtil.isSymbol(v)) result[v] = k;
-		return result;
-	}
-	static crush(obj) {
-		if (!obj) return {};
-		function crushReducer(crushed, value, path) {
-			if (TypeUtil.isPlainObject(value) || TypeUtil.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, "");
-	}
-	static enumKeys(enumeration) {
-		const [isEnum, isBidirectionalEnum] = TypeUtil.isEnumeration(enumeration);
-		if (!isEnum) throw Error("function [enumKeys] expected parameter to be a enum, and requires at least one member");
-		const keys = this.keys(enumeration);
-		if (isBidirectionalEnum) return keys.splice(keys.length / 2, keys.length / 2);
-		return keys;
-	}
-	static enumValues(enumeration) {
-		const [isEnum, isBidirectionalEnum] = TypeUtil.isEnumeration(enumeration);
-		if (!isEnum) throw Error("function [enumValues] expected parameter to be a enum, and requires at least one member");
-		const values = this.values(enumeration);
-		if (isBidirectionalEnum) return values.splice(values.length / 2, values.length / 2);
-		return values;
-	}
-	static enumEntries(enumeration) {
-		const [isEnum, isBidirectionalEnum] = TypeUtil.isEnumeration(enumeration);
-		if (!isEnum) throw Error("function [enumEntries] expected parameter to be a enum, and requires at least one member");
-		const entries = this.entries(enumeration);
-		if (isBidirectionalEnum) return entries.splice(entries.length / 2, entries.length / 2);
-		return entries;
-	}
-};
-//#endregion
 //#region src/react/useMount.ts
 /**
 * 在组件初始化时执行的 Hook
@@ -2056,423 +47,6 @@ function useMount(effect) {
 	}, [effectRef]);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.49.0/node_modules/es-toolkit/dist/_internal/globalThis.mjs
-const globalThis_ = typeof globalThis === "object" && globalThis || typeof window === "object" && window || typeof self === "object" && self || typeof global === "object" && global || (function() {
-	return this;
-})();
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.49.0/node_modules/es-toolkit/dist/function/noop.mjs
-/**
-* A no-operation function that does nothing.
-* This can be used as a placeholder or default function.
-*
-* @example
-* noop(); // Does nothing
-*
-* @returns This function does not return anything.
-*/
-function noop() {}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.49.0/node_modules/es-toolkit/dist/predicate/isPrimitive.mjs
-/**
-* Checks whether a value is a JavaScript primitive.
-* JavaScript primitives include null, undefined, strings, numbers, booleans, symbols, and bigints.
-*
-* @param value The value to check.
-* @returns Returns true if `value` is a primitive, false otherwise.
-*
-* @example
-* isPrimitive(null); // true
-* isPrimitive(undefined); // true
-* isPrimitive('123'); // true
-* isPrimitive(false); // true
-* isPrimitive(true); // true
-* isPrimitive(Symbol('a')); // true
-* isPrimitive(123n); // true
-* isPrimitive({}); // false
-* isPrimitive(new Date()); // false
-* isPrimitive(new Map()); // false
-* isPrimitive(new Set()); // false
-* isPrimitive([1, 2, 3]); // false
-*/
-function isPrimitive(value) {
-	return value == null || typeof value !== "object" && typeof value !== "function";
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.49.0/node_modules/es-toolkit/dist/predicate/isTypedArray.mjs
-/**
-* Checks if a value is a TypedArray.
-* @param x The value to check.
-* @returns Returns true if `x` is a TypedArray, false otherwise.
-*
-* @example
-* const arr = new Uint8Array([1, 2, 3]);
-* isTypedArray(arr); // true
-*
-* const regularArray = [1, 2, 3];
-* isTypedArray(regularArray); // false
-*
-* const buffer = new ArrayBuffer(16);
-* isTypedArray(buffer); // false
-*/
-function isTypedArray(x) {
-	return ArrayBuffer.isView(x) && !(x instanceof DataView);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.49.0/node_modules/es-toolkit/dist/object/clone.mjs
-/**
-* Creates a shallow clone of the given object.
-*
-* @template T - The type of the object.
-* @param obj - The object to clone.
-* @returns A shallow clone of the given object.
-*
-* @example
-* // Clone a primitive value
-* const num = 29;
-* const clonedNum = clone(num);
-* console.log(clonedNum); // 29
-* console.log(clonedNum === num); // true
-*
-* @example
-* // Clone an array
-* const arr = [1, 2, 3];
-* const clonedArr = clone(arr);
-* console.log(clonedArr); // [1, 2, 3]
-* console.log(clonedArr === arr); // false
-*
-* @example
-* // Clone an object
-* const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] };
-* const clonedObj = clone(obj);
-* console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] }
-* console.log(clonedObj === obj); // false
-*/
-function clone(obj) {
-	if (isPrimitive(obj)) return obj;
-	if (Array.isArray(obj) || isTypedArray(obj) || obj instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && obj instanceof SharedArrayBuffer) return obj.slice(0);
-	const prototype = Object.getPrototypeOf(obj);
-	if (prototype == null) return Object.assign(Object.create(prototype), obj);
-	const Constructor = prototype.constructor;
-	if (obj instanceof Date || obj instanceof Map || obj instanceof Set) return new Constructor(obj);
-	if (obj instanceof RegExp) {
-		const newRegExp = new Constructor(obj);
-		newRegExp.lastIndex = obj.lastIndex;
-		return newRegExp;
-	}
-	if (obj instanceof DataView) return new Constructor(obj.buffer.slice(0));
-	if (obj instanceof Error) {
-		let newError;
-		if (obj instanceof AggregateError) newError = new Constructor(obj.errors, obj.message, { cause: obj.cause });
-		else newError = new Constructor(obj.message, { cause: obj.cause });
-		newError.stack = obj.stack;
-		Object.assign(newError, obj);
-		return newError;
-	}
-	if (typeof File !== "undefined" && obj instanceof File) return new Constructor([obj], obj.name, {
-		type: obj.type,
-		lastModified: obj.lastModified
-	});
-	if (typeof obj === "object") return Object.assign(Object.create(prototype), obj);
-	return obj;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.49.0/node_modules/es-toolkit/dist/predicate/isBuffer.mjs
-/**
-* Checks if the given value is a Buffer instance.
-*
-* This function tests whether the provided value is an instance of Buffer.
-* It returns `true` if the value is a Buffer, and `false` otherwise.
-*
-* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Buffer`.
-*
-* @param x - The value to check if it is a Buffer.
-* @returns Returns `true` if `x` is a Buffer, else `false`.
-*
-* @example
-* const buffer = Buffer.from("test");
-* console.log(isBuffer(buffer)); // true
-*
-* const notBuffer = "not a buffer";
-* console.log(isBuffer(notBuffer)); // false
-*/
-function isBuffer(x) {
-	return typeof globalThis_.Buffer !== "undefined" && globalThis_.Buffer.isBuffer(x);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.49.0/node_modules/es-toolkit/dist/compat/_internal/getSymbols.mjs
-function getSymbols(object) {
-	return Object.getOwnPropertySymbols(object).filter((symbol) => Object.prototype.propertyIsEnumerable.call(object, symbol));
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.49.0/node_modules/es-toolkit/dist/compat/_internal/getTag.mjs
-/**
-* Gets the `toStringTag` of `value`.
-*
-* @private
-* @param {T} value The value to query.
-* @returns {string} Returns the `Object.prototype.toString.call` result.
-*/
-function getTag(value) {
-	if (value == null) return value === void 0 ? "[object Undefined]" : "[object Null]";
-	return Object.prototype.toString.call(value);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.49.0/node_modules/es-toolkit/dist/compat/_internal/tags.mjs
-const regexpTag = "[object RegExp]";
-const stringTag = "[object String]";
-const numberTag = "[object Number]";
-const booleanTag = "[object Boolean]";
-const symbolTag = "[object Symbol]";
-const dateTag = "[object Date]";
-const mapTag = "[object Map]";
-const setTag = "[object Set]";
-const arrayTag = "[object Array]";
-const functionTag = "[object Function]";
-const arrayBufferTag = "[object ArrayBuffer]";
-const objectTag = "[object Object]";
-const errorTag = "[object Error]";
-const dataViewTag = "[object DataView]";
-const uint8ArrayTag = "[object Uint8Array]";
-const uint8ClampedArrayTag = "[object Uint8ClampedArray]";
-const uint16ArrayTag = "[object Uint16Array]";
-const uint32ArrayTag = "[object Uint32Array]";
-const bigUint64ArrayTag = "[object BigUint64Array]";
-const int8ArrayTag = "[object Int8Array]";
-const int16ArrayTag = "[object Int16Array]";
-const int32ArrayTag = "[object Int32Array]";
-const bigInt64ArrayTag = "[object BigInt64Array]";
-const float32ArrayTag = "[object Float32Array]";
-const float64ArrayTag = "[object Float64Array]";
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.49.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
-/**
-* Checks if a given value is a plain object.
-*
-* @param value - The value to check.
-* @returns True if the value is a plain object, otherwise false.
-*
-* @example
-* ```typescript
-* // ✅👇 True
-*
-* isPlainObject({ });                       // ✅
-* isPlainObject({ key: 'value' });          // ✅
-* isPlainObject({ key: new Date() });       // ✅
-* isPlainObject(new Object());              // ✅
-* isPlainObject(Object.create(null));       // ✅
-* isPlainObject({ nested: { key: true} });  // ✅
-* isPlainObject(new Proxy({}, {}));         // ✅
-* isPlainObject({ [Symbol('tag')]: 'A' });  // ✅
-*
-* // ✅👇 (cross-realms, node context, workers, ...)
-* const runInNewContext = await import('node:vm').then(
-*     (mod) => mod.runInNewContext
-* );
-* isPlainObject(runInNewContext('({})'));   // ✅
-*
-* // ❌👇 False
-*
-* class Test { };
-* isPlainObject(new Test())           // ❌
-* isPlainObject(10);                  // ❌
-* isPlainObject(null);                // ❌
-* isPlainObject('hello');             // ❌
-* isPlainObject([]);                  // ❌
-* isPlainObject(new Date());          // ❌
-* isPlainObject(new Uint8Array([1])); // ❌
-* isPlainObject(Buffer.from('ABC'));  // ❌
-* isPlainObject(Promise.resolve({})); // ❌
-* isPlainObject(Object.create({}));   // ❌
-* isPlainObject(new (class Cls {}));  // ❌
-* isPlainObject(globalThis);          // ❌,
-* ```
-*/
-function isPlainObject(value) {
-	if (!value || typeof value !== "object") return false;
-	const proto = Object.getPrototypeOf(value);
-	if (!(proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null)) return false;
-	return Object.prototype.toString.call(value) === "[object Object]";
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.49.0/node_modules/es-toolkit/dist/_internal/isEqualsSameValueZero.mjs
-/**
-* Performs a `SameValueZero` comparison between two values to determine if they are equivalent.
-*
-* @param {any} value - The value to compare.
-* @param {any} other - The other value to compare.
-* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
-*
-* @example
-* eq(1, 1); // true
-* eq(0, -0); // true
-* eq(NaN, NaN); // true
-* eq('a', Object('a')); // false
-*/
-function isEqualsSameValueZero(value, other) {
-	return value === other || Number.isNaN(value) && Number.isNaN(other);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.49.0/node_modules/es-toolkit/dist/predicate/isEqualWith.mjs
-/**
-* Compares two values for equality using a custom comparison function.
-*
-* The custom function allows for fine-tuned control over the comparison process. If it returns a boolean, that result determines the equality. If it returns undefined, the function falls back to the default equality comparison.
-*
-* This function also uses the custom equality function to compare values inside objects,
-* arrays, maps, sets, and other complex structures, ensuring a deep comparison.
-*
-* This approach provides flexibility in handling complex comparisons while maintaining efficient default behavior for simpler cases.
-*
-* The custom comparison function can take up to six parameters:
-* - `x`: The value from the first object `a`.
-* - `y`: The value from the second object `b`.
-* - `property`: The property key used to get `x` and `y`.
-* - `xParent`: The parent of the first value `x`.
-* - `yParent`: The parent of the second value `y`.
-* - `stack`: An internal stack (Map) to handle circular references.
-*
-* @param a - The first value to compare.
-* @param b - The second value to compare.
-* @param areValuesEqual - A function to customize the comparison.
-*   If it returns a boolean, that result will be used. If it returns undefined,
-*   the default equality comparison will be used.
-* @returns `true` if the values are equal according to the customizer, otherwise `false`.
-*
-* @example
-* const customizer = (a, b) => {
-*   if (typeof a === 'string' && typeof b === 'string') {
-*     return a.toLowerCase() === b.toLowerCase();
-*   }
-* };
-* isEqualWith('Hello', 'hello', customizer); // true
-* isEqualWith({ a: 'Hello' }, { a: 'hello' }, customizer); // true
-* isEqualWith([1, 2, 3], [1, 2, 3], customizer); // true
-*/
-function isEqualWith(a, b, areValuesEqual) {
-	return isEqualWithImpl(a, b, void 0, void 0, void 0, void 0, areValuesEqual);
-}
-function isEqualWithImpl(a, b, property, aParent, bParent, stack, areValuesEqual) {
-	const result = areValuesEqual(a, b, property, aParent, bParent, stack);
-	if (result !== void 0) return result;
-	if (typeof a === typeof b) switch (typeof a) {
-		case "bigint":
-		case "string":
-		case "boolean":
-		case "symbol":
-		case "undefined": return a === b;
-		case "number": return a === b || Object.is(a, b);
-		case "function": return a === b;
-		case "object": return areObjectsEqual(a, b, stack, areValuesEqual);
-	}
-	return areObjectsEqual(a, b, stack, areValuesEqual);
-}
-function areObjectsEqual(a, b, stack, areValuesEqual) {
-	if (Object.is(a, b)) return true;
-	let aTag = getTag(a);
-	let bTag = getTag(b);
-	if (aTag === "[object Arguments]") aTag = objectTag;
-	if (bTag === "[object Arguments]") bTag = objectTag;
-	if (aTag !== bTag) return false;
-	switch (aTag) {
-		case stringTag: return a.toString() === b.toString();
-		case numberTag: return isEqualsSameValueZero(a.valueOf(), b.valueOf());
-		case booleanTag:
-		case dateTag:
-		case symbolTag: return Object.is(a.valueOf(), b.valueOf());
-		case regexpTag: return a.source === b.source && a.flags === b.flags;
-		case functionTag: return a === b;
-	}
-	stack = stack ?? /* @__PURE__ */ new Map();
-	const aStack = stack.get(a);
-	const bStack = stack.get(b);
-	if (aStack != null && bStack != null) return aStack === b;
-	stack.set(a, b);
-	stack.set(b, a);
-	try {
-		switch (aTag) {
-			case mapTag:
-				if (a.size !== b.size) return false;
-				for (const [key, value] of a.entries()) if (!b.has(key) || !isEqualWithImpl(value, b.get(key), key, a, b, stack, areValuesEqual)) return false;
-				return true;
-			case setTag: {
-				if (a.size !== b.size) return false;
-				const aValues = Array.from(a.values());
-				const bValues = Array.from(b.values());
-				for (let i = 0; i < aValues.length; i++) {
-					const aValue = aValues[i];
-					const index = bValues.findIndex((bValue) => {
-						return isEqualWithImpl(aValue, bValue, void 0, a, b, stack, areValuesEqual);
-					});
-					if (index === -1) return false;
-					bValues.splice(index, 1);
-				}
-				return true;
-			}
-			case arrayTag:
-			case uint8ArrayTag:
-			case uint8ClampedArrayTag:
-			case uint16ArrayTag:
-			case uint32ArrayTag:
-			case bigUint64ArrayTag:
-			case int8ArrayTag:
-			case int16ArrayTag:
-			case int32ArrayTag:
-			case bigInt64ArrayTag:
-			case float32ArrayTag:
-			case float64ArrayTag:
-				if (isBuffer(a) !== isBuffer(b)) return false;
-				if (a.length !== b.length) return false;
-				for (let i = 0; i < a.length; i++) if (!isEqualWithImpl(a[i], b[i], i, a, b, stack, areValuesEqual)) return false;
-				return true;
-			case arrayBufferTag:
-				if (a.byteLength !== b.byteLength) return false;
-				return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
-			case dataViewTag:
-				if (a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset) return false;
-				return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
-			case errorTag: return a.name === b.name && a.message === b.message;
-			case objectTag: {
-				if (!(areObjectsEqual(a.constructor, b.constructor, stack, areValuesEqual) || isPlainObject(a) && isPlainObject(b))) return false;
-				const aKeys = [...Object.keys(a), ...getSymbols(a)];
-				const bKeys = [...Object.keys(b), ...getSymbols(b)];
-				if (aKeys.length !== bKeys.length) return false;
-				for (let i = 0; i < aKeys.length; i++) {
-					const propKey = aKeys[i];
-					const aProp = a[propKey];
-					if (!Object.hasOwn(b, propKey)) return false;
-					const bProp = b[propKey];
-					if (!isEqualWithImpl(aProp, bProp, propKey, a, b, stack, areValuesEqual)) return false;
-				}
-				return true;
-			}
-			default: return false;
-		}
-	} finally {
-		stack.delete(a);
-		stack.delete(b);
-	}
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.49.0/node_modules/es-toolkit/dist/predicate/isEqual.mjs
-/**
-* Checks if two values are equal, including support for `Date`, `RegExp`, and deep object comparison.
-*
-* @param a - The first value to compare.
-* @param b - The second value to compare.
-* @returns `true` if the values are equal, otherwise `false`.
-*
-* @example
-* isEqual(1, 1); // true
-* isEqual({ a: 1 }, { a: 1 }); // true
-* isEqual(/abc/g, /abc/g); // true
-* isEqual(new Date('2020-01-01'), new Date('2020-01-01')); // true
-* isEqual([1, 2, 3], [1, 2, 3]); // true
-*/
-function isEqual(a, b) {
-	return isEqualWith(a, b, noop);
-}
-//#endregion
 //#region src/react/useResponsive.ts
 /** 屏幕响应断点 token 配置 */
 const BREAK_POINT_TOKEN = {