@pawover/kit 0.0.0-beta.9 → 0.1.0

package/packages/utils/dist/string-C_OCj9Lg.js

@@ -0,0 +1,950 @@
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/typeof.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);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/toPrimitive.js
+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);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/defineProperty.js
+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;
+}
+//#endregion
+//#region src/type/typeUtil.ts
+/**
+* 类型工具类
+*/
+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]"
+]));
+//#endregion
+//#region src/string/stringUtil.ts
+/**
+* 字符串工具类
+*/
+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
+export { TypeUtil as n, _defineProperty as r, StringUtil as t };