@cloudcome/utils-core 1.19.1 → 1.20.1

package/dist/env.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"env.mjs","sources":["../src/env.ts"],"sourcesContent":["import { isNullish } from './type';\n\n/**\n * 判断当前环境是否为浏览器环境\n * @returns 如果是浏览器环境返回 true，否则返回 false\n */\nexport function isBrowser() {\n  if (IS_TEST) return TEST_MOCK.IS_BROWSER || false;\n\n  return typeof window !== 'undefined' && typeof document !== 'undefined';\n}\n\n/**\n * 判断当前环境是否为 Node.js 环境\n * @returns 如果是 Node.js 环境返回 true，否则返回 false\n */\nexport function isNode() {\n  if (IS_TEST) return TEST_MOCK.IS_NODE || false;\n\n  return typeof process !== 'undefined' && !isNullish(process.versions) && !isNullish(process.versions.node);\n}\n\n/**\n * 判断当前环境是否为 Web Worker 环境\n * @returns 如果是 Web Worker 环境返回 true，否则返回 false\n * @remarks\n * 使用 @ts-ignore 忽略 self 的类型检查，因为 self 在 Web Worker 中可用但在其他环境中可能未定义\n */\nexport function isWorker() {\n  // @ts-ignore\n  return typeof self !== 'undefined' && self.importScripts != null;\n}\n\n/**\n * 判断当前操作系统是否为 macOS\n * @returns 如果是 macOS 返回 true，否则返回 false\n * @remarks\n * 在浏览器环境中通过 navigator.platform 检测，在 Node.js 环境中通过 process.platform 检测\n */\nexport function isMacOS() {\n  return isBrowser() ? /^mac/i.test(navigator.platform) : isNode() ? /^darwin/i.test(process.platform) : false;\n}\n\n/**\n * 判断当前操作系统是否为 Linux\n * @returns 如果是 Linux 返回 true，否则返回 false\n * @remarks\n * 在浏览器环境中通过 navigator.platform 检测，在 Node.js 环境中通过 process.platform 检测\n */\nexport function isLinux() {\n  return isBrowser() ? /^linux/i.test(navigator.platform) : isNode() ? /^linux/i.test(process.platform) : false;\n}\n\n/**\n * 判断当前操作系统是否为 Windows\n * @returns 如果是 Windows 返回 true，否则返回 false\n * @remarks\n * 在浏览器环境中通过 navigator.platform 检测，在 Node.js 环境中通过 process.platform 检测\n */\nexport function isWindows() {\n  return isBrowser() ? /^win/i.test(navigator.platform) : isNode() ? /^win/i.test(process.platform) : false;\n}\n"],"names":[],"mappings":";AAMO,SAAS,YAAY;AAG1B,SAAO,OAAO,WAAW,eAAe,OAAO,aAAa;AAC9D;AAMO,SAAS,SAAS;AAGvB,SAAO,OAAO,YAAY,eAAe,CAAC,UAAU,QAAQ,QAAQ,KAAK,CAAC,UAAU,QAAQ,SAAS,IAAI;AAC3G;AAQO,SAAS,WAAW;AAEzB,SAAO,OAAO,SAAS,eAAe,KAAK,iBAAiB;AAC9D;AAQO,SAAS,UAAU;AACxB,SAAO,UAAU,IAAI,QAAQ,KAAK,UAAU,QAAQ,IAAI,OAAA,IAAW,WAAW,KAAK,QAAQ,QAAQ,IAAI;AACzG;AAQO,SAAS,UAAU;AACxB,SAAO,UAAU,IAAI,UAAU,KAAK,UAAU,QAAQ,IAAI,OAAA,IAAW,UAAU,KAAK,QAAQ,QAAQ,IAAI;AAC1G;AAQO,SAAS,YAAY;AAC1B,SAAO,UAAU,IAAI,QAAQ,KAAK,UAAU,QAAQ,IAAI,OAAA,IAAW,QAAQ,KAAK,QAAQ,QAAQ,IAAI;AACtG;"}
+{"version":3,"file":"env.mjs","names":[],"sources":["../src/env.ts"],"sourcesContent":["import { isNullish } from './type';\n\n/**\n * 判断当前环境是否为浏览器环境\n * @returns 如果是浏览器环境返回 true，否则返回 false\n */\nexport function isBrowser() {\n  if (IS_TEST) return TEST_MOCK.IS_BROWSER || false;\n\n  return typeof window !== 'undefined' && typeof document !== 'undefined';\n}\n\n/**\n * 判断当前环境是否为 Node.js 环境\n * @returns 如果是 Node.js 环境返回 true，否则返回 false\n */\nexport function isNode() {\n  if (IS_TEST) return TEST_MOCK.IS_NODE || false;\n\n  return typeof process !== 'undefined' && !isNullish(process.versions) && !isNullish(process.versions.node);\n}\n\n/**\n * 判断当前环境是否为 Web Worker 环境\n * @returns 如果是 Web Worker 环境返回 true，否则返回 false\n * @remarks\n * 使用 @ts-expect-error 忽略 self 的类型检查，因为 self 在 Web Worker 中可用但在其他环境中可能未定义\n */\nexport function isWorker() {\n  // @ts-expect-error\n  return typeof self !== 'undefined' && self.importScripts != null;\n}\n\n/**\n * 判断当前操作系统是否为 macOS\n * @returns 如果是 macOS 返回 true，否则返回 false\n * @remarks\n * 在浏览器环境中通过 navigator.platform 检测，在 Node.js 环境中通过 process.platform 检测\n */\nexport function isMacOS() {\n  return isBrowser() ? /^mac/i.test(navigator.platform) : isNode() ? /^darwin/i.test(process.platform) : false;\n}\n\n/**\n * 判断当前操作系统是否为 Linux\n * @returns 如果是 Linux 返回 true，否则返回 false\n * @remarks\n * 在浏览器环境中通过 navigator.platform 检测，在 Node.js 环境中通过 process.platform 检测\n */\nexport function isLinux() {\n  return isBrowser() ? /^linux/i.test(navigator.platform) : isNode() ? /^linux/i.test(process.platform) : false;\n}\n\n/**\n * 判断当前操作系统是否为 Windows\n * @returns 如果是 Windows 返回 true，否则返回 false\n * @remarks\n * 在浏览器环境中通过 navigator.platform 检测，在 Node.js 环境中通过 process.platform 检测\n */\nexport function isWindows() {\n  return isBrowser() ? /^win/i.test(navigator.platform) : isNode() ? /^win/i.test(process.platform) : false;\n}\n"],"mappings":";;;;;;AAMA,SAAgB,YAAY;CAG1B,OAAO,OAAO,WAAW,eAAe,OAAO,aAAa;;;;;;AAO9D,SAAgB,SAAS;CAGvB,OAAO,OAAO,YAAY,eAAe,CAAC,UAAU,QAAQ,SAAS,IAAI,CAAC,UAAU,QAAQ,SAAS,KAAK;;;;;;;;AAS5G,SAAgB,WAAW;CAEzB,OAAO,OAAO,SAAS,eAAe,KAAK,iBAAiB;;;;;;;;AAS9D,SAAgB,UAAU;CACxB,OAAO,WAAW,GAAG,QAAQ,KAAK,UAAU,SAAS,GAAG,QAAQ,GAAG,WAAW,KAAK,QAAQ,SAAS,GAAG;;;;;;;;AASzG,SAAgB,UAAU;CACxB,OAAO,WAAW,GAAG,UAAU,KAAK,UAAU,SAAS,GAAG,QAAQ,GAAG,UAAU,KAAK,QAAQ,SAAS,GAAG;;;;;;;;AAS1G,SAAgB,YAAY;CAC1B,OAAO,WAAW,GAAG,QAAQ,KAAK,UAAU,SAAS,GAAG,QAAQ,GAAG,QAAQ,KAAK,QAAQ,SAAS,GAAG"}

package/dist/error.cjs

@@ -1,12 +1,33 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const type = require("./type.cjs");
+const require_type = require("./type.cjs");
+//#region src/error.ts
+/**
+* 标准化处理 Error 对象，适用于 try-catch
+* @param throwError 接收抛出的错误字符串或者 Error 对象或字符串
+* @returns {Error}
+* @example
+* const error = errorNormalize('这是一个错误');
+* console.log(error.message); // 输出: 这是一个错误
+*/
 function errorNormalize(throwError) {
-  return type.isError(throwError) ? throwError : new Error(String(type.isNullish(throwError) ? "" : throwError));
+	return require_type.isError(throwError) ? throwError : new Error(String(require_type.isNullish(throwError) ? "" : throwError));
 }
+/**
+* 分配对象到 Error 对象上，适用于扩展 Error 实例，不影响原型和构造函数
+* @param {Error} error
+* @param {E} source
+* @returns {Error & E}
+* @example
+* const error = new Error('原始错误');
+* const extendedError = errorAssign(error, { code: 404, message: '未找到资源' });
+* console.log(extendedError.code); // 输出: 404
+* console.log(extendedError.message); // 输出: 未找到资源
+*/
 function errorAssign(error, source) {
-  return Object.assign(error, source);
+	return Object.assign(error, source);
 }
+//#endregion
 exports.errorAssign = errorAssign;
 exports.errorNormalize = errorNormalize;
-//# sourceMappingURL=error.cjs.map
+
+//# sourceMappingURL=error.cjs.map

package/dist/error.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"error.cjs","sources":["../src/error.ts"],"sourcesContent":["import { isError, isNullish } from './type';\nimport type { AnyObject } from './types';\n\n/**\n * 标准化处理 Error 对象，适用于 try-catch\n * @param throwError 接收抛出的错误字符串或者 Error 对象或字符串\n * @returns {Error}\n * @example\n * const error = errorNormalize('这是一个错误');\n * console.log(error.message); // 输出: 这是一个错误\n */\nexport function errorNormalize<E extends Error | unknown = unknown>(throwError: E) {\n  return (\n    isError(throwError) ? throwError : new Error(String(isNullish(throwError) ? '' : throwError))\n  ) as E extends Error ? E : Error;\n}\n\n/**\n * 分配对象到 Error 对象上，适用于扩展 Error 实例，不影响原型和构造函数\n * @param {Error} error\n * @param {E} source\n * @returns {Error & E}\n * @example\n * const error = new Error('原始错误');\n * const extendedError = errorAssign(error, { code: 404, message: '未找到资源' });\n * console.log(extendedError.code); // 输出: 404\n * console.log(extendedError.message); // 输出: 未找到资源\n */\nexport function errorAssign<E extends AnyObject>(error: Error, source: E): Error & E {\n  return Object.assign(error, source) as Error & E;\n}\n"],"names":["isError","isNullish"],"mappings":";;;AAWO,SAAS,eAAoD,YAAe;AACjF,SACEA,aAAQ,UAAU,IAAI,aAAa,IAAI,MAAM,OAAOC,KAAAA,UAAU,UAAU,IAAI,KAAK,UAAU,CAAC;AAEhG;AAagB,SAAA,YAAiC,OAAc,QAAsB;AAC5E,SAAA,OAAO,OAAO,OAAO,MAAM;AACpC;;;"}
+{"version":3,"file":"error.cjs","names":[],"sources":["../src/error.ts"],"sourcesContent":["import { isError, isNullish } from './type';\nimport type { AnyObject } from './types';\n\n/**\n * 标准化处理 Error 对象，适用于 try-catch\n * @param throwError 接收抛出的错误字符串或者 Error 对象或字符串\n * @returns {Error}\n * @example\n * const error = errorNormalize('这是一个错误');\n * console.log(error.message); // 输出: 这是一个错误\n */\nexport function errorNormalize<E extends Error | unknown = unknown>(throwError: E) {\n  return (\n    isError(throwError) ? throwError : new Error(String(isNullish(throwError) ? '' : throwError))\n  ) as E extends Error ? E : Error;\n}\n\n/**\n * 分配对象到 Error 对象上，适用于扩展 Error 实例，不影响原型和构造函数\n * @param {Error} error\n * @param {E} source\n * @returns {Error & E}\n * @example\n * const error = new Error('原始错误');\n * const extendedError = errorAssign(error, { code: 404, message: '未找到资源' });\n * console.log(extendedError.code); // 输出: 404\n * console.log(extendedError.message); // 输出: 未找到资源\n */\nexport function errorAssign<E extends AnyObject>(error: Error, source: E): Error & E {\n  return Object.assign(error, source) as Error & E;\n}\n"],"mappings":";;;;;;;;;;;AAWA,SAAgB,eAAoD,YAAe;CACjF,OACE,aAAA,QAAQ,WAAW,GAAG,aAAa,IAAI,MAAM,OAAO,aAAA,UAAU,WAAW,GAAG,KAAK,WAAW,CAAC;;;;;;;;;;;;;AAejG,SAAgB,YAAiC,OAAc,QAAsB;CACnF,OAAO,OAAO,OAAO,OAAO,OAAO"}

package/dist/error.mjs

@@ -1,12 +1,31 @@
 import { isError, isNullish } from "./type.mjs";
+//#region src/error.ts
+/**
+* 标准化处理 Error 对象，适用于 try-catch
+* @param throwError 接收抛出的错误字符串或者 Error 对象或字符串
+* @returns {Error}
+* @example
+* const error = errorNormalize('这是一个错误');
+* console.log(error.message); // 输出: 这是一个错误
+*/
 function errorNormalize(throwError) {
-  return isError(throwError) ? throwError : new Error(String(isNullish(throwError) ? "" : throwError));
+	return isError(throwError) ? throwError : new Error(String(isNullish(throwError) ? "" : throwError));
 }
+/**
+* 分配对象到 Error 对象上，适用于扩展 Error 实例，不影响原型和构造函数
+* @param {Error} error
+* @param {E} source
+* @returns {Error & E}
+* @example
+* const error = new Error('原始错误');
+* const extendedError = errorAssign(error, { code: 404, message: '未找到资源' });
+* console.log(extendedError.code); // 输出: 404
+* console.log(extendedError.message); // 输出: 未找到资源
+*/
 function errorAssign(error, source) {
-  return Object.assign(error, source);
+	return Object.assign(error, source);
 }
-export {
-  errorAssign,
-  errorNormalize
-};
-//# sourceMappingURL=error.mjs.map
+//#endregion
+export { errorAssign, errorNormalize };
+
+//# sourceMappingURL=error.mjs.map

package/dist/error.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"error.mjs","sources":["../src/error.ts"],"sourcesContent":["import { isError, isNullish } from './type';\nimport type { AnyObject } from './types';\n\n/**\n * 标准化处理 Error 对象，适用于 try-catch\n * @param throwError 接收抛出的错误字符串或者 Error 对象或字符串\n * @returns {Error}\n * @example\n * const error = errorNormalize('这是一个错误');\n * console.log(error.message); // 输出: 这是一个错误\n */\nexport function errorNormalize<E extends Error | unknown = unknown>(throwError: E) {\n  return (\n    isError(throwError) ? throwError : new Error(String(isNullish(throwError) ? '' : throwError))\n  ) as E extends Error ? E : Error;\n}\n\n/**\n * 分配对象到 Error 对象上，适用于扩展 Error 实例，不影响原型和构造函数\n * @param {Error} error\n * @param {E} source\n * @returns {Error & E}\n * @example\n * const error = new Error('原始错误');\n * const extendedError = errorAssign(error, { code: 404, message: '未找到资源' });\n * console.log(extendedError.code); // 输出: 404\n * console.log(extendedError.message); // 输出: 未找到资源\n */\nexport function errorAssign<E extends AnyObject>(error: Error, source: E): Error & E {\n  return Object.assign(error, source) as Error & E;\n}\n"],"names":[],"mappings":";AAWO,SAAS,eAAoD,YAAe;AACjF,SACE,QAAQ,UAAU,IAAI,aAAa,IAAI,MAAM,OAAO,UAAU,UAAU,IAAI,KAAK,UAAU,CAAC;AAEhG;AAagB,SAAA,YAAiC,OAAc,QAAsB;AAC5E,SAAA,OAAO,OAAO,OAAO,MAAM;AACpC;"}
+{"version":3,"file":"error.mjs","names":[],"sources":["../src/error.ts"],"sourcesContent":["import { isError, isNullish } from './type';\nimport type { AnyObject } from './types';\n\n/**\n * 标准化处理 Error 对象，适用于 try-catch\n * @param throwError 接收抛出的错误字符串或者 Error 对象或字符串\n * @returns {Error}\n * @example\n * const error = errorNormalize('这是一个错误');\n * console.log(error.message); // 输出: 这是一个错误\n */\nexport function errorNormalize<E extends Error | unknown = unknown>(throwError: E) {\n  return (\n    isError(throwError) ? throwError : new Error(String(isNullish(throwError) ? '' : throwError))\n  ) as E extends Error ? E : Error;\n}\n\n/**\n * 分配对象到 Error 对象上，适用于扩展 Error 实例，不影响原型和构造函数\n * @param {Error} error\n * @param {E} source\n * @returns {Error & E}\n * @example\n * const error = new Error('原始错误');\n * const extendedError = errorAssign(error, { code: 404, message: '未找到资源' });\n * console.log(extendedError.code); // 输出: 404\n * console.log(extendedError.message); // 输出: 未找到资源\n */\nexport function errorAssign<E extends AnyObject>(error: Error, source: E): Error & E {\n  return Object.assign(error, source) as Error & E;\n}\n"],"mappings":";;;;;;;;;;AAWA,SAAgB,eAAoD,YAAe;CACjF,OACE,QAAQ,WAAW,GAAG,aAAa,IAAI,MAAM,OAAO,UAAU,WAAW,GAAG,KAAK,WAAW,CAAC;;;;;;;;;;;;;AAejG,SAAgB,YAAiC,OAAc,QAAsB;CACnF,OAAO,OAAO,OAAO,OAAO,OAAO"}

package/dist/exception.cjs

@@ -1,22 +1,40 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const merge = require("./merge.cjs");
-const defaults = {
-  /**
-   * 默认消息格式函数
-   * @default (name, message) => `[${name}] ${message}`
-   */
-  format: (name, message) => `[${name}] ${message}`
-};
-function buildException(name, options) {
-  const { format } = merge.objectDefaults(options || {}, defaults);
-  return class extends Error {
-    constructor(message, extra) {
-      super(format(name, message));
-      this.name = name;
-      Object.assign(this, extra);
-    }
-  };
+const require_object = require("./object.cjs");
+//#region src/exception.ts
+/**
+* 默认的异常构建选项
+*/
+var defaults = { 
+/**
+* 默认消息格式函数
+* @default (name, message) => `[${name}] ${message}`
+*/
+format: (name, message) => `[${name}] ${message}` };
+/**
+* 自定义异常类
+* @template T 额外属性的类型
+* @param name 异常类名称
+* @param options 构建选项
+* @returns 自定义异常类
+* @example
+* const MyException = defineException<{ code: number }>('MyException');
+* const err = new MyException('error', { code: 404 });
+*
+* @example
+* const SimpleException = defineException('SimpleException');
+* const err = new SimpleException('error', undefined);
+*/
+function defineException(name, options) {
+	const { format } = require_object.objectDefaults(options || {}, defaults);
+	return class extends Error {
+		constructor(message, extra) {
+			super(format(name, message));
+			this.name = name;
+			Object.assign(this, extra);
+		}
+	};
 }
-exports.buildException = buildException;
-//# sourceMappingURL=exception.cjs.map
+//#endregion
+exports.defineException = defineException;
+
+//# sourceMappingURL=exception.cjs.map

package/dist/exception.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"exception.cjs","sources":["../src/exception.ts"],"sourcesContent":["import { objectDefaults } from './object';\nimport type { AnyObject } from './types';\n\n/**\n * 构建异常选项\n */\nexport type BuildExceptionOptions = {\n  /**\n   * 自定义错误消息格式函数\n   * @param name 错误名称\n   * @param message 原始错误消息\n   * @returns 格式化后的错误消息\n   * @example\n   * (name, message) => `${name}::${message}`\n   */\n  format?: (name: string, message: string) => string;\n};\n\n/**\n * 默认的异常构建选项\n */\nconst defaults: BuildExceptionOptions = {\n  /**\n   * 默认消息格式函数\n   * @default (name, message) => `[${name}] ${message}`\n   */\n  format: (name, message) => `[${name}] ${message}`,\n};\n\n/**\n * 构建自定义异常类\n * @template T 额外属性的类型\n * @param name 异常类名称\n * @param options 构建选项\n * @returns 自定义异常类\n * @example\n * const MyException = buildException<{ code: number }>('MyException');\n * const err = new MyException('error', { code: 404 });\n *\n * @example\n * const SimpleException = buildException('SimpleException');\n * const err = new SimpleException('error', undefined);\n */\nexport function buildException<T = void>(name: string, options?: BuildExceptionOptions) {\n  const { format } = objectDefaults(options || {}, defaults) as Required<BuildExceptionOptions>;\n\n  return class extends Error {\n    constructor(message: string, extra: T) {\n      super(format(name, message));\n      this.name = name;\n      Object.assign(this, extra);\n    }\n  } as unknown as {\n    new (message: string, extra: T): Error & T;\n  };\n}\n\n// const MyException = buildException<{ foo: string; bar: number }>('MyException: ');\n// const myException = new MyException('bar', { foo: '1', bar: 1 });\n// myException.foo;\n// myException.bar;\n// myException.name;\n// myException.message;\n// myException.stack;\n// myException.cause;\n\n// const MyException2 = buildException('MyException2: ');\n// const myException2 = new MyException2('bar');\n"],"names":["objectDefaults"],"mappings":";;;AAqBA,MAAM,WAAkC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKtC,QAAQ,CAAC,MAAM,YAAY,IAAI,IAAI,KAAK,OAAO;AACjD;AAgBgB,SAAA,eAAyB,MAAc,SAAiC;AACtF,QAAM,EAAE,OAAO,IAAIA,MAAAA,eAAe,WAAW,CAAA,GAAI,QAAQ;AAEzD,SAAO,cAAc,MAAM;AAAA,IACzB,YAAY,SAAiB,OAAU;AAC/B,YAAA,OAAO,MAAM,OAAO,CAAC;AAC3B,WAAK,OAAO;AACL,aAAA,OAAO,MAAM,KAAK;AAAA,IAAA;AAAA,EAE7B;AAGF;;"}
+{"version":3,"file":"exception.cjs","names":[],"sources":["../src/exception.ts"],"sourcesContent":["import { objectDefaults } from './object';\n\n/**\n * 构建异常选项\n */\nexport type DefineExceptionOptions = {\n  /**\n   * 自定义错误消息格式函数\n   * @param name 错误名称\n   * @param message 原始错误消息\n   * @returns 格式化后的错误消息\n   * @example\n   * (name, message) => `${name}::${message}`\n   */\n  format?: (name: string, message: string) => string;\n};\n\n/**\n * 默认的异常构建选项\n */\nconst defaults: DefineExceptionOptions = {\n  /**\n   * 默认消息格式函数\n   * @default (name, message) => `[${name}] ${message}`\n   */\n  format: (name, message) => `[${name}] ${message}`,\n};\n\n/**\n * 自定义异常类\n * @template T 额外属性的类型\n * @param name 异常类名称\n * @param options 构建选项\n * @returns 自定义异常类\n * @example\n * const MyException = defineException<{ code: number }>('MyException');\n * const err = new MyException('error', { code: 404 });\n *\n * @example\n * const SimpleException = defineException('SimpleException');\n * const err = new SimpleException('error', undefined);\n */\nexport function defineException<T = void>(name: string, options?: DefineExceptionOptions) {\n  const { format } = objectDefaults(options || {}, defaults) as Required<DefineExceptionOptions>;\n\n  return class extends Error {\n    constructor(message: string, extra: T) {\n      super(format(name, message));\n      this.name = name;\n      Object.assign(this, extra);\n    }\n  } as unknown as {\n    new (message: string, extra: T): Error & T;\n  };\n}\n\n// const MyException = defineException<{ foo: string; bar: number }>('MyException: ');\n// const myException = new MyException('bar', { foo: '1', bar: 1 });\n// myException.foo;\n// myException.bar;\n// myException.name;\n// myException.message;\n// myException.stack;\n// myException.cause;\n\n// const MyException2 = defineException('MyException2: ');\n// const myException2 = new MyException2('bar');\n"],"mappings":";;;;;;AAoBA,IAAM,WAAmC;;;;;AAKvC,SAAS,MAAM,YAAY,IAAI,KAAK,IAAI,WACzC;;;;;;;;;;;;;;;AAgBD,SAAgB,gBAA0B,MAAc,SAAkC;CACxF,MAAM,EAAE,WAAW,eAAA,eAAe,WAAW,EAAE,EAAE,SAAS;CAE1D,OAAO,cAAc,MAAM;EACzB,YAAY,SAAiB,OAAU;GACrC,MAAM,OAAO,MAAM,QAAQ,CAAC;GAC5B,KAAK,OAAO;GACZ,OAAO,OAAO,MAAM,MAAM"}

package/dist/exception.d.ts

@@ -1,7 +1,7 @@
 /**
  * 构建异常选项
  */
-export type BuildExceptionOptions = {
+export type DefineExceptionOptions = {
     /**
      * 自定义错误消息格式函数
      * @param name 错误名称
@@ -13,19 +13,19 @@ export type BuildExceptionOptions = {
     format?: (name: string, message: string) => string;
 };
 /**
- * 构建自定义异常类
+ * 自定义异常类
  * @template T 额外属性的类型
  * @param name 异常类名称
  * @param options 构建选项
  * @returns 自定义异常类
  * @example
- * const MyException = buildException<{ code: number }>('MyException');
+ * const MyException = defineException<{ code: number }>('MyException');
  * const err = new MyException('error', { code: 404 });
  *
  * @example
- * const SimpleException = buildException('SimpleException');
+ * const SimpleException = defineException('SimpleException');
  * const err = new SimpleException('error', undefined);
  */
-export declare function buildException<T = void>(name: string, options?: BuildExceptionOptions): {
+export declare function defineException<T = void>(name: string, options?: DefineExceptionOptions): {
     new (message: string, extra: T): Error & T;
 };

package/dist/exception.mjs

@@ -1,22 +1,39 @@
-import { o as objectDefaults } from "./merge.mjs";
-const defaults = {
-  /**
-   * 默认消息格式函数
-   * @default (name, message) => `[${name}] ${message}`
-   */
-  format: (name, message) => `[${name}] ${message}`
-};
-function buildException(name, options) {
-  const { format } = objectDefaults(options || {}, defaults);
-  return class extends Error {
-    constructor(message, extra) {
-      super(format(name, message));
-      this.name = name;
-      Object.assign(this, extra);
-    }
-  };
+import { objectDefaults } from "./object.mjs";
+//#region src/exception.ts
+/**
+* 默认的异常构建选项
+*/
+var defaults = { 
+/**
+* 默认消息格式函数
+* @default (name, message) => `[${name}] ${message}`
+*/
+format: (name, message) => `[${name}] ${message}` };
+/**
+* 自定义异常类
+* @template T 额外属性的类型
+* @param name 异常类名称
+* @param options 构建选项
+* @returns 自定义异常类
+* @example
+* const MyException = defineException<{ code: number }>('MyException');
+* const err = new MyException('error', { code: 404 });
+*
+* @example
+* const SimpleException = defineException('SimpleException');
+* const err = new SimpleException('error', undefined);
+*/
+function defineException(name, options) {
+	const { format } = objectDefaults(options || {}, defaults);
+	return class extends Error {
+		constructor(message, extra) {
+			super(format(name, message));
+			this.name = name;
+			Object.assign(this, extra);
+		}
+	};
 }
-export {
-  buildException
-};
-//# sourceMappingURL=exception.mjs.map
+//#endregion
+export { defineException };
+
+//# sourceMappingURL=exception.mjs.map

package/dist/exception.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"exception.mjs","sources":["../src/exception.ts"],"sourcesContent":["import { objectDefaults } from './object';\nimport type { AnyObject } from './types';\n\n/**\n * 构建异常选项\n */\nexport type BuildExceptionOptions = {\n  /**\n   * 自定义错误消息格式函数\n   * @param name 错误名称\n   * @param message 原始错误消息\n   * @returns 格式化后的错误消息\n   * @example\n   * (name, message) => `${name}::${message}`\n   */\n  format?: (name: string, message: string) => string;\n};\n\n/**\n * 默认的异常构建选项\n */\nconst defaults: BuildExceptionOptions = {\n  /**\n   * 默认消息格式函数\n   * @default (name, message) => `[${name}] ${message}`\n   */\n  format: (name, message) => `[${name}] ${message}`,\n};\n\n/**\n * 构建自定义异常类\n * @template T 额外属性的类型\n * @param name 异常类名称\n * @param options 构建选项\n * @returns 自定义异常类\n * @example\n * const MyException = buildException<{ code: number }>('MyException');\n * const err = new MyException('error', { code: 404 });\n *\n * @example\n * const SimpleException = buildException('SimpleException');\n * const err = new SimpleException('error', undefined);\n */\nexport function buildException<T = void>(name: string, options?: BuildExceptionOptions) {\n  const { format } = objectDefaults(options || {}, defaults) as Required<BuildExceptionOptions>;\n\n  return class extends Error {\n    constructor(message: string, extra: T) {\n      super(format(name, message));\n      this.name = name;\n      Object.assign(this, extra);\n    }\n  } as unknown as {\n    new (message: string, extra: T): Error & T;\n  };\n}\n\n// const MyException = buildException<{ foo: string; bar: number }>('MyException: ');\n// const myException = new MyException('bar', { foo: '1', bar: 1 });\n// myException.foo;\n// myException.bar;\n// myException.name;\n// myException.message;\n// myException.stack;\n// myException.cause;\n\n// const MyException2 = buildException('MyException2: ');\n// const myException2 = new MyException2('bar');\n"],"names":[],"mappings":";AAqBA,MAAM,WAAkC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKtC,QAAQ,CAAC,MAAM,YAAY,IAAI,IAAI,KAAK,OAAO;AACjD;AAgBgB,SAAA,eAAyB,MAAc,SAAiC;AACtF,QAAM,EAAE,OAAO,IAAI,eAAe,WAAW,CAAA,GAAI,QAAQ;AAEzD,SAAO,cAAc,MAAM;AAAA,IACzB,YAAY,SAAiB,OAAU;AAC/B,YAAA,OAAO,MAAM,OAAO,CAAC;AAC3B,WAAK,OAAO;AACL,aAAA,OAAO,MAAM,KAAK;AAAA,IAAA;AAAA,EAE7B;AAGF;"}
+{"version":3,"file":"exception.mjs","names":[],"sources":["../src/exception.ts"],"sourcesContent":["import { objectDefaults } from './object';\n\n/**\n * 构建异常选项\n */\nexport type DefineExceptionOptions = {\n  /**\n   * 自定义错误消息格式函数\n   * @param name 错误名称\n   * @param message 原始错误消息\n   * @returns 格式化后的错误消息\n   * @example\n   * (name, message) => `${name}::${message}`\n   */\n  format?: (name: string, message: string) => string;\n};\n\n/**\n * 默认的异常构建选项\n */\nconst defaults: DefineExceptionOptions = {\n  /**\n   * 默认消息格式函数\n   * @default (name, message) => `[${name}] ${message}`\n   */\n  format: (name, message) => `[${name}] ${message}`,\n};\n\n/**\n * 自定义异常类\n * @template T 额外属性的类型\n * @param name 异常类名称\n * @param options 构建选项\n * @returns 自定义异常类\n * @example\n * const MyException = defineException<{ code: number }>('MyException');\n * const err = new MyException('error', { code: 404 });\n *\n * @example\n * const SimpleException = defineException('SimpleException');\n * const err = new SimpleException('error', undefined);\n */\nexport function defineException<T = void>(name: string, options?: DefineExceptionOptions) {\n  const { format } = objectDefaults(options || {}, defaults) as Required<DefineExceptionOptions>;\n\n  return class extends Error {\n    constructor(message: string, extra: T) {\n      super(format(name, message));\n      this.name = name;\n      Object.assign(this, extra);\n    }\n  } as unknown as {\n    new (message: string, extra: T): Error & T;\n  };\n}\n\n// const MyException = defineException<{ foo: string; bar: number }>('MyException: ');\n// const myException = new MyException('bar', { foo: '1', bar: 1 });\n// myException.foo;\n// myException.bar;\n// myException.name;\n// myException.message;\n// myException.stack;\n// myException.cause;\n\n// const MyException2 = defineException('MyException2: ');\n// const myException2 = new MyException2('bar');\n"],"mappings":";;;;;AAoBA,IAAM,WAAmC;;;;;AAKvC,SAAS,MAAM,YAAY,IAAI,KAAK,IAAI,WACzC;;;;;;;;;;;;;;;AAgBD,SAAgB,gBAA0B,MAAc,SAAkC;CACxF,MAAM,EAAE,WAAW,eAAe,WAAW,EAAE,EAAE,SAAS;CAE1D,OAAO,cAAc,MAAM;EACzB,YAAY,SAAiB,OAAU;GACrC,MAAM,OAAO,MAAM,QAAQ,CAAC;GAC5B,KAAK,OAAO;GACZ,OAAO,OAAO,MAAM,MAAM"}

package/dist/function.cjs

@@ -1,79 +1,139 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const type = require("./type.cjs");
-function fnNoop() {
-}
+const require_type = require("./type.cjs");
+//#region src/function.ts
+/**
+* 一个空操作函数，不执行任何操作。
+*
+* @example
+* ```typescript
+* fnNoop(); // 不执行任何操作
+* ```
+*/
+function fnNoop() {}
+/**
+* 创建一个防抖函数，该函数会在指定的等待时间后执行，如果在等待时间内再次调用，则重新计时。
+*
+* @param fn - 需要防抖的函数。
+* @param wait - 等待时间（毫秒）或包含 `wait` 和 `leading` 选项的对象。
+* @returns 返回一个防抖函数，该函数具有 `cancel` 方法，用于取消防抖操作。
+*
+* @example
+* ```typescript
+* const debouncedFn = fnDebounce(() => {
+*   console.log('Debounced!');
+* }, 100);
+*
+* debouncedFn(); // 不会立即执行
+* debouncedFn(); // 重新计时
+* debouncedFn.cancel(); // 取消防抖操作
+* ```
+*/
 function fnDebounce(fn, wait) {
-  const options = type.isNumber(wait) ? { wait } : wait;
-  let canceled = false;
-  let timer;
-  let leading = false;
-  const debounced = function(...args) {
-    if (canceled) return;
-    if (options.leading && !leading) {
-      leading = true;
-      fn.apply(this, args);
-      return;
-    }
-    clearTimeout(timer);
-    timer = setTimeout(() => {
-      if (canceled) return;
-      fn.apply(this, args);
-    }, options.wait);
-  };
-  debounced.cancel = () => {
-    clearTimeout(timer);
-    canceled = true;
-  };
-  return debounced;
+	const options = require_type.isNumber(wait) ? { wait } : wait;
+	let canceled = false;
+	let timer;
+	let leading = false;
+	const debounced = function(...args) {
+		if (canceled) return;
+		if (options.leading && !leading) {
+			leading = true;
+			fn.apply(this, args);
+			return;
+		}
+		clearTimeout(timer);
+		timer = setTimeout(() => {
+			if (canceled) return;
+			fn.apply(this, args);
+		}, options.wait);
+	};
+	debounced.cancel = () => {
+		clearTimeout(timer);
+		canceled = true;
+	};
+	return debounced;
 }
+/**
+* 创建一个节流函数，该函数会在指定的等待时间内最多执行一次，如果在等待时间内再次调用，则忽略后续调用。
+*
+* @param fn - 需要节流的函数。
+* @param wait - 等待时间（毫秒）或包含 `wait`、`leading` 和 `trailing` 选项的对象。
+* @returns 返回一个节流函数，该函数具有 `cancel` 方法，用于取消节流操作。
+*
+* @example
+* ```typescript
+* const throttledFn = fnThrottle(() => {
+*   console.log('Throttled!');
+* }, 100);
+*
+* throttledFn(); // 立即执行
+* throttledFn(); // 忽略
+* throttledFn.cancel(); // 取消节流操作
+* ```
+*/
 function fnThrottle(fn, wait) {
-  const options = type.isNumber(wait) ? { wait } : wait;
-  const waitFinal = options.wait;
-  let lastTime = 0;
-  let canceled = false;
-  let timer;
-  const throttled = function(...args) {
-    if (canceled) return;
-    const now = Date.now();
-    let executed = false;
-    if (options.leading && lastTime === 0) {
-      lastTime = now;
-      fn.apply(this, args);
-      executed = true;
-    } else if (lastTime > 0 && now - lastTime >= waitFinal) {
-      lastTime = now;
-      fn.apply(this, args);
-      executed = true;
-    } else if (lastTime === 0) {
-      lastTime = now;
-    }
-    if (options.trailing && !executed) {
-      clearTimeout(timer);
-      timer = setTimeout(() => {
-        fn.apply(this, args);
-      }, waitFinal);
-    }
-  };
-  throttled.cancel = () => {
-    canceled = true;
-    clearTimeout(timer);
-  };
-  return throttled;
+	const options = require_type.isNumber(wait) ? { wait } : wait;
+	const waitFinal = options.wait;
+	let lastTime = 0;
+	let canceled = false;
+	let timer;
+	const throttled = function(...args) {
+		if (canceled) return;
+		const now = Date.now();
+		let executed = false;
+		if (options.leading && lastTime === 0) {
+			lastTime = now;
+			fn.apply(this, args);
+			executed = true;
+		} else if (lastTime > 0 && now - lastTime >= waitFinal) {
+			lastTime = now;
+			fn.apply(this, args);
+			executed = true;
+		} else if (lastTime === 0) lastTime = now;
+		if (options.trailing && !executed) {
+			clearTimeout(timer);
+			timer = setTimeout(() => {
+				fn.apply(this, args);
+			}, waitFinal);
+		}
+	};
+	throttled.cancel = () => {
+		canceled = true;
+		clearTimeout(timer);
+	};
+	return throttled;
 }
+/**
+* 创建一个只执行一次的函数，无论调用多少次，实际执行的函数体也只会执行一次。
+*
+* @param fn - 需要只执行一次的函数。
+* @returns 返回一个只执行一次的函数，该函数在第一次调用后会缓存结果并返回缓存的结果。
+*
+* @example
+* ```typescript
+* const onceFn = fnOnce(() => {
+*   console.log('This will be logged only once.');
+*   return 42;
+* });
+*
+* console.log(onceFn()); // 输出: This will be logged only once. 42
+* console.log(onceFn()); // 输出: 42
+* ```
+*/
 function fnOnce(fn) {
-  let called = false;
-  let result;
-  return function(...args) {
-    if (!called) {
-      called = true;
-      result = fn.apply(this, args);
-    }
-    return result;
-  };
+	let called = false;
+	let result;
+	return function(...args) {
+		if (!called) {
+			called = true;
+			result = fn.apply(this, args);
+		}
+		return result;
+	};
 }
+//#endregion
 exports.fnDebounce = fnDebounce;
 exports.fnNoop = fnNoop;
 exports.fnOnce = fnOnce;
 exports.fnThrottle = fnThrottle;
-//# sourceMappingURL=function.cjs.map
+
+//# sourceMappingURL=function.cjs.map

package/dist/function.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"function.cjs","sources":["../src/function.ts"],"sourcesContent":["import { isNumber } from './type';\nimport type { AnyFunction } from './types';\n\n/**\n * 一个空操作函数，不执行任何操作。\n *\n * @example\n * ```typescript\n * fnNoop(); // 不执行任何操作\n * ```\n */\nexport function fnNoop() {\n  //\n}\n\n/**\n * 防抖函数的配置选项。\n */\nexport type DebounceOptions = {\n  /**\n   * 等待时间（毫秒）。\n   */\n  wait: number;\n  /**\n   * 是否在等待开始时立即执行一次\n   * @default false\n   */\n  leading?: boolean;\n};\n\n/**\n * 创建一个防抖函数，该函数会在指定的等待时间后执行，如果在等待时间内再次调用，则重新计时。\n *\n * @param fn - 需要防抖的函数。\n * @param wait - 等待时间（毫秒）或包含 `wait` 和 `leading` 选项的对象。\n * @returns 返回一个防抖函数，该函数具有 `cancel` 方法，用于取消防抖操作。\n *\n * @example\n * ```typescript\n * const debouncedFn = fnDebounce(() => {\n *   console.log('Debounced!');\n * }, 100);\n *\n * debouncedFn(); // 不会立即执行\n * debouncedFn(); // 重新计时\n * debouncedFn.cancel(); // 取消防抖操作\n * ```\n */\nexport function fnDebounce<F extends AnyFunction>(fn: F, wait: number | DebounceOptions) {\n  const options: DebounceOptions = isNumber(wait) ? { wait } : wait;\n  let canceled = false;\n  // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n  let timer: any;\n  let leading = false;\n\n  const debounced = function (this: unknown, ...args: Parameters<F>) {\n    if (canceled) return;\n\n    // 第一次执行\n    if (options.leading && !leading) {\n      leading = true;\n      fn.apply(this, args);\n      return;\n    }\n\n    // 最后一次执行\n    clearTimeout(timer);\n    timer = setTimeout(() => {\n      if (canceled) return;\n\n      fn.apply(this, args);\n    }, options.wait);\n  };\n\n  debounced.cancel = () => {\n    clearTimeout(timer);\n    canceled = true;\n  };\n\n  return debounced;\n}\n\nexport type ThrottleOptions = {\n  /**\n   * 等待时间（毫秒）。\n   */\n  wait: number;\n\n  /**\n   * 是否在第一次调用时立即执行\n   * @default false\n   */\n  leading?: boolean;\n\n  /**\n   * 是否在调用结束后等待一段时间再执行\n   * @default false\n   */\n  trailing?: boolean;\n};\n\n/**\n * 创建一个节流函数，该函数会在指定的等待时间内最多执行一次，如果在等待时间内再次调用，则忽略后续调用。\n *\n * @param fn - 需要节流的函数。\n * @param wait - 等待时间（毫秒）或包含 `wait`、`leading` 和 `trailing` 选项的对象。\n * @returns 返回一个节流函数，该函数具有 `cancel` 方法，用于取消节流操作。\n *\n * @example\n * ```typescript\n * const throttledFn = fnThrottle(() => {\n *   console.log('Throttled!');\n * }, 100);\n *\n * throttledFn(); // 立即执行\n * throttledFn(); // 忽略\n * throttledFn.cancel(); // 取消节流操作\n * ```\n */\nexport function fnThrottle<F extends AnyFunction>(fn: F, wait: number | ThrottleOptions) {\n  const options = isNumber(wait) ? { wait } : wait;\n  const waitFinal = options.wait;\n  let lastTime = 0;\n  let canceled = false;\n  // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n  let timer: any;\n\n  const throttled = function (this: unknown, ...args: Parameters<F>) {\n    if (canceled) return;\n\n    const now = Date.now();\n    let executed = false;\n\n    // 第一次执行\n    if (options.leading && lastTime === 0) {\n      lastTime = now;\n      fn.apply(this, args);\n      executed = true;\n    }\n\n    // 中间控频执行\n    else if (lastTime > 0 && now - lastTime >= waitFinal) {\n      lastTime = now;\n      fn.apply(this, args);\n      executed = true;\n    }\n\n    // 首次计时\n    else if (lastTime === 0) {\n      lastTime = now;\n    }\n\n    // 最后一次执行，仅在本次未执行时才设置 trailing\n    if (options.trailing && !executed) {\n      clearTimeout(timer);\n      timer = setTimeout(() => {\n        fn.apply(this, args);\n      }, waitFinal);\n    }\n  };\n\n  throttled.cancel = () => {\n    canceled = true;\n    clearTimeout(timer);\n  };\n\n  return throttled;\n}\n\n/**\n * 创建一个只执行一次的函数，无论调用多少次，实际执行的函数体也只会执行一次。\n *\n * @param fn - 需要只执行一次的函数。\n * @returns 返回一个只执行一次的函数，该函数在第一次调用后会缓存结果并返回缓存的结果。\n *\n * @example\n * ```typescript\n * const onceFn = fnOnce(() => {\n *   console.log('This will be logged only once.');\n *   return 42;\n * });\n *\n * console.log(onceFn()); // 输出: This will be logged only once. 42\n * console.log(onceFn()); // 输出: 42\n * ```\n */\nexport function fnOnce<F extends AnyFunction>(fn: F) {\n  let called = false;\n  // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n  let result: any;\n\n  return function (this: unknown, ...args: Parameters<F>) {\n    if (!called) {\n      called = true;\n      result = fn.apply(this, args);\n    }\n\n    return result;\n  };\n}\n"],"names":["isNumber"],"mappings":";;;AAWO,SAAS,SAAS;AAEzB;AAmCgB,SAAA,WAAkC,IAAO,MAAgC;AACvF,QAAM,UAA2BA,KAAAA,SAAS,IAAI,IAAI,EAAE,KAAS,IAAA;AAC7D,MAAI,WAAW;AAEX,MAAA;AACJ,MAAI,UAAU;AAER,QAAA,YAAY,YAA4B,MAAqB;AACjE,QAAI,SAAU;AAGV,QAAA,QAAQ,WAAW,CAAC,SAAS;AACrB,gBAAA;AACP,SAAA,MAAM,MAAM,IAAI;AACnB;AAAA,IAAA;AAIF,iBAAa,KAAK;AAClB,YAAQ,WAAW,MAAM;AACvB,UAAI,SAAU;AAEX,SAAA,MAAM,MAAM,IAAI;AAAA,IAAA,GAClB,QAAQ,IAAI;AAAA,EACjB;AAEA,YAAU,SAAS,MAAM;AACvB,iBAAa,KAAK;AACP,eAAA;AAAA,EACb;AAEO,SAAA;AACT;AAuCgB,SAAA,WAAkC,IAAO,MAAgC;AACvF,QAAM,UAAUA,KAAAA,SAAS,IAAI,IAAI,EAAE,KAAS,IAAA;AAC5C,QAAM,YAAY,QAAQ;AAC1B,MAAI,WAAW;AACf,MAAI,WAAW;AAEX,MAAA;AAEE,QAAA,YAAY,YAA4B,MAAqB;AACjE,QAAI,SAAU;AAER,UAAA,MAAM,KAAK,IAAI;AACrB,QAAI,WAAW;AAGX,QAAA,QAAQ,WAAW,aAAa,GAAG;AAC1B,iBAAA;AACR,SAAA,MAAM,MAAM,IAAI;AACR,iBAAA;AAAA,IAIJ,WAAA,WAAW,KAAK,MAAM,YAAY,WAAW;AACzC,iBAAA;AACR,SAAA,MAAM,MAAM,IAAI;AACR,iBAAA;AAAA,IAAA,WAIJ,aAAa,GAAG;AACZ,iBAAA;AAAA,IAAA;AAIT,QAAA,QAAQ,YAAY,CAAC,UAAU;AACjC,mBAAa,KAAK;AAClB,cAAQ,WAAW,MAAM;AACpB,WAAA,MAAM,MAAM,IAAI;AAAA,SAClB,SAAS;AAAA,IAAA;AAAA,EAEhB;AAEA,YAAU,SAAS,MAAM;AACZ,eAAA;AACX,iBAAa,KAAK;AAAA,EACpB;AAEO,SAAA;AACT;AAmBO,SAAS,OAA8B,IAAO;AACnD,MAAI,SAAS;AAET,MAAA;AAEJ,SAAO,YAA4B,MAAqB;AACtD,QAAI,CAAC,QAAQ;AACF,eAAA;AACA,eAAA,GAAG,MAAM,MAAM,IAAI;AAAA,IAAA;AAGvB,WAAA;AAAA,EACT;AACF;;;;;"}
+{"version":3,"file":"function.cjs","names":[],"sources":["../src/function.ts"],"sourcesContent":["import { isNumber } from './type';\nimport type { AnyFunction } from './types';\n\n/**\n * 一个空操作函数，不执行任何操作。\n *\n * @example\n * ```typescript\n * fnNoop(); // 不执行任何操作\n * ```\n */\nexport function fnNoop() {\n  //\n}\n\n/**\n * 防抖函数的配置选项。\n */\nexport type DebounceOptions = {\n  /**\n   * 等待时间（毫秒）。\n   */\n  wait: number;\n  /**\n   * 是否在等待开始时立即执行一次\n   * @default false\n   */\n  leading?: boolean;\n};\n\n/**\n * 创建一个防抖函数，该函数会在指定的等待时间后执行，如果在等待时间内再次调用，则重新计时。\n *\n * @param fn - 需要防抖的函数。\n * @param wait - 等待时间（毫秒）或包含 `wait` 和 `leading` 选项的对象。\n * @returns 返回一个防抖函数，该函数具有 `cancel` 方法，用于取消防抖操作。\n *\n * @example\n * ```typescript\n * const debouncedFn = fnDebounce(() => {\n *   console.log('Debounced!');\n * }, 100);\n *\n * debouncedFn(); // 不会立即执行\n * debouncedFn(); // 重新计时\n * debouncedFn.cancel(); // 取消防抖操作\n * ```\n */\nexport function fnDebounce<F extends AnyFunction>(fn: F, wait: number | DebounceOptions) {\n  const options: DebounceOptions = isNumber(wait) ? { wait } : wait;\n  let canceled = false;\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\n  let timer: any;\n  let leading = false;\n\n  const debounced = function (this: unknown, ...args: Parameters<F>) {\n    if (canceled) return;\n\n    // 第一次执行\n    if (options.leading && !leading) {\n      leading = true;\n      fn.apply(this, args);\n      return;\n    }\n\n    // 最后一次执行\n    clearTimeout(timer);\n    timer = setTimeout(() => {\n      if (canceled) return;\n\n      fn.apply(this, args);\n    }, options.wait);\n  };\n\n  debounced.cancel = () => {\n    clearTimeout(timer);\n    canceled = true;\n  };\n\n  return debounced;\n}\n\nexport type ThrottleOptions = {\n  /**\n   * 等待时间（毫秒）。\n   */\n  wait: number;\n\n  /**\n   * 是否在第一次调用时立即执行\n   * @default false\n   */\n  leading?: boolean;\n\n  /**\n   * 是否在调用结束后等待一段时间再执行\n   * @default false\n   */\n  trailing?: boolean;\n};\n\n/**\n * 创建一个节流函数，该函数会在指定的等待时间内最多执行一次，如果在等待时间内再次调用，则忽略后续调用。\n *\n * @param fn - 需要节流的函数。\n * @param wait - 等待时间（毫秒）或包含 `wait`、`leading` 和 `trailing` 选项的对象。\n * @returns 返回一个节流函数，该函数具有 `cancel` 方法，用于取消节流操作。\n *\n * @example\n * ```typescript\n * const throttledFn = fnThrottle(() => {\n *   console.log('Throttled!');\n * }, 100);\n *\n * throttledFn(); // 立即执行\n * throttledFn(); // 忽略\n * throttledFn.cancel(); // 取消节流操作\n * ```\n */\nexport function fnThrottle<F extends AnyFunction>(fn: F, wait: number | ThrottleOptions) {\n  const options = isNumber(wait) ? { wait } : wait;\n  const waitFinal = options.wait;\n  let lastTime = 0;\n  let canceled = false;\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\n  let timer: any;\n\n  const throttled = function (this: unknown, ...args: Parameters<F>) {\n    if (canceled) return;\n\n    const now = Date.now();\n    let executed = false;\n\n    // 第一次执行\n    if (options.leading && lastTime === 0) {\n      lastTime = now;\n      fn.apply(this, args);\n      executed = true;\n    }\n\n    // 中间控频执行\n    else if (lastTime > 0 && now - lastTime >= waitFinal) {\n      lastTime = now;\n      fn.apply(this, args);\n      executed = true;\n    }\n\n    // 首次计时\n    else if (lastTime === 0) {\n      lastTime = now;\n    }\n\n    // 最后一次执行，仅在本次未执行时才设置 trailing\n    if (options.trailing && !executed) {\n      clearTimeout(timer);\n      timer = setTimeout(() => {\n        fn.apply(this, args);\n      }, waitFinal);\n    }\n  };\n\n  throttled.cancel = () => {\n    canceled = true;\n    clearTimeout(timer);\n  };\n\n  return throttled;\n}\n\n/**\n * 创建一个只执行一次的函数，无论调用多少次，实际执行的函数体也只会执行一次。\n *\n * @param fn - 需要只执行一次的函数。\n * @returns 返回一个只执行一次的函数，该函数在第一次调用后会缓存结果并返回缓存的结果。\n *\n * @example\n * ```typescript\n * const onceFn = fnOnce(() => {\n *   console.log('This will be logged only once.');\n *   return 42;\n * });\n *\n * console.log(onceFn()); // 输出: This will be logged only once. 42\n * console.log(onceFn()); // 输出: 42\n * ```\n */\nexport function fnOnce<F extends AnyFunction>(fn: F) {\n  let called = false;\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\n  let result: any;\n\n  return function (this: unknown, ...args: Parameters<F>) {\n    if (!called) {\n      called = true;\n      result = fn.apply(this, args);\n    }\n\n    return result;\n  };\n}\n"],"mappings":";;;;;;;;;;;AAWA,SAAgB,SAAS;;;;;;;;;;;;;;;;;;;AAqCzB,SAAgB,WAAkC,IAAO,MAAgC;CACvF,MAAM,UAA2B,aAAA,SAAS,KAAK,GAAG,EAAE,MAAM,GAAG;CAC7D,IAAI,WAAW;CAEf,IAAI;CACJ,IAAI,UAAU;CAEd,MAAM,YAAY,SAAyB,GAAG,MAAqB;EACjE,IAAI,UAAU;EAGd,IAAI,QAAQ,WAAW,CAAC,SAAS;GAC/B,UAAU;GACV,GAAG,MAAM,MAAM,KAAK;GACpB;;EAIF,aAAa,MAAM;EACnB,QAAQ,iBAAiB;GACvB,IAAI,UAAU;GAEd,GAAG,MAAM,MAAM,KAAK;KACnB,QAAQ,KAAK;;CAGlB,UAAU,eAAe;EACvB,aAAa,MAAM;EACnB,WAAW;;CAGb,OAAO;;;;;;;;;;;;;;;;;;;;AAwCT,SAAgB,WAAkC,IAAO,MAAgC;CACvF,MAAM,UAAU,aAAA,SAAS,KAAK,GAAG,EAAE,MAAM,GAAG;CAC5C,MAAM,YAAY,QAAQ;CAC1B,IAAI,WAAW;CACf,IAAI,WAAW;CAEf,IAAI;CAEJ,MAAM,YAAY,SAAyB,GAAG,MAAqB;EACjE,IAAI,UAAU;EAEd,MAAM,MAAM,KAAK,KAAK;EACtB,IAAI,WAAW;EAGf,IAAI,QAAQ,WAAW,aAAa,GAAG;GACrC,WAAW;GACX,GAAG,MAAM,MAAM,KAAK;GACpB,WAAW;SAIR,IAAI,WAAW,KAAK,MAAM,YAAY,WAAW;GACpD,WAAW;GACX,GAAG,MAAM,MAAM,KAAK;GACpB,WAAW;SAIR,IAAI,aAAa,GACpB,WAAW;EAIb,IAAI,QAAQ,YAAY,CAAC,UAAU;GACjC,aAAa,MAAM;GACnB,QAAQ,iBAAiB;IACvB,GAAG,MAAM,MAAM,KAAK;MACnB,UAAU;;;CAIjB,UAAU,eAAe;EACvB,WAAW;EACX,aAAa,MAAM;;CAGrB,OAAO;;;;;;;;;;;;;;;;;;;AAoBT,SAAgB,OAA8B,IAAO;CACnD,IAAI,SAAS;CAEb,IAAI;CAEJ,OAAO,SAAyB,GAAG,MAAqB;EACtD,IAAI,CAAC,QAAQ;GACX,SAAS;GACT,SAAS,GAAG,MAAM,MAAM,KAAK;;EAG/B,OAAO"}