@pawover/kit 0.0.0-beta.9 → 0.1.0

package/packages/hooks/dist/react.js

@@ -0,0 +1,2678 @@
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+//#region src/react/useLatest.ts
+/**
+* 返回当前最新值的 Hook
+*
+* @param value
+*/
+function useLatest(value) {
+	const ref = useRef(value);
+	ref.current = value;
+	return ref;
+}
+//#endregion
+//#region ../utils/dist/string-C_OCj9Lg.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+/**
+* 类型工具类
+*/
+var TypeUtil = class {
+	/**
+	* 获取值的 [[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 类型
+	*
+	* @param value 待检查值
+	* @param checkEmpty 是否检查空字符串
+	* @returns 是否为字符串
+	* @example
+	* ```ts
+	* TypeUtil.isString("abc"); // true
+	* TypeUtil.isString(""); // true
+	* TypeUtil.isString("", true); // false
+	* ```
+	*/
+	static isString(value, checkEmpty = false) {
+		return typeof value === "string" && (!checkEmpty || !!value.length);
+	}
+	/**
+	* 检查 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.isObject(value, false) && this.isFunction(value["then"]);
+	}
+	/**
+	* 判断是否为普通对象类型
+	* - 可选是否检查原型为 `Object.prototype`，防止原型链污染
+	*
+	* @param value 待检查值
+	* @param prototypeCheck 是否进行原型检查，默认 `true`
+	* @returns 是否为 Plain Object (当 checkPrototype=true) 或 object
+	* @example
+	* ```ts
+	* TypeUtil.isObject({}); // true
+	* TypeUtil.isObject([]); // false
+	* TypeUtil.isObject(new Date()); // false
+	* TypeUtil.isObject(new Date(), false); // true
+	* TypeUtil.isObject(Object.create(null)) // false
+	* TypeUtil.isObject(Object.create(null), false) // true
+	* ```
+	*/
+	static isObject(value, prototypeCheck = true) {
+		const check = this.getPrototypeString(value) === this.PROTOTYPE_TAGS.OBJECT;
+		return prototypeCheck ? check && Object.getPrototypeOf(value) === Object.prototype : check;
+	}
+	/**
+	* 判断一个对象是否为有效的枚举
+	* - 枚举成员不能为空
+	* - 枚举成员的键不能具有数值名
+	* - 枚举成员的值必须类型一致且为 `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.isObject(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");
+	}
+};
+_defineProperty(TypeUtil, "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]"
+});
+_defineProperty(TypeUtil, "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]"
+]));
+/**
+* 字符串工具类
+*/
+var StringUtil = class {
+	/**
+	* 从字符串中提取数字字符串
+	* - 移除非数字字符，保留符号和小数点
+	*
+	* @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.replace(/\\/g, "/");
+		normalized = normalized.replace(/\/+/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(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);
+	}
+};
+var _DateTimeUtil;
+/**
+* 日期工具类
+*/
+var DateTimeUtil = class {
+	/**
+	* 获取当前时区信息
+	*
+	* @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
+		};
+	}
+};
+_DateTimeUtil = DateTimeUtil;
+_defineProperty(DateTimeUtil, "MILLISECONDS_PER_SECOND", 1e3);
+_defineProperty(DateTimeUtil, "SECOND_PER_MINUTE", 60);
+_defineProperty(DateTimeUtil, "MINUTE_PER_HOUR", 60);
+_defineProperty(DateTimeUtil, "SECOND_PER_HOUR", _DateTimeUtil.SECOND_PER_MINUTE ** 2);
+_defineProperty(DateTimeUtil, "HOUR_PER_DAY", 24);
+_defineProperty(DateTimeUtil, "SECOND_PER_DAY", _DateTimeUtil.SECOND_PER_HOUR * _DateTimeUtil.HOUR_PER_DAY);
+_defineProperty(DateTimeUtil, "DAY_PER_WEEK", 7);
+_defineProperty(DateTimeUtil, "DAY_PER_MONTH", 30);
+_defineProperty(DateTimeUtil, "DAY_PER_YEAR", 365);
+_defineProperty(DateTimeUtil, "MONTH_PER_YEAR", 12);
+_defineProperty(DateTimeUtil, "WEEK_PER_YEAR", 52);
+_defineProperty(DateTimeUtil, "WEEK_PER_MONTH", 4);
+_defineProperty(DateTimeUtil, "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"
+});
+/**
+* 环境检查工具类
+*/
+var EnvUtil = class {
+	/**
+	* 检测是否处于浏览器环境
+	*
+	* @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;
+		}
+	}
+};
+_defineProperty(EnvUtil, "_isBrowser", typeof window !== "undefined" && TypeUtil.isFunction(window?.document?.createElement));
+_defineProperty(EnvUtil, "_isWebWorker", typeof window === "undefined" && typeof self !== "undefined" && "importScripts" in self);
+_defineProperty(EnvUtil, "_isReactNative", typeof navigator !== "undefined" && navigator.product === "ReactNative");
+/**
+* MIME 工具类
+*/
+var MimeUtil = class {};
+_defineProperty(MimeUtil, "MIME", {
+	/** 普通文本文件 */
+	TEXT: "text/plain",
+	/** 超文本标记语言文档 */
+	HTML: "text/html",
+	/** 层叠样式表文件 */
+	CSS: "text/css",
+	/** 逗号分隔值文件（表格数据） */
+	CSV: "text/csv",
+	/** 制表符分隔值文件 */
+	TSV: "text/tab-separated-values",
+	/** XML 文档 */
+	XML: "text/xml",
+	/** XHTML 文档（XML 严格格式的 HTML） */
+	XHTML: "application/xhtml+xml",
+	/** JavaScript 文件 */
+	JS: "text/javascript",
+	/** TypeScript 文件 */
+	TS: "text/typescript",
+	/** Python 文件 */
+	PY: "text/x-python",
+	/** Shell 脚本 (.sh) */
+	SH: "text/x-sh",
+	/** C 语言源文件 */
+	C: "text/x-c",
+	/** C++ 源文件 */
+	CPP: "text/x-c++",
+	/** C# 源文件 */
+	CSHARP: "text/x-csharp",
+	/** Java 源文件 */
+	JAVA: "text/x-java",
+	/** Go 源文件 */
+	GO: "text/x-go",
+	/** Rust 源文件 */
+	RUST: "text/x-rust",
+	/** PHP 文件 */
+	PHP: "text/x-php",
+	/** Ruby 文件 */
+	RUBY: "text/x-ruby",
+	/** Swift 源文件 */
+	SWIFT: "text/x-swift",
+	/** YAML 文档 */
+	YAML: "text/vnd.yaml",
+	/** TOML 文档 */
+	TOML: "text/x-toml",
+	/** SQL 脚本 */
+	SQL: "text/x-sql",
+	/** Markdown 格式文档 */
+	MARKDOWN: "text/markdown",
+	/** 富文本格式文档（.rtf） */
+	RTF: "application/rtf",
+	/** iCalendar 日历格式（.ics） */
+	CALENDAR: "text/calendar",
+	/** JPEG 图像（.jpg/.jpeg） */
+	JPEG: "image/jpeg",
+	/** PNG 图像（无损压缩，支持透明） */
+	PNG: "image/png",
+	/** GIF 图像（支持动画） */
+	GIF: "image/gif",
+	/** Windows 位图（.bmp） */
+	BMP: "image/bmp",
+	/** SVG 向量图形（.svg） */
+	SVG: "image/svg+xml",
+	/** APNG 动态图像（.apng） */
+	APNG: "image/apng",
+	/** AVIF 图像（高效压缩） */
+	AVIF: "image/avif",
+	/** 图标文件格式（.ico） */
+	ICO: "image/vnd.microsoft.icon",
+	/** WebP 图像（高效压缩） */
+	WEBP: "image/webp",
+	/** TIFF 图像（.tif/.tiff） */
+	TIFF: "image/tiff",
+	/** HEIC 图像（高效编码） */
+	HEIC: "image/heic",
+	/** 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",
+	/** WAV 音频（.wav） */
+	WAV: "audio/wav",
+	/** 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",
+	/** 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",
+	/** GZIP 压缩文件（旧格式） */
+	X_GZIP: "application/x-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",
+	/** 通用二进制数据（默认类型） */
+	OCTET_STREAM: "application/octet-stream",
+	/** JSON 数据格式（.json） */
+	JSON: "application/json",
+	/** JSON-LD 格式（.jsonld） */
+	LD_JSON: "application/ld+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"
+});
+/**
+* 对象工具类
+*/
+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.isObject(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.isObject(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.isObject(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.isObject(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.isObject(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;
+	}
+};
+/**
+* 主题工具类
+*/
+var ThemeUtil = class {};
+_defineProperty(ThemeUtil, "THEME", {
+	LIGHT: "light",
+	DARK: "dark"
+});
+_defineProperty(ThemeUtil, "THEME_MODE", {
+	LIGHT: "light",
+	DARK: "dark",
+	SYSTEM: "system"
+});
+/**
+* 验证工具类
+*/
+var ValidateUtil = class {
+	/**
+	* 验证是否为手机号码
+	* @example
+	* ```ts
+	* ValidateUtil.isPhone("13800138000"); // true
+	* ```
+	*/
+	static isPhone(input) {
+		return this._phone.test(input.toString());
+	}
+	/**
+	* 验证是否为固定电话
+	* @example
+	* ```ts
+	* ValidateUtil.isTelephone("010-12345678"); // true
+	* ```
+	*/
+	static isTelephone(input) {
+		return this._telephone.test(input.toString());
+	}
+	/**
+	* 验证是否为移动设备识别码
+	* @example
+	* ```ts
+	* ValidateUtil.isIMEI("490154203237518"); // true
+	* ```
+	*/
+	static isIMEI(input) {
+		return this._IMEI.test(input.toString());
+	}
+	/**
+	* 验证是否为电子邮箱
+	* @example
+	* ```ts
+	* ValidateUtil.isEmail("dev@example.com"); // true
+	* ```
+	*/
+	static isEmail(input) {
+		return this._email.test(input.toString());
+	}
+	/**
+	* 验证是否为 http(s) 链接
+	* @example
+	* ```ts
+	* ValidateUtil.isHttpLink("https://example.com/path"); // true
+	* ```
+	*/
+	static isHttpLink(input) {
+		return this._link.test(input.toString());
+	}
+	/**
+	* 验证是否为端口号链接
+	* @example
+	* ```ts
+	* ValidateUtil.isPortLink("http://example.com:8080"); // true
+	* ```
+	*/
+	static isPortLink(input) {
+		return this._portLink.test(input.toString());
+	}
+	/**
+	* 验证是否为迅雷链接
+	* @example
+	* ```ts
+	* ValidateUtil.isThunderLink("thunder://QUFodHRwOi8vZXhhbXBsZS5jb20vZmlsZQ=="); // true
+	* ```
+	*/
+	static isThunderLink(input) {
+		return this._thunderLink.test(input.toString());
+	}
+	/**
+	* 验证是否为统一社会信用代码
+	* @example
+	* ```ts
+	* ValidateUtil.isUSCC("91350100M000100Y43"); // true
+	* ```
+	*/
+	static isUSCC(input) {
+		return this._uscc.test(input.toString());
+	}
+	/**
+	* 验证是否为统一社会信用代码 - 15位/18位/20位数字/字母
+	* @example
+	* ```ts
+	* ValidateUtil.isUSCCS("91350100M000100Y43"); // true
+	* ```
+	*/
+	static isUSCCS(input) {
+		return this._usccs.test(input.toString());
+	}
+	/**
+	* 验证是否为 Windows 系统文件夹路径
+	* @example
+	* ```ts
+	* ValidateUtil.isDirPathWindows("C:\\Users\\pawover\\"); // true
+	* ```
+	*/
+	static isDirPathWindows(input) {
+		return this._dirPathWindows.test(input.toString());
+	}
+	/**
+	* 验证是否为 Windows 系统文件路径
+	* @example
+	* ```ts
+	* ValidateUtil.isFilePathWindows("C:\\Users\\pawover\\a.txt"); // true
+	* ```
+	*/
+	static isFilePathWindows(input) {
+		return this._filePathWindows.test(input.toString());
+	}
+	/**
+	* 验证是否为 Linux 系统文件夹路径
+	* @example
+	* ```ts
+	* ValidateUtil.isDirPathLinux("/usr/local/"); // true
+	* ```
+	*/
+	static isDirPathLinux(input) {
+		return this._dirPathLinux.test(input.toString());
+	}
+	/**
+	* 验证是否为 Linux 系统文件路径
+	* @example
+	* ```ts
+	* ValidateUtil.isFilePathLinux("/usr/local/bin/node"); // true
+	* ```
+	*/
+	static isFilePathLinux(input) {
+		return this._filePathLinux.test(input.toString());
+	}
+	/**
+	* 验证是否为新能源车牌号
+	* @example
+	* ```ts
+	* ValidateUtil.isEVCarNumber("粤AD12345"); // true
+	* ```
+	*/
+	static isEVCarNumber(input) {
+		return this._EVCarNumber.test(input.toString());
+	}
+	/**
+	* 验证是否为燃油车车牌号
+	* @example
+	* ```ts
+	* ValidateUtil.isGVCarNumber("粤B12345"); // true
+	* ```
+	*/
+	static isGVCarNumber(input) {
+		return this._GVCarNumber.test(input.toString());
+	}
+	/**
+	* 验证是否为中文姓名
+	* @example
+	* ```ts
+	* ValidateUtil.isChineseName("张三"); // true
+	* ```
+	*/
+	static isChineseName(input) {
+		return this._chineseName.test(input.toString());
+	}
+	/**
+	* 验证是否为中国身份证号
+	* @example
+	* ```ts
+	* ValidateUtil.isChineseID("11010519491231002X"); // true
+	* ```
+	*/
+	static isChineseID(input) {
+		return this._chineseId.test(input.toString());
+	}
+	/**
+	* 验证是否为中国省份
+	* @example
+	* ```ts
+	* ValidateUtil.isChineseProvince("浙江"); // true
+	* ```
+	*/
+	static isChineseProvince(input) {
+		return this._chineseProvince.test(input.toString());
+	}
+	/**
+	* 验证是否为中华民族
+	* @example
+	* ```ts
+	* ValidateUtil.isChineseNation("汉族"); // true
+	* ```
+	*/
+	static isChineseNation(input) {
+		return this._chineseNation.test(input.toString());
+	}
+	/**
+	* 验证是否只包含字母
+	* @example
+	* ```ts
+	* ValidateUtil.isLetter("abcDEF"); // true
+	* ```
+	*/
+	static isLetter(input) {
+		return this._letter.test(input.toString());
+	}
+	/**
+	* 验证是否只包含小写字母
+	* @example
+	* ```ts
+	* ValidateUtil.isLetterLowercase("abc"); // true
+	* ```
+	*/
+	static isLetterLowercase(input) {
+		return this._letterLowercase.test(input.toString());
+	}
+	/**
+	* 验证是否只包含大写字母
+	* @example
+	* ```ts
+	* ValidateUtil.isLetterUppercase("ABC"); // true
+	* ```
+	*/
+	static isLetterUppercase(input) {
+		return this._letterUppercase.test(input.toString());
+	}
+	/**
+	* 验证是否不包含字母
+	* @example
+	* ```ts
+	* ValidateUtil.isLetterOmit("123_-"); // true
+	* ```
+	*/
+	static isLetterOmit(input) {
+		return this._letterOmit.test(input.toString());
+	}
+	/**
+	* 验证是否为数字和字母组合
+	* @example
+	* ```ts
+	* ValidateUtil.isLetterAndNumber("A1B2"); // true
+	* ```
+	*/
+	static isLetterAndNumber(input) {
+		return this._LetterAndNumber.test(input.toString());
+	}
+	/**
+	* 验证是否为有符号浮点数
+	* @example
+	* ```ts
+	* ValidateUtil.isSignedFloat("-12.34"); // true
+	* ```
+	*/
+	static isSignedFloat(input) {
+		return this._signedFloat.test(input.toString());
+	}
+	/**
+	* 验证是否为无符号浮点数
+	* @example
+	* ```ts
+	* ValidateUtil.isUnsignedFloat("12.34"); // true
+	* ```
+	*/
+	static isUnsignedFloat(input) {
+		return this._unsignedFloat.test(input.toString());
+	}
+	/**
+	* 验证是否为有符号整数
+	* @example
+	* ```ts
+	* ValidateUtil.isSignedInteger("-12"); // true
+	* ```
+	*/
+	static isSignedInteger(input) {
+		return this._signedInteger.test(input.toString());
+	}
+	/**
+	* 验证是否为无符号整数
+	* @example
+	* ```ts
+	* ValidateUtil.isUnsignedInteger("12"); // true
+	* ```
+	*/
+	static isUnsignedInteger(input) {
+		return this._unsignedInteger.test(input.toString());
+	}
+	/**
+	* 验证是否包含空格
+	* @example
+	* ```ts
+	* ValidateUtil.isSpaceInclude("a b"); // true
+	* ```
+	*/
+	static isSpaceInclude(input) {
+		return this._spaceInclude.test(input.toString());
+	}
+	/**
+	* 验证是否以空格开头
+	* @example
+	* ```ts
+	* ValidateUtil.isSpaceStart(" abc"); // true
+	* ```
+	*/
+	static isSpaceStart(input) {
+		return this._spaceStart.test(input.toString());
+	}
+	/**
+	* 验证是否以空格结尾
+	* @example
+	* ```ts
+	* ValidateUtil.isSpaceEnd("abc "); // true
+	* ```
+	*/
+	static isSpaceEnd(input) {
+		return this._spaceEnd.test(input.toString());
+	}
+	/**
+	* 验证是否以空格开头或结尾
+	* @example
+	* ```ts
+	* ValidateUtil.isSpaceStartOrEnd(" abc"); // true
+	* ```
+	*/
+	static isSpaceStartOrEnd(input) {
+		return this.isSpaceStart(input) || this.isSpaceEnd(input);
+	}
+};
+_defineProperty(ValidateUtil, "_phone", /^1(3\d|4[5-9]|5[0-35-9]|6[567]|7[0-8]|8\d|9[0-35-9])\d{8}$/);
+_defineProperty(ValidateUtil, "_telephone", /^(((0\d{2,3})-)?((\d{7,8})|(400\d{7})|(800\d{7}))(-(\d{1,4}))?)$/);
+_defineProperty(ValidateUtil, "_IMEI", /^\d{15,17}$/);
+_defineProperty(ValidateUtil, "_email", /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\])|(([a-z\-0-9]+\.)+[a-z]{2,}))$/i);
+_defineProperty(ValidateUtil, "_link", /^(https?:\/\/)?(([\w-]+(\.[\w-]+)*\.[a-z]{2,6})|((\d{1,3}\.){3}\d{1,3}))(:\d+)?(\/\S*)?$/i);
+_defineProperty(ValidateUtil, "_portLink", /^(https?:\/\/)?[\w-]+(\.[\w-]+)+:\d{1,5}\/?$/i);
+_defineProperty(ValidateUtil, "_thunderLink", /^thunderx?:\/\/[a-zA-Z\d]+=$/i);
+_defineProperty(ValidateUtil, "_uscc", /^[0-9A-HJ-NPQRTUWXY]{2}\d{6}[0-9A-HJ-NPQRTUWXY]{10}$/);
+_defineProperty(ValidateUtil, "_usccs", /^[0-9A-HJ-NPQRTUWXY]{2}\d{6}[0-9A-HJ-NPQRTUWXY]{10}$/);
+_defineProperty(ValidateUtil, "_dirPathWindows", /^[a-z]:\\(?:\w+\\?)*$/i);
+_defineProperty(ValidateUtil, "_filePathWindows", /^[a-z]:\\(?:\w+\\)*\w+\.\w+$/i);
+_defineProperty(ValidateUtil, "_dirPathLinux", /^\/(?:[^\\/\s]+\/)*$/);
+_defineProperty(ValidateUtil, "_filePathLinux", /^(\/$|\/(?:[^\\/\s]+\/)*[^\\/\s]+$)/);
+_defineProperty(ValidateUtil, "_EVCarNumber", /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-HJ-NP-Z](([DF]((?![IO])[a-zA-Z0-9](?![IO]))\d{4})|(\d{5}[DF]))$/);
+_defineProperty(ValidateUtil, "_GVCarNumber", /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-HJ-NP-Z][A-HJ-NP-Z0-9]{4,5}[A-HJ-NP-Z0-9挂学警港澳]$/);
+_defineProperty(ValidateUtil, "_chineseName", /^[一-龢][一·-龢]*$/);
+_defineProperty(ValidateUtil, "_chineseId", /^\d{6}((((((19|20)\d{2})(0[13-9]|1[012])(0[1-9]|[12]\d|30))|(((19|20)\d{2})(0[13578]|1[02])31)|((19|20)\d{2})02(0[1-9]|1\d|2[0-8])|((((19|20)([13579][26]|[2468][048]|0[48]))|(2000))0229))\d{3})|((((\d{2})(0[13-9]|1[012])(0[1-9]|[12]\d|30))|((\d{2})(0[13578]|1[02])31)|((\d{2})02(0[1-9]|1\d|2[0-8]))|(([13579][26]|[2468][048]|0[048])0229))\d{2}))([\dX])$/i);
+_defineProperty(ValidateUtil, "_chineseProvince", /^安徽|澳门|北京|重庆|福建|甘肃|广东|广西|贵州|海南|河北|河南|黑龙江|湖北|湖南|吉林|江苏|江西|辽宁|内蒙古|宁夏|青海|山东|山西|陕西|上海|四川|台湾|天津|西藏|香港|新疆|云南|浙江$/);
+_defineProperty(ValidateUtil, "_chineseNation", /^汉族|蒙古族|回族|藏族|维吾尔族|苗族|彝族|壮族|布依族|朝鲜族|满族|侗族|瑶族|白族|土家族|哈尼族|哈萨克族|傣族|黎族|傈僳族|佤族|畲族|高山族|拉祜族|水族|东乡族|纳西族|景颇族|柯尔克孜族|土族|达斡尔族|仫佬族|羌族|布朗族|撒拉族|毛南族|仡佬族|锡伯族|阿昌族|普米族|塔吉克族|怒族|乌孜别克族|俄罗斯族|鄂温克族|德昂族|保安族|裕固族|京族|塔塔尔族|独龙族|鄂伦春族|赫哲族|门巴族|珞巴族|基诺族|其它未识别民族|外国人入中国籍$/);
+_defineProperty(ValidateUtil, "_letter", /^[a-z]+$/i);
+_defineProperty(ValidateUtil, "_letterLowercase", /^[a-z]+$/);
+_defineProperty(ValidateUtil, "_letterUppercase", /^[A-Z]+$/);
+_defineProperty(ValidateUtil, "_letterOmit", /^[^A-Z]*$/i);
+_defineProperty(ValidateUtil, "_LetterAndNumber", /^[A-Z0-9]+$/i);
+_defineProperty(ValidateUtil, "_signedFloat", /^[+-]?(\d+(\.\d+)?|\.\d+)$/);
+_defineProperty(ValidateUtil, "_unsignedFloat", /^\+?(\d+(\.\d+)?|\.\d+)$/);
+_defineProperty(ValidateUtil, "_signedInteger", /^[+-]?\d+$/);
+_defineProperty(ValidateUtil, "_unsignedInteger", /^\+?\d+$/);
+_defineProperty(ValidateUtil, "_spaceInclude", /\s/);
+_defineProperty(ValidateUtil, "_spaceStart", /^\s/);
+_defineProperty(ValidateUtil, "_spaceEnd", /\s$/);
+//#endregion
+//#region src/react/useMount.ts
+/**
+* 在组件初始化时执行的 Hook
+* - 即使在严格模式（React StrictMode）也只执行一次
+* - 自动使用最新版 effect 函数
+*
+* @param effect 副作用函数（必须为同步函数；若为异步函数，清理逻辑需自行处理）
+* @example
+* useMount(() => {
+*   console.log('组件挂载');
+*   return () => console.log('组件卸载');
+* });
+*
+* useMount(async () => {
+*   const data = await fetchData();
+*   // 清理逻辑需通过 ref/AbortController 自行管理
+*   // ❌ 不要 return cleanupFn（async 函数返回 Promise，无法作为清理函数）
+* });
+*/
+function useMount(effect) {
+	const isMountedRef = useRef(false);
+	const effectRef = useLatest(effect);
+	useEffect(() => {
+		if (!TypeUtil.isFunction(effectRef.current)) {
+			console.error(`hook [useMount] Expected parameter to be a function, but got ${typeof effectRef.current}. This effect will not execute.`);
+			return;
+		}
+		if (isMountedRef.current) return;
+		isMountedRef.current = true;
+		const cleanup = effectRef.current?.();
+		return TypeUtil.isFunction(cleanup) && !TypeUtil.isPromise(cleanup) ? cleanup : void 0;
+	}, [effectRef]);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.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;
+})() || Function("return this")();
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.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 {void} This function does not return anything.
+*/
+function noop() {}
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.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 {unknown} value The value to check.
+* @returns {value is
+*     null
+*   | undefined
+*   | string
+*   | number
+*   | boolean
+*   | symbol
+*   | bigint} 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.47.0/node_modules/es-toolkit/dist/predicate/isTypedArray.mjs
+/**
+* Checks if a value is a TypedArray.
+* @param {unknown} x The value to check.
+* @returns {x is
+*     Uint8Array
+*   | Uint8ClampedArray
+*   | Uint16Array
+*   | Uint32Array
+*   | BigUint64Array
+*   | Int8Array
+*   | Int16Array
+*   | Int32Array
+*   | BigInt64Array
+*   | Float32Array
+*   | Float64Array} 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.47.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 {T} obj - The object to clone.
+* @returns {T} - A shallow clone of the given object.
+*
+* @example
+* // Clone a primitive values
+* 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.47.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 {unknown} x - The value to check if it is a Buffer.
+* @returns {boolean} 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.47.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.47.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.47.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.47.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
+/**
+* Checks if a given value is a plain object.
+*
+* @param {object} value - The value to check.
+* @returns {value is Record<PropertyKey, any>} - 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.47.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.47.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 {unknown} a - The first value to compare.
+* @param {unknown} b - The second value to compare.
+* @param {(x: any, y: any, property?: PropertyKey, xParent?: any, yParent?: any, stack?: Map<any, any>) => boolean | void} 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 {boolean} `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.47.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 {unknown} a - The first value to compare.
+* @param {unknown} b - The second value to compare.
+* @returns {boolean} `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 = {
+	XS: 480,
+	XSMax: 575,
+	XSMin: 480,
+	SM: 576,
+	SMMax: 767,
+	SMMin: 576,
+	MD: 768,
+	MDMax: 991,
+	MDMin: 768,
+	LG: 992,
+	LGMax: 1199,
+	LGMin: 992,
+	XL: 1200,
+	XLMax: 1599,
+	XLMin: 1200,
+	XXL: 1600,
+	XXLMax: 1919,
+	XXLMin: 1600,
+	XXXL: 1920,
+	XXXLMin: 1920
+};
+const SUBSCRIBER_SET = /* @__PURE__ */ new Set();
+const BREAK_POINTS = [
+	"xxxl",
+	"xxl",
+	"xl",
+	"lg",
+	"md",
+	"sm",
+	"xs"
+];
+const DEFAULT_VALUES = Object.freeze(ArrayUtil.zipToObject(BREAK_POINTS, false));
+let responsiveValues = { ...DEFAULT_VALUES };
+let responsiveTokens = clone(BREAK_POINT_TOKEN);
+function useResponsive(options) {
+	const { breakPointTokens = {} } = options || {};
+	const tokens = useMemo(() => Object.assign(BREAK_POINT_TOKEN, breakPointTokens), [breakPointTokens]);
+	const [responsive, setResponsive] = useState(() => calculateResponsive(tokens));
+	const current = ObjectUtil.keys(DEFAULT_VALUES).find((key) => responsive[key] === true) || "xs";
+	useLayoutEffect(() => {
+		responsiveTokens = tokens;
+		window.addEventListener("resize", resizeListener);
+		const subscriber = () => {
+			setResponsive(responsiveValues);
+		};
+		SUBSCRIBER_SET.add(subscriber);
+		return () => {
+			SUBSCRIBER_SET.delete(subscriber);
+			if (!SUBSCRIBER_SET.size) window.removeEventListener("resize", resizeListener);
+		};
+	}, [tokens]);
+	return {
+		responsive,
+		current,
+		breakPointTokens: tokens
+	};
+}
+function resizeListener() {
+	const newValues = calculateResponsive(responsiveTokens);
+	if (!isEqual(responsiveValues, newValues)) {
+		responsiveValues = newValues;
+		for (const subscriber of SUBSCRIBER_SET) subscriber();
+	}
+}
+function calculateResponsive(tokens) {
+	const config = ArrayUtil.zipToObject(BREAK_POINTS, BREAK_POINTS.map((t) => tokens[StringUtil.toUpperCase(t)]));
+	return ObjectUtil.entriesMap(DEFAULT_VALUES, (key) => [key, window.innerWidth >= config[key]]);
+}
+//#endregion
+//#region src/react/useUnmount.ts
+/**
+* 在组件卸载时执行的 Hook
+*
+* @param effect 副作用函数
+*/
+function useUnmount(effect) {
+	const effectRef = useLatest(effect);
+	useEffect(() => () => {
+		if (!TypeUtil.isFunction(effectRef.current)) {
+			console.error(`hook [useUnmount] Expected parameter to be a function, but got ${typeof effectRef.current}. This effect will not execute.`);
+			return;
+		}
+		effectRef.current?.();
+	}, [effectRef]);
+}
+//#endregion
+//#region src/react/useTitle.ts
+/**
+* 设置页面标题
+* - 轻量级，适用于无路由库时设置页面标题
+* - 多个 `useTitle` 实例会互相干扰，需在顶层组件使用
+* - 无法处理 `document.title` 固有的竞态问题
+*
+* @param title 页面标题
+* @param options 配置选项
+*/
+function useTitle(title, options) {
+	const titleRef = useRef(EnvUtil.isBrowser() ? document.title : "");
+	useEffect(() => {
+		if (!TypeUtil.isString(title)) {
+			console.error(`hook [useTitle] Expected parameter to be a string, but got ${typeof title}. This effect will not execute.`);
+			return;
+		}
+		if (EnvUtil.isBrowser()) document.title = title;
+	}, [title]);
+	useUnmount(() => {
+		if (EnvUtil.isBrowser() && options?.isRestoreOnUnmount) document.title = titleRef.current;
+	});
+}
+//#endregion
+export { BREAK_POINT_TOKEN, useLatest, useMount, useResponsive, useTitle, useUnmount };