@pawover/kit 0.6.0 → 0.7.0

package/packages/utils/dist/index.d.ts

@@ -1,2740 +0,0 @@
-import { MathJsInstance } from "mathjs";
-import { Except, If, IsAny, Replace, Simplify, Split, Trim, TupleOf, TypedArray, UnionToIntersection, UnionToTuple, ValueOf } from "type-fest";
-import { AnyAsyncFunction, AnyAsyncGeneratorFunction, AnyFunction, AnyGeneratorFunction, AnyObject, PlainObject, TreeLike, TreeLikeOptionalChildren } from "@pawover/kit-types";
-import { Any, List } from "ts-toolbelt";
-import { AnyObject as AnyObject$1 } from "@pawover/types";
-//#region src/array/index.type.d.ts
-type MatchFunction<T, R = unknown> = (row: T, index: number) => R;
-/**
- * `ArrayUtil.zip` / `ArrayUtil.unzip` 的配置项
- * - `truncate`: 为 `true` 时按最短数组截断
- */
-interface ZipOptions {
-  truncate?: boolean | undefined;
-}
-//#endregion
-//#region src/array/arrayUtil.d.ts
-/**
- * 数组工具类
- */
-declare class ArrayUtil {
-  /**
-   * 构造数组
-   * @param candidate 待构造项
-   * @param checkNullish 是否检查 `undefined` 和 `null`，默认为 `true`
-   * @returns 构造后的数组
-   * @example
-   * ```ts
-   * // 重载 1: checkNullish = true (默认)
-   * ArrayUtil.cast(1); // [1]
-   * ArrayUtil.cast(null); // []
-   *
-   * // 重载 2: checkNullish = false
-   * ArrayUtil.cast(null, false); // [null]
-   *
-   * // 通用场景
-   * ArrayUtil.cast([1, 2]); // [1, 2]
-   * ArrayUtil.cast(undefined); // []
-   * ```
-   */
-  static cast<T>(candidate: T | T[] | null | undefined, checkNullish?: true): NonNullable<T>[];
-  static cast<T>(candidate: T | T[] | null | undefined, checkNullish: false): T[];
-  /**
-   * 获取数组第一项
-   *
-   * @param initialList 初始数组
-   * @param fallback 回退值
-   * @returns 数组第一项，如果为空则返回回退值
-   * @example
-   * ```ts
-   * // 重载 1: 无 fallback
-   * ArrayUtil.first([1, 2]); // 1
-   * ArrayUtil.first([]); // undefined
-   *
-   * // 重载 2: 有 fallback
-   * ArrayUtil.first([], 0); // 0
-   * ```
-   */
-  static first<T>(initialList: readonly T[]): T | undefined;
-  static first<T>(initialList: readonly T[], fallback: T): T;
-  /**
-   * 获取数组最后一项
-   *
-   * @param initialList 初始数组
-   * @param fallback 回退值
-   * @returns 数组最后一项，如果为空则返回回退值
-   * @example
-   * ```ts
-   * // 重载 1: 无 fallback
-   * ArrayUtil.last([1, 2, 3]); // 3
-   * ArrayUtil.last([]); // undefined
-   *
-   * // 重载 2: 有 fallback
-   * ArrayUtil.last([], 0); // 0
-   * ```
-   */
-  static last<T>(initialList: readonly T[]): T | undefined;
-  static last<T>(initialList: readonly T[], fallback: T): T;
-  /**
-   * 数组竞选
-   * - 返回在匹配函数的比较条件中获胜的最终项目，适用于更复杂的最小值/最大值计算
-   *
-   * @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<T>(initialList: readonly T[], match: (a: T, b: T, index: number) => T): T | null;
-  /**
-   * 统计数组的项目出现次数
-   * - 通过给定的标识符匹配函数，返回一个对象，其中键是回调函数返回的 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<T, K extends PropertyKey>(initialList: readonly T[], match: MatchFunction<T, K>): Record<string, number>;
-  /**
-   * 获取数组差集
-   * - 返回在 `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<T>(initialList: readonly T[], diffList: readonly T[], match?: (row: T, index: number) => unknown): T[];
-  /**
-   * 获取数组交集
-   * - 返回在 `initialList` 和 `diffList` 中都存在的元素
-   *
-   * @param initialList 初始数组
-   * @param diffList 对比数组
-   * @param match 匹配函数
-   * @returns 交集数组
-   * @example
-   * ```ts
-   * // 重载 1: 按元素本身比较
-   * ArrayUtil.intersection([1, 2], [2, 3]); // [2]
-   *
-   * // 重载 2: 按 match 结果比较
-   * ArrayUtil.intersection([{ id: 1 }, { id: 2 }], [{ id: 2 }], (x) => x.id); // [{ id: 2 }]
-   * ```
-   */
-  static intersection<T>(initialList: readonly T[], diffList: readonly T[]): T[];
-  static intersection<T, D = T>(initialList: readonly T[], diffList: readonly D[], match: MatchFunction<T>): T[];
-  /**
-   * 数组合并
-   * - 如果未提供 `match` 函数，则合并两个数组并去重（Union）
-   * - 如果提供了 `match` 函数，则仅更新 `initialList` 中匹配到的项（Left Join Update），不会追加 `mergeList` 中新增的项
-   *
-   * @param initialList 初始数组
-   * @param mergeList 待合并数组
-   * @param match 匹配函数
-   * @returns 合并后的数组
-   * @example
-   * ```ts
-   * // 重载 1: 基础合并去重
-   * ArrayUtil.merge([1, 2], [2, 3]); // [1, 2, 3]
-   * ArrayUtil.merge([], [1, 2, 3]); // [1, 2, 3]
-   *
-   * // 重载 2: 按条件更新
-   * const source = [{ id: 1, val: "a" }, { id: 2, val: "b" }];
-   * const update = [{ id: 2, val: "new" }, { id: 3, val: "c" }];
-   * ArrayUtil.merge(source, update, (x) => x.id); // [{ id: 1, val: "a" }, { id: 2, val: "new" }] -> id:3 被忽略
-   * ```
-   */
-  static merge<T>(initialList: readonly T[], mergeList: readonly T[]): T[];
-  static merge<T, D = T>(initialList: readonly T[], mergeList: readonly D[], match: MatchFunction<T>): (T | D)[];
-  /**
-   * 数组选择
-   * - 一次性应用 `filter` 和 `map` 操作
-   *
-   * @param initialList 初始数组
-   * @param filter filter 函数
-   * @param mapper map 函数
-   * @returns 处理后的新数组
-   * @example
-   * ```ts
-   * const list = [1, 2, 3, 4];
-   *
-   * // 重载 1: 仅过滤
-   * ArrayUtil.pick(list, (n) => n % 2 === 0); // [2, 4]
-   *
-   * // 重载 2: 过滤 + 映射
-   * ArrayUtil.pick(list, (n) => n % 2 === 0, (n) => n * 2); // [4, 8]
-   * ```
-   */
-  static pick<const T>(initialList: readonly T[], filter: (row: T, index: number) => boolean): T[];
-  static pick<const T, K = T>(initialList: readonly T[], filter: (row: T, index: number) => boolean, mapper: (row: T, index: number) => K): K[];
-  /**
-   * 数组项替换
-   * - 在给定的数组中，替换符合匹配函数结果的项目
-   * - 只替换第一个匹配项
-   *
-   * @param initialList 初始数组
-   * @param newItem 替换项
-   * @param match 匹配函数
-   * @returns 替换后的新数组
-   * @example
-   * ```ts
-   * // 重载 1/2: newItem 与数组元素类型兼容
-   * ArrayUtil.replace([1, 2, 3], 4, (n) => n === 2); // [1, 4, 3]
-   *
-   * // 重载 3: newItem 可扩展为新类型
-   * ArrayUtil.replace([1, 2, 3], "X", (n) => n === 2); // [1, "X", 3]
-   * ```
-   */
-  static replace<const T>(initialList: readonly T[], newItem: T, match: MatchFunction<T, boolean>): T[];
-  static replace<const T, K extends T>(initialList: readonly T[], newItem: K, match: MatchFunction<T, boolean>): T[];
-  static replace<const T, K>(initialList: readonly T[], newItem: K, match: MatchFunction<T, boolean>): (T | K)[];
-  /**
-   * 数组项替换并移动
-   * - 在给定的数组中，替换并移动符合匹配函数结果的项目
-   * - 只替换和移动第一个匹配项
-   * - 未匹配时，根据 `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<const T>(initialList: readonly T[], newItem: T, match: MatchFunction<T, boolean>, position?: "start" | "end" | number): T[];
-  /**
-   * 数组切分
-   * - 将数组以指定的长度切分后，组合在高维数组中
-   *
-   * @param initialList 初始数组
-   * @param size 分割尺寸，默认 `10`
-   * @returns 切分后的二维数组
-   * @example
-   * ```ts
-   * ArrayUtil.split([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]
-   * ```
-   */
-  static split<T>(initialList: readonly T[], size?: number): T[][];
-  /**
-   * 数组分组过滤
-   * - 给定一个数组和一个条件，返回一个由两个数组组成的元组，其中第一个数组包含所有满足条件的项，第二个数组包含所有不满足条件的项
-   *
-   * @param initialList 初始数组
-   * @param match 条件匹配函数
-   * @returns [满足条件的项[], 不满足条件的项[]]
-   * @example
-   * ```ts
-   * ArrayUtil.fork([1, 2, 3, 4], (n) => n % 2 === 0); // [[2, 4], [1, 3]]
-   * ```
-   */
-  static fork<T>(initialList: readonly T[], match: MatchFunction<T, boolean>): [T[], T[]];
-  /**
-   * 数组解压
-   * - `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<T>(arrayList: readonly (readonly T[])[], options?: ZipOptions): T[][];
-  /**
-   * 数组压缩
-   * - 将多个数组的元素按索引组合成元组
-   * - 默认按最长数组补齐 `undefined`
-   *
-   * @param arrays 多个数组
-   * @param options 配置项（`truncate` 为 `true` 时按最短数组截断）
-   * @returns 压缩后的元组数组
-   * @example
-   * ```ts
-   * // 重载 1: 两个数组
-   * ArrayUtil.zip([1, 2], ["a", "b"]); // [[1, "a"], [2, "b"]]
-   * // 长度不一致时默认补齐 undefined
-   * ArrayUtil.zip([1, 2, 3], ["a"]); // [[1, "a"], [2, undefined], [3, undefined]]
-   *
-   * // 重载 2: 三个数组
-   * ArrayUtil.zip([1, 2], ["a", "b"], [true, false]); // [[1, "a", true], [2, "b", false]]
-   *
-   * // 重载 3: 四个数组
-   * ArrayUtil.zip([1], ["a"], [true], ["x"]); // [[1, "a", true, "x"]]
-   *
-   * // 重载 4: 五个数组
-   * ArrayUtil.zip([1], ["a"], [true], ["x"], [9]); // [[1, "a", true, "x", 9]]
-   *
-   * // 重载 5: 空参数
-   * ArrayUtil.zip(); // []
-   *
-   * // 重载 6: 两个数组 + options（truncate: true 截断到最短数组）
-   * ArrayUtil.zip([1, 2, 3], ["a"], { truncate: true }); // [[1, "a"]]
-   *
-   * // 重载 7: 三个数组 + options
-   * ArrayUtil.zip([1, 2], ["a"], [true], { truncate: true }); // [[1, "a", true]]
-   *
-   * // 重载 8: 四个数组 + options
-   * ArrayUtil.zip([1], ["a"], [true], ["x"], { truncate: true }); // [[1, "a", true, "x"]]
-   *
-   * // 重载 9: 五个数组 + options
-   * ArrayUtil.zip([1], ["a"], [true], ["x"], [9], { truncate: true }); // [[1, "a", true, "x", 9]]
-   * ```
-   */
-  static zip<T1, T2, T3, T4, T5>(array1: readonly T1[], array2: readonly T2[], array3: readonly T3[], array4: readonly T4[], array5: readonly T5[], options: ZipOptions): [T1, T2, T3, T4, T5][];
-  static zip<T1, T2, T3, T4>(array1: readonly T1[], array2: readonly T2[], array3: readonly T3[], array4: readonly T4[], options: ZipOptions): [T1, T2, T3, T4][];
-  static zip<T1, T2, T3>(array1: readonly T1[], array2: readonly T2[], array3: readonly T3[], options: ZipOptions): [T1, T2, T3][];
-  static zip<T1, T2>(array1: readonly T1[], array2: readonly T2[], options: ZipOptions): [T1, T2][];
-  static zip<T1, T2, T3, T4, T5>(array1: readonly T1[], array2: readonly T2[], array3: readonly T3[], array4: readonly T4[], array5: readonly T5[]): [T1, T2, T3, T4, T5][];
-  static zip<T1, T2, T3, T4>(array1: readonly T1[], array2: readonly T2[], array3: readonly T3[], array4: readonly T4[]): [T1, T2, T3, T4][];
-  static zip<T1, T2, T3>(array1: readonly T1[], array2: readonly T2[], array3: readonly T3[]): [T1, T2, T3][];
-  static zip<T1, T2>(array1: readonly T1[], array2: readonly T2[]): [T1, T2][];
-  static zip(): [];
-  /**
-   * 数组压缩为对象
-   * - 将键数组和值（数组、函数或静态值）组合成对象
-   *
-   * @param keys 键数组
-   * @param values 值数组、生成值的函数或静态值
-   * @returns 生成的对象
-   * @example
-   * ```ts
-   * // 重载 1: 传值数组
-   * ArrayUtil.zipToObject(["a", "b"], [1, 2]); // { a: 1, b: 2 }
-   *
-   * // 重载 2: 传生成函数
-   * ArrayUtil.zipToObject(["a", "b"], (k, i) => k + i); // { a: "a0", b: "b1" }
-   *
-   * // 重载 3: 传静态值
-   * ArrayUtil.zipToObject(["a", "b"], 1); // { a: 1, b: 1 }
-   * ```
-   */
-  static zipToObject<const K extends PropertyKey, const V>(keys: readonly K[], array: readonly V[]): Record<K, V>;
-  static zipToObject<const K extends PropertyKey, const V>(keys: readonly K[], match: MatchFunction<K, V>): Record<K, V>;
-  static zipToObject<const K extends PropertyKey, const V>(keys: readonly K[], value: V): Record<K, V>;
-}
-//#endregion
-//#region src/currency/index.type.d.ts
-type CurrencyCode = keyof typeof CurrencyUtil.CURRENCY_ENUM;
-type CurrencyLocale = ValueOf<typeof CurrencyUtil.CURRENCY_ENUM>;
-interface FormatterOptions {
-  locales: [CurrencyLocale, CurrencyLocale];
-  currencySign: string;
-  currencySignPosition: "start" | "end";
-  currencyFormatOptions: Intl.NumberFormatOptions;
-}
-//#endregion
-//#region src/currency/currencyUtil.d.ts
-/**
- * 货币工具类
- * - 基于 [`Intl.NumberFormat`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat) 进行本地化格式化
- * - 支持精确小数位处理（依赖 `mathjs`）
- */
-declare class CurrencyUtil {
-  /**
-   * 货币代码到 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 readonly CURRENCY_ENUM: {
-    /** 美元（美国及美元化国家，Locale: 美式英语） → 1,234,567.89 */
-    readonly USD: "en-US";
-    /** 加拿大元（加拿大，Locale: 加拿大英语） → 1,234,567.89 */
-    readonly CAD: "en-CA";
-    /** 墨西哥比索（墨西哥，Locale: 墨西哥西班牙语） → 1,234,567.89 */
-    readonly MXN: "es-MX";
-    /** 巴西雷亚尔（巴西，Locale: 巴西葡萄牙语） → 1.234.567,89 */
-    readonly BRL: "pt-BR";
-    /** 阿根廷比索（阿根廷，Locale: 阿根廷西班牙语） → 1.234.567,89 */
-    readonly ARS: "es-AR";
-    /** 智利比索（智利，Locale: 智利西班牙语） → 1.234.567,89 */
-    readonly CLP: "es-CL";
-    /** 秘鲁新索尔（秘鲁，Locale: 秘鲁西班牙语） → 1,234,567.89 */
-    readonly PEN: "es-PE";
-    /** 哥伦比亚比索（哥伦比亚，Locale: 哥伦比亚西班牙语） → 1.234.567,89 */
-    readonly COP: "es-CO";
-    /** 哥斯达黎加科朗（哥斯达黎加，Locale: 哥斯达黎加西班牙语） → 1 234 567,89（空格千分位） */
-    readonly CRC: "es-CR";
-    /** 人民币（中国，Locale: 简体中文） → 1,234,567.89 */
-    readonly CNY: "zh-CN";
-    /** 港元（中国香港，Locale: 繁体中文+香港） → 1,234,567.89 */
-    readonly HKD: "zh-HK";
-    /** 澳门元（中国澳门，Locale: 繁体中文+澳门） → 1,234,567.89 */
-    readonly MOP: "zh-MO";
-    /** 日元（日本，Locale: 日语） → 1,234,567.89 */
-    readonly JPY: "ja-JP";
-    /** 韩元（韩国，Locale: 韩语） → 1,234,567.89 */
-    readonly KRW: "ko-KR";
-    /** 新加坡元（新加坡，Locale: 英语+新加坡） → 1,234,567.89 */
-    readonly SGD: "en-SG";
-    /** 泰铢（泰国，Locale: 泰语） → 1,234,567.89 */
-    readonly THB: "th-TH";
-    /** 印度卢比（印度，Locale: 英语+印度） → 12,34,567.89（2,2,3 分组） */
-    readonly INR: "en-IN";
-    /** 沙特里亚尔（沙特，Locale: 阿拉伯语+沙特） → ١٬٢٣٤٬٥٦٧٫٨٩（阿拉伯数字） */
-    readonly SAR: "ar-SA";
-    /** 阿联酋迪拉姆（阿联酋，Locale: 阿拉伯语+阿联酋） → 1,234,567.89 */
-    readonly AED: "ar-AE";
-    /** 印尼盾（印尼，Locale: 印尼语） → 1.234.567,89 */
-    readonly IDR: "id-ID";
-    /** 马来西亚林吉特（马来西亚，Locale: 马来语） → 1,234,567.89 */
-    readonly MYR: "ms-MY";
-    /** 越南盾（越南，Locale: 越南语） → 1.234.567,89 */
-    readonly VND: "vi-VN";
-    /** 菲律宾比索（菲律宾，Locale: 英语+菲律宾） → 1,234,567.89 */
-    readonly PHP: "en-PH";
-    /** 巴基斯坦卢比（巴基斯坦，Locale: 英语+巴基斯坦） → 1,234,567.89 */
-    readonly PKR: "en-PK";
-    /** 新台币（中国台湾地区，Locale: 繁体中文+台湾） → 1,234,567.89 */
-    readonly TWD: "zh-TW";
-    /** 欧元（德国，Locale: 德语+德国，代表欧元区） → 1.234.567,89 */
-    readonly EUR: "de-DE";
-    /** 英镑（英国，Locale: 英式英语） → 1,234,567.89 */
-    readonly GBP: "en-GB";
-    /** 瑞士法郎（瑞士，Locale: 德语+瑞士） → 1'234'567.89 */
-    readonly CHF: "de-CH";
-    /** 瑞典克朗（瑞典，Locale: 瑞典语） → 1 234 567,89（空格千分位） */
-    readonly SEK: "sv-SE";
-    /** 挪威克朗（挪威，Locale: 挪威语） → 1 234 567,89（空格千分位） */
-    readonly NOK: "no-NO";
-    /** 丹麦克朗（丹麦，Locale: 丹麦语） → 1.234.567,89 */
-    readonly DKK: "da-DK";
-    /** 波兰兹罗提（波兰，Locale: 波兰语） → 1 234 567,89（空格千分位） */
-    readonly PLN: "pl-PL";
-    /** 捷克克朗（捷克，Locale: 捷克语） → 1 234 567,89（空格千分位） */
-    readonly CZK: "cs-CZ";
-    /** 匈牙利福林（匈牙利，Locale: 匈牙利语） → 1 234 567,89（空格千分位） */
-    readonly HUF: "hu-HU";
-    /** 俄罗斯卢布（俄罗斯，Locale: 俄语） → 1 234 567,89（空格千分位） */
-    readonly RUB: "ru-RU";
-    /** 罗马尼亚列伊（罗马尼亚，Locale: 罗马尼亚语） → 1.234.567,89 */
-    readonly RON: "ro-RO";
-    /** 乌克兰格里夫纳（乌克兰，Locale: 乌克兰语） → 1 234 567,89（空格千分位） */
-    readonly UAH: "uk-UA";
-    /** 澳大利亚元（澳大利亚，Locale: 澳大利亚英语） → 1,234,567.89 */
-    readonly AUD: "en-AU";
-    /** 新西兰元（新西兰，Locale: 新西兰英语） → 1,234,567.89 */
-    readonly NZD: "en-NZ";
-    /** 南非兰特（南非，Locale: 英语+南非） → 1 234 567,89（空格千分位） */
-    readonly ZAR: "en-ZA";
-    /** 埃及镑（埃及，Locale: 阿拉伯语+埃及） → ١٬٢٣٤٬٥٦٧٫٨٩（阿拉伯数字） */
-    readonly EGP: "ar-EG";
-    /** 土耳其里拉（土耳其，Locale: 土耳其语） → 1.234.567,89 */
-    readonly TRY: "tr-TR";
-    /** 以色列新谢克尔（以色列，Locale: 希伯来语） → 1,234,567.89 */
-    readonly ILS: "he-IL";
-    /** 摩洛哥迪拉姆（摩洛哥，Locale: 阿拉伯语+摩洛哥） → 1.234.567,89 */
-    readonly MAD: "ar-MA";
-    /** 科威特第纳尔（科威特，Locale: 阿拉伯语+科威特） → ١٬٢٣٤٬٥٦٧٫٨٩（阿拉伯数字） */
-    readonly KWD: "ar-KW";
-    /** 卡塔尔里亚尔（卡塔尔，Locale: 阿拉伯语+卡塔尔） → ١٬٢٣٤٬٥٦٧٫٨٩（阿拉伯数字） */
-    readonly QAR: "ar-QA";
-    /** 尼日利亚奈拉（尼日利亚，Locale: 英语+尼日利亚） → 1,234,567.89 */
-    readonly NGN: "en-NG";
-    /** 太平洋法郎（法属波利尼西亚，Locale: 法语+太平洋） → 1[U+202F]234[U+202F]567,89（窄空格千分位） */
-    readonly XPF: "fr-PF";
-  };
-  /**
-   * 货币格式化
-   * - 使用 `Intl.NumberFormat` 进行本地化数字格式化
-   * - 支持自定义货币符号及位置（首/尾）
-   * - 当值为 `null` 或 `undefined` 时返回 `null`
-   *
-   * @param value 待格式化的数值
-   * @param options 格式化选项
-   * @param options.locales locale 元组，同时指定格式化语言和货币所属地区
-   * @param options.currencySign 货币符号（如 `¥`、`$`、`€`）
-   * @param options.currencySignPosition 货币符号位置
-   * @param options.currencyFormatOptions `Intl.NumberFormatOptions` 格式化选项
-   * @returns 格式化后的货币字符串，无效输入返回 `null`
-   *
-   * @example
-   * ```ts
-   * import { CurrencyUtil } from "@pawover/kit/utils";
-   *
-   * // 重载 1: 有效数值
-   * CurrencyUtil.currencyFormatter(1234.56, {
-   *   locales: [CurrencyUtil.CURRENCY_ENUM.CNY, CurrencyUtil.CURRENCY_ENUM.USD],
-   *   currencySign: "¥",
-   *   currencySignPosition: "start",
-   *   currencyFormatOptions: { style: "currency", currency: "CNY" },
-   * }); // "¥ 1,234.56"
-   *
-   * // 重载 2: null / undefined
-   * CurrencyUtil.currencyFormatter(null, options); // null
-   * CurrencyUtil.currencyFormatter(undefined, options); // null
-   * ```
-   */
-  static currencyFormatter(value: string | number, options: FormatterOptions): string | null;
-  static currencyFormatter(value: string | number | null | undefined, options: FormatterOptions): string | null;
-  /**
-   * 将任意数值转换为精确的十进制值
-   * - 基于 `mathjs` 的 `bignumber` 处理，避免浮点数精度问题
-   * - 当值为 `null` 或 `undefined` 时返回 `null`
-   *
-   * @param mathJsInstance `mathjs` 实例
-   * @param value 待转换的数值
-   * @param precision 小数精度位数
-   * @param stringMode 是否返回字符串类型，默认 `true`
-   * @returns 精确的十进制值，无效输入返回 `null`
-   *
-   * @example
-   * ```ts
-   * import { create, all } from "mathjs";
-   * import { CurrencyUtil } from "@pawover/kit/utils";
-   *
-   * const math = create(all);
-   *
-   * // 重载 1: 有效值 + stringMode = true（默认）
-   * CurrencyUtil.toRealValue(math, "0.1"); // "0.1"
-   * CurrencyUtil.toRealValue(math, 0.1 + 0.2, 2); // "0.30"
-   *
-   * // 重载 2: stringMode = false → number
-   * CurrencyUtil.toRealValue(math, "0.1", undefined, false); // 0.1
-   *
-   * // 重载 3: null / undefined（含 stringMode 显式组合）
-   * CurrencyUtil.toRealValue(math, null); // null
-   * CurrencyUtil.toRealValue(math, undefined); // null
-   * CurrencyUtil.toRealValue(math, null, 2, true); // null
-   * CurrencyUtil.toRealValue(math, null, 2, false); // null
-   * ```
-   */
-  static toRealValue(mathJsInstance: MathJsInstance, value: string | number, precision: number | undefined, stringMode: true): string;
-  static toRealValue(mathJsInstance: MathJsInstance, value: string | number, precision: number | undefined, stringMode: false): number;
-  static toRealValue(mathJsInstance: MathJsInstance, value: string | number, precision?: number | undefined): string;
-  static toRealValue(mathJsInstance: MathJsInstance, value: string | number | null | undefined, precision: number | undefined, stringMode: true): string | null;
-  static toRealValue(mathJsInstance: MathJsInstance, value: string | number | null | undefined, precision: number | undefined, stringMode: false): number | null;
-  static toRealValue(mathJsInstance: MathJsInstance, value: string | number | null | undefined, precision?: number | undefined): string | null;
-}
-//#endregion
-//#region src/dateTime/dateTimeUtil.d.ts
-/**
- * 日期工具类
- */
-declare class DateTimeUtil {
-  /**
-   * 每秒的毫秒数
-   * @example
-   * ```ts
-   * DateTimeUtil.MILLISECONDS_PER_SECOND; // 1000
-   * ```
-   */
-  static readonly MILLISECONDS_PER_SECOND: number;
-  /**
-   * 每分钟的秒数
-   * @example
-   * ```ts
-   * DateTimeUtil.SECOND_PER_MINUTE; // 60
-   * ```
-   */
-  static readonly SECOND_PER_MINUTE: number;
-  /**
-   * 每小时的分钟数
-   * @example
-   * ```ts
-   * DateTimeUtil.MINUTE_PER_HOUR; // 60
-   * ```
-   */
-  static readonly MINUTE_PER_HOUR: number;
-  /**
-   * 每小时的秒数
-   * @example
-   * ```ts
-   * DateTimeUtil.SECOND_PER_HOUR; // 3600
-   * ```
-   */
-  static readonly SECOND_PER_HOUR: number;
-  /**
-   * 每天小时数
-   * @example
-   * ```ts
-   * DateTimeUtil.HOUR_PER_DAY; // 24
-   * ```
-   */
-  static readonly HOUR_PER_DAY: number;
-  /**
-   * 每天秒数
-   * @example
-   * ```ts
-   * DateTimeUtil.SECOND_PER_DAY; // 86400
-   * ```
-   */
-  static readonly SECOND_PER_DAY: number;
-  /**
-   * 每周天数
-   * @example
-   * ```ts
-   * DateTimeUtil.DAY_PER_WEEK; // 7
-   * ```
-   */
-  static readonly DAY_PER_WEEK: number;
-  /**
-   * 每月天数
-   * @example
-   * ```ts
-   * DateTimeUtil.DAY_PER_MONTH; // 30
-   * ```
-   */
-  static readonly DAY_PER_MONTH: number;
-  /**
-   * 每年天数
-   * @example
-   * ```ts
-   * DateTimeUtil.DAY_PER_YEAR; // 365
-   * ```
-   */
-  static readonly DAY_PER_YEAR: number;
-  /**
-   * 每年月数
-   * @example
-   * ```ts
-   * DateTimeUtil.MONTH_PER_YEAR; // 12
-   * ```
-   */
-  static readonly MONTH_PER_YEAR: number;
-  /**
-   * 每年平均周
-   * @example
-   * ```ts
-   * DateTimeUtil.WEEK_PER_YEAR; // 52
-   * ```
-   */
-  static readonly WEEK_PER_YEAR: number;
-  /**
-   * 每月平均周
-   * @example
-   * ```ts
-   * DateTimeUtil.WEEK_PER_MONTH; // 4
-   * ```
-   */
-  static readonly WEEK_PER_MONTH: number;
-  /**
-   * 常用时间格式模板集合
-   *
-   * @example
-   * ```ts
-   * DateTimeUtil.FORMAT.ISO_DATE; // "yyyy-MM-dd"
-   * DateTimeUtil.FORMAT.CN_DATE_TIME; // "yyyy年MM月dd日 HH时mm分ss秒"
-   * ```
-   */
-  static readonly FORMAT: {
-    readonly ISO_DATE: "yyyy-MM-dd";
-    readonly ISO_TIME: "HH:mm:ss";
-    readonly ISO_DATE_TIME: "yyyy-MM-dd HH:mm:ss";
-    readonly ISO_DATE_TIME_MS: "yyyy-MM-dd HH:mm:ss.SSS";
-    readonly ISO_DATETIME_TZ: "yyyy-MM-dd'T'HH:mm:ssXXX";
-    readonly ISO_DATETIME_TZ_MS: "yyyy-MM-dd'T'HH:mm:ss.SSSXXX";
-    readonly US_DATE: "MM/dd/yyyy";
-    readonly US_DATE_TIME: "MM/dd/yyyy HH:mm:ss";
-    readonly US_DATE_SHORT_YEAR: "MM/dd/yy";
-    readonly EU_DATE: "dd/MM/yyyy";
-    readonly EU_DATE_TIME: "dd/MM/yyyy HH:mm:ss";
-    readonly CN_DATE: "yyyy年MM月dd日";
-    readonly CN_DATE_TIME: "yyyy年MM月dd日 HH时mm分ss秒";
-    readonly CN_DATE_WEEKDAY: "yyyy年MM月dd日 EEE";
-    readonly CN_WEEKDAY_FULL: "EEEE";
-    readonly SHORT_DATE: "yy-MM-dd";
-    readonly SHORT_DATE_SLASH: "yy/MM/dd";
-    readonly MONTH_DAY: "MM-dd";
-    readonly MONTH_DAY_CN: "MM月dd日";
-    readonly DATE_WITH_WEEKDAY_SHORT: "yyyy-MM-dd (EEE)";
-    readonly DATE_WITH_WEEKDAY_FULL: "yyyy-MM-dd (EEEE)";
-    readonly TIME_24: "HH:mm:ss";
-    readonly TIME_24_NO_SEC: "HH:mm";
-    readonly TIME_12: "hh:mm:ss a";
-    readonly TIME_12_NO_SEC: "hh:mm a";
-    readonly TIMESTAMP: "yyyyMMddHHmmss";
-    readonly TIMESTAMP_MS: "yyyyMMddHHmmssSSS";
-    readonly RFC2822: "EEE, dd MMM yyyy HH:mm:ss xxx";
-    readonly READABLE_DATE: "MMM dd, yyyy";
-    readonly READABLE_DATE_TIME: "MMM dd, yyyy HH:mm";
-    readonly COMPACT_DATETIME: "yyyyMMdd_HHmmss";
-  };
-  /**
-   * 获取当前时区信息
-   *
-   * @returns 时区信息对象 (UTC偏移和时区名称)
-   * @example
-   * ```ts
-   * DateTimeUtil.getTimeZone(); // { UTC: "UTC+8", timeZone: "Asia/Shanghai" }
-   * ```
-   */
-  static getTimeZone(): {
-    UTC: string;
-    timeZone: string;
-  };
-}
-//#endregion
-//#region src/env/envUtil.d.ts
-/**
- * 环境检查工具类
- * - ⚠️ `isBrowser` / `isWebWorker` / `isReactNative` 基于静态字段判定，在**模块加载时**求值一次。
- *   SSR 场景下若在 Node 端 import（此时 `window` 未定义），结果会永久为 `false`，不会随运行时环境变化重算。
- */
-declare class EnvUtil {
-  private static readonly _isBrowser;
-  private static readonly _isWebWorker;
-  private static readonly _isReactNative;
-  /**
-   * 检测是否处于浏览器环境
-   *
-   * @returns 是否为浏览器环境
-   * @example
-   * ```ts
-   * EnvUtil.isBrowser(); // true: 浏览器, false: Node.js
-   * ```
-   */
-  static isBrowser(): boolean;
-  /**
-   * 检测是否处于 Web Worker 环境
-   *
-   * @returns 是否为 Web Worker 环境
-   * @example
-   * ```ts
-   * EnvUtil.isWebWorker(); // true: Worker, false: 主线程/Node.js
-   * ```
-   */
-  static isWebWorker(): boolean;
-  /**
-   * 检测是否处于 React Native 环境
-   *
-   * @returns 是否为 React Native 环境
-   * @example
-   * ```ts
-   * EnvUtil.isReactNative(); // true: React Native, false: Web/Node.js
-   * ```
-   */
-  static isReactNative(): boolean;
-  /**
-   * 检查是否在 iframe 环境中
-   *
-   * @returns 是否在 iframe 中
-   * @example
-   * ```ts
-   * EnvUtil.isIframe(); // true: 当前页面在 iframe 中
-   * ```
-   */
-  static isIframe(): boolean;
-  /**
-   * 检测当前设备是否为桌面设备
-   *
-   * @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?: number, minScreenSize?: number, dpi?: number): boolean;
-  /**
-   * 检测当前设备是否为 Windows 桌面设备
-   *
-   * @param minWidth - 桌面设备最小宽度（默认 1200px）
-   * @param minScreenSize - 桌面设备最小屏幕尺寸（默认 10英寸）
-   * @param dpi - 标准 DPI 基准（默认 160）
-   * @returns 是否为 Windows 桌面设备
-   * @example
-   * ```ts
-   * // UA contains Windows
-   * EnvUtil.isWindowsDesktop(); // true
-   * ```
-   */
-  static isWindowsDesktop(minWidth?: number, minScreenSize?: number, dpi?: number): boolean;
-  /**
-   * 检测当前设备是否为 macOS 桌面设备
-   *
-   * @param minWidth - 桌面设备最小宽度（默认 1200px）
-   * @param minScreenSize - 桌面设备最小屏幕尺寸（默认 10英寸）
-   * @param dpi - 标准 DPI 基准（默认 160）
-   * @returns 是否为 macOS 桌面设备
-   * @example
-   * ```ts
-   * // UA contains Macintosh
-   * EnvUtil.isMacOSDesktop(); // true
-   * ```
-   */
-  static isMacOSDesktop(minWidth?: number, minScreenSize?: number, dpi?: number): boolean;
-  /**
-   * 检测当前设备是否为移动设备
-   *
-   * @param maxWidth - 移动设备最大宽度（默认 768px）
-   * @param dpi - 标准 DPI 基准（默认 160）
-   * @returns 是否为移动设备
-   * @example
-   * ```ts
-   * // 假设 window.innerWidth = 500
-   * EnvUtil.isMobile(); // true
-   * ```
-   */
-  static isMobile(maxWidth?: number, dpi?: number): boolean;
-  /**
-   * 检测当前设备是否为IOS移动设备
-   *
-   * @param maxWidth - 移动设备最大宽度（默认 768px）
-   * @param dpi - 标准 DPI 基准（默认 160）
-   * @returns 是否为 iOS 移动设备 (iPhone/iPod)
-   * @example
-   * ```ts
-   * // UA contains iPhone
-   * EnvUtil.isIOSMobile(); // true
-   * ```
-   */
-  static isIOSMobile(maxWidth?: number, dpi?: number): boolean;
-  /**
-   * 检测当前设备是否为平板
-   *
-   * @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?: number, maxWidth?: number, dpi?: number): boolean;
-}
-//#endregion
-//#region src/function/functionUtil.d.ts
-/**
- * 函数工具类
- */
-declare class FunctionUtil {
-  /**
-   *将 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<T, U = Error>(promise: Readonly<Promise<T>>, errorExt?: PlainObject): Promise<[U, undefined] | [null, T]>;
-  /**
-   * 将 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<T = unknown>(args: IArguments, start?: number | undefined): T[];
-  /**
-   * 将同步或异步函数统一包装为 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<T>(fn: () => T | Promise<T>): Promise<T>;
-}
-//#endregion
-//#region src/mime/mimeUtil.d.ts
-/**
- * MIME 工具类
- */
-declare class MimeUtil {
-  /**
-   * 文件类型 MIME 常量
-   * - 每个类型对应具体的文件扩展名
-   */
-  static readonly FILE_MIME: {
-    /** 普通文本文件（.txt） */
-    readonly TEXT: "text/plain";
-    /** 超文本标记语言文档（.html/.htm） */
-    readonly HTML: "text/html";
-    /** 层叠样式表文件（.css） */
-    readonly CSS: "text/css";
-    /** 逗号分隔值文件/表格数据（.csv） */
-    readonly CSV: "text/csv";
-    /** 制表符分隔值文件（.tsv） */
-    readonly TSV: "text/tab-separated-values";
-    /** XML 文档（.xml） */
-    readonly XML: "application/xml";
-    /** XML 文档/兼容值 */
-    readonly XML_LEGACY: "text/xml";
-    /** XHTML 文档（.xhtml/.xht） */
-    readonly XHTML: "application/xhtml+xml";
-    /** JavaScript 文件（.js） */
-    readonly JS: "text/javascript";
-    /** TypeScript 文件（.ts） */
-    readonly TS: "text/typescript";
-    /** Python 文件（.py） */
-    readonly PY: "text/x-python";
-    /** Shell 脚本 (.sh) */
-    readonly SH: "text/x-sh";
-    /** C 语言源文件（.c） */
-    readonly C: "text/x-c";
-    /** C++ 源文件（.cpp/.cc/.cxx） */
-    readonly CPP: "text/x-c++";
-    /** C# 源文件（.cs） */
-    readonly CSHARP: "text/x-csharp";
-    /** Java 源文件（.java） */
-    readonly JAVA: "text/x-java";
-    /** Go 源文件（.go） */
-    readonly GO: "text/x-go";
-    /** Rust 源文件（.rs） */
-    readonly RUST: "text/x-rust";
-    /** PHP 文件（.php） */
-    readonly PHP: "text/x-php";
-    /** Ruby 文件（.rb） */
-    readonly RUBY: "text/x-ruby";
-    /** Swift 源文件（.swift） */
-    readonly SWIFT: "text/x-swift";
-    /** YAML 文档（.yaml/.yml） */
-    readonly YAML: "application/yaml";
-    /** YAML 文档/兼容值 */
-    readonly YAML_LEGACY: "text/vnd.yaml";
-    /** TOML 文档（.toml） */
-    readonly TOML: "application/toml";
-    /** TOML 文档/兼容值 */
-    readonly TOML_LEGACY: "text/x-toml";
-    /** SQL 脚本（.sql） */
-    readonly SQL: "application/sql";
-    /** SQL 脚本/兼容值 */
-    readonly SQL_LEGACY: "text/x-sql";
-    /** Markdown 格式文档（.md/.markdown） */
-    readonly MARKDOWN: "text/markdown";
-    /** 富文本格式文档（.rtf） */
-    readonly RTF: "application/rtf";
-    /** iCalendar 日历格式（.ics） */
-    readonly CALENDAR: "text/calendar";
-    /** JPEG 图像（.jpg/.jpeg） */
-    readonly JPEG: "image/jpeg";
-    /** JPG 图像（JPEG 别名，.jpg） */
-    readonly JPG: "image/jpeg";
-    /** PNG 图像/无损压缩，支持透明（.png） */
-    readonly PNG: "image/png";
-    /** GIF 图像/支持动画（.gif） */
-    readonly GIF: "image/gif";
-    /** Windows 位图（.bmp） */
-    readonly BMP: "image/bmp";
-    /** SVG 向量图形（.svg） */
-    readonly SVG: "image/svg+xml";
-    /** APNG 动态图像（.apng） */
-    readonly APNG: "image/apng";
-    /** AVIF 图像/高效压缩（.avif） */
-    readonly AVIF: "image/avif";
-    /** 图标文件格式（.ico） */
-    readonly ICO: "image/vnd.microsoft.icon";
-    /** 图标文件格式/兼容值（.ico） */
-    readonly ICO_LEGACY: "image/x-icon";
-    /** WebP 图像/高效压缩（.webp） */
-    readonly WEBP: "image/webp";
-    /** TIFF 图像（.tif/.tiff） */
-    readonly TIFF: "image/tiff";
-    /** HEIC 图像/高效编码（.heic） */
-    readonly HEIC: "image/heic";
-    /** HEIF 图像/高效编码（.heif） */
-    readonly HEIF: "image/heif";
-    /** Adobe Photoshop 文件（.psd） */
-    readonly PSD: "image/vnd.adobe.photoshop";
-    /** MP3 音频（.mp3） */
-    readonly MP3: "audio/mpeg";
-    /** AAC 音频（.aac） */
-    readonly AAC: "audio/aac";
-    /** MIDI 音乐文件（.mid/.midi） */
-    readonly MIDI: "audio/midi";
-    /** OGG 音频（.oga） */
-    readonly OGG_AUDIO: "audio/ogg";
-    /** Opus 音频（.opus） */
-    readonly OPUS: "audio/opus";
-    /** FLAC 无损音频（.flac） */
-    readonly FLAC: "audio/flac";
-    /** WAV 音频（.wav） */
-    readonly WAV: "audio/wav";
-    /** WebM 音频（.weba） */
-    readonly WEBM_AUDIO: "audio/webm";
-    /** RealAudio 音频（.ra/.ram） */
-    readonly REAL_AUDIO: "audio/x-pn-realaudio";
-    /** MP4 视频（.mp4） */
-    readonly MP4: "video/mp4";
-    /** MPEG 视频（.mpeg/.mpg） */
-    readonly MPEG: "video/mpeg";
-    /** OGG 视频（.ogv） */
-    readonly OGG_VIDEO: "video/ogg";
-    /** AVI 视频（.avi） */
-    readonly AVI: "video/x-msvideo";
-    /** 3GPP 视频（.3gp） */
-    readonly THREE_GPP: "video/3gpp";
-    /** 3GPP2 视频（.3g2） */
-    readonly THREE_GPP2: "video/3gpp2";
-    /** WebM 视频（.webm） */
-    readonly WEBM: "video/webm";
-    /** Matroska 视频（.mkv） */
-    readonly MKV: "video/x-matroska";
-    /** Matroska 音频（.mka） */
-    readonly MKA: "audio/x-matroska";
-    /** QuickTime 视频（.mov） */
-    readonly QUICKTIME: "video/quicktime";
-    /** PDF 文档（.pdf） */
-    readonly PDF: "application/pdf";
-    /** Word 97-2003 文档（.doc） */
-    readonly DOC: "application/msword";
-    /** Word 2007+ 文档（.docx） */
-    readonly DOCX: "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
-    /** Excel 2007+ 工作簿（.xlsx） */
-    readonly XLSX: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
-    /** 启用宏的Excel工作簿（.xlsm） */
-    readonly XLSM: "application/vnd.ms-excel.sheet.macroEnabled.12";
-    /** Excel模板文件（.xltx） */
-    readonly XLTX: "application/vnd.openxmlformats-officedocument.spreadsheetml.template";
-    /** PowerPoint 2007+ 演示文稿（.pptx） */
-    readonly PPTX: "application/vnd.openxmlformats-officedocument.presentationml.presentation";
-    /** PowerPoint 97-2003 演示文稿（.ppt） */
-    readonly PPT: "application/vnd.ms-powerpoint";
-    /** OpenDocument 文本文档（.odt） */
-    readonly ODT: "application/vnd.oasis.opendocument.text";
-    /** OpenDocument 表格文档（.ods） */
-    readonly ODS: "application/vnd.oasis.opendocument.spreadsheet";
-    /** OpenDocument 演示文稿（.odp） */
-    readonly ODP: "application/vnd.oasis.opendocument.presentation";
-    /** EPUB 电子书（.epub） */
-    readonly EPUB: "application/epub+zip";
-    /** Kindle 电子书（.azw） */
-    readonly AZW: "application/vnd.amazon.ebook";
-    /** ZIP 压缩文件（.zip） */
-    readonly ZIP: "application/zip";
-    /** GZIP 压缩文件（.gz） */
-    readonly GZIP: "application/gzip";
-    /** TAR 归档文件（.tar） */
-    readonly TAR: "application/x-tar";
-    /** BZip 归档（.bz） */
-    readonly BZIP: "application/x-bzip";
-    /** BZip2 归档（.bz2） */
-    readonly BZIP2: "application/x-bzip2";
-    /** 7-Zip 压缩文件（.7z） */
-    readonly SEVEN_Z: "application/x-7z-compressed";
-    /** RAR 压缩文件（.rar） */
-    readonly RAR: "application/vnd.rar";
-    /** XZ 压缩文件（.xz） */
-    readonly XZ: "application/x-xz";
-    /** Zstandard 压缩文件（.zst） */
-    readonly ZSTD: "application/zstd";
-    /** ISO 光盘镜像（.iso） */
-    readonly ISO9660_IMAGE: "application/x-iso9660-image";
-    /** JSON 数据格式（.json） */
-    readonly JSON: "application/json";
-    /** JSON-LD 格式（.jsonld） */
-    readonly LD_JSON: "application/ld+json";
-    /** Web App Manifest（.webmanifest） */
-    readonly MANIFEST: "application/manifest+json";
-    /** Java 归档文件（.jar） */
-    readonly JAR: "application/java-archive";
-    /** WebAssembly 二进制指令格式（.wasm） */
-    readonly WASM: "application/wasm";
-    /** MS 嵌入式 OpenType 字体（.eot） */
-    readonly EOT: "application/vnd.ms-fontobject";
-    /** OpenType 字体（.otf） */
-    readonly OTF: "font/otf";
-    /** WOFF 字体（.woff） */
-    readonly WOFF: "font/woff";
-    /** WOFF2 字体（.woff2） */
-    readonly WOFF2: "font/woff2";
-    /** TrueType 字体（.ttf） */
-    readonly TTF: "font/ttf";
-    /** Excel 97-2003 工作簿（.xls） */
-    readonly XLS: "application/vnd.ms-excel";
-    /** Microsoft XPS 文档（.xps） */
-    readonly XPS: "application/vnd.ms-xpsdocument";
-    /** Word 启用宏文档（.docm） */
-    readonly DOCM: "application/vnd.ms-word.document.macroEnabled.12";
-  };
-  /**
-   * 协议/内容类型 MIME 常量
-   * - 用于 HTTP 请求/响应内容协商，无对应文件扩展名
-   */
-  static readonly PROTOCOL_MIME: {
-    /** 通用二进制数据流 */
-    readonly OCTET_STREAM: "application/octet-stream";
-    /** URL 编码表单 */
-    readonly FORM_URLENCODED: "application/x-www-form-urlencoded";
-    /** multipart 表单 */
-    readonly FORM_DATA: "multipart/form-data";
-    /** Server-Sent Events 数据流 */
-    readonly EVENT_STREAM: "text/event-stream";
-    /** 问题详情 JSON（RFC 9457） */
-    readonly PROBLEM_JSON: "application/problem+json";
-    /** JSON Patch（RFC 6902） */
-    readonly JSON_PATCH: "application/json-patch+json";
-    /** JSON Merge Patch（RFC 7386） */
-    readonly 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: string): readonly [string, ...string[]] | undefined;
-  /**
-   * 根据 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: string): readonly [string, ...string[]] | undefined;
-}
-//#endregion
-//#region src/number/numberUtil.d.ts
-/**
- * 数字工具类
- */
-declare class NumberUtil {
-  /**
-   * 数字区间检查函数
-   *
-   * @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: number, interval: [number, number], includeLeft?: boolean, includeRight?: boolean): boolean;
-}
-//#endregion
-//#region src/object/index.type.d.ts
-type Range<Start extends number, End extends number> = Exclude<keyof TupleOf<End>, keyof TupleOf<Start>>;
-type AnyArray<A = any> = readonly A[];
-type TupleToEntries<A extends readonly unknown[]> = If<IsAny<A>, unknown, { [Key in keyof A]: [Key, A[Key]]; }>;
-type Groups<L extends AnyArray, LN extends AnyArray = [], D extends number[] = []> = D["length"] extends 40 ? LN : {
-  0: Groups<List.Drop<L, 1>, List.Append<LN, [`${LN["length"]}`, List.Take<L, 1>]>, [...D, 0]>;
-  1: LN;
-}[Any.Extends<L, AnyArray<never>>];
-type TupleToGroups<L extends AnyArray> = Groups<L> extends (infer X) ? Any.Cast<X, AnyArray> : never;
-type Crush<T> = T extends readonly (infer U)[] ? Record<string, U extends object ? unknown : U> : Simplify<UnionToIntersection<keyof T extends (infer Prop) ? Prop extends keyof T ? T[Prop] extends (infer Value) ? ([Extract<Value, object>] extends [never] ? never : Record<string, unknown>) | ([Exclude<Value, object>] extends [never] ? never : [Extract<Value, object>] extends [never] ? { [P in Prop]: Value; } : Record<string, unknown>) : never : never : never>>;
-type IntersectOf<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-type ComputeRaw<A> = A extends AnyFunction ? A : { [K in keyof A]: A[K]; } & unknown;
-type _Invert<O extends Record<PropertyKey, PropertyKey>> = ComputeRaw<IntersectOf<{ [K in keyof O]: Record<O[K], K>; }[keyof O]>>;
-type Invert<O extends Record<keyof O, PropertyKey>> = O extends unknown ? _Invert<O> : never;
-//#endregion
-//#region src/object/objectUtil.d.ts
-/**
- * 对象工具类
- */
-declare class ObjectUtil {
-  /**
-   * 返回对象可枚举属性和方法的名称
-   * - `Object.keys` 始终返回 `string[]` 类型，此函数可以返回具体类型
-   *
-   * @param value 对象
-   * @returns 键数组
-   * @example
-   * ```ts
-   * // 重载 1: string
-   * ObjectUtil.keys("abc"); // ["0", "1", "2"]
-   *
-   * // 重载 2: ArrayLike
-   * ObjectUtil.keys([10, 20]); // ["0", "1"]
-   *
-   * // 重载 3: PlainObject
-   * ObjectUtil.keys({ a: 1, b: 2 }); // ["a", "b"]
-   *
-   * // 重载 4: AnyObject
-   * const anyObj = { x: 1, y: 2 } as Record<string, unknown>;
-   * ObjectUtil.keys(anyObj); // ["x", "y"]
-   * ```
-   */
-  static keys<const S extends string>(string: S): UnionToTuple<Range<0, Split<S, "">["length"]>>;
-  static keys<const A extends ArrayLike<unknown>>(array: A): UnionToTuple<Range<0, A["length"]>>;
-  static keys<O extends PlainObject>(plainObject: O): `${Extract<keyof O, string | number>}`[];
-  static keys<O extends AnyObject>(anyObject: O): `${Extract<keyof O, string | number>}`[];
-  /**
-   * 返回对象可枚举属性的值的数组
-   *
-   * @param value 对象
-   * @returns 值数组
-   * @example
-   * ```ts
-   * // 重载 1: string
-   * ObjectUtil.values("abc"); // ["a", "b", "c"]
-   *
-   * // 重载 2: ArrayLike
-   * ObjectUtil.values([10, 20]); // [10, 20]
-   *
-   * // 重载 3: PlainObject
-   * ObjectUtil.values({ a: 1, b: 2 }); // [1, 2]
-   *
-   * // 重载 4: AnyObject
-   * const anyObj = { x: 1, y: 2 } as Record<string, unknown>;
-   * ObjectUtil.values(anyObj); // [1, 2]
-   * ```
-   */
-  static values<S extends string>(string: S): Split<S, "">;
-  static values<A extends ArrayLike<unknown>>(array: A): A;
-  static values<O extends PlainObject>(plainObject: O): O[keyof O][];
-  static values<O extends AnyObject>(anyObject: O): O[keyof O][];
-  /**
-   * 返回对象的可枚举属性的键/值数组
-   *
-   * @param value 对象
-   * @returns 键值对数组
-   * @example
-   * ```ts
-   * // 重载 1: string
-   * ObjectUtil.entries("ab"); // [["0", "a"], ["1", "b"]]
-   *
-   * // 重载 2: readonly array
-   * ObjectUtil.entries([10, 20] as const); // [["0", 10], ["1", 20]]
-   *
-   * // 重载 3: PlainObject
-   * ObjectUtil.entries({ a: 1 }); // [["a", 1]]
-   *
-   * // 重载 4: AnyObject
-   * const anyObj = { x: 1 } as Record<string, unknown>;
-   * ObjectUtil.entries(anyObj); // [["x", 1]]
-   * ```
-   */
-  static entries<const S extends string>(string: S): TupleToEntries<Split<S, "">>;
-  static entries<const A extends readonly unknown[]>(array: A): TupleToGroups<A>;
-  static entries<const O extends PlainObject>(plainObject: O): [`${keyof Except<O, symbol>}`, O[keyof Except<O, symbol>]][];
-  static entries<const O extends AnyObject>(anyObject: O): [`${keyof Except<O, symbol>}`, O[keyof Except<O, symbol>]][];
-  /**
-   * 映射对象条目
-   * - 将对象的键值对映射为新的键值对
-   *
-   * @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<O extends PlainObject, NK extends PropertyKey, NV>(plainObject: O, toEntry: (key: keyof O, value: O[keyof O]) => [NK, NV]): PlainObject<NK, NV>;
-  /**
-   * 选取对象的指定属性
-   *
-   * @param plainObject 对象
-   * @param keys 要选取的属性键数组
-   * @returns 包含指定属性的新对象
-   * @example
-   * ```ts
-   * // 重载 1: PlainObject
-   * ObjectUtil.pick({ a: 1, b: 2 }, ["a"]); // { a: 1 }
-   *
-   * // 重载 2: AnyObject
-   * const anyObj = { x: 1, y: 2 } as Record<string, unknown>;
-   * ObjectUtil.pick(anyObj, ["x"]); // { x: 1 }
-   * ```
-   */
-  static pick<O extends PlainObject, K extends keyof O>(plainObject: O, keys: readonly K[]): Pick<O, K>;
-  static pick<O extends AnyObject, K extends keyof O>(anyObject: O, keys: readonly K[]): Pick<O, K>;
-  /**
-   * 排除对象的指定属性
-   *
-   * @param plainObject 对象
-   * @param keys 要排除的属性键数组
-   * @returns 排除指定属性后的新对象
-   * @example
-   * ```ts
-   * // 重载 1: PlainObject
-   * ObjectUtil.omit({ a: 1, b: 2 }, ["a"]); // { b: 2 }
-   *
-   * // 重载 2: AnyObject
-   * const anyObj = { x: 1, y: 2 } as Record<string, unknown>;
-   * ObjectUtil.omit(anyObj, ["x"]); // { y: 2 }
-   * ```
-   */
-  static omit<O extends PlainObject, K extends keyof O>(plainObject: O, keys: readonly K[]): Omit<O, K>;
-  static omit<O extends AnyObject, K extends keyof O>(anyObject: O, keys: readonly K[]): PlainObject;
-  /**
-   * 尽可能地交换对象的键和值
-   *
-   * @param obj 对象
-   * @returns 键值互换后的对象
-   * @example
-   * ```ts
-   * // 重载 1: Record<keyof O, PropertyKey>
-   * const obj = { a: "1", b: 2 };
-   * ObjectUtil.invert(obj); // { "1": "a", 2: "b" }
-   *
-   * // 重载 2: AnyObject
-   * const anyObj = { x: Symbol.for("s"), y: true } as Record<string, unknown>;
-   * ObjectUtil.invert(anyObj); // { [Symbol.for("s")]: "x" }
-   * ```
-   */
-  static invert<const O extends Record<keyof O, PropertyKey>>(plainObject: O): Invert<O>;
-  static invert<const O extends AnyObject>(anyObject: O): Invert<O>;
-  /**
-   * 压平对象
-   * - 将多层级的对象转换为单层级的对象，键名使用点号连接
-   *
-   * @param plainObject 平面对象
-   * @returns 压平后的对象
-   * @example
-   * ```ts
-   * // 重载 1: PlainObject
-   * const plainObj = { a: { b: 1 } };
-   * ObjectUtil.crush(plainObj); // { "a.b": 1 }
-   *
-   * // 重载 2: AnyObject
-   * const anyObj = { list: [{ id: 1 }] } as Record<string, unknown>;
-   * ObjectUtil.crush(anyObj); // { "list.0.id": 1 }
-   * ```
-   */
-  static crush<T extends PlainObject>(plainObject: T): Crush<T>;
-  static crush<T extends AnyObject>(anyObject: T): Crush<T>;
-  /**
-   * 获取所有枚举成员的键
-   *
-   * @param enumeration 枚举对象
-   * @returns 键数组
-   * @example
-   * ```ts
-   * // 重载 1: PlainObject
-   * enum StringEnum { A = "a", B = "b" }
-   * ObjectUtil.enumKeys(StringEnum); // ["A", "B"]
-   *
-   * // 重载 2: AnyObject
-   * enum NumberEnum { A, B }
-   * const anyEnum = NumberEnum as Record<string, unknown>;
-   * ObjectUtil.enumKeys(anyEnum); // ["A", "B"]
-   * ```
-   */
-  static enumKeys<E extends PlainObject>(enumeration: E): (keyof E)[];
-  static enumKeys<E extends AnyObject>(enumeration: E): (keyof E)[];
-  /**
-   * 获取所有枚举成员的值
-   *
-   * @param enumeration 枚举对象
-   * @returns 值数组
-   * @example
-   * ```ts
-   * // 重载 1: PlainObject
-   * enum StringEnum { A = "a", B = "b" }
-   * ObjectUtil.enumValues(StringEnum); // ["a", "b"]
-   *
-   * // 重载 2: AnyObject
-   * enum NumberEnum { A, B }
-   * const anyEnum = NumberEnum as Record<string, unknown>;
-   * ObjectUtil.enumValues(anyEnum); // [0, 1]
-   * ```
-   */
-  static enumValues<E extends PlainObject>(enumeration: E): UnionToTuple<ValueOf<E>>;
-  static enumValues<E extends AnyObject>(enumeration: E): UnionToTuple<ValueOf<E>>;
-  /**
-   * 获取所有枚举成员的键/值数组
-   *
-   * @param enumeration 枚举对象
-   * @returns 键值对数组
-   * @example
-   * ```ts
-   * // 重载 1: PlainObject
-   * enum StringEnum { A = "a", B = "b" }
-   * ObjectUtil.enumEntries(StringEnum); // [["A", "a"], ["B", "b"]]
-   *
-   * // 重载 2: AnyObject
-   * enum NumberEnum { A, B }
-   * const anyEnum = NumberEnum as Record<string, unknown>;
-   * ObjectUtil.enumEntries(anyEnum); // [["A", 0], ["B", 1]]
-   * ```
-   */
-  static enumEntries<E extends PlainObject>(enumeration: E): [keyof E, E[keyof E]][];
-  static enumEntries<E extends AnyObject>(enumeration: E): [keyof E, E[keyof E]][];
-}
-//#endregion
-//#region src/string/stringUtil.d.ts
-/**
- * 字符串工具类
- */
-declare class StringUtil {
-  /**
-   * 将任意值转换为字符串
-   * - 当传入数值字面量时，返回对应的字符串字面量类型
-   *
-   * @param candidate 待转换的值
-   * @param checkNullish 是否检查空值（`null` / `undefined` / 空白字符串），默认为 `true`
-   * @param trim 是否去除结果首尾空白，默认为 `true`
-   * @returns 转换后的字符串
-   * @example
-   * ```ts
-   * // 重载 1: null / undefined + checkNullish = true (默认) → ""
-   * StringUtil.cast(null); // ""
-   * StringUtil.cast(undefined); // ""
-   * StringUtil.cast(""); // ""
-   * StringUtil.cast("   "); // ""
-   *
-   * // 重载 2: null / undefined + checkNullish = false → "null" / "undefined"
-   * StringUtil.cast(null, false); // "null" (类型为 "null")
-   * StringUtil.cast(undefined, false); // "undefined" (类型为 "undefined")
-   *
-   * // 重载 3: 原始类型 → Trim<`${T}`> 字面量类型（trim 默认 true）
-   * StringUtil.cast(123); // "123" (类型为 "123")
-   * StringUtil.cast("hello"); // "hello" (类型为 "hello")
-   * StringUtil.cast(true); // "true" (类型为 "true")
-   * StringUtil.cast(42n); // "42" (类型为 "42")
-   * // 默认去除结果首尾空白
-   * StringUtil.cast("  hello  "); // "hello" (类型为 Trim<"  hello  "> = "hello")
-   * StringUtil.cast("\n  abc  \n"); // "abc" (类型为 "abc")
-   *
-   * // 重载 4: 原始类型 + trim = false → 保留字面量类型
-   * StringUtil.cast("\n  abc  \n", true, false); // "\n  abc  \n" (类型为 "\n  abc  \n")
-   * StringUtil.cast(123, undefined, false); // "123" (类型为 "123")
-   *
-   * // 重载 5: 其他类型 → string
-   * StringUtil.cast(Symbol("foo")); // "Symbol(foo)" (类型为 string)
-   * StringUtil.cast([1, 2, 3]); // "1,2,3" (类型为 string)
-   * StringUtil.cast({}); // "[object Object]" (类型为 string)
-   * ```
-   */
-  static cast<T extends null | undefined>(candidate: T, checkNullish?: true, trim?: boolean): "";
-  static cast<T extends null | undefined>(candidate: T, checkNullish: false, trim?: boolean): Trim<`${T}`>;
-  static cast<T extends string | number | bigint | boolean>(candidate: T, checkNullish?: boolean, trim?: true): Trim<`${T}`>;
-  static cast<T extends string | number | bigint | boolean>(candidate: T, checkNullish: boolean | undefined, trim: false): `${T}`;
-  static cast(candidate: unknown, checkNullish?: boolean, trim?: boolean): string;
-  /**
-   * 从字符串中提取数字字符串
-   * - 移除非数字字符，保留符号和小数点
-   *
-   * @param input 待处理字符串
-   * @returns 提取出的数字字符串
-   * @example
-   * ```ts
-   * StringUtil.toNumber("$1,234.56"); // "1234.56"
-   * StringUtil.toNumber("abc-123"); // "-123"
-   * ```
-   */
-  static toNumber(input: string): string;
-  /**
-   * 将字符串转换为小写
-   * - 将字符串字面量类型转换为其小写形式
-   * - 当输入无效时，返回空字符串
-   *
-   * @param input 待处理字符串
-   * @returns 转换后的小写字符串类型，如果输入无效则返回空字符串类型 ""
-   * @example
-   * ```ts
-   * // 重载 1: 输入 string
-   * StringUtil.toLowerCase("HELLO"); // "hello"
-   *
-   * // 重载 2: 输入 unknown
-   * StringUtil.toLowerCase(null); // ""
-   * ```
-   */
-  static toLowerCase<const T extends string>(input: T): Lowercase<T>;
-  static toLowerCase(input: unknown): "";
-  /**
-   * 将字符串转换为大写
-   * - 将字符串字面量类型转换为其大写形式
-   * - 当输入无效时，返回空字符串
-   *
-   * @param input 待处理字符串
-   * @returns 转换后的大写字符串，如果输入无效则返回空字符串
-   * @example
-   * ```ts
-   * // 重载 1: 输入 string
-   * StringUtil.toUpperCase("hello"); // "HELLO"
-   *
-   * // 重载 2: 输入 unknown
-   * StringUtil.toUpperCase(null); // ""
-   * ```
-   */
-  static toUpperCase<const T extends string>(input: T): Uppercase<T>;
-  static toUpperCase(input: unknown): "";
-  /**
-   * 调整大小写
-   * - 每个单词（`\S+`）独立处理
-   * - 包含非西欧字母字符（如 `.`、`,`、`'`、`-`）时，该词不处理
-   * - 纯字母且全大写时，不处理
-   * - 纯字母且非全大写时：`caseType` 为 `"lower"` 则首字母小写，`"upper"` 则首字母大写，其余字符保留
-   * - ⚠️ 缺省 `caseType` 时不产生任何转换（no-op），需显式传 `"lower"` / `"upper"`
-   *
-   * @param input 待处理字符串
-   * @param caseType 大小写类型（缺省时无操作）
-   * @returns 处理后的字符串
-   * @example
-   * ```ts
-   * // 重载 1: lower
-   * StringUtil.toInitialCase("Hello World", "lower"); // "hello world"
-   *
-   * // 重载 2: upper
-   * StringUtil.toInitialCase("hello world", "upper"); // "Hello World"
-   *
-   * // 缺省 caseType → no-op
-   * StringUtil.toInitialCase("Hello"); // "Hello"
-   * ```
-   */
-  static toInitialCase(input: string, caseType?: "lower" | "upper" | undefined): string;
-  /**
-   * 将路径转换为 POSIX 风格
-   * - 统一使用正斜杠 (/)
-   * - 可选移除 Windows 盘符 (如 C:)
-   * - 可选移除开头的斜杠
-   * - 规范化连续斜杠为单个斜杠
-   *
-   * @param input 待处理字符串
-   * @param removeLeadingSlash 是否移除开头斜杠，默认为 `false`。如果移除了盘符，路径通常会以 / 开头，此参数可控制是否保留该 /
-   * @returns 转换后的路径，如果输入无效则返回空字符串
-   *
-   * @example
-   * ```ts
-   * StringUtil.toPosix("C:\\Windows\\System32"); // 默认: "/Windows/System32" (移除了 C: 并标准化)
-   *
-   * StringUtil.toPosix("C:\\Windows\\System32", true); // 移除开头斜杠: "Windows/System32"
-   *
-   * StringUtil.toPosix("\\\\server\\share\\file.txt"); // UNC 路径: "/server/share/file.txt"
-   *
-   * StringUtil.toPosix("folder\\subfolder\\file.txt"); // 相对路径: "folder/subfolder/file.txt"
-   * ```
-   */
-  static toPosix(input: string | null | undefined, removeLeadingSlash?: boolean): string;
-  /**
-   * 处理 JSON 字符串
-   *
-   * @param input 待处理字符串
-   * @param fallback 回退值
-   * @returns 解析后的对象 或 回退值
-   * @example
-   * ```ts
-   * // 重载 1: 无 fallback
-   * StringUtil.toJson<{ a: number }>("{\"a\":1}"); // { a: 1 }
-   * StringUtil.toJson("invalid"); // undefined
-   *
-   * // 重载 2: 有 fallback
-   * StringUtil.toJson<{ a: number }>("invalid", { a: 0 }); // { a: 0 }
-   * ```
-   */
-  static toJson<D extends AnyObject = AnyObject>(input: string | null | undefined): D | undefined;
-  static toJson<D extends AnyObject = AnyObject>(input: string | null | undefined, fallback: D): D;
-  /**
-   * 字符串分割为数组
-   * - 按指定分隔符分割字符串，并转换类型
-   * - ⚠️ `valueType` 为 `"number"` 时，无法解析的片段会转为 `NaN`，**不进行过滤**
-   *
-   * @param input 待处理字符串
-   * @param valueType 数组中每一项的类型，默认为 "number"
-   * @param splitSymbol 分隔符，默认为 `,`
-   * @returns 分割后的数组
-   * @example
-   * ```ts
-   * // 重载 1: valueType = "number" (默认)
-   * StringUtil.toValues("1,2,3"); // [1, 2, 3]
-   *
-   * // 重载 2: valueType = "string"
-   * StringUtil.toValues("a-b-c", "string", "-"); // ["a", "b", "c"]
-   *
-   * // 无法解析的片段 → NaN 不被过滤
-   * StringUtil.toValues("1,abc,3"); // [1, NaN, 3]
-   * ```
-   */
-  static toValues(input: string | null | undefined, valueType?: "number" | undefined, splitSymbol?: string | undefined): number[];
-  static toValues(input: string | null | undefined, valueType: "string", splitSymbol?: string | undefined): string[];
-  /**
-   * 从字符串中裁切掉所有的前缀和后缀字符
-   *
-   * @param input 待处理字符串
-   * @param charsToTrim 裁切字符，默认为 `" "`
-   * @returns 裁切后的字符串
-   * @example
-   * ```ts
-   * StringUtil.trim("  hello  "); // "hello"
-   * StringUtil.trim("__hello__", "_"); // "hello"
-   * ```
-   */
-  static trim(input: string | null | undefined, charsToTrim?: string): string;
-  /**
-   * 截取字符串
-   * - 支持自定义省略符，不会截断在汉字中间（因为JS字符串本身按字符处理）
-   *
-   * @param input 待处理字符串
-   * @param maxLength 最大长度 (包含省略符)
-   * @param ellipsis 省略符，默认为 `...`
-   * @returns 截取后的字符串
-   * @example
-   * ```ts
-   * StringUtil.truncate("hello world", 8); // "hello..."
-   * ```
-   */
-  static truncate(input: string, maxLength: number, ellipsis?: string): string;
-  /**
-   * 字符串模板替换
-   * - 使用对象的属性值替换字符串中的 {{key}} 模板
-   *
-   * @param input 待处理字符串
-   * @param template 模板对象
-   * @param regex 模板匹配正则 (默认: `\{\{(.+?)\}\}`)
-   * @returns 替换后的字符串
-   * @example
-   * ```ts
-   * StringUtil.template("Hello {{name}}", { name: "World" }); // "Hello World"
-   * ```
-   */
-  static template(input: string, template: PlainObject, regex?: RegExp): string;
-  /**
-   * 字符串替换
-   * - 替换第一个匹配项
-   *
-   * @param input 待处理字符串
-   * @param search 匹配项
-   * @param replacement 替换项
-   * @returns 替换后的字符串
-   * @example
-   * ```ts
-   * StringUtil.replace("hello world", "world", "context"); // "hello context"
-   * ```
-   */
-  static replace<I extends string, S extends string, R extends string>(input: I, search: S, replacement: R): Replace<I, S, R>;
-}
-//#endregion
-//#region src/theme/themeUtil.d.ts
-/**
- * 主题工具类
- */
-declare class ThemeUtil {
-  /**
-   * 固定主题类型（仅亮色/暗色）
-   *
-   * @example
-   * ```ts
-   * ThemeUtil.THEME.LIGHT; // "light"
-   * ThemeUtil.THEME.DARK; // "dark"
-   * ```
-   */
-  static readonly THEME: {
-    readonly LIGHT: "light";
-    readonly DARK: "dark";
-  };
-  /**
-   * 主题模式（支持跟随系统）
-   *
-   * @example
-   * ```ts
-   * ThemeUtil.THEME_MODE.SYSTEM; // "system"
-   * ThemeUtil.THEME_MODE.DARK; // "dark"
-   * ```
-   */
-  static readonly THEME_MODE: {
-    readonly LIGHT: "light";
-    readonly DARK: "dark";
-    readonly SYSTEM: "system";
-  };
-}
-//#endregion
-//#region src/theme/index.type.d.ts
-type THEME_TYPE = ValueOf<typeof ThemeUtil.THEME>;
-type THEME_MODE_TYPE = ValueOf<typeof ThemeUtil.THEME_MODE>;
-//#endregion
-//#region src/tree/index.type.d.ts
-type RowKey = "id";
-type ParentIdKey = "parentId";
-type ChildrenKey = "children";
-type Strategy = "pre" | "post" | "breadth";
-interface BaseCallbackMeta<T> {
-  depth: number;
-  parents?: T[] | undefined;
-}
-interface BaseOptions<T, CK extends string> {
-  childrenKey?: CK;
-  strategy?: Strategy;
-  getChildrenKey?: ((row: T, meta: BaseCallbackMeta<T>) => CK) | undefined;
-}
-interface RowsToTreeOptions<RK extends string = RowKey, PK extends string = ParentIdKey, CK extends string = ChildrenKey> {
-  rowKey?: RK;
-  parentIdKey?: PK;
-  childrenKey?: CK;
-}
-type TreeToRowsOptions<T extends AnyObject$1, CK extends string = ChildrenKey> = TreeForeachOptions<T, CK>;
-type TreeFindOptions<T extends AnyObject$1, CK extends string = ChildrenKey> = BaseOptions<T, CK>;
-type TreeFindCallback<T extends AnyObject$1> = (row: T, meta: BaseCallbackMeta<T>) => boolean;
-type TreeForeachOptions<T extends AnyObject$1, CK extends string = ChildrenKey> = BaseOptions<T, CK>;
-type TreeForeachCallback<T extends AnyObject$1> = (row: T, meta: BaseCallbackMeta<T>) => void;
-type TreeFilterOptions<T extends AnyObject$1, CK extends string = ChildrenKey> = BaseOptions<T, CK>;
-type TreeFilterCallback<T extends AnyObject$1> = (row: T, meta: BaseCallbackMeta<T>) => boolean;
-type TreeMapOptions<T extends AnyObject$1, CK extends string> = BaseOptions<T, CK>;
-type TreeMapCallback<R extends AnyObject$1, T extends AnyObject$1> = (row: T, meta: BaseCallbackMeta<T>) => R;
-//#endregion
-//#region src/tree/treeUtil.d.ts
-/**
- * 树结构工具类
- *
- * 引用策略约定：
- * - 转换类方法（`rowsToTree` / `treeToRows` / `filter` / `map`）：不突变输入；输出的每个节点均为**新对象引用**（来源节点的浅拷贝，仅自有可枚举属性；非枚举属性、原型链、getter 及深层嵌套对象不保证）。
- * - 查询类方法（`find` / `forEach`）：按查询语义直接使用**原对象引用**。
- */
-declare class TreeUtil {
-  /**
-   * 行结构 转 树结构
-   * - 将平铺的数组转换为树形结构
-   * - 返回的树结构与输入行无共享节点（新对象引用），输入行不会被突变
-   * - 重复 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<T extends AnyObject = AnyObject, CK extends string = ChildrenKey, R extends AnyObject = TreeLike<T, CK>, RK extends string = RowKey, PK extends string = ParentIdKey>(rows: T[], options?: RowsToTreeOptions<RK, PK, CK> | undefined): R[];
-  /**
-   * 树结构 转 行结构
-   * - 将树形结构扁平化为数组
-   *
-   * @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<T extends AnyObject, CK extends string = ChildrenKey, R extends AnyObject = TreeLikeOptionalChildren<T, CK>>(tree: T | T[], options?: TreeToRowsOptions<T, CK>): R[];
-  /**
-   * 遍历树节点
-   *
-   * @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<T extends AnyObject, CK extends string = ChildrenKey>(tree: T | T[], callback: TreeForeachCallback<T>, options?: TreeForeachOptions<T, CK>): void;
-  /**
-   * 查找树节点
-   * - 返回第一个回调返回 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<T extends AnyObject, CK extends string = ChildrenKey>(tree: T | T[], callback: TreeFindCallback<T>, options?: TreeFindOptions<T, CK>): T | undefined;
-  /**
-   * 过滤树节点
-   * - 返回新的树结构，包含所有回调返回 true 的节点
-   * - 如果父节点被过滤，则其子节点也会被过滤 (pre 策略下)
-   *
-   * @param tree 树结构数据
-   * @param callback 回调函数
-   * @param options 配置项 (childrenKey, strategy等)
-   * @returns 过滤后的树结构数组
-   * @example
-   * ```ts
-   * const tree = [{ id: 1, visible: true, children: [{ id: 2, visible: false }] }];
-   *
-   * // 重载 1: 传入树数组
-   * TreeUtil.filter(tree, (node) => node.visible); // [{ id: 1, visible: true, children: [] }]
-   *
-   * // 重载 2: 传入单个树节点
-   * TreeUtil.filter(tree[0], (node) => node.visible); // { id: 1, visible: true, children: [] }
-   * ```
-   */
-  static filter<T extends AnyObject, CK extends string = ChildrenKey>(tree: T[], callback: TreeFilterCallback<T>, options?: TreeFilterOptions<T, CK>): T[];
-  static filter<T extends AnyObject, CK extends string = ChildrenKey>(tree: T, callback: TreeFilterCallback<T>, options?: TreeFilterOptions<T, CK>): T;
-  /**
-   * 映射树节点
-   * - 返回新的树结构，保持层级关系
-   *
-   * @param tree 树结构数据
-   * @param callback 回调函数 (返回映射后的节点内容)
-   * @param options 配置项
-   * @returns 映射后的树结构数组
-   * @example
-   * ```ts
-   * const tree = [{ id: 1, val: 10, children: [{ id: 2, val: 20 }] }];
-   *
-   * // 重载 1: 传入树数组
-   * TreeUtil.map(tree, (node) => ({ ...node, val: node.val * 2 }));
-   * // [{ id: 1, val: 20, children: [{ id: 2, val: 40 }] }]
-   *
-   * // 重载 2: 传入单个树节点
-   * TreeUtil.map(tree[0], (node) => ({ ...node, val: node.val * 2 }));
-   * // { id: 1, val: 20, children: [{ id: 2, val: 40 }] }
-   * ```
-   */
-  static map<R extends AnyObject, T extends AnyObject, CK extends string = ChildrenKey>(tree: T[], callback: TreeMapCallback<R, T>, options?: TreeMapOptions<T, CK>): TreeLike<R, CK>[];
-  static map<R extends AnyObject, T extends AnyObject, CK extends string = ChildrenKey>(tree: T, callback: TreeMapCallback<R, T>, options?: TreeMapOptions<T, CK>): TreeLike<R, CK>;
-}
-//#endregion
-//#region src/type/index.type.d.ts
-interface Class<T, Arguments extends unknown[] = unknown[]> {
-  new (...arguments_: Arguments): T;
-  prototype: Pick<T, keyof T>;
-}
-//#endregion
-//#region src/type/typeUtil.d.ts
-/**
- * 类型工具类
- */
-declare class TypeUtil {
-  private static readonly PROTOTYPE_TAGS;
-  private static readonly TYPED_ARRAY_TAGS;
-  /**
-   * 获取值的 [[Prototype]] 标签
-   *
-   * @param value - 任意 JavaScript 值
-   * @returns 标准化的类型标签字符串
-   */
-  private static getPrototypeString;
-  /**
-   * 检查 value 是否为 string 类型
-   * - 当 `checkNullish` 为 `true` 时，会先 trim 再判断是否为空
-   *
-   * @param value 待检查值
-   * @param checkNullish 是否检查空字符串（含空白字符串），默认为 `false`
-   * @returns 是否为字符串
-   * @example
-   * ```ts
-   * TypeUtil.isString("abc"); // true
-   * TypeUtil.isString(""); // true
-   * TypeUtil.isString("", true); // false
-   * TypeUtil.isString("   ", true); // false
-   * TypeUtil.isString(" a ", true); // true
-   * ```
-   */
-  static isString(value: unknown, checkNullish?: boolean): value is string;
-  /**
-   * 检查 value 是否为 number 类型
-   * - 默认会调用 `TypeUtil.isNaN`（内部基于 `Number.isNaN`）过滤掉 `NaN`
-   *
-   * @param value 待检查值
-   * @param checkNaN 是否检查 `NaN`，默认为 `true`
-   * @returns 是否为 number
-   * @example
-   * ```ts
-   * TypeUtil.isNumber(1); // true
-   * TypeUtil.isNumber(NaN); // false (default)
-   * TypeUtil.isNumber(NaN, false); // true
-   * ```
-   */
-  static isNumber(value: unknown, checkNaN?: boolean): value is number;
-  /**
-   * 检查 value 是否为 NaN
-   * - 禁止使用全局 `isNaN`，其会先进行隐式数字转换，可能导致误判（例如 `isNaN("foo") === true`）
-   * - 使用 `Number.isNaN` 仅在值本身就是 `NaN` 时返回 `true`，语义更严格且更安全
-   *
-   * @param value 待检查值
-   * @returns 是否为 NaN
-   * @example
-   * ```ts
-   * TypeUtil.isNaN(NaN); // true
-   * ```
-   */
-  static isNaN(value: unknown): value is number;
-  /**
-   * 检查 value 是否为整数
-   *
-   * @param value 待检查值
-   * @param checkSafe 是否附加安全整数检查
-   * @returns 是否为整数
-   * @example
-   * ```ts
-   * TypeUtil.isInteger(1); // true
-   * TypeUtil.isInteger(1.1); // false
-   * ```
-   */
-  static isInteger(value: unknown, checkSafe?: boolean): value is number;
-  /**
-   * 检查 value 是否为正整数
-   * - 此函数中 `0` 不被视为正整数
-   *
-   * @param value 待检查值
-   * @param checkSafe 是否附加安全整数检查
-   * @example
-   * ```ts
-   * TypeUtil.isPositiveInteger(1); // true
-   * TypeUtil.isPositiveInteger(0); // false
-   * ```
-   */
-  static isPositiveInteger(value: unknown, checkSafe?: boolean): value is number;
-  /**
-   * 检查 value 是否为负整数
-   * - 此函数中 `0` 不被视为负整数
-   *
-   * @param value 待检查值
-   * @param checkSafe 是否附加安全整数检查
-   * @example
-   * ```ts
-   * TypeUtil.isNegativeInteger(-1); // true
-   * TypeUtil.isNegativeInteger(0); // false
-   * ```
-   */
-  static isNegativeInteger(value: unknown, checkSafe?: boolean): value is number;
-  /**
-   * 检查 value 是否为 Infinity
-   * - 排除 `NaN`
-   *
-   * @param value 待检查值
-   * @example
-   * ```ts
-   * TypeUtil.isInfinity(Infinity); // true
-   * TypeUtil.isInfinity(1); // false
-   * ```
-   */
-  static isInfinity(value: unknown): value is number;
-  /**
-   * 检查 value 是否类似 Infinity
-   * - 排除 `NaN`
-   *
-   * @param value 待检查值
-   * @example
-   * ```ts
-   * TypeUtil.isInfinityLike("Infinity"); // true
-   * TypeUtil.isInfinityLike("123"); // false
-   * ```
-   */
-  static isInfinityLike(value: unknown): boolean;
-  /**
-   * 检查 value 是否为 Boolean
-   * @param value 待检查值
-   * @returns 是否为 Boolean
-   * @example
-   * ```ts
-   * TypeUtil.isBoolean(false); // true
-   * ```
-   */
-  static isBoolean(value: unknown): value is boolean;
-  /**
-   * 检查 value 是否为 BigInt
-   * @param value 待检查值
-   * @returns 是否为 BigInt
-   * @example
-   * ```ts
-   * TypeUtil.isBigInt(1n); // true
-   * ```
-   */
-  static isBigInt(value: unknown): value is bigint;
-  /**
-   * 检查 value 是否为 Symbol
-   * @param value 待检查值
-   * @returns 是否为 Symbol
-   * @example
-   * ```ts
-   * TypeUtil.isSymbol(Symbol("a")); // true
-   * ```
-   */
-  static isSymbol(value: unknown): value is symbol;
-  /**
-   * 检查 value 是否为 undefined
-   * @param value 待检查值
-   * @returns 是否为 undefined
-   * @example
-   * ```ts
-   * TypeUtil.isUndefined(undefined); // true
-   * ```
-   */
-  static isUndefined(value: unknown): value is undefined;
-  /**
-   * 检查 value 是否为 null
-   * @param value 待检查值
-   * @returns 是否为 null
-   * @example
-   * ```ts
-   * TypeUtil.isNull(null); // true
-   * ```
-   */
-  static isNull(value: unknown): value is null;
-  /**
-   * 检查 value 是否为 null 或 undefined
-   * @param value 待检查值
-   * @returns 是否为 Nullish
-   * @example
-   * ```ts
-   * TypeUtil.isNullish(null); // true
-   * TypeUtil.isNullish(undefined); // true
-   * ```
-   */
-  static isNullish(value: unknown): value is null | undefined;
-  /**
-   * 检查 value 是否为 Function
-   * @param value 待检查值
-   * @returns 是否为 Function
-   * @example
-   * ```ts
-   * TypeUtil.isFunction(() => {}); // true
-   * ```
-   */
-  static isFunction(value: unknown): value is AnyFunction;
-  /**
-   * 检查 value 是否为 AsyncFunction
-   * @param value 待检查值
-   * @returns 是否为 AsyncFunction
-   * @example
-   * ```ts
-   * TypeUtil.isAsyncFunction(async () => {}); // true
-   * ```
-   */
-  static isAsyncFunction(value: unknown): value is AnyAsyncFunction;
-  /**
-   * 检查 value 是否为 GeneratorFunction
-   * @param value 待检查值
-   * @returns 是否为 GeneratorFunction
-   * @example
-   * ```ts
-   * TypeUtil.isGeneratorFunction(function * a () {}); // true
-   * ```
-   */
-  static isGeneratorFunction(value: unknown): value is AnyGeneratorFunction;
-  /**
-   * 检查 value 是否为 AsyncGeneratorFunction
-   * @param value 待检查值
-   * @returns 是否为 AsyncGeneratorFunction
-   * @example
-   * ```ts
-   * TypeUtil.isAsyncGeneratorFunction(async function * a () {}); // true
-   * ```
-   */
-  static isAsyncGeneratorFunction(value: unknown): value is AnyAsyncGeneratorFunction;
-  /**
-   * 检查 value 是否为 Promise
-   * @param value 待检查值
-   * @returns 是否为 Promise
-   * @example
-   * ```ts
-   * TypeUtil.isPromise(Promise.resolve(1)); // true
-   * ```
-   */
-  static isPromise(value: unknown): value is Promise<unknown>;
-  /**
-   * 检查 value 是否为 PromiseLike
-   * - 可识别拥有 then 方法的非 Promise 对象
-   * @param value 待检查值
-   * @returns 是否为 PromiseLike
-   * @example
-   * ```ts
-   * TypeUtil.isPromiseLike({ then: () => {} }); // true
-   * ```
-   */
-  static isPromiseLike(value: unknown): value is PromiseLike<unknown>;
-  /**
-   * 判断是否为普通对象类型
-   * - 可选是否检查原型为 `Object.prototype`，防止原型链污染
-   *
-   * @param value 待检查值
-   * @param prototypeCheck 是否进行原型检查，默认 `true`
-   * @returns 是否为 Plain Object (当 prototypeCheck=true) 或 object
-   * @example
-   * ```ts
-   * TypeUtil.isPlainObject({}); // true
-   * TypeUtil.isPlainObject([]); // false
-   * TypeUtil.isPlainObject(new Date()); // false
-   * TypeUtil.isPlainObject(new (class {})()); // false
-   * TypeUtil.isPlainObject(new (class {})(), false); // true
-   * TypeUtil.isPlainObject(Object.create(null)) // false
-   * TypeUtil.isPlainObject(Object.create(null), false) // true
-   * ```
-   */
-  static isPlainObject(value: unknown, prototypeCheck?: boolean): value is Record<PropertyKey, unknown>;
-  /**
-   * 判断是否为广义对象类型
-   *
-   * @param value 待检查值
-   * @returns 是否为对象
-   * @example
-   * ```ts
-   * TypeUtil.isObject({}); // true
-   * TypeUtil.isObject([]); // true
-   * TypeUtil.isObject(new Date()); // true
-   * TypeUtil.isObject(null); // false
-   * TypeUtil.isObject("string"); // false
-   * ```
-   */
-  static isObject(value: unknown): value is object;
-  /**
-   * 判断一个对象是否为有效的枚举
-   * - 枚举成员不能为空
-   * - 枚举成员的键不能具有数值名
-   * - 枚举成员的值必须类型一致且为 `string` 或 `number` 类型
-   * - 枚举成员的值不能重复
-   * - 枚举成员的值必须全部为双向映射或非双向映射
-   *
-   * @param enumeration 待检查值
-   * @returns [是否为有效的枚举, 是否为双向枚举]
-   * @example
-   * ```ts
-   * enum A { X, Y }
-   * TypeUtil.isEnumeration(A); // [true, true]
-   * ```
-   */
-  static isEnumeration(enumeration: PlainObject): [boolean, boolean];
-  /**
-   * 检查 value 是否为 Class
-   *
-   * @param value 待检查值
-   * @returns 是否为 Class
-   * @example
-   * ```ts
-   * class A {}
-   * TypeUtil.isClass(A); // true
-   * TypeUtil.isClass(() => {}); // false
-   * ```
-   */
-  static isClass(value: unknown): value is Class<AnyObject>;
-  /**
-   * 检查 value 是否为数组
-   *
-   * @param value 待检查值
-   * @returns 是否为数组
-   * @example
-   * ```ts
-   * TypeUtil.isArray([]); // true
-   * ```
-   */
-  static isArray(value: unknown): value is unknown[];
-  /**
-   * 检查 value 是否为 TypedArray
-   *
-   * @param value 待检查值
-   * @returns 是否为 TypedArray
-   * @example
-   * ```ts
-   * TypeUtil.isTypedArray(new Int8Array()); // true
-   * ```
-   */
-  static isTypedArray(value: unknown): value is TypedArray;
-  /**
-   * 检查 value 是否为 Map
-   * @param value 待检查值
-   * @returns 是否为 Map
-   * @example
-   * ```ts
-   * TypeUtil.isMap(new Map()); // true
-   * ```
-   */
-  static isMap(value: unknown): value is Map<unknown, unknown>;
-  /**
-   * 检查 value 是否为 WeakMap
-   * @param value 待检查值
-   * @returns 是否为 WeakMap
-   * @example
-   * ```ts
-   * TypeUtil.isWeakMap(new WeakMap()); // true
-   * ```
-   */
-  static isWeakMap(value: unknown): value is WeakMap<AnyObject, unknown>;
-  /**
-   * 检查 value 是否为 Set
-   * @param value 待检查值
-   * @returns 是否为 Set
-   * @example
-   * ```ts
-   * TypeUtil.isSet(new Set()); // true
-   * ```
-   */
-  static isSet(value: unknown): value is Set<unknown>;
-  /**
-   * 检查 value 是否为 WeakSet
-   * @param value 待检查值
-   * @returns 是否为 WeakSet
-   * @example
-   * ```ts
-   * TypeUtil.isWeakSet(new WeakSet()); // true
-   * ```
-   */
-  static isWeakSet(value: unknown): value is WeakSet<AnyObject>;
-  /**
-   * 检查 value 是否为 Blob
-   * @param value 待检查值
-   * @returns 是否为 Blob
-   * @example
-   * ```ts
-   * TypeUtil.isBlob(new Blob(["a"])); // true
-   * ```
-   */
-  static isBlob(value: unknown): value is Blob;
-  /**
-   * 检查 value 是否为 File
-   * @param value 待检查值
-   * @returns 是否为 File
-   * @example
-   * ```ts
-   * TypeUtil.isFile(new File(["a"], "a.txt")); // true
-   * ```
-   */
-  static isFile(value: unknown): value is File;
-  /**
-   * 检查 value 是否为 ReadableStream
-   * - Uses `Object.prototype.toString` where supported (modern browsers, Node.js ≥18).
-   * - Falls back to duck-typing in older environments.
-   * - Resistant to basic forgery, but not 100% secure in all polyfill scenarios.
-   * - ⚠️ Note: In older Node.js (<18) or with non-compliant polyfills, this may return false positives or negatives.
-   *
-   * @param value 待检查值
-   * @returns 是否为 ReadableStream
-   * @example
-   * ```ts
-   * TypeUtil.isReadableStream(new ReadableStream()); // true
-   * ```
-   */
-  static isReadableStream(value: unknown): value is ReadableStream;
-  /**
-   * 检查 value 是否为 Window
-   * @param value 待检查值
-   * @returns 是否为 Window
-   * @example
-   * ```ts
-   * TypeUtil.isWindow(window); // true
-   * ```
-   */
-  static isWindow(value: unknown): value is Window;
-  /**
-   * 检查 value 是否为 HTMLIFrameElement
-   * @param value 待检查值
-   * @returns 是否为 HTMLIFrameElement
-   * @example
-   * ```ts
-   * TypeUtil.isIframe(document.createElement("iframe")); // true
-   * ```
-   */
-  static isIframe(value: unknown): value is HTMLIFrameElement;
-  /**
-   * 检查 value 是否为 Date 对象
-   *
-   * @param value 待检查值
-   * @param invalidCheck 是否要求日期有效（非 Invalid Date）。默认 true
-   *   - true: 仅当是有效 Date 对象时返回 true（排除 new Date('invalid')）
-   *   - false: 只要 [[Prototype]] 是 Date 即返回 true（包含 Invalid Date）
-   * @returns 是否为 Date 对象，根据 invalidCheck 返回不同语义的 Date 判定
-   *
-   * @example
-   * ```ts
-   * TypeUtil.isDate(new Date()); // true
-   * TypeUtil.isDate(new Date('invalid')); // false
-   * TypeUtil.isDate(new Date('invalid'), false); // true
-   * TypeUtil.isDate(null); // false
-   * TypeUtil.isDate({}); // false
-   * ```
-   */
-  static isDate(value: unknown, invalidCheck?: boolean): value is Date;
-  /**
-   * 检查 value 是否为 Error 对象
-   * @param value 待检查值
-   * @returns 是否为 Error
-   * @example
-   * ```ts
-   * TypeUtil.isError(new Error("x")); // true
-   * ```
-   */
-  static isError(value: unknown): value is Error;
-  /**
-   * 检查 value 是否为 RegExp
-   * @param value 待检查值
-   * @returns 是否为 RegExp
-   * @example
-   * ```ts
-   * TypeUtil.isRegExp(/a/); // true
-   * ```
-   */
-  static isRegExp(value: unknown): value is RegExp;
-  /**
-   * 检查 value 是否为 WebSocket
-   * @param value 待检查值
-   * @returns 是否为 WebSocket
-   * @example
-   * ```ts
-   * TypeUtil.isWebSocket(new WebSocket("wss://echo.websocket.events")); // true
-   * ```
-   */
-  static isWebSocket(value: unknown): value is WebSocket;
-  /**
-   * 检查 value 是否为 URLSearchParams
-   * @param value 待检查值
-   * @returns 是否为 URLSearchParams
-   * @example
-   * ```ts
-   * TypeUtil.isURLSearchParams(new URLSearchParams("a=1")); // true
-   * ```
-   */
-  static isURLSearchParams(value: unknown): value is URLSearchParams;
-  /**
-   * 检查 value 是否为 AbortSignal
-   * @param value 待检查值
-   * @returns 是否为 AbortSignal
-   * @example
-   * ```ts
-   * TypeUtil.isAbortSignal(new AbortController().signal); // true
-   * ```
-   */
-  static isAbortSignal(value: unknown): value is AbortSignal;
-  /**
-   * 检查 value 是否为可迭代对象 (Iterable)
-   * @param value 待检查值
-   * @returns 是否为 Iterable
-   * @example
-   * ```ts
-   * TypeUtil.isIterable([1, 2]); // true
-   * ```
-   */
-  static isIterable(value: unknown): value is {
-    [Symbol.iterator]: () => Iterator<unknown>;
-  };
-  /**
-   * 检查 value 是否为 Falsy 值 (false, 0, "", null, undefined, NaN, 0n)
-   * - 处理非字符串形式的 falsy；字符串形式（`"null"`、`"0"` 等）请使用 `isFalsyLike`
-   *
-   * @param value 待检查值
-   * @returns 是否为 Falsy
-   * @example
-   * ```ts
-   * TypeUtil.isFalsy(0); // true
-   * ```
-   */
-  static isFalsy(value: unknown): boolean;
-  /**
-   * 检查 value 是否为 FalsyLike 值
-   * - 包含字符串形式的 `"null"`、`"undefined"`、`"false"`、`"0"` 等
-   *
-   * @param value 待检查值
-   * @returns 是否为 FalsyLike
-   * @example
-   * ```ts
-   * TypeUtil.isFalsyLike("false"); // true
-   * TypeUtil.isFalsyLike("hello"); // false
-   * ```
-   */
-  static isFalsyLike(value: unknown): boolean;
-}
-//#endregion
-//#region src/validate/validateUtil.d.ts
-/**
- * 验证工具类
- */
-declare class ValidateUtil {
-  static _phone: RegExp;
-  /**
-   * 验证是否为手机号码
-   * @example
-   * ```ts
-   * ValidateUtil.isPhone("13800138000"); // true
-   * ```
-   */
-  static isPhone(input: string): boolean;
-  static _telephone: RegExp;
-  /**
-   * 验证是否为固定电话
-   * @example
-   * ```ts
-   * ValidateUtil.isTelephone("010-12345678"); // true
-   * ```
-   */
-  static isTelephone(input: string): boolean;
-  static _IMEI: RegExp;
-  /**
-   * 验证是否为移动设备识别码
-   * @example
-   * ```ts
-   * ValidateUtil.isIMEI("490154203237518"); // true
-   * ```
-   */
-  static isIMEI(input: string): boolean;
-  static _email: RegExp;
-  /**
-   * 验证是否为电子邮箱
-   * @example
-   * ```ts
-   * ValidateUtil.isEmail("dev@example.com"); // true
-   * ```
-   */
-  static isEmail(input: string): boolean;
-  static _link: RegExp;
-  /**
-   * 验证是否为 http(s) 链接
-   * @example
-   * ```ts
-   * ValidateUtil.isHttpLink("https://example.com/path"); // true
-   * ```
-   */
-  static isHttpLink(input: string): boolean;
-  static _portLink: RegExp;
-  /**
-   * 验证是否为端口号链接
-   * @example
-   * ```ts
-   * ValidateUtil.isPortLink("http://example.com:8080"); // true
-   * ```
-   */
-  static isPortLink(input: string): boolean;
-  static _thunderLink: RegExp;
-  /**
-   * 验证是否为迅雷链接
-   * @example
-   * ```ts
-   * ValidateUtil.isThunderLink("thunder://QUFodHRwOi8vZXhhbXBsZS5jb20vZmlsZQ=="); // true
-   * ```
-   */
-  static isThunderLink(input: string): boolean;
-  static _uscc: RegExp;
-  /**
-   * 验证是否为统一社会信用代码（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: string): boolean;
-  /**
-   * 验证是否为统一社会信用代码（同 `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: string): boolean;
-  static _dirPathWindows: RegExp;
-  /**
-   * 验证是否为 Windows 系统文件夹路径
-   * @example
-   * ```ts
-   * ValidateUtil.isDirPathWindows("C:\\Users\\pawover\\"); // true
-   * ```
-   */
-  static isDirPathWindows(input: string): boolean;
-  static _filePathWindows: RegExp;
-  /**
-   * 验证是否为 Windows 系统文件路径
-   * @example
-   * ```ts
-   * ValidateUtil.isFilePathWindows("C:\\Users\\pawover\\a.txt"); // true
-   * ```
-   */
-  static isFilePathWindows(input: string): boolean;
-  static _dirPathLinux: RegExp;
-  /**
-   * 验证是否为 Linux 系统文件夹路径
-   * @example
-   * ```ts
-   * ValidateUtil.isDirPathLinux("/usr/local/"); // true
-   * ```
-   */
-  static isDirPathLinux(input: string): boolean;
-  static _filePathLinux: RegExp;
-  /**
-   * 验证是否为 Linux 系统文件路径
-   * @example
-   * ```ts
-   * ValidateUtil.isFilePathLinux("/usr/local/bin/node"); // true
-   * ```
-   */
-  static isFilePathLinux(input: string): boolean;
-  static _EVCarNumber: RegExp;
-  /**
-   * 验证是否为新能源车牌号
-   * @example
-   * ```ts
-   * ValidateUtil.isEVCarNumber("粤AD12345"); // true
-   * ```
-   */
-  static isEVCarNumber(input: string): boolean;
-  static _GVCarNumber: RegExp;
-  /**
-   * 验证是否为燃油车车牌号
-   * @example
-   * ```ts
-   * ValidateUtil.isGVCarNumber("粤B12345"); // true
-   * ```
-   */
-  static isGVCarNumber(input: string): boolean;
-  static _chineseName: RegExp;
-  /**
-   * 验证是否为中文姓名
-   * @example
-   * ```ts
-   * ValidateUtil.isChineseName("张三"); // true
-   * ```
-   */
-  static isChineseName(input: string): boolean;
-  static _chineseId: RegExp;
-  /**
-   * 验证是否为中国身份证号
-   * - ⚠️ 仅校验 18 位格式（含生日合法性），**不验证第 18 位校验位**，伪造码可通过校验
-   * @example
-   * ```ts
-   * ValidateUtil.isChineseID("11010519491231002X"); // true
-   * ```
-   */
-  static isChineseID(input: string): boolean;
-  static _chineseProvince: RegExp;
-  /**
-   * 验证是否为中国省份
-   * @example
-   * ```ts
-   * ValidateUtil.isChineseProvince("浙江"); // true
-   * ```
-   */
-  static isChineseProvince(input: string): boolean;
-  static _chineseNation: RegExp;
-  /**
-   * 验证是否为中华民族
-   * @example
-   * ```ts
-   * ValidateUtil.isChineseNation("汉族"); // true
-   * ```
-   */
-  static isChineseNation(input: string): boolean;
-  static _letter: RegExp;
-  /**
-   * 验证是否只包含字母
-   * @example
-   * ```ts
-   * ValidateUtil.isLetter("abcDEF"); // true
-   * ```
-   */
-  static isLetter(input: string): boolean;
-  static _letterLowercase: RegExp;
-  /**
-   * 验证是否只包含小写字母
-   * @example
-   * ```ts
-   * ValidateUtil.isLetterLowercase("abc"); // true
-   * ```
-   */
-  static isLetterLowercase(input: string): boolean;
-  static _letterUppercase: RegExp;
-  /**
-   * 验证是否只包含大写字母
-   * @example
-   * ```ts
-   * ValidateUtil.isLetterUppercase("ABC"); // true
-   * ```
-   */
-  static isLetterUppercase(input: string): boolean;
-  static _letterOmit: RegExp;
-  /**
-   * 验证是否不包含字母
-   * @example
-   * ```ts
-   * ValidateUtil.isLetterOmit("123_-"); // true
-   * ```
-   */
-  static isLetterOmit(input: string): boolean;
-  static _LetterAndNumber: RegExp;
-  /**
-   * 验证是否为数字和字母组合
-   * @example
-   * ```ts
-   * ValidateUtil.isLetterAndNumber("A1B2"); // true
-   * ```
-   */
-  static isLetterAndNumber(input: string): boolean;
-  static _signedFloat: RegExp;
-  /**
-   * 验证是否为有符号浮点数
-   * @example
-   * ```ts
-   * ValidateUtil.isSignedFloat("-12.34"); // true
-   * ```
-   */
-  static isSignedFloat(input: string): boolean;
-  static _unsignedFloat: RegExp;
-  /**
-   * 验证是否为无符号浮点数
-   * @example
-   * ```ts
-   * ValidateUtil.isUnsignedFloat("12.34"); // true
-   * ```
-   */
-  static isUnsignedFloat(input: string): boolean;
-  static _signedInteger: RegExp;
-  /**
-   * 验证是否为有符号整数
-   * @example
-   * ```ts
-   * ValidateUtil.isSignedInteger("-12"); // true
-   * ```
-   */
-  static isSignedInteger(input: string): boolean;
-  static _unsignedInteger: RegExp;
-  /**
-   * 验证是否为无符号整数
-   * @example
-   * ```ts
-   * ValidateUtil.isUnsignedInteger("12"); // true
-   * ```
-   */
-  static isUnsignedInteger(input: string): boolean;
-  static _spaceInclude: RegExp;
-  /**
-   * 验证是否包含空格
-   * @example
-   * ```ts
-   * ValidateUtil.isSpaceInclude("a b"); // true
-   * ```
-   */
-  static isSpaceInclude(input: string): boolean;
-  static _spaceStart: RegExp;
-  /**
-   * 验证是否以空格开头
-   * @example
-   * ```ts
-   * ValidateUtil.isSpaceStart(" abc"); // true
-   * ```
-   */
-  static isSpaceStart(input: string): boolean;
-  static _spaceEnd: RegExp;
-  /**
-   * 验证是否以空格结尾
-   * @example
-   * ```ts
-   * ValidateUtil.isSpaceEnd("abc "); // true
-   * ```
-   */
-  static isSpaceEnd(input: string): boolean;
-  /**
-   * 验证是否以空格开头或结尾
-   * @example
-   * ```ts
-   * ValidateUtil.isSpaceStartOrEnd(" abc"); // true
-   * ```
-   */
-  static isSpaceStartOrEnd(input: string): boolean;
-}
-//#endregion
-export { ArrayUtil, type CurrencyCode, type CurrencyLocale, CurrencyUtil, DateTimeUtil, EnvUtil, type FormatterOptions, FunctionUtil, type MatchFunction, MimeUtil, NumberUtil, ObjectUtil, StringUtil, type THEME_MODE_TYPE, type THEME_TYPE, ThemeUtil, TreeUtil, TypeUtil, ValidateUtil, type ZipOptions };