@cloudcome/utils-core 1.1.1 → 1.2.0

package/dist/exception.d.ts

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

package/dist/exception.mjs

@@ -0,0 +1,22 @@
+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);
+    }
+  };
+}
+export {
+  buildException
+};
+//# sourceMappingURL=exception.mjs.map

package/dist/exception.mjs.map

@@ -0,0 +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;"}

package/dist/fn.cjs

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("./type.cjs");
+function fnNoop() {
+}
+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;
+}
+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();
+    if (options.leading && lastTime === 0) {
+      lastTime = now;
+      fn.apply(this, args);
+    } else if (lastTime > 0 && now - lastTime >= waitFinal) {
+      lastTime = now;
+      fn.apply(this, args);
+    } else if (lastTime === 0) {
+      lastTime = now;
+    }
+    if (options.trailing) {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        fn.apply(this, args);
+      }, waitFinal);
+    }
+  };
+  throttled.cancel = () => {
+    canceled = true;
+    clearTimeout(timer);
+  };
+  return throttled;
+}
+function fnOnce(fn) {
+  let called = false;
+  let result;
+  return function(...args) {
+    if (!called) {
+      called = true;
+      result = fn.apply(this, args);
+    }
+    return result;
+  };
+}
+exports.fnDebounce = fnDebounce;
+exports.fnNoop = fnNoop;
+exports.fnOnce = fnOnce;
+exports.fnThrottle = fnThrottle;
+//# sourceMappingURL=fn.cjs.map

package/dist/fn.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fn.cjs","sources":["../src/fn.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 TDebounceOptions = {\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 | TDebounceOptions) {\n  const options: TDebounceOptions = 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 TThrottleOptions = {\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 | TThrottleOptions) {\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\n    // 第一次执行\n    if (options.leading && lastTime === 0) {\n      lastTime = now;\n      fn.apply(this, args);\n    }\n\n    // 中间控频执行\n    else if (lastTime > 0 && now - lastTime >= waitFinal) {\n      lastTime = now;\n      fn.apply(this, args);\n    }\n\n    // 首次计时\n    else if (lastTime === 0) {\n      lastTime = now;\n    }\n\n    // 最后一次执行\n    if (options.trailing) {\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,MAAiC;AACxF,QAAM,UAA4BA,KAAAA,SAAS,IAAI,IAAI,EAAE,KAAS,IAAA;AAC9D,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,MAAiC;AACxF,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;AAGjB,QAAA,QAAQ,WAAW,aAAa,GAAG;AAC1B,iBAAA;AACR,SAAA,MAAM,MAAM,IAAI;AAAA,IAIZ,WAAA,WAAW,KAAK,MAAM,YAAY,WAAW;AACzC,iBAAA;AACR,SAAA,MAAM,MAAM,IAAI;AAAA,IAAA,WAIZ,aAAa,GAAG;AACZ,iBAAA;AAAA,IAAA;AAIb,QAAI,QAAQ,UAAU;AACpB,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;;;;;"}

package/dist/fn.d.ts

@@ -0,0 +1,102 @@
+import { AnyFunction } from './types';
+/**
+ * 一个空操作函数，不执行任何操作。
+ *
+ * @example
+ * ```typescript
+ * fnNoop(); // 不执行任何操作
+ * ```
+ */
+export declare function fnNoop(): void;
+/**
+ * 防抖函数的配置选项。
+ */
+export type TDebounceOptions = {
+    /**
+     * 等待时间（毫秒）。
+     */
+    wait: number;
+    /**
+     * 是否在等待开始时立即执行一次
+     * @default false
+     */
+    leading?: boolean;
+};
+/**
+ * 创建一个防抖函数，该函数会在指定的等待时间后执行，如果在等待时间内再次调用，则重新计时。
+ *
+ * @param fn - 需要防抖的函数。
+ * @param wait - 等待时间（毫秒）或包含 `wait` 和 `leading` 选项的对象。
+ * @returns 返回一个防抖函数，该函数具有 `cancel` 方法，用于取消防抖操作。
+ *
+ * @example
+ * ```typescript
+ * const debouncedFn = fnDebounce(() => {
+ *   console.log('Debounced!');
+ * }, 100);
+ *
+ * debouncedFn(); // 不会立即执行
+ * debouncedFn(); // 重新计时
+ * debouncedFn.cancel(); // 取消防抖操作
+ * ```
+ */
+export declare function fnDebounce<F extends AnyFunction>(fn: F, wait: number | TDebounceOptions): {
+    (this: unknown, ...args: Parameters<F>): void;
+    cancel(): void;
+};
+export type TThrottleOptions = {
+    /**
+     * 等待时间（毫秒）。
+     */
+    wait: number;
+    /**
+     * 是否在第一次调用时立即执行
+     * @default false
+     */
+    leading?: boolean;
+    /**
+     * 是否在调用结束后等待一段时间再执行
+     * @default false
+     */
+    trailing?: boolean;
+};
+/**
+ * 创建一个节流函数，该函数会在指定的等待时间内最多执行一次，如果在等待时间内再次调用，则忽略后续调用。
+ *
+ * @param fn - 需要节流的函数。
+ * @param wait - 等待时间（毫秒）或包含 `wait`、`leading` 和 `trailing` 选项的对象。
+ * @returns 返回一个节流函数，该函数具有 `cancel` 方法，用于取消节流操作。
+ *
+ * @example
+ * ```typescript
+ * const throttledFn = fnThrottle(() => {
+ *   console.log('Throttled!');
+ * }, 100);
+ *
+ * throttledFn(); // 立即执行
+ * throttledFn(); // 忽略
+ * throttledFn.cancel(); // 取消节流操作
+ * ```
+ */
+export declare function fnThrottle<F extends AnyFunction>(fn: F, wait: number | TThrottleOptions): {
+    (this: unknown, ...args: Parameters<F>): void;
+    cancel(): void;
+};
+/**
+ * 创建一个只执行一次的函数，无论调用多少次，实际执行的函数体也只会执行一次。
+ *
+ * @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
+ * ```
+ */
+export declare function fnOnce<F extends AnyFunction>(fn: F): (this: unknown, ...args: Parameters<F>) => any;

package/dist/fn.mjs

@@ -0,0 +1,76 @@
+import { isNumber } from "./type.mjs";
+function fnNoop() {
+}
+function fnDebounce(fn, wait) {
+  const options = 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;
+}
+function fnThrottle(fn, wait) {
+  const options = 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();
+    if (options.leading && lastTime === 0) {
+      lastTime = now;
+      fn.apply(this, args);
+    } else if (lastTime > 0 && now - lastTime >= waitFinal) {
+      lastTime = now;
+      fn.apply(this, args);
+    } else if (lastTime === 0) {
+      lastTime = now;
+    }
+    if (options.trailing) {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        fn.apply(this, args);
+      }, waitFinal);
+    }
+  };
+  throttled.cancel = () => {
+    canceled = true;
+    clearTimeout(timer);
+  };
+  return throttled;
+}
+function fnOnce(fn) {
+  let called = false;
+  let result;
+  return function(...args) {
+    if (!called) {
+      called = true;
+      result = fn.apply(this, args);
+    }
+    return result;
+  };
+}
+export {
+  fnDebounce,
+  fnNoop,
+  fnOnce,
+  fnThrottle
+};
+//# sourceMappingURL=fn.mjs.map

package/dist/fn.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fn.mjs","sources":["../src/fn.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 TDebounceOptions = {\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 | TDebounceOptions) {\n  const options: TDebounceOptions = 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 TThrottleOptions = {\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 | TThrottleOptions) {\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\n    // 第一次执行\n    if (options.leading && lastTime === 0) {\n      lastTime = now;\n      fn.apply(this, args);\n    }\n\n    // 中间控频执行\n    else if (lastTime > 0 && now - lastTime >= waitFinal) {\n      lastTime = now;\n      fn.apply(this, args);\n    }\n\n    // 首次计时\n    else if (lastTime === 0) {\n      lastTime = now;\n    }\n\n    // 最后一次执行\n    if (options.trailing) {\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":[],"mappings":";AAWO,SAAS,SAAS;AAEzB;AAmCgB,SAAA,WAAkC,IAAO,MAAiC;AACxF,QAAM,UAA4B,SAAS,IAAI,IAAI,EAAE,KAAS,IAAA;AAC9D,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,MAAiC;AACxF,QAAM,UAAU,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;AAGjB,QAAA,QAAQ,WAAW,aAAa,GAAG;AAC1B,iBAAA;AACR,SAAA,MAAM,MAAM,IAAI;AAAA,IAIZ,WAAA,WAAW,KAAK,MAAM,YAAY,WAAW;AACzC,iBAAA;AACR,SAAA,MAAM,MAAM,IAAI;AAAA,IAAA,WAIZ,aAAa,GAAG;AACZ,iBAAA;AAAA,IAAA;AAIb,QAAI,QAAQ,UAAU;AACpB,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;"}

package/dist/index.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const VERSION = "1.1.1";
+exports.VERSION = VERSION;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../src/index.ts"],"sourcesContent":["export const VERSION = PKG_VERSION;\n"],"names":[],"mappings":";;AAAO,MAAM,UAAU;;"}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare const VERSION: string;

package/dist/index.mjs

@@ -0,0 +1,5 @@
+const VERSION = "1.1.1";
+export {
+  VERSION
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../src/index.ts"],"sourcesContent":["export const VERSION = PKG_VERSION;\n"],"names":[],"mappings":"AAAO,MAAM,UAAU;"}

package/dist/merge.cjs

@@ -0,0 +1,87 @@
+"use strict";
+const type = require("./type.cjs");
+const each = require("./each.cjs");
+function _objectMerge(mergeRule, target, ...sources) {
+  const seen = /* @__PURE__ */ new WeakMap();
+  const { assign, next } = mergeRule;
+  const align = (target2, source) => {
+    const targetType = type.typeIs(target2);
+    const sourceType = type.typeIs(source);
+    if (targetType === sourceType) {
+      return target2;
+    }
+    return sourceType === "array" ? [] : {};
+  };
+  const each$1 = (source, iterator) => {
+    if (type.isObject(source)) {
+      each.objectEach(source, iterator);
+    } else {
+      source.forEach(iterator);
+    }
+  };
+  const merge = (target2, source) => {
+    if (seen.has(source)) {
+      return seen.get(source);
+    }
+    const merged = align(target2, source);
+    seen.set(source, merged);
+    each$1(source, (value, key) => {
+      if (!next({ target: merged, source, key })) {
+        return;
+      }
+      if (type.isObject(value) || type.isArray(value)) {
+        merged[key] = assign({
+          target: merged,
+          source,
+          key,
+          // @ts-expect-error
+          merge: () => merge(merged[key], value)
+        });
+      } else {
+        merged[key] = assign({
+          target: merged,
+          source,
+          key,
+          merge: () => value
+        });
+      }
+    });
+    return merged;
+  };
+  let returnTarget = target;
+  for (const source of sources) {
+    returnTarget = merge(target, source);
+  }
+  return returnTarget;
+}
+function objectMerge(target, ...sources) {
+  return _objectMerge(
+    {
+      next() {
+        return true;
+      },
+      assign({ merge }) {
+        return merge();
+      }
+    },
+    target,
+    ...sources
+  );
+}
+function objectDefaults(target, defaults) {
+  return _objectMerge(
+    {
+      next({ target: target2, source, key }) {
+        return target2[key] === void 0 || type.isObject(target2[key]) || type.isArray(target2[key]);
+      },
+      assign({ merge }) {
+        return merge();
+      }
+    },
+    target,
+    defaults
+  );
+}
+exports.objectDefaults = objectDefaults;
+exports.objectMerge = objectMerge;
+//# sourceMappingURL=merge.cjs.map

package/dist/merge.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.cjs","sources":["../src/object/merge.ts"],"sourcesContent":["import { isArray, isObject, typeIs } from '@/type';\nimport type { AnyArray, AnyObject } from '@/types';\nimport { objectEach } from './each';\n\nexport type TObjectMergeRule = {\n  /**\n   * 处理冲突\n   * @param target - 目标对象\n   * @param source - 源对象\n   * @param key - 键名\n   * @returns 返回 true 表示继续处理，否则返回 false\n   */\n  next: (info: {\n    target: AnyObject | AnyArray;\n    source: AnyObject | AnyArray;\n    key: string | number;\n  }) => boolean;\n\n  /**\n   * 处理赋值\n   * @param target - 目标对象\n   * @param source - 源对象\n   * @param key - 键名\n   * @returns 返回处理后的值\n   */\n  assign: (info: {\n    target: AnyObject | AnyArray;\n    source: AnyObject | AnyArray;\n    key: string | number;\n    // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n    merge: () => any;\n    // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n  }) => any;\n};\n\nfunction _objectMerge(mergeRule: TObjectMergeRule, target: AnyObject | AnyArray, ...sources: (AnyObject | AnyArray)[]) {\n  const seen = new WeakMap<AnyObject | AnyArray, AnyObject | AnyArray>();\n  const { assign, next } = mergeRule;\n  const align = (target: AnyObject | AnyArray, source: AnyObject | AnyArray) => {\n    const targetType = typeIs(target);\n    const sourceType = typeIs(source);\n\n    if (targetType === sourceType) {\n      return target;\n    }\n\n    return sourceType === 'array' ? [] : {};\n  };\n  // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n  const each = (source: AnyObject | AnyArray, iterator: (val: any, key: string | number) => void) => {\n    if (isObject(source)) {\n      objectEach(source, iterator);\n    } else {\n      source.forEach(iterator);\n    }\n  };\n\n  const merge = (target: AnyObject | AnyArray, source: AnyObject | AnyArray): AnyObject | AnyArray => {\n    // 如果循环引用了，则直接返回目标对象\n    if (seen.has(source)) {\n      // biome-ignore lint/style/noNonNullAssertion: <explanation>\n      return seen.get(source)!;\n    }\n\n    // 对齐目标对象和源对象\n    const merged = align(target, source);\n\n    // 存储循环引用\n    seen.set(source, merged);\n\n    // 遍历源对象\n    each(source, (value, key) => {\n      if (!next({ target: merged, source, key })) {\n        return;\n      }\n\n      if (isObject(value) || isArray(value)) {\n        // @ts-expect-error\n        merged[key] = assign({\n          target: merged,\n          source,\n          key,\n          // @ts-expect-error\n          merge: () => merge(merged[key], value),\n        });\n      } else {\n        // @ts-expect-error\n        merged[key] = assign({\n          target: merged,\n          source,\n          key,\n          merge: () => value,\n        });\n      }\n    });\n\n    return merged;\n  };\n\n  let returnTarget = target;\n\n  for (const source of sources) {\n    returnTarget = merge(target, source);\n  }\n\n  return returnTarget;\n}\n\n/**\n * 合并多个对象或数组。如果遇到循环引用，则直接返回目标对象。\n *\n * @param target - 目标对象或数组。\n * @param sources - 要合并的源对象或数组。\n * @returns 合并后的对象或数组。\n *\n * @example\n * ```typescript\n * const obj1 = { a: 1, b: { x: 10 } };\n * const obj2 = { b: { y: 20 }, c: 3 };\n * const merged = objectMerge(obj1, obj2);\n * console.log(merged); // { a: 1, b: { x: 10, y: 20 }, c: 3 }\n * ```\n */\nexport function objectMerge(target: AnyObject | AnyArray, ...sources: (AnyObject | AnyArray)[]) {\n  return _objectMerge(\n    {\n      next() {\n        return true;\n      },\n      assign({ merge }) {\n        return merge();\n      },\n    },\n    target,\n    ...sources,\n  );\n}\n\n/**\n * 为对象设置默认值。如果目标对象中的属性为 `undefined`，则使用默认对象中的属性值。\n * 支持多个默认对象，优先级从左到右依次降低。\n * 如果目标对象中的属性已经是对象或数组，则递归地设置默认值。\n *\n * @param target - 目标对象或数组。\n * @param defaults - 默认对象或数组。\n * @returns 合并后的对象或数组。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: undefined };\n * const defaults = { a: 4, b: 2, c: 3 };\n * const result = objectDefaults(obj, defaults);\n * console.log(result); // { a: 1, b: 2, c: 3 }\n *\n * const obj2 = { a: 1, b: 2 };\n * const defaults2 = { a: 5, b: 3, c: 4 };\n * const result2 = objectDefaults(obj2, defaults2);\n * console.log(result2); // { a: 1, b: 2, c: 4 }\n *\n * const obj3 = { a: { x: 1 }, b: undefined };\n * const defaults3 = { a: { x: 4, z: 3 }, b: { y: 2 } };\n * const result3 = objectDefaults(obj3, defaults3);\n * console.log(result3); // { a: { x: 1, z: 3 }, b: { y: 2 } }\n * ```\n */\nexport function objectDefaults<T extends AnyObject | AnyArray>(target: T, defaults: T): T {\n  return _objectMerge(\n    {\n      next({ target, source, key }) {\n        // @ts-expect-error\n        return target[key] === undefined || isObject(target[key]) || isArray(target[key]);\n      },\n      assign({ merge }) {\n        return merge();\n      },\n    },\n    target,\n    defaults,\n  ) as T;\n}\n"],"names":["target","typeIs","each","isObject","objectEach","isArray"],"mappings":";;;AAmCA,SAAS,aAAa,WAA6B,WAAiC,SAAmC;AAC/G,QAAA,2BAAW,QAAoD;AAC/D,QAAA,EAAE,QAAQ,KAAA,IAAS;AACnB,QAAA,QAAQ,CAACA,SAA8B,WAAiC;AACtE,UAAA,aAAaC,YAAOD,OAAM;AAC1B,UAAA,aAAaC,YAAO,MAAM;AAEhC,QAAI,eAAe,YAAY;AACtBD,aAAAA;AAAAA,IAAA;AAGT,WAAO,eAAe,UAAU,CAAA,IAAK,CAAC;AAAA,EACxC;AAEM,QAAAE,SAAO,CAAC,QAA8B,aAAuD;AAC7F,QAAAC,KAAAA,SAAS,MAAM,GAAG;AACpBC,WAAA,WAAW,QAAQ,QAAQ;AAAA,IAAA,OACtB;AACL,aAAO,QAAQ,QAAQ;AAAA,IAAA;AAAA,EAE3B;AAEM,QAAA,QAAQ,CAACJ,SAA8B,WAAuD;AAE9F,QAAA,KAAK,IAAI,MAAM,GAAG;AAEb,aAAA,KAAK,IAAI,MAAM;AAAA,IAAA;AAIlB,UAAA,SAAS,MAAMA,SAAQ,MAAM;AAG9B,SAAA,IAAI,QAAQ,MAAM;AAGlBE,WAAA,QAAQ,CAAC,OAAO,QAAQ;AACvB,UAAA,CAAC,KAAK,EAAE,QAAQ,QAAQ,QAAQ,IAAA,CAAK,GAAG;AAC1C;AAAA,MAAA;AAGF,UAAIC,KAAS,SAAA,KAAK,KAAKE,KAAA,QAAQ,KAAK,GAAG;AAE9B,eAAA,GAAG,IAAI,OAAO;AAAA,UACnB,QAAQ;AAAA,UACR;AAAA,UACA;AAAA;AAAA,UAEA,OAAO,MAAM,MAAM,OAAO,GAAG,GAAG,KAAK;AAAA,QAAA,CACtC;AAAA,MAAA,OACI;AAEE,eAAA,GAAG,IAAI,OAAO;AAAA,UACnB,QAAQ;AAAA,UACR;AAAA,UACA;AAAA,UACA,OAAO,MAAM;AAAA,QAAA,CACd;AAAA,MAAA;AAAA,IACH,CACD;AAEM,WAAA;AAAA,EACT;AAEA,MAAI,eAAe;AAEnB,aAAW,UAAU,SAAS;AACb,mBAAA,MAAM,QAAQ,MAAM;AAAA,EAAA;AAG9B,SAAA;AACT;AAiBgB,SAAA,YAAY,WAAiC,SAAmC;AACvF,SAAA;AAAA,IACL;AAAA,MACE,OAAO;AACE,eAAA;AAAA,MACT;AAAA,MACA,OAAO,EAAE,SAAS;AAChB,eAAO,MAAM;AAAA,MAAA;AAAA,IAEjB;AAAA,IACA;AAAA,IACA,GAAG;AAAA,EACL;AACF;AA6BgB,SAAA,eAA+C,QAAW,UAAgB;AACjF,SAAA;AAAA,IACL;AAAA,MACE,KAAK,EAAE,QAAAL,SAAQ,QAAQ,OAAO;AAE5B,eAAOA,QAAO,GAAG,MAAM,UAAaG,KAAAA,SAASH,QAAO,GAAG,CAAC,KAAKK,KAAAA,QAAQL,QAAO,GAAG,CAAC;AAAA,MAClF;AAAA,MACA,OAAO,EAAE,SAAS;AAChB,eAAO,MAAM;AAAA,MAAA;AAAA,IAEjB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;;;"}

package/dist/merge.mjs

@@ -0,0 +1,88 @@
+import { typeIs, isObject, isArray } from "./type.mjs";
+import { o as objectEach } from "./each.mjs";
+function _objectMerge(mergeRule, target, ...sources) {
+  const seen = /* @__PURE__ */ new WeakMap();
+  const { assign, next } = mergeRule;
+  const align = (target2, source) => {
+    const targetType = typeIs(target2);
+    const sourceType = typeIs(source);
+    if (targetType === sourceType) {
+      return target2;
+    }
+    return sourceType === "array" ? [] : {};
+  };
+  const each = (source, iterator) => {
+    if (isObject(source)) {
+      objectEach(source, iterator);
+    } else {
+      source.forEach(iterator);
+    }
+  };
+  const merge = (target2, source) => {
+    if (seen.has(source)) {
+      return seen.get(source);
+    }
+    const merged = align(target2, source);
+    seen.set(source, merged);
+    each(source, (value, key) => {
+      if (!next({ target: merged, source, key })) {
+        return;
+      }
+      if (isObject(value) || isArray(value)) {
+        merged[key] = assign({
+          target: merged,
+          source,
+          key,
+          // @ts-expect-error
+          merge: () => merge(merged[key], value)
+        });
+      } else {
+        merged[key] = assign({
+          target: merged,
+          source,
+          key,
+          merge: () => value
+        });
+      }
+    });
+    return merged;
+  };
+  let returnTarget = target;
+  for (const source of sources) {
+    returnTarget = merge(target, source);
+  }
+  return returnTarget;
+}
+function objectMerge(target, ...sources) {
+  return _objectMerge(
+    {
+      next() {
+        return true;
+      },
+      assign({ merge }) {
+        return merge();
+      }
+    },
+    target,
+    ...sources
+  );
+}
+function objectDefaults(target, defaults) {
+  return _objectMerge(
+    {
+      next({ target: target2, source, key }) {
+        return target2[key] === void 0 || isObject(target2[key]) || isArray(target2[key]);
+      },
+      assign({ merge }) {
+        return merge();
+      }
+    },
+    target,
+    defaults
+  );
+}
+export {
+  objectMerge as a,
+  objectDefaults as o
+};
+//# sourceMappingURL=merge.mjs.map

package/dist/merge.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.mjs","sources":["../src/object/merge.ts"],"sourcesContent":["import { isArray, isObject, typeIs } from '@/type';\nimport type { AnyArray, AnyObject } from '@/types';\nimport { objectEach } from './each';\n\nexport type TObjectMergeRule = {\n  /**\n   * 处理冲突\n   * @param target - 目标对象\n   * @param source - 源对象\n   * @param key - 键名\n   * @returns 返回 true 表示继续处理，否则返回 false\n   */\n  next: (info: {\n    target: AnyObject | AnyArray;\n    source: AnyObject | AnyArray;\n    key: string | number;\n  }) => boolean;\n\n  /**\n   * 处理赋值\n   * @param target - 目标对象\n   * @param source - 源对象\n   * @param key - 键名\n   * @returns 返回处理后的值\n   */\n  assign: (info: {\n    target: AnyObject | AnyArray;\n    source: AnyObject | AnyArray;\n    key: string | number;\n    // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n    merge: () => any;\n    // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n  }) => any;\n};\n\nfunction _objectMerge(mergeRule: TObjectMergeRule, target: AnyObject | AnyArray, ...sources: (AnyObject | AnyArray)[]) {\n  const seen = new WeakMap<AnyObject | AnyArray, AnyObject | AnyArray>();\n  const { assign, next } = mergeRule;\n  const align = (target: AnyObject | AnyArray, source: AnyObject | AnyArray) => {\n    const targetType = typeIs(target);\n    const sourceType = typeIs(source);\n\n    if (targetType === sourceType) {\n      return target;\n    }\n\n    return sourceType === 'array' ? [] : {};\n  };\n  // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n  const each = (source: AnyObject | AnyArray, iterator: (val: any, key: string | number) => void) => {\n    if (isObject(source)) {\n      objectEach(source, iterator);\n    } else {\n      source.forEach(iterator);\n    }\n  };\n\n  const merge = (target: AnyObject | AnyArray, source: AnyObject | AnyArray): AnyObject | AnyArray => {\n    // 如果循环引用了，则直接返回目标对象\n    if (seen.has(source)) {\n      // biome-ignore lint/style/noNonNullAssertion: <explanation>\n      return seen.get(source)!;\n    }\n\n    // 对齐目标对象和源对象\n    const merged = align(target, source);\n\n    // 存储循环引用\n    seen.set(source, merged);\n\n    // 遍历源对象\n    each(source, (value, key) => {\n      if (!next({ target: merged, source, key })) {\n        return;\n      }\n\n      if (isObject(value) || isArray(value)) {\n        // @ts-expect-error\n        merged[key] = assign({\n          target: merged,\n          source,\n          key,\n          // @ts-expect-error\n          merge: () => merge(merged[key], value),\n        });\n      } else {\n        // @ts-expect-error\n        merged[key] = assign({\n          target: merged,\n          source,\n          key,\n          merge: () => value,\n        });\n      }\n    });\n\n    return merged;\n  };\n\n  let returnTarget = target;\n\n  for (const source of sources) {\n    returnTarget = merge(target, source);\n  }\n\n  return returnTarget;\n}\n\n/**\n * 合并多个对象或数组。如果遇到循环引用，则直接返回目标对象。\n *\n * @param target - 目标对象或数组。\n * @param sources - 要合并的源对象或数组。\n * @returns 合并后的对象或数组。\n *\n * @example\n * ```typescript\n * const obj1 = { a: 1, b: { x: 10 } };\n * const obj2 = { b: { y: 20 }, c: 3 };\n * const merged = objectMerge(obj1, obj2);\n * console.log(merged); // { a: 1, b: { x: 10, y: 20 }, c: 3 }\n * ```\n */\nexport function objectMerge(target: AnyObject | AnyArray, ...sources: (AnyObject | AnyArray)[]) {\n  return _objectMerge(\n    {\n      next() {\n        return true;\n      },\n      assign({ merge }) {\n        return merge();\n      },\n    },\n    target,\n    ...sources,\n  );\n}\n\n/**\n * 为对象设置默认值。如果目标对象中的属性为 `undefined`，则使用默认对象中的属性值。\n * 支持多个默认对象，优先级从左到右依次降低。\n * 如果目标对象中的属性已经是对象或数组，则递归地设置默认值。\n *\n * @param target - 目标对象或数组。\n * @param defaults - 默认对象或数组。\n * @returns 合并后的对象或数组。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: undefined };\n * const defaults = { a: 4, b: 2, c: 3 };\n * const result = objectDefaults(obj, defaults);\n * console.log(result); // { a: 1, b: 2, c: 3 }\n *\n * const obj2 = { a: 1, b: 2 };\n * const defaults2 = { a: 5, b: 3, c: 4 };\n * const result2 = objectDefaults(obj2, defaults2);\n * console.log(result2); // { a: 1, b: 2, c: 4 }\n *\n * const obj3 = { a: { x: 1 }, b: undefined };\n * const defaults3 = { a: { x: 4, z: 3 }, b: { y: 2 } };\n * const result3 = objectDefaults(obj3, defaults3);\n * console.log(result3); // { a: { x: 1, z: 3 }, b: { y: 2 } }\n * ```\n */\nexport function objectDefaults<T extends AnyObject | AnyArray>(target: T, defaults: T): T {\n  return _objectMerge(\n    {\n      next({ target, source, key }) {\n        // @ts-expect-error\n        return target[key] === undefined || isObject(target[key]) || isArray(target[key]);\n      },\n      assign({ merge }) {\n        return merge();\n      },\n    },\n    target,\n    defaults,\n  ) as T;\n}\n"],"names":["target"],"mappings":";;AAmCA,SAAS,aAAa,WAA6B,WAAiC,SAAmC;AAC/G,QAAA,2BAAW,QAAoD;AAC/D,QAAA,EAAE,QAAQ,KAAA,IAAS;AACnB,QAAA,QAAQ,CAACA,SAA8B,WAAiC;AACtE,UAAA,aAAa,OAAOA,OAAM;AAC1B,UAAA,aAAa,OAAO,MAAM;AAEhC,QAAI,eAAe,YAAY;AACtBA,aAAAA;AAAAA,IAAA;AAGT,WAAO,eAAe,UAAU,CAAA,IAAK,CAAC;AAAA,EACxC;AAEM,QAAA,OAAO,CAAC,QAA8B,aAAuD;AAC7F,QAAA,SAAS,MAAM,GAAG;AACpB,iBAAW,QAAQ,QAAQ;AAAA,IAAA,OACtB;AACL,aAAO,QAAQ,QAAQ;AAAA,IAAA;AAAA,EAE3B;AAEM,QAAA,QAAQ,CAACA,SAA8B,WAAuD;AAE9F,QAAA,KAAK,IAAI,MAAM,GAAG;AAEb,aAAA,KAAK,IAAI,MAAM;AAAA,IAAA;AAIlB,UAAA,SAAS,MAAMA,SAAQ,MAAM;AAG9B,SAAA,IAAI,QAAQ,MAAM;AAGlB,SAAA,QAAQ,CAAC,OAAO,QAAQ;AACvB,UAAA,CAAC,KAAK,EAAE,QAAQ,QAAQ,QAAQ,IAAA,CAAK,GAAG;AAC1C;AAAA,MAAA;AAGF,UAAI,SAAS,KAAK,KAAK,QAAQ,KAAK,GAAG;AAE9B,eAAA,GAAG,IAAI,OAAO;AAAA,UACnB,QAAQ;AAAA,UACR;AAAA,UACA;AAAA;AAAA,UAEA,OAAO,MAAM,MAAM,OAAO,GAAG,GAAG,KAAK;AAAA,QAAA,CACtC;AAAA,MAAA,OACI;AAEE,eAAA,GAAG,IAAI,OAAO;AAAA,UACnB,QAAQ;AAAA,UACR;AAAA,UACA;AAAA,UACA,OAAO,MAAM;AAAA,QAAA,CACd;AAAA,MAAA;AAAA,IACH,CACD;AAEM,WAAA;AAAA,EACT;AAEA,MAAI,eAAe;AAEnB,aAAW,UAAU,SAAS;AACb,mBAAA,MAAM,QAAQ,MAAM;AAAA,EAAA;AAG9B,SAAA;AACT;AAiBgB,SAAA,YAAY,WAAiC,SAAmC;AACvF,SAAA;AAAA,IACL;AAAA,MACE,OAAO;AACE,eAAA;AAAA,MACT;AAAA,MACA,OAAO,EAAE,SAAS;AAChB,eAAO,MAAM;AAAA,MAAA;AAAA,IAEjB;AAAA,IACA;AAAA,IACA,GAAG;AAAA,EACL;AACF;AA6BgB,SAAA,eAA+C,QAAW,UAAgB;AACjF,SAAA;AAAA,IACL;AAAA,MACE,KAAK,EAAE,QAAAA,SAAQ,QAAQ,OAAO;AAE5B,eAAOA,QAAO,GAAG,MAAM,UAAa,SAASA,QAAO,GAAG,CAAC,KAAK,QAAQA,QAAO,GAAG,CAAC;AAAA,MAClF;AAAA,MACA,OAAO,EAAE,SAAS;AAChB,eAAO,MAAM;AAAA,MAAA;AAAA,IAEjB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;"}

package/dist/number.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./merge.cjs");
+const number = require("./string2.cjs");
+require("./type.cjs");
+exports.fileSizeAbbr = number.fileSizeAbbr;
+exports.numberAbbr = number.numberAbbr;
+exports.numberClamp = number.numberClamp;
+exports.numberConvert = number.numberConvert;
+exports.numberFixed = number.numberFixed;
+exports.numberFormat = number.numberFormat;
+exports.numberUnit = number.numberUnit;
+exports.randomNumber = number.randomNumber;
+//# sourceMappingURL=number.cjs.map

package/dist/number.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;"}