@pawover/kit 0.0.1 → 0.1.1

package/packages/hooks/dist/react.js

@@ -1,240 +1,4 @@
 import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
-//#region ../../node_modules/.pnpm/es-toolkit@1.46.1/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.46.1/node_modules/es-toolkit/dist/function/noop.mjs
-function noop() {}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.46.1/node_modules/es-toolkit/dist/predicate/isPrimitive.mjs
-function isPrimitive(value) {
-	return value == null || typeof value !== "object" && typeof value !== "function";
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.46.1/node_modules/es-toolkit/dist/predicate/isTypedArray.mjs
-function isTypedArray(x) {
-	return ArrayBuffer.isView(x) && !(x instanceof DataView);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.46.1/node_modules/es-toolkit/dist/object/clone.mjs
-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.46.1/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.46.1/node_modules/es-toolkit/dist/compat/_internal/getTag.mjs
-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.46.1/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.46.1/node_modules/es-toolkit/dist/predicate/isBuffer.mjs
-function isBuffer(x) {
-	return typeof globalThis_.Buffer !== "undefined" && globalThis_.Buffer.isBuffer(x);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.46.1/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
-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.46.1/node_modules/es-toolkit/dist/_internal/isEqualsSameValueZero.mjs
-function isEqualsSameValueZero(value, other) {
-	return value === other || Number.isNaN(value) && Number.isNaN(other);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.46.1/node_modules/es-toolkit/dist/predicate/isEqualWith.mjs
-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.46.1/node_modules/es-toolkit/dist/predicate/isEqual.mjs
-function isEqual(a, b) {
-	return isEqualWith(a, b, noop);
-}
-//#endregion
-//#region src/react/useCreation.ts
-/**
-* 确保实例不会被重复创建
-*
-* @param factory
-* @param deps
-*/
-function useCreation(factory, deps) {
-	const { current } = useRef({
-		deps,
-		result: void 0,
-		isInitialized: false
-	});
-	if (current.isInitialized === false || !isEqual(current.deps, deps)) {
-		current.deps = deps;
-		current.result = factory();
-		current.isInitialized = true;
-	}
-	return current.result;
-}
-//#endregion
 //#region src/react/useLatest.ts
 /**
 * 返回当前最新值的 Hook
@@ -247,7 +11,7 @@ function useLatest(value) {
 	return ref;
 }
 //#endregion
-//#region ../utils/dist/string-DCWqoW4P.js
+//#region ../utils/dist/string-p6hZ1Mjb.js
 function _typeof(o) {
 	"@babel/helpers - typeof";
 	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
@@ -301,25 +65,29 @@ var TypeUtil = class {
 	}
 	/**
 	* 检查 value 是否为 string 类型
+	* - 当 `checkEmpty` 为 `true` 时，会先 trim 再判断是否为空
 	*
 	* @param value 待检查值
-	* @param checkEmpty 是否检查空字符串
+	* @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.length);
+		return typeof value === "string" && (!checkEmpty || value.trim().length > 0);
 	}
 	/**
 	* 检查 value 是否为 number 类型
+	* - 默认会调用 `TypeUtil.isNaN`（内部基于 `Number.isNaN`）过滤掉 `NaN`
 	*
 	* @param value 待检查值
-	* @param checkNaN 是否排除 `NaN`，默认为 `true`
+	* @param checkNaN 是否检查 `NaN`，默认为 `true`
 	* @returns 是否为 number
 	* @example
 	* ```ts
@@ -333,9 +101,15 @@ var TypeUtil = class {
 	}
 	/**
 	* 检查 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);
@@ -346,6 +120,11 @@ var TypeUtil = class {
 	* @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);
@@ -357,6 +136,11 @@ var TypeUtil = class {
 	*
 	* @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;
@@ -367,6 +151,11 @@ var TypeUtil = class {
 	*
 	* @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;
@@ -376,6 +165,11 @@ var TypeUtil = class {
 	* - 排除 `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);
@@ -385,6 +179,11 @@ var TypeUtil = class {
 	* - 排除 `NaN`
 	*
 	* @param value 待检查值
+	* @example
+	* ```ts
+	* TypeUtil.isInfinityLike("Infinity"); // true
+	* TypeUtil.isInfinityLike("123"); // false
+	* ```
 	*/
 	static isInfinityLike(value) {
 		const check = this.isInfinity(value);
@@ -403,6 +202,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 Boolean
 	* @param value 待检查值
 	* @returns 是否为 Boolean
+	* @example
+	* ```ts
+	* TypeUtil.isBoolean(false); // true
+	* ```
 	*/
 	static isBoolean(value) {
 		return typeof value === "boolean";
@@ -411,6 +214,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 BigInt
 	* @param value 待检查值
 	* @returns 是否为 BigInt
+	* @example
+	* ```ts
+	* TypeUtil.isBigInt(1n); // true
+	* ```
 	*/
 	static isBigInt(value) {
 		return typeof value === "bigint";
@@ -419,6 +226,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 Symbol
 	* @param value 待检查值
 	* @returns 是否为 Symbol
+	* @example
+	* ```ts
+	* TypeUtil.isSymbol(Symbol("a")); // true
+	* ```
 	*/
 	static isSymbol(value) {
 		return typeof value === "symbol";
@@ -427,6 +238,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 undefined
 	* @param value 待检查值
 	* @returns 是否为 undefined
+	* @example
+	* ```ts
+	* TypeUtil.isUndefined(undefined); // true
+	* ```
 	*/
 	static isUndefined(value) {
 		return typeof value === "undefined";
@@ -435,6 +250,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 null
 	* @param value 待检查值
 	* @returns 是否为 null
+	* @example
+	* ```ts
+	* TypeUtil.isNull(null); // true
+	* ```
 	*/
 	static isNull(value) {
 		return value === null;
@@ -443,6 +262,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 Function
 	* @param value 待检查值
 	* @returns 是否为 Function
+	* @example
+	* ```ts
+	* TypeUtil.isFunction(() => {}); // true
+	* ```
 	*/
 	static isFunction(value) {
 		return typeof value === "function";
@@ -451,6 +274,10 @@ var TypeUtil = class {
 	* 检查 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;
@@ -459,6 +286,10 @@ var TypeUtil = class {
 	* 检查 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;
@@ -467,6 +298,10 @@ var TypeUtil = class {
 	* 检查 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;
@@ -475,8 +310,12 @@ var TypeUtil = class {
 	* 检查 value 是否为 Promise
 	* @param value 待检查值
 	* @returns 是否为 Promise
-	*/
-	static isPromise(value) {
+	* @example
+	* ```ts
+	* TypeUtil.isPromise(Promise.resolve(1)); // true
+	* ```
+	*/
+	static isPromise(value) {
 		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.PROMISE;
 	}
 	/**
@@ -484,6 +323,10 @@ var TypeUtil = class {
 	* - 可识别拥有 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"]);
@@ -519,6 +362,11 @@ var TypeUtil = class {
 	*
 	* @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];
@@ -600,6 +448,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 Map
 	* @param value 待检查值
 	* @returns 是否为 Map
+	* @example
+	* ```ts
+	* TypeUtil.isMap(new Map()); // true
+	* ```
 	*/
 	static isMap(value) {
 		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.MAP;
@@ -608,6 +460,10 @@ var TypeUtil = class {
 	* 检查 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;
@@ -616,6 +472,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 Set
 	* @param value 待检查值
 	* @returns 是否为 Set
+	* @example
+	* ```ts
+	* TypeUtil.isSet(new Set()); // true
+	* ```
 	*/
 	static isSet(value) {
 		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.SET;
@@ -624,6 +484,10 @@ var TypeUtil = class {
 	* 检查 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;
@@ -632,6 +496,10 @@ var TypeUtil = class {
 	* 检查 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;
@@ -640,6 +508,10 @@ var TypeUtil = class {
 	* 检查 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;
@@ -653,6 +525,10 @@ var TypeUtil = class {
 	*
 	* @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;
@@ -662,6 +538,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 Window
 	* @param value 待检查值
 	* @returns 是否为 Window
+	* @example
+	* ```ts
+	* TypeUtil.isWindow(window); // true
+	* ```
 	*/
 	static isWindow(value) {
 		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.WINDOW;
@@ -670,6 +550,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 HTMLIFrameElement
 	* @param value 待检查值
 	* @returns 是否为 HTMLIFrameElement
+	* @example
+	* ```ts
+	* TypeUtil.isIframe(document.createElement("iframe")); // true
+	* ```
 	*/
 	static isIframe(value) {
 		if (typeof window === "undefined") return false;
@@ -708,6 +592,10 @@ var TypeUtil = class {
 	* 检查 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;
@@ -716,6 +604,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 RegExp
 	* @param value 待检查值
 	* @returns 是否为 RegExp
+	* @example
+	* ```ts
+	* TypeUtil.isRegExp(/a/); // true
+	* ```
 	*/
 	static isRegExp(value) {
 		if (typeof value !== "object" || value === null) return false;
@@ -730,6 +622,10 @@ var TypeUtil = class {
 	* 检查 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;
@@ -738,6 +634,10 @@ var TypeUtil = class {
 	* 检查 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;
@@ -746,6 +646,10 @@ var TypeUtil = class {
 	* 检查 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;
@@ -754,6 +658,10 @@ var TypeUtil = class {
 	* 检查 value 是否为可迭代对象 (Iterable)
 	* @param value 待检查值
 	* @returns 是否为 Iterable
+	* @example
+	* ```ts
+	* TypeUtil.isIterable([1, 2]); // true
+	* ```
 	*/
 	static isIterable(value) {
 		return !!value && typeof value[Symbol.iterator] === "function";
@@ -762,11 +670,27 @@ var TypeUtil = class {
 	* 检查 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");
@@ -820,6 +744,13 @@ _defineProperty(TypeUtil, "TYPED_ARRAY_TAGS", new Set([
 * 字符串工具类
 */
 var StringUtil = class {
+	static cast(candidate, checkEmpty = true) {
+		if (checkEmpty) {
+			if (candidate === null || candidate === void 0) return "";
+			if (typeof candidate === "string" && candidate.trim().length === 0) return "";
+		}
+		return String(candidate);
+	}
 	/**
 	* 从字符串中提取数字字符串
 	* - 移除非数字字符，保留符号和小数点
@@ -1337,17 +1268,50 @@ _defineProperty(DateTimeUtil, "FORMAT", {
 * 环境检查工具类
 */
 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;
@@ -1516,8 +1480,38 @@ _defineProperty(MimeUtil, "MIME", {
 	XML: "text/xml",
 	/** XHTML 文档（XML 严格格式的 HTML） */
 	XHTML: "application/xhtml+xml",
-	/** JavaScript 脚本文件（标准推荐） */
+	/** 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） */
@@ -1542,6 +1536,12 @@ _defineProperty(MimeUtil, "MIME", {
 	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） */
@@ -1610,6 +1610,8 @@ _defineProperty(MimeUtil, "MIME", {
 	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） */
@@ -1618,10 +1620,18 @@ _defineProperty(MimeUtil, "MIME", {
 	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） */
@@ -1652,7 +1662,10 @@ var ObjectUtil = class {
 	* @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) {
@@ -1739,192 +1752,320 @@ _defineProperty(ThemeUtil, "THEME_MODE", {
 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);
@@ -1996,6 +2137,441 @@ function useMount(effect) {
 	}, [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 = {
@@ -2109,4 +2685,4 @@ function useTitle(title, options) {
 	});
 }
 //#endregion
-export { BREAK_POINT_TOKEN, useCreation, useLatest, useMount, useResponsive, useTitle, useUnmount };
+export { BREAK_POINT_TOKEN, useLatest, useMount, useResponsive, useTitle, useUnmount };