@pawover/kit 0.4.1 → 0.5.1

package/packages/utils/dist/index.cjs

@@ -0,0 +1,2300 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_math = require("./math-BznvO4qI.cjs");
+//#region src/array/arrayUtil.ts
+/**
+* 数组工具类
+*/
+var ArrayUtil = class {
+	static cast(candidate, checkNullish = true) {
+		if (checkNullish && require_math.TypeUtil.isNullish(candidate)) return [];
+		return require_math.TypeUtil.isArray(candidate) ? [...candidate] : [candidate];
+	}
+	static first(initialList, fallback) {
+		if (!require_math.TypeUtil.isArray(initialList) || initialList.length === 0) return fallback;
+		return initialList[0];
+	}
+	static last(initialList, fallback) {
+		if (!require_math.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 (!require_math.TypeUtil.isArray(initialList) || initialList.length === 0 || !require_math.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 (!require_math.TypeUtil.isArray(initialList) || !require_math.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
+	* // 重载 1: 按元素本身比较（自动去重）
+	* ArrayUtil.difference([1, 2, 3], [2, 3, 4]); // [1]
+	* ArrayUtil.difference([1, 1, 2], [2]); // [1]，重复项会被去重
+	*
+	* // 重载 2: 按 match 结果比较（不去重，保留 initialList 原始重复项与顺序）
+	* ArrayUtil.difference([{ id: 1 }, { id: 2 }], [{ id: 2 }], (x) => x.id); // [{ id: 1 }]
+	* ArrayUtil.difference([{ id: 1 }, { id: 1 }], [{ id: 2 }], (x) => x.id); // [{ id: 1 }, { id: 1 }]
+	* ```
+	*/
+	static difference(initialList, diffList, match) {
+		if (!require_math.TypeUtil.isArray(initialList) && !require_math.TypeUtil.isArray(diffList)) return [];
+		if (!require_math.TypeUtil.isArray(initialList) || !initialList.length) return [];
+		if (!require_math.TypeUtil.isArray(diffList) || !diffList.length) return [...initialList];
+		if (!require_math.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 (!require_math.TypeUtil.isArray(initialList) || !require_math.TypeUtil.isArray(diffList)) return [];
+		if (!initialList.length || !diffList.length) return [];
+		if (!require_math.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 (!require_math.TypeUtil.isArray(initialList)) return [];
+		if (!require_math.TypeUtil.isArray(mergeList)) return [...initialList];
+		if (!require_math.TypeUtil.isFunction(match)) return Array.from(/* @__PURE__ */ 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 (!require_math.TypeUtil.isArray(initialList)) return [];
+		if (!require_math.TypeUtil.isFunction(filter)) return [...initialList];
+		const hasMapper = require_math.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 (!require_math.TypeUtil.isArray(initialList) || !initialList.length) return [];
+		if (!require_math.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`
+	* - ⚠️ `position` 为负数或非正整数（如 `-1`、`2.5`）时不生效，静默回退为 `push`（追加到末尾）
+	*
+	* @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]
+	*
+	* // position 为负数 → 静默回退为 push
+	* ArrayUtil.replaceMove([1, 2, 3, 4], 5, (n) => n === 2, -1); // [1, 3, 4, 5]
+	* ```
+	*/
+	static replaceMove(initialList, newItem, match, position) {
+		if (!require_math.TypeUtil.isArray(initialList)) return [];
+		if (!initialList.length) return [newItem];
+		if (!require_math.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 || require_math.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 (!require_math.TypeUtil.isArray(initialList)) return [];
+		if (!require_math.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 (require_math.TypeUtil.isArray(initialList)) initialList.forEach((item, index) => {
+			forked[match(item, index) ? 0 : 1].push(item);
+		});
+		return forked;
+	}
+	/**
+	* 数组解压
+	* - `ArrayUtil.zip` 的反向操作
+	* - 默认按最长数组补齐 `undefined`
+	*
+	* @param arrayList 压缩后的数组
+	* @param options 配置项（`truncate` 为 `true` 时按最短数组截断）
+	* @returns 解压后的二维数组
+	* @example
+	* ```ts
+	* ArrayUtil.unzip([[1, "a"], [2, "b"]]); // [[1, 2], ["a", "b"]]
+	*
+	* // 补齐语义
+	* ArrayUtil.unzip([[1, 2], [3]]); // [[1, 3], [2, undefined]]
+	*
+	* // 截断语义
+	* ArrayUtil.unzip([[1, 2], [3]], { truncate: true }); // [[1, 3]]
+	* ```
+	*/
+	static unzip(arrayList, options) {
+		if (!require_math.TypeUtil.isArray(arrayList) || !arrayList.length) return [];
+		const length = options?.truncate ? arrayList.reduce((min, arr) => Math.min(min, arr.length), Infinity) : arrayList.reduce((max, arr) => Math.max(max, arr.length), 0);
+		const out = new Array(length);
+		let index = 0;
+		const get = (array) => array[index];
+		for (; index < out.length; index++) out[index] = Array.from(arrayList, get);
+		return out;
+	}
+	static zip(...arraysAndOptions) {
+		const last = arraysAndOptions[arraysAndOptions.length - 1];
+		const options = last && !require_math.TypeUtil.isArray(last) ? last : void 0;
+		const arrays = options ? arraysAndOptions.slice(0, -1) : arraysAndOptions;
+		return this.unzip(arrays, options);
+	}
+	static zipToObject(keys, values) {
+		const result = {};
+		if (!require_math.TypeUtil.isArray(keys) || !keys.length) return result;
+		const getValue = require_math.TypeUtil.isFunction(values) ? values : require_math.TypeUtil.isArray(values) ? (_k, i) => values[i] : (_k, _i) => values;
+		return keys.reduce((acc, key, idx) => {
+			Object.defineProperty(acc, key, {
+				value: getValue(key, idx),
+				enumerable: true,
+				writable: true,
+				configurable: true
+			});
+			return acc;
+		}, result);
+	}
+};
+//#endregion
+//#region src/currency/currencyUtil.ts
+/**
+* 货币工具类
+* - 基于 [`Intl.NumberFormat`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat) 进行本地化格式化
+* - 支持精确小数位处理（依赖 `mathjs`）
+*/
+var CurrencyUtil = class {
+	/**
+	* 货币代码到 Locale 的映射枚举
+	* - 键为 ISO 4217 货币代码，值为 BCP 47 语言标签
+	* - 用于 `Intl.NumberFormat` 的本地化数字格式化
+	* - 格式示例基于 `Intl.NumberFormat` 对 `1,234,567.89` 的输出
+	*
+	* @example
+	* ```ts
+	* import { CurrencyUtil } from "@pawover/kit/utils";
+	* // 获取人民币的格式化 locale
+	* const locale = CurrencyUtil.CURRENCY_ENUM.CNY; // "zh-CN"
+	*
+	* // 结合 Intl.NumberFormat 使用
+	* new Intl.NumberFormat(CurrencyUtil.CURRENCY_ENUM.USD, {
+	*   style: "currency",
+	*   currency: "USD",
+	* }).format(1234.56); // "$1,234.56"
+	* ```
+	*/
+	static CURRENCY_ENUM = {
+		/** 美元（美国及美元化国家，Locale: 美式英语） → 1,234,567.89 */
+		USD: "en-US",
+		/** 加拿大元（加拿大，Locale: 加拿大英语） → 1,234,567.89 */
+		CAD: "en-CA",
+		/** 墨西哥比索（墨西哥，Locale: 墨西哥西班牙语） → 1,234,567.89 */
+		MXN: "es-MX",
+		/** 巴西雷亚尔（巴西，Locale: 巴西葡萄牙语） → 1.234.567,89 */
+		BRL: "pt-BR",
+		/** 阿根廷比索（阿根廷，Locale: 阿根廷西班牙语） → 1.234.567,89 */
+		ARS: "es-AR",
+		/** 智利比索（智利，Locale: 智利西班牙语） → 1.234.567,89 */
+		CLP: "es-CL",
+		/** 秘鲁新索尔（秘鲁，Locale: 秘鲁西班牙语） → 1,234,567.89 */
+		PEN: "es-PE",
+		/** 哥伦比亚比索（哥伦比亚，Locale: 哥伦比亚西班牙语） → 1.234.567,89 */
+		COP: "es-CO",
+		/** 哥斯达黎加科朗（哥斯达黎加，Locale: 哥斯达黎加西班牙语） → 1 234 567,89（空格千分位） */
+		CRC: "es-CR",
+		/** 人民币（中国，Locale: 简体中文） → 1,234,567.89 */
+		CNY: "zh-CN",
+		/** 港元（中国香港，Locale: 繁体中文+香港） → 1,234,567.89 */
+		HKD: "zh-HK",
+		/** 澳门元（中国澳门，Locale: 繁体中文+澳门） → 1,234,567.89 */
+		MOP: "zh-MO",
+		/** 日元（日本，Locale: 日语） → 1,234,567.89 */
+		JPY: "ja-JP",
+		/** 韩元（韩国，Locale: 韩语） → 1,234,567.89 */
+		KRW: "ko-KR",
+		/** 新加坡元（新加坡，Locale: 英语+新加坡） → 1,234,567.89 */
+		SGD: "en-SG",
+		/** 泰铢（泰国，Locale: 泰语） → 1,234,567.89 */
+		THB: "th-TH",
+		/** 印度卢比（印度，Locale: 英语+印度） → 12,34,567.89（2,2,3 分组） */
+		INR: "en-IN",
+		/** 沙特里亚尔（沙特，Locale: 阿拉伯语+沙特） → ١٬٢٣٤٬٥٦٧٫٨٩（阿拉伯数字） */
+		SAR: "ar-SA",
+		/** 阿联酋迪拉姆（阿联酋，Locale: 阿拉伯语+阿联酋） → 1,234,567.89 */
+		AED: "ar-AE",
+		/** 印尼盾（印尼，Locale: 印尼语） → 1.234.567,89 */
+		IDR: "id-ID",
+		/** 马来西亚林吉特（马来西亚，Locale: 马来语） → 1,234,567.89 */
+		MYR: "ms-MY",
+		/** 越南盾（越南，Locale: 越南语） → 1.234.567,89 */
+		VND: "vi-VN",
+		/** 菲律宾比索（菲律宾，Locale: 英语+菲律宾） → 1,234,567.89 */
+		PHP: "en-PH",
+		/** 巴基斯坦卢比（巴基斯坦，Locale: 英语+巴基斯坦） → 1,234,567.89 */
+		PKR: "en-PK",
+		/** 新台币（中国台湾地区，Locale: 繁体中文+台湾） → 1,234,567.89 */
+		TWD: "zh-TW",
+		/** 欧元（德国，Locale: 德语+德国，代表欧元区） → 1.234.567,89 */
+		EUR: "de-DE",
+		/** 英镑（英国，Locale: 英式英语） → 1,234,567.89 */
+		GBP: "en-GB",
+		/** 瑞士法郎（瑞士，Locale: 德语+瑞士） → 1'234'567.89 */
+		CHF: "de-CH",
+		/** 瑞典克朗（瑞典，Locale: 瑞典语） → 1 234 567,89（空格千分位） */
+		SEK: "sv-SE",
+		/** 挪威克朗（挪威，Locale: 挪威语） → 1 234 567,89（空格千分位） */
+		NOK: "no-NO",
+		/** 丹麦克朗（丹麦，Locale: 丹麦语） → 1.234.567,89 */
+		DKK: "da-DK",
+		/** 波兰兹罗提（波兰，Locale: 波兰语） → 1 234 567,89（空格千分位） */
+		PLN: "pl-PL",
+		/** 捷克克朗（捷克，Locale: 捷克语） → 1 234 567,89（空格千分位） */
+		CZK: "cs-CZ",
+		/** 匈牙利福林（匈牙利，Locale: 匈牙利语） → 1 234 567,89（空格千分位） */
+		HUF: "hu-HU",
+		/** 俄罗斯卢布（俄罗斯，Locale: 俄语） → 1 234 567,89（空格千分位） */
+		RUB: "ru-RU",
+		/** 罗马尼亚列伊（罗马尼亚，Locale: 罗马尼亚语） → 1.234.567,89 */
+		RON: "ro-RO",
+		/** 乌克兰格里夫纳（乌克兰，Locale: 乌克兰语） → 1 234 567,89（空格千分位） */
+		UAH: "uk-UA",
+		/** 澳大利亚元（澳大利亚，Locale: 澳大利亚英语） → 1,234,567.89 */
+		AUD: "en-AU",
+		/** 新西兰元（新西兰，Locale: 新西兰英语） → 1,234,567.89 */
+		NZD: "en-NZ",
+		/** 南非兰特（南非，Locale: 英语+南非） → 1 234 567,89（空格千分位） */
+		ZAR: "en-ZA",
+		/** 埃及镑（埃及，Locale: 阿拉伯语+埃及） → ١٬٢٣٤٬٥٦٧٫٨٩（阿拉伯数字） */
+		EGP: "ar-EG",
+		/** 土耳其里拉（土耳其，Locale: 土耳其语） → 1.234.567,89 */
+		TRY: "tr-TR",
+		/** 以色列新谢克尔（以色列，Locale: 希伯来语） → 1,234,567.89 */
+		ILS: "he-IL",
+		/** 摩洛哥迪拉姆（摩洛哥，Locale: 阿拉伯语+摩洛哥） → 1.234.567,89 */
+		MAD: "ar-MA",
+		/** 科威特第纳尔（科威特，Locale: 阿拉伯语+科威特） → ١٬٢٣٤٬٥٦٧٫٨٩（阿拉伯数字） */
+		KWD: "ar-KW",
+		/** 卡塔尔里亚尔（卡塔尔，Locale: 阿拉伯语+卡塔尔） → ١٬٢٣٤٬٥٦٧٫٨٩（阿拉伯数字） */
+		QAR: "ar-QA",
+		/** 尼日利亚奈拉（尼日利亚，Locale: 英语+尼日利亚） → 1,234,567.89 */
+		NGN: "en-NG",
+		/** 太平洋法郎（法属波利尼西亚，Locale: 法语+太平洋） → 1[U+202F]234[U+202F]567,89（窄空格千分位） */
+		XPF: "fr-PF"
+	};
+	static currencyFormatter(value, options) {
+		if (require_math.TypeUtil.isNullish(value)) return null;
+		const { currencySign, currencySignPosition, locales, currencyFormatOptions } = options;
+		const numberValue = Number(value);
+		if (Number.isNaN(numberValue)) return null;
+		let formatedValue = numberValue.toLocaleString(locales, currencyFormatOptions).replace(currencySign, "").trim();
+		if (currencySignPosition === "start") formatedValue = `${currencySign} ${formatedValue}`;
+		if (currencySignPosition === "end") formatedValue = `${formatedValue} ${currencySign}`;
+		return formatedValue;
+	}
+	static toRealValue(mathJsInstance, value, precision, stringMode) {
+		if (require_math.TypeUtil.isNullish(value)) return null;
+		const precisionValue = require_math.MathUtil.toDecimal(mathJsInstance, value, precision);
+		return stringMode === false ? Number(precisionValue) : precisionValue;
+	}
+};
+//#endregion
+//#region src/dateTime/dateTimeUtil.ts
+/**
+* 日期工具类
+*/
+var DateTimeUtil = class {
+	/**
+	* 每秒的毫秒数
+	* @example
+	* ```ts
+	* DateTimeUtil.MILLISECONDS_PER_SECOND; // 1000
+	* ```
+	*/
+	static MILLISECONDS_PER_SECOND = 1e3;
+	/**
+	* 每分钟的秒数
+	* @example
+	* ```ts
+	* DateTimeUtil.SECOND_PER_MINUTE; // 60
+	* ```
+	*/
+	static SECOND_PER_MINUTE = 60;
+	/**
+	* 每小时的分钟数
+	* @example
+	* ```ts
+	* DateTimeUtil.MINUTE_PER_HOUR; // 60
+	* ```
+	*/
+	static MINUTE_PER_HOUR = 60;
+	/**
+	* 每小时的秒数
+	* @example
+	* ```ts
+	* DateTimeUtil.SECOND_PER_HOUR; // 3600
+	* ```
+	*/
+	static SECOND_PER_HOUR = this.SECOND_PER_MINUTE ** 2;
+	/**
+	* 每天小时数
+	* @example
+	* ```ts
+	* DateTimeUtil.HOUR_PER_DAY; // 24
+	* ```
+	*/
+	static HOUR_PER_DAY = 24;
+	/**
+	* 每天秒数
+	* @example
+	* ```ts
+	* DateTimeUtil.SECOND_PER_DAY; // 86400
+	* ```
+	*/
+	static SECOND_PER_DAY = this.SECOND_PER_HOUR * this.HOUR_PER_DAY;
+	/**
+	* 每周天数
+	* @example
+	* ```ts
+	* DateTimeUtil.DAY_PER_WEEK; // 7
+	* ```
+	*/
+	static DAY_PER_WEEK = 7;
+	/**
+	* 每月天数
+	* @example
+	* ```ts
+	* DateTimeUtil.DAY_PER_MONTH; // 30
+	* ```
+	*/
+	static DAY_PER_MONTH = 30;
+	/**
+	* 每年天数
+	* @example
+	* ```ts
+	* DateTimeUtil.DAY_PER_YEAR; // 365
+	* ```
+	*/
+	static DAY_PER_YEAR = 365;
+	/**
+	* 每年月数
+	* @example
+	* ```ts
+	* DateTimeUtil.MONTH_PER_YEAR; // 12
+	* ```
+	*/
+	static MONTH_PER_YEAR = 12;
+	/**
+	* 每年平均周
+	* @example
+	* ```ts
+	* DateTimeUtil.WEEK_PER_YEAR; // 52
+	* ```
+	*/
+	static WEEK_PER_YEAR = 52;
+	/**
+	* 每月平均周
+	* @example
+	* ```ts
+	* DateTimeUtil.WEEK_PER_MONTH; // 4
+	* ```
+	*/
+	static WEEK_PER_MONTH = 4;
+	/**
+	* 常用时间格式模板集合
+	*
+	* @example
+	* ```ts
+	* DateTimeUtil.FORMAT.ISO_DATE; // "yyyy-MM-dd"
+	* DateTimeUtil.FORMAT.CN_DATE_TIME; // "yyyy年MM月dd日 HH时mm分ss秒"
+	* ```
+	*/
+	static 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"
+	};
+	/**
+	* 获取当前时区信息
+	*
+	* @returns 时区信息对象 (UTC偏移和时区名称)
+	* @example
+	* ```ts
+	* DateTimeUtil.getTimeZone(); // { UTC: "UTC+8", timeZone: "Asia/Shanghai" }
+	* ```
+	*/
+	static getTimeZone() {
+		const offsetMinutes = 0 - (/* @__PURE__ */ new Date()).getTimezoneOffset();
+		const sign = offsetMinutes >= 0 ? "+" : "-";
+		const absMinutes = Math.abs(offsetMinutes);
+		const hours = Math.floor(absMinutes / this.MINUTE_PER_HOUR);
+		const minutes = absMinutes % this.MINUTE_PER_HOUR;
+		return {
+			UTC: `UTC${sign}${hours}${minutes ? `:${String(minutes).padStart(2, "0")}` : ""}`,
+			timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone
+		};
+	}
+};
+//#endregion
+//#region src/env/envUtil.ts
+/**
+* 环境检查工具类
+* - ⚠️ `isBrowser` / `isWebWorker` / `isReactNative` 基于静态字段判定，在**模块加载时**求值一次。
+*   SSR 场景下若在 Node 端 import（此时 `window` 未定义），结果会永久为 `false`，不会随运行时环境变化重算。
+*/
+var EnvUtil = class {
+	static _isBrowser = typeof window !== "undefined" && require_math.TypeUtil.isFunction(window?.document?.createElement);
+	static _isWebWorker = typeof window === "undefined" && typeof self !== "undefined" && "importScripts" in self;
+	static _isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+	/**
+	* 检测是否处于浏览器环境
+	*
+	* @returns 是否为浏览器环境
+	* @example
+	* ```ts
+	* EnvUtil.isBrowser(); // true: 浏览器, false: Node.js
+	* ```
+	*/
+	static isBrowser() {
+		return this._isBrowser;
+	}
+	/**
+	* 检测是否处于 Web Worker 环境
+	*
+	* @returns 是否为 Web Worker 环境
+	* @example
+	* ```ts
+	* EnvUtil.isWebWorker(); // true: Worker, false: 主线程/Node.js
+	* ```
+	*/
+	static isWebWorker() {
+		return this._isWebWorker;
+	}
+	/**
+	* 检测是否处于 React Native 环境
+	*
+	* @returns 是否为 React Native 环境
+	* @example
+	* ```ts
+	* EnvUtil.isReactNative(); // true: React Native, false: Web/Node.js
+	* ```
+	*/
+	static isReactNative() {
+		return this._isReactNative;
+	}
+	/**
+	* 检查是否在 iframe 环境中
+	*
+	* @returns 是否在 iframe 中
+	* @example
+	* ```ts
+	* EnvUtil.isIframe(); // true: 当前页面在 iframe 中
+	* ```
+	*/
+	static isIframe() {
+		if (typeof window === "undefined") return false;
+		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" || !require_math.TypeUtil.isPositiveInteger(minWidth) || !require_math.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" || !require_math.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 是否为平板设备
+	* - 宽度命中 `[minWidth, maxWidth]` 区间，或 CSS/DPI 折算尺寸落在 `[7, 13)` 英寸（排除 DPR=1 的 1920×1080 桌面）
+	* @example
+	* ```ts
+	* // 假设 window.innerWidth = 1000
+	* EnvUtil.isTablet(); // true
+	* ```
+	*/
+	static isTablet(minWidth = 768, maxWidth = 1200, dpi = 160) {
+		if (typeof window === "undefined" || !require_math.TypeUtil.isPositiveInteger(minWidth) || !require_math.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 && screenInches < 13;
+		} catch {
+			return isWithinWidthRange;
+		}
+	}
+};
+//#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);
+					if (!parsedError.message) parsedError.message = String(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
+	* ```ts
+	* // 遗留代码场景
+	* 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 || args === void 0) throw new TypeError(`function [toArgs] Expected parameter [args] to be a arguments object, got ${typeof args}`);
+		return Array.prototype.slice.call(args, start);
+	}
+	/**
+	* 将同步或异步函数统一包装为 Promise
+	* - 自动捕获同步异常
+	*
+	* @param fn 返回值可为同步值或 Promise 的函数
+	* @returns 标准化的 Promise
+	*
+	* @example
+	* ```ts
+	* // 同步函数
+	* 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 {
+	/**
+	* 文件类型 MIME 常量
+	* - 每个类型对应具体的文件扩展名
+	*/
+	static FILE_MIME = {
+		/** 普通文本文件（.txt） */
+		TEXT: "text/plain",
+		/** 超文本标记语言文档（.html/.htm） */
+		HTML: "text/html",
+		/** 层叠样式表文件（.css） */
+		CSS: "text/css",
+		/** 逗号分隔值文件/表格数据（.csv） */
+		CSV: "text/csv",
+		/** 制表符分隔值文件（.tsv） */
+		TSV: "text/tab-separated-values",
+		/** XML 文档（.xml） */
+		XML: "application/xml",
+		/** XML 文档/兼容值 */
+		XML_LEGACY: "text/xml",
+		/** XHTML 文档（.xhtml/.xht） */
+		XHTML: "application/xhtml+xml",
+		/** JavaScript 文件（.js） */
+		JS: "text/javascript",
+		/** TypeScript 文件（.ts） */
+		TS: "text/typescript",
+		/** Python 文件（.py） */
+		PY: "text/x-python",
+		/** Shell 脚本 (.sh) */
+		SH: "text/x-sh",
+		/** C 语言源文件（.c） */
+		C: "text/x-c",
+		/** C++ 源文件（.cpp/.cc/.cxx） */
+		CPP: "text/x-c++",
+		/** C# 源文件（.cs） */
+		CSHARP: "text/x-csharp",
+		/** Java 源文件（.java） */
+		JAVA: "text/x-java",
+		/** Go 源文件（.go） */
+		GO: "text/x-go",
+		/** Rust 源文件（.rs） */
+		RUST: "text/x-rust",
+		/** PHP 文件（.php） */
+		PHP: "text/x-php",
+		/** Ruby 文件（.rb） */
+		RUBY: "text/x-ruby",
+		/** Swift 源文件（.swift） */
+		SWIFT: "text/x-swift",
+		/** YAML 文档（.yaml/.yml） */
+		YAML: "application/yaml",
+		/** YAML 文档/兼容值 */
+		YAML_LEGACY: "text/vnd.yaml",
+		/** TOML 文档（.toml） */
+		TOML: "application/toml",
+		/** TOML 文档/兼容值 */
+		TOML_LEGACY: "text/x-toml",
+		/** SQL 脚本（.sql） */
+		SQL: "application/sql",
+		/** SQL 脚本/兼容值 */
+		SQL_LEGACY: "text/x-sql",
+		/** Markdown 格式文档（.md/.markdown） */
+		MARKDOWN: "text/markdown",
+		/** 富文本格式文档（.rtf） */
+		RTF: "application/rtf",
+		/** iCalendar 日历格式（.ics） */
+		CALENDAR: "text/calendar",
+		/** JPEG 图像（.jpg/.jpeg） */
+		JPEG: "image/jpeg",
+		/** JPG 图像（JPEG 别名，.jpg） */
+		JPG: "image/jpeg",
+		/** PNG 图像/无损压缩，支持透明（.png） */
+		PNG: "image/png",
+		/** GIF 图像/支持动画（.gif） */
+		GIF: "image/gif",
+		/** Windows 位图（.bmp） */
+		BMP: "image/bmp",
+		/** SVG 向量图形（.svg） */
+		SVG: "image/svg+xml",
+		/** APNG 动态图像（.apng） */
+		APNG: "image/apng",
+		/** AVIF 图像/高效压缩（.avif） */
+		AVIF: "image/avif",
+		/** 图标文件格式（.ico） */
+		ICO: "image/vnd.microsoft.icon",
+		/** 图标文件格式/兼容值（.ico） */
+		ICO_LEGACY: "image/x-icon",
+		/** WebP 图像/高效压缩（.webp） */
+		WEBP: "image/webp",
+		/** TIFF 图像（.tif/.tiff） */
+		TIFF: "image/tiff",
+		/** HEIC 图像/高效编码（.heic） */
+		HEIC: "image/heic",
+		/** HEIF 图像/高效编码（.heif） */
+		HEIF: "image/heif",
+		/** Adobe Photoshop 文件（.psd） */
+		PSD: "image/vnd.adobe.photoshop",
+		/** 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",
+		/** FLAC 无损音频（.flac） */
+		FLAC: "audio/flac",
+		/** WAV 音频（.wav） */
+		WAV: "audio/wav",
+		/** WebM 音频（.weba） */
+		WEBM_AUDIO: "audio/webm",
+		/** 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",
+		/** Matroska 视频（.mkv） */
+		MKV: "video/x-matroska",
+		/** Matroska 音频（.mka） */
+		MKA: "audio/x-matroska",
+		/** QuickTime 视频（.mov） */
+		QUICKTIME: "video/quicktime",
+		/** PDF 文档（.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",
+		/** 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",
+		/** RAR 压缩文件（.rar） */
+		RAR: "application/vnd.rar",
+		/** XZ 压缩文件（.xz） */
+		XZ: "application/x-xz",
+		/** Zstandard 压缩文件（.zst） */
+		ZSTD: "application/zstd",
+		/** ISO 光盘镜像（.iso） */
+		ISO9660_IMAGE: "application/x-iso9660-image",
+		/** JSON 数据格式（.json） */
+		JSON: "application/json",
+		/** JSON-LD 格式（.jsonld） */
+		LD_JSON: "application/ld+json",
+		/** Web App Manifest（.webmanifest） */
+		MANIFEST: "application/manifest+json",
+		/** Java 归档文件（.jar） */
+		JAR: "application/java-archive",
+		/** WebAssembly 二进制指令格式（.wasm） */
+		WASM: "application/wasm",
+		/** MS 嵌入式 OpenType 字体（.eot） */
+		EOT: "application/vnd.ms-fontobject",
+		/** OpenType 字体（.otf） */
+		OTF: "font/otf",
+		/** WOFF 字体（.woff） */
+		WOFF: "font/woff",
+		/** WOFF2 字体（.woff2） */
+		WOFF2: "font/woff2",
+		/** TrueType 字体（.ttf） */
+		TTF: "font/ttf",
+		/** Excel 97-2003 工作簿（.xls） */
+		XLS: "application/vnd.ms-excel",
+		/** Microsoft XPS 文档（.xps） */
+		XPS: "application/vnd.ms-xpsdocument",
+		/** Word 启用宏文档（.docm） */
+		DOCM: "application/vnd.ms-word.document.macroEnabled.12"
+	};
+	/**
+	* 协议/内容类型 MIME 常量
+	* - 用于 HTTP 请求/响应内容协商，无对应文件扩展名
+	*/
+	static PROTOCOL_MIME = {
+		/** 通用二进制数据流 */
+		OCTET_STREAM: "application/octet-stream",
+		/** URL 编码表单 */
+		FORM_URLENCODED: "application/x-www-form-urlencoded",
+		/** multipart 表单 */
+		FORM_DATA: "multipart/form-data",
+		/** Server-Sent Events 数据流 */
+		EVENT_STREAM: "text/event-stream",
+		/** 问题详情 JSON（RFC 9457） */
+		PROBLEM_JSON: "application/problem+json",
+		/** JSON Patch（RFC 6902） */
+		JSON_PATCH: "application/json-patch+json",
+		/** JSON Merge Patch（RFC 7386） */
+		MERGE_PATCH_JSON: "application/merge-patch+json"
+	};
+	/**
+	* 根据文件后缀名获取对应的标准 MIME 类型（含历史兼容值）
+	* - 支持带 `.` 或不带 `.` 的后缀名，不区分大小写
+	* - 元组第一项始终为 IANA 官方标准 MIME，后续项为历史兼容值
+	* - 仅查询文件类型 MIME，不包含无后缀对应的协议类型
+	*
+	* @param extension 文件后缀名（如 `".png"` / `"png"` / `".PNG"`）
+	* @returns 标准 MIME + 兼容值的元组；如无匹配则返回 `undefined`
+	* @example
+	* ```ts
+	* MimeUtil.fromExtension(".png");  // ["image/png"]
+	* MimeUtil.fromExtension("ico");   // ["image/vnd.microsoft.icon", "image/x-icon"]
+	* MimeUtil.fromExtension(".xml");  // ["application/xml", "text/xml"]
+	* MimeUtil.fromExtension(".xyz");  // undefined
+	* ```
+	*/
+	static fromExtension(extension) {
+		const ext = require_math.StringUtil.cast(extension).toLowerCase();
+		const key = ext.startsWith(".") ? ext : `.${ext}`;
+		return EXT_TO_MIME[key];
+	}
+	/**
+	* 根据 MIME 类型获取对应的文件后缀名列表
+	* - 一个 MIME 类型可能对应多个后缀名（如 `text/html` → `.html` / `.htm`）
+	* - 兼容值和标准值映射到相同的后缀（如 `image/x-icon` 和 `image/vnd.microsoft.icon` 均返回 `[".ico"]`）
+	* - 仅查询文件类型 MIME，协议类型无对应后缀
+	*
+	* @param mime MIME 类型字符串（如 `"image/png"` / `"IMAGE/PNG"`）
+	* @returns 文件后缀名列表；如无匹配则返回 `undefined`
+	* @example
+	* ```ts
+	* MimeUtil.toExtension("IMAGE/PNG");                    // [".png"]
+	* MimeUtil.toExtension("text/html");                    // [".html", ".htm"]
+	* MimeUtil.toExtension("image/jpeg");                   // [".jpg", ".jpeg"]
+	* MimeUtil.toExtension("application/octet-stream");     // undefined
+	* ```
+	*/
+	static toExtension(mime) {
+		const m = require_math.StringUtil.cast(mime).toLowerCase();
+		return MIME_TO_EXT.get(m);
+	}
+};
+const EXT_TO_MIME = {
+	".txt": [MimeUtil.FILE_MIME.TEXT],
+	".html": [MimeUtil.FILE_MIME.HTML],
+	".htm": [MimeUtil.FILE_MIME.HTML],
+	".css": [MimeUtil.FILE_MIME.CSS],
+	".csv": [MimeUtil.FILE_MIME.CSV],
+	".tsv": [MimeUtil.FILE_MIME.TSV],
+	".xml": [MimeUtil.FILE_MIME.XML, MimeUtil.FILE_MIME.XML_LEGACY],
+	".xhtml": [MimeUtil.FILE_MIME.XHTML],
+	".xht": [MimeUtil.FILE_MIME.XHTML],
+	".js": [MimeUtil.FILE_MIME.JS],
+	".ts": [MimeUtil.FILE_MIME.TS],
+	".py": [MimeUtil.FILE_MIME.PY],
+	".sh": [MimeUtil.FILE_MIME.SH],
+	".c": [MimeUtil.FILE_MIME.C],
+	".cpp": [MimeUtil.FILE_MIME.CPP],
+	".cc": [MimeUtil.FILE_MIME.CPP],
+	".cxx": [MimeUtil.FILE_MIME.CPP],
+	".cs": [MimeUtil.FILE_MIME.CSHARP],
+	".java": [MimeUtil.FILE_MIME.JAVA],
+	".go": [MimeUtil.FILE_MIME.GO],
+	".rs": [MimeUtil.FILE_MIME.RUST],
+	".php": [MimeUtil.FILE_MIME.PHP],
+	".rb": [MimeUtil.FILE_MIME.RUBY],
+	".swift": [MimeUtil.FILE_MIME.SWIFT],
+	".yaml": [MimeUtil.FILE_MIME.YAML, MimeUtil.FILE_MIME.YAML_LEGACY],
+	".yml": [MimeUtil.FILE_MIME.YAML, MimeUtil.FILE_MIME.YAML_LEGACY],
+	".toml": [MimeUtil.FILE_MIME.TOML, MimeUtil.FILE_MIME.TOML_LEGACY],
+	".sql": [MimeUtil.FILE_MIME.SQL, MimeUtil.FILE_MIME.SQL_LEGACY],
+	".md": [MimeUtil.FILE_MIME.MARKDOWN],
+	".markdown": [MimeUtil.FILE_MIME.MARKDOWN],
+	".rtf": [MimeUtil.FILE_MIME.RTF],
+	".ics": [MimeUtil.FILE_MIME.CALENDAR],
+	".jpg": [MimeUtil.FILE_MIME.JPEG],
+	".jpeg": [MimeUtil.FILE_MIME.JPEG],
+	".png": [MimeUtil.FILE_MIME.PNG],
+	".gif": [MimeUtil.FILE_MIME.GIF],
+	".bmp": [MimeUtil.FILE_MIME.BMP],
+	".svg": [MimeUtil.FILE_MIME.SVG],
+	".apng": [MimeUtil.FILE_MIME.APNG],
+	".avif": [MimeUtil.FILE_MIME.AVIF],
+	".ico": [MimeUtil.FILE_MIME.ICO, MimeUtil.FILE_MIME.ICO_LEGACY],
+	".webp": [MimeUtil.FILE_MIME.WEBP],
+	".tif": [MimeUtil.FILE_MIME.TIFF],
+	".tiff": [MimeUtil.FILE_MIME.TIFF],
+	".heic": [MimeUtil.FILE_MIME.HEIC],
+	".heif": [MimeUtil.FILE_MIME.HEIF],
+	".psd": [MimeUtil.FILE_MIME.PSD],
+	".mp3": [MimeUtil.FILE_MIME.MP3],
+	".aac": [MimeUtil.FILE_MIME.AAC],
+	".mid": [MimeUtil.FILE_MIME.MIDI],
+	".midi": [MimeUtil.FILE_MIME.MIDI],
+	".oga": [MimeUtil.FILE_MIME.OGG_AUDIO],
+	".opus": [MimeUtil.FILE_MIME.OPUS],
+	".flac": [MimeUtil.FILE_MIME.FLAC],
+	".wav": [MimeUtil.FILE_MIME.WAV],
+	".weba": [MimeUtil.FILE_MIME.WEBM_AUDIO],
+	".ra": [MimeUtil.FILE_MIME.REAL_AUDIO],
+	".ram": [MimeUtil.FILE_MIME.REAL_AUDIO],
+	".mp4": [MimeUtil.FILE_MIME.MP4],
+	".mpeg": [MimeUtil.FILE_MIME.MPEG],
+	".mpg": [MimeUtil.FILE_MIME.MPEG],
+	".ogv": [MimeUtil.FILE_MIME.OGG_VIDEO],
+	".avi": [MimeUtil.FILE_MIME.AVI],
+	".3gp": [MimeUtil.FILE_MIME.THREE_GPP],
+	".3g2": [MimeUtil.FILE_MIME.THREE_GPP2],
+	".webm": [MimeUtil.FILE_MIME.WEBM],
+	".mkv": [MimeUtil.FILE_MIME.MKV],
+	".mka": [MimeUtil.FILE_MIME.MKA],
+	".mov": [MimeUtil.FILE_MIME.QUICKTIME],
+	".pdf": [MimeUtil.FILE_MIME.PDF],
+	".doc": [MimeUtil.FILE_MIME.DOC],
+	".docx": [MimeUtil.FILE_MIME.DOCX],
+	".xlsx": [MimeUtil.FILE_MIME.XLSX],
+	".xlsm": [MimeUtil.FILE_MIME.XLSM],
+	".xltx": [MimeUtil.FILE_MIME.XLTX],
+	".pptx": [MimeUtil.FILE_MIME.PPTX],
+	".ppt": [MimeUtil.FILE_MIME.PPT],
+	".odt": [MimeUtil.FILE_MIME.ODT],
+	".ods": [MimeUtil.FILE_MIME.ODS],
+	".odp": [MimeUtil.FILE_MIME.ODP],
+	".epub": [MimeUtil.FILE_MIME.EPUB],
+	".azw": [MimeUtil.FILE_MIME.AZW],
+	".zip": [MimeUtil.FILE_MIME.ZIP],
+	".gz": [MimeUtil.FILE_MIME.GZIP],
+	".tar": [MimeUtil.FILE_MIME.TAR],
+	".bz": [MimeUtil.FILE_MIME.BZIP],
+	".bz2": [MimeUtil.FILE_MIME.BZIP2],
+	".7z": [MimeUtil.FILE_MIME.SEVEN_Z],
+	".rar": [MimeUtil.FILE_MIME.RAR],
+	".xz": [MimeUtil.FILE_MIME.XZ],
+	".zst": [MimeUtil.FILE_MIME.ZSTD],
+	".iso": [MimeUtil.FILE_MIME.ISO9660_IMAGE],
+	".json": [MimeUtil.FILE_MIME.JSON],
+	".jsonld": [MimeUtil.FILE_MIME.LD_JSON],
+	".webmanifest": [MimeUtil.FILE_MIME.MANIFEST],
+	".jar": [MimeUtil.FILE_MIME.JAR],
+	".wasm": [MimeUtil.FILE_MIME.WASM],
+	".eot": [MimeUtil.FILE_MIME.EOT],
+	".otf": [MimeUtil.FILE_MIME.OTF],
+	".woff": [MimeUtil.FILE_MIME.WOFF],
+	".woff2": [MimeUtil.FILE_MIME.WOFF2],
+	".ttf": [MimeUtil.FILE_MIME.TTF],
+	".xls": [MimeUtil.FILE_MIME.XLS],
+	".xps": [MimeUtil.FILE_MIME.XPS],
+	".docm": [MimeUtil.FILE_MIME.DOCM]
+};
+const MIME_TO_EXT = (() => {
+	const map = /* @__PURE__ */ new Map();
+	for (const [ext, mimes] of Object.entries(EXT_TO_MIME)) for (const mime of mimes) {
+		const exts = map.get(mime);
+		if (exts) {
+			if (!exts.includes(ext)) exts.push(ext);
+		} else map.set(mime, [ext]);
+	}
+	return map;
+})();
+//#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 (!require_math.TypeUtil.isNumber(input) || require_math.TypeUtil.isInfinity(input)) throw new Error("function [within] Expected parameter [input] to be a finite number.");
+		if (!require_math.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 }
+	*
+	* ObjectUtil.entriesMap(obj, (k, v) => [`prefix_${String(k)}`, `${v}x`]); // { prefix_a: "1x", prefix_b: "2x" }
+	* ```
+	*/
+	static entriesMap(plainObject, toEntry) {
+		const defaultResult = {};
+		if (!require_math.TypeUtil.isPlainObject(plainObject)) return defaultResult;
+		return this.entries(plainObject).reduce((acc, [key, value]) => {
+			const [newKey, newValue] = toEntry(key, value);
+			Object.defineProperty(acc, newKey, {
+				value: newValue,
+				enumerable: true,
+				writable: true,
+				configurable: true
+			});
+			return acc;
+		}, defaultResult);
+	}
+	static pick(obj, keys) {
+		const result = {};
+		if (!require_math.TypeUtil.isPlainObject(obj)) return result;
+		if (!require_math.TypeUtil.isArray(keys)) return obj;
+		return keys.reduce((acc, key) => {
+			if (key in obj) Object.defineProperty(acc, key, {
+				value: obj[key],
+				enumerable: true,
+				writable: true,
+				configurable: true
+			});
+			return acc;
+		}, result);
+	}
+	static omit(obj, keys) {
+		const result = {};
+		if (!require_math.TypeUtil.isPlainObject(obj)) return result;
+		if (!require_math.TypeUtil.isArray(keys)) return obj;
+		const keysToOmit = new Set(keys);
+		return Object.keys(obj).reduce((acc, key) => {
+			if (!keysToOmit.has(key)) Object.defineProperty(acc, key, {
+				value: obj[key],
+				enumerable: true,
+				writable: true,
+				configurable: true
+			});
+			return acc;
+		}, result);
+	}
+	static invert(obj) {
+		const result = {};
+		if (!require_math.TypeUtil.isPlainObject(obj)) return result;
+		for (const [k, v] of this.entries(obj)) if (require_math.TypeUtil.isString(v) || require_math.TypeUtil.isNumber(v) || require_math.TypeUtil.isSymbol(v)) result[v] = k;
+		return result;
+	}
+	static crush(obj) {
+		if (!obj) return {};
+		function crushReducer(crushed, value, path) {
+			if (require_math.TypeUtil.isPlainObject(value) || require_math.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] = require_math.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] = require_math.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] = require_math.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 {
+	/**
+	* 固定主题类型（仅亮色/暗色）
+	*
+	* @example
+	* ```ts
+	* ThemeUtil.THEME.LIGHT; // "light"
+	* ThemeUtil.THEME.DARK; // "dark"
+	* ```
+	*/
+	static THEME = {
+		LIGHT: "light",
+		DARK: "dark"
+	};
+	/**
+	* 主题模式（支持跟随系统）
+	*
+	* @example
+	* ```ts
+	* ThemeUtil.THEME_MODE.SYSTEM; // "system"
+	* ThemeUtil.THEME_MODE.DARK; // "dark"
+	* ```
+	*/
+	static THEME_MODE = {
+		LIGHT: "light",
+		DARK: "dark",
+		SYSTEM: "system"
+	};
+};
+//#endregion
+//#region src/tree/utils.ts
+function getFinalChildrenKey(tree, meta, options) {
+	if (require_math.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 (require_math.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 (require_math.TypeUtil.isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		newChildren = children.map((c) => postImpl$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 (require_math.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 (require_math.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 (require_math.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 (require_math.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 (require_math.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 (require_math.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 (require_math.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 (require_math.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 (require_math.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 (require_math.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
+/**
+* 树结构工具类
+*
+* 引用策略约定：
+* - 转换类方法（`rowsToTree` / `treeToRows` / `filter` / `map`）：不突变输入；输出的每个节点均为**新对象引用**（来源节点的浅拷贝，仅自有可枚举属性；非枚举属性、原型链、getter 及深层嵌套对象不保证）。
+* - 查询类方法（`find` / `forEach`）：按查询语义直接使用**原对象引用**。
+*/
+var TreeUtil = class {
+	/**
+	* 行结构 转 树结构
+	* - 将平铺的数组转换为树形结构
+	* - 返回的树结构与输入行无共享节点（新对象引用），输入行不会被突变
+	* - 重复 id 的行只取首次出现；仅叶子/缺失父节点的 id 会作为根节点，且每个根节点只输出一次
+	*
+	* @param rows 行数据数组
+	* @param options 配置项
+	* @returns 树结构数组（所有节点均包含 children 数组）
+	* @example
+	* ```ts
+	* const rows = [
+	*   { id: 1, parentId: null },
+	*   { id: 2, parentId: 1 },
+	* ];
+	* TreeUtil.rowsToTree(rows); // [{ id: 1, parentId: null, children: [{ id: 2, parentId: 1, children: [] }] }]
+	* ```
+	*/
+	static rowsToTree(rows, options) {
+		const { parentIdKey = "parentId", rowKey = "id", childrenKey = "children" } = options || {};
+		const result = [];
+		const map = /* @__PURE__ */ new Map();
+		const processedIds = /* @__PURE__ */ new Set();
+		for (const row of rows) {
+			const id = row[rowKey];
+			if (!map.get(id)) map.set(id, { ...row });
+		}
+		for (const row of rows) {
+			const id = row[rowKey];
+			if (processedIds.has(id)) continue;
+			processedIds.add(id);
+			const parentId = row[parentIdKey];
+			const node = map.get(id);
+			if (!node) continue;
+			if (require_math.TypeUtil.isNullish(parentId) || parentId === id || !map.has(parentId)) {
+				result.push(node);
+				continue;
+			}
+			const parent = map.get(parentId);
+			const siblings = parent[childrenKey];
+			if (require_math.TypeUtil.isNullish(siblings)) parent[childrenKey] = [node];
+			else if (Array.isArray(siblings)) siblings.push(node);
+			else {
+				const message = `The key "${childrenKey.toString()}" in parent item is not an array.`;
+				throw new Error(message);
+			}
+		}
+		for (const root of result) this.forEach(root, (node) => {
+			const record = node;
+			const children = record[childrenKey];
+			if (require_math.TypeUtil.isNullish(children)) record[childrenKey] = [];
+			else if (!Array.isArray(children)) {
+				const message = `The key "${childrenKey.toString()}" in parent item is not an array.`;
+				throw new Error(message);
+			}
+		}, { childrenKey });
+		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 (require_math.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 (require_math.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 require_math.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 require_math.TypeUtil.isArray(tree) ? tree.map((row) => traversalMethod(row, callback, innerOptions)) : traversalMethod(tree, callback, innerOptions);
+	}
+};
+//#endregion
+//#region src/validate/validateUtil.ts
+/**
+* 验证工具类
+*/
+var ValidateUtil = class {
+	static _phone = /^1(3\d|4[5-9]|5[0-35-9]|6[567]|7[0-8]|8\d|9[0-35-9])\d{8}$/;
+	/**
+	* 验证是否为手机号码
+	* @example
+	* ```ts
+	* ValidateUtil.isPhone("13800138000"); // true
+	* ```
+	*/
+	static isPhone(input) {
+		return this._phone.test(input.toString());
+	}
+	static _telephone = /^(((0\d{2,3})-)?((\d{7,8})|(400\d{7})|(800\d{7}))(-(\d{1,4}))?)$/;
+	/**
+	* 验证是否为固定电话
+	* @example
+	* ```ts
+	* ValidateUtil.isTelephone("010-12345678"); // true
+	* ```
+	*/
+	static isTelephone(input) {
+		return this._telephone.test(input.toString());
+	}
+	static _IMEI = /^\d{15,17}$/;
+	/**
+	* 验证是否为移动设备识别码
+	* @example
+	* ```ts
+	* ValidateUtil.isIMEI("490154203237518"); // true
+	* ```
+	*/
+	static isIMEI(input) {
+		return this._IMEI.test(input.toString());
+	}
+	static _email = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\])|(([a-z\-0-9]+\.)+[a-z]{2,}))$/i;
+	/**
+	* 验证是否为电子邮箱
+	* @example
+	* ```ts
+	* ValidateUtil.isEmail("dev@example.com"); // true
+	* ```
+	*/
+	static isEmail(input) {
+		return this._email.test(input.toString());
+	}
+	static _link = /^(https?:\/\/)?(([\w-]+(\.[\w-]+)*\.[a-z]{2,6})|((\d{1,3}\.){3}\d{1,3}))(:\d+)?(\/\S*)?$/i;
+	/**
+	* 验证是否为 http(s) 链接
+	* @example
+	* ```ts
+	* ValidateUtil.isHttpLink("https://example.com/path"); // true
+	* ```
+	*/
+	static isHttpLink(input) {
+		return this._link.test(input.toString());
+	}
+	static _portLink = /^(https?:\/\/)?[\w-]+(\.[\w-]+)+:\d{1,5}\/?$/i;
+	/**
+	* 验证是否为端口号链接
+	* @example
+	* ```ts
+	* ValidateUtil.isPortLink("http://example.com:8080"); // true
+	* ```
+	*/
+	static isPortLink(input) {
+		return this._portLink.test(input.toString());
+	}
+	static _thunderLink = /^thunderx?:\/\/[a-zA-Z\d]+=$/i;
+	/**
+	* 验证是否为迅雷链接
+	* @example
+	* ```ts
+	* ValidateUtil.isThunderLink("thunder://QUFodHRwOi8vZXhhbXBsZS5jb20vZmlsZQ=="); // true
+	* ```
+	*/
+	static isThunderLink(input) {
+		return this._thunderLink.test(input.toString());
+	}
+	static _uscc = /^[0-9A-HJ-NPQRTUWXY]{2}\d{6}[0-9A-HJ-NPQRTUWXY]{10}$/;
+	/**
+	* 验证是否为统一社会信用代码（USCC / USCI / USCCS）
+	* - 固定 18 位：1 位登记管理部门码 + 1 位机构类别码 + 6 位行政区划码 + 9 位主体标识码 + 1 位校验码
+	* - 字符集：数字 0-9 + 大写英文字母（排除 I、O、Z、S、V，防视觉混淆）
+	* - 第 1-2 位允许字母（如登记管理部门码 `A`，代表"其他"），第 3-8 位行政区划码为纯数字
+	*
+	* @param input 待校验字符串
+	* @returns 是否为合法格式的统一社会信用代码
+	* @example
+	* ```ts
+	* ValidateUtil.isUSCC("91350100M000100Y43"); // true
+	* ValidateUtil.isUSCC("A1350100M000100Y43"); // true (A 开头"其他"部门码)
+	* ```
+	*/
+	static isUSCC(input) {
+		return this._uscc.test(input.toString());
+	}
+	/**
+	* 验证是否为统一社会信用代码（同 `isUSCC`）
+	* - USCC / USCI / USCCS 均指统一社会信用代码，固定 18 位
+	* - 15 位旧税务登记号在 2015 年"三证合一"前使用，现已作废，视为无效
+	*
+	* @param input 待校验字符串
+	* @returns 是否为合法代码
+	* @example
+	* ```ts
+	* ValidateUtil.isUSCCS("91350100M000100Y43"); // true (18位)
+	* ValidateUtil.isUSCCS("91350100M000100"); // false (15位旧号，已作废)
+	* ```
+	*/
+	static isUSCCS(input) {
+		return this.isUSCC(input);
+	}
+	static _dirPathWindows = /^[a-z]:\\(?:\w+\\?)*$/i;
+	/**
+	* 验证是否为 Windows 系统文件夹路径
+	* @example
+	* ```ts
+	* ValidateUtil.isDirPathWindows("C:\\Users\\pawover\\"); // true
+	* ```
+	*/
+	static isDirPathWindows(input) {
+		return this._dirPathWindows.test(input.toString());
+	}
+	static _filePathWindows = /^[a-z]:\\(?:\w+\\)*\w+\.\w+$/i;
+	/**
+	* 验证是否为 Windows 系统文件路径
+	* @example
+	* ```ts
+	* ValidateUtil.isFilePathWindows("C:\\Users\\pawover\\a.txt"); // true
+	* ```
+	*/
+	static isFilePathWindows(input) {
+		return this._filePathWindows.test(input.toString());
+	}
+	static _dirPathLinux = /^\/(?:[^\\/\s]+\/)*$/;
+	/**
+	* 验证是否为 Linux 系统文件夹路径
+	* @example
+	* ```ts
+	* ValidateUtil.isDirPathLinux("/usr/local/"); // true
+	* ```
+	*/
+	static isDirPathLinux(input) {
+		return this._dirPathLinux.test(input.toString());
+	}
+	static _filePathLinux = /^(\/$|\/(?:[^\\/\s]+\/)*[^\\/\s]+$)/;
+	/**
+	* 验证是否为 Linux 系统文件路径
+	* @example
+	* ```ts
+	* ValidateUtil.isFilePathLinux("/usr/local/bin/node"); // true
+	* ```
+	*/
+	static isFilePathLinux(input) {
+		return this._filePathLinux.test(input.toString());
+	}
+	static _EVCarNumber = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-HJ-NP-Z](([DF]((?![IO])[a-zA-Z0-9](?![IO]))\d{4})|(\d{5}[DF]))$/;
+	/**
+	* 验证是否为新能源车牌号
+	* @example
+	* ```ts
+	* ValidateUtil.isEVCarNumber("粤AD12345"); // true
+	* ```
+	*/
+	static isEVCarNumber(input) {
+		return this._EVCarNumber.test(input.toString());
+	}
+	static _GVCarNumber = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-HJ-NP-Z][A-HJ-NP-Z0-9]{4,5}[A-HJ-NP-Z0-9挂学警港澳]$/;
+	/**
+	* 验证是否为燃油车车牌号
+	* @example
+	* ```ts
+	* ValidateUtil.isGVCarNumber("粤B12345"); // true
+	* ```
+	*/
+	static isGVCarNumber(input) {
+		return this._GVCarNumber.test(input.toString());
+	}
+	static _chineseName = /^[一-龢][一·-龢]*$/;
+	/**
+	* 验证是否为中文姓名
+	* @example
+	* ```ts
+	* ValidateUtil.isChineseName("张三"); // true
+	* ```
+	*/
+	static isChineseName(input) {
+		return this._chineseName.test(input.toString());
+	}
+	static _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;
+	/**
+	* 验证是否为中国身份证号
+	* - ⚠️ 仅校验 18 位格式（含生日合法性），**不验证第 18 位校验位**，伪造码可通过校验
+	* @example
+	* ```ts
+	* ValidateUtil.isChineseID("11010519491231002X"); // true
+	* ```
+	*/
+	static isChineseID(input) {
+		return this._chineseId.test(input.toString());
+	}
+	static _chineseProvince = /^(?:安徽|澳门|北京|重庆|福建|甘肃|广东|广西|贵州|海南|河北|河南|黑龙江|湖北|湖南|吉林|江苏|江西|辽宁|内蒙古|宁夏|青海|山东|山西|陕西|上海|四川|台湾|天津|西藏|香港|新疆|云南|浙江)$/;
+	/**
+	* 验证是否为中国省份
+	* @example
+	* ```ts
+	* ValidateUtil.isChineseProvince("浙江"); // true
+	* ```
+	*/
+	static isChineseProvince(input) {
+		return this._chineseProvince.test(input.toString());
+	}
+	static _chineseNation = /^(?:汉族|蒙古族|回族|藏族|维吾尔族|苗族|彝族|壮族|布依族|朝鲜族|满族|侗族|瑶族|白族|土家族|哈尼族|哈萨克族|傣族|黎族|傈僳族|佤族|畲族|高山族|拉祜族|水族|东乡族|纳西族|景颇族|柯尔克孜族|土族|达斡尔族|仫佬族|羌族|布朗族|撒拉族|毛南族|仡佬族|锡伯族|阿昌族|普米族|塔吉克族|怒族|乌孜别克族|俄罗斯族|鄂温克族|德昂族|保安族|裕固族|京族|塔塔尔族|独龙族|鄂伦春族|赫哲族|门巴族|珞巴族|基诺族|其它未识别民族|外国人入中国籍)$/;
+	/**
+	* 验证是否为中华民族
+	* @example
+	* ```ts
+	* ValidateUtil.isChineseNation("汉族"); // true
+	* ```
+	*/
+	static isChineseNation(input) {
+		return this._chineseNation.test(input.toString());
+	}
+	static _letter = /^[a-z]+$/i;
+	/**
+	* 验证是否只包含字母
+	* @example
+	* ```ts
+	* ValidateUtil.isLetter("abcDEF"); // true
+	* ```
+	*/
+	static isLetter(input) {
+		return this._letter.test(input.toString());
+	}
+	static _letterLowercase = /^[a-z]+$/;
+	/**
+	* 验证是否只包含小写字母
+	* @example
+	* ```ts
+	* ValidateUtil.isLetterLowercase("abc"); // true
+	* ```
+	*/
+	static isLetterLowercase(input) {
+		return this._letterLowercase.test(input.toString());
+	}
+	static _letterUppercase = /^[A-Z]+$/;
+	/**
+	* 验证是否只包含大写字母
+	* @example
+	* ```ts
+	* ValidateUtil.isLetterUppercase("ABC"); // true
+	* ```
+	*/
+	static isLetterUppercase(input) {
+		return this._letterUppercase.test(input.toString());
+	}
+	static _letterOmit = /^[^A-Z]*$/i;
+	/**
+	* 验证是否不包含字母
+	* @example
+	* ```ts
+	* ValidateUtil.isLetterOmit("123_-"); // true
+	* ```
+	*/
+	static isLetterOmit(input) {
+		return this._letterOmit.test(input.toString());
+	}
+	static _LetterAndNumber = /^[A-Z0-9]+$/i;
+	/**
+	* 验证是否为数字和字母组合
+	* @example
+	* ```ts
+	* ValidateUtil.isLetterAndNumber("A1B2"); // true
+	* ```
+	*/
+	static isLetterAndNumber(input) {
+		return this._LetterAndNumber.test(input.toString());
+	}
+	static _signedFloat = /^[+-]?(\d+(\.\d+)?|\.\d+)$/;
+	/**
+	* 验证是否为有符号浮点数
+	* @example
+	* ```ts
+	* ValidateUtil.isSignedFloat("-12.34"); // true
+	* ```
+	*/
+	static isSignedFloat(input) {
+		return this._signedFloat.test(input.toString());
+	}
+	static _unsignedFloat = /^\+?(\d+(\.\d+)?|\.\d+)$/;
+	/**
+	* 验证是否为无符号浮点数
+	* @example
+	* ```ts
+	* ValidateUtil.isUnsignedFloat("12.34"); // true
+	* ```
+	*/
+	static isUnsignedFloat(input) {
+		return this._unsignedFloat.test(input.toString());
+	}
+	static _signedInteger = /^[+-]?\d+$/;
+	/**
+	* 验证是否为有符号整数
+	* @example
+	* ```ts
+	* ValidateUtil.isSignedInteger("-12"); // true
+	* ```
+	*/
+	static isSignedInteger(input) {
+		return this._signedInteger.test(input.toString());
+	}
+	static _unsignedInteger = /^\+?\d+$/;
+	/**
+	* 验证是否为无符号整数
+	* @example
+	* ```ts
+	* ValidateUtil.isUnsignedInteger("12"); // true
+	* ```
+	*/
+	static isUnsignedInteger(input) {
+		return this._unsignedInteger.test(input.toString());
+	}
+	static _spaceInclude = /\s/;
+	/**
+	* 验证是否包含空格
+	* @example
+	* ```ts
+	* ValidateUtil.isSpaceInclude("a b"); // true
+	* ```
+	*/
+	static isSpaceInclude(input) {
+		return this._spaceInclude.test(input.toString());
+	}
+	static _spaceStart = /^\s/;
+	/**
+	* 验证是否以空格开头
+	* @example
+	* ```ts
+	* ValidateUtil.isSpaceStart(" abc"); // true
+	* ```
+	*/
+	static isSpaceStart(input) {
+		return this._spaceStart.test(input.toString());
+	}
+	static _spaceEnd = /\s$/;
+	/**
+	* 验证是否以空格结尾
+	* @example
+	* ```ts
+	* ValidateUtil.isSpaceEnd("abc "); // true
+	* ```
+	*/
+	static isSpaceEnd(input) {
+		return this._spaceEnd.test(input.toString());
+	}
+	/**
+	* 验证是否以空格开头或结尾
+	* @example
+	* ```ts
+	* ValidateUtil.isSpaceStartOrEnd(" abc"); // true
+	* ```
+	*/
+	static isSpaceStartOrEnd(input) {
+		return this.isSpaceStart(input) || this.isSpaceEnd(input);
+	}
+};
+//#endregion
+exports.ArrayUtil = ArrayUtil;
+exports.CurrencyUtil = CurrencyUtil;
+exports.DateTimeUtil = DateTimeUtil;
+exports.EnvUtil = EnvUtil;
+exports.FunctionUtil = FunctionUtil;
+exports.MimeUtil = MimeUtil;
+exports.NumberUtil = NumberUtil;
+exports.ObjectUtil = ObjectUtil;
+exports.StringUtil = require_math.StringUtil;
+exports.ThemeUtil = ThemeUtil;
+exports.TreeUtil = TreeUtil;
+exports.TypeUtil = require_math.TypeUtil;
+exports.ValidateUtil = ValidateUtil;