es-toolkit 1.13.1-dev.332 → 1.13.1-dev.333

package/dist/function/index.js

@@ -1,119 +1,83 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
 
-// src/function/index.ts
-var function_exports = {};
-__export(function_exports, {
-  after: () => after,
-  debounce: () => debounce,
-  negate: () => negate,
-  noop: () => noop,
-  once: () => once,
-  throttle: () => throttle
-});
-module.exports = __toCommonJS(function_exports);
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-// src/function/after.ts
-var after = (n, func) => {
-  if (!Number.isInteger(n) || n < 0) {
-    throw new Error(`n must be a non-negative integer.`);
-  }
-  let counter = 0;
-  return (...args) => {
-    if (++counter >= n) {
-      return func(...args);
+const after = (n, func) => {
+    if (!Number.isInteger(n) || n < 0) {
+        throw new Error(`n must be a non-negative integer.`);
     }
-    return void 0;
-  };
+    let counter = 0;
+    return ((...args) => {
+        if (++counter >= n) {
+            return func(...args);
+        }
+        return undefined;
+    });
 };
 
-// src/function/debounce.ts
 function debounce(func, debounceMs, { signal } = {}) {
-  let timeoutId = null;
-  const debounced = function(...args) {
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
-    }
-    if (signal?.aborted) {
-      return;
-    }
-    timeoutId = setTimeout(() => {
-      func(...args);
-      timeoutId = null;
-    }, debounceMs);
-  };
-  const onAbort = function() {
-    debounced.cancel();
-  };
-  debounced.cancel = function() {
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-    }
-  };
-  signal?.addEventListener("abort", onAbort, { once: true });
-  return debounced;
+    let timeoutId = null;
+    const debounced = function (...args) {
+        if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+        }
+        if (signal?.aborted) {
+            return;
+        }
+        timeoutId = setTimeout(() => {
+            func(...args);
+            timeoutId = null;
+        }, debounceMs);
+    };
+    const onAbort = function () {
+        debounced.cancel();
+    };
+    debounced.cancel = function () {
+        if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+        }
+    };
+    signal?.addEventListener('abort', onAbort, { once: true });
+    return debounced;
 }
 
-// src/function/noop.ts
-function noop() {
-}
+function noop() { }
 
-// src/function/once.ts
 function once(func) {
-  let called = false;
-  let cache;
-  return function() {
-    if (called) {
-      return cache;
-    }
-    const result = func();
-    called = true;
-    cache = result;
-    return result;
-  };
+    let called = false;
+    let cache;
+    return function () {
+        if (called) {
+            return cache;
+        }
+        const result = func();
+        called = true;
+        cache = result;
+        return result;
+    };
 }
 
-// src/function/throttle.ts
 function throttle(func, throttleMs) {
-  let lastCallTime;
-  const throttledFunction = function(...args) {
-    const now = Date.now();
-    if (lastCallTime == null || now - lastCallTime >= throttleMs) {
-      lastCallTime = now;
-      func(...args);
-    }
-  };
-  return throttledFunction;
+    let lastCallTime;
+    const throttledFunction = function (...args) {
+        const now = Date.now();
+        if (lastCallTime == null || now - lastCallTime >= throttleMs) {
+            lastCallTime = now;
+            func(...args);
+        }
+    };
+    return throttledFunction;
 }
 
-// src/function/negate.ts
 function negate(func) {
-  return (...args) => !func(...args);
+    return ((...args) => !func(...args));
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  after,
-  debounce,
-  negate,
-  noop,
-  once,
-  throttle
-});
-//# sourceMappingURL=index.js.map
+
+exports.after = after;
+exports.debounce = debounce;
+exports.negate = negate;
+exports.noop = noop;
+exports.once = once;
+exports.throttle = throttle;
+//# sourceMappingURL=index.js.map

package/dist/function/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/function/index.ts","../../src/function/after.ts","../../src/function/debounce.ts","../../src/function/noop.ts","../../src/function/once.ts","../../src/function/throttle.ts","../../src/function/negate.ts"],"sourcesContent":["export { after } from './after.ts';\nexport { debounce } from './debounce.ts';\nexport { noop } from './noop.ts';\nexport { once } from './once.ts';\nexport { throttle } from './throttle.ts';\nexport { negate } from './negate.ts';\n","/**\n * Creates a function that only executes starting from the `n`-th call.\n * The provided function will be invoked starting from the `n`-th call.\n *\n * This is particularly useful for scenarios involving events or asynchronous operations\n * where an action should occur only after a certain number of invocations.\n *\n * @template F - The type of the function to be invoked.\n * @param {number} n - The number of calls required for `func` to execute.\n * @param {F} func - The function to be invoked.\n * @returns {F} - A new function that:\n * - Tracks the number of calls.\n * - Invokes `func` starting from the `n`-th call.\n * - Returns `undefined` if fewer than `n` calls have been made.\n * @throws {Error} - Throws an error if `n` is negative.\n * @example\n *\n * const afterFn = after(3, () => {\n *  console.log(\"called\")\n * });\n *\n * // Will not log anything.\n * afterFn()\n * // Will not log anything.\n * afterFn()\n * // Will log 'called'.\n * afterFn()\n */\n\nexport const after = <F extends (...args: any[]) => any>(n: number, func: F): F => {\n  if (!Number.isInteger(n) || n < 0) {\n    throw new Error(`n must be a non-negative integer.`);\n  }\n\n  let counter = 0;\n  return ((...args: Parameters<F>) => {\n    if (++counter >= n) {\n      return func(...args);\n    }\n    return undefined;\n  }) as F;\n};\n","interface DebounceOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds\n * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`\n * method to cancel any pending execution.\n *\n * @template F - The type of function.\n * @param {F} func - The function to debounce.\n * @param {number} debounceMs - The number of milliseconds to delay.\n * @param {DebounceOptions} options - The options object.\n * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.\n * @returns {F & { cancel: () => void }} A new debounced function with a `cancel` method.\n *\n * @example\n * const debouncedFunction = debounce(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' after 1 second if not called again in that time\n * debouncedFunction();\n *\n * // Will not log anything as the previous call is canceled\n * debouncedFunction.cancel();\n *\n * // With AbortSignal\n * const controller = new AbortController();\n * const signal = controller.signal;\n * const debouncedWithSignal = debounce(() => {\n *  console.log('Function executed');\n * }, 1000, { signal });\n *\n * debouncedWithSignal();\n *\n * // Will cancel the debounced function call\n * controller.abort();\n */\nexport function debounce<F extends (...args: any[]) => void>(\n  func: F,\n  debounceMs: number,\n  { signal }: DebounceOptions = {}\n): F & { cancel: () => void } {\n  let timeoutId: ReturnType<typeof setTimeout> | null = null;\n\n  const debounced = function (...args: Parameters<F>) {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n    }\n\n    if (signal?.aborted) {\n      return;\n    }\n\n    timeoutId = setTimeout(() => {\n      func(...args);\n      timeoutId = null;\n    }, debounceMs) ;\n  } as F & { cancel: () => void };\n\n  const onAbort = function () {\n    debounced.cancel();\n  };\n\n  debounced.cancel = function () {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n  };\n\n  signal?.addEventListener('abort', onAbort, { once: true });\n\n  return debounced;\n}\n","/**\n * A no-operation function that does nothing.\n * This can be used as a placeholder or default function.\n *\n * @example\n * noop(); // Does nothing\n *\n * @returns {void} This function does not return anything.\n */\nexport function noop(): void {}\n","/**\n * Creates a function that is restricted to invoking the provided function `func` once.\n * Repeated calls to the function will return the value from the first invocation.\n *\n * @template F - The type of function.\n * @param {F} func - The function to restrict.\n * @returns {F} A new function that invokes `func` once and caches the result.\n *\n * @example\n * const initialize = once(() => {\n *   console.log('Initialized!');\n *   return true;\n * });\n *\n * initialize(); // Logs: 'Initialized!' and returns true\n * initialize(); // Returns true without logging\n */\nexport function once<F extends () => any>(func: F): F {\n  let called = false;\n  let cache: ReturnType<F> | undefined;\n\n  return function () {\n    if (called) {\n      return cache;\n    }\n\n    const result = func();\n\n    called = true;\n    cache = result;\n\n    return result;\n  } as F;\n}\n","/**\n * Creates a throttled function that only invokes the provided function at most once\n * per every `throttleMs` milliseconds. Subsequent calls to the throttled function\n * within the wait time will not trigger the execution of the original function.\n *\n * @template F - The type of function.\n * @param {F} func - The function to throttle.\n * @param {number} throttleMs - The number of milliseconds to throttle executions to.\n * @returns {F} A new throttled function that accepts the same parameters as the original function.\n *\n * @example\n * const throttledFunction = throttle(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' immediately\n * throttledFunction();\n *\n * // Will not log anything as it is within the throttle time\n * throttledFunction();\n *\n * // After 1 second\n * setTimeout(() => {\n *   throttledFunction(); // Will log 'Function executed'\n * }, 1000);\n */\nexport function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number): F {\n  let lastCallTime: number | null;\n\n  const throttledFunction = function (...args: Parameters<F>) {\n    const now = Date.now();\n\n    if (lastCallTime == null || now - lastCallTime >= throttleMs) {\n      lastCallTime = now;\n      func(...args);\n    }\n  } as F;\n\n  return throttledFunction;\n}\n","/**\n * Creates a function that negates the result of the predicate function.\n *\n * @template F - The type of the function to negate.\n * @param {F} func - The function to negate.\n * @returns {F} The new negated function, which negates the boolean result of `func`.\n */\nexport function negate<F extends (...args: unknown[]) => boolean>(func: F): F {\n    return ((...args: any[]) => !func(...args)) as F;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;AC6BO,IAAM,QAAQ,CAAoC,GAAW,SAAe;AACjF,MAAI,CAAC,OAAO,UAAU,CAAC,KAAK,IAAI,GAAG;AACjC,UAAM,IAAI,MAAM,mCAAmC;AAAA,EACrD;AAEA,MAAI,UAAU;AACd,SAAQ,IAAI,SAAwB;AAClC,QAAI,EAAE,WAAW,GAAG;AAClB,aAAO,KAAK,GAAG,IAAI;AAAA,IACrB;AACA,WAAO;AAAA,EACT;AACF;;;ACFO,SAAS,SACd,MACA,YACA,EAAE,OAAO,IAAqB,CAAC,GACH;AAC5B,MAAI,YAAkD;AAEtD,QAAM,YAAY,YAAa,MAAqB;AAClD,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AAAA,IACxB;AAEA,QAAI,QAAQ,SAAS;AACnB;AAAA,IACF;AAEA,gBAAY,WAAW,MAAM;AAC3B,WAAK,GAAG,IAAI;AACZ,kBAAY;AAAA,IACd,GAAG,UAAU;AAAA,EACf;AAEA,QAAM,UAAU,WAAY;AAC1B,cAAU,OAAO;AAAA,EACnB;AAEA,YAAU,SAAS,WAAY;AAC7B,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AACtB,kBAAY;AAAA,IACd;AAAA,EACF;AAEA,UAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;AAEzD,SAAO;AACT;;;AClEO,SAAS,OAAa;AAAC;;;ACQvB,SAAS,KAA0B,MAAY;AACpD,MAAI,SAAS;AACb,MAAI;AAEJ,SAAO,WAAY;AACjB,QAAI,QAAQ;AACV,aAAO;AAAA,IACT;AAEA,UAAM,SAAS,KAAK;AAEpB,aAAS;AACT,YAAQ;AAER,WAAO;AAAA,EACT;AACF;;;ACPO,SAAS,SAA6C,MAAS,YAAuB;AAC3F,MAAI;AAEJ,QAAM,oBAAoB,YAAa,MAAqB;AAC1D,UAAM,MAAM,KAAK,IAAI;AAErB,QAAI,gBAAgB,QAAQ,MAAM,gBAAgB,YAAY;AAC5D,qBAAe;AACf,WAAK,GAAG,IAAI;AAAA,IACd;AAAA,EACF;AAEA,SAAO;AACT;;;AChCO,SAAS,OAAkD,MAAY;AAC1E,SAAQ,IAAI,SAAgB,CAAC,KAAK,GAAG,IAAI;AAC7C;","names":[]}
+{"version":3,"file":"index.js","sources":["../../src/function/after.ts","../../src/function/debounce.ts","../../src/function/noop.ts","../../src/function/once.ts","../../src/function/throttle.ts","../../src/function/negate.ts"],"sourcesContent":["/**\n * Creates a function that only executes starting from the `n`-th call.\n * The provided function will be invoked starting from the `n`-th call.\n *\n * This is particularly useful for scenarios involving events or asynchronous operations\n * where an action should occur only after a certain number of invocations.\n *\n * @template F - The type of the function to be invoked.\n * @param {number} n - The number of calls required for `func` to execute.\n * @param {F} func - The function to be invoked.\n * @returns {F} - A new function that:\n * - Tracks the number of calls.\n * - Invokes `func` starting from the `n`-th call.\n * - Returns `undefined` if fewer than `n` calls have been made.\n * @throws {Error} - Throws an error if `n` is negative.\n * @example\n *\n * const afterFn = after(3, () => {\n *  console.log(\"called\")\n * });\n *\n * // Will not log anything.\n * afterFn()\n * // Will not log anything.\n * afterFn()\n * // Will log 'called'.\n * afterFn()\n */\n\nexport const after = <F extends (...args: any[]) => any>(n: number, func: F): F => {\n  if (!Number.isInteger(n) || n < 0) {\n    throw new Error(`n must be a non-negative integer.`);\n  }\n\n  let counter = 0;\n  return ((...args: Parameters<F>) => {\n    if (++counter >= n) {\n      return func(...args);\n    }\n    return undefined;\n  }) as F;\n};\n","interface DebounceOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds\n * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`\n * method to cancel any pending execution.\n *\n * @template F - The type of function.\n * @param {F} func - The function to debounce.\n * @param {number} debounceMs - The number of milliseconds to delay.\n * @param {DebounceOptions} options - The options object.\n * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.\n * @returns {F & { cancel: () => void }} A new debounced function with a `cancel` method.\n *\n * @example\n * const debouncedFunction = debounce(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' after 1 second if not called again in that time\n * debouncedFunction();\n *\n * // Will not log anything as the previous call is canceled\n * debouncedFunction.cancel();\n *\n * // With AbortSignal\n * const controller = new AbortController();\n * const signal = controller.signal;\n * const debouncedWithSignal = debounce(() => {\n *  console.log('Function executed');\n * }, 1000, { signal });\n *\n * debouncedWithSignal();\n *\n * // Will cancel the debounced function call\n * controller.abort();\n */\nexport function debounce<F extends (...args: any[]) => void>(\n  func: F,\n  debounceMs: number,\n  { signal }: DebounceOptions = {}\n): F & { cancel: () => void } {\n  let timeoutId: ReturnType<typeof setTimeout> | null = null;\n\n  const debounced = function (...args: Parameters<F>) {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n    }\n\n    if (signal?.aborted) {\n      return;\n    }\n\n    timeoutId = setTimeout(() => {\n      func(...args);\n      timeoutId = null;\n    }, debounceMs) ;\n  } as F & { cancel: () => void };\n\n  const onAbort = function () {\n    debounced.cancel();\n  };\n\n  debounced.cancel = function () {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n  };\n\n  signal?.addEventListener('abort', onAbort, { once: true });\n\n  return debounced;\n}\n","/**\n * A no-operation function that does nothing.\n * This can be used as a placeholder or default function.\n *\n * @example\n * noop(); // Does nothing\n *\n * @returns {void} This function does not return anything.\n */\nexport function noop(): void {}\n","/**\n * Creates a function that is restricted to invoking the provided function `func` once.\n * Repeated calls to the function will return the value from the first invocation.\n *\n * @template F - The type of function.\n * @param {F} func - The function to restrict.\n * @returns {F} A new function that invokes `func` once and caches the result.\n *\n * @example\n * const initialize = once(() => {\n *   console.log('Initialized!');\n *   return true;\n * });\n *\n * initialize(); // Logs: 'Initialized!' and returns true\n * initialize(); // Returns true without logging\n */\nexport function once<F extends () => any>(func: F): F {\n  let called = false;\n  let cache: ReturnType<F> | undefined;\n\n  return function () {\n    if (called) {\n      return cache;\n    }\n\n    const result = func();\n\n    called = true;\n    cache = result;\n\n    return result;\n  } as F;\n}\n","/**\n * Creates a throttled function that only invokes the provided function at most once\n * per every `throttleMs` milliseconds. Subsequent calls to the throttled function\n * within the wait time will not trigger the execution of the original function.\n *\n * @template F - The type of function.\n * @param {F} func - The function to throttle.\n * @param {number} throttleMs - The number of milliseconds to throttle executions to.\n * @returns {F} A new throttled function that accepts the same parameters as the original function.\n *\n * @example\n * const throttledFunction = throttle(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' immediately\n * throttledFunction();\n *\n * // Will not log anything as it is within the throttle time\n * throttledFunction();\n *\n * // After 1 second\n * setTimeout(() => {\n *   throttledFunction(); // Will log 'Function executed'\n * }, 1000);\n */\nexport function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number): F {\n  let lastCallTime: number | null;\n\n  const throttledFunction = function (...args: Parameters<F>) {\n    const now = Date.now();\n\n    if (lastCallTime == null || now - lastCallTime >= throttleMs) {\n      lastCallTime = now;\n      func(...args);\n    }\n  } as F;\n\n  return throttledFunction;\n}\n","/**\n * Creates a function that negates the result of the predicate function.\n *\n * @template F - The type of the function to negate.\n * @param {F} func - The function to negate.\n * @returns {F} The new negated function, which negates the boolean result of `func`.\n */\nexport function negate<F extends (...args: unknown[]) => boolean>(func: F): F {\n    return ((...args: any[]) => !func(...args)) as F;\n}\n"],"names":[],"mappings":";;;;MA6Ba,KAAK,GAAG,CAAoC,CAAS,EAAE,IAAO,KAAO;AAChF,IAAA,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;AACjC,QAAA,MAAM,IAAI,KAAK,CAAC,CAAA,iCAAA,CAAmC,CAAC,CAAC;KACtD;IAED,IAAI,OAAO,GAAG,CAAC,CAAC;AAChB,IAAA,QAAQ,CAAC,GAAG,IAAmB,KAAI;AACjC,QAAA,IAAI,EAAE,OAAO,IAAI,CAAC,EAAE;AAClB,YAAA,OAAO,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;SACtB;AACD,QAAA,OAAO,SAAS,CAAC;AACnB,KAAC,EAAO;AACV;;ACFM,SAAU,QAAQ,CACtB,IAAO,EACP,UAAkB,EAClB,EAAE,MAAM,EAAA,GAAsB,EAAE,EAAA;IAEhC,IAAI,SAAS,GAAyC,IAAI,CAAC;AAE3D,IAAA,MAAM,SAAS,GAAG,UAAU,GAAG,IAAmB,EAAA;AAChD,QAAA,IAAI,SAAS,KAAK,IAAI,EAAE;YACtB,YAAY,CAAC,SAAS,CAAC,CAAC;SACzB;AAED,QAAA,IAAI,MAAM,EAAE,OAAO,EAAE;YACnB,OAAO;SACR;AAED,QAAA,SAAS,GAAG,UAAU,CAAC,MAAK;AAC1B,YAAA,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;YACd,SAAS,GAAG,IAAI,CAAC;SAClB,EAAE,UAAU,CAAC,CAAE;AAClB,KAA+B,CAAC;AAEhC,IAAA,MAAM,OAAO,GAAG,YAAA;QACd,SAAS,CAAC,MAAM,EAAE,CAAC;AACrB,KAAC,CAAC;IAEF,SAAS,CAAC,MAAM,GAAG,YAAA;AACjB,QAAA,IAAI,SAAS,KAAK,IAAI,EAAE;YACtB,YAAY,CAAC,SAAS,CAAC,CAAC;YACxB,SAAS,GAAG,IAAI,CAAC;SAClB;AACH,KAAC,CAAC;AAEF,IAAA,MAAM,EAAE,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;AAE3D,IAAA,OAAO,SAAS,CAAC;AACnB;;AClEM,SAAU,IAAI,GAAA;;ACQd,SAAU,IAAI,CAAsB,IAAO,EAAA;IAC/C,IAAI,MAAM,GAAG,KAAK,CAAC;AACnB,IAAA,IAAI,KAAgC,CAAC;IAErC,OAAO,YAAA;QACL,IAAI,MAAM,EAAE;AACV,YAAA,OAAO,KAAK,CAAC;SACd;AAED,QAAA,MAAM,MAAM,GAAG,IAAI,EAAE,CAAC;QAEtB,MAAM,GAAG,IAAI,CAAC;QACd,KAAK,GAAG,MAAM,CAAC;AAEf,QAAA,OAAO,MAAM,CAAC;AAChB,KAAM,CAAC;AACT;;ACPgB,SAAA,QAAQ,CAAqC,IAAO,EAAE,UAAkB,EAAA;AACtF,IAAA,IAAI,YAA2B,CAAC;AAEhC,IAAA,MAAM,iBAAiB,GAAG,UAAU,GAAG,IAAmB,EAAA;AACxD,QAAA,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAEvB,IAAI,YAAY,IAAI,IAAI,IAAI,GAAG,GAAG,YAAY,IAAI,UAAU,EAAE;YAC5D,YAAY,GAAG,GAAG,CAAC;AACnB,YAAA,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;SACf;AACH,KAAM,CAAC;AAEP,IAAA,OAAO,iBAAiB,CAAC;AAC3B;;AChCM,SAAU,MAAM,CAA4C,IAAO,EAAA;AACrE,IAAA,QAAQ,CAAC,GAAG,IAAW,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,EAAO;AACrD;;;;;;;;;"}

package/dist/function/index.mjs

@@ -1,29 +1,7 @@
-import "../chunk-ZA2XI3OV.mjs";
-import {
-  negate
-} from "../chunk-BOOQBJN2.mjs";
-import {
-  noop
-} from "../chunk-LKXCOLNY.mjs";
-import {
-  once
-} from "../chunk-CMBC4MXG.mjs";
-import {
-  throttle
-} from "../chunk-QOJGMVVR.mjs";
-import {
-  after
-} from "../chunk-OGZMEWPR.mjs";
-import {
-  debounce
-} from "../chunk-5F26PFZL.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  after,
-  debounce,
-  negate,
-  noop,
-  once,
-  throttle
-};
-//# sourceMappingURL=index.mjs.map
+export { after } from './after.mjs';
+export { debounce } from './debounce.mjs';
+export { noop } from './noop.mjs';
+export { once } from './once.mjs';
+export { throttle } from './throttle.mjs';
+export { negate } from './negate.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/function/index.mjs.map

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

package/dist/function/negate.mjs

@@ -1,8 +1,6 @@
-import {
-  negate
-} from "../chunk-BOOQBJN2.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  negate
-};
-//# sourceMappingURL=negate.mjs.map
+function negate(func) {
+    return ((...args) => !func(...args));
+}
+
+export { negate };
+//# sourceMappingURL=negate.mjs.map

package/dist/function/negate.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"negate.mjs","sources":["../../src/function/negate.ts"],"sourcesContent":["/**\n * Creates a function that negates the result of the predicate function.\n *\n * @template F - The type of the function to negate.\n * @param {F} func - The function to negate.\n * @returns {F} The new negated function, which negates the boolean result of `func`.\n */\nexport function negate<F extends (...args: unknown[]) => boolean>(func: F): F {\n    return ((...args: any[]) => !func(...args)) as F;\n}\n"],"names":[],"mappings":"AAOM,SAAU,MAAM,CAA4C,IAAO,EAAA;AACrE,IAAA,QAAQ,CAAC,GAAG,IAAW,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,EAAO;AACrD;;;;"}

package/dist/function/noop.mjs

@@ -1,8 +1,4 @@
-import {
-  noop
-} from "../chunk-LKXCOLNY.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  noop
-};
-//# sourceMappingURL=noop.mjs.map
+function noop() { }
+
+export { noop };
+//# sourceMappingURL=noop.mjs.map

package/dist/function/noop.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"noop.mjs","sources":["../../src/function/noop.ts"],"sourcesContent":["/**\n * A no-operation function that does nothing.\n * This can be used as a placeholder or default function.\n *\n * @example\n * noop(); // Does nothing\n *\n * @returns {void} This function does not return anything.\n */\nexport function noop(): void {}\n"],"names":[],"mappings":"AASM,SAAU,IAAI,GAAA;;;;"}

package/dist/function/once.mjs

@@ -1,8 +1,16 @@
-import {
-  once
-} from "../chunk-CMBC4MXG.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  once
-};
-//# sourceMappingURL=once.mjs.map
+function once(func) {
+    let called = false;
+    let cache;
+    return function () {
+        if (called) {
+            return cache;
+        }
+        const result = func();
+        called = true;
+        cache = result;
+        return result;
+    };
+}
+
+export { once };
+//# sourceMappingURL=once.mjs.map

package/dist/function/once.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"once.mjs","sources":["../../src/function/once.ts"],"sourcesContent":["/**\n * Creates a function that is restricted to invoking the provided function `func` once.\n * Repeated calls to the function will return the value from the first invocation.\n *\n * @template F - The type of function.\n * @param {F} func - The function to restrict.\n * @returns {F} A new function that invokes `func` once and caches the result.\n *\n * @example\n * const initialize = once(() => {\n *   console.log('Initialized!');\n *   return true;\n * });\n *\n * initialize(); // Logs: 'Initialized!' and returns true\n * initialize(); // Returns true without logging\n */\nexport function once<F extends () => any>(func: F): F {\n  let called = false;\n  let cache: ReturnType<F> | undefined;\n\n  return function () {\n    if (called) {\n      return cache;\n    }\n\n    const result = func();\n\n    called = true;\n    cache = result;\n\n    return result;\n  } as F;\n}\n"],"names":[],"mappings":"AAiBM,SAAU,IAAI,CAAsB,IAAO,EAAA;IAC/C,IAAI,MAAM,GAAG,KAAK,CAAC;AACnB,IAAA,IAAI,KAAgC,CAAC;IAErC,OAAO,YAAA;QACL,IAAI,MAAM,EAAE;AACV,YAAA,OAAO,KAAK,CAAC;SACd;AAED,QAAA,MAAM,MAAM,GAAG,IAAI,EAAE,CAAC;QAEtB,MAAM,GAAG,IAAI,CAAC;QACd,KAAK,GAAG,MAAM,CAAC;AAEf,QAAA,OAAO,MAAM,CAAC;AAChB,KAAM,CAAC;AACT;;;;"}

package/dist/function/throttle.mjs

@@ -1,8 +1,14 @@
-import {
-  throttle
-} from "../chunk-QOJGMVVR.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  throttle
-};
-//# sourceMappingURL=throttle.mjs.map
+function throttle(func, throttleMs) {
+    let lastCallTime;
+    const throttledFunction = function (...args) {
+        const now = Date.now();
+        if (lastCallTime == null || now - lastCallTime >= throttleMs) {
+            lastCallTime = now;
+            func(...args);
+        }
+    };
+    return throttledFunction;
+}
+
+export { throttle };
+//# sourceMappingURL=throttle.mjs.map

package/dist/function/throttle.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"throttle.mjs","sources":["../../src/function/throttle.ts"],"sourcesContent":["/**\n * Creates a throttled function that only invokes the provided function at most once\n * per every `throttleMs` milliseconds. Subsequent calls to the throttled function\n * within the wait time will not trigger the execution of the original function.\n *\n * @template F - The type of function.\n * @param {F} func - The function to throttle.\n * @param {number} throttleMs - The number of milliseconds to throttle executions to.\n * @returns {F} A new throttled function that accepts the same parameters as the original function.\n *\n * @example\n * const throttledFunction = throttle(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' immediately\n * throttledFunction();\n *\n * // Will not log anything as it is within the throttle time\n * throttledFunction();\n *\n * // After 1 second\n * setTimeout(() => {\n *   throttledFunction(); // Will log 'Function executed'\n * }, 1000);\n */\nexport function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number): F {\n  let lastCallTime: number | null;\n\n  const throttledFunction = function (...args: Parameters<F>) {\n    const now = Date.now();\n\n    if (lastCallTime == null || now - lastCallTime >= throttleMs) {\n      lastCallTime = now;\n      func(...args);\n    }\n  } as F;\n\n  return throttledFunction;\n}\n"],"names":[],"mappings":"AA0BgB,SAAA,QAAQ,CAAqC,IAAO,EAAE,UAAkB,EAAA;AACtF,IAAA,IAAI,YAA2B,CAAC;AAEhC,IAAA,MAAM,iBAAiB,GAAG,UAAU,GAAG,IAAmB,EAAA;AACxD,QAAA,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAEvB,IAAI,YAAY,IAAI,IAAI,IAAI,GAAG,GAAG,YAAY,IAAI,UAAU,EAAE;YAC5D,YAAY,GAAG,GAAG,CAAC;AACnB,YAAA,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;SACf;AACH,KAAM,CAAC;AAEP,IAAA,OAAO,iBAAiB,CAAC;AAC3B;;;;"}