@pawover/kit 0.0.0-alpha.9 → 0.0.0-beta.1

package/dist/index.js

@@ -1 +1,1375 @@
-export * from "./utils";
+//#region src/utils/typeof/types.ts
+const PROTOTYPE_TAGS = {
+	abortSignal: "[object AbortSignal]",
+	array: "[object Array]",
+	asyncFunction: "[object AsyncFunction]",
+	asyncGeneratorFunction: "[object AsyncGeneratorFunction]",
+	bigInt: "[object BigInt]",
+	blob: "[object Blob]",
+	boolean: "[object Boolean]",
+	date: "[object Date]",
+	error: "[object Error]",
+	file: "[object File]",
+	function: "[object Function]",
+	generatorFunction: "[object GeneratorFunction]",
+	map: "[object Map]",
+	null: "[object Null]",
+	number: "[object Number]",
+	object: "[object Object]",
+	promise: "[object Promise]",
+	readableStream: "[object ReadableStream]",
+	regExp: "[object RegExp]",
+	set: "[object Set]",
+	string: "[object String]",
+	symbol: "[object Symbol]",
+	undefined: "[object Undefined]",
+	URLSearchParams: "[object URLSearchParams]",
+	weakMap: "[object WeakMap]",
+	weakSet: "[object WeakSet]",
+	webSocket: "[object WebSocket]",
+	window: "[object Window]"
+};
+const 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]"
+]);
+function resolvePrototypeString(value) {
+	return Object.prototype.toString.call(value);
+}
+
+//#endregion
+//#region src/utils/typeof/isAbortSignal.ts
+function isAbortSignal(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.abortSignal;
+}
+
+//#endregion
+//#region src/utils/typeof/isArray.ts
+function isArray(value) {
+	return Array.isArray(value);
+}
+function isTypedArray(value) {
+	return typeof value === "object" && value !== null && TYPED_ARRAY_TAGS.has(resolvePrototypeString(value));
+}
+
+//#endregion
+//#region src/utils/typeof/isBigInt.ts
+function isBigInt(value) {
+	return typeof value === "bigint";
+}
+
+//#endregion
+//#region src/utils/typeof/isBlob.ts
+function isBlob(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.blob;
+}
+
+//#endregion
+//#region src/utils/typeof/isBoolean.ts
+function isBoolean(value) {
+	return typeof value === "boolean";
+}
+
+//#endregion
+//#region src/utils/typeof/isClass.ts
+function isConstructable(fn) {
+	try {
+		Reflect.construct(fn, []);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isClass(value) {
+	return isFunction(value) && !isAsyncFunction(value) && Function.prototype.toString.call(value).startsWith("class ") && isConstructable(value) && value.prototype !== void 0;
+}
+
+//#endregion
+//#region src/utils/typeof/isObject.ts
+/**
+* 判断是否为对象类型
+* - 可选是否检查原型为 `Object.prototype`，防止原型链污染
+*
+* @param value - 待检查值
+* @param prototypeCheck - 是否进行原型检查，默认 `true`
+*/
+function isObject(value, prototypeCheck = true) {
+	const check = resolvePrototypeString(value) === PROTOTYPE_TAGS.object;
+	return prototypeCheck ? check && Object.getPrototypeOf(value) === Object.prototype : check;
+}
+
+//#endregion
+//#region src/utils/typeof/isDate.ts
+function isDate(value) {
+	if (!isObject(value)) return false;
+	try {
+		return resolvePrototypeString(value) === PROTOTYPE_TAGS.date && typeof value["getTime"] === "function";
+	} catch (error) {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/utils/typeof/isEqual.ts
+/**
+* 检查给定的值是否相等
+* @reference https://github.com/radashi-org/radashi/blob/main/src/typed/isEqual.ts
+*
+* @param {T} x
+* @param {T} y
+*/
+function isEqual(x, y) {
+	if (Object.is(x, y)) return true;
+	if (isDate(x) && isDate(y)) return x.getTime() === y.getTime();
+	if (isRegExp(x) && isRegExp(y)) return x.toString() === y.toString();
+	if (typeof x !== "object" || x === null || typeof y !== "object" || y === null) return false;
+	const keysX = Reflect.ownKeys(x);
+	const keysY = Reflect.ownKeys(y);
+	if (keysX.length !== keysY.length) return false;
+	for (const key of keysX) {
+		if (!Reflect.has(y, key)) return false;
+		if (!isEqual(x[key], y[key])) return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/utils/typeof/isError.ts
+function isError(value) {
+	return value instanceof Error || resolvePrototypeString(value) === PROTOTYPE_TAGS.error;
+}
+
+//#endregion
+//#region src/utils/typeof/isFalsy.ts
+function isFalsy(value) {
+	if (isNaN(value) || isNull(value) || isUndefined(value)) return true;
+	return value === false || value === 0 || value === 0n || value === "";
+}
+function isFalsyLike(value) {
+	if (isFalsy(value)) return true;
+	return typeof value === "string" && (value === "null" || value === "undefined" || value === "NaN" || value === "false" || value === "0" || value === "0n");
+}
+
+//#endregion
+//#region src/utils/typeof/isFile.ts
+function isFile(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.file;
+}
+
+//#endregion
+//#region src/utils/typeof/isFunction.ts
+function isFunction(value) {
+	return typeof value === "function";
+}
+function isAsyncFunction(value) {
+	return isFunction(value) && resolvePrototypeString(value) === PROTOTYPE_TAGS.asyncFunction;
+}
+function isGeneratorFunction(value) {
+	return isFunction(value) && resolvePrototypeString(value) === PROTOTYPE_TAGS.generatorFunction;
+}
+function isAsyncGeneratorFunction(value) {
+	return isFunction(value) && resolvePrototypeString(value) === PROTOTYPE_TAGS.asyncGeneratorFunction;
+}
+
+//#endregion
+//#region src/utils/typeof/isIterable.ts
+function isIterable(value) {
+	return isObject(value) && Symbol.iterator in value;
+}
+
+//#endregion
+//#region src/utils/typeof/isMap.ts
+function isMap(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.map;
+}
+function isWeakMap(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.weakMap;
+}
+
+//#endregion
+//#region src/utils/typeof/isNull.ts
+function isNull(value) {
+	return value === null;
+}
+
+//#endregion
+//#region src/utils/typeof/isNumber.ts
+/**
+* 检查 value 是否为 number 类型
+*
+* @param value - 待检查值
+* @param checkNaN - 是否排除 `NaN`，默认为 `true`
+*/
+function isNumber(value, checkNaN = true) {
+	return typeof value === "number" && (!checkNaN || !isNaN(value));
+}
+/**
+* 检查 value 是否为 NaN
+*
+* @param value - 待检查值
+*/
+function isNaN(value) {
+	return Number.isNaN(value);
+}
+/**
+* 检查 value 是否为整数
+*
+* @param value - 待检查值
+* @param safeCheck - 是否附加安全数检查
+*/
+function isInteger(value, safeCheck = true) {
+	const check = Number.isInteger(value);
+	return safeCheck ? check && Number.isSafeInteger(value) : check;
+}
+/**
+* 检查 value 是否为正整数
+* - 此函数中 `0` 不被视为正整数
+*
+* @param value - 待检查值
+* @param safeCheck - 是否附加安全数检查
+*/
+function isPositiveInteger(value, safeCheck = true) {
+	return isInteger(value, safeCheck) && value > 0;
+}
+/**
+* 检查 value 是否为负整数
+* - 此函数中 `0` 不被视为负整数
+*
+* @param value - 待检查值
+* @param safeCheck - 是否附加安全数检查
+*/
+function isNegativeInteger(value, safeCheck = true) {
+	return isInteger(value, safeCheck) && value < 0;
+}
+/**
+* 检查 value 是否为 Infinity
+* - 排除 `NaN`
+*
+* @param value - 待检查值
+*/
+function isInfinity(value) {
+	return isNumber(value) && (Number.POSITIVE_INFINITY === value || Number.NEGATIVE_INFINITY === value);
+}
+/**
+* 检查 value 是否类似 Infinity
+* - 排除 `NaN`
+*
+* @param value - 待检查值
+*/
+function isInfinityLike(value) {
+	const check = isInfinity(value);
+	if (check) return check;
+	if (typeof value === "string") {
+		const v = value.trim().toLowerCase();
+		return v === "infinity" || v === "-infinity" || v === "+infinity";
+	}
+	return false;
+}
+
+//#endregion
+//#region src/utils/typeof/isPromise.ts
+function isPromise(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.promise;
+}
+function isPromiseLike(value) {
+	return isPromise(value) || isObject(value) && isFunction(value["then"]);
+}
+
+//#endregion
+//#region src/utils/typeof/isReadableStream.ts
+/**
+* Checks if a value is a WHATWG ReadableStream instance.
+*
+* - 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.
+*/
+function isReadableStream(value) {
+	if (resolvePrototypeString(value) === PROTOTYPE_TAGS.readableStream) return true;
+	return isObject(value) && isFunction(value["getReader"]) && isFunction(value["pipeThrough"]);
+}
+
+//#endregion
+//#region src/utils/typeof/isRegExp.ts
+function isRegExp(value) {
+	if (!isObject(value)) return false;
+	try {
+		const regex = value;
+		return resolvePrototypeString(value) === PROTOTYPE_TAGS.regExp && isString(regex.source) && isString(regex.flags) && isBoolean(regex.global) && isFunction(regex.test);
+	} catch (error) {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/utils/typeof/isSet.ts
+function isSet(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.set;
+}
+function isWeakSet(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.weakSet;
+}
+
+//#endregion
+//#region src/utils/typeof/isString.ts
+function isString(value) {
+	return typeof value === "string";
+}
+
+//#endregion
+//#region src/utils/typeof/isSymbol.ts
+function isSymbol(value) {
+	return typeof value === "symbol";
+}
+
+//#endregion
+//#region src/utils/typeof/isUndefined.ts
+function isUndefined(value) {
+	return typeof value === "undefined";
+}
+
+//#endregion
+//#region src/utils/typeof/isURLSearchParams.ts
+function isURLSearchParams(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.URLSearchParams;
+}
+
+//#endregion
+//#region src/utils/typeof/isWebSocket.ts
+function isWebSocket(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.webSocket;
+}
+
+//#endregion
+//#region src/utils/typeof/isWindow.ts
+function isWindow(value) {
+	return resolvePrototypeString(value) === PROTOTYPE_TAGS.window;
+}
+
+//#endregion
+//#region src/utils/array/arrayCast.ts
+/**
+* 构造数组
+* @param candidate 待构造项
+* @param checkEmpty 是否检查 `undefined` 和 `null`
+*/
+function arrayCast(candidate, checkEmpty = true) {
+	if (checkEmpty && (isUndefined(candidate) || isNull(candidate))) return [];
+	return isArray(candidate) ? [...candidate] : [candidate];
+}
+
+//#endregion
+//#region src/utils/array/arrayCompete.ts
+/**
+* 数组竞争
+* - 返回在匹配函数的比较条件中获胜的最终项目，适用于更复杂的最小值/最大值计算
+*
+* @param initialList 数组
+* @param match 匹配函数
+*/
+function arrayCompete(initialList, match) {
+	if (!isArray(initialList) || initialList.length === 0 || !isFunction(match)) return null;
+	return initialList.reduce(match);
+}
+
+//#endregion
+//#region src/utils/array/arrayCounting.ts
+/**
+* 统计数组的项目出现次数
+* - 通过给定的标识符匹配函数，返回一个对象，其中键是回调函数返回的 key 值，每个值是一个整数，表示该 key 出现的次数
+*
+* @param initialList 初始数组
+* @param match 匹配函数
+*/
+function arrayCounting(initialList, match) {
+	if (!isArray(initialList) || !isFunction(match)) return {};
+	return initialList.reduce((prev, curr) => {
+		const id = match(curr).toString();
+		prev[id] = (prev[id] ?? 0) + 1;
+		return prev;
+	}, {});
+}
+
+//#endregion
+//#region src/utils/array/arrayDifference.ts
+/**
+* 求数组差集
+*
+* @param initialList 初始数组
+* @param diffList 对比数组
+* @param match 匹配函数
+*/
+function arrayDifference(initialList, diffList, match) {
+	if (!isArray(initialList) && !isArray(diffList)) return [];
+	if (!isArray(initialList) || !initialList.length) return [...diffList];
+	if (!isArray(diffList) || !diffList.length) return [...initialList];
+	if (!isFunction(match)) {
+		const arraySet = new Set(diffList);
+		return Array.from(new Set(initialList.filter((item) => !arraySet.has(item))));
+	}
+	const map = /* @__PURE__ */ new Map();
+	diffList.forEach((item) => {
+		map.set(match(item), true);
+	});
+	return initialList.filter((a) => !map.get(match(a)));
+}
+
+//#endregion
+//#region src/utils/array/arrayFirst.ts
+function arrayFirst(initialList, saveValue) {
+	if (!isArray(initialList) || initialList.length === 0) return saveValue;
+	return initialList[0];
+}
+
+//#endregion
+//#region src/utils/array/arrayFork.ts
+/**
+* 数组分组过滤
+* - 给定一个数组和一个条件，返回一个由两个数组组成的元组，其中第一个数组包含所有满足条件的项，第二个数组包含所有不满足条件的项
+*
+* @param initialList 初始数组
+* @param match 条件匹配函数
+*/
+function arrayFork(initialList, match) {
+	const forked = [[], []];
+	if (isArray(initialList)) for (const item of initialList) forked[match(item) ? 0 : 1].push(item);
+	return forked;
+}
+
+//#endregion
+//#region src/utils/array/arrayIntersection.ts
+/**
+* 求数组交集
+*
+* @param initialList 初始数组
+* @param diffList 对比数组
+* @param match 匹配函数
+*/
+function arrayIntersection(initialList, diffList, match) {
+	if (!isArray(initialList) && !isArray(diffList)) return [];
+	if (!isArray(initialList) || !initialList.length) return [...diffList];
+	if (!isArray(diffList) || !diffList.length) return [...initialList];
+	if (!isFunction(match)) {
+		const arraySet = new Set(diffList);
+		return Array.from(new Set(initialList.filter((item) => arraySet.has(item))));
+	}
+	const map = /* @__PURE__ */ new Map();
+	diffList.forEach((item) => {
+		map.set(match(item), true);
+	});
+	return initialList.filter((a) => map.get(match(a)));
+}
+
+//#endregion
+//#region src/utils/array/arrayLast.ts
+function arrayLast(initialList, saveValue) {
+	if (!isArray(initialList) || initialList.length === 0) return saveValue;
+	return initialList[initialList.length - 1];
+}
+
+//#endregion
+//#region src/utils/array/arrayMerge.ts
+/**
+* 数组合并
+* - 通过给定的标识符匹配函数，用第二个数组中的匹配项替换第一个数组中匹配项的所有内容
+*
+* @param initialList 初始数组
+* @param mergeList 待合并数组
+* @param match 匹配函数
+*/
+function arrayMerge(initialList, mergeList, match) {
+	if (!isArray(initialList)) return [];
+	if (!isArray(mergeList)) return [...initialList];
+	if (!isFunction(match)) return Array.from(new Set([...initialList, ...mergeList]));
+	const keys = /* @__PURE__ */ new Map();
+	for (const item of mergeList) keys.set(match(item), item);
+	return initialList.map((prevItem) => {
+		const key = match(prevItem);
+		return keys.has(key) ? keys.get(key) : prevItem;
+	});
+}
+
+//#endregion
+//#region src/utils/array/arrayPick.ts
+/**
+* 数组选择
+* - 一次性应用 `filter` 和 `map` 操作
+*
+* @param initialList 初始数组
+* @param filter filter 函数
+* @param mapper map 函数
+*/
+function arrayPick(initialList, filter, mapper) {
+	if (!isArray(initialList)) return [];
+	if (!isFunction(filter)) return [...initialList];
+	const hasMapper = isFunction(mapper);
+	return initialList.reduce((prev, curr, index) => {
+		if (!filter(curr, index)) return prev;
+		if (hasMapper) prev.push(mapper(curr, index));
+		else prev.push(curr);
+		return prev;
+	}, []);
+}
+
+//#endregion
+//#region src/utils/array/arrayReplace.ts
+/**
+* 数组项替换
+* - 在给定的数组中，替换符合匹配函数结果的项目。只替换第一个匹配项。始终返回原始数组的副本。
+*
+* @param initialList 初始数组
+* @param newItem 替换项
+* @param match 匹配函数
+*/
+function arrayReplace(initialList, newItem, match) {
+	if (!initialList) return [];
+	if (newItem === void 0 || !isFunction(match)) return [...initialList];
+	for (let i = 0; i < initialList.length; i++) {
+		const item = initialList[i];
+		if (item !== void 0 && match(item, i)) return [
+			...initialList.slice(0, i),
+			newItem,
+			...initialList.slice(i + 1, initialList.length)
+		];
+	}
+	return [...initialList];
+}
+
+//#endregion
+//#region src/utils/array/arraySplit.ts
+/**
+* 数组切分
+* - 将数组以指定的长度切分后，组合在高维数组中
+*
+* @param initialList 初始数组
+* @param size 分割尺寸，默认 `10`
+*/
+function arraySplit(initialList, size = 10) {
+	if (!isArray(initialList)) return [];
+	const count = Math.ceil(initialList.length / size);
+	return Array.from({ length: count }).fill(null).map((_c, i) => {
+		return initialList.slice(i * size, i * size + size);
+	});
+}
+
+//#endregion
+//#region src/utils/function/to.ts
+/**
+* @param promise
+* @param errorExt - 可以传递给err对象的其他信息
+*/
+function to(promise, errorExt) {
+	return promise.then((data) => [null, data]).catch((err) => {
+		if (errorExt) return [{
+			...err,
+			...errorExt
+		}, void 0];
+		return [err ? err : /* @__PURE__ */ new Error("defaultError"), void 0];
+	});
+}
+
+//#endregion
+//#region src/utils/string/stringToNumber.ts
+const R1$1 = /[^0-9.-]/g;
+/**
+* 从字符串中提取数字字符串
+*
+* @param input 待处理字符串
+*/
+function stringToNumber(input) {
+	if (!isString(input) || !input.length) return "";
+	const cleaned = input.replace(R1$1, "");
+	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;
+}
+
+//#endregion
+//#region src/utils/math/toMathBignumber.ts
+/**
+* 将任意类型的值转换为 `math.bignumber`
+*
+* @param mathJsInstance mathJs 实例
+* @param value 任意类型的值
+* @param saveValue 安全值
+*/
+function toMathBignumber(mathJsInstance, value, saveValue) {
+	const errorValue = saveValue ?? mathJsInstance.bignumber(0);
+	if (isFalsyLike(value) || isInfinityLike(value)) return errorValue;
+	try {
+		return mathJsInstance.bignumber(stringToNumber(`${value}`));
+	} catch (error) {
+		return errorValue;
+	}
+}
+
+//#endregion
+//#region src/utils/math/toMathDecimal.ts
+function toMathDecimal(mathJsInstance, value, precision, isFormat = true) {
+	const bigNumber = toMathBignumber(mathJsInstance, value);
+	return isFormat ? mathJsInstance.format(bigNumber, {
+		notation: "fixed",
+		precision
+	}) : bigNumber;
+}
+
+//#endregion
+//#region src/utils/math/toMathEvaluate.ts
+/**
+* 数学表达式求值
+*
+* @param mathJsInstance mathJs 实例
+* @param expr 表达式
+* @param scope 键值映射
+*/
+function toMathEvaluate(mathJsInstance, expr, scope) {
+	const evaluateValue = `${mathJsInstance.evaluate(expr, scope || {})}`;
+	return mathJsInstance.format(toMathBignumber(mathJsInstance, evaluateValue), { notation: "fixed" });
+}
+
+//#endregion
+//#region src/utils/object/cloneDeep.ts
+const DefaultCloningStrategy = {
+	cloneMap(input, track, clone) {
+		const output = track(/* @__PURE__ */ new Map());
+		for (const [key, value] of input) output.set(key, clone(value));
+		return output;
+	},
+	cloneSet(input, track, clone) {
+		const output = track(/* @__PURE__ */ new Set());
+		for (const value of input) output.add(clone(value));
+		return output;
+	},
+	cloneArray(input, track, clone) {
+		const output = track(new Array(input.length));
+		input.forEach((value, index) => {
+			output[index] = clone(value);
+		});
+		return output;
+	},
+	cloneObject(input, track, clone) {
+		const output = track(Object.create(Object.getPrototypeOf(input)));
+		for (const key of Reflect.ownKeys(input)) {
+			const descriptor = Object.getOwnPropertyDescriptor(input, key);
+			if ("value" in descriptor) descriptor.value = clone(descriptor.value);
+			Object.defineProperty(output, key, descriptor);
+		}
+		return output;
+	},
+	cloneOther(input, track) {
+		return track(input);
+	}
+};
+/**
+* cloneDeep
+* @reference https://github.com/radashi-org/radashi/blob/main/src/object/cloneDeep.ts
+*/
+function cloneDeep(root, customStrategy) {
+	const strategy = {
+		...DefaultCloningStrategy,
+		...customStrategy
+	};
+	const tracked = /* @__PURE__ */ new Map();
+	const track = (parent, newParent) => {
+		tracked.set(parent, newParent);
+		return newParent;
+	};
+	const clone = (value) => {
+		return value && typeof value === "object" ? tracked.get(value) ?? cloneDeep$1(value, strategy) : value;
+	};
+	const cloneDeep$1 = (parent, strategy$1) => {
+		const newParent = (isObject(parent) ? strategy$1.cloneObject : isArray(parent) ? strategy$1.cloneArray : isMap(parent) ? strategy$1.cloneMap : isSet(parent) ? strategy$1.cloneSet : strategy$1.cloneOther)(parent, track.bind(null, parent), clone);
+		if (!newParent) return cloneDeep$1(parent, DefaultCloningStrategy);
+		tracked.set(parent, newParent);
+		return newParent;
+	};
+	return cloneDeep$1(root, strategy);
+}
+
+//#endregion
+//#region src/utils/object/objectKeys.ts
+/**
+* 返回对象的可枚举属性和方法的名称
+* - `Object.keys` 始终返回 `string[]` 类型，此函数可以返回具体类型
+*
+* @param obj 对象
+*/
+function objectKeys(obj) {
+	return Object.keys(obj);
+}
+
+//#endregion
+//#region src/utils/object/enumTypeCheck.ts
+function enumTypeCheck(enumeration) {
+	if (!isObject(enumeration)) throw Error(`function enumKeys expected parameter is a enum, but got ${typeof enumeration}`);
+	if (!objectKeys(enumeration).length) throw Error("Enum requires at least one member");
+	return enumeration;
+}
+
+//#endregion
+//#region src/utils/object/objectEntries.ts
+/**
+* 返回对象的可枚举属性的键/值数组
+*
+* @param obj 对象
+*/
+function objectEntries(obj) {
+	return Object.entries(obj);
+}
+
+//#endregion
+//#region src/utils/object/objectValues.ts
+/**
+* 返回对象的可枚举属性的值数组
+*
+* @param obj 对象
+*/
+function objectValues(obj) {
+	return Object.values(obj);
+}
+
+//#endregion
+//#region src/utils/object/enumEntries.ts
+/**
+* 返回枚举的属性的键/值数组
+*
+* @param enumeration 枚举
+*/
+function enumEntries(enumeration) {
+	const e = enumTypeCheck(enumeration);
+	const keys = objectKeys(e);
+	const values = objectValues(e);
+	const entries = objectEntries(e);
+	if (keys.every((k) => values.some((v) => `${v}` === k))) return entries.splice(keys.length / 2, keys.length / 2);
+	return entries;
+}
+
+//#endregion
+//#region src/utils/object/enumKeys.ts
+/**
+* 获取枚举所有属性的键
+*
+* @param enumeration 枚举
+*/
+function enumKeys(enumeration) {
+	const e = enumTypeCheck(enumeration);
+	const keys = objectKeys(e);
+	const values = objectValues(e);
+	if (keys.every((k) => values.some((v) => `${v}` === k))) return keys.splice(keys.length / 2, keys.length / 2);
+	return keys;
+}
+
+//#endregion
+//#region src/utils/object/enumValues.ts
+/**
+* 获取枚举所有属性的值
+*
+* @param enumeration 枚举
+*/
+function enumValues(enumeration) {
+	const e = enumTypeCheck(enumeration);
+	const keys = objectKeys(e);
+	const values = objectValues(e);
+	if (keys.every((k) => values.some((v) => `${v}` === k))) return values.splice(keys.length / 2, keys.length / 2);
+	return values;
+}
+
+//#endregion
+//#region src/utils/object/mapEntries.ts
+function mapEntries(obj, toEntry) {
+	const defaultResult = {};
+	if (!obj) return defaultResult;
+	return objectEntries(obj).reduce((acc, [key, value]) => {
+		const [newKey, newValue] = toEntry(key, value);
+		acc[newKey] = newValue;
+		return acc;
+	}, defaultResult);
+}
+
+//#endregion
+//#region src/utils/object/objectAssign.ts
+/**
+* 递归地将第二个对象合并到第一个对象的副本中
+* - 只有普通对象才会递归合并
+*
+* @param initial 初始对象
+* @param override 待合并对象
+*/
+function objectAssign(initial, override) {
+	if (!isObject(initial) || !isObject(override)) return initial ?? override ?? {};
+	const proto = Object.getPrototypeOf(initial);
+	const assigned = proto ? { ...initial } : Object.assign(Object.create(proto), initial);
+	for (const key of Object.keys(override)) assigned[key] = isObject(initial[key]) && isObject(override[key]) ? objectAssign(initial[key], override[key]) : override[key];
+	return assigned;
+}
+
+//#endregion
+//#region src/utils/object/objectCrush.ts
+function objectCrush(value) {
+	if (!value) return {};
+	function crushReducer(crushed, value$1, path) {
+		if (isObject(value$1) || isArray(value$1)) for (const [prop, propValue] of Object.entries(value$1)) crushReducer(crushed, propValue, path ? `${path}.${prop}` : prop);
+		else crushed[path] = value$1;
+		return crushed;
+	}
+	return crushReducer({}, value, "");
+}
+
+//#endregion
+//#region src/utils/object/objectPick.ts
+function objectPick(obj, keys) {
+	const result = {};
+	if (!isObject(obj)) return result;
+	if (!isArray(keys)) return obj;
+	return keys.reduce((acc, curr) => {
+		if (curr in obj) acc[curr] = obj[curr];
+		return acc;
+	}, result);
+}
+
+//#endregion
+//#region src/utils/object/objectSwitch.ts
+/**
+* 对象反转
+* - 返回交换了对象的可枚举属性的值/键对象
+*
+* @param obj 对象
+*/
+function objectSwitch(obj) {
+	const result = {};
+	if (!isObject(obj)) return result;
+	for (const [k, v] of objectEntries(obj)) result[v] = k;
+	return result;
+}
+
+//#endregion
+//#region src/utils/string/stringInitialCase.ts
+const R1 = /\S+/g;
+const R2 = /[^a-zA-Z\u00C0-\u017F]/;
+/**
+* 字符串首字母大小写
+* - 包含非西欧字母字符时，不处理
+* - 纯字母且全大写时，不处理
+* - 纯字母且非全大写时，首字母小写，其余保留
+* - 纯字母且非全大写时，首字母大写，其余保留
+*
+* @param input 待处理字符串
+* @param caseType 大小写类型
+*/
+function stringInitialCase(input, caseType) {
+	if (!isString(input) || !input.length) return "";
+	return input.replace(R1, (word) => {
+		if (R2.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;
+	});
+}
+
+//#endregion
+//#region src/utils/string/stringReplace.ts
+/**
+* 字符串替换
+* - 替换第一个匹配项
+*
+* @param input 待处理字符串
+* @param search 匹配项
+* @param replacement 替换项
+*/
+function stringReplace(input, search, replacement) {
+	if (!isString(input) || !input.length) return "";
+	return input.replace(search, replacement);
+}
+
+//#endregion
+//#region src/utils/string/stringTemplate.ts
+/**
+* 字符串模板替换
+*
+* @param input 待处理字符串
+* @param template 模板对象
+* @param regex 模板匹配正则
+*/
+function stringTemplate(input, template, regex = /\{\{(.+?)\}\}/g) {
+	if (!isString(input) || !input.length) return "";
+	let result = "";
+	let from = 0;
+	let match;
+	while (match = regex.exec(input)) {
+		result += input.slice(from, match.index) + template[match[1]];
+		from = regex.lastIndex;
+	}
+	return result + input.slice(from);
+}
+
+//#endregion
+//#region src/utils/string/stringToJson.ts
+/**
+* 处理 JSON 字符串
+*
+* @param input 待处理字符串
+* @param safeValue 安全值
+*/
+function stringToJson(input, safeValue) {
+	if (!isString(input) || !input.length) return safeValue;
+	try {
+		return JSON.parse(input);
+	} catch (error) {
+		return safeValue;
+	}
+}
+
+//#endregion
+//#region src/utils/string/stringToValues.ts
+function stringToValues(input, valueType = "number", splitSymbol = ",") {
+	if (!isString(input) || !input.length) return [];
+	try {
+		const values = input.split(splitSymbol);
+		if (valueType === "number") return values.map((d) => Number(d));
+		return values;
+	} catch (error) {
+		return [];
+	}
+}
+
+//#endregion
+//#region src/utils/tree/types.ts
+function getFinalChildrenKey(tree, meta, options) {
+	if (isFunction(options.getChildrenKey)) {
+		const dynamicChildrenKey = options.getChildrenKey(tree, meta);
+		if (dynamicChildrenKey && dynamicChildrenKey !== null) return dynamicChildrenKey;
+	}
+	return options.childrenKey;
+}
+
+//#endregion
+//#region src/utils/tree/treeFilter.ts
+function preImpl$3(row, callback, options) {
+	if (!callback(row, options)) return;
+	const finalChildrenKey = getFinalChildrenKey(row, options, options);
+	const children = row[finalChildrenKey];
+	let newChildren;
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		newChildren = children.map((c) => preImpl$3(c, callback, nextLevelOptions)).filter((c) => !!c);
+	}
+	return {
+		...row,
+		[finalChildrenKey]: newChildren
+	};
+}
+function postImpl$3(row, callback, options) {
+	const finalChildrenKey = getFinalChildrenKey(row, options, options);
+	const children = row[finalChildrenKey];
+	let newChildren;
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		newChildren = children.map((c) => preImpl$3(c, callback, nextLevelOptions)).filter((c) => !!c);
+	}
+	if (!callback(row, options)) return;
+	return {
+		...row,
+		[finalChildrenKey]: newChildren
+	};
+}
+function breadthImpl$3(row, callback, options) {
+	const queue = [{
+		queueRow: row,
+		queueOptions: options
+	}];
+	const resultCache = /* @__PURE__ */ new WeakMap();
+	const newNodeCache = /* @__PURE__ */ new WeakMap();
+	const childrenKeyCache = /* @__PURE__ */ new WeakMap();
+	let result;
+	const runQueue = () => {
+		if (queue.length === 0) return result;
+		const { queueRow, queueOptions } = queue.shift();
+		const finalChildrenKey = getFinalChildrenKey(queueRow, queueOptions, queueOptions);
+		const children = queueRow[finalChildrenKey];
+		if (isArray(children)) {
+			const nextLevelOptions = {
+				...queueOptions,
+				parents: [...queueOptions.parents, queueRow],
+				depth: queueOptions.depth + 1
+			};
+			const subQueueItems = children.map((queueRow$1) => ({
+				queueRow: queueRow$1,
+				queueOptions: nextLevelOptions
+			}));
+			queue.push(...subQueueItems);
+		}
+		const parent = arrayLast(queueOptions.parents);
+		const isTopNode = queueOptions.depth === 0;
+		const parentResult = parent && resultCache.get(parent);
+		if (!isTopNode && !parentResult) return runQueue();
+		const callbackResult = callback(queueRow, queueOptions);
+		if (isTopNode && !callbackResult) return;
+		const newNode = {
+			...queueRow,
+			[finalChildrenKey]: void 0
+		};
+		if (isTopNode) result = newNode;
+		resultCache.set(queueRow, callbackResult);
+		newNodeCache.set(queueRow, newNode);
+		childrenKeyCache.set(queueRow, finalChildrenKey);
+		if (callbackResult && parent) {
+			const parentNewNode = newNodeCache.get(parent);
+			const parentChildrenKey = childrenKeyCache.get(parent);
+			if (parentNewNode && parentChildrenKey) {
+				if (!parentNewNode[parentChildrenKey]) parentNewNode[parentChildrenKey] = [];
+				parentNewNode[parentChildrenKey].push(newNode);
+			}
+		}
+		return runQueue();
+	};
+	return runQueue();
+}
+const strategies$3 = {
+	pre: preImpl$3,
+	post: postImpl$3,
+	breadth: breadthImpl$3
+};
+function treeFilter(tree, callback, options = {}) {
+	const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+	const traversalMethod = strategies$3[strategy];
+	const innerOptions = {
+		childrenKey,
+		depth: 0,
+		parents: [],
+		getChildrenKey
+	};
+	return isArray(tree) ? tree.map((row) => traversalMethod(row, callback, innerOptions)).filter((t) => !!t) : traversalMethod(tree, callback, innerOptions) || [];
+}
+
+//#endregion
+//#region src/utils/tree/treeFind.ts
+const strategies$2 = {
+	pre: preImpl$2,
+	post: postImpl$2,
+	breadth: breadthImpl$2
+};
+function preImpl$2(row, callback, options) {
+	if (callback(row, options)) return row;
+	const children = row[getFinalChildrenKey(row, options, options)];
+	if (isArray(children)) for (const child of children) {
+		const result = preImpl$2(child, callback, {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		});
+		if (result) return result;
+	}
+}
+function postImpl$2(row, callback, options) {
+	const children = row[getFinalChildrenKey(row, options, options)];
+	if (isArray(children)) for (const child of children) {
+		const result = postImpl$2(child, callback, {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		});
+		if (result) return result;
+	}
+	if (callback(row, options)) return row;
+}
+function breadthImpl$2(row, callback, options) {
+	const queue = [{
+		queueRow: row,
+		queueOptions: options
+	}];
+	const runQueue = () => {
+		if (queue.length === 0) return;
+		const { queueRow, queueOptions } = queue.shift();
+		const children = queueRow[getFinalChildrenKey(queueRow, queueOptions, queueOptions)];
+		if (isArray(children)) {
+			const nextLevelOptions = {
+				...queueOptions,
+				parents: [...queueOptions.parents, queueRow],
+				depth: queueOptions.depth + 1
+			};
+			const subQueueItems = children.map((queueRow$1) => ({
+				queueRow: queueRow$1,
+				queueOptions: nextLevelOptions
+			}));
+			queue.push(...subQueueItems);
+		}
+		if (callback(queueRow, queueOptions)) return queueRow;
+		return runQueue();
+	};
+	return runQueue();
+}
+/**
+* 查找树节点，找到第一个返回非空值的节点
+*/
+function treeFind(tree, callback, options = {}) {
+	const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+	const traversalMethod = strategies$2[strategy];
+	const innerOptions = {
+		childrenKey,
+		depth: 0,
+		parents: [],
+		getChildrenKey
+	};
+	if (isArray(tree)) {
+		for (const row of tree) {
+			const result = traversalMethod(row, callback, innerOptions);
+			if (result) return result;
+		}
+		return;
+	}
+	return traversalMethod(tree, callback, innerOptions);
+}
+
+//#endregion
+//#region src/utils/tree/treeForEach.ts
+const strategies$1 = {
+	pre: preImpl$1,
+	post: postImpl$1,
+	breadth: breadthImpl$1
+};
+function preImpl$1(row, callback, options) {
+	callback(row, options);
+	const children = row[getFinalChildrenKey(row, options, options)];
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		for (const child of children) preImpl$1(child, callback, nextLevelOptions);
+	}
+}
+function postImpl$1(row, callback, options) {
+	const children = row[getFinalChildrenKey(row, options, options)];
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		for (const child of children) postImpl$1(child, callback, nextLevelOptions);
+	}
+	callback(row, options);
+}
+function breadthImpl$1(row, callback, options) {
+	const queue = [{
+		queueRow: row,
+		queueOptions: options
+	}];
+	const runQueue = () => {
+		if (queue.length === 0) return;
+		const { queueRow, queueOptions } = queue.shift();
+		const children = queueRow[getFinalChildrenKey(queueRow, queueOptions, queueOptions)];
+		if (isArray(children)) {
+			const nextLevelOptions = {
+				...queueOptions,
+				parents: [...queueOptions.parents, queueRow],
+				depth: queueOptions.depth + 1
+			};
+			const subQueueItems = children.map((queueRow$1) => ({
+				queueRow: queueRow$1,
+				queueOptions: nextLevelOptions
+			}));
+			queue.push(...subQueueItems);
+		}
+		callback(queueRow, queueOptions);
+		runQueue();
+	};
+	runQueue();
+}
+function treeForEach(tree, callback, options = {}) {
+	const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+	const traversalMethod = strategies$1[strategy];
+	const innerOptions = {
+		childrenKey,
+		depth: 0,
+		parents: [],
+		getChildrenKey
+	};
+	if (isArray(tree)) for (const row of tree) traversalMethod(row, callback, innerOptions);
+	else traversalMethod(tree, callback, innerOptions);
+}
+
+//#endregion
+//#region src/utils/tree/treeMap.ts
+const strategies = {
+	pre: preImpl,
+	post: postImpl,
+	breadth: breadthImpl
+};
+function preImpl(row, callback, options) {
+	const finalChildrenKey = getFinalChildrenKey(row, options, options);
+	const result = callback(row, options);
+	const children = row[finalChildrenKey];
+	let newChildren;
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		newChildren = children.map((c) => preImpl(c, callback, nextLevelOptions));
+	}
+	return {
+		...result,
+		[finalChildrenKey]: newChildren
+	};
+}
+function postImpl(row, callback, options) {
+	const finalChildrenKey = getFinalChildrenKey(row, options, options);
+	const children = row[finalChildrenKey];
+	let newChildren;
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		newChildren = children.map((c) => postImpl(c, callback, nextLevelOptions));
+	}
+	return {
+		...callback(row, options),
+		[finalChildrenKey]: newChildren
+	};
+}
+function breadthImpl(row, callback, options) {
+	const queue = [{
+		queueRow: row,
+		queueOptions: options
+	}];
+	const cache = /* @__PURE__ */ new WeakMap();
+	const childrenKeyCache = /* @__PURE__ */ new WeakMap();
+	let result;
+	const runQueue = () => {
+		if (queue.length === 0) return result;
+		const { queueRow, queueOptions } = queue.shift();
+		const finalChildrenKey = getFinalChildrenKey(queueRow, queueOptions, queueOptions);
+		const children = queueRow[finalChildrenKey];
+		if (isArray(children)) {
+			const nextLevelOptions = {
+				...queueOptions,
+				parents: [...queueOptions.parents, queueRow],
+				depth: queueOptions.depth + 1
+			};
+			const subQueueItems = children.map((queueRow$1) => ({
+				queueRow: queueRow$1,
+				queueOptions: nextLevelOptions
+			}));
+			queue.push(...subQueueItems);
+		}
+		const res = callback(queueRow, queueOptions);
+		cache.set(queueRow, res);
+		childrenKeyCache.set(queueRow, finalChildrenKey);
+		const parent = arrayLast(queueOptions.parents);
+		if (parent) {
+			const newParent = cache.get(parent);
+			const parentChildrenKey = childrenKeyCache.get(parent);
+			if (newParent && parentChildrenKey) if (newParent[parentChildrenKey]) newParent[parentChildrenKey].push(res);
+			else newParent[parentChildrenKey] = [res];
+		}
+		if (queueOptions.depth === 0) result = res;
+		return runQueue();
+	};
+	return runQueue();
+}
+function treeMap(tree, callback, options = {}) {
+	const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+	const traversalMethod = strategies[strategy];
+	const innerOptions = {
+		childrenKey,
+		depth: 0,
+		parents: [],
+		getChildrenKey
+	};
+	return isArray(tree) ? tree.map((row) => traversalMethod(row, callback, innerOptions)) : traversalMethod(tree, callback, innerOptions);
+}
+
+//#endregion
+//#region src/utils/tree/rowsToTree.ts
+/**
+* 行结构 转 树结构
+*/
+function rowsToTree(rows, options) {
+	const { parentIdKey = "parentId", rowKey = "id", childrenKey = "children" } = options || {};
+	const result = [];
+	const map = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const id = row[rowKey];
+		if (!map.get(id)) map.set(id, row);
+	}
+	for (const row of rows) {
+		const parentId = row[parentIdKey];
+		const parent = map.get(parentId);
+		if (!parent || !parentId) {
+			result.push(row);
+			continue;
+		}
+		const siblings = parent[childrenKey];
+		if (isNull(siblings) || isUndefined(siblings)) parent[childrenKey] = [row];
+		else if (Array.isArray(siblings)) siblings.push(row);
+		else {
+			const message = `The key "${childrenKey.toString()}" in parent item is not an array.`;
+			throw new Error(message);
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/utils/tree/treeToRows.ts
+/**
+* 树结构 转 行结构
+*/
+function treeToRows(tree, options = {}) {
+	const { childrenKey = "children" } = options;
+	const result = [];
+	if (!tree) return result;
+	treeForEach(tree, (t) => result.push({
+		...t,
+		[childrenKey]: void 0
+	}), options);
+	return result;
+}
+
+//#endregion
+export { arrayCast, arrayCompete, arrayCounting, arrayDifference, arrayFirst, arrayFork, arrayIntersection, arrayLast, arrayMerge, arrayPick, arrayReplace, arraySplit, cloneDeep, enumEntries, enumKeys, enumTypeCheck, enumValues, isAbortSignal, isArray, isAsyncFunction, isAsyncGeneratorFunction, isBigInt, isBlob, isBoolean, isClass, isDate, isEqual, isError, isFalsy, isFalsyLike, isFile, isFunction, isGeneratorFunction, isInfinity, isInfinityLike, isInteger, isIterable, isMap, isNaN, isNegativeInteger, isNull, isNumber, isObject, isPositiveInteger, isPromise, isPromiseLike, isReadableStream, isRegExp, isSet, isString, isSymbol, isTypedArray, isURLSearchParams, isUndefined, isWeakMap, isWeakSet, isWebSocket, isWindow, mapEntries, objectAssign, objectCrush, objectEntries, objectKeys, objectPick, objectSwitch, objectValues, rowsToTree, stringInitialCase, stringReplace, stringTemplate, stringToJson, stringToNumber, stringToValues, to, toMathBignumber, toMathDecimal, toMathEvaluate, treeFilter, treeFind, treeForEach, treeMap, treeToRows };
+//# sourceMappingURL=index.js.map