ph-utils 0.20.0 → 1.0.0

package/lib/index.js

@@ -1,239 +1,1543 @@
+import { a as toRgb, i as toHsv, n as rgbToHex, r as toHex, t as adjust } from "./color-CUZrwrjD.js";
+//#region src/common.ts
 /**
- * node 和 web 通用的工具类
- */
+* node 和 web 通用的基础工具函数
+*/
 /** 包含字母+数字的随机数字符 */
 const RANDOM_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-/** 只包含字母的随机数字符 */
-const NUMBER_RANDOM_CHARTS = "0123456789";
-/**
- * 验证参数是否为空
- * @param str               待验证的参数
- * @param ignoreWhitespace  如果是字符串是否忽略空格(包括空白字符串以及[\r\t\n]之类的制表符)，默认为true
- */
-export function isBlank(str, ignoreWhitespace = true) {
-    if (str == null) {
-        return true;
-    }
-    return ((ignoreWhitespace && typeof str === "string"
-        ? str.trim().length
-        : str.length) === 0);
-}
-/**
- * 屏蔽手机号，中间部分用 * 展示
- * @param mobile 待屏蔽的手机号
- * @returns 屏蔽后的手机号，例如：123 **** 1234
- */
-export function shieldMobile(mobile) {
-    const x1 = Math.floor(mobile.length / 2);
-    const x2 = Math.ceil(x1 / 2);
-    const shields = [" "];
-    for (let i = 0; i < x1 - 1; i++) {
-        shields.push("*");
-    }
-    shields.push(" ");
-    return (mobile.substring(0, x2) + shields.join("") + mobile.substring(x2 + x1 - 1));
-}
-/**
- * 验证参数是否是数字
- * @param str 待验证的字符串
- * @param numericParam 通过参数标记是否包含小数、正数
- * @param numericParam.isPositive 是否是正数, 默认: false
- * @param numericParam.isFloat 是否是小数, 默认: true
- * @returns true 是数字, false 不是数字
- */
-export function isNumeric(str, numericParam) {
-    numericParam = { isPositive: false, isFloat: true, ...numericParam };
-    const symbol = numericParam.isPositive ? "[+]?" : "[+-]?";
-    const main = numericParam.isFloat ? "([0-9]*[.])?[0-9]+" : "[0-9]+";
-    return new RegExp("^" + symbol + main + "$").test(str);
-}
-/**
- * 验证参数是否是Boolean 类型
- * @param str 待验证的字符串
- * @returns
- */
-export function isBoolean(str) {
-    return ["true", "false"].indexOf(str) >= 0;
-}
-export function random(opts) {
-    if (typeof opts === "object" && opts.min != null && opts.max != null) {
-        const randomNum = Math.random();
-        /* 生成两个数字之间的随机数(number) */
-        const end = opts.hasEnd ? 1 : 0;
-        const resRandom = randomNum * (opts.max - opts.min + end) + opts.min;
-        return opts.isInteger !== false ? Math.floor(resRandom) : resRandom;
-    }
-    else {
-        if (typeof opts === "object" && opts.length == null) {
-            throw new Error("random_length_cannot_null");
-        }
-        let len = typeof opts === "object" ? opts.length : opts;
-        /* 生成指定长度的随机数 */
-        let chars = RANDOM_CHARS;
-        if (typeof opts === "object" && opts.hasLetter === false) {
-            chars = NUMBER_RANDOM_CHARTS;
-        }
-        const resRandom = Array.from({ length: len }, () => chars.charAt(random({ min: 0, max: chars.length - 1, hasEnd: true }))).join("");
-        if (typeof opts === "object" &&
-            opts.firstIsZero === false &&
-            resRandom.indexOf("0") === 0) {
-            return random(opts);
-        }
-        else {
-            return resRandom;
-        }
-    }
-}
-/**
- * 带有错误名称标记的错误类型
- */
-export class BaseError extends Error {
-    constructor() {
-        if (arguments.length === 1) {
-            super(arguments[0]);
-            this.name = "BaseError";
-        }
-        else {
-            super(arguments[1]);
-            this.name = arguments[0];
-        }
-    }
-}
-/**
- * 将金额数字格式化为金额格式显示并且会保留两位小数[去除多余的位数，不是四舍五入，而是直接舍去]  1234523432.23 => 123,123,123.23
- * @param {number} number 待转换的金额数字
- * @return string
- */
-export function formatMoney(number) {
-    if (typeof Intl.NumberFormat !== "undefined") {
-        const formatter = new Intl.NumberFormat("zh-CN", {
-            style: "decimal",
-            maximumFractionDigits: 2,
-        });
-        return formatter.format(number);
-    }
-    else {
-        number = number || 0;
-        const negative = "";
-        const base = String(parseInt(number, 10)); // 获取数字整数部分
-        const mod = base.length > 3 ? base.length % 3 : 0;
-        /*
-         * 利用 正则前瞻 (?=) 将3位数字后面还紧跟一位数字的三位数字替换为 数字, 的形式
-         */
-        const numberStr = String(number);
-        const usePrecision = numberStr.indexOf(".");
-        let dotStr = usePrecision > 0 ? numberStr.slice(usePrecision + 1) : "00";
-        dotStr = dotStr.length > 2 ? dotStr.slice(0, 2) : dotStr;
-        return (negative +
-            (mod ? base.slice(0, mod) + "," : "") +
-            base.slice(mod).replace(/(\d{3})(?=\d)/g, "$1,") +
-            "." +
-            dotStr);
-    }
-}
-/**
- * 将风格由大写风格转换为下划线风格: HelloWorld -> hello-world
- * @param name 命名, 例如: HelloWorld
- * @param connector 连接符, 默认为: _
- */
-export function snakeCaseStyle(name, connector = "-") {
-    return name.replace(/([A-Z])/g, (match, p1, offset) => (offset > 0 ? connector : "") + match.toLowerCase());
-}
-/**
- * 对数字进行四舍五入处理
- * @param num 需要进行四舍五入的数字
- * @param precision 精度，默认为2，即保留小数点后两位
- * @param roundType 舍入类型，默认为0，提供三种取值:
- *        0: 标准四舍五入
- *        1: 向上取整
- *        2: 向下取整
- * @returns 返回经过指定方式舍入后的数字
- */
-export function round(num, precision = 2, roundType = 0) {
-    // 计算精度因子，用于后续四舍五入计算
-    const factor = Math.pow(10, precision);
-    switch (roundType) {
-        case 0:
-            // 标准四舍五入
-            return Math.round(num * factor) / factor;
-        case 1:
-            // 向上取整
-            return Math.ceil(num * factor) / factor;
-        case 2:
-            // 向下取整
-            return Math.floor(num * factor) / factor;
-        default:
-            // 如果传入的roundType不是预期的值，则直接返回原始数字
-            return num;
-    }
-}
-/**
- * 反转字符串
- */
-export function reverseStr(str) {
-    return str.split("").reverse().join("");
-}
-function getObjKeyValue(data, key) {
-    if (data == null)
-        return null;
-    return data[key];
-}
-/**
- * 嵌套的 json 指定 key 数据
- * @param data JSON格式数据
- * @param keys 待获取的数据 key, 可以通过 [.] 获取嵌套数据, 例如: a.b.c
- * @returns
- */
-export function getJSONValue(data, keystr) {
-    if (data == null)
-        return null;
-    const keys = keystr.split(".");
-    let res = data;
-    for (const key of keys) {
-        res = getObjKeyValue(res, key);
-        if (res == null)
-            break;
-    }
-    return res;
-}
-/**
- * 数据格式化主要用于数据类型转换
- * @param data 待转换数据类型的数据
- * @param config 转换配置
- * @returns
- */
-export function formatData(data, config) {
-    const cfg = {
-        numberFields: [],
-        stringFields: [],
-        formatter: {},
-        ...config,
-    };
-    const res = {};
-    for (const key in data) {
-        let value = getJSONValue(data, key);
-        let formater;
-        if (key in cfg.formatter) {
-            formater = cfg.formatter[key];
-        }
-        if (cfg.numberFields.includes(key)) {
-            formater = "number";
-        }
-        if (cfg.stringFields.includes(key)) {
-            formater = "string";
-        }
-        if (formater != null) {
-            if (typeof formater == "function") {
-                value = formater(value);
-            }
-            else if (formater == "number") {
-                value = Number(value);
-            }
-            else if (formater == "string") {
-                value = String(value);
-            }
-        }
-        res[key] = value;
-    }
-    return res;
+/** 只包含数字的随机数字符 */
+const NUMBER_RANDOM_CHARS = "0123456789";
+/**
+* 验证参数是否为空
+* @param str               待验证的参数
+* @param ignoreWhitespace  如果是字符串是否忽略空格(包括空白字符串以及[\r\t\n]之类的制表符)，默认为true
+*/
+function isBlank(str, ignoreWhitespace = true) {
+	if (str == null) return true;
+	if (typeof str !== "string") return str.length === 0;
+	return ignoreWhitespace ? str.trim().length === 0 : str.length === 0;
+}
+/**
+* 屏蔽手机号，中间部分用 * 展示（保持向后兼容）
+* @param mobile 待屏蔽的手机号
+* @param placeholder 遮掩字符，默认: '*'
+* @returns 屏蔽后的手机号，例如：138****5678
+*/
+function shieldMobile(mobile, placeholder = "*") {
+	return shieldString({
+		str: mobile,
+		startKeep: 3,
+		endKeep: 4,
+		placeholder,
+		addSpaces: false
+	});
+}
+/**
+* 通用字符串遮掩函数
+* @param options 配置参数
+* @returns 遮掩后的字符串
+*
+* @example
+* // 基本遮掩: 13812345678 -> 138****5678
+* shieldString({ str: '13812345678' })
+*
+* @example
+* // 限制长度: 64位字符串 -> 只显示前20位
+* shieldString({
+*   str: '1234567890123456789012345678901234567890123456789012345678901234',
+*   startKeep: 8,
+*   endKeep: 8,
+*   maxLength: 20
+* })
+* // 结果: 12345678****87654321
+*
+* @example
+* // 带省略号截断
+* shieldString({
+*   str: '1234567890123456789012345678901234567890123456789012345678901234',
+*   startKeep: 8,
+*   endKeep: 8,
+*   maxLength: 15,
+*   showEllipsis: true
+* })
+* // 结果: 12345678...8765
+*/
+function shieldString(options) {
+	const { str, startKeep = 3, endKeep = 4, placeholder = "*", addSpaces = false, customShield, maxLength, showEllipsis = true, ellipsis = "..." } = options;
+	let result;
+	if (customShield) result = customShield(str);
+	else if (str.length <= startKeep + endKeep) result = placeholder.repeat(str.length);
+	else {
+		const shieldCount = str.length - startKeep - endKeep;
+		const shieldStr = placeholder.repeat(shieldCount);
+		const startPart = str.slice(0, startKeep);
+		const endPart = str.slice(-endKeep);
+		result = addSpaces ? `${startPart} ${shieldStr} ${endPart}`.trim() : startPart + shieldStr + endPart;
+	}
+	if (maxLength != null && result.length > maxLength) {
+		if (!showEllipsis) return result.slice(0, maxLength);
+		const ellipsisLen = ellipsis.length;
+		if (maxLength <= ellipsisLen) return ellipsis.slice(0, maxLength);
+		const keepLen = maxLength - ellipsisLen;
+		const startKeepLen = Math.min(Math.floor(keepLen * .7), keepLen);
+		const endKeepLen = keepLen - startKeepLen;
+		if (startKeepLen < 3 && endKeepLen > 0) {
+			const startPart = result.slice(0, Math.min(startKeepLen, result.length));
+			const endPart = result.slice(-endKeepLen);
+			return startPart + ellipsis + endPart;
+		}
+		const startPart = result.slice(0, startKeepLen);
+		const endPart = result.slice(-endKeepLen);
+		return startPart + ellipsis + endPart;
+	}
+	return result;
+}
+/**
+* 简化版：遮掩并限制长度
+* @param str 待遮掩的字符串
+* @param options 配置选项
+* @returns 遮掩并截断后的字符串
+*
+* @example
+* // 遮掩手机号并限制显示长度
+* shieldWithLimit('13812345678', { maxLength: 8 }) // 138****78
+*
+* @example
+* // 遮掩长字符串
+* shieldWithLimit('12345678901234567890', {
+*   startKeep: 4,
+*   endKeep: 4,
+*   maxLength: 12
+* }) // 1234****7890
+*/
+function shieldWithLimit(str, options) {
+	return shieldString({
+		str,
+		...options
+	});
+}
+/**
+* 智能摘要：根据重要性自动调整保留位数
+* @param str 待处理的字符串
+* @param maxLength 最大输出长度
+* @param placeholder 遮掩字符
+* @returns 摘要后的字符串
+*
+* @example
+* // 长字符串自动摘要
+* smartSummary('12345678901234567890', 10) // 1234****90
+*
+* @example
+* // 短字符串不变
+* smartSummary('12345', 10) // 12345
+*/
+function smartSummary(str, maxLength, placeholder = "*") {
+	if (str.length <= maxLength) return str;
+	if (maxLength < 3) return str.slice(0, maxLength);
+	const totalKeep = maxLength - placeholder.length;
+	const startKeep = Math.floor(totalKeep / 2);
+	const endKeep = totalKeep - startKeep;
+	return shieldString({
+		str,
+		startKeep: Math.max(1, startKeep),
+		endKeep: Math.max(1, endKeep),
+		placeholder,
+		maxLength,
+		showEllipsis: false
+	});
+}
+/**
+* 屏蔽邮箱
+* @param email 待屏蔽的邮箱
+* @param placeholder 遮掩字符，默认: '*'
+* @returns 屏蔽后的邮箱，例如：exa****@email.com
+*/
+function shieldEmail(email, placeholder = "*") {
+	const [name, domain] = email.split("@");
+	if (!domain) return email;
+	const keepLength = Math.min(3, Math.floor(name.length / 2));
+	const shieldCount = name.length - keepLength;
+	const shieldStr = placeholder.repeat(Math.min(shieldCount, 4));
+	return `${name.slice(0, keepLength)}${shieldStr}@${domain}`;
+}
+/**
+* 屏蔽身份证号
+* @param idCard 待屏蔽的身份证号
+* @param placeholder 遮掩字符，默认: '*'
+* @returns 屏蔽后的身份证号，例如：110101********1234
+*/
+function shieldIdCard(idCard, placeholder = "*") {
+	return shieldString({
+		str: idCard,
+		startKeep: 6,
+		endKeep: 4,
+		placeholder,
+		addSpaces: false
+	});
+}
+/**
+* 屏蔽银行卡号（带空格格式化）
+* @param bankCard 待屏蔽的银行卡号
+* @param placeholder 遮掩字符，默认: '*'
+* @returns 屏蔽后的银行卡号，例如：622848 **** **** 9018
+*/
+function shieldBankCard(bankCard, placeholder = "*") {
+	return shieldString({
+		str: bankCard,
+		startKeep: 6,
+		endKeep: 4,
+		placeholder,
+		addSpaces: true
+	});
+}
+/**
+* 屏蔽姓名
+* @param name 待屏蔽的姓名
+* @param placeholder 遮掩字符，默认: '*'
+* @returns 屏蔽后的姓名，例如：张** 或 张*三
+*/
+function shieldName(name, placeholder = "*") {
+	if (name.length <= 2) return name.charAt(0) + placeholder.repeat(name.length - 1);
+	return shieldString({
+		str: name,
+		startKeep: 1,
+		endKeep: 1,
+		placeholder,
+		addSpaces: false
+	});
+}
+/**
+* 检测敏感信息并智能遮掩（支持长度控制）
+* @param str 待检测的字符串
+* @param placeholder 遮掩字符，默认: '*'
+* @param maxLength 最大输出长度，默认: 不限制
+* @returns 遮掩后的字符串，自动识别类型
+*
+* @example
+* // 手机号：138****5678
+* smartShield('13812345678')
+*
+* @example
+* // 邮箱：exa****@email.com
+* smartShield('example@email.com')
+*
+* @example
+* // 身份证：110101********1234
+* smartShield('110101199001011234')
+*
+* @example
+* // 限制长度
+* smartShield('13812345678', '*', 8) // 138****78
+*/
+function smartShield(str, placeholder = "*", maxLength) {
+	const cleanStr = str.replace(/\s/g, "");
+	let result;
+	if (/^1\d{10}$/.test(cleanStr)) result = shieldMobile(cleanStr, placeholder);
+	else if (/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(cleanStr)) result = shieldEmail(cleanStr, placeholder);
+	else if (/^[1-9]\d{14}(\d{2}[\dXx])?$/.test(cleanStr)) result = shieldIdCard(cleanStr, placeholder);
+	else if (/^\d{16,19}$/.test(cleanStr)) result = shieldBankCard(cleanStr, placeholder);
+	else {
+		const keepLength = Math.floor(cleanStr.length / 3);
+		result = shieldString({
+			str: cleanStr,
+			startKeep: keepLength,
+			endKeep: keepLength,
+			placeholder,
+			addSpaces: false
+		});
+	}
+	if (maxLength != null && result.length > maxLength) return result.slice(0, maxLength);
+	return result;
+}
+/**
+* 验证参数是否是数字
+* @param str 待验证的字符串
+* @param numericParam 通过参数标记是否包含小数、正数
+* @param numericParam.isPositive 是否是正数, 默认: false
+* @param numericParam.isFloat 是否是小数, 默认: true
+* @returns true 是数字, false 不是数字
+*/
+function isNumeric(str, numericParam) {
+	const { isPositive = false, isFloat = true } = numericParam ?? {};
+	return new RegExp(`^${isPositive ? "[+]?" : "[+-]?"}${isFloat ? "([0-9]*[.])?[0-9]+" : "[0-9]+"}$`).test(str);
+}
+/**
+* 验证参数是否是Boolean 类型
+* @param str 待验证的字符串
+* @returns
+*/
+function isBoolean(str) {
+	return ["true", "false"].includes(str);
+}
+function random(opts) {
+	if (typeof opts === "object" && opts !== null && "min" in opts && "max" in opts) {
+		const { min, max, hasEnd = false, isInteger = true } = opts;
+		const end = hasEnd ? 1 : 0;
+		const resRandom = Math.random() * (max - min + end) + min;
+		return isInteger ? Math.floor(resRandom) : resRandom;
+	}
+	const len = typeof opts === "object" ? opts.length : opts;
+	if (len == null) throw new Error("random_length_cannot_null");
+	const chars = typeof opts === "object" && opts.hasLetter === false ? NUMBER_RANDOM_CHARS : RANDOM_CHARS;
+	const charsLen = chars.length;
+	const generate = () => {
+		const result = [];
+		let i = 0;
+		while (i < len) {
+			result.push(chars[Math.floor(Math.random() * charsLen)]);
+			i++;
+		}
+		return result.join("");
+	};
+	const result = generate();
+	if (typeof opts === "object" && opts.firstIsZero === false && result.at(0) === "0") return random(opts);
+	return result;
+}
+/**
+* 将金额数字格式化为金额格式显示并且会保留两位小数[去除多余的位数，不是四舍五入，而是直接舍去]  1234523432.23 => 123,123,123.23
+* @param {number} number 待转换的金额数字
+* @return string
+*/
+function formatMoney(number) {
+	if (!Number.isFinite(number)) return "0.00";
+	return new Intl.NumberFormat("zh-CN", {
+		style: "decimal",
+		maximumFractionDigits: 2,
+		minimumFractionDigits: 2
+	}).format(number);
+}
+/**
+* 将风格由大写风格转换为下划线风格: HelloWorld -> hello-world
+* @param name 命名, 例如: HelloWorld
+* @param connector 连接符, 默认为: _
+*/
+function snakeCaseStyle(name, connector = "-") {
+	return name.replace(/([A-Z])/g, (match, p1, offset) => offset > 0 ? connector + match.toLowerCase() : match.toLowerCase());
+}
+/**
+* 对数字进行四舍五入处理
+* @param num 需要进行四舍五入的数字
+* @param precision 精度，默认为2，即保留小数点后两位
+* @param roundType 舍入类型，默认为0，提供三种取值:
+*        0: 标准四舍五入
+*        1: 向上取整
+*        2: 向下取整
+* @returns 返回经过指定方式舍入后的数字
+*/
+function round(num, precision = 2, roundType = 0) {
+	if (!Number.isFinite(num)) return num;
+	const factor = 10 ** precision;
+	const roundFn = {
+		0: Math.round,
+		1: Math.ceil,
+		2: Math.floor
+	}[roundType];
+	if (!roundFn) return num;
+	return roundFn(num * factor) / factor;
+}
+/**
+* 反转字符串
+*/
+function reverseStr(str) {
+	return str.split("").reverse().join("");
+}
+/**
+* 嵌套的 json 指定 key 数据
+* @param data JSON格式数据
+* @param keys 待获取的数据 key, 可以通过 [.] 获取嵌套数据, 例如: a.b.c
+* @returns
+*/
+function getJSONValue(data, keystr) {
+	if (data == null) return null;
+	return keystr.split(".").reduce((acc, key) => acc?.[key] ?? null, data);
+}
+/**
+* 数据格式化主要用于数据类型转换
+* @param data 待转换数据类型的数据
+* @param config 转换配置
+* @returns
+*/
+function formatData(data, config) {
+	if (data == null) return data;
+	const { numberFields = [], stringFields = [], formatter = {} } = config ?? {};
+	return Object.fromEntries(Object.entries(data).map(([key, value]) => {
+		let formater = formatter[key];
+		if (formater == null) {
+			if (numberFields.includes(key)) formater = "number";
+			else if (stringFields.includes(key)) formater = "string";
+		}
+		let newValue = value;
+		if (formater != null) {
+			if (typeof formater === "function") newValue = formater(value);
+			else if (formater === "number") newValue = Number(value);
+			else if (formater === "string") newValue = String(value);
+		}
+		return [key, newValue];
+	}));
+}
+//#endregion
+//#region src/date.ts
+/**
+* node 和 web 端日期处理工具类
+*/
+const REGEX_FORMAT = /yy(?:yy)?|([HMmds])\1?|(S)?/g;
+const REGEX_PARSE = /^(\d{4})-?(\d{1,2})-?(\d{0,2})[^0-9]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?.?(\d{1,3})?$/;
+const ofArgs = {
+	start: [
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		0
+	],
+	end: [
+		0,
+		11,
+		-2,
+		23,
+		59,
+		59,
+		999
+	]
+};
+const units = {
+	Date: [
+		"date",
+		"Date",
+		"day",
+		"Day",
+		"D",
+		"d"
+	],
+	Month: [
+		"Month",
+		"month",
+		"m"
+	],
+	FullYear: [
+		"Year",
+		"year",
+		"y"
+	],
+	Hours: [
+		"Hours",
+		"hours",
+		"H"
+	],
+	Minutes: [
+		"Minutes",
+		"Minute",
+		"minute",
+		"minutes",
+		"M"
+	],
+	Seconds: [
+		"Seconds",
+		"seconds",
+		"Second",
+		"second",
+		"s"
+	],
+	Milliseconds: [
+		"Milliseconds",
+		"Millisecond",
+		"milliseconds",
+		"illisecond",
+		"S"
+	]
+};
+/**
+* 不足位数, 前位补 0
+* @param s 日期数字
+* @param l 截取位数
+* @returns {string}  补0后的日期数字
+*/
+function p(s, l = 2) {
+	return `000${s}`.slice(l * -1);
+}
+/**
+* 将单位转换为首字母大写, 例如：hours -> Hours
+* @param unit hours
+* @returns
+*/
+function getUnit(unit) {
+	let period = null;
+	for (const [key, value] of Object.entries(units)) if (value.includes(unit)) {
+		period = key;
+		break;
+	}
+	if (period == null) throw new Error(`Invalid unit: ${unit}`);
+	return period;
+}
+/**
+* 获取指定日期某个月的最后一天
+* @param date  日期
+* @param month 月份, 如果不传, 则当前月的最后一天
+* @returns
+*/
+function getLastDayOfMonth(date, month) {
+	const lastDate = new Date(date.getFullYear(), (month || date.getMonth()) + 1, 1);
+	lastDate.setDate(lastDate.getDate() - 1);
+	return lastDate.getDate();
+}
+/**
+* 将日期格式化为指定形式的字符串
+* @param date      日期
+* @param pattern   格式化字符串 yyyy - 年, mm - 月, dd - 日, HH - 小时(24时制), MM - 分钟, ss - 秒, S - 毫秒, 默认: yyyy-mm-dd HH:MM:ss
+*/
+function format(date, pattern = "yyyy-mm-dd HH:MM:ss") {
+	date = parse(date);
+	const d = date.getDate();
+	const y = date.getFullYear();
+	const m = date.getMonth();
+	const H = date.getHours();
+	const M = date.getMinutes();
+	const s = date.getSeconds();
+	const flags = {
+		yy: p(y),
+		yyyy: y,
+		m: m + 1,
+		mm: p(m + 1),
+		d,
+		dd: p(d),
+		H,
+		HH: p(H),
+		M,
+		MM: p(M),
+		s,
+		ss: p(s),
+		S: p(date.getMilliseconds(), 3)
+	};
+	if (pattern != null) return pattern.replace(REGEX_FORMAT, (flag) => {
+		if (flag in flags) return flags[flag];
+		return flag;
+	});
+	return String(date.getTime());
+}
+/**
+* 将指定的参数解析为日期对象(Date)
+* 参考 dayjs 实现, 也可以参考 https://github.com/nomiddlename/date-format
+* @param date 待解析的日期参数
+*/
+function parse(date) {
+	if (date == null) return /* @__PURE__ */ new Date();
+	if (typeof date === "string" && !/Z$/i.test(date)) {
+		const d = date.match(REGEX_PARSE);
+		if (d) return new Date(d[1], d[2] - 1, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, d[7] || 0);
+	}
+	if (typeof date === "number") return new Date(date <= 9999999999 ? date * 1e3 : date);
+	return new Date(date);
+}
+/**
+* 设置日期的开始或者结束的点
+* @param date 日期，能够被 parse 解析的日期
+* @param unit 单位，Date[D]、Minute[M], 默认为 Date
+* @param isEnd true则为 endOf
+*/
+function dateOf(date, unit, isEnd = false) {
+	const periods = [
+		"Year",
+		"Month",
+		"Date",
+		"Hours",
+		"Minutes",
+		"Seconds",
+		"Milliseconds"
+	];
+	let index = periods.indexOf(getUnit(unit || "Date"));
+	const clone = parse(date);
+	index++;
+	const setValues = ofArgs[isEnd === true ? "end" : "start"];
+	for (const len = periods.length; index < len; index++) {
+		let value = setValues[index];
+		if (value === -2) value = getLastDayOfMonth(clone);
+		Date.prototype["set" + periods[index]].apply(clone, [setValues[index]]);
+	}
+	return clone;
+}
+/**
+* 设置日期的开始的点
+* @param date 日期，能够被 parse 解析的日期
+* @param unit 单位，Date[D]、Minute[M], 默认为 Date
+* @returns
+*/
+function startOf(date, unit) {
+	return dateOf(date, unit);
+}
+/**
+* 设置日期的结束点
+* @param date 日期，能够被 parse 解析的日期
+* @param unit 单位，Date[D]、Minute[M], 默认为 Date
+* @returns
+*/
+function endOf(date, unit) {
+	return dateOf(date, unit, true);
+}
+/**
+* 获取时间戳
+* @param ctime 时间
+* @param pre 精度, s - 精确到秒, ms - 精确到毫秒, 默认: s
+* @returns
+*/
+function timestamp(ctime, pre = "s") {
+	let tm = parse(ctime).getTime();
+	return pre === "s" ? Math.floor(tm / 1e3) : tm;
+}
+/**
+* 日期加上指定时间后的日期
+* @param date  指定的日期
+* @param num   需要添加的数字, 如果这个参数传递一个小于0的数字，则就是日期减去相应的数字
+* @param unit  需要添加的单位，date - 加减天数
+* @param fmt   可选参数，如果传递了格式化的单位，则返回格式化后的日期, 格式化字符串 yyyy - 年, mm - 月, dd - 日, HH - 小时, MM - 分钟, ss - 秒
+* @returns {Date | string} 如果传递了 fmt 参数，则返回 string，否则返回 Date
+*/
+function add(date, num, unit, fmt) {
+	let sdate = /* @__PURE__ */ new Date();
+	if (date != null) sdate = parse(date);
+	unit = getUnit(unit);
+	let fn = "set" + unit;
+	let gn = "get" + unit;
+	let oldValue = Date.prototype[gn].apply(sdate);
+	Date.prototype[fn].apply(sdate, [oldValue + num]);
+	if (typeof fmt === "string") return format(sdate, fmt);
+	else return sdate;
+}
+//#endregion
+//#region src/array.ts
+/**
+* 全局 Collator 单例缓存，避免重复创建
+*/
+let _collator;
+/**
+* 获取 Intl.Collator 单例（支持数字感知的字符串比较，如 "a2" < "a10"）
+* 使用 ??= 运算符实现惰性初始化
+*/
+function _getCollator() {
+	return _collator ?? (_collator = new Intl.Collator(void 0, { numeric: true }));
+}
+/**
+* 数组排序（不修改原数组，返回新数组）
+* @param arr 待排序数组
+* @param order 排序方向: "asc" - 升序（默认）, "desc" - 降序
+* @param orderKey 如果数组元素是对象，指定按哪个字段排序；为 null 时按元素本身排序
+* @returns 排序后的新数组
+*/
+function order(arr, order = "asc", orderKey = null) {
+	const collator = _getCollator();
+	const sign = order === "asc" ? 1 : -1;
+	const get = orderKey == null ? (v) => v : (v) => v[orderKey];
+	return [...arr].sort((a, b) => {
+		const av = get(a);
+		const bv = get(b);
+		return (typeof av === "string" ? collator.compare(av, bv) : av < bv ? -1 : av > bv ? 1 : 0) * sign;
+	});
 }
+/**
+* 获取集合大小（兼容 Set 和 Array）
+* @param v Set 或 Array
+* @returns 元素个数
+*/
+function _size(v) {
+	return v instanceof Set ? v.size : v.length;
+}
+/**
+* 将 Set 或 Array 统一转为 Set（如果已经是 Set 则直接返回，避免重复创建）
+* @param v Set 或 Array
+* @returns Set 实例
+*/
+function _toSet(v) {
+	return v instanceof Set ? v : new Set(v);
+}
+/**
+* 检测对象上是否存在可用的原生方法（ES2025 Set 新方法检测）
+* @param obj 目标对象
+* @param name 方法名
+* @returns 是否为可调用的函数
+*/
+function _hasNative(obj, name) {
+	return typeof obj[name] === "function";
+}
+/**
+* 返回所有集合交集的元素组成的新集合
+* - 以第一个参数的类型决定返回 Set 还是 Array
+* - 支持混合传入 Set 和 Array
+* - 优先使用原生 ES2025 Set.prototype.intersection
+* @param arrs 多个集合/数组
+* @returns 交集结果（Set 或 Array）
+*/
+function intersection(...arrs) {
+	const isSet = arrs[0] instanceof Set;
+	let acc = isSet ? new Set(arrs[0]) : [...arrs[0]];
+	for (let i = 1; i < arrs.length && _size(acc) > 0; i++) {
+		const cur = arrs[i];
+		if (_size(cur) === 0) return isSet ? /* @__PURE__ */ new Set() : [];
+		if (isSet) {
+			const accSet = acc;
+			const curSet = _toSet(cur);
+			acc = _hasNative(accSet, "intersection") ? accSet.intersection(curSet) : _intersectFallback(accSet, curSet);
+		} else {
+			const curSet = _toSet(cur);
+			acc = acc.filter((x) => curSet.has(x));
+		}
+	}
+	return acc;
+}
+/**
+* 交集回退实现（不支持原生 intersection 时使用）
+* 性能优化：始终遍历较小的集合，减少迭代次数
+* @param a 集合 A
+* @param b 集合 B
+* @returns 交集 Set
+*/
+function _intersectFallback(a, b) {
+	const [smaller, larger] = a.size <= b.size ? [a, b] : [b, a];
+	const res = /* @__PURE__ */ new Set();
+	for (const v of smaller) if (larger.has(v)) res.add(v);
+	return res;
+}
+/**
+* 返回第一个集合中有但后续所有集合中没有的元素组成的新集合
+* - 优先使用原生 ES2025 Set.prototype.difference
+* - 数组模式使用 Set.has 替代 includes，性能从 O(n×m) 降至 O(n+m)
+* @param arrs 多个集合/数组
+* @returns 差集结果（Set 或 Array）
+*/
+function difference(...arrs) {
+	const isSet = arrs[0] instanceof Set;
+	let acc = isSet ? new Set(arrs[0]) : [...arrs[0]];
+	for (let i = 1; i < arrs.length && _size(acc) > 0; i++) {
+		const curSet = _toSet(arrs[i]);
+		if (isSet) {
+			const accSet = acc;
+			acc = _hasNative(accSet, "difference") ? accSet.difference(curSet) : _filterSet(accSet, (v) => !curSet.has(v));
+		} else acc = acc.filter((v) => !curSet.has(v));
+	}
+	return acc;
+}
+/**
+* Set 过滤辅助函数：返回满足条件的新 Set
+* @param set 源集合
+* @param predicate 过滤条件函数
+* @returns 过滤后的新 Set
+*/
+function _filterSet(set, predicate) {
+	const res = /* @__PURE__ */ new Set();
+	for (const v of set) if (predicate(v)) res.add(v);
+	return res;
+}
+/**
+* 返回多个集合的并集
+* - 优先使用原生 ES2025 Set.prototype.union
+* - Set 模式自动去重；Array 模式保持原有行为（拼接，不去重）
+* @param arrs 多个集合/数组
+* @returns 并集结果（Set 或 Array）
+*/
+function union(...arrs) {
+	const isSet = arrs[0] instanceof Set;
+	let acc = isSet ? new Set(arrs[0]) : [...arrs[0]];
+	for (let i = 1; i < arrs.length; i++) {
+		const cur = arrs[i];
+		if (isSet) {
+			const accSet = acc;
+			const curSet = _toSet(cur);
+			acc = _hasNative(accSet, "union") ? accSet.union(curSet) : /* @__PURE__ */ new Set([...accSet, ...curSet]);
+		} else acc = [...acc, ...cur];
+	}
+	return acc;
+}
+/**
+* 对称差：返回只存在于其中一个集合中的元素（不同时存在于两个集合中的元素）
+* - 优先使用原生 ES2025 Set.prototype.symmetricDifference
+* - 数组模式使用 Set.has 替代 includes，性能大幅提升
+* @param arrs 多个集合/数组
+* @returns 对称差结果（Set 或 Array）
+*/
+function symmetricDifference(...arrs) {
+	const isSet = arrs[0] instanceof Set;
+	let acc = isSet ? new Set(arrs[0]) : [...arrs[0]];
+	for (let i = 1; i < arrs.length; i++) {
+		const cur = arrs[i];
+		if (isSet) {
+			const accSet = acc;
+			const curSet = _toSet(cur);
+			acc = _hasNative(accSet, "symmetricDifference") ? accSet.symmetricDifference(curSet) : _symDiffSetFallback(accSet, curSet);
+		} else acc = _symDiffArrayFallback(acc, cur);
+	}
+	return acc;
+}
+/**
+* Set 对称差回退实现
+* 逻辑：A△B = (A-B) ∪ (B-A)
+* @param a 集合 A
+* @param b 集合 B
+* @returns 对称差 Set
+*/
+function _symDiffSetFallback(a, b) {
+	const res = /* @__PURE__ */ new Set();
+	for (const v of a) if (!b.has(v)) res.add(v);
+	for (const v of b) if (!a.has(v)) res.add(v);
+	return res;
+}
+/**
+* 数组对称差回退实现
+* 性能优化：将两个数组都转为 Set，查找从 O(n) 降至 O(1)
+* @param a 数组 A
+* @param b 数组 B
+* @returns 对称差数组
+*/
+function _symDiffArrayFallback(a, b) {
+	const aSet = new Set(a);
+	const bSet = new Set(b);
+	const res = [];
+	for (const v of a) if (!bSet.has(v)) res.push(v);
+	for (const v of b) if (!aSet.has(v)) res.push(v);
+	return res;
+}
+/**
+* 判断 a1 是否是 a2 的子集（a1 的所有元素是否都在 a2 中）
+* - 优先使用原生 ES2025 Set.prototype.isSubsetOf
+* - 数组模式使用 Set.has 替代 includes，性能优化
+* @param a1 待判断集合（可能是子集）
+* @param a2 目标集合（可能是超集）
+* @returns a1 ⊆ a2 时返回 true
+*/
+function isSubsetOf(a1, a2) {
+	if (a1 instanceof Set && _hasNative(a1, "isSubsetOf")) return a1.isSubsetOf(_toSet(a2));
+	const set2 = _toSet(a2);
+	for (const item of a1) if (!set2.has(item)) return false;
+	return true;
+}
+/**
+* 判断 a1 是否是 a2 的超集（a2 的所有元素是否都在 a1 中）
+* 逻辑等价于：a2 是 a1 的子集
+* @param a1 待判断集合（可能是超集）
+* @param a2 目标集合（可能是子集）
+* @returns a1 ⊇ a2 时返回 true
+*/
+function isSupersetOf(a1, a2) {
+	return isSubsetOf(a2, a1);
+}
+/**
+* 判断两个集合是否没有公共元素（不相交）
+* - 优先使用原生 ES2025 Set.prototype.isDisjointFrom
+* - 数组模式使用 Set.has 替代 includes，性能优化
+* @param a1 集合 1
+* @param a2 集合 2
+* @returns 两集合无交集时返回 true
+*/
+function isDisjointFrom(a1, a2) {
+	if (a1 instanceof Set && _hasNative(a1, "isDisjointFrom")) return a1.isDisjointFrom(_toSet(a2));
+	const set2 = _toSet(a2);
+	for (const item of a1) if (set2.has(item)) return false;
+	return true;
+}
+//#endregion
+//#region src/id.ts
+/** 雪花ID, 推荐在全局构造一个对象用于生成id */
+var SnowflakeID = class SnowflakeID {
+	/**
+	* 构造函数
+	*
+	* @param machineId 机器标识，默认为1
+	* @param epoch 时间戳起始值，默认为1288834974657
+	* @param maxClockTolerance 允许的最大时钟回拨毫秒数，默认为5
+	*/
+	constructor(machineId = 1, epoch = 1288834974657, maxClockTolerance = SnowflakeID.DEFAULT_MAX_CLOCK_TOLERANCE) {
+		this._version = 0;
+		if (!Number.isSafeInteger(machineId) || machineId < 0 || machineId > SnowflakeID.MAX_MACHINE_ID) throw new Error(`machineId must be a safe integer between 0 and ${SnowflakeID.MAX_MACHINE_ID}, got ${machineId}`);
+		if (!Number.isSafeInteger(epoch) || epoch < 0 || epoch > Date.now()) throw new Error(`epoch must be a non-negative safe integer not later than the current time, got ${epoch}`);
+		if (!Number.isSafeInteger(maxClockTolerance) || maxClockTolerance < 0) throw new Error(`maxClockTolerance must be a non-negative safe integer, got ${maxClockTolerance}`);
+		this.machineId = BigInt(machineId);
+		this.epoch = BigInt(epoch);
+		this.maxClockTolerance = maxClockTolerance;
+		const stateKey = `${this.epoch}:${this.machineId}`;
+		let state = SnowflakeID.STATES.get(stateKey);
+		if (state == null) {
+			state = {
+				lastTimestamp: 0n,
+				sequence: 0n
+			};
+			SnowflakeID.STATES.set(stateKey, state);
+		}
+		this._state = state;
+	}
+	get version() {
+		return this._version;
+	}
+	set version(version) {
+		if (!Number.isInteger(version) || version < 0 || version > 9) throw new Error(`version must be an integer between 0 and 9, got ${version}`);
+		this._version = version;
+	}
+	/**
+	* 生成雪花ID
+	*
+	* @returns 返回生成的唯一ID字符串
+	* @throws 如果时钟回拨超过容差阈值，抛出错误
+	*/
+	generate() {
+		let cTimestamp = BigInt(Date.now());
+		if (cTimestamp < this._state.lastTimestamp) {
+			const drift = Number(this._state.lastTimestamp - cTimestamp);
+			if (drift > this.maxClockTolerance) throw new Error(`Clock moved backwards by ${drift}ms (tolerance: ${this.maxClockTolerance}ms)`);
+			cTimestamp = this._state.lastTimestamp;
+		}
+		let sequence;
+		if (cTimestamp === this._state.lastTimestamp) {
+			sequence = this._state.sequence + 1n & SnowflakeID.SEQUENCE_MASK;
+			if (sequence === 0n) cTimestamp += 1n;
+		} else sequence = 0n;
+		const timeDiff = cTimestamp - this.epoch;
+		if (timeDiff < 0n || timeDiff > SnowflakeID.TIMESTAMP_MASK) throw new Error(`Timestamp offset must be between 0 and ${SnowflakeID.TIMESTAMP_MASK}, got ${timeDiff}`);
+		this._state.lastTimestamp = cTimestamp;
+		this._state.sequence = sequence;
+		const idstr = (timeDiff << SnowflakeID.SHIFT_TIMESTAMP | this.machineId << SnowflakeID.SHIFT_MACHINE | sequence).toString().padStart(19, "0");
+		return `${this.version}${idstr}`;
+	}
+	parse(snowflakeID, epoch, includeVersion = true) {
+		if (typeof snowflakeID !== "string" || !/^\d+$/.test(snowflakeID)) throw new Error("snowflakeID must be a non-empty decimal string");
+		let version;
+		if (includeVersion) {
+			if (snowflakeID.length < 2) throw new Error("snowflakeID must contain a version and an ID value");
+			version = snowflakeID.substring(0, 1);
+			snowflakeID = snowflakeID.substring(1);
+		}
+		const epochTime = epoch ?? Number(this.epoch);
+		if (!Number.isSafeInteger(epochTime) || epochTime < 0) throw new Error(`epoch must be a non-negative safe integer, got ${epochTime}`);
+		const id = BigInt(snowflakeID);
+		if (id > SnowflakeID.MAX_ID) throw new Error(`snowflakeID value exceeds the 63-bit Snowflake range`);
+		const timeDiff = id >> SnowflakeID.SHIFT_TIMESTAMP & SnowflakeID.TIMESTAMP_MASK;
+		const flowTime = Number(timeDiff) + epochTime;
+		if (!Number.isSafeInteger(flowTime)) throw new Error("Parsed timestamp exceeds the JavaScript safe integer range");
+		const machineId = id >> SnowflakeID.SHIFT_MACHINE & SnowflakeID.MACHINE_MASK;
+		const sequence = id & SnowflakeID.SEQUENCE_MASK;
+		return {
+			value: snowflakeID,
+			timeOffset: timeDiff,
+			timestamp: flowTime,
+			machineId,
+			sequence,
+			epoch: epochTime,
+			version
+		};
+	}
+};
+SnowflakeID.SEQUENCE_MASK = 4095n;
+SnowflakeID.TIMESTAMP_MASK = 2199023255551n;
+SnowflakeID.MACHINE_MASK = 1023n;
+SnowflakeID.SHIFT_TIMESTAMP = 22n;
+SnowflakeID.SHIFT_MACHINE = 12n;
+SnowflakeID.MAX_MACHINE_ID = 1023;
+SnowflakeID.DEFAULT_MAX_CLOCK_TOLERANCE = 5;
+SnowflakeID.MAX_ID = (1n << 63n) - 1n;
+SnowflakeID.STATES = /* @__PURE__ */ new Map();
+/** 将uuid转换为更简单的唯一标记id */
+var ShortUUID = class {
+	/**
+	* 构造函数，用于初始化字母表
+	* @param {string} [alphabet] - 可选参数，用于指定自定义字母表
+	* 如果提供了alphabet参数，则将其设置为实例的字母表属性
+	* 如果未提供alphabet参数，则使用默认值
+	*/
+	constructor(alphabet) {
+		this.alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+		if (alphabet) this.alphabet = alphabet;
+	}
+	/**
+	* 将UUID字符串进行编码处理
+	* @param uuid - 需要编码的UUID字符串
+	* @returns 编码后的字符串
+	*/
+	encode(uuid, alphabet) {
+		const uuidInt = this._uuidHexToInt(uuid);
+		return this._intToString(uuidInt, alphabet);
+	}
+	/**
+	* 解码短UUID字符串，将其转换为UUID整数和十六进制格式
+	* @param shortUUID - 需要解码的短UUID字符串
+	* @returns 返回包含UUID整数和十六进制格式的对象
+	*/
+	decode(shortUUID, alphabet) {
+		const uuidInt = this._stringToInt(shortUUID, alphabet);
+		return {
+			uuidInt,
+			uuid: this._uuidIntToHex(uuidInt)
+		};
+	}
+	_stringToInt(str, alphabet) {
+		if (!alphabet) alphabet = this.alphabet;
+		const alphabetlen = BigInt(alphabet.length);
+		let result = BigInt(0);
+		let multiplier = BigInt(1);
+		const strlen = str.length;
+		for (let i = strlen - 1; i >= 0; i--) {
+			const char = str[i];
+			const index = alphabet.indexOf(char);
+			if (index === -1) throw new Error(`Character "${char}" not found in alphabet`);
+			result += BigInt(index) * multiplier;
+			multiplier *= alphabetlen;
+		}
+		return result;
+	}
+	_intToString(uuidInt, alphabet) {
+		if (!alphabet) alphabet = this.alphabet;
+		const alphabetlen = BigInt(alphabet.length);
+		let num = uuidInt;
+		const result = [];
+		while (num) {
+			const index = Number(num % alphabetlen);
+			num = num / alphabetlen;
+			result.push(alphabet.charAt(index));
+		}
+		return result.reverse().join("");
+	}
+	_uuidHexToInt(uuid) {
+		const uuidHex = uuid.replaceAll("-", "");
+		return BigInt(`0x${uuidHex}`);
+	}
+	_uuidIntToHex(uuidInt) {
+		const uuidHexStr = uuidInt.toString(16);
+		if (!/^[0-9a-fA-F]{32}$/.test(uuidHexStr)) throw new Error("Invalid UUID string (must be 32 hex characters)");
+		return [
+			uuidHexStr.slice(0, 8),
+			uuidHexStr.slice(8, 12),
+			uuidHexStr.slice(12, 16),
+			uuidHexStr.slice(16, 20),
+			uuidHexStr.slice(20)
+		].join("-");
+	}
+};
+//#endregion
+//#region src/crypto.ts
+/**
+* 将原始的二进制数据转换为 Hex String
+* @param bf 待转换的原始数据
+* @param upper 是否需要转换为大写
+* @returns
+*/
+function bufferToHex(bf, upper = false) {
+	const u8Array = bf instanceof Uint8Array ? bf : new Uint8Array(bf);
+	return Array.from(u8Array).map((b) => {
+		let hx = b.toString(16).padStart(2, "0");
+		return upper === true ? hx.toUpperCase() : hx;
+	}).join("");
+}
+/**
+* 将16进制的数据转换为 UInt8Array
+* @param data 16进制的数据
+* @returns
+*/
+function hexToBuffer(data) {
+	const len = data.length / 2;
+	const uint8Array = new Uint8Array(len);
+	for (let i = 0; i < len; i++) {
+		const byteHex = data.substring(i * 2, i * 2 + 2);
+		const byte = parseInt(byteHex.toLocaleLowerCase(), 16);
+		uint8Array[i] = byte;
+	}
+	return uint8Array;
+}
+/**
+* 将原始数据转换为 Base64 编码
+* @param bf 待转换的原始数据
+* @returns
+*/
+function bufferToBase64(bf) {
+	const u8Array = bf instanceof Uint8Array ? bf : new Uint8Array(bf);
+	const hashArray = Array.from(u8Array);
+	return globalThis.btoa(String.fromCharCode.apply(null, hashArray));
+}
+/**
+* 将 Base64 转换为 UInt8Array 数据
+* @param data
+* @returns
+*/
+function base64ToBuffer(data) {
+	return new Uint8Array(globalThis.atob(data).split("").map((char) => char.charCodeAt(0)));
+}
+/**
+* SHA 哈希算法
+* @param message     待进行 hash 的数据
+* @param upper       是否转换为大写, 默认为: false
+* @param algorithm   hash算法, 支持: SHA-1、SHA-256、SHA-384、SHA-512; 默认为: SHA-256
+* @returns
+*/
+async function sha(message, upper = false, algorithm = "SHA-256") {
+	let msgBuffer = message;
+	if (typeof message === "string") msgBuffer = new TextEncoder().encode(message);
+	return bufferToHex(await globalThis.crypto.subtle.digest(algorithm || "SHA-256", msgBuffer), upper);
+}
+/**
+* 哈希算法
+* @param message     待进行 hash 的数据
+* @param upper       是否转换为大写, 默认为: false
+* @param algorithm   hash算法, 支持: SHA-1、SHA-256、SHA-384、SHA-512; 默认为: SHA-256
+* @returns
+*/
+async function hash(message, upper = false, algorithm = "SHA-256") {
+	return sha(message, upper, algorithm);
+}
+/**
+* 使用 HMAC 算法计算消息的哈希值
+* @param message - 需要计算哈希的消息字符串
+* @param secret - 用于生成 HMAC 的密钥
+* @param algorithm - HMAC 使用的哈希算法,默认为 "SHA-256"
+* @param upper - 是否将结果转换为大写,默认为 false
+* @returns 返回十六进制格式的 HMAC 哈希值
+*/
+async function hmacHash(message, secret, algorithm = "SHA-256", upper = false) {
+	const encoder = new TextEncoder();
+	const key = await crypto.subtle.importKey("raw", encoder.encode(secret), {
+		name: "HMAC",
+		hash: { name: algorithm }
+	}, false, ["sign"]);
+	return bufferToHex(await crypto.subtle.sign("HMAC", key, encoder.encode(message)), upper);
+}
+function parseRsaKey(pem) {
+	const pemHeader = "-----BEGIN PUBLIC KEY-----";
+	const pemFooter = "-----END PUBLIC KEY-----";
+	if (pem.indexOf(pemHeader) !== -1 && pem.indexOf(pemFooter) !== -1) pem = pem.substring(26, pem.indexOf(pemFooter)).trim();
+	return pem;
+}
+/**
+* 导入上下文密钥
+* @param key           导入的密钥
+* @param algorithmName 算法名称
+* @param usages        该密钥可以用于哪些函数使用
+* @returns
+*/
+async function importKey(key, algorithmName, usages, encoding = "hex") {
+	let name = "AES-CBC";
+	if (algorithmName == null) name = "AES-CBC";
+	else if (algorithmName.toUpperCase() === "AES") name = "AES-CBC";
+	else if (algorithmName.toUpperCase() === "RSA") name = "RSA-OAEP";
+	name = name.toUpperCase();
+	if (usages == null || usages.length === 0) usages = ["encrypt"];
+	let format = "raw";
+	let algorithm = { name };
+	if (name.includes("RSA")) {
+		format = "spki";
+		algorithm.hash = { name: "SHA-256" };
+		key = parseRsaKey(key);
+	}
+	const keyBuf = encoding === "base64" ? base64ToBuffer(key) : hexToBuffer(key);
+	return Promise.all([globalThis.crypto.subtle.importKey(format, keyBuf, algorithm, false, usages), Promise.resolve({ name })]);
+}
+/**
+* 加密
+* @param algorithm  算法参数, 算法名称、向量等
+* @param key        算法密钥
+* @param message    待加密的数据
+* @param encode     解密后返回数据格式
+* @returns
+*/
+async function encrypt(algorithm, key, message, encode = "hex") {
+	if (typeof message === "string") message = new TextEncoder().encode(message);
+	const encrypted = await globalThis.crypto.subtle.encrypt(algorithm, key, message);
+	if (encode === "hex") return bufferToHex(encrypted);
+	else if (encode === "hexUpper") return bufferToHex(encrypted, true);
+	else if (encode === "base64") return bufferToBase64(encrypted);
+	else return encrypted;
+}
+/**
+* 数据解密
+* @param algorithm 解密算法
+* @param key       解密密钥
+* @param message   加密后的数据
+* @returns
+*/
+async function decrypt(algorithm, key, message) {
+	const decrypted = await globalThis.crypto.subtle.decrypt(algorithm, key, message);
+	return new TextDecoder("utf-8").decode(decrypted);
+}
+/**
+* AES 加密
+* @param message 待加密的数据
+* @param key 加解密密钥
+* @param encode 加密后的数据转换的形式, hex - 转换为16进制字符串, hexUpper - 转换为16进制且大写, base64 - 转换为 base64 形式
+* @param iv 加解密向量
+* @returns [加密数据,向量]
+*/
+async function aesEncrypt(message, key, encode = "hex", iv = null) {
+	let ciphertext = "";
+	let resIv = "";
+	const [cryptoKey, algorithm] = await importKey(key, "aes", ["encrypt"]);
+	if (iv == null) iv = globalThis.crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16));
+	else if (typeof iv === "string") iv = hexToBuffer(iv);
+	ciphertext = await encrypt({
+		...algorithm,
+		iv
+	}, cryptoKey, message, encode);
+	resIv = bufferToHex(iv);
+	return {
+		ciphertext,
+		iv: resIv,
+		key
+	};
+}
+/**
+* 根据加密后的数据类型使用对应函数最终转换为 UInt8Array
+* @param message 原始加密后的数据
+* @param type    类型: hex | base64
+* @returns
+*/
+function parseEncryptData(message, type) {
+	let input;
+	if (typeof message === "string") {
+		if (type === "hex" || type === "hexUpper") input = hexToBuffer(message);
+		else input = base64ToBuffer(message);
+	} else input = message;
+	return input;
+}
+/**
+* AES 解密
+* @param message 加密后的数据
+* @param key     解密密钥
+* @param iv      向量
+* @param encode  加密后数据的形式: hex | base64
+* @returns
+*/
+async function aesDecrypt(message, key, iv, encode = "hex") {
+	const [cryptoKey, algorithm] = await importKey(key, "aes", ["decrypt"]);
+	const input = parseEncryptData(message, encode);
+	return await decrypt({
+		...algorithm,
+		iv: hexToBuffer(iv)
+	}, cryptoKey, input);
+}
+/**
+* RSA 加密
+* @param key     公钥
+* @param message 待加密数据
+* @param encode  返回类型
+* @returns
+*/
+async function rsaEncrypt(message, publicKey, encode = "hex") {
+	const [cryptoKey, algorithm] = await importKey(publicKey, "rsa", ["encrypt"], "base64");
+	return await encrypt(algorithm, cryptoKey, message, encode);
+}
+/**
+* RSA 解密
+* @param key     私钥, 根据私钥解密
+* @param message 加密后的数据
+* @param encode  加密后的数据形式
+* @returns
+*/
+async function rsaDecrypt(privateKey, message, encode = "hex") {
+	const [cryptoKey, algorithm] = await importKey(privateKey, "rsa", ["decrypt"]);
+	return await decrypt({ ...algorithm }, cryptoKey, parseEncryptData(message, encode));
+}
+//#endregion
+//#region src/base-codec.ts
+/** 通用进制编码解码器，兼容 Node.js 和浏览器环境 */
+const BASE62_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const BASE32_ALPHABET = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
+var BaseCodec = class {
+	constructor(name, alphabet) {
+		this.alphabet = alphabet;
+		this.base = BigInt(alphabet.length);
+		this.name = name;
+	}
+	intToBytes(value) {
+		if (value < 0n) throw new RangeError("Only supports non-negative integers");
+		if (value === 0n) return new Uint8Array([0]);
+		const bytes = [];
+		while (value > 0n) {
+			bytes.unshift(Number(value & 255n));
+			value >>= 8n;
+		}
+		return new Uint8Array(bytes);
+	}
+	bytesToInt(bytes) {
+		let value = 0n;
+		for (const byte of bytes) value = value << 8n | BigInt(byte);
+		return value;
+	}
+	concatBytes(...arrays) {
+		const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+		const result = new Uint8Array(totalLength);
+		let offset = 0;
+		for (const arr of arrays) {
+			result.set(arr, offset);
+			offset += arr.length;
+		}
+		return result;
+	}
+	bytesToUtf8(bytes) {
+		return new TextDecoder().decode(bytes);
+	}
+	utf8ToBytes(str) {
+		return new TextEncoder().encode(str);
+	}
+	bytesToHex(bytes) {
+		let hex = "";
+		for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
+		return hex;
+	}
+	encodeFromBytes(input) {
+		if (input.length === 0) return "";
+		let leadingZeros = 0;
+		while (leadingZeros < input.length && input[leadingZeros] === 0) leadingZeros++;
+		let value = this.bytesToInt(input);
+		let encoded = "";
+		while (value > 0n) {
+			encoded = this.alphabet.charAt(Number(value % this.base)) + encoded;
+			value /= this.base;
+		}
+		return this.alphabet.charAt(0).repeat(leadingZeros) + encoded;
+	}
+	decodeToBytes(input) {
+		if (input.length === 0) return /* @__PURE__ */ new Uint8Array(0);
+		let leadingZeros = 0;
+		while (leadingZeros < input.length && input.charAt(leadingZeros) === this.alphabet.charAt(0)) leadingZeros++;
+		let value = 0n;
+		for (const char of input.slice(leadingZeros)) {
+			const index = this.alphabet.indexOf(char);
+			if (index === -1) throw new TypeError(`Invalid ${this.name} character: ${char}`);
+			value = value * this.base + BigInt(index);
+		}
+		const valueBytes = value === 0n ? /* @__PURE__ */ new Uint8Array(0) : this.intToBytes(value);
+		return this.concatBytes(new Uint8Array(leadingZeros), valueBytes);
+	}
+	/** 将非负 bigint 编码为字符串 */
+	encodeFromInt(value) {
+		return this.encodeFromBytes(this.intToBytes(value));
+	}
+	/** 先将字符串转换为 UTF-8 字节，再编码 */
+	encodeFromStr(value) {
+		return this.encodeFromBytes(this.utf8ToBytes(value));
+	}
+	/** 根据参数类型将 bigint 或字符串编码 */
+	encode(value) {
+		return typeof value === "bigint" ? this.encodeFromInt(value) : this.encodeFromStr(value);
+	}
+	/** 解码为非负 bigint */
+	decodeToInt(value) {
+		return this.bytesToInt(this.decodeToBytes(value));
+	}
+	/** 解码为 UTF-8 字符串 */
+	decodeToStr(value) {
+		return this.bytesToUtf8(this.decodeToBytes(value));
+	}
+	/** 默认解码为 UTF-8 字符串 */
+	decode(value) {
+		return this.decodeToStr(value);
+	}
+	/** 将字节数组转换为十六进制字符串 */
+	bufferToHex(value) {
+		return this.bytesToHex(value);
+	}
+};
+var Base32 = class extends BaseCodec {
+	constructor() {
+		super("Base32", BASE32_ALPHABET);
+	}
+};
+var Base62 = class extends BaseCodec {
+	constructor() {
+		super("Base62", BASE62_ALPHABET);
+	}
+};
+//#endregion
+//#region src/validator.ts
+/**
+* 数据验证器
+*/
+const defaultMsgs = {
+	mobile: "请输入正确的手机号",
+	same: "两次输入不一致",
+	required: "%s为必填字段",
+	default: "请输入正确的数据"
+};
+const ruleRegexs = {
+	/** 验证跟其余数据相等的正则，一般用于验证再次输入密码 */
+	same: /^same:(.+)$/i,
+	/** 验证手机号的正则表达式 */
+	mobile: /^1[3456789]\d{9}$/,
+	/** 非空验证的正则表达式 */
+	required: /\S/
+};
+const ruleFns = {
+	/** 验证相等 */
+	same(val1, val2) {
+		return val2 === val1;
+	},
+	/** 正则匹配 */
+	pattern(regex, val) {
+		if (val == null) return false;
+		return regex.test(String(val));
+	}
+};
+var ValidateError = class extends Error {
+	constructor(detail, key, message) {
+		super(message);
+		this.name = "ValidateError";
+		this.key = key;
+		this.detail = detail;
+	}
+};
+/**
+* 数据验证器
+*/
+var Validator = class {
+	/**
+	* 构造数据验证转换器
+	*
+	* See {@link https://gitee.com/towardly/ph/wikis/utils/validator|Validator文档}.
+	*
+	* @param schemas 配置验证转换规则
+	*
+	* @example
+	*
+	* const validator = new Validator([
+	*  { key: 'mobile', rules: ['required', 'mobile'] },
+	*  { key: 'code': rules: /^\d{6}$/, message: '请输入正确的验证码' },
+	*  { key: 'confirmPassword', rules: ['required', 'same:password'] }
+	* ])
+	* // 验证某一个字段
+	* validator.validateKey().then(res => {})
+	*/
+	constructor(schemas) {
+		this.setSchemas(schemas);
+	}
+	addSchemas(schemas) {
+		for (let schema of schemas) this.addSchema(schema);
+	}
+	addSchema(schema) {
+		if (schema.key in this.rules) this.rules[schema.key] = [...this.rules[schema.key], ...this._parseSchemaRules(schema)];
+		else this.rules[schema.key] = this._parseSchemaRules(schema);
+	}
+	setSchema(schema) {
+		this.rules[schema.key] = this._parseSchemaRules(schema);
+	}
+	setSchemas(schemas) {
+		this.rules = {};
+		for (let schema of schemas) this.rules[schema.key] = this._parseSchemaRules(schema);
+	}
+	removeSchema(key) {
+		delete this.rules[key];
+	}
+	hasSchema(key) {
+		return key in this.rules;
+	}
+	/**
+	* 进行数据验证
+	* @param data 待验证的数据
+	* @param all 是否全部验证, false - 只要验证错误一个则停止验证
+	* @returns
+	*/
+	validate(data, all = false) {
+		const detail = {};
+		let currentKey = void 0;
+		let currentMessage = void 0;
+		for (let key in this.rules) {
+			let errMsg = this._validateRule(this.rules[key], data[key], data);
+			if (errMsg !== "") {
+				errMsg = errMsg.replace("%s", key);
+				detail[key] = errMsg;
+				currentKey = key;
+				currentMessage = errMsg;
+				if (!all) break;
+			}
+		}
+		if (currentKey == null) return true;
+		throw new ValidateError(detail, currentKey, currentMessage);
+	}
+	/**
+	* 只验证指定 key 的数据格式
+	* @param key   指定待验证的 key
+	* @param value 待验证的数据
+	* @param data 原始数据，当验证确认密码时需要使用
+	*/
+	validateKey(key, value, data) {
+		let keyRules = this.rules[key];
+		if (keyRules == null) return {
+			key,
+			value
+		};
+		let errMsg = this._validateRule(keyRules, value, data);
+		if (errMsg !== "") {
+			errMsg = errMsg.replace("%s", key);
+			throw new ValidateError({ [key]: errMsg }, key, errMsg);
+		}
+		return {
+			key,
+			value
+		};
+	}
+	_validateRule(rules, value, data) {
+		let errMsg = "";
+		for (let rule of rules) {
+			if (!rule) continue;
+			if (rule.rule === "required") {
+				if (value == null || !ruleFns.pattern(ruleRegexs.required, value)) errMsg = rule.message;
+			} else if (typeof rule.rule === "function") {
+				if (!rule.rule(value)) errMsg = rule.message;
+			} else if (rule.sameKey != null) {
+				if (data != null) {
+					if (!ruleFns.same(value, data[rule.sameKey])) errMsg = rule.message;
+				}
+			} else if (rule && !ruleFns.pattern(rule.rule, value)) errMsg = rule.message;
+			if (errMsg !== "") break;
+		}
+		return errMsg;
+	}
+	_parseSchemaRules(schema) {
+		let rules = [];
+		let rule = schema.rules;
+		if (schema.required === true) rules.push(...this._parseStringRule("required", schema.message));
+		if (rule != null) {
+			if (typeof rule === "string") rules.push(...this._parseStringRule(rule, schema.message));
+			else if (rule instanceof Array) for (let ruleItem of rule) if (typeof ruleItem === "string") rules.push(...this._parseStringRule(ruleItem, schema.message));
+			else if (ruleItem instanceof RegExp || typeof ruleItem === "function") rules.push({
+				rule: ruleItem,
+				message: schema.message || defaultMsgs["default"]
+			});
+			else {
+				const emessage = ruleItem.message || schema.message || defaultMsgs["default"];
+				if (typeof ruleItem.rule === "string") rules.push(...this._parseStringRule(ruleItem.rule, emessage));
+				else rules.push({
+					rule: ruleItem.rule,
+					message: emessage
+				});
+			}
+			else rules.push({
+				rule,
+				message: defaultMsgs["default"]
+			});
+		}
+		return rules;
+	}
+	_parseStringRule(rule, ruleErrMsg) {
+		let rules = [];
+		let trule = rule.split("|");
+		for (let r of trule) {
+			let message = ruleErrMsg;
+			let rrule = null;
+			let sameKey;
+			if (r === "required") {
+				rrule = "required";
+				message = message || ruleErrMsg || defaultMsgs.required;
+			} else if (ruleRegexs.same.test(r)) {
+				let m = r.match(ruleRegexs.same);
+				if (m != null) {
+					rrule = ruleRegexs.same;
+					sameKey = m[1];
+					message = message || defaultMsgs["same"];
+				}
+			} else if (Object.hasOwn(ruleRegexs, r)) {
+				rrule = ruleRegexs[r];
+				message = message || defaultMsgs[r];
+			}
+			if (rrule) rules.push({
+				rule: rrule,
+				message,
+				sameKey
+			});
+		}
+		return rules;
+	}
+};
+//#endregion
+export { Base32, Base62, ShortUUID, SnowflakeID, Validator, add, adjust, aesDecrypt, aesEncrypt, bufferToHex, dateOf, difference, endOf, format, formatData, formatMoney, getJSONValue, hash, hmacHash, intersection, isBlank, isBoolean, isDisjointFrom, isNumeric, isSubsetOf, isSupersetOf, order, parse, random, reverseStr, rgbToHex, round, rsaDecrypt, rsaEncrypt, sha, shieldBankCard, shieldEmail, shieldIdCard, shieldMobile, shieldName, shieldString, shieldWithLimit, smartShield, smartSummary, snakeCaseStyle, startOf, symmetricDifference, timestamp, toHex, toHsv, toRgb, union };