@pawover/kit 0.6.0 → 0.8.0

package/packages/utils/dist/math-BznvO4qI.cjs

@@ -1,1029 +0,0 @@
-//#region src/type/typeUtil.ts
-/**
-* 类型工具类
-*/
-var TypeUtil = class {
-	static PROTOTYPE_TAGS = {
-		STRING: "[object String]",
-		NUMBER: "[object Number]",
-		BOOLEAN: "[object Boolean]",
-		BIGINT: "[object BigInt]",
-		SYMBOL: "[object Symbol]",
-		UNDEFINED: "[object Undefined]",
-		NULL: "[object Null]",
-		OBJECT: "[object Object]",
-		FUNCTION: "[object Function]",
-		GENERATOR_FUNCTION: "[object GeneratorFunction]",
-		ASYNC_FUNCTION: "[object AsyncFunction]",
-		ASYNC_GENERATOR_FUNCTION: "[object AsyncGeneratorFunction]",
-		PROMISE: "[object Promise]",
-		MAP: "[object Map]",
-		SET: "[object Set]",
-		WEAK_MAP: "[object WeakMap]",
-		WEAK_SET: "[object WeakSet]",
-		BLOB: "[object Blob]",
-		FILE: "[object File]",
-		READABLE_STREAM: "[object ReadableStream]",
-		GLOBAL: "[object global]",
-		WINDOW: "[object Window]",
-		IFRAME: "[object HTMLIFrameElement]",
-		DATE: "[object Date]",
-		ERROR: "[object Error]",
-		REG_EXP: "[object RegExp]",
-		WEB_SOCKET: "[object WebSocket]",
-		URL_SEARCH_PARAMS: "[object URLSearchParams]",
-		ABORT_SIGNAL: "[object AbortSignal]"
-	};
-	static TYPED_ARRAY_TAGS = /* @__PURE__ */ new Set([
-		"[object Int8Array]",
-		"[object Uint8Array]",
-		"[object Uint8ClampedArray]",
-		"[object Int16Array]",
-		"[object Uint16Array]",
-		"[object Int32Array]",
-		"[object Uint32Array]",
-		"[object Float32Array]",
-		"[object Float64Array]",
-		"[object BigInt64Array]",
-		"[object BigUint64Array]"
-	]);
-	/**
-	* 获取值的 [[Prototype]] 标签
-	*
-	* @param value - 任意 JavaScript 值
-	* @returns 标准化的类型标签字符串
-	*/
-	static getPrototypeString(value) {
-		return Object.prototype.toString.call(value);
-	}
-	/**
-	* 检查 value 是否为 string 类型
-	* - 当 `checkNullish` 为 `true` 时，会先 trim 再判断是否为空
-	*
-	* @param value 待检查值
-	* @param checkNullish 是否检查空字符串（含空白字符串），默认为 `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, checkNullish = false) {
-		return typeof value === "string" && (!checkNullish || value.trim().length > 0);
-	}
-	/**
-	* 检查 value 是否为 number 类型
-	* - 默认会调用 `TypeUtil.isNaN`（内部基于 `Number.isNaN`）过滤掉 `NaN`
-	*
-	* @param value 待检查值
-	* @param checkNaN 是否检查 `NaN`，默认为 `true`
-	* @returns 是否为 number
-	* @example
-	* ```ts
-	* TypeUtil.isNumber(1); // true
-	* TypeUtil.isNumber(NaN); // false (default)
-	* TypeUtil.isNumber(NaN, false); // true
-	* ```
-	*/
-	static isNumber(value, checkNaN = true) {
-		return typeof value === "number" && (!checkNaN || !this.isNaN(value));
-	}
-	/**
-	* 检查 value 是否为 NaN
-	* - 禁止使用全局 `isNaN`，其会先进行隐式数字转换，可能导致误判（例如 `isNaN("foo") === true`）
-	* - 使用 `Number.isNaN` 仅在值本身就是 `NaN` 时返回 `true`，语义更严格且更安全
-	*
-	* @param value 待检查值
-	* @returns 是否为 NaN
-	* @example
-	* ```ts
-	* TypeUtil.isNaN(NaN); // true
-	* ```
-	*/
-	static isNaN(value) {
-		return Number.isNaN(value);
-	}
-	/**
-	* 检查 value 是否为整数
-	*
-	* @param value 待检查值
-	* @param checkSafe 是否附加安全整数检查
-	* @returns 是否为整数
-	* @example
-	* ```ts
-	* TypeUtil.isInteger(1); // true
-	* TypeUtil.isInteger(1.1); // false
-	* ```
-	*/
-	static isInteger(value, checkSafe = true) {
-		const check = Number.isInteger(value);
-		return checkSafe ? check && Number.isSafeInteger(value) : check;
-	}
-	/**
-	* 检查 value 是否为正整数
-	* - 此函数中 `0` 不被视为正整数
-	*
-	* @param value 待检查值
-	* @param checkSafe 是否附加安全整数检查
-	* @example
-	* ```ts
-	* TypeUtil.isPositiveInteger(1); // true
-	* TypeUtil.isPositiveInteger(0); // false
-	* ```
-	*/
-	static isPositiveInteger(value, checkSafe = true) {
-		return this.isInteger(value, checkSafe) && value > 0;
-	}
-	/**
-	* 检查 value 是否为负整数
-	* - 此函数中 `0` 不被视为负整数
-	*
-	* @param value 待检查值
-	* @param checkSafe 是否附加安全整数检查
-	* @example
-	* ```ts
-	* TypeUtil.isNegativeInteger(-1); // true
-	* TypeUtil.isNegativeInteger(0); // false
-	* ```
-	*/
-	static isNegativeInteger(value, checkSafe = true) {
-		return this.isInteger(value, checkSafe) && value < 0;
-	}
-	/**
-	* 检查 value 是否为 Infinity
-	* - 排除 `NaN`
-	*
-	* @param value 待检查值
-	* @example
-	* ```ts
-	* TypeUtil.isInfinity(Infinity); // true
-	* TypeUtil.isInfinity(1); // false
-	* ```
-	*/
-	static isInfinity(value) {
-		return this.isNumber(value) && (Number.POSITIVE_INFINITY === value || Number.NEGATIVE_INFINITY === value);
-	}
-	/**
-	* 检查 value 是否类似 Infinity
-	* - 排除 `NaN`
-	*
-	* @param value 待检查值
-	* @example
-	* ```ts
-	* TypeUtil.isInfinityLike("Infinity"); // true
-	* TypeUtil.isInfinityLike("123"); // false
-	* ```
-	*/
-	static isInfinityLike(value) {
-		const check = this.isInfinity(value);
-		if (check) return check;
-		if (typeof value === "string") return [
-			"infinity",
-			"-infinity",
-			"+infinity",
-			"Infinity",
-			"-Infinity",
-			"+Infinity"
-		].includes(value.trim());
-		return false;
-	}
-	/**
-	* 检查 value 是否为 Boolean
-	* @param value 待检查值
-	* @returns 是否为 Boolean
-	* @example
-	* ```ts
-	* TypeUtil.isBoolean(false); // true
-	* ```
-	*/
-	static isBoolean(value) {
-		return typeof value === "boolean";
-	}
-	/**
-	* 检查 value 是否为 BigInt
-	* @param value 待检查值
-	* @returns 是否为 BigInt
-	* @example
-	* ```ts
-	* TypeUtil.isBigInt(1n); // true
-	* ```
-	*/
-	static isBigInt(value) {
-		return typeof value === "bigint";
-	}
-	/**
-	* 检查 value 是否为 Symbol
-	* @param value 待检查值
-	* @returns 是否为 Symbol
-	* @example
-	* ```ts
-	* TypeUtil.isSymbol(Symbol("a")); // true
-	* ```
-	*/
-	static isSymbol(value) {
-		return typeof value === "symbol";
-	}
-	/**
-	* 检查 value 是否为 undefined
-	* @param value 待检查值
-	* @returns 是否为 undefined
-	* @example
-	* ```ts
-	* TypeUtil.isUndefined(undefined); // true
-	* ```
-	*/
-	static isUndefined(value) {
-		return typeof value === "undefined";
-	}
-	/**
-	* 检查 value 是否为 null
-	* @param value 待检查值
-	* @returns 是否为 null
-	* @example
-	* ```ts
-	* TypeUtil.isNull(null); // true
-	* ```
-	*/
-	static isNull(value) {
-		return value === null;
-	}
-	/**
-	* 检查 value 是否为 null 或 undefined
-	* @param value 待检查值
-	* @returns 是否为 Nullish
-	* @example
-	* ```ts
-	* TypeUtil.isNullish(null); // true
-	* TypeUtil.isNullish(undefined); // true
-	* ```
-	*/
-	static isNullish(value) {
-		return this.isNull(value) || this.isUndefined(value);
-	}
-	/**
-	* 检查 value 是否为 Function
-	* @param value 待检查值
-	* @returns 是否为 Function
-	* @example
-	* ```ts
-	* TypeUtil.isFunction(() => {}); // true
-	* ```
-	*/
-	static isFunction(value) {
-		return typeof value === "function";
-	}
-	/**
-	* 检查 value 是否为 AsyncFunction
-	* @param value 待检查值
-	* @returns 是否为 AsyncFunction
-	* @example
-	* ```ts
-	* TypeUtil.isAsyncFunction(async () => {}); // true
-	* ```
-	*/
-	static isAsyncFunction(value) {
-		return this.isFunction(value) && this.getPrototypeString(value) === this.PROTOTYPE_TAGS.ASYNC_FUNCTION;
-	}
-	/**
-	* 检查 value 是否为 GeneratorFunction
-	* @param value 待检查值
-	* @returns 是否为 GeneratorFunction
-	* @example
-	* ```ts
-	* TypeUtil.isGeneratorFunction(function * a () {}); // true
-	* ```
-	*/
-	static isGeneratorFunction(value) {
-		return this.isFunction(value) && this.getPrototypeString(value) === this.PROTOTYPE_TAGS.GENERATOR_FUNCTION;
-	}
-	/**
-	* 检查 value 是否为 AsyncGeneratorFunction
-	* @param value 待检查值
-	* @returns 是否为 AsyncGeneratorFunction
-	* @example
-	* ```ts
-	* TypeUtil.isAsyncGeneratorFunction(async function * a () {}); // true
-	* ```
-	*/
-	static isAsyncGeneratorFunction(value) {
-		return this.isFunction(value) && this.getPrototypeString(value) === this.PROTOTYPE_TAGS.ASYNC_GENERATOR_FUNCTION;
-	}
-	/**
-	* 检查 value 是否为 Promise
-	* @param value 待检查值
-	* @returns 是否为 Promise
-	* @example
-	* ```ts
-	* TypeUtil.isPromise(Promise.resolve(1)); // true
-	* ```
-	*/
-	static isPromise(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.PROMISE;
-	}
-	/**
-	* 检查 value 是否为 PromiseLike
-	* - 可识别拥有 then 方法的非 Promise 对象
-	* @param value 待检查值
-	* @returns 是否为 PromiseLike
-	* @example
-	* ```ts
-	* TypeUtil.isPromiseLike({ then: () => {} }); // true
-	* ```
-	*/
-	static isPromiseLike(value) {
-		return this.isPromise(value) || this.isPlainObject(value, false) && this.isFunction(value["then"]);
-	}
-	/**
-	* 判断是否为普通对象类型
-	* - 可选是否检查原型为 `Object.prototype`，防止原型链污染
-	*
-	* @param value 待检查值
-	* @param prototypeCheck 是否进行原型检查，默认 `true`
-	* @returns 是否为 Plain Object (当 prototypeCheck=true) 或 object
-	* @example
-	* ```ts
-	* TypeUtil.isPlainObject({}); // true
-	* TypeUtil.isPlainObject([]); // false
-	* TypeUtil.isPlainObject(new Date()); // false
-	* TypeUtil.isPlainObject(new (class {})()); // false
-	* TypeUtil.isPlainObject(new (class {})(), false); // true
-	* TypeUtil.isPlainObject(Object.create(null)) // false
-	* TypeUtil.isPlainObject(Object.create(null), false) // true
-	* ```
-	*/
-	static isPlainObject(value, prototypeCheck = true) {
-		const check = this.getPrototypeString(value) === this.PROTOTYPE_TAGS.OBJECT;
-		return prototypeCheck ? check && Object.getPrototypeOf(value) === Object.prototype : check;
-	}
-	/**
-	* 判断是否为广义对象类型
-	*
-	* @param value 待检查值
-	* @returns 是否为对象
-	* @example
-	* ```ts
-	* TypeUtil.isObject({}); // true
-	* TypeUtil.isObject([]); // true
-	* TypeUtil.isObject(new Date()); // true
-	* TypeUtil.isObject(null); // false
-	* TypeUtil.isObject("string"); // false
-	* ```
-	*/
-	static isObject(value) {
-		return typeof value === "object" && value !== null;
-	}
-	/**
-	* 判断一个对象是否为有效的枚举
-	* - 枚举成员不能为空
-	* - 枚举成员的键不能具有数值名
-	* - 枚举成员的值必须类型一致且为 `string` 或 `number` 类型
-	* - 枚举成员的值不能重复
-	* - 枚举成员的值必须全部为双向映射或非双向映射
-	*
-	* @param enumeration 待检查值
-	* @returns [是否为有效的枚举, 是否为双向枚举]
-	* @example
-	* ```ts
-	* enum A { X, Y }
-	* TypeUtil.isEnumeration(A); // [true, true]
-	* ```
-	*/
-	static isEnumeration(enumeration) {
-		if (typeof enumeration !== "object" || enumeration === null) return [false, false];
-		const keys = Object.keys(enumeration);
-		if (keys.length === 0) return [false, false];
-		const originalKeys = [];
-		const numericKeys = [];
-		for (const key of keys) if (/^\d+$/.test(key)) numericKeys.push(key);
-		else originalKeys.push(key);
-		if (originalKeys.length === 0) return [false, false];
-		let valueType = null;
-		const values = [];
-		for (const key of originalKeys) {
-			const value = enumeration[key];
-			const type = typeof value;
-			if (type !== "string" && type !== "number") return [false, false];
-			if (valueType === null) valueType = type;
-			else if (type !== valueType) return [false, false];
-			values.push(value);
-		}
-		if (new Set(values).size !== values.length) return [false, false];
-		let isBidirectional = false;
-		if (numericKeys.length > 0) {
-			if (numericKeys.length !== originalKeys.length) return [false, false];
-			const reverseMappedNames = /* @__PURE__ */ new Set();
-			for (const numKey of numericKeys) {
-				const reverseValue = enumeration[numKey];
-				if (typeof reverseValue !== "string") return [false, false];
-				if (!originalKeys.includes(reverseValue)) return [false, false];
-				reverseMappedNames.add(reverseValue);
-			}
-			if (reverseMappedNames.size !== originalKeys.length) return [false, false];
-			isBidirectional = true;
-		}
-		return [true, isBidirectional];
-	}
-	/**
-	* 检查 value 是否为 Class
-	*
-	* @param value 待检查值
-	* @returns 是否为 Class
-	* @example
-	* ```ts
-	* class A {}
-	* TypeUtil.isClass(A); // true
-	* TypeUtil.isClass(() => {}); // false
-	* ```
-	*/
-	static isClass(value) {
-		return this.isFunction(value) && !this.isAsyncFunction(value) && Function.prototype.toString.call(value).startsWith("class ") && value.prototype !== void 0;
-	}
-	/**
-	* 检查 value 是否为数组
-	*
-	* @param value 待检查值
-	* @returns 是否为数组
-	* @example
-	* ```ts
-	* TypeUtil.isArray([]); // true
-	* ```
-	*/
-	static isArray(value) {
-		return Array.isArray(value);
-	}
-	/**
-	* 检查 value 是否为 TypedArray
-	*
-	* @param value 待检查值
-	* @returns 是否为 TypedArray
-	* @example
-	* ```ts
-	* TypeUtil.isTypedArray(new Int8Array()); // true
-	* ```
-	*/
-	static isTypedArray(value) {
-		return typeof value === "object" && value !== null && this.TYPED_ARRAY_TAGS.has(this.getPrototypeString(value));
-	}
-	/**
-	* 检查 value 是否为 Map
-	* @param value 待检查值
-	* @returns 是否为 Map
-	* @example
-	* ```ts
-	* TypeUtil.isMap(new Map()); // true
-	* ```
-	*/
-	static isMap(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.MAP;
-	}
-	/**
-	* 检查 value 是否为 WeakMap
-	* @param value 待检查值
-	* @returns 是否为 WeakMap
-	* @example
-	* ```ts
-	* TypeUtil.isWeakMap(new WeakMap()); // true
-	* ```
-	*/
-	static isWeakMap(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.WEAK_MAP;
-	}
-	/**
-	* 检查 value 是否为 Set
-	* @param value 待检查值
-	* @returns 是否为 Set
-	* @example
-	* ```ts
-	* TypeUtil.isSet(new Set()); // true
-	* ```
-	*/
-	static isSet(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.SET;
-	}
-	/**
-	* 检查 value 是否为 WeakSet
-	* @param value 待检查值
-	* @returns 是否为 WeakSet
-	* @example
-	* ```ts
-	* TypeUtil.isWeakSet(new WeakSet()); // true
-	* ```
-	*/
-	static isWeakSet(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.WEAK_SET;
-	}
-	/**
-	* 检查 value 是否为 Blob
-	* @param value 待检查值
-	* @returns 是否为 Blob
-	* @example
-	* ```ts
-	* TypeUtil.isBlob(new Blob(["a"])); // true
-	* ```
-	*/
-	static isBlob(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.BLOB;
-	}
-	/**
-	* 检查 value 是否为 File
-	* @param value 待检查值
-	* @returns 是否为 File
-	* @example
-	* ```ts
-	* TypeUtil.isFile(new File(["a"], "a.txt")); // true
-	* ```
-	*/
-	static isFile(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.FILE;
-	}
-	/**
-	* 检查 value 是否为 ReadableStream
-	* - Uses `Object.prototype.toString` where supported (modern browsers, Node.js ≥18).
-	* - Falls back to duck-typing in older environments.
-	* - Resistant to basic forgery, but not 100% secure in all polyfill scenarios.
-	* - ⚠️ Note: In older Node.js (<18) or with non-compliant polyfills, this may return false positives or negatives.
-	*
-	* @param value 待检查值
-	* @returns 是否为 ReadableStream
-	* @example
-	* ```ts
-	* TypeUtil.isReadableStream(new ReadableStream()); // true
-	* ```
-	*/
-	static isReadableStream(value) {
-		if (this.getPrototypeString(value) === this.PROTOTYPE_TAGS.READABLE_STREAM) return true;
-		return this.isPlainObject(value) && this.isFunction(value["getReader"]) && this.isFunction(value["pipeThrough"]);
-	}
-	/**
-	* 检查 value 是否为 Window
-	* @param value 待检查值
-	* @returns 是否为 Window
-	* @example
-	* ```ts
-	* TypeUtil.isWindow(window); // true
-	* ```
-	*/
-	static isWindow(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.WINDOW;
-	}
-	/**
-	* 检查 value 是否为 HTMLIFrameElement
-	* @param value 待检查值
-	* @returns 是否为 HTMLIFrameElement
-	* @example
-	* ```ts
-	* TypeUtil.isIframe(document.createElement("iframe")); // true
-	* ```
-	*/
-	static isIframe(value) {
-		if (typeof window === "undefined") return false;
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.IFRAME;
-	}
-	/**
-	* 检查 value 是否为 Date 对象
-	*
-	* @param value 待检查值
-	* @param invalidCheck 是否要求日期有效（非 Invalid Date）。默认 true
-	*   - true: 仅当是有效 Date 对象时返回 true（排除 new Date('invalid')）
-	*   - false: 只要 [[Prototype]] 是 Date 即返回 true（包含 Invalid Date）
-	* @returns 是否为 Date 对象，根据 invalidCheck 返回不同语义的 Date 判定
-	*
-	* @example
-	* ```ts
-	* TypeUtil.isDate(new Date()); // true
-	* TypeUtil.isDate(new Date('invalid')); // false
-	* TypeUtil.isDate(new Date('invalid'), false); // true
-	* TypeUtil.isDate(null); // false
-	* TypeUtil.isDate({}); // false
-	* ```
-	*/
-	static isDate(value, invalidCheck = true) {
-		if (!value || typeof value !== "object") return false;
-		if (this.getPrototypeString(value) !== this.PROTOTYPE_TAGS.DATE) return false;
-		if (!invalidCheck) return true;
-		try {
-			const time = value.getTime();
-			return typeof time === "number" && !Number.isNaN(time);
-		} catch {
-			return false;
-		}
-	}
-	/**
-	* 检查 value 是否为 Error 对象
-	* @param value 待检查值
-	* @returns 是否为 Error
-	* @example
-	* ```ts
-	* TypeUtil.isError(new Error("x")); // true
-	* ```
-	*/
-	static isError(value) {
-		return value instanceof Error || this.getPrototypeString(value) === this.PROTOTYPE_TAGS.ERROR;
-	}
-	/**
-	* 检查 value 是否为 RegExp
-	* @param value 待检查值
-	* @returns 是否为 RegExp
-	* @example
-	* ```ts
-	* TypeUtil.isRegExp(/a/); // true
-	* ```
-	*/
-	static isRegExp(value) {
-		if (typeof value !== "object" || value === null) return false;
-		try {
-			const regex = value;
-			return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.REG_EXP && this.isString(regex.source) && this.isString(regex.flags) && this.isBoolean(regex.global) && this.isFunction(regex.test);
-		} catch (error) {
-			return false;
-		}
-	}
-	/**
-	* 检查 value 是否为 WebSocket
-	* @param value 待检查值
-	* @returns 是否为 WebSocket
-	* @example
-	* ```ts
-	* TypeUtil.isWebSocket(new WebSocket("wss://echo.websocket.events")); // true
-	* ```
-	*/
-	static isWebSocket(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.WEB_SOCKET;
-	}
-	/**
-	* 检查 value 是否为 URLSearchParams
-	* @param value 待检查值
-	* @returns 是否为 URLSearchParams
-	* @example
-	* ```ts
-	* TypeUtil.isURLSearchParams(new URLSearchParams("a=1")); // true
-	* ```
-	*/
-	static isURLSearchParams(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.URL_SEARCH_PARAMS;
-	}
-	/**
-	* 检查 value 是否为 AbortSignal
-	* @param value 待检查值
-	* @returns 是否为 AbortSignal
-	* @example
-	* ```ts
-	* TypeUtil.isAbortSignal(new AbortController().signal); // true
-	* ```
-	*/
-	static isAbortSignal(value) {
-		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.ABORT_SIGNAL;
-	}
-	/**
-	* 检查 value 是否为可迭代对象 (Iterable)
-	* @param value 待检查值
-	* @returns 是否为 Iterable
-	* @example
-	* ```ts
-	* TypeUtil.isIterable([1, 2]); // true
-	* ```
-	*/
-	static isIterable(value) {
-		return !!value && typeof value[Symbol.iterator] === "function";
-	}
-	/**
-	* 检查 value 是否为 Falsy 值 (false, 0, "", null, undefined, NaN, 0n)
-	* - 处理非字符串形式的 falsy；字符串形式（`"null"`、`"0"` 等）请使用 `isFalsyLike`
-	*
-	* @param value 待检查值
-	* @returns 是否为 Falsy
-	* @example
-	* ```ts
-	* TypeUtil.isFalsy(0); // true
-	* ```
-	*/
-	static isFalsy(value) {
-		return this.isNaN(value) || this.isNullish(value) || 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");
-	}
-};
-//#endregion
-//#region src/string/stringUtil.ts
-/**
-* 字符串工具类
-*/
-var StringUtil = class {
-	static cast(candidate, checkNullish = true, trim = true) {
-		if (checkNullish) {
-			if (candidate === null || candidate === void 0) return "";
-			if (typeof candidate === "string" && candidate.trim().length === 0) return "";
-		}
-		const result = String(candidate);
-		return trim ? result.trim() : result;
-	}
-	/**
-	* 从字符串中提取数字字符串
-	* - 移除非数字字符，保留符号和小数点
-	*
-	* @param input 待处理字符串
-	* @returns 提取出的数字字符串
-	* @example
-	* ```ts
-	* StringUtil.toNumber("$1,234.56"); // "1234.56"
-	* StringUtil.toNumber("abc-123"); // "-123"
-	* ```
-	*/
-	static toNumber(input) {
-		if (!TypeUtil.isString(input, true)) return "0";
-		const cleaned = input.replace(/[^0-9.-]/g, "");
-		if (!cleaned) return "0";
-		let isDecimal = false;
-		let signCount = 0;
-		let firstIndex = -1;
-		const stringList = cleaned.split("").map((s, i) => {
-			if (s === ".") {
-				if (isDecimal) return "";
-				isDecimal = true;
-				return ".";
-			}
-			if (s === "-") {
-				firstIndex === -1 && signCount++;
-				return "";
-			}
-			firstIndex === -1 && (firstIndex = i);
-			return s;
-		});
-		const sign = signCount % 2 === 1 ? "-" : "";
-		if (firstIndex === -1) return sign + "0";
-		let result = stringList.join("");
-		if (result.startsWith(".")) result = "0" + result;
-		if (result.endsWith(".")) result = result.slice(0, -1);
-		return sign + result;
-	}
-	static toLowerCase(input) {
-		if (!TypeUtil.isString(input, true)) return "";
-		return input.toLowerCase();
-	}
-	static toUpperCase(input) {
-		if (!TypeUtil.isString(input, true)) return "";
-		return input.toUpperCase();
-	}
-	/**
-	* 调整大小写
-	* - 每个单词（`\S+`）独立处理
-	* - 包含非西欧字母字符（如 `.`、`,`、`'`、`-`）时，该词不处理
-	* - 纯字母且全大写时，不处理
-	* - 纯字母且非全大写时：`caseType` 为 `"lower"` 则首字母小写，`"upper"` 则首字母大写，其余字符保留
-	* - ⚠️ 缺省 `caseType` 时不产生任何转换（no-op），需显式传 `"lower"` / `"upper"`
-	*
-	* @param input 待处理字符串
-	* @param caseType 大小写类型（缺省时无操作）
-	* @returns 处理后的字符串
-	* @example
-	* ```ts
-	* // 重载 1: lower
-	* StringUtil.toInitialCase("Hello World", "lower"); // "hello world"
-	*
-	* // 重载 2: upper
-	* StringUtil.toInitialCase("hello world", "upper"); // "Hello World"
-	*
-	* // 缺省 caseType → no-op
-	* StringUtil.toInitialCase("Hello"); // "Hello"
-	* ```
-	*/
-	static toInitialCase(input, caseType) {
-		if (!TypeUtil.isString(input, true)) return "";
-		return input.replace(/\S+/g, (word) => {
-			if (/[^a-zA-Z\u00C0-\u017F]/.test(word)) return word;
-			if (word === word.toLocaleUpperCase()) return word;
-			if (caseType === "lower" && word[0]) return word[0].toLocaleLowerCase() + word.slice(1);
-			if (caseType === "upper" && word[0]) return word[0].toLocaleUpperCase() + word.slice(1);
-			return word;
-		});
-	}
-	/**
-	* 将路径转换为 POSIX 风格
-	* - 统一使用正斜杠 (/)
-	* - 可选移除 Windows 盘符 (如 C:)
-	* - 可选移除开头的斜杠
-	* - 规范化连续斜杠为单个斜杠
-	*
-	* @param input 待处理字符串
-	* @param removeLeadingSlash 是否移除开头斜杠，默认为 `false`。如果移除了盘符，路径通常会以 / 开头，此参数可控制是否保留该 /
-	* @returns 转换后的路径，如果输入无效则返回空字符串
-	*
-	* @example
-	* ```ts
-	* StringUtil.toPosix("C:\\Windows\\System32"); // 默认: "/Windows/System32" (移除了 C: 并标准化)
-	*
-	* StringUtil.toPosix("C:\\Windows\\System32", true); // 移除开头斜杠: "Windows/System32"
-	*
-	* StringUtil.toPosix("\\\\server\\share\\file.txt"); // UNC 路径: "/server/share/file.txt"
-	*
-	* StringUtil.toPosix("folder\\subfolder\\file.txt"); // 相对路径: "folder/subfolder/file.txt"
-	* ```
-	*/
-	static toPosix(input, removeLeadingSlash = false) {
-		if (!TypeUtil.isString(input, true)) return "";
-		let normalized = input.replace(/^[A-Za-z]:([\\/])?/, (_, separator) => {
-			return separator ? "/" : "";
-		});
-		normalized = normalized.replaceAll("\\", "/");
-		normalized = normalized.replaceAll(/\/+/g, "/");
-		if (removeLeadingSlash && normalized.startsWith("/")) normalized = normalized.substring(1);
-		return normalized;
-	}
-	static toJson(input, fallback) {
-		if (!TypeUtil.isString(input, true)) return fallback;
-		try {
-			return JSON.parse(input);
-		} catch (error) {
-			return fallback;
-		}
-	}
-	static toValues(input, valueType = "number", splitSymbol = ",") {
-		if (!TypeUtil.isString(input, true)) return [];
-		try {
-			const values = input.split(splitSymbol);
-			if (valueType === "number") return values.map((d) => Number(d));
-			return values;
-		} catch (error) {
-			return [];
-		}
-	}
-	/**
-	* 从字符串中裁切掉所有的前缀和后缀字符
-	*
-	* @param input 待处理字符串
-	* @param charsToTrim 裁切字符，默认为 `" "`
-	* @returns 裁切后的字符串
-	* @example
-	* ```ts
-	* StringUtil.trim("  hello  "); // "hello"
-	* StringUtil.trim("__hello__", "_"); // "hello"
-	* ```
-	*/
-	static trim(input, charsToTrim = " ") {
-		if (!TypeUtil.isString(input, true)) return "";
-		const toTrim = charsToTrim.replace(/[\W]{1}/g, "\\$&");
-		const regex = new RegExp(`^[${toTrim}]+|[${toTrim}]+$`, "g");
-		return input.replace(regex, "");
-	}
-	/**
-	* 截取字符串
-	* - 支持自定义省略符，不会截断在汉字中间（因为JS字符串本身按字符处理）
-	*
-	* @param input 待处理字符串
-	* @param maxLength 最大长度 (包含省略符)
-	* @param ellipsis 省略符，默认为 `...`
-	* @returns 截取后的字符串
-	* @example
-	* ```ts
-	* StringUtil.truncate("hello world", 8); // "hello..."
-	* ```
-	*/
-	static truncate(input, maxLength, ellipsis = "...") {
-		if (!TypeUtil.isString(input, true)) return "";
-		const codePoints = Array.from(input);
-		if (!TypeUtil.isInteger(maxLength) || maxLength < 0) return input;
-		if (codePoints.length <= maxLength) return input;
-		const availableLength = maxLength - ellipsis.length;
-		if (availableLength <= 0) return "";
-		return codePoints.slice(0, availableLength).join("") + ellipsis;
-	}
-	/**
-	* 字符串模板替换
-	* - 使用对象的属性值替换字符串中的 {{key}} 模板
-	*
-	* @param input 待处理字符串
-	* @param template 模板对象
-	* @param regex 模板匹配正则 (默认: `\{\{(.+?)\}\}`)
-	* @returns 替换后的字符串
-	* @example
-	* ```ts
-	* StringUtil.template("Hello {{name}}", { name: "World" }); // "Hello World"
-	* ```
-	*/
-	static template(input, template, regex = /\{\{(.+?)\}\}/g) {
-		if (!TypeUtil.isString(input, true)) return "";
-		regex.lastIndex = 0;
-		const executor = regex.global ? regex : new RegExp(regex.source, `${regex.flags}g`);
-		let result = "";
-		let from = 0;
-		let match;
-		while (match = executor.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 = executor.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 src/math/mathUtil.ts
-/**
-* 数学工具类
-* - 基于 [`mathjs`](https://mathjs.org)
-*/
-var MathUtil = class MathUtil {
-	/**
-	* 将任意类型的值转换为 `math.bignumber`
-	*
-	* @param mathJsInstance mathJs 实例
-	* @param value 任意类型的值
-	* @param fallback 回退值
-	* @returns 转换后的 BigNumber
-	* @example
-	* ```ts
-	* import { create, all } from "mathjs";
-	* const math = create(all);
-	* MathUtil.toBignumber(math, "0.1");
-	* ```
-	*/
-	static toBignumber(mathJsInstance, value, fallback) {
-		const errorValue = fallback ?? mathJsInstance.bignumber(0);
-		if (TypeUtil.isFalsyLike(value) || TypeUtil.isInfinityLike(value)) return errorValue;
-		try {
-			return mathJsInstance.bignumber(StringUtil.toNumber(`${value}`));
-		} catch (error) {
-			return errorValue;
-		}
-	}
-	static toDecimal(mathJsInstance, value, precision, isFormat = true) {
-		const bigNumber = MathUtil.toBignumber(mathJsInstance, value);
-		return isFormat ? mathJsInstance.format(bigNumber, {
-			notation: "fixed",
-			precision
-		}) : bigNumber;
-	}
-	/**
-	* 数学表达式求值
-	*
-	* ⚠️ 安全警告：mathjs `evaluate` 存在已知的沙箱逃逸向量，**仅限可信输入**（硬编码表达式或受控参数），
-	* 切勿直接用于用户提供的表达式。
-	*
-	* @param mathJsInstance mathJs 实例
-	* @param expr 表达式
-	* @param scope 键值映射
-	* @returns 计算结果的字符串表示
-	* @example
-	* ```ts
-	* MathUtil.toEvaluate(math, "a + b", { a: 1, b: 2 }); // "3"
-	* ```
-	*/
-	static toEvaluate(mathJsInstance, expr, scope) {
-		const evaluateValue = `${mathJsInstance.evaluate(expr, scope || {})}`;
-		return mathJsInstance.format(MathUtil.toBignumber(mathJsInstance, evaluateValue), { notation: "fixed" });
-	}
-};
-//#endregion
-Object.defineProperty(exports, "MathUtil", {
-	enumerable: true,
-	get: function() {
-		return MathUtil;
-	}
-});
-Object.defineProperty(exports, "StringUtil", {
-	enumerable: true,
-	get: function() {
-		return StringUtil;
-	}
-});
-Object.defineProperty(exports, "TypeUtil", {
-	enumerable: true,
-	get: function() {
-		return TypeUtil;
-	}
-});