@longmo-utils/common 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2249 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let _ctrl_tinycolor = require("@ctrl/tinycolor");
+let theme_colors = require("theme-colors");
+let dayjs = require("dayjs");
+dayjs = __toESM(dayjs);
+let dayjs_plugin_timezone_js = require("dayjs/plugin/timezone.js");
+dayjs_plugin_timezone_js = __toESM(dayjs_plugin_timezone_js);
+let dayjs_plugin_utc_js = require("dayjs/plugin/utc.js");
+dayjs_plugin_utc_js = __toESM(dayjs_plugin_utc_js);
+
+//#region package.json
+var version = "1.0.0";
+
+//#endregion
+//#region src/_internal/_version.ts
+/**
+* 工具箱版本
+* @public
+*/
+const _version = version;
+
+//#endregion
+//#region src/array/unique.ts
+/**
+* 移除数组中的重复值
+*
+* @param arr - 输入数组
+* @returns 去除重复值后的新数组
+* @example
+* ```ts
+* unique([1, 2, 2, 3, 3, 3]) // [1, 2, 3]
+* unique(['a', 'b', 'a', 'c']) // ['a', 'b', 'c']
+* ```
+*/
+function unique(arr) {
+	return Array.from(new Set(arr));
+}
+
+//#endregion
+//#region src/array/groupBy.ts
+/**
+* 根据键函数对数组元素进行分组
+*
+* @param arr - 要分组的输入数组
+* @param keyFn - 返回每个元素的分组键的函数
+* @returns 对象，其中键是分组结果，值是元素数组
+* @example
+* ```ts
+* const data = [
+*   { name: 'Alice', role: 'admin' },
+*   { name: 'Bob', role: 'user' },
+*   { name: 'Charlie', role: 'admin' }
+* ]
+* groupBy(data, item => item.role)
+* // { admin: [{ name: 'Alice', role: 'admin' }, { name: 'Charlie', role: 'admin' }],
+* //   user: [{ name: 'Bob', role: 'user' }] }
+* ```
+*/
+function groupBy(arr, keyFn) {
+	return arr.reduce((acc, item) => {
+		const key = keyFn(item);
+		if (!acc[key]) acc[key] = [];
+		acc[key].push(item);
+		return acc;
+	}, {});
+}
+
+//#endregion
+//#region src/array/chunk.ts
+/**
+* 将数组拆分成指定大小的子数组
+*
+* @param arr - 要拆分的输入数组
+* @param size - 每个子数组的大小。如果小于等于 0，则默认为 1
+* @returns 子数组的数组
+* @example
+* ```ts
+* chunk([1, 2, 3, 4, 5], 2) // [[1, 2], [3, 4], [5]]
+* chunk([1, 2, 3, 4, 5], 3) // [[1, 2, 3], [4, 5]]
+* chunk([1, 2, 3], 5) // [[1, 2, 3]]
+* chunk([1, 2, 3], 0) // [[1], [2], [3]] (size 默认为 1)
+* chunk([1, 2, 3], -2) // [[1], [2], [3]] (size 默认为 1)
+* ```
+*/
+function chunk(arr, size) {
+	if (size <= 0) size = 1;
+	const result = [];
+	for (let i = 0; i < arr.length; i += size) result.push(arr.slice(i, i + size));
+	return result;
+}
+
+//#endregion
+//#region src/array/uniqueByField.ts
+/**
+* @Author: longmo
+* @Date: 2026-01-25 20:41:10
+* @LastEditTime: 2026-01-25 20:41:19
+* @FilePath: packages/common/src/array/uniqueByField.ts
+* @Description:
+*/
+/**
+* 根据指定字段对对象数组进行去重
+* @param arr 要去重的对象数组
+* @param key 去重依据的字段名
+* @returns 去重后的对象数组
+*/
+function uniqueByField(arr, key) {
+	const seen = /* @__PURE__ */ new Map();
+	return arr.filter((item) => {
+		const value = item[key];
+		return seen.has(value) ? false : (seen.set(value, item), true);
+	});
+}
+
+//#endregion
+//#region src/object/deepClone.ts
+/**
+* 深度克隆一个对象
+* @param obj - 要克隆的对象
+* @returns 克隆后的对象
+* @example
+* ```ts
+* const obj = {a: 1, b: {c: 2}}
+* const cloned = deepClone(obj)
+* cloned.b.c = 3
+* console.log(obj.b.c) // 2
+* ```
+* @public
+*/
+function deepClone(obj) {
+	if (obj === null || typeof obj !== "object") return obj;
+	if (Array.isArray(obj)) return obj.map((item) => deepClone(item));
+	const cloned = {};
+	for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) cloned[key] = deepClone(obj[key]);
+	return cloned;
+}
+
+//#endregion
+//#region src/object/deepEqual.ts
+/**
+* 深度比较两个对象是否相等
+* @param a - 第一个对象
+* @param b - 第二个对象
+* @returns 是否相等
+* @example
+* ```ts
+* deepEqual({a: 1}, {a: 1}) // true
+* deepEqual({a: {b: 1}}, {a: {b: 1}}) // true
+* deepEqual({a: 1}, {a: 2}) // false
+* ```
+* @public
+*/
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (typeof a !== "object" || a === null || b === null) return false;
+	const keysA = Object.keys(a);
+	const keysB = Object.keys(b);
+	if (keysA.length !== keysB.length) return false;
+	for (const key of keysA) {
+		if (!keysB.includes(key)) return false;
+		if (!deepEqual(a[key], b[key])) return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/object/deepMerge.ts
+/**
+* 深度合并多个对象
+* @param objects - 要合并的对象数组
+* @returns 合并后的对象
+* @example
+* ```ts
+* deepMerge({a: 1}, {b: 2}) // {a: 1, b: 2}
+* deepMerge({a: {x: 1}}, {a: {y: 2}}) // {a: {x: 1, y: 2}}
+* ```
+* @public
+*/
+function deepMerge(...objects) {
+	const result = {};
+	for (const obj of objects) for (const key in obj) if (obj[key] !== void 0) if (typeof obj[key] === "object" && obj[key] !== null && !Array.isArray(obj[key]) && typeof result[key] === "object" && result[key] !== null) result[key] = deepMerge(result[key], obj[key]);
+	else result[key] = obj[key];
+	return result;
+}
+
+//#endregion
+//#region src/object/get.ts
+/**
+* 通过路径字符串获取对象的嵌套值
+* @param obj - 对象
+* @param path - 路径字符串，使用点分隔
+* @param defaultValue - 默认值
+* @returns 获取的值
+* @example
+* ```ts
+* const obj = {a: {b: {c: 1}}}
+* get(obj, 'a.b.c') // 1
+* get(obj, 'a.b.d', 'default') // 'default'
+* ```
+* @public
+*/
+function get(obj, path, defaultValue) {
+	const keys = path.split(".");
+	let result = obj;
+	for (const key of keys) {
+		if (result === null || result === void 0) return defaultValue;
+		result = result[key];
+	}
+	return result !== void 0 ? result : defaultValue;
+}
+
+//#endregion
+//#region src/object/set.ts
+/**
+* 通过路径字符串设置对象的嵌套值
+* @param obj - 对象
+* @param path - 路径字符串，使用点分隔
+* @param value - 要设置的值
+* @example
+* ```ts
+* const obj = {a: {}}
+* set(obj, 'a.b.c', 1)
+* console.log(obj) // {a: {b: {c: 1}}}
+* ```
+* @public
+*/
+function set(obj, path, value) {
+	const keys = path.split(".");
+	const lastKey = keys.pop();
+	let current = obj;
+	for (const key of keys) {
+		if (current[key] === void 0) current[key] = {};
+		current = current[key];
+	}
+	current[lastKey] = value;
+}
+
+//#endregion
+//#region src/function/debounce.ts
+/**
+* 防抖函数，延迟执行函数
+* @param fn - 要执行的函数
+* @param delay - 延迟时间（毫秒）
+* @returns 防抖后的函数
+* @example
+* ```ts
+* const debouncedFn = debounce(() => console.log('hello'), 300)
+* debouncedFn() // 300ms 后执行
+* debouncedFn() // 重置计时器，300ms 后执行
+* ```
+* @public
+*/
+function debounce(fn, delay) {
+	let timeoutId = null;
+	return function(...args) {
+		if (timeoutId !== null) clearTimeout(timeoutId);
+		timeoutId = setTimeout(() => {
+			fn.apply(this, args);
+		}, delay);
+	};
+}
+
+//#endregion
+//#region src/function/memoize.ts
+/**
+* 创建函数的记忆化版本，缓存函数结果
+* @param fn - 要记忆化的函数
+* @param keyFn - 可选的缓存键生成函数
+* @returns 记忆化后的函数
+* @example
+* ```ts
+* const memoizedFn = memoize((a: number) => a * 2)
+* memoizedFn(2) // 4，计算并缓存
+* memoizedFn(2) // 4，从缓存返回
+* ```
+* @public
+*/
+function memoize(fn, keyFn) {
+	const cache = /* @__PURE__ */ new Map();
+	return ((...args) => {
+		const key = keyFn ? keyFn(...args) : JSON.stringify(args);
+		if (cache.has(key)) return cache.get(key);
+		const result = fn(...args);
+		cache.set(key, result);
+		return result;
+	});
+}
+
+//#endregion
+//#region src/function/partial.ts
+/**
+* 创建偏函数，预设部分参数
+* @param fn - 原始函数
+* @param presetArgs - 预设的参数
+* @returns 偏函数
+* @example
+* ```ts
+* const add = (a: number, b: number) => a + b
+* const add5 = partial(add, 5)
+* add5(3) // 8
+* ```
+* @public
+*/
+function partial(fn, ...presetArgs) {
+	return function(...remainingArgs) {
+		return fn(...presetArgs, ...remainingArgs);
+	};
+}
+
+//#endregion
+//#region src/function/throttle.ts
+/**
+* 节流函数，限制函数执行频率
+* @param fn - 要执行的函数
+* @param delay - 节流时间间隔（毫秒）
+* @returns 节流后的函数
+* @example
+* ```ts
+* const throttledFn = throttle(() => console.log('hello'), 300)
+* throttledFn() // 立即执行
+* throttledFn() // 300ms 内不执行
+* ```
+* @public
+*/
+function throttle(fn, delay) {
+	let lastCall = 0;
+	let timeoutId = null;
+	return function(...args) {
+		const now = Date.now();
+		if (now - lastCall >= delay) {
+			lastCall = now;
+			fn.apply(this, args);
+		} else if (timeoutId === null) timeoutId = setTimeout(() => {
+			lastCall = Date.now();
+			timeoutId = null;
+			fn.apply(this, args);
+		}, delay - (now - lastCall));
+	};
+}
+
+//#endregion
+//#region src/string/camelCase.ts
+/**
+* 将字符串转换为驼峰命名
+* @param str - 输入字符串
+* @returns 驼峰命名字符串
+* @example
+* ```ts
+* camelCase('hello-world') // 'helloWorld'
+* camelCase('hello_world') // 'helloWorld'
+* camelCase('hello world') // 'helloWorld'
+* ```
+* @public
+*/
+function camelCase(str) {
+	return str.replace(/[-_\s]+(.)?/g, (_, char) => char?.toUpperCase() || "").replace(/^(.)/, (_, char) => char?.toLowerCase() || "");
+}
+
+//#endregion
+//#region src/string/capitalize.ts
+/**
+* 将字符串首字母大写
+* @param str - 输入字符串
+* @returns 首字母大写的字符串
+* @example
+* ```ts
+* capitalize('hello') // 'Hello'
+* capitalize('hello world') // 'Hello world'
+* ```
+* @public
+*/
+function capitalize(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+//#endregion
+//#region src/string/isEmpty.ts
+/**
+* 检查字符串是否为空或只包含空白字符
+* @param str - 输入字符串
+* @returns 如果为空或只包含空白字符返回 true
+* @example
+* ```ts
+* isEmpty('') // true
+* isEmpty('   ') // true
+* isEmpty(null) // true
+* isEmpty(undefined) // true
+* isEmpty('hello') // false
+* ```
+* @public
+*/
+function isEmpty(str) {
+	return !str || str.trim().length === 0;
+}
+
+//#endregion
+//#region src/string/kebabCase.ts
+/**
+* 将字符串转换为短横线命名
+* @param str - 输入字符串
+* @returns 短横线命名字符串
+* @example
+* ```ts
+* kebabCase('helloWorld') // 'hello-world'
+* kebabCase('hello_world') // 'hello-world'
+* kebabCase('hello world') // 'hello-world'
+* ```
+* @public
+*/
+function kebabCase(str) {
+	return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+
+//#endregion
+//#region src/string/random.ts
+/**
+* 生成指定长度的随机字符串
+* @param length - 随机字符串的长度（默认: 8）
+* @returns 随机字符串
+* @example
+* ```ts
+* random() // 'aB3dE7fG'
+* random(12) // 'xY9kL2mN3pQ'
+* ```
+* @public
+*/
+function random(length = 8) {
+	const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+	let result = "";
+	for (let i = 0; i < length; i++) result += chars.charAt(Math.floor(Math.random() * 62));
+	return result;
+}
+
+//#endregion
+//#region src/string/snakeCase.ts
+/**
+* 将字符串转换为下划线命名
+* @param str - 输入字符串
+* @returns 下划线命名字符串
+* @example
+* ```ts
+* snakeCase('helloWorld') // 'hello_world'
+* snakeCase('hello-world') // 'hello_world'
+* snakeCase('hello world') // 'hello_world'
+* ```
+* @public
+*/
+function snakeCase(str) {
+	return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+}
+
+//#endregion
+//#region src/string/truncate.ts
+/**
+* 截断字符串到指定长度
+* @param str - 输入字符串
+* @param length - 最大长度
+* @param suffix - 截断时添加的后缀（默认: '...'）
+* @returns 截断后的字符串
+* @example
+* ```ts
+* truncate('hello world', 5) // 'hello...'
+* truncate('hello world', 11) // 'hello world'
+* truncate('hello world', 5, '---') // 'hello---'
+* ```
+* @public
+*/
+function truncate(str, length, suffix = "...") {
+	if (str.length <= length) return str;
+	return str.slice(0, length) + suffix;
+}
+
+//#endregion
+//#region src/util/isTypeOf.ts
+/**
+* 安全的类型检查
+* @param  arg - 判断的参数
+* @returns 返回类型字符串
+* @example
+* ```ts
+* isTypeOf(10);                  // "number"
+* isTypeOf("abc");               // "string"
+* isTypeOf(true);                // "boolean"
+* isTypeOf(null);                // "null"
+* isTypeOf(undefined);           // "undefined"
+* isTypeOf({a: 1});              // "object"
+* isTypeOf([1,2,3]);             // "array"
+* isTypeOf(new Date());          // "date"
+* isTypeOf(/^\d{6}$/);           // "regexp"
+* isTypeOf(Symbol('1'));         // "symbol"
+* isTypeOf(function(){});        // "function"
+* isTypeOf(new Error());         // "error"
+* isTypeOf(new Promise(()=>{})); // "promise"
+* isTypeOf(new Set());           // "set"
+* isTypeOf(new Map());           // "map"
+* isTypeOf(Math);                // "math"
+* ```
+* @public
+*/
+function isTypeOf(arg) {
+	return Object.prototype.toString.call(arg).replace(/\[object (\w+)\]/, "$1").toLowerCase();
+}
+
+//#endregion
+//#region src/util/isArray.ts
+/**
+* 是否是数组
+* @param arg - 参数
+* @returns `true|false`
+* @example
+* ```ts
+* isArray({}) // false
+* isArray(1) // false
+* isArray([]) // true
+* ```
+*
+* @public
+*/
+function isArray(arg) {
+	return isTypeOf(arg) === "array";
+}
+
+//#endregion
+//#region src/util/isEmptyObject.ts
+/**
+* 是否是空对象
+* @remarks
+* ```
+* 1、校验结果和`jquery.isEmptyObject()`一致
+* 2、只有可枚举对象并且有枚举的值才返回false
+* 3、不可枚举值，始终返回true
+* ```
+* @param arg
+* @returns `true|false`
+* @example
+* ```ts
+* isEmptyObject('') // true 不可枚举
+* isEmptyObject(null) // true 不可枚举
+* isEmptyObject(undefined) // true 不可枚举
+* isEmptyObject({}) // true 可枚举，没有枚举属性
+* isEmptyObject({a:1}) // false 可枚举，有枚举属性
+* isEmptyObject(new Object()) // true 可枚举，没有属性
+* isEmptyObject([]) // true 可枚举，没有枚举属性
+* isEmptyObject([1]) // false 可枚举，有枚举属性
+* ```
+* @public
+*/
+function isEmptyObject(arg) {
+	if (arg == null) return true;
+	for (const _key in arg) return false;
+	return true;
+}
+
+//#endregion
+//#region src/util/isObject.ts
+/**
+* 是否是对象
+* @param arg - 参数
+* @returns `true|false`
+* @example
+* ```ts
+* isObject({}) // true
+* isObject(1) // false
+* isObject([]) // false
+* ```
+*
+* @public
+*/
+function isObject(arg) {
+	return isTypeOf(arg) === "object";
+}
+
+//#endregion
+//#region src/string/safeJsonStringify.ts
+/**
+* 安全的json序列化，只对object和array进行转换，其他原样返回
+* @param value - 待序列化的值
+* @returns 序列化的值
+* @example
+* ```ts
+* safeJsonStringify({a:1}); // => `{"a":1}`
+* safeJsonStringify([1,"2"]); // => `[1,"2"]`
+* safeJsonStringify({}); // => null 空值处理
+* safeJsonStringify([]); // => null 空值处理
+* safeJsonStringify(null); // => null 空值处理
+* safeJsonStringify("abc"); // => "abc" 原样返回
+* safeJsonStringify(123); // => 123  原样返回
+* ```
+*/
+function safeJsonStringify(value) {
+	if (isObject(value)) return isEmptyObject(value) ? null : JSON.stringify(value);
+	else if (isArray(value)) return isEmptyObject(value) ? null : JSON.stringify(value);
+	else return value;
+}
+
+//#endregion
+//#region src/util/isString.ts
+/**
+* 是否是字符串
+* @param arg - 参数
+* @returns `true|false`
+* @example
+* ```ts
+* isString(123) // false
+* isString("abc") // true
+* isString(String(1)) // true
+* ```
+*
+* @public
+*/
+function isString(arg) {
+	return isTypeOf(arg) === "string";
+}
+
+//#endregion
+//#region src/string/safeParseJson.ts
+/**
+* 安全的JSON字符串解析
+* @param jsonString - 待转换的字符串
+* @param rollback - 转换失败后回退的备选值，默认`{}`
+* @returns JSONObject JSONArray
+* @example
+* ```ts
+* safeParseJson('{"name": "abc", age: 20}'); // => {name: "abc", age: 20} 正常解析
+* safeParseJson(0); // => {} 解析失败默认回退处理
+* safeParseJson(`[name=123]`, []); // => [] 解析失败回退处理
+* ```
+*/
+function safeParseJson(jsonString, rollback = {}) {
+	if (isString(jsonString)) {
+		let json;
+		try {
+			json = JSON.parse(jsonString);
+		} catch (e) {
+			json = rollback;
+		}
+		return json;
+	} else return rollback;
+}
+
+//#endregion
+//#region src/util/isBoolean.ts
+/**
+* 是否是布尔值
+* @param arg - 参数
+* @returns `true|false`
+* @example
+* ```ts
+* isBoolean(123) // false
+* isBoolean(Boolean('1')) // true
+* isBoolean(true) // true
+* ```
+*
+* @public
+*/
+function isBoolean(arg) {
+	return isTypeOf(arg) === "boolean";
+}
+
+//#endregion
+//#region src/util/isDate.ts
+/**
+* 是否是日期对象
+* @param arg - 参数
+* @returns `true|false`
+* @example
+* ```ts
+* isDate(new Date()) // true
+* ```
+*
+* @public
+*/
+function isDate(arg) {
+	return isTypeOf(arg) === "date";
+}
+
+//#endregion
+//#region src/util/isError.ts
+/**
+* 是否是错误对象
+* @param arg - 参数
+* @returns `true|false`
+* @example
+* ```ts
+* isError(new Error('122')) // true
+* ```
+*
+* @public
+*/
+function isError(arg) {
+	return isTypeOf(arg) === "error";
+}
+
+//#endregion
+//#region src/util/isFunction.ts
+/**
+* 是否是函数
+* @param arg - 参数
+* @returns `true|false`
+* @example
+* ```ts
+* isFunction(function(){}) // true
+* ```
+*
+* @public
+*/
+function isFunction(arg) {
+	return isTypeOf(arg) === "function";
+}
+
+//#endregion
+//#region src/util/isMap.ts
+/**
+* 是否是Map
+* @param arg - 参数
+* @returns `true|false`
+* @example
+* ```ts
+* isMap(new Map()) // true
+* ```
+*
+* @public
+*/
+function isMap(arg) {
+	return isTypeOf(arg) === "map";
+}
+
+//#endregion
+//#region src/util/isNull.ts
+/**
+* 是否是null
+* @param arg - 参数
+* @returns `true|false`
+* @example
+* ```ts
+* isNull(null) // true
+* isNull(1) // false
+* ```
+*
+* @public
+*/
+function isNull(arg) {
+	return isTypeOf(arg) === "null";
+}
+
+//#endregion
+//#region src/util/isUndefined.ts
+/**
+* 是否是undefined
+* @param arg - 参数
+* @returns `true|false`
+* @example
+* ```ts
+* isUndefined(undefined) // true
+* isUndefined(a) // true a未定义
+* isUndefined(void 0) // true
+* ```
+*
+* @public
+*/
+function isUndefined(arg) {
+	return typeof arg === "undefined";
+}
+
+//#endregion
+//#region src/util/isNil.ts
+/**
+* 检测`value`是否是`null`或`undefined`
+* @param value - 待检测值
+* @returns boolean
+* @example 
+* ```ts
+* isNil(null); // => true
+* isNil(void 0); // => true
+* isNil(NaN); // => false
+* ```
+*/
+function isNil(value) {
+	if (isUndefined(value)) return true;
+	else return isNull(value);
+}
+
+//#endregion
+//#region src/util/isNumber.ts
+/**
+* 是否是数字
+* @param arg - 参数
+* @returns `true|false`
+* @example
+* ```ts
+* isNumber(123) // true
+* isNumber(Number('1')) // true
+* isNumber("abc") // false
+* ```
+*
+* @public
+*/
+function isNumber(arg) {
+	return isTypeOf(arg) === "number";
+}
+
+//#endregion
+//#region src/util/isPromise.ts
+/**
+* 是否是Promise
+* @param arg - 参数
+* @returns `true|false`
+* @example
+* ```ts
+* isPromise(new Promise(()=>{})) // true
+* ```
+*
+* @public
+*/
+function isPromise(arg) {
+	return isTypeOf(arg) === "promise";
+}
+
+//#endregion
+//#region src/util/isRegExp.ts
+/**
+* 是否是正则
+* @param arg - 参数
+* @returns `true|false`
+* @example
+* ```ts
+* isRegExp(/^\d+/) // true
+* isRegExp(new RegExp("\w")) // true
+* ```
+*
+* @public
+*/
+function isRegExp(arg) {
+	return isTypeOf(arg) === "regexp";
+}
+
+//#endregion
+//#region src/util/isSet.ts
+/**
+* 是否是Set
+* @param arg - 参数
+* @returns `true|false`
+* @example
+* ```ts
+* isSet(new Set([1,2,3])) // true
+* ```
+*
+* @public
+*/
+function isSet(arg) {
+	return isTypeOf(arg) === "set";
+}
+
+//#endregion
+//#region src/util/isSymbol.ts
+/**
+* 是否是符号
+* @param arg - 参数
+* @returns `true|false`
+* @example
+* ```ts
+* isSymbol(Symbol(1)) // true
+* ```
+*
+* @public
+*/
+function isSymbol(arg) {
+	return isTypeOf(arg) === "symbol";
+}
+
+//#endregion
+//#region src/url/querystringify.ts
+/**
+* 解码一个URI编码的字符串。
+*
+* @param  input - URI编码字符串
+* @returns  解码后的字符串
+* @internal
+*/
+function _decode(input) {
+	try {
+		return decodeURIComponent(input.replace(/\+/g, " "));
+	} catch (e) {
+		return null;
+	}
+}
+/**
+* 尝试编码给定输入
+*
+* @param  input - 需要编码的字符串
+* @returns  编码后的字符串
+* @internal
+*/
+function _encode(input) {
+	try {
+		return encodeURIComponent(input);
+	} catch (e) {
+		return null;
+	}
+}
+/**
+* querystring转换成对象
+*
+* @param  obj - 需要被转换的查询对象
+* @param  prefix - 添加前缀
+* @returns url查询字符串
+* @example
+* ```ts
+*  querystringify({ foo: bar });       // foo=bar
+*  querystringify({ foo: bar }, '#');  // #foo=bar
+*  querystringify({ foo: '' }, '&');   // &foo=
+* ```
+*
+* @public
+*/
+function querystringify(obj, prefix = "") {
+	let pairs = [];
+	let value;
+	let key;
+	for (key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) {
+		value = obj[key];
+		if (!value && (value === null || value === void 0 || isNaN(value))) value = "";
+		key = _encode(key);
+		value = _encode(value);
+		if (key === null) continue;
+		if (value === null) value = "";
+		pairs.push(key + "=" + value);
+	}
+	return pairs.length ? prefix + pairs.join("&") : "";
+}
+
+//#endregion
+//#region src/url/parseQueryString.ts
+/**
+* 解析URL查询字符串，转换成JSON格式
+*
+* @param query - 查询字符串，可以是?开头也可以是#号开头
+* @returns 解析为对象
+* @example
+* ```ts
+* parseQueryString('?foo=bar');         // { foo: 'bar' }
+* parseQueryString('#foo=bar');         // { foo: 'bar' }
+* parseQueryString('foo=bar');          // { foo: 'bar' }
+* parseQueryString('foo=bar&bar=foo');  // { foo: 'bar', bar: 'foo' }
+* parseQueryString('foo&bar=foo');      // { foo: '', bar: 'foo' }
+* ```
+*
+* @public
+*/
+function parseQueryString(query) {
+	if (!query) return {};
+	let parser = /([^=?#&]+)=?([^&]*)/g, result = {}, part;
+	while (part = parser.exec(query)) {
+		let key = _decode(part[1]), value = _decode(part[2]);
+		if (key === null) continue;
+		if (value === null) value = void 0;
+		result[key] = value;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/url/urlParse.ts
+/**
+* url解析，在URL基础上扩展了查询字符串解析对象
+* @param urlString - url格式字符串
+* @returns IURL - 返回URL对象扩展了searchObject和hashSearchObject
+* @example
+* ```ts
+* const urlStr = 'https://www.baidu.com/path1/path2?foo=1&bar=a/#/hashpath1/hashpath2?hashfoo=1&hashbar=a'
+* const url = urlParse(urlStr)
+* {
+*  hash: "#/hashpath1/hashpath2?hashfoo=1&hashbar=a",
+*  hashSearchObject: {
+*    hashfoo: '1',
+*    hashbar: 'a'
+*  }
+*  host: "www.baidu.com"
+*  hostname: "www.baidu.com"
+*  href: "https://www.baidu.com/path1/path2?foo=1&bar=a/#/hashpath1/hashpath2?hashfoo=1&hashbar=a"
+*  origin: "https://www.baidu.com"
+*  password: ""
+*  pathname: "/path1/path2"
+*  port: ""
+*  protocol: "https:"
+*  search: "?foo=1&bar=a/"
+*  searchObject: {
+*    foo: '1',
+*    bar: 'a'
+*  }
+*  username: ""
+* }
+* ```
+*
+* @public
+*/
+function urlParse(urlString = "") {
+	try {
+		const url = new URL(urlString);
+		const parsed = {};
+		for (const key in url) if (key !== "toString" && key !== "toJSON" && key !== "searchParams") parsed[key] = url[key];
+		parsed["searchObject"] = parseQueryString(url.search.replace(/\/$/, ""));
+		parsed["hashSearchObject"] = parseQueryString(url.hash.replace(/^#.+\?/, ""));
+		return parsed;
+	} catch (err) {
+		return {};
+	}
+}
+
+//#endregion
+//#region src/accountant/convertChineseNumber.ts
+/**
+* 阿拉伯数字转中文数字
+* @param num 需要转换的数字
+* @returns 返回转换后的中文字符串
+* @example
+* ```ts
+* convertChineseNumber(0); // 零
+* convertChineseNumber(1); // 一
+* convertChineseNumber(10); // 十
+* convertChineseNumber(11); // 十一
+* convertChineseNumber(11.12); // 十一点一二
+* convertChineseNumber(100); // 一百
+* convertChineseNumber(123); // 一百二十三
+* ```
+* @public
+*/
+function convertChineseNumber(num) {
+	if (num === 0) return "零";
+	const AA = [
+		"零",
+		"一",
+		"二",
+		"三",
+		"四",
+		"五",
+		"六",
+		"七",
+		"八",
+		"九",
+		"十"
+	];
+	const BB = [
+		"",
+		"十",
+		"百",
+		"千",
+		"万",
+		"亿",
+		"点",
+		""
+	];
+	const a = ("" + num).replace(/(^0*)/g, "").split(".");
+	let k = 0;
+	let re = "";
+	for (let i = a[0].length - 1; i >= 0; i--) {
+		switch (k) {
+			case 0:
+				re = BB[7] + re;
+				break;
+			case 4:
+				if (!new RegExp("0{4}//d{" + (a[0].length - i - 1) + "}$").test(a[0])) re = BB[4] + re;
+				break;
+			case 8:
+				re = BB[5] + re;
+				BB[7] = BB[5];
+				k = 0;
+				break;
+		}
+		if (k % 4 == 2 && a[0].charAt(i + 2) !== "0" && a[0].charAt(i + 1) === "0") re = AA[0] + re;
+		if (a[0].charAt(i) !== "0") re = AA[Number(a[0].charAt(i))] + BB[k % 4] + re;
+		k++;
+	}
+	if (a.length > 1) {
+		re += BB[6];
+		for (let i = 0; i < a[1].length; i++) re += AA[Number(a[1].charAt(i))];
+	}
+	if (re == "一十") re = "十";
+	if (re.match(/^一/) && re.length == 3) re = re.replace("一", "");
+	return re;
+}
+
+//#endregion
+//#region src/accountant/convertCurrency.ts
+const CN_CHAR = {
+	"$0": "零",
+	"$1": "壹",
+	"$2": "贰",
+	"$3": "叁",
+	"$4": "肆",
+	"$5": "伍",
+	"$6": "陆",
+	"$7": "柒",
+	"$8": "捌",
+	"$9": "玖",
+	"$10": "拾",
+	"$100": "佰",
+	"$1000": "仟",
+	"$10000": "万",
+	"$100000000": "亿",
+	"CN_SYMBOL": "人民币",
+	"DOLLAR": "元",
+	"$0.1": "角",
+	"$0.01": "分",
+	"$0.001": "毫",
+	"$0.0001": "厘",
+	"INTEGER": "整"
+};
+/**
+* 阿拉伯数字换成汉字大写金额
+* @remarks
+* ```
+* 小数点最多支持到4位单位厘
+* 金额最大支持1万亿
+* ```
+* @param currencyDigits - 转换的金额字符串或数字
+* @param prefixSymbol - 前缀默认false（true=人民币, false=''）
+* @returns 转换成汉字大写金额格式
+* @example
+* ```ts
+* convertCurrency(0); // 零圆整
+* convertCurrency(1234) // 壹仟贰佰叁拾肆圆整
+* convertCurrency('9877662.090') // 玖佰捌拾柒万柒仟陆佰陆拾贰圆零角玖分
+* convertCurrency('9877662.097866') // 玖佰捌拾柒万柒仟陆佰陆拾贰圆零角玖分柒毫捌厘
+* convertCurrency('4231234.04', true)) // 人民币肆佰贰拾叁万壹仟贰佰叁拾肆圆零角肆分
+* ```
+* @public
+*/
+function convertCurrency(currencyDigits, prefixSymbol = false) {
+	const MAXIMUM_INTEGRAL = 999999999999;
+	let integral;
+	let decimal;
+	let outputCharacters;
+	let parts;
+	let digits, radices, bigRadices, decimals;
+	if (isNaN(Number(currencyDigits))) {
+		console.warn("金额无效！");
+		return "";
+	}
+	let currencyDigitsStr = currencyDigits.toString();
+	if (currencyDigitsStr === "") {
+		console.warn("请输入小写金额！");
+		return "";
+	}
+	if (currencyDigitsStr.match(/[^,.\d]/) != null) {
+		console.warn("小写金额含有无效字符！");
+		return "";
+	}
+	if (currencyDigitsStr.match(/^((\d{1,3}(,\d{3})*(.((\d{3},)*\d{1,3}))?)|(\d+(.\d+)?))$/) == null) {
+		console.warn("小写金额的格式不正确！");
+		return "";
+	}
+	currencyDigitsStr = currencyDigitsStr.replace(/,/g, "");
+	currencyDigitsStr = currencyDigitsStr.replace(/^0+/, "");
+	parts = currencyDigitsStr.split(".");
+	if (parts.length > 1) {
+		integral = parts[0];
+		decimal = parts[1];
+		decimal = decimal.substr(0, 4);
+	} else {
+		integral = parts[0];
+		decimal = "";
+	}
+	if (Number(integral) > MAXIMUM_INTEGRAL) integral = MAXIMUM_INTEGRAL + "";
+	digits = [
+		CN_CHAR.$0,
+		CN_CHAR.$1,
+		CN_CHAR.$2,
+		CN_CHAR.$3,
+		CN_CHAR.$4,
+		CN_CHAR.$5,
+		CN_CHAR.$6,
+		CN_CHAR.$7,
+		CN_CHAR.$8,
+		CN_CHAR.$9
+	];
+	radices = [
+		"",
+		CN_CHAR.$10,
+		CN_CHAR.$100,
+		CN_CHAR.$1000
+	];
+	bigRadices = [
+		"",
+		CN_CHAR.$10000,
+		CN_CHAR.$100000000
+	];
+	decimals = [
+		CN_CHAR["$0.1"],
+		CN_CHAR["$0.01"],
+		CN_CHAR["$0.001"],
+		CN_CHAR["$0.0001"]
+	];
+	outputCharacters = "";
+	if (Number(integral) > 0) {
+		let zeroCount = 0;
+		for (let i = 0; i < integral.length; i++) {
+			let p = integral.length - i - 1;
+			let d = integral.substr(i, 1);
+			let quotient = p / 4;
+			let modulus = p % 4;
+			if (d == "0") zeroCount++;
+			else {
+				if (zeroCount > 0) outputCharacters += digits[0];
+				zeroCount = 0;
+				outputCharacters += digits[Number(d)] + radices[modulus];
+			}
+			if (modulus == 0 && zeroCount < 4) {
+				outputCharacters += bigRadices[quotient];
+				zeroCount = 0;
+			}
+		}
+		outputCharacters += CN_CHAR.DOLLAR;
+	}
+	decimal = decimal.replace(/0+$/, "");
+	if (decimal !== "") for (let i = 0; i < decimal.length; i++) {
+		let d = decimal.substr(i, 1);
+		outputCharacters += digits[Number(d)] + decimals[i];
+	}
+	if (outputCharacters == "") outputCharacters = CN_CHAR.$0 + CN_CHAR.DOLLAR;
+	if (decimal == "") outputCharacters += CN_CHAR.INTEGER;
+	if (prefixSymbol) outputCharacters = CN_CHAR.CN_SYMBOL + outputCharacters;
+	return outputCharacters;
+}
+
+//#endregion
+//#region src/_internal/_numeral.ts
+let _numeral = null;
+/**
+* 异步获取 Numeral 实例（已配置中文本地化）
+* 这是一个懒加载导入，避免将 numeral 作为直接依赖
+*
+* @example
+* ```ts
+* const numeral = await getNumeral()
+* numeral(1000).format('$0,0.00') // '¥1,000.00'
+* ```
+*/
+async function getNumeral() {
+	if (_numeral) return _numeral;
+	const numeral = await import("numeral");
+	numeral.register("locale", "ch", {
+		delimiters: {
+			thousands: ",",
+			decimal: "."
+		},
+		abbreviations: {
+			thousand: "千",
+			million: "百万",
+			billion: "十亿",
+			trillion: "兆"
+		},
+		ordinal: function() {
+			return ".";
+		},
+		currency: { symbol: "¥" }
+	});
+	numeral.locale("ch");
+	_numeral = numeral.default;
+	return _numeral;
+}
+/**
+* 同步获取 Numeral 实例（仅用于测试环境）
+* 使用 ESM 动态导入，配合 vitest setupFiles 预加载使用
+* 
+* 注意：此函数本质是异步的，但为了保持 API 一致性命名为 sync
+* 请确保在测试运行前通过 setupFiles 预加载
+*
+* @throws {Error} 如果 numeral 未安装
+*
+* @example
+* ```ts
+* // 在测试 setup 文件中预加载
+* import { getNumeralSync } from './_numeral'
+* await getNumeralSync()
+* 
+* // 然后在代码中可以直接使用
+* const numeral = getNumeralSync() // 返回缓存实例
+* ```
+*/
+function getNumeralSync() {
+	if (_numeral) return _numeral;
+	throw new Error("numeral 未加载。请确保在测试 setup 文件中调用 await getNumeralSync() 预加载");
+}
+
+//#endregion
+//#region src/accountant/format.ts
+/**
+* 通用格式化，需要手动指定格式
+* @remarks
+* format用法：http://numeraljs.com/
+* @param input - 待格式化数字
+* @param format - 输出格式，默认''，默认不保留小数，格式整数
+* @returns 返回格式化字符串
+* @example
+* ```ts
+* format(1230974.998979).format() // "1,230,975"
+* ```
+* @public
+*/
+function format(input, format = "") {
+	try {
+		return getNumeralSync()(input).format(format);
+	} catch (e) {
+		console.warn("格式化错误，请确保已安装 numeral: npm install numeral");
+		return "";
+	}
+}
+
+//#endregion
+//#region src/accountant/formatMoney.ts
+/**
+* 金额格式化
+* @remarks
+* ```
+* `0,0.00`：尾端保留2位小数，四舍五入
+* format用法：http://numeraljs.com/
+* ```
+* @param input - 待格式化金额
+* @param format - 输出格式，默认'0,0.00'，尾端保留2位小数，四舍五入，自定义需手动指定格式
+* @returns 返回千分位格式化字符串
+* @example
+* ```ts
+* formatMoney(1000.234) // 1,000.23
+* formatMoney(1000.235) // 1,000.24
+* formatMoney(1000.235, '$0,0.00') // ¥1,000.24 只设置货币
+* formatNumber(1230974, '0.0a') // 1.2千万
+* ```
+* @public
+*/
+function formatMoney(input, format = "0,0.00") {
+	try {
+		return getNumeralSync()(input).format(format);
+	} catch (e) {
+		console.warn("金额格式化错误，请确保已安装 numeral: npm install numeral");
+		return "";
+	}
+}
+
+//#endregion
+//#region src/accountant/formatNumber.ts
+/**
+* 数字格式化
+* @remarks
+* ```
+* `0,0[.]00` - 小数位（可选）有则四舍五入保留2位小数
+* format用法：http://numeraljs.com/
+* ```
+* @param input - 待格式化数字
+* @param format - 输出格式，默认'0,0[.]00'，小数位（可选）有则四舍五入保留2位小数，自定义需手动指定格式
+* @returns 返回千分位格式化字符串
+* @example
+* ```ts
+* formatNumber(789789.025) // "789,789.03"
+* formatNumber(789789.00) // "789,789"
+* formatNumber(789789.005) // "789,789.01"
+* formatNumber(1230974, '0.0a') // 1.2千万
+* ```
+* @public
+*/
+function formatNumber(input, format = "0,0[.]00") {
+	try {
+		return getNumeralSync()(input).format(format);
+	} catch (e) {
+		console.warn("数字格式化错误，请确保已安装 numeral: npm install numeral");
+		return "";
+	}
+}
+
+//#endregion
+//#region src/accountant/formatPercentage.ts
+/**
+* 百分比格式化
+* @remarks
+* ```
+* `0.[00]%` - 小数位（可选）有则四舍五入保留2位小数
+* format用法：http://numeraljs.com/
+* ```
+* @param input - 待格式化数字
+* @param format - 输出格式，默认'0.[00]%'，小数位（可选）有则四舍五入保留2位小数，自定义需手动指定格式
+* @returns 返回百分比格式化字符串
+* @example
+* ```ts
+* formatPercentage(0.4567) // "45.67%"
+* formatPercentage(0.456) // "45.6%"
+* formatPercentage(0.45600) // "46%"
+* formatPercentage(0.4567, '0.00%') // "45.67%"
+* ```
+* @public
+*/
+function formatPercentage(input, format = "0.00%") {
+	try {
+		return getNumeralSync()(input).format(format);
+	} catch (e) {
+		console.warn("百分比格式化错误，请确保已安装 numeral: npm install numeral");
+		return "";
+	}
+}
+
+//#endregion
+//#region src/accountant/getFormatStr.ts
+/**
+* 快速生成numeraljs格式字符串, 处理千分位和小数位，可以继续使用format方法进行格式化，小数位处理方式四舍五入
+* @remarks
+* @param options - 格式选项同数字组件的options { separate: true, point: 0 }
+* @param unit - 是否显示单位，formatType=“percent” 字段加上单位，如“%”, 其他字段使用自定义单元（如果设置了）
+* @returns 返回格式字符串
+* @example
+* ```ts
+* getFormatStr() // "0,0" 默认格式字符串
+* getFormatStr({ separate: true, point: 2 }) // '0,0.00'
+* getFormatStr({ separate: false, point: 2 }) // '00.00'
+* ```
+* @public
+*/
+function getFormatStr(options = {
+	separate: true,
+	point: 0
+}) {
+	const { separate, point } = options;
+	let formatStr = "";
+	formatStr = separate ? "0,0" : "0";
+	if (point > 0) formatStr += "." + Array(point).fill(0).join("");
+	return formatStr;
+}
+
+//#endregion
+//#region src/accountant/toFixed.ts
+/**
+* 数字格式化，指定需要保留的小数位数，解决部分浏览器兼容性问题，如`(0.615).toFixed(2) === '0.61');`
+* @remarks
+* ```
+* 修复Number.prototype.toFixed兼容性问题
+* `(0.615).toFixed(2) === '0.61');`，按照银行家法原则应该是0.62''
+* 位数不够，后面补0
+* ```
+* @param number - 需要转换的数字
+* @param digits - 需要保留的位数，只允许 [0, 20] 之间的数字
+* @returns 返回格式化后的字符串
+* @example
+* ```ts
+* toFixed(25.198726354, 0);       // 25
+* toFixed(25.198726354, 1);       // 25.2
+* toFixed(25.198726354, 2);       // 25.20
+* toFixed(25.198726354, 3);       // 25.199
+* toFixed(25.198726354, 4);       // 25.1987
+* toFixed(25.198726354, 5);       // 25.19873
+* toFixed(25.198726354, 6);       // 25.198726
+* toFixed(25, 2);                 // 25.00
+* toFixed(25.125, 4);             // 25.1250
+* ```
+* @public
+*/
+function toFixed(number, digits = 2) {
+	if (digits < 0) digits = 0;
+	if (digits > 20) digits = 20;
+	return getNumeralSync()._.toFixed(number, digits, Math.round);
+}
+
+//#endregion
+//#region src/accountant/unformat.ts
+/**
+* 反格式化，自动识别格式
+* @remarks
+* format用法：http://numeraljs.com/
+* @param input - 待格式化数字
+* @returns 返回转换后的数字，无法识别返回NaN
+*
+* @example
+* ```ts
+* unformat('18:13:09') // 65589 (秒)
+* unformat('34.78%') //  0.3478
+* unformat('7,883.9876') //  7883.9876
+* unformat('￥7,883.9876') //  7883.9876
+* unformat('1.8千') //  1800
+* unformat('1.8百万') //  1800000
+* unformat('1.8十亿') //  1800000000
+* unformat('1.8兆') //  1800000000000
+* ```
+*
+* @public
+*/
+function unformat(input = "") {
+	try {
+		return getNumeralSync()(input).value();
+	} catch (e) {
+		console.warn("格式化错误，请确保已安装 numeral: npm install numeral");
+		return NaN;
+	}
+}
+
+//#endregion
+//#region src/color/color.ts
+function isDarkColor(color) {
+	return new _ctrl_tinycolor.TinyColor(color).isDark();
+}
+function isLightColor(color) {
+	return new _ctrl_tinycolor.TinyColor(color).isLight();
+}
+
+//#endregion
+//#region src/color/convert.ts
+/**
+* 将颜色转换为HSL格式。
+*
+* HSL是一种颜色模型，包括色相(Hue)、饱和度(Saturation)和亮度(Lightness)三个部分。
+*
+* @param {string} color 输入的颜色。
+* @returns {string} HSL格式的颜色字符串。
+*/
+function convertToHsl(color) {
+	const { a, h, l, s } = new _ctrl_tinycolor.TinyColor(color).toHsl();
+	const hsl = `hsl(${Math.round(h)} ${Math.round(s * 100)}% ${Math.round(l * 100)}%)`;
+	return a < 1 ? `${hsl} ${a}` : hsl;
+}
+/**
+* 将颜色转换为HSL CSS变量。
+*
+* 这个函数与convertToHsl函数类似，但是返回的字符串格式稍有不同，
+* 以便可以作为CSS变量使用。
+*
+* @param {string} color 输入的颜色。
+* @returns {string} 可以作为CSS变量使用的HSL格式的颜色字符串。
+*/
+function convertToHslCssVar(color) {
+	const { a, h, l, s } = new _ctrl_tinycolor.TinyColor(color).toHsl();
+	const hsl = `${Math.round(h)} ${Math.round(s * 100)}% ${Math.round(l * 100)}%`;
+	return a < 1 ? `${hsl} / ${a}` : hsl;
+}
+/**
+* 将颜色转换为RGB颜色字符串
+* TinyColor无法处理hsl内包含'deg'、'grad'、'rad'或'turn'的字符串
+* 比如 hsl(231deg 98% 65%)将被解析为rgb(0, 0, 0)
+* 这里在转换之前先将这些单位去掉
+* @param str 表示HLS颜色值的字符串
+* @returns 如果颜色值有效，则返回对应的RGB颜色字符串；如果无效，则返回rgb(0, 0, 0)
+*/
+function convertToRgb(str) {
+	return new _ctrl_tinycolor.TinyColor(str.replace(/deg|grad|rad|turn/g, "")).toRgbString();
+}
+/**
+* 检查颜色是否有效
+* @param {string} color - 待检查的颜色
+* 如果颜色有效返回true，否则返回false
+*/
+function isValidColor(color) {
+	if (!color) return false;
+	return new _ctrl_tinycolor.TinyColor(color).isValid;
+}
+
+//#endregion
+//#region src/color/generator.ts
+function generatorColorVariables(colorItems) {
+	const colorVariables = {};
+	colorItems.forEach(({ alias, color, name }) => {
+		if (color) {
+			const colorsMap = (0, theme_colors.getColors)(new _ctrl_tinycolor.TinyColor(color).toHexString());
+			let mainColor = colorsMap["500"];
+			Object.keys(colorsMap).forEach((key) => {
+				const colorValue = colorsMap[key];
+				if (colorValue) {
+					const hslColor = convertToHslCssVar(colorValue);
+					colorVariables[`--${name}-${key}`] = hslColor;
+					if (alias) colorVariables[`--${alias}-${key}`] = hslColor;
+					if (key === "500") mainColor = hslColor;
+				}
+			});
+			if (alias && mainColor) colorVariables[`--${alias}`] = mainColor;
+		}
+	});
+	return colorVariables;
+}
+
+//#endregion
+//#region src/date/formatDate.ts
+/**
+* 日期格式化模块
+*/
+dayjs.default.extend(dayjs_plugin_utc_js.default);
+dayjs.default.extend(dayjs_plugin_timezone_js.default);
+/**
+* 格式化日期
+*
+* 将各种日期格式转换为指定格式的字符串，支持时区转换
+*
+* @param time - 日期值，可以是 Date 对象、dayjs 对象、时间戳或字符串
+* @param format - 输出格式，默认为 'YYYY-MM-DD'
+*
+* @returns 格式化后的日期字符串
+*
+* @example 格式化为日期
+* ```typescript
+* formatDate(new Date()); // '2024-01-25'
+* ```
+*
+* @example 格式化为日期时间
+* ```typescript
+* formatDate(new Date(), 'YYYY-MM-DD HH:mm:ss'); // '2024-01-25 14:30:00'
+* ```
+*
+* @example 格式化为时间
+* ```typescript
+* formatDate(new Date(), 'HH:mm:ss'); // '14:30:00'
+* ```
+*
+* @example 格式化时间戳
+* ```typescript
+* formatDate(1706161800000, 'YYYY-MM-DD'); // '2024-01-25'
+* ```
+*
+* @example 格式化日期字符串
+* ```typescript
+* formatDate('2024-01-25T06:30:00Z', 'YYYY-MM-DD HH:mm'); // '2024-01-25 14:30'
+* ```
+*
+* @example 使用 dayjs 对象
+* ```typescript
+* import dayjs from 'dayjs';
+* const date = dayjs('2024-01-25');
+* formatDate(date, 'YYYY/MM/DD'); // '2024/01/25'
+* ```
+*/
+function formatDate(time, format = "YYYY-MM-DD") {
+	try {
+		const date = dayjs.default.isDayjs(time) ? time : (0, dayjs.default)(time);
+		if (!date.isValid()) throw new Error("Invalid date");
+		return date.tz().format(format);
+	} catch (error) {
+		console.error(`Error formatting date: ${error}`);
+		return String(time ?? "");
+	}
+}
+
+//#endregion
+//#region src/date/formatDateTime.ts
+/**
+* 格式化日期时间
+*
+* 将日期格式化为完整的日期时间字符串（YYYY-MM-DD HH:mm:ss）
+*
+* @param time - 日期值，可以是 Date 对象、dayjs 对象、时间戳或字符串
+*
+* @returns 格式化后的日期时间字符串
+*
+* @example 格式化当前日期时间
+* ```typescript
+* formatDateTime(); // '2024-01-25 14:30:00'
+* ```
+*
+* @example 格式化指定日期
+* ```typescript
+* formatDateTime(new Date(2024, 0, 25, 14, 30, 0)); // '2024-01-25 14:30:00'
+* ```
+*
+* @example 格式化时间戳
+* ```typescript
+* formatDateTime(1706161800000); // '2024-01-25 14:30:00'
+* ```
+*
+* @example 格式化字符串日期
+* ```typescript
+* formatDateTime('2024-01-25T06:30:00Z'); // '2024-01-25 14:30:00'
+* ```
+*/
+function formatDateTime(time) {
+	return formatDate(time, "YYYY-MM-DD HH:mm:ss");
+}
+
+//#endregion
+//#region src/date/isDateInstance.ts
+/**
+* 日期实例类型检查模块
+*/
+/**
+* 检查值是否为 Date 实例
+*
+* 使用 instanceof 操作符判断一个值是否为 Date 对象
+*
+* @param value - 要检查的值
+* @returns 是否为 Date 实例
+*
+* @example 检查 Date 对象
+* ```typescript
+* const date = new Date();
+* isDateInstance(date); // true
+* ```
+*
+* @example 检查非 Date 对象
+* ```typescript
+* isDateInstance('2024-01-25'); // false
+* isDateInstance(123456); // false
+* isDateInstance(null); // false
+* ```
+*
+* @example 类型守卫
+* ```typescript
+* function process(value: unknown) {
+*   if (isDateInstance(value)) {
+*     console.log(value.getFullYear()); // TypeScript 知道 value 是 Date
+*   }
+* }
+* ```
+*/
+function isDateInstance(value) {
+	return value instanceof Date;
+}
+
+//#endregion
+//#region src/date/isDayjsObject.ts
+/**
+* dayjs 对象类型检查模块
+*/
+/**
+* 检查值是否为 dayjs 对象
+*
+* 使用 dayjs.isDayjs 方法判断一个值是否为 dayjs 对象
+*
+* @param value - 要检查的值
+* @returns 是否为 dayjs 对象
+*
+* @example 检查 dayjs 对象
+* ```typescript
+* const date = dayjs();
+* isDayjsObject(date); // true
+* ```
+*
+* @example 检查非 dayjs 对象
+* ```typescript
+* isDayjsObject(new Date()); // false
+* isDayjsObject('2024-01-25'); // false
+* isDayjsObject(123456); // false
+* ```
+*
+* @example 类型守卫
+* ```typescript
+* function process(value: unknown) {
+*   if (isDayjsObject(value)) {
+*     console.log(value.format('YYYY-MM-DD')); // TypeScript 知道 value 是 Dayjs
+*   }
+* }
+* ```
+*/
+function isDayjsObject(value) {
+	return dayjs.default.isDayjs(value);
+}
+
+//#endregion
+//#region src/date/constants.ts
+/**
+* 日期时间常量
+*/
+dayjs.default.extend(dayjs_plugin_utc_js.default);
+dayjs.default.extend(dayjs_plugin_timezone_js.default);
+/**
+* 获取当前时区
+*
+* @returns 当前时区名称（如 'Asia/Shanghai'）
+*
+* @example 获取系统时区
+* ```typescript
+* const tz = getSystemTimezone();
+* console.log(tz); // 'Asia/Shanghai'
+* ```
+*/
+const getSystemTimezone = () => {
+	return dayjs.default.tz.guess();
+};
+/**
+* 自定义设置的时区
+*/
+let currentTimezone = getSystemTimezone();
+/**
+* 设置默认时区
+*
+* 设置后续所有日期操作使用的时区
+*
+* @param timezone - 时区字符串，如果为空则使用系统时区
+*
+* @example 设置为东八区
+* ```typescript
+* setCurrentTimezone('Asia/Shanghai');
+* ```
+*
+* @example 设置为 UTC
+* ```typescript
+* setCurrentTimezone('UTC');
+* ```
+*
+* @example 重置为系统时区
+* ```typescript
+* setCurrentTimezone();
+* ```
+*/
+const setCurrentTimezone = (timezone) => {
+	currentTimezone = timezone || getSystemTimezone();
+	dayjs.default.tz.setDefault(currentTimezone);
+};
+/**
+* 获取设置的时区
+*
+* @returns 当前设置的时区名称
+*
+* @example 获取当前时区
+* ```typescript
+* setCurrentTimezone('Asia/Tokyo');
+* const tz = getCurrentTimezone();
+* console.log(tz); // 'Asia/Tokyo'
+* ```
+*/
+const getCurrentTimezone = () => {
+	return currentTimezone;
+};
+
+//#endregion
+//#region src/tree/traverseTreeValues.ts
+/**
+* 遍历树形结构，并返回所有节点中指定的值
+*
+* 使用深度优先遍历（DFS）遍历树形结构的所有节点，提取每个节点的指定值
+*
+* @typeParam T - 树节点类型
+* @typeParam V - 节点值的类型
+*
+* @param tree - 树形结构数组
+* @param getValue - 获取节点值的函数
+* @param options - 配置选项
+* @param options.childProps - 子节点属性名称，默认为 'children'
+*
+* @returns 所有节点中指定的值的数组
+*
+* @example 提取所有节点的 id
+* ```typescript
+* const tree = [
+*   { id: 1, name: 'A', children: [{ id: 2, name: 'A-1' }] },
+*   { id: 3, name: 'B' }
+* ];
+* const ids = traverseTreeValues(tree, node => node.id);
+* console.log(ids); // [1, 2, 3]
+* ```
+*
+* @example 使用自定义子节点属性
+* ```typescript
+* const tree = [
+*   { id: 1, items: [{ id: 2 }] }
+* ];
+* const ids = traverseTreeValues(
+*   tree,
+*   node => node.id,
+*   { childProps: 'items' }
+* );
+* ```
+*
+* @example 提取所有节点的名称
+* ```typescript
+* const names = traverseTreeValues(tree, node => node.name);
+* console.log(names); // ['A', 'A-1', 'B']
+* ```
+*/
+function traverseTreeValues(tree, getValue, options) {
+	const result = [];
+	const childProps = options?.childProps ?? "children";
+	const dfs = (treeNode) => {
+		const value = getValue(treeNode);
+		result.push(value);
+		const children = treeNode?.[childProps];
+		if (!children) return;
+		if (children.length > 0) for (const child of children) dfs(child);
+	};
+	for (const treeNode of tree) dfs(treeNode);
+	return result.filter(Boolean);
+}
+
+//#endregion
+//#region src/tree/filterTree.ts
+/**
+* 根据条件过滤给定树结构的节点
+*
+* 保留满足条件的节点及其祖先节点，保持原有的层级结构
+*
+* @typeParam T - 树节点类型，必须是对象类型
+*
+* @param tree - 要过滤的树结构的根节点数组
+* @param filter - 用于匹配每个节点的条件函数
+* @param options - 配置选项
+* @param options.childProps - 子节点属性名称，默认为 'children'
+*
+* @returns 包含所有匹配节点的数组
+*
+* @example 过滤包含特定属性的节点
+* ```typescript
+* const tree = [
+*   { id: 1, active: true, children: [
+*     { id: 2, active: false },
+*     { id: 3, active: true }
+*   ]},
+*   { id: 4, active: false }
+* ];
+*
+* const result = filterTree(tree, node => node.active);
+* console.log(result);
+* // [
+* //   { id: 1, active: true, children: [{ id: 3, active: true }] }
+* // ]
+* ```
+*
+* @example 过滤包含特定文本的节点
+* ```typescript
+* const tree = [
+*   { name: 'A', children: [{ name: 'Apple' }] },
+*   { name: 'B', children: [{ name: 'Banana' }] }
+* ];
+*
+* const result = filterTree(tree, node => node.name.includes('A'));
+* console.log(result);
+* // [
+* //   { name: 'A', children: [{ name: 'Apple' }] }
+* // ]
+* ```
+*
+* @example 使用自定义子节点属性
+* ```typescript
+* const tree = [
+*   { id: 1, items: [{ id: 2, visible: true }] }
+* ];
+*
+* const result = filterTree(
+*   tree,
+*   node => node.visible,
+*   { childProps: 'items' }
+* );
+* ```
+*/
+function filterTree(tree, filter, options) {
+	const childProps = options?.childProps ?? "children";
+	const _filterTree = (nodes) => {
+		return nodes.filter((node) => {
+			if (filter(node)) {
+				if (node[childProps]) node[childProps] = _filterTree(node[childProps]);
+				return true;
+			}
+			return false;
+		});
+	};
+	return _filterTree(tree);
+}
+
+//#endregion
+//#region src/tree/mapTree.ts
+/**
+* 根据条件重新映射给定树结构的节点
+*
+* 对树形结构的每个节点应用映射函数，生成新的树形结构
+*
+* @typeParam T - 源树节点类型
+* @typeParam V - 目标树节点类型，必须是对象类型
+*
+* @param tree - 要映射的树结构的根节点数组
+* @param mapper - 用于映射每个节点的函数
+* @param options - 配置选项
+* @param options.childProps - 子节点属性名称，默认为 'children'
+*
+* @returns 映射后的树形结构数组
+*
+* @example 添加新属性到节点
+* ```typescript
+* const tree = [
+*   { id: 1, name: 'A', children: [{ id: 2, name: 'A-1' }] }
+* ];
+*
+* const result = mapTree(tree, node => ({
+*   ...node,
+*   label: `${node.name} (${node.id})`
+* }));
+* console.log(result);
+* // [
+* //   { id: 1, name: 'A', label: 'A (1)', children: [
+* //     { id: 2, name: 'A-1', label: 'A-1 (2)' }
+* //   ]}
+* // ]
+* ```
+*
+* @example 转换节点类型
+* ```typescript
+* const tree = [
+*   { value: 'a', children: [{ value: 'a-1' }] }
+* ];
+*
+* const result = mapTree(tree, node => ({
+*   text: node.value,
+*   checked: false
+* }));
+* console.log(result);
+* // [
+* //   { text: 'a', checked: false, children: [{ text: 'a-1', checked: false }] }
+* // ]
+* ```
+*
+* @example 使用自定义子节点属性
+* ```typescript
+* const tree = [
+*   { id: 1, items: [{ id: 2 }] }
+* ];
+*
+* const result = mapTree(
+*   tree,
+*   node => ({ ...node, mapped: true }),
+*   { childProps: 'items' }
+* );
+* ```
+*/
+function mapTree(tree, mapper, options) {
+	const childProps = options?.childProps ?? "children";
+	return tree.map((node) => {
+		const mapperNode = mapper(node);
+		if (mapperNode[childProps]) mapperNode[childProps] = mapTree(mapperNode[childProps], mapper, options);
+		return mapperNode;
+	});
+}
+
+//#endregion
+//#region src/tree/sortTree.ts
+/**
+* 对树形结构数据进行递归排序
+*
+* 对树形结构的每一层节点应用排序函数，保持层级结构
+*
+* @typeParam T - 树节点类型，必须是对象类型
+*
+* @param treeData - 树形数据数组
+* @param sortFunction - 排序函数，用于定义排序规则
+* @param options - 配置选项
+* @param options.childProps - 子节点属性名称，默认为 'children'
+*
+* @returns 排序后的树形数据
+*
+* @example 按 id 升序排序
+* ```typescript
+* const tree = [
+*   { id: 3, name: 'C', children: [{ id: 5, name: 'E' }] },
+*   { id: 1, name: 'A', children: [{ id: 4, name: 'D' }, { id: 2, name: 'B' }] }
+* ];
+*
+* const result = sortTree(tree, (a, b) => a.id - b.id);
+* console.log(result);
+* // [
+* //   { id: 1, name: 'A', children: [
+* //     { id: 2, name: 'B' },
+* //     { id: 4, name: 'D' }
+* //   ]},
+* //   { id: 3, name: 'C', children: [{ id: 5, name: 'E' }] }
+* // ]
+* ```
+*
+* @example 按名称字母顺序排序
+* ```typescript
+* const tree = [
+*   { name: 'Zebra', children: [{ name: 'Y' }] },
+*   { name: 'Apple', children: [{ name: 'Beta' }] }
+* ];
+*
+* const result = sortTree(tree, (a, b) => a.name.localeCompare(b.name));
+* console.log(result);
+* // [
+* //   { name: 'Apple', children: [{ name: 'Beta' }] },
+* //   { name: 'Zebra', children: [{ name: 'Y' }] }
+* // ]
+* ```
+*
+* @example 按自定义属性排序
+* ```typescript
+* const tree = [
+*   { priority: 2, tasks: [{ priority: 3 }] },
+*   { priority: 1, tasks: [{ priority: 2 }] }
+* ];
+*
+* const result = sortTree(
+*   tree,
+*   (a, b) => a.priority - b.priority,
+*   { childProps: 'tasks' }
+* );
+* ```
+*/
+function sortTree(treeData, sortFunction, options) {
+	const childProps = options?.childProps ?? "children";
+	return [...treeData].sort(sortFunction).map((item) => {
+		const children = item[childProps];
+		if (children && Array.isArray(children) && children.length > 0) {
+			const result = { ...item };
+			result[childProps] = sortTree(children, sortFunction, options);
+			return result;
+		}
+		return item;
+	});
+}
+
+//#endregion
+//#region src/_internal/_dayjs.ts
+let _dayjs = null;
+/**
+* 异步获取 Dayjs 实例（已配置中文本地化和季度插件）
+* 这是一个懒加载导入，避免将 dayjs 作为直接依赖
+*
+* @example
+* ```ts
+* const dayjs = await getDayjs()
+* dayjs().format('YYYY-MM-DD') // '2024-01-25'
+* ```
+*/
+async function getDayjs() {
+	if (_dayjs) return _dayjs;
+	const dayjs = await import("dayjs");
+	const quarterOfYear = await import("dayjs/plugin/quarterOfYear");
+	await import("dayjs/locale/zh-cn");
+	dayjs.default.extend(quarterOfYear.default);
+	dayjs.default.locale("zh-cn");
+	_dayjs = dayjs.default;
+	return _dayjs;
+}
+/**
+* 同步获取 Dayjs 实例（仅用于测试环境）
+* 使用 ESM 动态导入，配合 vitest setupFiles 预加载使用
+*
+* 注意：此函数本质是异步的，但为了保持 API 一致性命名为 sync
+* 请确保在测试运行前通过 setupFiles 预加载
+*
+* @throws {Error} 如果 dayjs 未安装
+*
+* @example
+* ```ts
+* // 在测试 setup 文件中预加载
+* import { getDayjsSync } from './_dayjs'
+* await getDayjsSync()
+* 
+* // 然后在代码中可以直接使用
+* const dayjs = getDayjsSync() // 返回缓存实例
+* ```
+*/
+function getDayjsSync() {
+	if (_dayjs) return _dayjs;
+	throw new Error("dayjs 未加载。请确保在测试 setup 文件中调用 await getDayjsSync() 预加载");
+}
+
+//#endregion
+exports.TinyColor = _ctrl_tinycolor.TinyColor;
+exports._decode = _decode;
+exports._encode = _encode;
+exports._version = _version;
+exports.camelCase = camelCase;
+exports.capitalize = capitalize;
+exports.chunk = chunk;
+exports.convertChineseNumber = convertChineseNumber;
+exports.convertCurrency = convertCurrency;
+exports.convertToHsl = convertToHsl;
+exports.convertToHslCssVar = convertToHslCssVar;
+exports.convertToRgb = convertToRgb;
+exports.debounce = debounce;
+exports.deepClone = deepClone;
+exports.deepEqual = deepEqual;
+exports.deepMerge = deepMerge;
+exports.filterTree = filterTree;
+exports.format = format;
+exports.formatDate = formatDate;
+exports.formatDateTime = formatDateTime;
+exports.formatMoney = formatMoney;
+exports.formatNumber = formatNumber;
+exports.formatPercentage = formatPercentage;
+exports.generatorColorVariables = generatorColorVariables;
+exports.get = get;
+exports.getCurrentTimezone = getCurrentTimezone;
+exports.getDayjs = getDayjs;
+exports.getDayjsSync = getDayjsSync;
+exports.getFormatStr = getFormatStr;
+exports.getNumeral = getNumeral;
+exports.getNumeralSync = getNumeralSync;
+exports.getSystemTimezone = getSystemTimezone;
+exports.groupBy = groupBy;
+exports.isArray = isArray;
+exports.isBoolean = isBoolean;
+exports.isDarkColor = isDarkColor;
+exports.isDate = isDate;
+exports.isDateInstance = isDateInstance;
+exports.isDayjsObject = isDayjsObject;
+exports.isEmpty = isEmpty;
+exports.isEmptyObject = isEmptyObject;
+exports.isError = isError;
+exports.isFunction = isFunction;
+exports.isLightColor = isLightColor;
+exports.isMap = isMap;
+exports.isNil = isNil;
+exports.isNull = isNull;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
+exports.isSet = isSet;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isTypeOf = isTypeOf;
+exports.isUndefined = isUndefined;
+exports.isValidColor = isValidColor;
+exports.kebabCase = kebabCase;
+exports.mapTree = mapTree;
+exports.memoize = memoize;
+exports.parseQueryString = parseQueryString;
+exports.partial = partial;
+exports.querystringify = querystringify;
+exports.random = random;
+exports.safeJsonStringify = safeJsonStringify;
+exports.safeParseJson = safeParseJson;
+exports.set = set;
+exports.setCurrentTimezone = setCurrentTimezone;
+exports.snakeCase = snakeCase;
+exports.sortTree = sortTree;
+exports.throttle = throttle;
+exports.toFixed = toFixed;
+exports.traverseTreeValues = traverseTreeValues;
+exports.truncate = truncate;
+exports.unformat = unformat;
+exports.unique = unique;
+exports.uniqueByField = uniqueByField;
+exports.urlParse = urlParse;
+//# sourceMappingURL=index.cjs.map