@cloudcome/utils-core 1.1.1 → 1.2.0

package/dist/string2.cjs

@@ -0,0 +1,157 @@
+"use strict";
+const merge = require("./merge.cjs");
+const type = require("./type.cjs");
+function numberFixed(number, options) {
+  const { precision = 0, round = 0 } = options || {};
+  const scale = 10 ** precision;
+  if (round === 1) {
+    return Math.ceil(number * scale) / scale;
+  }
+  if (round === -1) {
+    return Math.floor(number * scale) / scale;
+  }
+  return Math.round(number * scale) / scale;
+}
+function randomNumber(min, max) {
+  const [minFinal, maxFinal] = min > max ? [max, min] : [min, max];
+  return Math.floor(Math.random() * (maxFinal - minFinal + 1) + minFinal);
+}
+function numberAbbr(number, units, options) {
+  const { base = 1e3, precision = 0 } = options || {};
+  const { length } = units;
+  if (length === 0) throw new Error("数字单位组不能为空");
+  let numberFinal = number;
+  let step = 0;
+  while (numberFinal >= base && step < length - 1) {
+    numberFinal = numberFinal / base;
+    step++;
+  }
+  const value = numberFixed(numberFinal, { precision, round: -1 });
+  const unit = units[step];
+  return `${value}${unit}`;
+}
+function fileSizeAbbr(number, precision = 0) {
+  return numberAbbr(number, ["B", "KB", "MB", "GB", "TB"], {
+    base: 1024,
+    precision
+  });
+}
+function numberConvert(decimal, dict) {
+  const dictFinal = dict || STRING_DICT;
+  if (dictFinal.length < 2) throw new Error("进制转换字典长度不能小于 2");
+  let bigInt = BigInt(decimal);
+  const symbol = bigInt < 0n ? "-" : "";
+  bigInt = bigInt < 0n ? -bigInt : bigInt;
+  const result = [];
+  const { length } = dictFinal;
+  const bigLength = BigInt(length);
+  const calculate = () => {
+    const y = Number(bigInt % bigLength);
+    bigInt = bigInt / bigLength;
+    result.unshift(dictFinal[y]);
+    if (bigInt > 0) {
+      calculate();
+    }
+  };
+  calculate();
+  return symbol + result.join("");
+}
+function numberFormat(number, options) {
+  let optionsFinal = {
+    separator: ",",
+    step: 3
+  };
+  if (typeof options === "string") {
+    optionsFinal.separator = options;
+  } else if (typeof options === "number") {
+    optionsFinal.step = options;
+  } else {
+    optionsFinal = merge.objectDefaults(options || {}, optionsFinal);
+  }
+  const { separator, step } = optionsFinal;
+  const arr = String(number).split(".");
+  const re = new RegExp(`(\\d)(?=(\\d{${step}})+(?!\\d))`, "g");
+  const p1 = arr[0].replace(re, `$1${separator}`);
+  return p1 + (arr[1] ? `.${arr[1]}` : "");
+}
+function numberClamp(min, number, max) {
+  return Math.min(Math.max(number, min), max);
+}
+function numberUnit(number, unit = "") {
+  if (type.isNumber(number)) return `${number}${unit}`;
+  if (/^-?[\d.]+$/.test(number)) return `${number}${unit}`;
+  return number;
+}
+const STRING_ARABIC_NUMERALS = "0123456789";
+const STRING_HEXADECIMALS = "0123456789abcdef";
+const STRING_LOWERCASE_ALPHA = "abcdefghijklmnopqrstuvwxyz";
+const STRING_UPPERCASE_ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const STRING_DICT = `${STRING_ARABIC_NUMERALS + STRING_UPPERCASE_ALPHA + STRING_LOWERCASE_ALPHA}`;
+function stringCamelCase(string, bigger) {
+  const string2 = string.replace(/[\s_-](.)/g, (_, char) => char.toUpperCase());
+  return bigger ? string2.slice(0, 1).toUpperCase() + string2.slice(1) : string2;
+}
+function stringKebabCase(string, separator = "-") {
+  return string.replace(/[A-Z]/g, (origin) => `${separator}${origin.toLowerCase()}`);
+}
+function randomString(length, dict) {
+  const dictFinal = dict || STRING_DICT;
+  const dictLength = dictFinal.length;
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += dictFinal.charAt(randomNumber(0, dictLength - 1));
+  }
+  return result;
+}
+function stringFormat(str, ...args) {
+  const [firstArg, fallback] = args;
+  if (type.isObject(firstArg) || type.isUndefined(firstArg)) {
+    const vars = firstArg || {};
+    return str.replace(/\{(\w+)\}/g, (_, key) => vars[key] ?? (type.isFunction(fallback) ? fallback(key) : fallback) ?? key);
+  }
+  return str.replace(/\{(\d+)\}/g, (_, key) => {
+    const index = Number(key);
+    if (Number.isNaN(index)) return key;
+    return args[index];
+  });
+}
+function randomUUID4() {
+  const template = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
+  let result = "";
+  for (let i = 0; i < template.length; i++) {
+    const t = template[i];
+    if (t === "-" || t === "4") {
+      result += t;
+      continue;
+    }
+    if (t === "y") {
+      result += randomString(1, "89ab");
+      continue;
+    }
+    result += randomString(1, STRING_HEXADECIMALS);
+  }
+  return result;
+}
+function stringify(value) {
+  return type.isNullish(value) ? "" : String(value);
+}
+exports.STRING_ARABIC_NUMERALS = STRING_ARABIC_NUMERALS;
+exports.STRING_DICT = STRING_DICT;
+exports.STRING_HEXADECIMALS = STRING_HEXADECIMALS;
+exports.STRING_LOWERCASE_ALPHA = STRING_LOWERCASE_ALPHA;
+exports.STRING_UPPERCASE_ALPHA = STRING_UPPERCASE_ALPHA;
+exports.fileSizeAbbr = fileSizeAbbr;
+exports.numberAbbr = numberAbbr;
+exports.numberClamp = numberClamp;
+exports.numberConvert = numberConvert;
+exports.numberFixed = numberFixed;
+exports.numberFormat = numberFormat;
+exports.numberUnit = numberUnit;
+exports.randomNumber = randomNumber;
+exports.randomString = randomString;
+exports.randomUUID4 = randomUUID4;
+exports.stringCamelCase = stringCamelCase;
+exports.stringFormat = stringFormat;
+exports.stringKebabCase = stringKebabCase;
+exports.stringify = stringify;
+//# sourceMappingURL=string2.cjs.map

package/dist/string2.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"string2.cjs","sources":["../src/number.ts","../src/string.ts"],"sourcesContent":["import { objectDefaults } from './object';\nimport { STRING_DICT } from './string';\nimport { isNumber } from './type';\n\nexport type NumberFixedOptions = {\n  /**\n   * 保留的小数位数\n   * @default 0\n   */\n  precision?: number;\n\n  /**\n   * 舍入方法，0 为四舍五入，1 为向上取整，-1 为向下取整\n   * @default 0\n   */\n  round?: 0 | 1 | -1;\n};\n\n/**\n * 对数字进行精确小数位数处理并按规则舍入\n * @param number 需要处理的原始数值\n * @param options 可选配置参数\n * @returns 处理后的数值（number类型）\n * @example\n * // 四舍五入示例\n * numberFixed(3.1415, { precision: 2 }); // 3.14\n * // 向上取整示例\n * numberFixed(3.1415, { precision: 2, round: 1 }); // 3.15\n * // 向下取整示例\n * numberFixed(3.9999, { precision: 1, round: -1 }); // 3.9\n */\nexport function numberFixed(number: number, options?: NumberFixedOptions) {\n  const { precision = 0, round = 0 } = options || {};\n  const scale = 10 ** precision;\n\n  if (round === 1) {\n    return Math.ceil(number * scale) / scale;\n  }\n\n  if (round === -1) {\n    return Math.floor(number * scale) / scale;\n  }\n\n  return Math.round(number * scale) / scale;\n}\n\n/**\n * 生成指定范围内的随机整数\n * @param {number} min - 随机数的最小值（包含）\n * @param {number} max - 随机数的最大值（包含）\n * @returns {number} - 生成的随机整数\n * @example\n * // 生成 1 到 10 之间的随机整数\n * randomNumber(1, 10); // 可能返回 7\n */\nexport function randomNumber(min: number, max: number): number {\n  const [minFinal, maxFinal] = min > max ? [max, min] : [min, max];\n  return Math.floor(Math.random() * (maxFinal - minFinal + 1) + minFinal);\n}\n\n/**\n * 数字缩写选项\n */\nexport type NumberAbbrOptions = {\n  /**\n   * 进制基数，用于计算单位进阶（如 1000 表示千进制）\n   * @default 1000\n   */\n  base?: number;\n\n  /**\n   * 数值保留的小数位数\n   * @default 0\n   */\n  precision?: number;\n};\n\n/**\n * 将数字转换为带单位缩写的字符串表示\n *\n * @param {number} number - 需要转换的原始数值\n * @param {Array<string>} units - 单位数组，按从小到大顺序排列（如['B','KB','MB']），不能为空\n * @param {NumberAbbrOptions} [options] - 可选配置参数\n * @returns {string} - 转换后的带单位字符串（如\"1.2KB\"）\n * @example\n * // 基础用法\n * numberAbbr(1500, ['', 'K', 'M'], { base: 1000 }); // \"1.5K\"\n * @example\n * // 自定义小数位\n * numberAbbr(123456, ['B','KB','MB'], { precision: 1 }); // \"0.1MB\"\n * @example\n * // 处理不足基数的情况\n * numberAbbr(500, ['B','KB']); // \"500B\"\n */\nexport function numberAbbr(number: number, units: Array<string>, options?: NumberAbbrOptions): string {\n  const { base = 1000, precision = 0 } = options || {};\n  const { length } = units;\n\n  if (length === 0) throw new Error('数字单位组不能为空');\n\n  let numberFinal = number;\n  let step = 0;\n\n  while (numberFinal >= base && step < length - 1) {\n    numberFinal = numberFinal / base;\n    step++;\n  }\n\n  const value = numberFixed(numberFinal, { precision, round: -1 });\n  const unit = units[step];\n\n  return `${value}${unit}`;\n}\n\n/**\n * 将文件大小转换为带单位缩写的字符串表示\n *\n * @param {number} number - 需要转换的文件大小数值\n * @param {number} [precision=0] - 数值保留的小数位数\n * @returns {string} - 转换后的带单位字符串（如\"1.2KB\"）\n * @example\n * // 基础用法\n * fileSizeAbbr(1024); // \"1KB\"\n * @example\n * // 自定义小数位\n * fileSizeAbbr(123456, 1); // \"0.1MB\"\n */\nexport function fileSizeAbbr(number: number, precision = 0) {\n  return numberAbbr(number, ['B', 'KB', 'MB', 'GB', 'TB'], {\n    base: 1024,\n    precision,\n  });\n}\n\n/**\n * 将十进制数转换为指定进制的字符串表示\n *\n * @param {number | bigint} decimal - 需要转换的十进制数，可以是任意长度的数字或大整数\n * @param {string} [dict] - 用于表示进制的字符字典，默认为数字、小写字母和大写字母的组合（62 进制）\n * @returns {string} - 转换后的指定进制字符串\n * @throws {Error} - 如果字符字典的长度小于 2，将抛出错误\n * @example\n * // 默认 62 进制\n * numberConvert(123456789); // \"8M0kX\"\n * @example\n * // 自定义 16 进制\n * numberConvert(255, '0123456789ABCDEF'); // \"FF\"\n * @example\n * // 处理大整数\n * numberConvert(9007199254740991n); // \"2gosa7pa2GV\"\n */\nexport function numberConvert(decimal: number | bigint, dict?: string): string {\n  const dictFinal = dict || STRING_DICT;\n\n  if (dictFinal.length < 2) throw new Error('进制转换字典长度不能小于 2');\n\n  let bigInt = BigInt(decimal);\n  const symbol = bigInt < 0n ? '-' : '';\n  bigInt = bigInt < 0n ? -bigInt : bigInt;\n  const result: Array<string> = [];\n  const { length } = dictFinal;\n  const bigLength = BigInt(length);\n  const calculate = (): void => {\n    const y = Number(bigInt % bigLength);\n\n    bigInt = bigInt / bigLength;\n    result.unshift(dictFinal[y]);\n\n    if (bigInt > 0) {\n      calculate();\n    }\n  };\n\n  calculate();\n\n  return symbol + result.join('');\n}\n\n/**\n * 数字格式化配置选项\n */\nexport type NumberFormatOptions = {\n  /**\n   * 分隔符字符，用于数字分隔\n   * @default ','\n   * @example 使用 '_' 分隔符时，123456 会格式化为 '123_456'\n   */\n  separator?: string;\n\n  /**\n   * 分隔步长，即每隔多少位添加分隔符\n   * @default 3\n   * @example 步长为 2 时，123456 会格式化为 '12,34,56'\n   */\n  step?: number;\n};\n\n/**\n * 数字格式化\n * @param [number] {number} 数字\n * @param options {NumberFormatOptions} 格式化配置\n * @returns {string} 分割后的字符串\n * @example\n * // 使用默认分隔符和步长\n * numberFormat(123456.789); // => \"123,456.789\"\n * // 自定义分隔符\n * numberFormat(123456.789, '_'); // => \"123_456.789\"\n * // 自定义步长\n * numberFormat(123456.789, 2); // => \"12,34,56.789\"\n * // 使用对象配置\n * numberFormat(123456.789, { separator: '.', step: 4 }); // => \"12.3456.789\"\n */\nexport function numberFormat(number: number, options: NumberFormatOptions): string;\nexport function numberFormat(number: number, separator: string): string;\nexport function numberFormat(number: number, step: number): string;\nexport function numberFormat(number: number): string;\nexport function numberFormat(number: number, options?: NumberFormatOptions | string | number) {\n  let optionsFinal: Required<NumberFormatOptions> = {\n    separator: ',',\n    step: 3,\n  };\n\n  if (typeof options === 'string') {\n    optionsFinal.separator = options;\n  } else if (typeof options === 'number') {\n    optionsFinal.step = options;\n  } else {\n    optionsFinal = objectDefaults(options || {}, optionsFinal) as Required<NumberFormatOptions>;\n  }\n\n  const { separator, step } = optionsFinal;\n  const arr = String(number).split('.');\n  const re = new RegExp(`(\\\\d)(?=(\\\\d{${step}})+(?!\\\\d))`, 'g');\n  const p1 = arr[0].replace(re, `$1${separator}`);\n\n  return p1 + (arr[1] ? `.${arr[1]}` : '');\n}\n\n/**\n * 将数字限制在指定范围内。\n *\n * @param min - 最小值。\n * @param number - 要限制的数字。\n * @param max - 最大值。\n * @returns 限制后的数字。\n */\nexport function numberClamp(min: number, number: number, max: number) {\n  return Math.min(Math.max(number, min), max);\n}\n\n/**\n * 为数字添加单位\n * @param number - 需要处理的数字，可以是数字类型或字符串类型\n * @param unit - 要添加的单位，默认为空字符串\n * @returns 如果输入是数字或纯数字字符串，则返回带单位的字符串；否则返回原值\n */\nexport function numberUnit(number: string | number, unit = '') {\n  if (isNumber(number)) return `${number}${unit}`;\n  if (/^-?[\\d.]+$/.test(number)) return `${number}${unit}`;\n  return number;\n}\n","import { numberConvert, randomNumber } from './number';\nimport { isFunction, isNullish, isNumber, isObject, isString, isUndefined } from './type';\n\nexport const STRING_ARABIC_NUMERALS = '0123456789';\nexport const STRING_HEXADECIMALS = '0123456789abcdef';\nexport const STRING_LOWERCASE_ALPHA = 'abcdefghijklmnopqrstuvwxyz';\nexport const STRING_UPPERCASE_ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';\nexport const STRING_DICT = `${STRING_ARABIC_NUMERALS + STRING_UPPERCASE_ALPHA + STRING_LOWERCASE_ALPHA}`;\n\n/**\n * 将字符串转换为驼峰格式\n * @param {string} string - 要转换的字符串\n * @param {boolean} [bigger] - 是否大写第一个字母，默认为 false\n * @returns {string} - 转换后的驼峰格式字符串\n */\nexport function stringCamelCase(string: string, bigger?: boolean): string {\n  const string2 = string.replace(/[\\s_-](.)/g, (_, char) => (char as string).toUpperCase());\n  return bigger ? string2.slice(0, 1).toUpperCase() + string2.slice(1) : string2;\n}\n\n/**\n * 将字符串转换为连字格式\n * @param {string} string - 要转换的字符串\n * @param {string} [separator] - 分隔符，默认是 \"-\"（短横线）\n * @returns {string} - 转换后的连字格式字符串\n */\nexport function stringKebabCase(string: string, separator = '-'): string {\n  return string.replace(/[A-Z]/g, (origin) => `${separator}${origin.toLowerCase()}`);\n}\n\n/**\n * 生成随机字符串\n * @param {number} length - 生成的随机字符串长度\n * @param {string} [dict] - 用于生成随机字符串的字符字典，默认为数字、小写字母和大写字母的组合\n * @returns {string} - 生成的随机字符串\n * @example\n * randomString(10); // 生成一个长度为 10 的随机字符串\n * randomString(8, 'ABCDEF'); // 生成一个长度为 8 的随机字符串，仅包含字符 'ABCDEF'\n */\nexport function randomString(length: number, dict?: string): string {\n  const dictFinal = dict || STRING_DICT;\n  const dictLength = dictFinal.length;\n\n  let result = '';\n\n  for (let i = 0; i < length; i++) {\n    result += dictFinal.charAt(randomNumber(0, dictLength - 1));\n  }\n\n  return result;\n}\n\n/**\n * 简单的模板引擎，类似于 Python 的 `.format()` 方法\n * 支持通过索引或对象/名称的方式传递变量\n * 当使用对象/名称方式时，可以传递一个回退值作为第三个参数\n *\n * @category 字符串\n * @example\n * ```\n * // 索引方式\n * const result = stringFormat(\n *   '你好 {0}！我的名字是 {1}。',\n *   '张三',\n *   '李四'\n * ); // 你好 张三！我的名字是 李四。\n * ```\n *\n * @example\n * ```\n * // 对象方式\n * const result = stringFormat(\n *   '{greet}！我的名字是 {name}。',\n *   { greet: '你好', name: '王五' }\n * ); // 你好！我的名字是 王五。\n * ```\n *\n * @example\n * ```\n * // 带回退值的对象方式\n * const result = stringFormat(\n *   '{greet}！我的名字是 {name}。',\n *   { greet: '你好' }, // name 未传递，因此会使用回退值\n *   '未知'\n * ); // 你好！我的名字是 未知。\n * ```\n */\nexport function stringFormat(\n  str: string,\n  object: Record<string | number, unknown>,\n  fallback?: string | ((key: string) => string),\n): string;\nexport function stringFormat(str: string, ...args: (string | number | bigint | undefined | null)[]): string;\nexport function stringFormat(str: string, ...args: unknown[]): string {\n  const [firstArg, fallback] = args;\n\n  if (isObject(firstArg) || isUndefined(firstArg)) {\n    const vars = firstArg || {};\n    return str.replace(/\\{(\\w+)\\}/g, (_, key) => vars[key] ?? (isFunction(fallback) ? fallback(key) : fallback) ?? key);\n  }\n\n  return str.replace(/\\{(\\d+)\\}/g, (_, key) => {\n    const index = Number(key);\n    if (Number.isNaN(index)) return key;\n    return args[index];\n  });\n}\n\n/**\n * 生成符合 [RFC 4122](https://www.ietf.org/rfc/rfc4122.txt) 版本 4 的 UUID 字符串\n * @returns {string} - 生成的 UUID 字符串\n * @example\n * const uuid = randomUUID4();\n * console.log(uuid); // 输出类似 '123e4567-e89b-12d3-a456-426614174000' 的 UUID 字符串\n */\nexport function randomUUID4(): string {\n  const template = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';\n  let result = '';\n\n  for (let i = 0; i < template.length; i++) {\n    const t = template[i];\n\n    if (t === '-' || t === '4') {\n      result += t;\n      continue;\n    }\n\n    if (t === 'y') {\n      result += randomString(1, '89ab');\n      continue;\n    }\n\n    result += randomString(1, STRING_HEXADECIMALS);\n  }\n\n  return result;\n}\n\n/**\n * 将值转换为字符串，若值为 null 或 undefined 则返回空字符串\n * @param {unknown} value - 需要转换的值\n * @returns {string} 转换后的字符串结果\n */\nexport function stringify(value: unknown) {\n  return isNullish(value) ? '' : String(value);\n}\n"],"names":["objectDefaults","isNumber","isObject","isUndefined","isFunction","isNullish"],"mappings":";;;AA+BgB,SAAA,YAAY,QAAgB,SAA8B;AACxE,QAAM,EAAE,YAAY,GAAG,QAAQ,EAAE,IAAI,WAAW,CAAC;AACjD,QAAM,QAAQ,MAAM;AAEpB,MAAI,UAAU,GAAG;AACf,WAAO,KAAK,KAAK,SAAS,KAAK,IAAI;AAAA,EAAA;AAGrC,MAAI,UAAU,IAAI;AAChB,WAAO,KAAK,MAAM,SAAS,KAAK,IAAI;AAAA,EAAA;AAGtC,SAAO,KAAK,MAAM,SAAS,KAAK,IAAI;AACtC;AAWgB,SAAA,aAAa,KAAa,KAAqB;AAC7D,QAAM,CAAC,UAAU,QAAQ,IAAI,MAAM,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG;AACxD,SAAA,KAAK,MAAM,KAAK,OAAA,KAAY,WAAW,WAAW,KAAK,QAAQ;AACxE;AAoCgB,SAAA,WAAW,QAAgB,OAAsB,SAAqC;AACpG,QAAM,EAAE,OAAO,KAAM,YAAY,EAAE,IAAI,WAAW,CAAC;AAC7C,QAAA,EAAE,WAAW;AAEnB,MAAI,WAAW,EAAS,OAAA,IAAI,MAAM,WAAW;AAE7C,MAAI,cAAc;AAClB,MAAI,OAAO;AAEX,SAAO,eAAe,QAAQ,OAAO,SAAS,GAAG;AAC/C,kBAAc,cAAc;AAC5B;AAAA,EAAA;AAGF,QAAM,QAAQ,YAAY,aAAa,EAAE,WAAW,OAAO,IAAI;AACzD,QAAA,OAAO,MAAM,IAAI;AAEhB,SAAA,GAAG,KAAK,GAAG,IAAI;AACxB;AAegB,SAAA,aAAa,QAAgB,YAAY,GAAG;AACnD,SAAA,WAAW,QAAQ,CAAC,KAAK,MAAM,MAAM,MAAM,IAAI,GAAG;AAAA,IACvD,MAAM;AAAA,IACN;AAAA,EAAA,CACD;AACH;AAmBgB,SAAA,cAAc,SAA0B,MAAuB;AAC7E,QAAM,YAAY,QAAQ;AAE1B,MAAI,UAAU,SAAS,EAAS,OAAA,IAAI,MAAM,gBAAgB;AAEtD,MAAA,SAAS,OAAO,OAAO;AACrB,QAAA,SAAS,SAAS,KAAK,MAAM;AAC1B,WAAA,SAAS,KAAK,CAAC,SAAS;AACjC,QAAM,SAAwB,CAAC;AACzB,QAAA,EAAE,WAAW;AACb,QAAA,YAAY,OAAO,MAAM;AAC/B,QAAM,YAAY,MAAY;AACtB,UAAA,IAAI,OAAO,SAAS,SAAS;AAEnC,aAAS,SAAS;AACX,WAAA,QAAQ,UAAU,CAAC,CAAC;AAE3B,QAAI,SAAS,GAAG;AACJ,gBAAA;AAAA,IAAA;AAAA,EAEd;AAEU,YAAA;AAEH,SAAA,SAAS,OAAO,KAAK,EAAE;AAChC;AAwCgB,SAAA,aAAa,QAAgB,SAAiD;AAC5F,MAAI,eAA8C;AAAA,IAChD,WAAW;AAAA,IACX,MAAM;AAAA,EACR;AAEI,MAAA,OAAO,YAAY,UAAU;AAC/B,iBAAa,YAAY;AAAA,EAAA,WAChB,OAAO,YAAY,UAAU;AACtC,iBAAa,OAAO;AAAA,EAAA,OACf;AACL,mBAAeA,MAAe,eAAA,WAAW,CAAA,GAAI,YAAY;AAAA,EAAA;AAGrD,QAAA,EAAE,WAAW,KAAA,IAAS;AAC5B,QAAM,MAAM,OAAO,MAAM,EAAE,MAAM,GAAG;AACpC,QAAM,KAAK,IAAI,OAAO,gBAAgB,IAAI,eAAe,GAAG;AACtD,QAAA,KAAK,IAAI,CAAC,EAAE,QAAQ,IAAI,KAAK,SAAS,EAAE;AAEvC,SAAA,MAAM,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,KAAK;AACvC;AAUgB,SAAA,YAAY,KAAa,QAAgB,KAAa;AACpE,SAAO,KAAK,IAAI,KAAK,IAAI,QAAQ,GAAG,GAAG,GAAG;AAC5C;AAQgB,SAAA,WAAW,QAAyB,OAAO,IAAI;AAC7D,MAAIC,KAAAA,SAAS,MAAM,UAAU,GAAG,MAAM,GAAG,IAAI;AACzC,MAAA,aAAa,KAAK,MAAM,UAAU,GAAG,MAAM,GAAG,IAAI;AAC/C,SAAA;AACT;ACjQO,MAAM,yBAAyB;AAC/B,MAAM,sBAAsB;AAC5B,MAAM,yBAAyB;AAC/B,MAAM,yBAAyB;AAC/B,MAAM,cAAc,GAAG,yBAAyB,yBAAyB,sBAAsB;AAQtF,SAAA,gBAAgB,QAAgB,QAA0B;AAClE,QAAA,UAAU,OAAO,QAAQ,cAAc,CAAC,GAAG,SAAU,KAAgB,aAAa;AACjF,SAAA,SAAS,QAAQ,MAAM,GAAG,CAAC,EAAE,YAAA,IAAgB,QAAQ,MAAM,CAAC,IAAI;AACzE;AAQgB,SAAA,gBAAgB,QAAgB,YAAY,KAAa;AAChE,SAAA,OAAO,QAAQ,UAAU,CAAC,WAAW,GAAG,SAAS,GAAG,OAAO,YAAY,CAAC,EAAE;AACnF;AAWgB,SAAA,aAAa,QAAgB,MAAuB;AAClE,QAAM,YAAY,QAAQ;AAC1B,QAAM,aAAa,UAAU;AAE7B,MAAI,SAAS;AAEb,WAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC/B,cAAU,UAAU,OAAO,aAAa,GAAG,aAAa,CAAC,CAAC;AAAA,EAAA;AAGrD,SAAA;AACT;AA2CgB,SAAA,aAAa,QAAgB,MAAyB;AAC9D,QAAA,CAAC,UAAU,QAAQ,IAAI;AAE7B,MAAIC,KAAS,SAAA,QAAQ,KAAKC,KAAA,YAAY,QAAQ,GAAG;AACzC,UAAA,OAAO,YAAY,CAAC;AAC1B,WAAO,IAAI,QAAQ,cAAc,CAAC,GAAG,QAAQ,KAAK,GAAG,MAAMC,KAAA,WAAW,QAAQ,IAAI,SAAS,GAAG,IAAI,aAAa,GAAG;AAAA,EAAA;AAGpH,SAAO,IAAI,QAAQ,cAAc,CAAC,GAAG,QAAQ;AACrC,UAAA,QAAQ,OAAO,GAAG;AACxB,QAAI,OAAO,MAAM,KAAK,EAAU,QAAA;AAChC,WAAO,KAAK,KAAK;AAAA,EAAA,CAClB;AACH;AASO,SAAS,cAAsB;AACpC,QAAM,WAAW;AACjB,MAAI,SAAS;AAEb,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AAClC,UAAA,IAAI,SAAS,CAAC;AAEhB,QAAA,MAAM,OAAO,MAAM,KAAK;AAChB,gBAAA;AACV;AAAA,IAAA;AAGF,QAAI,MAAM,KAAK;AACH,gBAAA,aAAa,GAAG,MAAM;AAChC;AAAA,IAAA;AAGQ,cAAA,aAAa,GAAG,mBAAmB;AAAA,EAAA;AAGxC,SAAA;AACT;AAOO,SAAS,UAAU,OAAgB;AACxC,SAAOC,KAAU,UAAA,KAAK,IAAI,KAAK,OAAO,KAAK;AAC7C;;;;;;;;;;;;;;;;;;;;"}

package/dist/string2.mjs

@@ -0,0 +1,158 @@
+import { o as objectDefaults } from "./merge.mjs";
+import { isNumber, isObject, isUndefined, isFunction, isNullish } from "./type.mjs";
+function numberFixed(number, options) {
+  const { precision = 0, round = 0 } = options || {};
+  const scale = 10 ** precision;
+  if (round === 1) {
+    return Math.ceil(number * scale) / scale;
+  }
+  if (round === -1) {
+    return Math.floor(number * scale) / scale;
+  }
+  return Math.round(number * scale) / scale;
+}
+function randomNumber(min, max) {
+  const [minFinal, maxFinal] = min > max ? [max, min] : [min, max];
+  return Math.floor(Math.random() * (maxFinal - minFinal + 1) + minFinal);
+}
+function numberAbbr(number, units, options) {
+  const { base = 1e3, precision = 0 } = options || {};
+  const { length } = units;
+  if (length === 0) throw new Error("数字单位组不能为空");
+  let numberFinal = number;
+  let step = 0;
+  while (numberFinal >= base && step < length - 1) {
+    numberFinal = numberFinal / base;
+    step++;
+  }
+  const value = numberFixed(numberFinal, { precision, round: -1 });
+  const unit = units[step];
+  return `${value}${unit}`;
+}
+function fileSizeAbbr(number, precision = 0) {
+  return numberAbbr(number, ["B", "KB", "MB", "GB", "TB"], {
+    base: 1024,
+    precision
+  });
+}
+function numberConvert(decimal, dict) {
+  const dictFinal = dict || STRING_DICT;
+  if (dictFinal.length < 2) throw new Error("进制转换字典长度不能小于 2");
+  let bigInt = BigInt(decimal);
+  const symbol = bigInt < 0n ? "-" : "";
+  bigInt = bigInt < 0n ? -bigInt : bigInt;
+  const result = [];
+  const { length } = dictFinal;
+  const bigLength = BigInt(length);
+  const calculate = () => {
+    const y = Number(bigInt % bigLength);
+    bigInt = bigInt / bigLength;
+    result.unshift(dictFinal[y]);
+    if (bigInt > 0) {
+      calculate();
+    }
+  };
+  calculate();
+  return symbol + result.join("");
+}
+function numberFormat(number, options) {
+  let optionsFinal = {
+    separator: ",",
+    step: 3
+  };
+  if (typeof options === "string") {
+    optionsFinal.separator = options;
+  } else if (typeof options === "number") {
+    optionsFinal.step = options;
+  } else {
+    optionsFinal = objectDefaults(options || {}, optionsFinal);
+  }
+  const { separator, step } = optionsFinal;
+  const arr = String(number).split(".");
+  const re = new RegExp(`(\\d)(?=(\\d{${step}})+(?!\\d))`, "g");
+  const p1 = arr[0].replace(re, `$1${separator}`);
+  return p1 + (arr[1] ? `.${arr[1]}` : "");
+}
+function numberClamp(min, number, max) {
+  return Math.min(Math.max(number, min), max);
+}
+function numberUnit(number, unit = "") {
+  if (isNumber(number)) return `${number}${unit}`;
+  if (/^-?[\d.]+$/.test(number)) return `${number}${unit}`;
+  return number;
+}
+const STRING_ARABIC_NUMERALS = "0123456789";
+const STRING_HEXADECIMALS = "0123456789abcdef";
+const STRING_LOWERCASE_ALPHA = "abcdefghijklmnopqrstuvwxyz";
+const STRING_UPPERCASE_ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const STRING_DICT = `${STRING_ARABIC_NUMERALS + STRING_UPPERCASE_ALPHA + STRING_LOWERCASE_ALPHA}`;
+function stringCamelCase(string, bigger) {
+  const string2 = string.replace(/[\s_-](.)/g, (_, char) => char.toUpperCase());
+  return bigger ? string2.slice(0, 1).toUpperCase() + string2.slice(1) : string2;
+}
+function stringKebabCase(string, separator = "-") {
+  return string.replace(/[A-Z]/g, (origin) => `${separator}${origin.toLowerCase()}`);
+}
+function randomString(length, dict) {
+  const dictFinal = dict || STRING_DICT;
+  const dictLength = dictFinal.length;
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += dictFinal.charAt(randomNumber(0, dictLength - 1));
+  }
+  return result;
+}
+function stringFormat(str, ...args) {
+  const [firstArg, fallback] = args;
+  if (isObject(firstArg) || isUndefined(firstArg)) {
+    const vars = firstArg || {};
+    return str.replace(/\{(\w+)\}/g, (_, key) => vars[key] ?? (isFunction(fallback) ? fallback(key) : fallback) ?? key);
+  }
+  return str.replace(/\{(\d+)\}/g, (_, key) => {
+    const index = Number(key);
+    if (Number.isNaN(index)) return key;
+    return args[index];
+  });
+}
+function randomUUID4() {
+  const template = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
+  let result = "";
+  for (let i = 0; i < template.length; i++) {
+    const t = template[i];
+    if (t === "-" || t === "4") {
+      result += t;
+      continue;
+    }
+    if (t === "y") {
+      result += randomString(1, "89ab");
+      continue;
+    }
+    result += randomString(1, STRING_HEXADECIMALS);
+  }
+  return result;
+}
+function stringify(value) {
+  return isNullish(value) ? "" : String(value);
+}
+export {
+  STRING_DICT as S,
+  numberFixed as a,
+  numberAbbr as b,
+  numberFormat as c,
+  numberClamp as d,
+  numberUnit as e,
+  fileSizeAbbr as f,
+  STRING_ARABIC_NUMERALS as g,
+  STRING_HEXADECIMALS as h,
+  STRING_LOWERCASE_ALPHA as i,
+  STRING_UPPERCASE_ALPHA as j,
+  stringCamelCase as k,
+  stringKebabCase as l,
+  randomString as m,
+  numberConvert as n,
+  randomUUID4 as o,
+  stringify as p,
+  randomNumber as r,
+  stringFormat as s
+};
+//# sourceMappingURL=string2.mjs.map

package/dist/string2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"string2.mjs","sources":["../src/number.ts","../src/string.ts"],"sourcesContent":["import { objectDefaults } from './object';\nimport { STRING_DICT } from './string';\nimport { isNumber } from './type';\n\nexport type NumberFixedOptions = {\n  /**\n   * 保留的小数位数\n   * @default 0\n   */\n  precision?: number;\n\n  /**\n   * 舍入方法，0 为四舍五入，1 为向上取整，-1 为向下取整\n   * @default 0\n   */\n  round?: 0 | 1 | -1;\n};\n\n/**\n * 对数字进行精确小数位数处理并按规则舍入\n * @param number 需要处理的原始数值\n * @param options 可选配置参数\n * @returns 处理后的数值（number类型）\n * @example\n * // 四舍五入示例\n * numberFixed(3.1415, { precision: 2 }); // 3.14\n * // 向上取整示例\n * numberFixed(3.1415, { precision: 2, round: 1 }); // 3.15\n * // 向下取整示例\n * numberFixed(3.9999, { precision: 1, round: -1 }); // 3.9\n */\nexport function numberFixed(number: number, options?: NumberFixedOptions) {\n  const { precision = 0, round = 0 } = options || {};\n  const scale = 10 ** precision;\n\n  if (round === 1) {\n    return Math.ceil(number * scale) / scale;\n  }\n\n  if (round === -1) {\n    return Math.floor(number * scale) / scale;\n  }\n\n  return Math.round(number * scale) / scale;\n}\n\n/**\n * 生成指定范围内的随机整数\n * @param {number} min - 随机数的最小值（包含）\n * @param {number} max - 随机数的最大值（包含）\n * @returns {number} - 生成的随机整数\n * @example\n * // 生成 1 到 10 之间的随机整数\n * randomNumber(1, 10); // 可能返回 7\n */\nexport function randomNumber(min: number, max: number): number {\n  const [minFinal, maxFinal] = min > max ? [max, min] : [min, max];\n  return Math.floor(Math.random() * (maxFinal - minFinal + 1) + minFinal);\n}\n\n/**\n * 数字缩写选项\n */\nexport type NumberAbbrOptions = {\n  /**\n   * 进制基数，用于计算单位进阶（如 1000 表示千进制）\n   * @default 1000\n   */\n  base?: number;\n\n  /**\n   * 数值保留的小数位数\n   * @default 0\n   */\n  precision?: number;\n};\n\n/**\n * 将数字转换为带单位缩写的字符串表示\n *\n * @param {number} number - 需要转换的原始数值\n * @param {Array<string>} units - 单位数组，按从小到大顺序排列（如['B','KB','MB']），不能为空\n * @param {NumberAbbrOptions} [options] - 可选配置参数\n * @returns {string} - 转换后的带单位字符串（如\"1.2KB\"）\n * @example\n * // 基础用法\n * numberAbbr(1500, ['', 'K', 'M'], { base: 1000 }); // \"1.5K\"\n * @example\n * // 自定义小数位\n * numberAbbr(123456, ['B','KB','MB'], { precision: 1 }); // \"0.1MB\"\n * @example\n * // 处理不足基数的情况\n * numberAbbr(500, ['B','KB']); // \"500B\"\n */\nexport function numberAbbr(number: number, units: Array<string>, options?: NumberAbbrOptions): string {\n  const { base = 1000, precision = 0 } = options || {};\n  const { length } = units;\n\n  if (length === 0) throw new Error('数字单位组不能为空');\n\n  let numberFinal = number;\n  let step = 0;\n\n  while (numberFinal >= base && step < length - 1) {\n    numberFinal = numberFinal / base;\n    step++;\n  }\n\n  const value = numberFixed(numberFinal, { precision, round: -1 });\n  const unit = units[step];\n\n  return `${value}${unit}`;\n}\n\n/**\n * 将文件大小转换为带单位缩写的字符串表示\n *\n * @param {number} number - 需要转换的文件大小数值\n * @param {number} [precision=0] - 数值保留的小数位数\n * @returns {string} - 转换后的带单位字符串（如\"1.2KB\"）\n * @example\n * // 基础用法\n * fileSizeAbbr(1024); // \"1KB\"\n * @example\n * // 自定义小数位\n * fileSizeAbbr(123456, 1); // \"0.1MB\"\n */\nexport function fileSizeAbbr(number: number, precision = 0) {\n  return numberAbbr(number, ['B', 'KB', 'MB', 'GB', 'TB'], {\n    base: 1024,\n    precision,\n  });\n}\n\n/**\n * 将十进制数转换为指定进制的字符串表示\n *\n * @param {number | bigint} decimal - 需要转换的十进制数，可以是任意长度的数字或大整数\n * @param {string} [dict] - 用于表示进制的字符字典，默认为数字、小写字母和大写字母的组合（62 进制）\n * @returns {string} - 转换后的指定进制字符串\n * @throws {Error} - 如果字符字典的长度小于 2，将抛出错误\n * @example\n * // 默认 62 进制\n * numberConvert(123456789); // \"8M0kX\"\n * @example\n * // 自定义 16 进制\n * numberConvert(255, '0123456789ABCDEF'); // \"FF\"\n * @example\n * // 处理大整数\n * numberConvert(9007199254740991n); // \"2gosa7pa2GV\"\n */\nexport function numberConvert(decimal: number | bigint, dict?: string): string {\n  const dictFinal = dict || STRING_DICT;\n\n  if (dictFinal.length < 2) throw new Error('进制转换字典长度不能小于 2');\n\n  let bigInt = BigInt(decimal);\n  const symbol = bigInt < 0n ? '-' : '';\n  bigInt = bigInt < 0n ? -bigInt : bigInt;\n  const result: Array<string> = [];\n  const { length } = dictFinal;\n  const bigLength = BigInt(length);\n  const calculate = (): void => {\n    const y = Number(bigInt % bigLength);\n\n    bigInt = bigInt / bigLength;\n    result.unshift(dictFinal[y]);\n\n    if (bigInt > 0) {\n      calculate();\n    }\n  };\n\n  calculate();\n\n  return symbol + result.join('');\n}\n\n/**\n * 数字格式化配置选项\n */\nexport type NumberFormatOptions = {\n  /**\n   * 分隔符字符，用于数字分隔\n   * @default ','\n   * @example 使用 '_' 分隔符时，123456 会格式化为 '123_456'\n   */\n  separator?: string;\n\n  /**\n   * 分隔步长，即每隔多少位添加分隔符\n   * @default 3\n   * @example 步长为 2 时，123456 会格式化为 '12,34,56'\n   */\n  step?: number;\n};\n\n/**\n * 数字格式化\n * @param [number] {number} 数字\n * @param options {NumberFormatOptions} 格式化配置\n * @returns {string} 分割后的字符串\n * @example\n * // 使用默认分隔符和步长\n * numberFormat(123456.789); // => \"123,456.789\"\n * // 自定义分隔符\n * numberFormat(123456.789, '_'); // => \"123_456.789\"\n * // 自定义步长\n * numberFormat(123456.789, 2); // => \"12,34,56.789\"\n * // 使用对象配置\n * numberFormat(123456.789, { separator: '.', step: 4 }); // => \"12.3456.789\"\n */\nexport function numberFormat(number: number, options: NumberFormatOptions): string;\nexport function numberFormat(number: number, separator: string): string;\nexport function numberFormat(number: number, step: number): string;\nexport function numberFormat(number: number): string;\nexport function numberFormat(number: number, options?: NumberFormatOptions | string | number) {\n  let optionsFinal: Required<NumberFormatOptions> = {\n    separator: ',',\n    step: 3,\n  };\n\n  if (typeof options === 'string') {\n    optionsFinal.separator = options;\n  } else if (typeof options === 'number') {\n    optionsFinal.step = options;\n  } else {\n    optionsFinal = objectDefaults(options || {}, optionsFinal) as Required<NumberFormatOptions>;\n  }\n\n  const { separator, step } = optionsFinal;\n  const arr = String(number).split('.');\n  const re = new RegExp(`(\\\\d)(?=(\\\\d{${step}})+(?!\\\\d))`, 'g');\n  const p1 = arr[0].replace(re, `$1${separator}`);\n\n  return p1 + (arr[1] ? `.${arr[1]}` : '');\n}\n\n/**\n * 将数字限制在指定范围内。\n *\n * @param min - 最小值。\n * @param number - 要限制的数字。\n * @param max - 最大值。\n * @returns 限制后的数字。\n */\nexport function numberClamp(min: number, number: number, max: number) {\n  return Math.min(Math.max(number, min), max);\n}\n\n/**\n * 为数字添加单位\n * @param number - 需要处理的数字，可以是数字类型或字符串类型\n * @param unit - 要添加的单位，默认为空字符串\n * @returns 如果输入是数字或纯数字字符串，则返回带单位的字符串；否则返回原值\n */\nexport function numberUnit(number: string | number, unit = '') {\n  if (isNumber(number)) return `${number}${unit}`;\n  if (/^-?[\\d.]+$/.test(number)) return `${number}${unit}`;\n  return number;\n}\n","import { numberConvert, randomNumber } from './number';\nimport { isFunction, isNullish, isNumber, isObject, isString, isUndefined } from './type';\n\nexport const STRING_ARABIC_NUMERALS = '0123456789';\nexport const STRING_HEXADECIMALS = '0123456789abcdef';\nexport const STRING_LOWERCASE_ALPHA = 'abcdefghijklmnopqrstuvwxyz';\nexport const STRING_UPPERCASE_ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';\nexport const STRING_DICT = `${STRING_ARABIC_NUMERALS + STRING_UPPERCASE_ALPHA + STRING_LOWERCASE_ALPHA}`;\n\n/**\n * 将字符串转换为驼峰格式\n * @param {string} string - 要转换的字符串\n * @param {boolean} [bigger] - 是否大写第一个字母，默认为 false\n * @returns {string} - 转换后的驼峰格式字符串\n */\nexport function stringCamelCase(string: string, bigger?: boolean): string {\n  const string2 = string.replace(/[\\s_-](.)/g, (_, char) => (char as string).toUpperCase());\n  return bigger ? string2.slice(0, 1).toUpperCase() + string2.slice(1) : string2;\n}\n\n/**\n * 将字符串转换为连字格式\n * @param {string} string - 要转换的字符串\n * @param {string} [separator] - 分隔符，默认是 \"-\"（短横线）\n * @returns {string} - 转换后的连字格式字符串\n */\nexport function stringKebabCase(string: string, separator = '-'): string {\n  return string.replace(/[A-Z]/g, (origin) => `${separator}${origin.toLowerCase()}`);\n}\n\n/**\n * 生成随机字符串\n * @param {number} length - 生成的随机字符串长度\n * @param {string} [dict] - 用于生成随机字符串的字符字典，默认为数字、小写字母和大写字母的组合\n * @returns {string} - 生成的随机字符串\n * @example\n * randomString(10); // 生成一个长度为 10 的随机字符串\n * randomString(8, 'ABCDEF'); // 生成一个长度为 8 的随机字符串，仅包含字符 'ABCDEF'\n */\nexport function randomString(length: number, dict?: string): string {\n  const dictFinal = dict || STRING_DICT;\n  const dictLength = dictFinal.length;\n\n  let result = '';\n\n  for (let i = 0; i < length; i++) {\n    result += dictFinal.charAt(randomNumber(0, dictLength - 1));\n  }\n\n  return result;\n}\n\n/**\n * 简单的模板引擎，类似于 Python 的 `.format()` 方法\n * 支持通过索引或对象/名称的方式传递变量\n * 当使用对象/名称方式时，可以传递一个回退值作为第三个参数\n *\n * @category 字符串\n * @example\n * ```\n * // 索引方式\n * const result = stringFormat(\n *   '你好 {0}！我的名字是 {1}。',\n *   '张三',\n *   '李四'\n * ); // 你好 张三！我的名字是 李四。\n * ```\n *\n * @example\n * ```\n * // 对象方式\n * const result = stringFormat(\n *   '{greet}！我的名字是 {name}。',\n *   { greet: '你好', name: '王五' }\n * ); // 你好！我的名字是 王五。\n * ```\n *\n * @example\n * ```\n * // 带回退值的对象方式\n * const result = stringFormat(\n *   '{greet}！我的名字是 {name}。',\n *   { greet: '你好' }, // name 未传递，因此会使用回退值\n *   '未知'\n * ); // 你好！我的名字是 未知。\n * ```\n */\nexport function stringFormat(\n  str: string,\n  object: Record<string | number, unknown>,\n  fallback?: string | ((key: string) => string),\n): string;\nexport function stringFormat(str: string, ...args: (string | number | bigint | undefined | null)[]): string;\nexport function stringFormat(str: string, ...args: unknown[]): string {\n  const [firstArg, fallback] = args;\n\n  if (isObject(firstArg) || isUndefined(firstArg)) {\n    const vars = firstArg || {};\n    return str.replace(/\\{(\\w+)\\}/g, (_, key) => vars[key] ?? (isFunction(fallback) ? fallback(key) : fallback) ?? key);\n  }\n\n  return str.replace(/\\{(\\d+)\\}/g, (_, key) => {\n    const index = Number(key);\n    if (Number.isNaN(index)) return key;\n    return args[index];\n  });\n}\n\n/**\n * 生成符合 [RFC 4122](https://www.ietf.org/rfc/rfc4122.txt) 版本 4 的 UUID 字符串\n * @returns {string} - 生成的 UUID 字符串\n * @example\n * const uuid = randomUUID4();\n * console.log(uuid); // 输出类似 '123e4567-e89b-12d3-a456-426614174000' 的 UUID 字符串\n */\nexport function randomUUID4(): string {\n  const template = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';\n  let result = '';\n\n  for (let i = 0; i < template.length; i++) {\n    const t = template[i];\n\n    if (t === '-' || t === '4') {\n      result += t;\n      continue;\n    }\n\n    if (t === 'y') {\n      result += randomString(1, '89ab');\n      continue;\n    }\n\n    result += randomString(1, STRING_HEXADECIMALS);\n  }\n\n  return result;\n}\n\n/**\n * 将值转换为字符串，若值为 null 或 undefined 则返回空字符串\n * @param {unknown} value - 需要转换的值\n * @returns {string} 转换后的字符串结果\n */\nexport function stringify(value: unknown) {\n  return isNullish(value) ? '' : String(value);\n}\n"],"names":[],"mappings":"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"}

package/dist/time/from.d.ts

@@ -0,0 +1,14 @@
+import { TTimeDuration } from './to';
+/**
+ * 将时间持续时间字符串或对象转换为毫秒数
+ *
+ * @param duration - 可以是时间持续时间字符串（如 '1d2h'）或 TTimeDuration 对象
+ * @returns 计算得到的总毫秒数
+ */
+export declare function timeFrom(duration: string | TTimeDuration): number;
+/**
+ * 将时长字符串解析为时间对象
+ * @param duration - 时长字符串（例如 "1h30m"）
+ * @returns 包含解析后时间单位的对象（小时、分钟等）
+ */
+export declare function timeParse(duration: string): TTimeDuration;

package/dist/time/to.d.ts

@@ -0,0 +1,38 @@
+export type TTimeDuration = {
+    years: number;
+    months: number;
+    /** 天数 */
+    days: number;
+    /** 小时数 */
+    hours: number;
+    /** 分钟数 */
+    minutes: number;
+    /** 秒数 */
+    seconds: number;
+    /** 毫秒数 */
+    milliseconds: number;
+};
+/**
+ * 将时间毫秒数解析为以天为最大单位的绝对时间对象
+ * @param timeMs 时间毫秒数
+ * @returns 包含天/小时/分钟/秒/毫秒分解结果的对象
+ */
+export declare function timeToDays(timeMs: number): TTimeDuration;
+/**
+ * 将时间毫秒数解析为以小时为最大单位的绝对时间对象
+ * @param timeMs 时间毫秒数
+ * @returns 包含小时/分钟/秒/毫秒分解结果的对象
+ */
+export declare function timeToHours(timeMs: number): TTimeDuration;
+/**
+ * 将时间毫秒数解析为以分钟为最大单位的绝对时间对象
+ * @param timeMs 时间毫秒数
+ * @returns 包含分钟/秒/毫秒分解结果的对象
+ */
+export declare function timeToMinutes(timeMs: number): TTimeDuration;
+/**
+ * 将时间毫秒数解析为以秒为最大单位的绝对时间对象
+ * @param timeMs 时间毫秒数
+ * @returns 包含秒/毫秒分解结果的对象
+ */
+export declare function timeToSeconds(timeMs: number): TTimeDuration;

package/dist/time.cjs

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _const = require("./const.cjs");
+const type = require("./type.cjs");
+const rules = [
+  ["years", _const.DATE_YEAR_MS],
+  ["months", _const.DATE_MONTH_MS],
+  ["days", _const.DATE_DAY_MS],
+  ["hours", _const.DATE_HOUR_MS],
+  ["minutes", _const.DATE_MINUTE_MS],
+  ["seconds", _const.DATE_SECOND_MS]
+];
+function timeFrom(duration) {
+  const td = type.isString(duration) ? timeParse(duration) : duration;
+  return rules.reduce((acc, [key, time]) => acc + (td[key] || 0) * time, 0);
+}
+const durationMatchRules = [
+  [/(\d+)y/i, "years"],
+  [/(\d+)M/, "months"],
+  [/(\d+)d/i, "days"],
+  [/(\d+)h/i, "hours"],
+  [/(\d+)m/, "minutes"],
+  [/(\d+)s/, "seconds"]
+];
+function timeParse(duration) {
+  const result = {};
+  for (const [regex, key] of durationMatchRules) {
+    const match = duration.match(regex);
+    if (match) result[key] = Number(match[1]);
+    else result[key] = 0;
+  }
+  return result;
+}
+function _timeAbsolute(timeMs, maxPoint) {
+  const minPoint = "S";
+  const defines = [
+    ["D", "days", _const.DATE_DAY_MS],
+    ["h", "hours", _const.DATE_HOUR_MS],
+    ["m", "minutes", _const.DATE_MINUTE_MS],
+    ["s", "seconds", _const.DATE_SECOND_MS],
+    ["S", "milliseconds", 1]
+  ];
+  const minIndex = defines.findIndex((item) => item[0] === maxPoint);
+  const maxIndex = defines.findIndex((item) => item[0] === minPoint);
+  let timeMsFinal = timeMs;
+  const dao = {
+    years: 0,
+    months: 0,
+    days: 0,
+    hours: 0,
+    minutes: 0,
+    seconds: 0,
+    milliseconds: 0
+  };
+  for (let i = minIndex; i <= maxIndex; i++) {
+    const mode = defines[i];
+    const base = mode[2];
+    const value = Math.floor(timeMsFinal / base);
+    timeMsFinal = timeMsFinal - value * base;
+    dao[mode[1]] = value;
+  }
+  return dao;
+}
+function timeToDays(timeMs) {
+  return _timeAbsolute(timeMs, "D");
+}
+function timeToHours(timeMs) {
+  return _timeAbsolute(timeMs, "h");
+}
+function timeToMinutes(timeMs) {
+  return _timeAbsolute(timeMs, "m");
+}
+function timeToSeconds(timeMs) {
+  return _timeAbsolute(timeMs, "s");
+}
+exports.timeFrom = timeFrom;
+exports.timeParse = timeParse;
+exports.timeToDays = timeToDays;
+exports.timeToHours = timeToHours;
+exports.timeToMinutes = timeToMinutes;
+exports.timeToSeconds = timeToSeconds;
+//# sourceMappingURL=time.cjs.map

package/dist/time.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.cjs","sources":["../src/time/from.ts","../src/time/to.ts"],"sourcesContent":["// @rer https://day.js.org/docs/en/durations/creating\n\nimport { DATE_DAY_MS, DATE_HOUR_MS, DATE_MINUTE_MS, DATE_MONTH_MS, DATE_SECOND_MS, DATE_YEAR_MS } from '@/date';\nimport { isString } from '@/type';\nimport type { TTimeDuration } from './to';\n\n/**\n * 时间转换规则数组\n * @type {Array<[RegExp, (match: RegExpMatchArray) => number]>}\n * @property {RegExp} 0 - 匹配时间单位正则表达式\n * @property {function} 1 - 将匹配结果转换为毫秒数的函数\n */\nconst rules: [key: keyof TTimeDuration, time: number][] = [\n  ['years', DATE_YEAR_MS],\n  ['months', DATE_MONTH_MS],\n  ['days', DATE_DAY_MS],\n  ['hours', DATE_HOUR_MS],\n  ['minutes', DATE_MINUTE_MS],\n  ['seconds', DATE_SECOND_MS],\n];\n\n/**\n * 将时间持续时间字符串或对象转换为毫秒数\n *\n * @param duration - 可以是时间持续时间字符串（如 '1d2h'）或 TTimeDuration 对象\n * @returns 计算得到的总毫秒数\n */\nexport function timeFrom(duration: string | TTimeDuration) {\n  const td = isString(duration) ? timeParse(duration) : duration;\n  return rules.reduce((acc, [key, time]) => acc + (td[key] || 0) * time, 0);\n}\n\nconst durationMatchRules: [RegExp, key: keyof TTimeDuration][] = [\n  [/(\\d+)y/i, 'years'],\n  [/(\\d+)M/, 'months'],\n  [/(\\d+)d/i, 'days'],\n  [/(\\d+)h/i, 'hours'],\n  [/(\\d+)m/, 'minutes'],\n  [/(\\d+)s/, 'seconds'],\n];\n\n/**\n * 将时长字符串解析为时间对象\n * @param duration - 时长字符串（例如 \"1h30m\"）\n * @returns 包含解析后时间单位的对象（小时、分钟等）\n */\nexport function timeParse(duration: string) {\n  const result = {} as TTimeDuration;\n\n  for (const [regex, key] of durationMatchRules) {\n    const match = duration.match(regex);\n    if (match) result[key] = Number(match[1]);\n    else result[key] = 0;\n  }\n\n  return result;\n}\n","import { DATE_DAY_MS, DATE_HOUR_MS, DATE_MINUTE_MS, DATE_SECOND_MS } from '../date';\n\nexport type TTimeDuration = {\n  years: number;\n  months: number;\n  /** 天数 */\n  days: number;\n  /** 小时数 */\n  hours: number;\n  /** 分钟数 */\n  minutes: number;\n  /** 秒数 */\n  seconds: number;\n  /** 毫秒数 */\n  milliseconds: number;\n};\n\ntype _TTimeParsePoint = 'D' | 'h' | 'm' | 's' | 'S';\n\n/**\n * 解析时间毫秒数为绝对时间对象\n * @param timeMs 时间毫秒数\n * @param maxPoint 最大时间单位（决定分解的起始单位）\n * @returns 包含时间单位分解结果的对象\n * @example\n * ```typescript\n * // 默认以天为最大单位分解\n * timeInDay(123456789);\n * // { days: 1, hours: 10, minutes: 17, seconds: 36, milliseconds: 789 }\n *\n * // 指定最大单位为分钟，分解到分钟及以下单位\n * timeInMinute(123456789);\n * // { days: 0, hours: 0, minutes: 2057, seconds: 36, milliseconds: 789 }\n * ```\n */\nfunction _timeAbsolute(timeMs: number, maxPoint: _TTimeParsePoint): TTimeDuration {\n  const minPoint: _TTimeParsePoint = 'S';\n\n  const defines: [point: _TTimeParsePoint, key: keyof TTimeDuration, base: number][] = [\n    ['D', 'days', DATE_DAY_MS],\n    ['h', 'hours', DATE_HOUR_MS],\n    ['m', 'minutes', DATE_MINUTE_MS],\n    ['s', 'seconds', DATE_SECOND_MS],\n    ['S', 'milliseconds', 1],\n  ] as const;\n\n  const minIndex = defines.findIndex((item) => item[0] === maxPoint);\n  const maxIndex = defines.findIndex((item) => item[0] === minPoint);\n\n  let timeMsFinal = timeMs;\n  const dao: TTimeDuration = {\n    years: 0,\n    months: 0,\n    days: 0,\n    hours: 0,\n    minutes: 0,\n    seconds: 0,\n    milliseconds: 0,\n  };\n\n  for (let i = minIndex; i <= maxIndex; i++) {\n    const mode = defines[i];\n    const base = mode[2];\n    const value = Math.floor(timeMsFinal / base);\n    timeMsFinal = timeMsFinal - value * base;\n    dao[mode[1]] = value;\n  }\n\n  return dao;\n}\n\n/**\n * 将时间毫秒数解析为以天为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含天/小时/分钟/秒/毫秒分解结果的对象\n */\nexport function timeToDays(timeMs: number) {\n  return _timeAbsolute(timeMs, 'D');\n}\n\n/**\n * 将时间毫秒数解析为以小时为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含小时/分钟/秒/毫秒分解结果的对象\n */\nexport function timeToHours(timeMs: number) {\n  return _timeAbsolute(timeMs, 'h');\n}\n\n/**\n * 将时间毫秒数解析为以分钟为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含分钟/秒/毫秒分解结果的对象\n */\nexport function timeToMinutes(timeMs: number) {\n  return _timeAbsolute(timeMs, 'm');\n}\n\n/**\n * 将时间毫秒数解析为以秒为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含秒/毫秒分解结果的对象\n */\nexport function timeToSeconds(timeMs: number) {\n  return _timeAbsolute(timeMs, 's');\n}\n"],"names":["DATE_YEAR_MS","DATE_MONTH_MS","DATE_DAY_MS","DATE_HOUR_MS","DATE_MINUTE_MS","DATE_SECOND_MS","isString"],"mappings":";;;;AAYA,MAAM,QAAoD;AAAA,EACxD,CAAC,SAASA,OAAAA,YAAY;AAAA,EACtB,CAAC,UAAUC,OAAAA,aAAa;AAAA,EACxB,CAAC,QAAQC,OAAAA,WAAW;AAAA,EACpB,CAAC,SAASC,OAAAA,YAAY;AAAA,EACtB,CAAC,WAAWC,OAAAA,cAAc;AAAA,EAC1B,CAAC,WAAWC,OAAc,cAAA;AAC5B;AAQO,SAAS,SAAS,UAAkC;AACzD,QAAM,KAAKC,KAAAA,SAAS,QAAQ,IAAI,UAAU,QAAQ,IAAI;AACtD,SAAO,MAAM,OAAO,CAAC,KAAK,CAAC,KAAK,IAAI,MAAM,OAAO,GAAG,GAAG,KAAK,KAAK,MAAM,CAAC;AAC1E;AAEA,MAAM,qBAA2D;AAAA,EAC/D,CAAC,WAAW,OAAO;AAAA,EACnB,CAAC,UAAU,QAAQ;AAAA,EACnB,CAAC,WAAW,MAAM;AAAA,EAClB,CAAC,WAAW,OAAO;AAAA,EACnB,CAAC,UAAU,SAAS;AAAA,EACpB,CAAC,UAAU,SAAS;AACtB;AAOO,SAAS,UAAU,UAAkB;AAC1C,QAAM,SAAS,CAAC;AAEhB,aAAW,CAAC,OAAO,GAAG,KAAK,oBAAoB;AACvC,UAAA,QAAQ,SAAS,MAAM,KAAK;AAClC,QAAI,MAAc,QAAA,GAAG,IAAI,OAAO,MAAM,CAAC,CAAC;AAAA,QACnC,QAAO,GAAG,IAAI;AAAA,EAAA;AAGd,SAAA;AACT;ACrBA,SAAS,cAAc,QAAgB,UAA2C;AAChF,QAAM,WAA6B;AAEnC,QAAM,UAA+E;AAAA,IACnF,CAAC,KAAK,QAAQJ,kBAAW;AAAA,IACzB,CAAC,KAAK,SAASC,mBAAY;AAAA,IAC3B,CAAC,KAAK,WAAWC,qBAAc;AAAA,IAC/B,CAAC,KAAK,WAAWC,qBAAc;AAAA,IAC/B,CAAC,KAAK,gBAAgB,CAAC;AAAA,EACzB;AAEM,QAAA,WAAW,QAAQ,UAAU,CAAC,SAAS,KAAK,CAAC,MAAM,QAAQ;AAC3D,QAAA,WAAW,QAAQ,UAAU,CAAC,SAAS,KAAK,CAAC,MAAM,QAAQ;AAEjE,MAAI,cAAc;AAClB,QAAM,MAAqB;AAAA,IACzB,OAAO;AAAA,IACP,QAAQ;AAAA,IACR,MAAM;AAAA,IACN,OAAO;AAAA,IACP,SAAS;AAAA,IACT,SAAS;AAAA,IACT,cAAc;AAAA,EAChB;AAEA,WAAS,IAAI,UAAU,KAAK,UAAU,KAAK;AACnC,UAAA,OAAO,QAAQ,CAAC;AAChB,UAAA,OAAO,KAAK,CAAC;AACnB,UAAM,QAAQ,KAAK,MAAM,cAAc,IAAI;AAC3C,kBAAc,cAAc,QAAQ;AAChC,QAAA,KAAK,CAAC,CAAC,IAAI;AAAA,EAAA;AAGV,SAAA;AACT;AAOO,SAAS,WAAW,QAAgB;AAClC,SAAA,cAAc,QAAQ,GAAG;AAClC;AAOO,SAAS,YAAY,QAAgB;AACnC,SAAA,cAAc,QAAQ,GAAG;AAClC;AAOO,SAAS,cAAc,QAAgB;AACrC,SAAA,cAAc,QAAQ,GAAG;AAClC;AAOO,SAAS,cAAc,QAAgB;AACrC,SAAA,cAAc,QAAQ,GAAG;AAClC;;;;;;;"}

package/dist/time.mjs

@@ -0,0 +1,82 @@
+import { D as DATE_YEAR_MS, a as DATE_MONTH_MS, b as DATE_DAY_MS, c as DATE_HOUR_MS, d as DATE_MINUTE_MS, e as DATE_SECOND_MS } from "./const.mjs";
+import { isString } from "./type.mjs";
+const rules = [
+  ["years", DATE_YEAR_MS],
+  ["months", DATE_MONTH_MS],
+  ["days", DATE_DAY_MS],
+  ["hours", DATE_HOUR_MS],
+  ["minutes", DATE_MINUTE_MS],
+  ["seconds", DATE_SECOND_MS]
+];
+function timeFrom(duration) {
+  const td = isString(duration) ? timeParse(duration) : duration;
+  return rules.reduce((acc, [key, time]) => acc + (td[key] || 0) * time, 0);
+}
+const durationMatchRules = [
+  [/(\d+)y/i, "years"],
+  [/(\d+)M/, "months"],
+  [/(\d+)d/i, "days"],
+  [/(\d+)h/i, "hours"],
+  [/(\d+)m/, "minutes"],
+  [/(\d+)s/, "seconds"]
+];
+function timeParse(duration) {
+  const result = {};
+  for (const [regex, key] of durationMatchRules) {
+    const match = duration.match(regex);
+    if (match) result[key] = Number(match[1]);
+    else result[key] = 0;
+  }
+  return result;
+}
+function _timeAbsolute(timeMs, maxPoint) {
+  const minPoint = "S";
+  const defines = [
+    ["D", "days", DATE_DAY_MS],
+    ["h", "hours", DATE_HOUR_MS],
+    ["m", "minutes", DATE_MINUTE_MS],
+    ["s", "seconds", DATE_SECOND_MS],
+    ["S", "milliseconds", 1]
+  ];
+  const minIndex = defines.findIndex((item) => item[0] === maxPoint);
+  const maxIndex = defines.findIndex((item) => item[0] === minPoint);
+  let timeMsFinal = timeMs;
+  const dao = {
+    years: 0,
+    months: 0,
+    days: 0,
+    hours: 0,
+    minutes: 0,
+    seconds: 0,
+    milliseconds: 0
+  };
+  for (let i = minIndex; i <= maxIndex; i++) {
+    const mode = defines[i];
+    const base = mode[2];
+    const value = Math.floor(timeMsFinal / base);
+    timeMsFinal = timeMsFinal - value * base;
+    dao[mode[1]] = value;
+  }
+  return dao;
+}
+function timeToDays(timeMs) {
+  return _timeAbsolute(timeMs, "D");
+}
+function timeToHours(timeMs) {
+  return _timeAbsolute(timeMs, "h");
+}
+function timeToMinutes(timeMs) {
+  return _timeAbsolute(timeMs, "m");
+}
+function timeToSeconds(timeMs) {
+  return _timeAbsolute(timeMs, "s");
+}
+export {
+  timeFrom,
+  timeParse,
+  timeToDays,
+  timeToHours,
+  timeToMinutes,
+  timeToSeconds
+};
+//# sourceMappingURL=time.mjs.map

package/dist/time.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.mjs","sources":["../src/time/from.ts","../src/time/to.ts"],"sourcesContent":["// @rer https://day.js.org/docs/en/durations/creating\n\nimport { DATE_DAY_MS, DATE_HOUR_MS, DATE_MINUTE_MS, DATE_MONTH_MS, DATE_SECOND_MS, DATE_YEAR_MS } from '@/date';\nimport { isString } from '@/type';\nimport type { TTimeDuration } from './to';\n\n/**\n * 时间转换规则数组\n * @type {Array<[RegExp, (match: RegExpMatchArray) => number]>}\n * @property {RegExp} 0 - 匹配时间单位正则表达式\n * @property {function} 1 - 将匹配结果转换为毫秒数的函数\n */\nconst rules: [key: keyof TTimeDuration, time: number][] = [\n  ['years', DATE_YEAR_MS],\n  ['months', DATE_MONTH_MS],\n  ['days', DATE_DAY_MS],\n  ['hours', DATE_HOUR_MS],\n  ['minutes', DATE_MINUTE_MS],\n  ['seconds', DATE_SECOND_MS],\n];\n\n/**\n * 将时间持续时间字符串或对象转换为毫秒数\n *\n * @param duration - 可以是时间持续时间字符串（如 '1d2h'）或 TTimeDuration 对象\n * @returns 计算得到的总毫秒数\n */\nexport function timeFrom(duration: string | TTimeDuration) {\n  const td = isString(duration) ? timeParse(duration) : duration;\n  return rules.reduce((acc, [key, time]) => acc + (td[key] || 0) * time, 0);\n}\n\nconst durationMatchRules: [RegExp, key: keyof TTimeDuration][] = [\n  [/(\\d+)y/i, 'years'],\n  [/(\\d+)M/, 'months'],\n  [/(\\d+)d/i, 'days'],\n  [/(\\d+)h/i, 'hours'],\n  [/(\\d+)m/, 'minutes'],\n  [/(\\d+)s/, 'seconds'],\n];\n\n/**\n * 将时长字符串解析为时间对象\n * @param duration - 时长字符串（例如 \"1h30m\"）\n * @returns 包含解析后时间单位的对象（小时、分钟等）\n */\nexport function timeParse(duration: string) {\n  const result = {} as TTimeDuration;\n\n  for (const [regex, key] of durationMatchRules) {\n    const match = duration.match(regex);\n    if (match) result[key] = Number(match[1]);\n    else result[key] = 0;\n  }\n\n  return result;\n}\n","import { DATE_DAY_MS, DATE_HOUR_MS, DATE_MINUTE_MS, DATE_SECOND_MS } from '../date';\n\nexport type TTimeDuration = {\n  years: number;\n  months: number;\n  /** 天数 */\n  days: number;\n  /** 小时数 */\n  hours: number;\n  /** 分钟数 */\n  minutes: number;\n  /** 秒数 */\n  seconds: number;\n  /** 毫秒数 */\n  milliseconds: number;\n};\n\ntype _TTimeParsePoint = 'D' | 'h' | 'm' | 's' | 'S';\n\n/**\n * 解析时间毫秒数为绝对时间对象\n * @param timeMs 时间毫秒数\n * @param maxPoint 最大时间单位（决定分解的起始单位）\n * @returns 包含时间单位分解结果的对象\n * @example\n * ```typescript\n * // 默认以天为最大单位分解\n * timeInDay(123456789);\n * // { days: 1, hours: 10, minutes: 17, seconds: 36, milliseconds: 789 }\n *\n * // 指定最大单位为分钟，分解到分钟及以下单位\n * timeInMinute(123456789);\n * // { days: 0, hours: 0, minutes: 2057, seconds: 36, milliseconds: 789 }\n * ```\n */\nfunction _timeAbsolute(timeMs: number, maxPoint: _TTimeParsePoint): TTimeDuration {\n  const minPoint: _TTimeParsePoint = 'S';\n\n  const defines: [point: _TTimeParsePoint, key: keyof TTimeDuration, base: number][] = [\n    ['D', 'days', DATE_DAY_MS],\n    ['h', 'hours', DATE_HOUR_MS],\n    ['m', 'minutes', DATE_MINUTE_MS],\n    ['s', 'seconds', DATE_SECOND_MS],\n    ['S', 'milliseconds', 1],\n  ] as const;\n\n  const minIndex = defines.findIndex((item) => item[0] === maxPoint);\n  const maxIndex = defines.findIndex((item) => item[0] === minPoint);\n\n  let timeMsFinal = timeMs;\n  const dao: TTimeDuration = {\n    years: 0,\n    months: 0,\n    days: 0,\n    hours: 0,\n    minutes: 0,\n    seconds: 0,\n    milliseconds: 0,\n  };\n\n  for (let i = minIndex; i <= maxIndex; i++) {\n    const mode = defines[i];\n    const base = mode[2];\n    const value = Math.floor(timeMsFinal / base);\n    timeMsFinal = timeMsFinal - value * base;\n    dao[mode[1]] = value;\n  }\n\n  return dao;\n}\n\n/**\n * 将时间毫秒数解析为以天为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含天/小时/分钟/秒/毫秒分解结果的对象\n */\nexport function timeToDays(timeMs: number) {\n  return _timeAbsolute(timeMs, 'D');\n}\n\n/**\n * 将时间毫秒数解析为以小时为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含小时/分钟/秒/毫秒分解结果的对象\n */\nexport function timeToHours(timeMs: number) {\n  return _timeAbsolute(timeMs, 'h');\n}\n\n/**\n * 将时间毫秒数解析为以分钟为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含分钟/秒/毫秒分解结果的对象\n */\nexport function timeToMinutes(timeMs: number) {\n  return _timeAbsolute(timeMs, 'm');\n}\n\n/**\n * 将时间毫秒数解析为以秒为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含秒/毫秒分解结果的对象\n */\nexport function timeToSeconds(timeMs: number) {\n  return _timeAbsolute(timeMs, 's');\n}\n"],"names":[],"mappings":";;AAYA,MAAM,QAAoD;AAAA,EACxD,CAAC,SAAS,YAAY;AAAA,EACtB,CAAC,UAAU,aAAa;AAAA,EACxB,CAAC,QAAQ,WAAW;AAAA,EACpB,CAAC,SAAS,YAAY;AAAA,EACtB,CAAC,WAAW,cAAc;AAAA,EAC1B,CAAC,WAAW,cAAc;AAC5B;AAQO,SAAS,SAAS,UAAkC;AACzD,QAAM,KAAK,SAAS,QAAQ,IAAI,UAAU,QAAQ,IAAI;AACtD,SAAO,MAAM,OAAO,CAAC,KAAK,CAAC,KAAK,IAAI,MAAM,OAAO,GAAG,GAAG,KAAK,KAAK,MAAM,CAAC;AAC1E;AAEA,MAAM,qBAA2D;AAAA,EAC/D,CAAC,WAAW,OAAO;AAAA,EACnB,CAAC,UAAU,QAAQ;AAAA,EACnB,CAAC,WAAW,MAAM;AAAA,EAClB,CAAC,WAAW,OAAO;AAAA,EACnB,CAAC,UAAU,SAAS;AAAA,EACpB,CAAC,UAAU,SAAS;AACtB;AAOO,SAAS,UAAU,UAAkB;AAC1C,QAAM,SAAS,CAAC;AAEhB,aAAW,CAAC,OAAO,GAAG,KAAK,oBAAoB;AACvC,UAAA,QAAQ,SAAS,MAAM,KAAK;AAClC,QAAI,MAAc,QAAA,GAAG,IAAI,OAAO,MAAM,CAAC,CAAC;AAAA,QACnC,QAAO,GAAG,IAAI;AAAA,EAAA;AAGd,SAAA;AACT;ACrBA,SAAS,cAAc,QAAgB,UAA2C;AAChF,QAAM,WAA6B;AAEnC,QAAM,UAA+E;AAAA,IACnF,CAAC,KAAK,QAAQ,WAAW;AAAA,IACzB,CAAC,KAAK,SAAS,YAAY;AAAA,IAC3B,CAAC,KAAK,WAAW,cAAc;AAAA,IAC/B,CAAC,KAAK,WAAW,cAAc;AAAA,IAC/B,CAAC,KAAK,gBAAgB,CAAC;AAAA,EACzB;AAEM,QAAA,WAAW,QAAQ,UAAU,CAAC,SAAS,KAAK,CAAC,MAAM,QAAQ;AAC3D,QAAA,WAAW,QAAQ,UAAU,CAAC,SAAS,KAAK,CAAC,MAAM,QAAQ;AAEjE,MAAI,cAAc;AAClB,QAAM,MAAqB;AAAA,IACzB,OAAO;AAAA,IACP,QAAQ;AAAA,IACR,MAAM;AAAA,IACN,OAAO;AAAA,IACP,SAAS;AAAA,IACT,SAAS;AAAA,IACT,cAAc;AAAA,EAChB;AAEA,WAAS,IAAI,UAAU,KAAK,UAAU,KAAK;AACnC,UAAA,OAAO,QAAQ,CAAC;AAChB,UAAA,OAAO,KAAK,CAAC;AACnB,UAAM,QAAQ,KAAK,MAAM,cAAc,IAAI;AAC3C,kBAAc,cAAc,QAAQ;AAChC,QAAA,KAAK,CAAC,CAAC,IAAI;AAAA,EAAA;AAGV,SAAA;AACT;AAOO,SAAS,WAAW,QAAgB;AAClC,SAAA,cAAc,QAAQ,GAAG;AAClC;AAOO,SAAS,YAAY,QAAgB;AACnC,SAAA,cAAc,QAAQ,GAAG;AAClC;AAOO,SAAS,cAAc,QAAgB;AACrC,SAAA,cAAc,QAAQ,GAAG;AAClC;AAOO,SAAS,cAAc,QAAgB;AACrC,SAAA,cAAc,QAAQ,GAAG;AAClC;"}