@pawover/kit 0.0.0-beta.45 → 0.0.0-beta.50

package/packages/utils/dist/index.js

@@ -0,0 +1,1527 @@
+import { n as TypeUtil, r as _defineProperty, t as StringUtil } from "./string-CESQdidv.js";
+//#region src/array/arrayUtil.ts
+/**
+* 数组工具类
+*/
+var ArrayUtil = class {
+	static cast(candidate, checkEmpty = true) {
+		if (checkEmpty && (TypeUtil.isUndefined(candidate) || TypeUtil.isNull(candidate))) return [];
+		return TypeUtil.isArray(candidate) ? [...candidate] : [candidate];
+	}
+	static first(initialList, fallback) {
+		if (!TypeUtil.isArray(initialList) || initialList.length === 0) return fallback;
+		return initialList[0];
+	}
+	static last(initialList, fallback) {
+		if (!TypeUtil.isArray(initialList) || initialList.length === 0) return fallback;
+		return initialList[initialList.length - 1];
+	}
+	/**
+	* 数组竞选
+	* - 返回在匹配函数的比较条件中获胜的最终项目，适用于更复杂的最小值/最大值计算
+	*
+	* @param initialList 数组
+	* @param match 匹配函数
+	* @returns 获胜的元素，如果数组为空或参数无效则返回 `null`
+	* @example
+	* ```ts
+	* const list = [1, 10, 5];
+	* ArrayUtil.compete(list, (a, b) => (a > b ? a : b)); // 10
+	* ArrayUtil.compete(list, (a, b) => (a < b ? a : b)); // 1
+	* ```
+	*/
+	static compete(initialList, match) {
+		if (!TypeUtil.isArray(initialList) || initialList.length === 0 || !TypeUtil.isFunction(match)) return null;
+		return initialList.reduce(match);
+	}
+	/**
+	* 统计数组的项目出现次数
+	* - 通过给定的标识符匹配函数，返回一个对象，其中键是回调函数返回的 key 值，每个值是一个整数，表示该 key 出现的次数
+	*
+	* @param initialList 初始数组
+	* @param match 匹配函数
+	* @returns 统计对象
+	* @example
+	* ```ts
+	* const list = ["a", "b", "a", "c"];
+	* ArrayUtil.count(list, (x) => x); // { a: 2, b: 1, c: 1 }
+	*
+	* const users = [{ id: 1, group: "A" }, { id: 2, group: "B" }, { id: 3, group: "A" }];
+	* ArrayUtil.count(users, (u) => u.group); // { A: 2, B: 1 }
+	* ```
+	*/
+	static count(initialList, match) {
+		if (!TypeUtil.isArray(initialList) || !TypeUtil.isFunction(match)) return {};
+		return initialList.reduce((prev, curr, index) => {
+			const id = match(curr, index).toString();
+			prev[id] = (prev[id] ?? 0) + 1;
+			return prev;
+		}, {});
+	}
+	/**
+	* 获取数组差集
+	* - 返回在 `initialList` 中存在，但在 `diffList` 中不存在的元素
+	*
+	* @param initialList 初始数组
+	* @param diffList 对比数组
+	* @param match 匹配函数
+	* @returns 差集数组
+	* @example
+	* ```ts
+	* ArrayUtil.difference([1, 2, 3], [2, 3, 4]); // [1]
+	* ArrayUtil.difference([{ id: 1 }, { id: 2 }], [{ id: 2 }], (x) => x.id); // [{ id: 1 }]
+	* ```
+	*/
+	static difference(initialList, diffList, match) {
+		if (!TypeUtil.isArray(initialList) && !TypeUtil.isArray(diffList)) return [];
+		if (!TypeUtil.isArray(initialList) || !initialList.length) return [];
+		if (!TypeUtil.isArray(diffList) || !diffList.length) return [...initialList];
+		if (!TypeUtil.isFunction(match)) {
+			const arraySet = new Set(diffList);
+			return Array.from(new Set(initialList.filter((item) => !arraySet.has(item))));
+		}
+		const map = /* @__PURE__ */ new Map();
+		diffList.forEach((item, index) => {
+			map.set(match(item, index), true);
+		});
+		return initialList.filter((item, index) => !map.get(match(item, index)));
+	}
+	static intersection(initialList, diffList, match) {
+		if (!TypeUtil.isArray(initialList) || !TypeUtil.isArray(diffList)) return [];
+		if (!initialList.length || !diffList.length) return [];
+		if (!TypeUtil.isFunction(match)) {
+			const diffSet = new Set(diffList);
+			return initialList.filter((item) => diffSet.has(item));
+		}
+		const diffKeys = new Set(diffList.map((item, index) => match(item, index)));
+		return initialList.filter((item, index) => diffKeys.has(match(item, index)));
+	}
+	static merge(initialList, mergeList, match) {
+		if (!TypeUtil.isArray(initialList)) return [];
+		if (!TypeUtil.isArray(mergeList)) return [...initialList];
+		if (!TypeUtil.isFunction(match)) return Array.from(new Set([...initialList, ...mergeList]));
+		const keys = /* @__PURE__ */ new Map();
+		mergeList.forEach((item, index) => {
+			keys.set(match(item, index), item);
+		});
+		return initialList.map((prevItem, index) => {
+			const key = match(prevItem, index);
+			return keys.has(key) ? keys.get(key) : prevItem;
+		});
+	}
+	static pick(initialList, filter, mapper) {
+		if (!TypeUtil.isArray(initialList)) return [];
+		if (!TypeUtil.isFunction(filter)) return [...initialList];
+		const hasMapper = TypeUtil.isFunction(mapper);
+		return initialList.reduce((prev, curr, index) => {
+			if (!filter(curr, index)) return prev;
+			if (hasMapper) prev.push(mapper(curr, index));
+			else prev.push(curr);
+			return prev;
+		}, []);
+	}
+	static replace(initialList, newItem, match) {
+		if (!TypeUtil.isArray(initialList) || !initialList.length) return [];
+		if (!TypeUtil.isFunction(match)) return [...initialList];
+		for (let i = 0; i < initialList.length; i++) {
+			const item = initialList[i];
+			if (match(item, i)) return [
+				...initialList.slice(0, i),
+				newItem,
+				...initialList.slice(i + 1, initialList.length)
+			];
+		}
+		return [...initialList];
+	}
+	/**
+	* 数组项替换并移动
+	* - 在给定的数组中，替换并移动符合匹配函数结果的项目
+	* - 只替换和移动第一个匹配项
+	* - 未匹配时，根据 `position` 在指定位置插入 `newItem`
+	*
+	* @param initialList 初始数组
+	* @param newItem 替换项
+	* @param match 匹配函数
+	* @param position 移动位置，可选 `start` | `end` | 索引位置， 默认为 `end`
+	* @returns
+	* @example
+	* ```ts
+	* ArrayUtil.replaceMove([1, 2, 3, 4], 5, (n) => n === 2, 0); // [5, 1, 3, 4]
+	* ArrayUtil.replaceMove([1, 2, 3, 4], 5, (n) => n === 2, 2); // [1, 3, 5, 4]
+	* ArrayUtil.replaceMove([1, 2, 3, 4], 5, (n) => n === 2, "start"); // [5, 1, 3, 4]
+	* ArrayUtil.replaceMove([1, 2, 3, 4], 5, (n) => n === 2); // [1, 3, 4, 5]
+	* ```
+	*/
+	static replaceMove(initialList, newItem, match, position) {
+		if (!TypeUtil.isArray(initialList)) return [];
+		if (!initialList.length) return [newItem];
+		if (!TypeUtil.isFunction(match)) return [...initialList];
+		const result = [...initialList];
+		const matchIndex = initialList.findIndex(match);
+		if (matchIndex !== -1) result.splice(matchIndex, 1);
+		if (position === "start") result.unshift(newItem);
+		else if (position === 0 || TypeUtil.isPositiveInteger(position, false)) result.splice(Math.min(position, result.length), 0, newItem);
+		else result.push(newItem);
+		return result;
+	}
+	/**
+	* 数组切分
+	* - 将数组以指定的长度切分后，组合在高维数组中
+	*
+	* @param initialList 初始数组
+	* @param size 分割尺寸，默认 `10`
+	* @returns 切分后的二维数组
+	* @example
+	* ```ts
+	* ArrayUtil.split([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]
+	* ```
+	*/
+	static split(initialList, size = 10) {
+		if (!TypeUtil.isArray(initialList)) return [];
+		if (!TypeUtil.isPositiveInteger(size, false)) return [];
+		const count = Math.ceil(initialList.length / size);
+		return Array.from({ length: count }).fill(null).map((_c, i) => {
+			return initialList.slice(i * size, i * size + size);
+		});
+	}
+	/**
+	* 数组分组过滤
+	* - 给定一个数组和一个条件，返回一个由两个数组组成的元组，其中第一个数组包含所有满足条件的项，第二个数组包含所有不满足条件的项
+	*
+	* @param initialList 初始数组
+	* @param match 条件匹配函数
+	* @returns [满足条件的项[], 不满足条件的项[]]
+	* @example
+	* ```ts
+	* ArrayUtil.fork([1, 2, 3, 4], (n) => n % 2 === 0); // [[2, 4], [1, 3]]
+	* ```
+	*/
+	static fork(initialList, match) {
+		const forked = [[], []];
+		if (TypeUtil.isArray(initialList)) initialList.forEach((item, index) => {
+			forked[match(item, index) ? 0 : 1].push(item);
+		});
+		return forked;
+	}
+	/**
+	* 数组解压
+	* - `ArrayUtil.zip` 的反向操作
+	*
+	* @param arrayList 压缩后的数组
+	* @returns 解压后的二维数组
+	* @example
+	* ```ts
+	* ArrayUtil.unzip([[1, "a"], [2, "b"]]); // [[1, 2], ["a", "b"]]
+	* ```
+	*/
+	static unzip(arrayList) {
+		if (!TypeUtil.isArray(arrayList) || !arrayList.length) return [];
+		const out = new Array(arrayList.reduce((max, arr) => Math.max(max, arr.length), 0));
+		let index = 0;
+		const get = (array) => array[index];
+		for (; index < out.length; index++) out[index] = Array.from(arrayList, get);
+		return out;
+	}
+	static zip(...arrays) {
+		return this.unzip(arrays);
+	}
+	static zipToObject(keys, values) {
+		const result = {};
+		if (!TypeUtil.isArray(keys) || !keys.length) return result;
+		const getValue = TypeUtil.isFunction(values) ? values : TypeUtil.isArray(values) ? (_k, i) => values[i] : (_k, _i) => values;
+		return keys.reduce((acc, key, idx) => {
+			acc[key] = getValue(key, idx);
+			return acc;
+		}, result);
+	}
+};
+//#endregion
+//#region src/dateTime/dateTimeUtil.ts
+var _DateTimeUtil;
+/**
+* 日期工具类
+*/
+var DateTimeUtil = class {
+	/**
+	* 获取当前时区信息
+	*
+	* @returns 时区信息对象 (UTC偏移和时区名称)
+	* @example
+	* ```ts
+	* DateTimeUtil.getTimeZone(); // { UTC: "UTC+8", timeZone: "Asia/Shanghai" }
+	* ```
+	*/
+	static getTimeZone() {
+		const hour = 0 - (/* @__PURE__ */ new Date()).getTimezoneOffset() / this.MINUTE_PER_HOUR;
+		return {
+			UTC: "UTC" + (hour >= 0 ? "+" + hour : hour),
+			timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone
+		};
+	}
+};
+_DateTimeUtil = DateTimeUtil;
+_defineProperty(DateTimeUtil, "MILLISECONDS_PER_SECOND", 1e3);
+_defineProperty(DateTimeUtil, "SECOND_PER_MINUTE", 60);
+_defineProperty(DateTimeUtil, "MINUTE_PER_HOUR", 60);
+_defineProperty(DateTimeUtil, "SECOND_PER_HOUR", _DateTimeUtil.SECOND_PER_MINUTE ** 2);
+_defineProperty(DateTimeUtil, "HOUR_PER_DAY", 24);
+_defineProperty(DateTimeUtil, "SECOND_PER_DAY", _DateTimeUtil.SECOND_PER_HOUR * _DateTimeUtil.HOUR_PER_DAY);
+_defineProperty(DateTimeUtil, "DAY_PER_WEEK", 7);
+_defineProperty(DateTimeUtil, "DAY_PER_MONTH", 30);
+_defineProperty(DateTimeUtil, "DAY_PER_YEAR", 365);
+_defineProperty(DateTimeUtil, "MONTH_PER_YEAR", 12);
+_defineProperty(DateTimeUtil, "WEEK_PER_YEAR", 52);
+_defineProperty(DateTimeUtil, "WEEK_PER_MONTH", 4);
+_defineProperty(DateTimeUtil, "FORMAT", {
+	ISO_DATE: "yyyy-MM-dd",
+	ISO_TIME: "HH:mm:ss",
+	ISO_DATE_TIME: "yyyy-MM-dd HH:mm:ss",
+	ISO_DATE_TIME_MS: "yyyy-MM-dd HH:mm:ss.SSS",
+	ISO_DATETIME_TZ: "yyyy-MM-dd'T'HH:mm:ssXXX",
+	ISO_DATETIME_TZ_MS: "yyyy-MM-dd'T'HH:mm:ss.SSSXXX",
+	US_DATE: "MM/dd/yyyy",
+	US_DATE_TIME: "MM/dd/yyyy HH:mm:ss",
+	US_DATE_SHORT_YEAR: "MM/dd/yy",
+	EU_DATE: "dd/MM/yyyy",
+	EU_DATE_TIME: "dd/MM/yyyy HH:mm:ss",
+	CN_DATE: "yyyy年MM月dd日",
+	CN_DATE_TIME: "yyyy年MM月dd日 HH时mm分ss秒",
+	CN_DATE_WEEKDAY: "yyyy年MM月dd日 EEE",
+	CN_WEEKDAY_FULL: "EEEE",
+	SHORT_DATE: "yy-MM-dd",
+	SHORT_DATE_SLASH: "yy/MM/dd",
+	MONTH_DAY: "MM-dd",
+	MONTH_DAY_CN: "MM月dd日",
+	DATE_WITH_WEEKDAY_SHORT: "yyyy-MM-dd (EEE)",
+	DATE_WITH_WEEKDAY_FULL: "yyyy-MM-dd (EEEE)",
+	TIME_24: "HH:mm:ss",
+	TIME_24_NO_SEC: "HH:mm",
+	TIME_12: "hh:mm:ss a",
+	TIME_12_NO_SEC: "hh:mm a",
+	TIMESTAMP: "yyyyMMddHHmmss",
+	TIMESTAMP_MS: "yyyyMMddHHmmssSSS",
+	RFC2822: "EEE, dd MMM yyyy HH:mm:ss xxx",
+	READABLE_DATE: "MMM dd, yyyy",
+	READABLE_DATE_TIME: "MMM dd, yyyy HH:mm",
+	COMPACT_DATETIME: "yyyyMMdd_HHmmss"
+});
+//#endregion
+//#region src/env/envUtil.ts
+/**
+* 环境检查工具类
+*/
+var EnvUtil = class {
+	static isBrowser() {
+		return this._isBrowser;
+	}
+	static isWebWorker() {
+		return this._isWebWorker;
+	}
+	static isReactNative() {
+		return this._isReactNative;
+	}
+	/**
+	* 检查是否在 iframe 环境中
+	*/
+	static isIframe() {
+		if (typeof window === "undefined") return false;
+		try {
+			return window.top !== window.self;
+		} catch (error) {
+			if (error.name === "SecurityError") return true;
+			return false;
+		}
+	}
+	/**
+	* 检测当前设备是否为桌面设备
+	*
+	* @param minWidth - 桌面设备最小宽度（默认 1200px）
+	* @param minScreenSize - 桌面设备最小屏幕尺寸（默认 10英寸）
+	* @param dpi - 标准 DPI 基准（默认 160）
+	* @returns 是否为桌面设备
+	* @example
+	* ```ts
+	* // 假设 window.innerWidth = 1920
+	* EnvUtil.isDesktop(); // true
+	*
+	* // 自定义阈值
+	* EnvUtil.isDesktop(1440, 13); // 更严格的桌面检测
+	* ```
+	*/
+	static isDesktop(minWidth = 1200, minScreenSize = 10, dpi = 160) {
+		if (typeof window === "undefined" || !TypeUtil.isPositiveInteger(minWidth) || !TypeUtil.isPositiveInteger(minScreenSize)) return false;
+		if (window.innerWidth < minWidth) return false;
+		try {
+			const widthPx = window.screen.width;
+			const heightPx = window.screen.height;
+			const DPI = dpi * (window.devicePixelRatio || 1);
+			const widthInch = widthPx / DPI;
+			const heightInch = heightPx / DPI;
+			return Math.sqrt(widthInch ** 2 + heightInch ** 2) >= minScreenSize;
+		} catch {
+			return true;
+		}
+	}
+	/**
+	* 检测当前设备是否为 Windows 桌面设备
+	*
+	* @param minWidth - 桌面设备最小宽度（默认 1200px）
+	* @param minScreenSize - 桌面设备最小屏幕尺寸（默认 10英寸）
+	* @param dpi - 标准 DPI 基准（默认 160）
+	* @returns 是否为 Windows 桌面设备
+	* @example
+	* ```ts
+	* // UA contains Windows
+	* EnvUtil.isWindowsDesktop(); // true
+	* ```
+	*/
+	static isWindowsDesktop(minWidth = 1200, minScreenSize = 10, dpi = 160) {
+		if (typeof navigator === "undefined" || !navigator.userAgent) return false;
+		return /Windows/i.test(navigator.userAgent) && this.isDesktop(minWidth, minScreenSize, dpi);
+	}
+	/**
+	* 检测当前设备是否为 macOS 桌面设备
+	*
+	* @param minWidth - 桌面设备最小宽度（默认 1200px）
+	* @param minScreenSize - 桌面设备最小屏幕尺寸（默认 10英寸）
+	* @param dpi - 标准 DPI 基准（默认 160）
+	* @returns 是否为 macOS 桌面设备
+	* @example
+	* ```ts
+	* // UA contains Macintosh
+	* EnvUtil.isMacOSDesktop(); // true
+	* ```
+	*/
+	static isMacOSDesktop(minWidth = 1200, minScreenSize = 10, dpi = 160) {
+		if (typeof navigator === "undefined" || !navigator.userAgent) return false;
+		return /Macintosh/i.test(navigator.userAgent) && this.isDesktop(minWidth, minScreenSize, dpi);
+	}
+	/**
+	* 检测当前设备是否为移动设备
+	*
+	* @param maxWidth - 移动设备最大宽度（默认 768px）
+	* @param dpi - 标准 DPI 基准（默认 160）
+	* @returns 是否为移动设备
+	* @example
+	* ```ts
+	* // 假设 window.innerWidth = 500
+	* EnvUtil.isMobile(); // true
+	* ```
+	*/
+	static isMobile(maxWidth = 768, dpi = 160) {
+		if (typeof window === "undefined" || !TypeUtil.isPositiveInteger(maxWidth)) return false;
+		if (window.innerWidth >= maxWidth) return false;
+		try {
+			const widthPx = window.screen.width;
+			const heightPx = window.screen.height;
+			const DPI = dpi * (window.devicePixelRatio || 1);
+			const widthInch = widthPx / DPI;
+			const heightInch = heightPx / DPI;
+			return Math.sqrt(widthInch ** 2 + heightInch ** 2) < 7;
+		} catch {
+			return true;
+		}
+	}
+	/**
+	* 检测当前设备是否为IOS移动设备
+	*
+	* @param maxWidth - 移动设备最大宽度（默认 768px）
+	* @param dpi - 标准 DPI 基准（默认 160）
+	* @returns 是否为 iOS 移动设备 (iPhone/iPod)
+	* @example
+	* ```ts
+	* // UA contains iPhone
+	* EnvUtil.isIOSMobile(); // true
+	* ```
+	*/
+	static isIOSMobile(maxWidth = 768, dpi = 160) {
+		if (typeof navigator === "undefined" || !navigator.userAgent) return false;
+		return /iPhone|iPad|iPod/i.test(navigator.userAgent) && this.isMobile(maxWidth, dpi);
+	}
+	/**
+	* 检测当前设备是否为平板
+	*
+	* @param minWidth - 平板最小宽度（默认 768px）
+	* @param maxWidth - 平板最大宽度（默认 1200px）
+	* @param dpi - 标准 DPI 基准（默认 160）
+	* @returns 是否为平板设备
+	* @example
+	* ```ts
+	* // 假设 window.innerWidth = 1000
+	* EnvUtil.isTablet(); // true
+	* ```
+	*/
+	static isTablet(minWidth = 768, maxWidth = 1200, dpi = 160) {
+		if (typeof window === "undefined" || !TypeUtil.isPositiveInteger(minWidth) || !TypeUtil.isPositiveInteger(maxWidth)) return false;
+		const width = window.innerWidth;
+		const isWithinWidthRange = width >= minWidth && width <= maxWidth;
+		try {
+			const widthPx = window.screen.width;
+			const heightPx = window.screen.height;
+			const DPI = dpi * (window.devicePixelRatio || 1);
+			const widthInch = widthPx / DPI;
+			const heightInch = heightPx / DPI;
+			const screenInches = Math.sqrt(widthInch ** 2 + heightInch ** 2);
+			return isWithinWidthRange || screenInches >= 7;
+		} catch {
+			return isWithinWidthRange;
+		}
+	}
+};
+_defineProperty(EnvUtil, "_isBrowser", typeof window !== "undefined" && TypeUtil.isFunction(window?.document?.createElement));
+_defineProperty(EnvUtil, "_isWebWorker", typeof window === "undefined" && typeof self !== "undefined" && "importScripts" in self);
+_defineProperty(EnvUtil, "_isReactNative", typeof navigator !== "undefined" && navigator.product === "ReactNative");
+//#endregion
+//#region src/function/functionUtil.ts
+/**
+* 函数工具类
+*/
+var FunctionUtil = class {
+	/**
+	*将 Promise 转换为 `[err, result]` 格式，方便 async/await 错误处理
+	*
+	* @param promise 待处理的 Promise
+	* @param errorExt 附加到 error 对象的扩展信息（注意：如果原 error 是 Error 实例，扩展属性可能会覆盖或无法正确合并非枚举属性）
+	* @returns `[err, null]` 或 `[null, data]`
+	* @example
+	* ```ts
+	* const [err, data] = await FunctionUtil.to(someAsyncFunc());
+	* ```
+	*/
+	static to(promise, errorExt) {
+		return promise.then((data) => [null, data]).catch((err) => {
+			if (errorExt) {
+				const parsedError = {
+					name: "",
+					message: "",
+					stack: ""
+				};
+				if (err instanceof Error) {
+					parsedError.message = err.message;
+					parsedError.name = err.name;
+					parsedError.stack = err.stack;
+					Object.getOwnPropertyNames(err).forEach((key) => {
+						if (!(key in parsedError)) parsedError[key] = err[key];
+					});
+				} else Object.assign(parsedError, err);
+				Object.assign(parsedError, errorExt);
+				return [parsedError, void 0];
+			}
+			return [err ? err : /* @__PURE__ */ new Error("defaultError"), void 0];
+		});
+	}
+	/**
+	* 将 Arguments 对象转换为数组
+	*
+	* ⚠️ 注意：TypeScript 官方推荐使用 rest parameters (...args) 替代 arguments
+	* 本函数仅用于处理遗留代码或特殊场景（如装饰器中需保留 this 绑定）
+	*
+	* @param args Arguments 对象（必须为类数组对象）
+	* @param start 起始索引（可选，默认为 0）
+	* @returns 转换后的数组，元素类型为 T
+	*
+	* @throws TypeError 如果 args 为 null 或 undefined
+	*
+	* @example
+	* // 遗留代码场景
+	* function legacyFn(a: number, b: string) {
+	*   const argsArray = FunctionUtil.toArgs(arguments);
+	*   // argsArray: unknown[]
+	* }
+	*
+	* // 现代替代方案（推荐）
+	* function modernFn(a: number, b: string, ...rest: unknown[]) {
+	*   // rest 已经是数组，无需 toArgs
+	* }
+	*
+	* // 参数截取
+	* function skipFirst(...args: unknown[]) {
+	*   const rest = FunctionUtil.toArgs(arguments, 1);
+	*   // rest: unknown[]，跳过第一个参数
+	* }
+	*/
+	static toArgs(args, start) {
+		if (args === null) throw new TypeError(`function [toArgs] Expected parameter [args] to be a arguments object, got ${typeof args}`);
+		const array = Array.from(args);
+		return TypeUtil.isNumber(start) ? array.slice(start) : array;
+	}
+	/**
+	* 将同步或异步函数统一包装为 Promise
+	* - 自动捕获同步异常
+	*
+	* @param fn 返回值可为同步值或 Promise 的函数
+	* @returns 标准化的 Promise
+	*
+	* @example
+	* // 同步函数
+	* FunctionUtil.toPromise(() => 42).then(v => console.log(v)); // 42
+	*
+	* // 异步函数
+	* FunctionUtil.toPromise(async () => await fetchData()).then(data => ...);
+	*
+	* // 异常处理
+	* FunctionUtil.toPromise(() => { throw new Error('fail'); }).catch(err => console.error(err)); // 捕获同步异常
+	*/
+	static toPromise(fn) {
+		try {
+			return Promise.resolve(fn());
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+};
+//#endregion
+//#region src/mime/mimeUtil.ts
+/**
+* MIME 工具类
+*/
+var MimeUtil = class {};
+_defineProperty(MimeUtil, "MIME", {
+	/** 普通文本文件 */
+	TEXT: "text/plain",
+	/** 超文本标记语言文档 */
+	HTML: "text/html",
+	/** 层叠样式表文件 */
+	CSS: "text/css",
+	/** 逗号分隔值文件（表格数据） */
+	CSV: "text/csv",
+	/** 制表符分隔值文件 */
+	TSV: "text/tab-separated-values",
+	/** XML 文档 */
+	XML: "text/xml",
+	/** XHTML 文档（XML 严格格式的 HTML） */
+	XHTML: "application/xhtml+xml",
+	/** JavaScript 脚本文件（标准推荐） */
+	JS: "text/javascript",
+	/** Markdown 格式文档 */
+	MARKDOWN: "text/markdown",
+	/** 富文本格式文档（.rtf） */
+	RTF: "application/rtf",
+	/** iCalendar 日历格式（.ics） */
+	CALENDAR: "text/calendar",
+	/** JPEG 图像（.jpg/.jpeg） */
+	JPEG: "image/jpeg",
+	/** PNG 图像（无损压缩，支持透明） */
+	PNG: "image/png",
+	/** GIF 图像（支持动画） */
+	GIF: "image/gif",
+	/** Windows 位图（.bmp） */
+	BMP: "image/bmp",
+	/** SVG 向量图形（.svg） */
+	SVG: "image/svg+xml",
+	/** APNG 动态图像（.apng） */
+	APNG: "image/apng",
+	/** AVIF 图像（高效压缩） */
+	AVIF: "image/avif",
+	/** 图标文件格式（.ico） */
+	ICO: "image/vnd.microsoft.icon",
+	/** WebP 图像（高效压缩） */
+	WEBP: "image/webp",
+	/** MP3 音频（.mp3） */
+	MP3: "audio/mpeg",
+	/** AAC 音频（.aac） */
+	AAC: "audio/aac",
+	/** MIDI 音乐文件（.mid/.midi） */
+	MIDI: "audio/midi",
+	/** OGG 音频（.oga） */
+	OGG_AUDIO: "audio/ogg",
+	/** Opus 音频（.opus） */
+	OPUS: "audio/opus",
+	/** WAV 音频（.wav） */
+	WAV: "audio/wav",
+	/** RealAudio 音频（.ra/.ram） */
+	REAL_AUDIO: "audio/x-pn-realaudio",
+	/** MP4 视频（.mp4） */
+	MP4: "video/mp4",
+	/** MPEG 视频（.mpeg/.mpg） */
+	MPEG: "video/mpeg",
+	/** OGG 视频（.ogv） */
+	OGG_VIDEO: "video/ogg",
+	/** AVI 视频（.avi） */
+	AVI: "video/x-msvideo",
+	/** 3GPP 视频（.3gp） */
+	THREE_GPP: "video/3gpp",
+	/** 3GPP2 视频（.3g2） */
+	THREE_GPP2: "video/3gpp2",
+	/** WebM 视频（.webm） */
+	WEBM: "video/webm",
+	/** PDF 文档 */
+	PDF: "application/pdf",
+	/** Word 97-2003 文档（.doc） */
+	DOC: "application/msword",
+	/** Word 2007+ 文档（.docx） */
+	DOCX: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	/** Excel 2007+ 工作簿（.xlsx） */
+	XLSX: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	/** 启用宏的Excel工作簿（.xlsm） */
+	XLSM: "application/vnd.ms-excel.sheet.macroEnabled.12",
+	/** Excel模板文件（.xltx） */
+	XLTX: "application/vnd.openxmlformats-officedocument.spreadsheetml.template",
+	/** PowerPoint 2007+ 演示文稿（.pptx） */
+	PPTX: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+	/** PowerPoint 97-2003 演示文稿（.ppt） */
+	PPT: "application/vnd.ms-powerpoint",
+	/** OpenDocument 文本文档（.odt） */
+	ODT: "application/vnd.oasis.opendocument.text",
+	/** OpenDocument 表格文档（.ods） */
+	ODS: "application/vnd.oasis.opendocument.spreadsheet",
+	/** OpenDocument 演示文稿（.odp） */
+	ODP: "application/vnd.oasis.opendocument.presentation",
+	/** EPUB 电子书（.epub） */
+	EPUB: "application/epub+zip",
+	/** Kindle 电子书（.azw） */
+	AZW: "application/vnd.amazon.ebook",
+	/** ZIP 压缩文件（.zip） */
+	ZIP: "application/zip",
+	/** GZIP 压缩文件（.gz） */
+	GZIP: "application/gzip",
+	/** GZIP 压缩文件（旧格式） */
+	X_GZIP: "application/x-gzip",
+	/** TAR 归档文件（.tar） */
+	TAR: "application/x-tar",
+	/** BZip 归档（.bz） */
+	BZIP: "application/x-bzip",
+	/** BZip2 归档（.bz2） */
+	BZIP2: "application/x-bzip2",
+	/** 7-Zip 压缩文件（.7z） */
+	SEVEN_Z: "application/x-7z-compressed",
+	/** 通用二进制数据（默认类型） */
+	OCTET_STREAM: "application/octet-stream",
+	/** JSON 数据格式（.json） */
+	JSON: "application/json",
+	/** JSON-LD 格式（.jsonld） */
+	LD_JSON: "application/ld+json",
+	/** Java 归档文件（.jar） */
+	JAR: "application/java-archive",
+	/** MS 嵌入式 OpenType 字体（.eot） */
+	EOT: "application/vnd.ms-fontobject",
+	/** OpenType 字体（.otf） */
+	OTF: "font/otf",
+	/** Excel 97-2003 工作簿（.xls） */
+	XLS: "application/vnd.ms-excel",
+	/** Microsoft XPS 文档（.xps） */
+	XPS: "application/vnd.ms-xpsdocument",
+	/** Word 启用宏文档（.docm） */
+	DOCM: "application/vnd.ms-word.document.macroEnabled.12"
+});
+//#endregion
+//#region src/number/numberUtil.ts
+/**
+* 数字工具类
+*/
+var NumberUtil = class {
+	/**
+	* 数字区间检查函数
+	*
+	* @param input 待检查数字
+	* @param interval 由两个数字组成的元组 [left, right]
+	* @param includeLeft 是否包含左边界（默认 true）
+	* @param includeRight 是否包含右边界（默认 false）
+	* @returns 是否在区间内
+	* @example
+	* ```ts
+	* NumberUtil.within(5, [1, 10]); // true
+	* NumberUtil.within(1, [1, 10], false); // false
+	* ```
+	*/
+	static within(input, interval, includeLeft = true, includeRight = false) {
+		if (!TypeUtil.isNumber(input) || TypeUtil.isInfinity(input)) throw new Error("function [within] Expected parameter [input] to be a finite number.");
+		if (!TypeUtil.isArray(interval) || interval.length !== 2) throw new Error("function [within] Expected parameter [interval] to be a tuple with 2 numbers.");
+		const [left, right] = interval;
+		if (left > right) throw new Error(`Invalid interval: left (${left}) must be <= right (${right}).`);
+		if (includeLeft && includeRight) return input >= left && input <= right;
+		else if (includeLeft) return input >= left && input < right;
+		else if (includeRight) return input > left && input <= right;
+		else return input > left && input < right;
+	}
+};
+//#endregion
+//#region src/object/objectUtil.ts
+/**
+* 对象工具类
+*/
+var ObjectUtil = class {
+	static keys(value) {
+		return Object.keys(value);
+	}
+	static values(value) {
+		return Object.values(value);
+	}
+	static entries(value) {
+		return Object.entries(value);
+	}
+	/**
+	* 映射对象条目
+	* - 将对象的键值对映射为新的键值对
+	*
+	* @param plainObject 对象
+	* @param toEntry 映射函数
+	* @returns 映射后的新对象
+	* @example
+	* ```ts
+	* const obj = { a: 1, b: 2 };
+	* ObjectUtil.entriesMap(obj, (k, v) => [k, v * 2]); // { a: 2, b: 4 }
+	* ```
+	*/
+	static entriesMap(plainObject, toEntry) {
+		const defaultResult = {};
+		if (!TypeUtil.isObject(plainObject)) return defaultResult;
+		return this.entries(plainObject).reduce((acc, [key, value]) => {
+			const [newKey, newValue] = toEntry(key, value);
+			acc[newKey] = newValue;
+			return acc;
+		}, defaultResult);
+	}
+	static pick(obj, keys) {
+		const result = {};
+		if (!TypeUtil.isObject(obj)) return result;
+		if (!TypeUtil.isArray(keys)) return obj;
+		return keys.reduce((acc, key) => {
+			if (key in obj) acc[key] = obj[key];
+			return acc;
+		}, result);
+	}
+	static omit(obj, keys) {
+		const result = {};
+		if (!TypeUtil.isObject(obj)) return result;
+		if (!TypeUtil.isArray(keys)) return obj;
+		const keysToOmit = new Set(keys);
+		return Object.keys(obj).reduce((acc, key) => {
+			if (!keysToOmit.has(key)) acc[key] = obj[key];
+			return acc;
+		}, result);
+	}
+	static invert(obj) {
+		const result = {};
+		if (!TypeUtil.isObject(obj)) return result;
+		for (const [k, v] of this.entries(obj)) if (TypeUtil.isString(v) || TypeUtil.isNumber(v) || TypeUtil.isSymbol(v)) result[v] = k;
+		return result;
+	}
+	static crush(obj) {
+		if (!obj) return {};
+		function crushReducer(crushed, value, path) {
+			if (TypeUtil.isObject(value) || TypeUtil.isArray(value)) for (const [prop, propValue] of Object.entries(value)) crushReducer(crushed, propValue, path ? `${path}.${prop}` : prop);
+			else crushed[path] = value;
+			return crushed;
+		}
+		return crushReducer({}, obj, "");
+	}
+	static enumKeys(enumeration) {
+		const [isEnum, isBidirectionalEnum] = TypeUtil.isEnumeration(enumeration);
+		if (!isEnum) throw Error("function [enumKeys] expected parameter to be a enum, and requires at least one member");
+		const keys = this.keys(enumeration);
+		if (isBidirectionalEnum) return keys.splice(keys.length / 2, keys.length / 2);
+		return keys;
+	}
+	static enumValues(enumeration) {
+		const [isEnum, isBidirectionalEnum] = TypeUtil.isEnumeration(enumeration);
+		if (!isEnum) throw Error("function [enumValues] expected parameter to be a enum, and requires at least one member");
+		const values = this.values(enumeration);
+		if (isBidirectionalEnum) return values.splice(values.length / 2, values.length / 2);
+		return values;
+	}
+	static enumEntries(enumeration) {
+		const [isEnum, isBidirectionalEnum] = TypeUtil.isEnumeration(enumeration);
+		if (!isEnum) throw Error("function [enumEntries] expected parameter to be a enum, and requires at least one member");
+		const entries = this.entries(enumeration);
+		if (isBidirectionalEnum) return entries.splice(entries.length / 2, entries.length / 2);
+		return entries;
+	}
+};
+//#endregion
+//#region src/theme/themeUtil.ts
+/**
+* 主题工具类
+*/
+var ThemeUtil = class {};
+_defineProperty(ThemeUtil, "THEME", {
+	LIGHT: "light",
+	DARK: "dark"
+});
+_defineProperty(ThemeUtil, "THEME_MODE", {
+	LIGHT: "light",
+	DARK: "dark",
+	SYSTEM: "system"
+});
+//#endregion
+//#region src/tree/utils.ts
+function getFinalChildrenKey(tree, meta, options) {
+	if (TypeUtil.isFunction(options.getChildrenKey)) {
+		const dynamicChildrenKey = options.getChildrenKey(tree, meta);
+		if (dynamicChildrenKey && dynamicChildrenKey !== null) return dynamicChildrenKey;
+	}
+	return options.childrenKey;
+}
+//#endregion
+//#region src/tree/filter.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 (TypeUtil.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 (TypeUtil.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 (TypeUtil.isArray(children)) {
+			const nextLevelOptions = {
+				...queueOptions,
+				parents: [...queueOptions.parents, queueRow],
+				depth: queueOptions.depth + 1
+			};
+			const subQueueItems = children.map((queueRow) => ({
+				queueRow,
+				queueOptions: nextLevelOptions
+			}));
+			queue.push(...subQueueItems);
+		}
+		const parent = ArrayUtil.last(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 treeFilterStrategies = {
+	pre: preImpl$3,
+	post: postImpl$3,
+	breadth: breadthImpl$3
+};
+//#endregion
+//#region src/tree/find.ts
+function preImpl$2(row, callback, options) {
+	if (callback(row, options)) return row;
+	const children = row[getFinalChildrenKey(row, options, options)];
+	if (TypeUtil.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 (TypeUtil.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 (TypeUtil.isArray(children)) {
+			const nextLevelOptions = {
+				...queueOptions,
+				parents: [...queueOptions.parents, queueRow],
+				depth: queueOptions.depth + 1
+			};
+			const subQueueItems = children.map((queueRow) => ({
+				queueRow,
+				queueOptions: nextLevelOptions
+			}));
+			queue.push(...subQueueItems);
+		}
+		if (callback(queueRow, queueOptions)) return queueRow;
+		return runQueue();
+	};
+	return runQueue();
+}
+const treeFindStrategies = {
+	pre: preImpl$2,
+	post: postImpl$2,
+	breadth: breadthImpl$2
+};
+//#endregion
+//#region src/tree/forEach.ts
+function preImpl$1(row, callback, options) {
+	callback(row, options);
+	const children = row[getFinalChildrenKey(row, options, options)];
+	if (TypeUtil.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 (TypeUtil.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 (TypeUtil.isArray(children)) {
+			const nextLevelOptions = {
+				...queueOptions,
+				parents: [...queueOptions.parents, queueRow],
+				depth: queueOptions.depth + 1
+			};
+			const subQueueItems = children.map((queueRow) => ({
+				queueRow,
+				queueOptions: nextLevelOptions
+			}));
+			queue.push(...subQueueItems);
+		}
+		callback(queueRow, queueOptions);
+		runQueue();
+	};
+	runQueue();
+}
+const treeForEachStrategies = {
+	pre: preImpl$1,
+	post: postImpl$1,
+	breadth: breadthImpl$1
+};
+//#endregion
+//#region src/tree/map.ts
+function preImpl(row, callback, options) {
+	const finalChildrenKey = getFinalChildrenKey(row, options, options);
+	const result = callback(row, options);
+	const children = row[finalChildrenKey];
+	let newChildren;
+	if (TypeUtil.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 (TypeUtil.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 (TypeUtil.isArray(children)) {
+			const nextLevelOptions = {
+				...queueOptions,
+				parents: [...queueOptions.parents, queueRow],
+				depth: queueOptions.depth + 1
+			};
+			const subQueueItems = children.map((queueRow) => ({
+				queueRow,
+				queueOptions: nextLevelOptions
+			}));
+			queue.push(...subQueueItems);
+		}
+		const res = callback(queueRow, queueOptions);
+		cache.set(queueRow, res);
+		childrenKeyCache.set(queueRow, finalChildrenKey);
+		const parent = ArrayUtil.last(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();
+}
+const treeMapStrategies = {
+	pre: preImpl,
+	post: postImpl,
+	breadth: breadthImpl
+};
+//#endregion
+//#region src/tree/treeUtil.ts
+/**
+* 树结构工具类
+*/
+var TreeUtil = class {
+	/**
+	* 行结构 转 树结构
+	* - 将平铺的数组转换为树形结构
+	*
+	* @param rows 行数据数组
+	* @param options 配置项
+	* @returns 树结构数组
+	* @example
+	* ```ts
+	* const rows = [
+	*   { id: 1, parentId: null },
+	*   { id: 2, parentId: 1 },
+	* ];
+	* TreeUtil.rowsToTree(rows); // [{ id: 1, parentId: null, children: [{ id: 2, parentId: 1 }] }]
+	* ```
+	*/
+	static 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 (TypeUtil.isNull(siblings) || TypeUtil.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;
+	}
+	/**
+	* 树结构 转 行结构
+	* - 将树形结构扁平化为数组
+	*
+	* @param tree 树结构数据 (单个节点或节点数组)
+	* @param options 配置项
+	* @returns 扁平化后的数组
+	* @example
+	* ```ts
+	* const tree = [{ id: 1, children: [{ id: 2 }] }];
+	* TreeUtil.treeToRows(tree); // [{ id: 1, children: undefined }, { id: 2, children: undefined }]
+	* ```
+	*/
+	static treeToRows(tree, options = {}) {
+		const { childrenKey = "children" } = options;
+		const result = [];
+		if (!tree) return result;
+		this.forEach(tree, (t) => result.push({
+			...t,
+			[childrenKey]: void 0
+		}), options);
+		return result;
+	}
+	/**
+	* 遍历树节点
+	*
+	* @param tree 树结构数据
+	* @param callback 回调函数
+	* @param options 配置项
+	* @example
+	* ```ts
+	* const tree = [{ id: 1, children: [{ id: 2 }] }];
+	* const ids: number[] = [];
+	* TreeUtil.forEach(tree, (node) => ids.push(node.id)); // ids: [1, 2] (pre-order default)
+	* ```
+	*/
+	static forEach(tree, callback, options = {}) {
+		const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+		const traversalMethod = treeForEachStrategies[strategy];
+		const innerOptions = {
+			childrenKey,
+			depth: 0,
+			parents: [],
+			getChildrenKey
+		};
+		if (TypeUtil.isArray(tree)) for (const row of tree) traversalMethod(row, callback, innerOptions);
+		else traversalMethod(tree, callback, innerOptions);
+	}
+	/**
+	* 查找树节点
+	* - 返回第一个回调返回 true 的节点
+	*
+	* @param tree 树结构数据
+	* @param callback 回调函数
+	* @param options 配置项
+	* @returns 找到的节点，未找到则返回 undefined
+	* @example
+	* ```ts
+	* const tree = [{ id: 1, children: [{ id: 2 }] }];
+	* TreeUtil.find(tree, (node) => node.id === 2); // { id: 2, ... }
+	* ```
+	*/
+	static find(tree, callback, options = {}) {
+		const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+		const traversalMethod = treeFindStrategies[strategy];
+		const innerOptions = {
+			childrenKey,
+			depth: 0,
+			parents: [],
+			getChildrenKey
+		};
+		if (TypeUtil.isArray(tree)) {
+			for (const row of tree) {
+				const result = traversalMethod(row, callback, innerOptions);
+				if (result) return result;
+			}
+			return;
+		}
+		return traversalMethod(tree, callback, innerOptions);
+	}
+	static filter(tree, callback, options = {}) {
+		const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+		const traversalMethod = treeFilterStrategies[strategy];
+		const innerOptions = {
+			childrenKey,
+			depth: 0,
+			parents: [],
+			getChildrenKey
+		};
+		return TypeUtil.isArray(tree) ? tree.map((row) => traversalMethod(row, callback, innerOptions)).filter((t) => !!t) : traversalMethod(tree, callback, innerOptions) || [];
+	}
+	static map(tree, callback, options = {}) {
+		const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+		const traversalMethod = treeMapStrategies[strategy];
+		const innerOptions = {
+			childrenKey,
+			depth: 0,
+			parents: [],
+			getChildrenKey
+		};
+		return TypeUtil.isArray(tree) ? tree.map((row) => traversalMethod(row, callback, innerOptions)) : traversalMethod(tree, callback, innerOptions);
+	}
+};
+//#endregion
+//#region src/validate/validateUtil.ts
+/**
+* 验证工具类
+*/
+var ValidateUtil = class {
+	/**
+	* 验证是否为手机号码
+	*/
+	static isPhone(input) {
+		return this._phone.test(input.toString());
+	}
+	/**
+	* 验证是否为固定电话
+	*/
+	static isTelephone(input) {
+		return this._telephone.test(input.toString());
+	}
+	/**
+	* 验证是否为移动设备识别码
+	*/
+	static isIMEI(input) {
+		return this._IMEI.test(input.toString());
+	}
+	/**
+	* 验证是否为电子邮箱
+	*/
+	static isEmail(input) {
+		return this._email.test(input.toString());
+	}
+	/**
+	* 验证是否为 http(s) 链接
+	*/
+	static isHttpLink(input) {
+		return this._link.test(input.toString());
+	}
+	/**
+	* 验证是否为端口号链接
+	*/
+	static isPortLink(input) {
+		return this._portLink.test(input.toString());
+	}
+	/**
+	* 验证是否为迅雷链接
+	*/
+	static isThunderLink(input) {
+		return this._thunderLink.test(input.toString());
+	}
+	/**
+	* 验证是否为统一社会信用代码
+	*/
+	static isUSCC(input) {
+		return this._uscc.test(input.toString());
+	}
+	/**
+	* 验证是否为统一社会信用代码 - 15位/18位/20位数字/字母
+	*/
+	static isUSCCS(input) {
+		return this._usccs.test(input.toString());
+	}
+	/**
+	* 验证是否为 Windows 系统文件夹路径
+	*/
+	static isDirPathWindows(input) {
+		return this._dirPathWindows.test(input.toString());
+	}
+	/**
+	* 验证是否为 Windows 系统文件路径
+	*/
+	static isFilePathWindows(input) {
+		return this._filePathWindows.test(input.toString());
+	}
+	/**
+	* 验证是否为 Linux 系统文件夹路径
+	*/
+	static isDirPathLinux(input) {
+		return this._dirPathLinux.test(input.toString());
+	}
+	/**
+	* 验证是否为 Linux 系统文件路径
+	*/
+	static isFilePathLinux(input) {
+		return this._filePathLinux.test(input.toString());
+	}
+	/**
+	* 验证是否为新能源车牌号
+	*/
+	static isEVCarNumber(input) {
+		return this._EVCarNumber.test(input.toString());
+	}
+	/**
+	* 验证是否为燃油车车牌号
+	*/
+	static isGVCarNumber(input) {
+		return this._GVCarNumber.test(input.toString());
+	}
+	/**
+	* 验证是否为中文姓名
+	*/
+	static isChineseName(input) {
+		return this._chineseName.test(input.toString());
+	}
+	/**
+	* 验证是否为中国身份证号
+	*/
+	static isChineseID(input) {
+		return this._chineseId.test(input.toString());
+	}
+	/**
+	* 验证是否为中国省份
+	*/
+	static isChineseProvince(input) {
+		return this._chineseProvince.test(input.toString());
+	}
+	/**
+	* 验证是否为中华民族
+	*/
+	static isChineseNation(input) {
+		return this._chineseNation.test(input.toString());
+	}
+	/**
+	* 验证是否只包含字母
+	*/
+	static isLetter(input) {
+		return this._letter.test(input.toString());
+	}
+	/**
+	* 验证是否只包含小写字母
+	*/
+	static isLetterLowercase(input) {
+		return this._letterLowercase.test(input.toString());
+	}
+	/**
+	* 验证是否只包含大写字母
+	*/
+	static isLetterUppercase(input) {
+		return this._letterUppercase.test(input.toString());
+	}
+	/**
+	* 验证是否不包含字母
+	*/
+	static isLetterOmit(input) {
+		return this._letterOmit.test(input.toString());
+	}
+	/**
+	* 验证是否为数字和字母组合
+	*/
+	static isLetterAndNumber(input) {
+		return this._LetterAndNumber.test(input.toString());
+	}
+	/**
+	* 验证是否为有符号浮点数
+	*/
+	static isSignedFloat(input) {
+		return this._signedFloat.test(input.toString());
+	}
+	/**
+	* 验证是否为无符号浮点数
+	*/
+	static isUnsignedFloat(input) {
+		return this._unsignedFloat.test(input.toString());
+	}
+	/**
+	* 验证是否为有符号整数
+	*/
+	static isSignedInteger(input) {
+		return this._signedInteger.test(input.toString());
+	}
+	/**
+	* 验证是否为无符号整数
+	*/
+	static isUnsignedInteger(input) {
+		return this._unsignedInteger.test(input.toString());
+	}
+	/**
+	* 验证是否包含空格
+	*/
+	static isSpaceInclude(input) {
+		return this._spaceInclude.test(input.toString());
+	}
+	/**
+	* 验证是否以空格开头
+	*/
+	static isSpaceStart(input) {
+		return this._spaceStart.test(input.toString());
+	}
+	/**
+	* 验证是否以空格结尾
+	*/
+	static isSpaceEnd(input) {
+		return this._spaceEnd.test(input.toString());
+	}
+	/**
+	* 验证是否以空格开头或结尾
+	*/
+	static isSpaceStartOrEnd(input) {
+		return this.isSpaceStart(input) || this.isSpaceEnd(input);
+	}
+};
+_defineProperty(ValidateUtil, "_phone", /^1(3\d|4[5-9]|5[0-35-9]|6[567]|7[0-8]|8\d|9[0-35-9])\d{8}$/);
+_defineProperty(ValidateUtil, "_telephone", /^(((0\d{2,3})-)?((\d{7,8})|(400\d{7})|(800\d{7}))(-(\d{1,4}))?)$/);
+_defineProperty(ValidateUtil, "_IMEI", /^\d{15,17}$/);
+_defineProperty(ValidateUtil, "_email", /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\])|(([a-z\-0-9]+\.)+[a-z]{2,}))$/i);
+_defineProperty(ValidateUtil, "_link", /^(https?:\/\/)?(([\w-]+(\.[\w-]+)*\.[a-z]{2,6})|((\d{1,3}\.){3}\d{1,3}))(:\d+)?(\/\S*)?$/i);
+_defineProperty(ValidateUtil, "_portLink", /^(https?:\/\/)?[\w-]+(\.[\w-]+)+:\d{1,5}\/?$/i);
+_defineProperty(ValidateUtil, "_thunderLink", /^thunderx?:\/\/[a-zA-Z\d]+=$/i);
+_defineProperty(ValidateUtil, "_uscc", /^[0-9A-HJ-NPQRTUWXY]{2}\d{6}[0-9A-HJ-NPQRTUWXY]{10}$/);
+_defineProperty(ValidateUtil, "_usccs", /^[0-9A-HJ-NPQRTUWXY]{2}\d{6}[0-9A-HJ-NPQRTUWXY]{10}$/);
+_defineProperty(ValidateUtil, "_dirPathWindows", /^[a-z]:\\(?:\w+\\?)*$/i);
+_defineProperty(ValidateUtil, "_filePathWindows", /^[a-z]:\\(?:\w+\\)*\w+\.\w+$/i);
+_defineProperty(ValidateUtil, "_dirPathLinux", /^\/(?:[^\\/\s]+\/)*$/);
+_defineProperty(ValidateUtil, "_filePathLinux", /^(\/$|\/(?:[^\\/\s]+\/)*[^\\/\s]+$)/);
+_defineProperty(ValidateUtil, "_EVCarNumber", /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-HJ-NP-Z](([DF]((?![IO])[a-zA-Z0-9](?![IO]))\d{4})|(\d{5}[DF]))$/);
+_defineProperty(ValidateUtil, "_GVCarNumber", /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-HJ-NP-Z][A-HJ-NP-Z0-9]{4,5}[A-HJ-NP-Z0-9挂学警港澳]$/);
+_defineProperty(ValidateUtil, "_chineseName", /^[一-龢][一·-龢]*$/);
+_defineProperty(ValidateUtil, "_chineseId", /^\d{6}((((((19|20)\d{2})(0[13-9]|1[012])(0[1-9]|[12]\d|30))|(((19|20)\d{2})(0[13578]|1[02])31)|((19|20)\d{2})02(0[1-9]|1\d|2[0-8])|((((19|20)([13579][26]|[2468][048]|0[48]))|(2000))0229))\d{3})|((((\d{2})(0[13-9]|1[012])(0[1-9]|[12]\d|30))|((\d{2})(0[13578]|1[02])31)|((\d{2})02(0[1-9]|1\d|2[0-8]))|(([13579][26]|[2468][048]|0[048])0229))\d{2}))([\dX])$/i);
+_defineProperty(ValidateUtil, "_chineseProvince", /^安徽|澳门|北京|重庆|福建|甘肃|广东|广西|贵州|海南|河北|河南|黑龙江|湖北|湖南|吉林|江苏|江西|辽宁|内蒙古|宁夏|青海|山东|山西|陕西|上海|四川|台湾|天津|西藏|香港|新疆|云南|浙江$/);
+_defineProperty(ValidateUtil, "_chineseNation", /^汉族|蒙古族|回族|藏族|维吾尔族|苗族|彝族|壮族|布依族|朝鲜族|满族|侗族|瑶族|白族|土家族|哈尼族|哈萨克族|傣族|黎族|傈僳族|佤族|畲族|高山族|拉祜族|水族|东乡族|纳西族|景颇族|柯尔克孜族|土族|达斡尔族|仫佬族|羌族|布朗族|撒拉族|毛南族|仡佬族|锡伯族|阿昌族|普米族|塔吉克族|怒族|乌孜别克族|俄罗斯族|鄂温克族|德昂族|保安族|裕固族|京族|塔塔尔族|独龙族|鄂伦春族|赫哲族|门巴族|珞巴族|基诺族|其它未识别民族|外国人入中国籍$/);
+_defineProperty(ValidateUtil, "_letter", /^[a-z]+$/i);
+_defineProperty(ValidateUtil, "_letterLowercase", /^[a-z]+$/);
+_defineProperty(ValidateUtil, "_letterUppercase", /^[A-Z]+$/);
+_defineProperty(ValidateUtil, "_letterOmit", /^[^A-Z]*$/i);
+_defineProperty(ValidateUtil, "_LetterAndNumber", /^[A-Z0-9]+$/i);
+_defineProperty(ValidateUtil, "_signedFloat", /^[+-]?(\d+(\.\d+)?|\.\d+)$/);
+_defineProperty(ValidateUtil, "_unsignedFloat", /^\+?(\d+(\.\d+)?|\.\d+)$/);
+_defineProperty(ValidateUtil, "_signedInteger", /^[+-]?\d+$/);
+_defineProperty(ValidateUtil, "_unsignedInteger", /^\+?\d+$/);
+_defineProperty(ValidateUtil, "_spaceInclude", /\s/);
+_defineProperty(ValidateUtil, "_spaceStart", /^\s/);
+_defineProperty(ValidateUtil, "_spaceEnd", /\s$/);
+//#endregion
+export { ArrayUtil, DateTimeUtil, EnvUtil, FunctionUtil, MimeUtil, NumberUtil, ObjectUtil, StringUtil, ThemeUtil, TreeUtil, TypeUtil, ValidateUtil };