@vielzeug/toolkit 1.0.12 → 1.0.13

package/dist/function/memo.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"memo.cjs","sources":["../../src/function/memo.ts"],"sourcesContent":["/** biome-ignore-all lint/suspicious/noExplicitAny: - */\nimport type { Fn } from '../types';\n\ntype MemoizeOptions = {\n  ttl?: number; // Time-to-live in milliseconds\n  maxSize?: number; // Maximum number of items in cache\n};\n\ntype CacheEntry<T extends Fn> = {\n  value: ReturnType<T>;\n  timestamp: number;\n};\n\n/**\n * Creates a function that memorizes the result of the provided function.\n * Supports expiration (TTL) and limited cache size (LRU).\n *\n * @example\n * ```ts\n * const add = (x, y) => x + y;\n * const memoizedAdd = memo(add, { ttl: 5000, maxSize: 10 });\n *\n * memoizedAdd(1, 2); // 3 (caches the result)\n * memoizedAdd(1, 2); // 3 (from cache)\n * ```\n *\n * @param fn - The function to memorize.\n * @param options - Memoization options.\n * @param [options.ttl] - (optional) time-to-live (TTL) for cache expiration (in milliseconds).\n * @param [options.maxSize] - (optional) maximum cache size (LRU eviction).\n *\n * @returns A new function that memorizes the input function.\n */\nexport function memo<T extends Fn>(\n  fn: T,\n  { ttl, maxSize }: MemoizeOptions = {},\n): (...args: Parameters<T>) => ReturnType<T> {\n  const cache = new Map<string, CacheEntry<T>>();\n\n  const keyGen = (args: Parameters<T>): string => {\n    if (args.length === 0) return '__empty__';\n    if (args.length === 1) {\n      const arg = args[0];\n      const argType = typeof arg;\n      if (argType === 'string' || argType === 'number' || argType === 'boolean') {\n        return `${argType}:${arg}`;\n      }\n      if (arg === null) return 'null';\n      if (arg === undefined) return 'undefined';\n    }\n    return JSON.stringify(args);\n  };\n\n  return (...args: Parameters<T>): ReturnType<T> => {\n    const key = keyGen(args);\n    const now = Date.now();\n    const cached = cache.get(key);\n\n    if (cached && (!ttl || now - cached.timestamp < ttl)) {\n      cache.delete(key);\n      cache.set(key, cached); // Move to end (most recently used)\n      return cached.value;\n    }\n\n    const result = fn(...args);\n    cache.set(key, { timestamp: now, value: result });\n\n    if (maxSize && cache.size > maxSize) {\n      cache.delete(cache.keys().next().value!); // Remove least recently used\n    }\n\n    return result;\n  };\n}\n"],"names":["memo","fn","ttl","maxSize","cache","keyGen","args","arg","argType","key","now","cached","result"],"mappings":"gFAiCO,SAASA,EACdC,EACA,CAAE,IAAAC,EAAK,QAAAC,CAAA,EAA4B,CAAA,EACQ,CAC3C,MAAMC,MAAY,IAEZC,EAAUC,GAAgC,CAC9C,GAAIA,EAAK,SAAW,EAAG,MAAO,YAC9B,GAAIA,EAAK,SAAW,EAAG,CACrB,MAAMC,EAAMD,EAAK,CAAC,EACZE,EAAU,OAAOD,EACvB,GAAIC,IAAY,UAAYA,IAAY,UAAYA,IAAY,UAC9D,MAAO,GAAGA,CAAO,IAAID,CAAG,GAE1B,GAAIA,IAAQ,KAAM,MAAO,OACzB,GAAIA,IAAQ,OAAW,MAAO,WAChC,CACA,OAAO,KAAK,UAAUD,CAAI,CAC5B,EAEA,MAAO,IAAIA,IAAuC,CAChD,MAAMG,EAAMJ,EAAOC,CAAI,EACjBI,EAAM,KAAK,IAAA,EACXC,EAASP,EAAM,IAAIK,CAAG,EAE5B,GAAIE,IAAW,CAACT,GAAOQ,EAAMC,EAAO,UAAYT,GAC9C,OAAAE,EAAM,OAAOK,CAAG,EAChBL,EAAM,IAAIK,EAAKE,CAAM,EACdA,EAAO,MAGhB,MAAMC,EAASX,EAAG,GAAGK,CAAI,EACzB,OAAAF,EAAM,IAAIK,EAAK,CAAE,UAAWC,EAAK,MAAOE,EAAQ,EAE5CT,GAAWC,EAAM,KAAOD,GAC1BC,EAAM,OAAOA,EAAM,KAAA,EAAO,KAAA,EAAO,KAAM,EAGlCQ,CACT,CACF"}
+{"version":3,"file":"memo.cjs","sources":["../../src/function/memo.ts"],"sourcesContent":["/** biome-ignore-all lint/suspicious/noExplicitAny: - */\nimport type { Fn } from '../types';\n\ntype MemoizeOptions<T extends Fn> = {\n  ttl?: number; // Time-to-live in milliseconds\n  maxSize?: number; // Maximum number of items in cache\n  resolver?: (...args: Parameters<T>) => string; // Custom key generator\n};\n\ntype CacheEntry<T extends Fn> = {\n  value: ReturnType<T>;\n  timestamp: number;\n};\n\n/**\n * Creates a function that memorizes the result of the provided function.\n * Supports expiration (TTL) and limited cache size (LRU).\n *\n * @example\n * ```ts\n * const add = (x, y) => x + y;\n * const memoizedAdd = memo(add, { ttl: 5000, maxSize: 10 });\n *\n * memoizedAdd(1, 2); // 3 (caches the result)\n * memoizedAdd(1, 2); // 3 (from cache)\n * ```\n *\n * @param fn - The function to memorize.\n * @param options - Memoization options.\n * @param [options.ttl] - (optional) time-to-live (TTL) for cache expiration (in milliseconds).\n * @param [options.maxSize] - (optional) maximum cache size (LRU eviction).\n * @param [options.resolver] - (optional) custom function to resolve the cache key.\n *\n * @returns A new function that memorizes the input function.\n */\nexport function memo<T extends Fn>(\n  fn: T,\n  { ttl, maxSize, resolver }: MemoizeOptions<T> = {},\n): (...args: Parameters<T>) => ReturnType<T> {\n  const cache = new Map<string, CacheEntry<T>>();\n\n  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: -\n  const keyGen = (args: Parameters<T>): string => {\n    if (resolver) return resolver(...args);\n    if (args.length === 0) return '__empty__';\n    if (args.length === 1) {\n      const arg = args[0];\n      const argType = typeof arg;\n      if (argType === 'string' || argType === 'number' || argType === 'boolean') {\n        return `${argType}:${arg}`;\n      }\n      if (arg === null) return 'null';\n      if (arg === undefined) return 'undefined';\n    }\n    return JSON.stringify(args);\n  };\n\n  return (...args: Parameters<T>): ReturnType<T> => {\n    const key = keyGen(args);\n    const now = Date.now();\n    const cached = cache.get(key);\n\n    if (cached && (!ttl || now - cached.timestamp < ttl)) {\n      cache.delete(key);\n      cache.set(key, cached); // Move to end (most recently used)\n      return cached.value;\n    }\n\n    const result = fn(...args);\n    cache.set(key, { timestamp: now, value: result });\n\n    if (maxSize && cache.size > maxSize) {\n      cache.delete(cache.keys().next().value!); // Remove least recently used\n    }\n\n    return result;\n  };\n}\n"],"names":["memo","fn","ttl","maxSize","resolver","cache","keyGen","args","arg","argType","key","now","cached","result"],"mappings":"gFAmCO,SAASA,EACdC,EACA,CAAE,IAAAC,EAAK,QAAAC,EAAS,SAAAC,CAAA,EAAgC,GACL,CAC3C,MAAMC,MAAY,IAGZC,EAAUC,GAAgC,CAC9C,GAAIH,EAAU,OAAOA,EAAS,GAAGG,CAAI,EACrC,GAAIA,EAAK,SAAW,EAAG,MAAO,YAC9B,GAAIA,EAAK,SAAW,EAAG,CACrB,MAAMC,EAAMD,EAAK,CAAC,EACZE,EAAU,OAAOD,EACvB,GAAIC,IAAY,UAAYA,IAAY,UAAYA,IAAY,UAC9D,MAAO,GAAGA,CAAO,IAAID,CAAG,GAE1B,GAAIA,IAAQ,KAAM,MAAO,OACzB,GAAIA,IAAQ,OAAW,MAAO,WAChC,CACA,OAAO,KAAK,UAAUD,CAAI,CAC5B,EAEA,MAAO,IAAIA,IAAuC,CAChD,MAAMG,EAAMJ,EAAOC,CAAI,EACjBI,EAAM,KAAK,IAAA,EACXC,EAASP,EAAM,IAAIK,CAAG,EAE5B,GAAIE,IAAW,CAACV,GAAOS,EAAMC,EAAO,UAAYV,GAC9C,OAAAG,EAAM,OAAOK,CAAG,EAChBL,EAAM,IAAIK,EAAKE,CAAM,EACdA,EAAO,MAGhB,MAAMC,EAASZ,EAAG,GAAGM,CAAI,EACzB,OAAAF,EAAM,IAAIK,EAAK,CAAE,UAAWC,EAAK,MAAOE,EAAQ,EAE5CV,GAAWE,EAAM,KAAOF,GAC1BE,EAAM,OAAOA,EAAM,KAAA,EAAO,KAAA,EAAO,KAAM,EAGlCQ,CACT,CACF"}

package/dist/function/memo.js

@@ -1,24 +1,25 @@
-function f(s, { ttl: u, maxSize: i } = {}) {
-  const t = /* @__PURE__ */ new Map(), l = (n) => {
-    if (n.length === 0) return "__empty__";
-    if (n.length === 1) {
-      const e = n[0], r = typeof e;
+function m(l, { ttl: i, maxSize: o, resolver: c } = {}) {
+  const n = /* @__PURE__ */ new Map(), s = (t) => {
+    if (c) return c(...t);
+    if (t.length === 0) return "__empty__";
+    if (t.length === 1) {
+      const e = t[0], r = typeof e;
       if (r === "string" || r === "number" || r === "boolean")
         return `${r}:${e}`;
       if (e === null) return "null";
       if (e === void 0) return "undefined";
     }
-    return JSON.stringify(n);
+    return JSON.stringify(t);
   };
-  return (...n) => {
-    const e = l(n), r = Date.now(), o = t.get(e);
-    if (o && (!u || r - o.timestamp < u))
-      return t.delete(e), t.set(e, o), o.value;
-    const c = s(...n);
-    return t.set(e, { timestamp: r, value: c }), i && t.size > i && t.delete(t.keys().next().value), c;
+  return (...t) => {
+    const e = s(t), r = Date.now(), u = n.get(e);
+    if (u && (!i || r - u.timestamp < i))
+      return n.delete(e), n.set(e, u), u.value;
+    const f = l(...t);
+    return n.set(e, { timestamp: r, value: f }), o && n.size > o && n.delete(n.keys().next().value), f;
   };
 }
 export {
-  f as memo
+  m as memo
 };
 //# sourceMappingURL=memo.js.map

package/dist/function/memo.js.map

@@ -1 +1 @@
-{"version":3,"file":"memo.js","sources":["../../src/function/memo.ts"],"sourcesContent":["/** biome-ignore-all lint/suspicious/noExplicitAny: - */\nimport type { Fn } from '../types';\n\ntype MemoizeOptions = {\n  ttl?: number; // Time-to-live in milliseconds\n  maxSize?: number; // Maximum number of items in cache\n};\n\ntype CacheEntry<T extends Fn> = {\n  value: ReturnType<T>;\n  timestamp: number;\n};\n\n/**\n * Creates a function that memorizes the result of the provided function.\n * Supports expiration (TTL) and limited cache size (LRU).\n *\n * @example\n * ```ts\n * const add = (x, y) => x + y;\n * const memoizedAdd = memo(add, { ttl: 5000, maxSize: 10 });\n *\n * memoizedAdd(1, 2); // 3 (caches the result)\n * memoizedAdd(1, 2); // 3 (from cache)\n * ```\n *\n * @param fn - The function to memorize.\n * @param options - Memoization options.\n * @param [options.ttl] - (optional) time-to-live (TTL) for cache expiration (in milliseconds).\n * @param [options.maxSize] - (optional) maximum cache size (LRU eviction).\n *\n * @returns A new function that memorizes the input function.\n */\nexport function memo<T extends Fn>(\n  fn: T,\n  { ttl, maxSize }: MemoizeOptions = {},\n): (...args: Parameters<T>) => ReturnType<T> {\n  const cache = new Map<string, CacheEntry<T>>();\n\n  const keyGen = (args: Parameters<T>): string => {\n    if (args.length === 0) return '__empty__';\n    if (args.length === 1) {\n      const arg = args[0];\n      const argType = typeof arg;\n      if (argType === 'string' || argType === 'number' || argType === 'boolean') {\n        return `${argType}:${arg}`;\n      }\n      if (arg === null) return 'null';\n      if (arg === undefined) return 'undefined';\n    }\n    return JSON.stringify(args);\n  };\n\n  return (...args: Parameters<T>): ReturnType<T> => {\n    const key = keyGen(args);\n    const now = Date.now();\n    const cached = cache.get(key);\n\n    if (cached && (!ttl || now - cached.timestamp < ttl)) {\n      cache.delete(key);\n      cache.set(key, cached); // Move to end (most recently used)\n      return cached.value;\n    }\n\n    const result = fn(...args);\n    cache.set(key, { timestamp: now, value: result });\n\n    if (maxSize && cache.size > maxSize) {\n      cache.delete(cache.keys().next().value!); // Remove least recently used\n    }\n\n    return result;\n  };\n}\n"],"names":["memo","fn","ttl","maxSize","cache","keyGen","args","arg","argType","key","now","cached","result"],"mappings":"AAiCO,SAASA,EACdC,GACA,EAAE,KAAAC,GAAK,SAAAC,EAAA,IAA4B,CAAA,GACQ;AAC3C,QAAMC,wBAAY,IAAA,GAEZC,IAAS,CAACC,MAAgC;AAC9C,QAAIA,EAAK,WAAW,EAAG,QAAO;AAC9B,QAAIA,EAAK,WAAW,GAAG;AACrB,YAAMC,IAAMD,EAAK,CAAC,GACZE,IAAU,OAAOD;AACvB,UAAIC,MAAY,YAAYA,MAAY,YAAYA,MAAY;AAC9D,eAAO,GAAGA,CAAO,IAAID,CAAG;AAE1B,UAAIA,MAAQ,KAAM,QAAO;AACzB,UAAIA,MAAQ,OAAW,QAAO;AAAA,IAChC;AACA,WAAO,KAAK,UAAUD,CAAI;AAAA,EAC5B;AAEA,SAAO,IAAIA,MAAuC;AAChD,UAAMG,IAAMJ,EAAOC,CAAI,GACjBI,IAAM,KAAK,IAAA,GACXC,IAASP,EAAM,IAAIK,CAAG;AAE5B,QAAIE,MAAW,CAACT,KAAOQ,IAAMC,EAAO,YAAYT;AAC9C,aAAAE,EAAM,OAAOK,CAAG,GAChBL,EAAM,IAAIK,GAAKE,CAAM,GACdA,EAAO;AAGhB,UAAMC,IAASX,EAAG,GAAGK,CAAI;AACzB,WAAAF,EAAM,IAAIK,GAAK,EAAE,WAAWC,GAAK,OAAOE,GAAQ,GAE5CT,KAAWC,EAAM,OAAOD,KAC1BC,EAAM,OAAOA,EAAM,KAAA,EAAO,KAAA,EAAO,KAAM,GAGlCQ;AAAA,EACT;AACF;"}
+{"version":3,"file":"memo.js","sources":["../../src/function/memo.ts"],"sourcesContent":["/** biome-ignore-all lint/suspicious/noExplicitAny: - */\nimport type { Fn } from '../types';\n\ntype MemoizeOptions<T extends Fn> = {\n  ttl?: number; // Time-to-live in milliseconds\n  maxSize?: number; // Maximum number of items in cache\n  resolver?: (...args: Parameters<T>) => string; // Custom key generator\n};\n\ntype CacheEntry<T extends Fn> = {\n  value: ReturnType<T>;\n  timestamp: number;\n};\n\n/**\n * Creates a function that memorizes the result of the provided function.\n * Supports expiration (TTL) and limited cache size (LRU).\n *\n * @example\n * ```ts\n * const add = (x, y) => x + y;\n * const memoizedAdd = memo(add, { ttl: 5000, maxSize: 10 });\n *\n * memoizedAdd(1, 2); // 3 (caches the result)\n * memoizedAdd(1, 2); // 3 (from cache)\n * ```\n *\n * @param fn - The function to memorize.\n * @param options - Memoization options.\n * @param [options.ttl] - (optional) time-to-live (TTL) for cache expiration (in milliseconds).\n * @param [options.maxSize] - (optional) maximum cache size (LRU eviction).\n * @param [options.resolver] - (optional) custom function to resolve the cache key.\n *\n * @returns A new function that memorizes the input function.\n */\nexport function memo<T extends Fn>(\n  fn: T,\n  { ttl, maxSize, resolver }: MemoizeOptions<T> = {},\n): (...args: Parameters<T>) => ReturnType<T> {\n  const cache = new Map<string, CacheEntry<T>>();\n\n  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: -\n  const keyGen = (args: Parameters<T>): string => {\n    if (resolver) return resolver(...args);\n    if (args.length === 0) return '__empty__';\n    if (args.length === 1) {\n      const arg = args[0];\n      const argType = typeof arg;\n      if (argType === 'string' || argType === 'number' || argType === 'boolean') {\n        return `${argType}:${arg}`;\n      }\n      if (arg === null) return 'null';\n      if (arg === undefined) return 'undefined';\n    }\n    return JSON.stringify(args);\n  };\n\n  return (...args: Parameters<T>): ReturnType<T> => {\n    const key = keyGen(args);\n    const now = Date.now();\n    const cached = cache.get(key);\n\n    if (cached && (!ttl || now - cached.timestamp < ttl)) {\n      cache.delete(key);\n      cache.set(key, cached); // Move to end (most recently used)\n      return cached.value;\n    }\n\n    const result = fn(...args);\n    cache.set(key, { timestamp: now, value: result });\n\n    if (maxSize && cache.size > maxSize) {\n      cache.delete(cache.keys().next().value!); // Remove least recently used\n    }\n\n    return result;\n  };\n}\n"],"names":["memo","fn","ttl","maxSize","resolver","cache","keyGen","args","arg","argType","key","now","cached","result"],"mappings":"AAmCO,SAASA,EACdC,GACA,EAAE,KAAAC,GAAK,SAAAC,GAAS,UAAAC,EAAA,IAAgC,IACL;AAC3C,QAAMC,wBAAY,IAAA,GAGZC,IAAS,CAACC,MAAgC;AAC9C,QAAIH,EAAU,QAAOA,EAAS,GAAGG,CAAI;AACrC,QAAIA,EAAK,WAAW,EAAG,QAAO;AAC9B,QAAIA,EAAK,WAAW,GAAG;AACrB,YAAMC,IAAMD,EAAK,CAAC,GACZE,IAAU,OAAOD;AACvB,UAAIC,MAAY,YAAYA,MAAY,YAAYA,MAAY;AAC9D,eAAO,GAAGA,CAAO,IAAID,CAAG;AAE1B,UAAIA,MAAQ,KAAM,QAAO;AACzB,UAAIA,MAAQ,OAAW,QAAO;AAAA,IAChC;AACA,WAAO,KAAK,UAAUD,CAAI;AAAA,EAC5B;AAEA,SAAO,IAAIA,MAAuC;AAChD,UAAMG,IAAMJ,EAAOC,CAAI,GACjBI,IAAM,KAAK,IAAA,GACXC,IAASP,EAAM,IAAIK,CAAG;AAE5B,QAAIE,MAAW,CAACV,KAAOS,IAAMC,EAAO,YAAYV;AAC9C,aAAAG,EAAM,OAAOK,CAAG,GAChBL,EAAM,IAAIK,GAAKE,CAAM,GACdA,EAAO;AAGhB,UAAMC,IAASZ,EAAG,GAAGM,CAAI;AACzB,WAAAF,EAAM,IAAIK,GAAK,EAAE,WAAWC,GAAK,OAAOE,GAAQ,GAE5CV,KAAWE,EAAM,OAAOF,KAC1BE,EAAM,OAAOA,EAAM,KAAA,EAAO,KAAA,EAAO,KAAM,GAGlCQ;AAAA,EACT;AACF;"}

package/dist/function/retry.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("../logit/dist/logit.cjs"),c=require("./sleep.cjs");async function u(n,{times:e=3,delay:i=250,backoff:y=1,signal:l}={}){let t=i;for(let r=1;r<=e;r++){if(l?.aborted)throw a.Logit.warn(`retry() -> Aborted after ${r-1} attempts`),new Error("Retry aborted");try{return await n()}catch(o){if(r===e)throw o;a.Logit.warn(`retry() -> ${o}, attempt ${r}/${e}, retrying in ${t}ms`),t>0&&await c.sleep(t),t*=y}}throw new Error("Retry failed unexpectedly")}exports.retry=u;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("../logit/dist/logit.cjs"),u=require("./sleep.cjs");async function c(i,{times:e=3,delay:y=250,backoff:o=1,signal:l}={}){let t=y;for(let r=1;r<=e;r++){if(l?.aborted)throw a.Logit.warn(`retry() -> Aborted after ${r-1} attempts`),new Error("Retry aborted");try{return await i()}catch(n){if(r===e)throw n;a.Logit.warn(`retry() -> ${n}, attempt ${r}/${e}, retrying in ${t}ms`),t>0&&await u.sleep(t),t=typeof o=="function"?o(r,t):t*o}}throw new Error("Retry failed unexpectedly")}exports.retry=c;
 //# sourceMappingURL=retry.cjs.map

package/dist/function/retry.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"retry.cjs","sources":["../../src/function/retry.ts"],"sourcesContent":["import { Logit } from '@vielzeug/logit';\nimport { sleep } from './sleep';\n\n/**\n * Retries an asynchronous function a specified number of times with delay and optional exponential backoff.\n *\n * @example\n * ```ts\n * retry(() => fetchData(), { times: 3, delay: 1000, backoff: 2, signal: abortSignal })\n *   .then(result => console.log(result))\n *   .catch(error => console.error(error));\n * ```\n *\n * @param fn - The asynchronous function to retry.\n * @param options - (optional) Options for retrying the function.\n * @param [options.times=3] - The number of retry attempts.\n * @param [options.delay=250] - The delay in milliseconds between retries.\n * @param [options.backoff=1] - Exponential backoff factor (default: 1 → no backoff).\n * @param [options.signal] - `AbortSignal` to allow canceling retries.\n *\n * @returns The result of the asynchronous function.\n */\nexport async function retry<T>(\n  fn: () => Promise<T>,\n  {\n    times = 3,\n    delay = 250,\n    backoff = 1,\n    signal,\n  }: {\n    times?: number;\n    delay?: number;\n    backoff?: number;\n    signal?: AbortSignal;\n  } = {},\n): Promise<T> {\n  let currentDelay = delay;\n\n  for (let attempt = 1; attempt <= times; attempt++) {\n    if (signal?.aborted) {\n      Logit.warn(`retry() -> Aborted after ${attempt - 1} attempts`);\n      throw new Error('Retry aborted');\n    }\n\n    try {\n      return await fn();\n    } catch (err) {\n      if (attempt === times) throw err;\n\n      Logit.warn(`retry() -> ${err}, attempt ${attempt}/${times}, retrying in ${currentDelay}ms`);\n      if (currentDelay > 0) await sleep(currentDelay);\n      currentDelay *= backoff;\n    }\n  }\n\n  throw new Error('Retry failed unexpectedly');\n}\n"],"names":["retry","fn","times","delay","backoff","signal","currentDelay","attempt","Logit","err","sleep"],"mappings":"oJAsBA,eAAsBA,EACpBC,EACA,CACE,MAAAC,EAAQ,EACR,MAAAC,EAAQ,IACR,QAAAC,EAAU,EACV,OAAAC,CACF,EAKI,GACQ,CACZ,IAAIC,EAAeH,EAEnB,QAASI,EAAU,EAAGA,GAAWL,EAAOK,IAAW,CACjD,GAAIF,GAAQ,QACVG,MAAAA,EAAAA,MAAM,KAAK,4BAA4BD,EAAU,CAAC,WAAW,EACvD,IAAI,MAAM,eAAe,EAGjC,GAAI,CACF,OAAO,MAAMN,EAAA,CACf,OAASQ,EAAK,CACZ,GAAIF,IAAYL,EAAO,MAAMO,EAE7BD,EAAAA,MAAM,KAAK,cAAcC,CAAG,aAAaF,CAAO,IAAIL,CAAK,iBAAiBI,CAAY,IAAI,EACtFA,EAAe,GAAG,MAAMI,EAAAA,MAAMJ,CAAY,EAC9CA,GAAgBF,CAClB,CACF,CAEA,MAAM,IAAI,MAAM,2BAA2B,CAC7C"}
+{"version":3,"file":"retry.cjs","sources":["../../src/function/retry.ts"],"sourcesContent":["import { Logit } from '@vielzeug/logit';\nimport { sleep } from './sleep';\n\n/**\n * Retries an asynchronous function a specified number of times with delay and optional exponential backoff.\n *\n * @example\n * ```ts\n * retry(() => fetchData(), { times: 3, delay: 1000, backoff: 2, signal: abortSignal })\n *   .then(result => console.log(result))\n *   .catch(error => console.error(error));\n * ```\n *\n * @param fn - The asynchronous function to retry.\n * @param options - (optional) Options for retrying the function.\n * @param [options.times=3] - The number of retry attempts.\n * @param [options.delay=250] - The delay in milliseconds between retries.\n * @param [options.backoff=1] - Exponential backoff factor (default: 1 → no backoff).\n * @param [options.signal] - `AbortSignal` to allow canceling retries.\n *\n * @returns The result of the asynchronous function.\n */\nexport async function retry<T>(\n  fn: () => Promise<T>,\n  {\n    times = 3,\n    delay = 250,\n    backoff = 1,\n    signal,\n  }: {\n    times?: number;\n    delay?: number;\n    backoff?: number | ((attempt: number, delay: number) => number);\n    signal?: AbortSignal;\n  } = {},\n): Promise<T> {\n  let currentDelay = delay;\n\n  for (let attempt = 1; attempt <= times; attempt++) {\n    if (signal?.aborted) {\n      Logit.warn(`retry() -> Aborted after ${attempt - 1} attempts`);\n      throw new Error('Retry aborted');\n    }\n\n    try {\n      return await fn();\n    } catch (err) {\n      if (attempt === times) throw err;\n\n      Logit.warn(`retry() -> ${err}, attempt ${attempt}/${times}, retrying in ${currentDelay}ms`);\n      if (currentDelay > 0) await sleep(currentDelay);\n\n      currentDelay = typeof backoff === 'function' ? backoff(attempt, currentDelay) : currentDelay * backoff;\n    }\n  }\n\n  throw new Error('Retry failed unexpectedly');\n}\n"],"names":["retry","fn","times","delay","backoff","signal","currentDelay","attempt","Logit","err","sleep"],"mappings":"oJAsBA,eAAsBA,EACpBC,EACA,CACE,MAAAC,EAAQ,EACR,MAAAC,EAAQ,IACR,QAAAC,EAAU,EACV,OAAAC,CACF,EAKI,GACQ,CACZ,IAAIC,EAAeH,EAEnB,QAASI,EAAU,EAAGA,GAAWL,EAAOK,IAAW,CACjD,GAAIF,GAAQ,QACVG,MAAAA,EAAAA,MAAM,KAAK,4BAA4BD,EAAU,CAAC,WAAW,EACvD,IAAI,MAAM,eAAe,EAGjC,GAAI,CACF,OAAO,MAAMN,EAAA,CACf,OAASQ,EAAK,CACZ,GAAIF,IAAYL,EAAO,MAAMO,EAE7BD,EAAAA,MAAM,KAAK,cAAcC,CAAG,aAAaF,CAAO,IAAIL,CAAK,iBAAiBI,CAAY,IAAI,EACtFA,EAAe,GAAG,MAAMI,EAAAA,MAAMJ,CAAY,EAE9CA,EAAe,OAAOF,GAAY,WAAaA,EAAQG,EAASD,CAAY,EAAIA,EAAeF,CACjG,CACF,CAEA,MAAM,IAAI,MAAM,2BAA2B,CAC7C"}

package/dist/function/retry.js

@@ -1,25 +1,25 @@
-import { Logit as o } from "../logit/dist/logit.js";
+import { Logit as n } from "../logit/dist/logit.js";
 import { sleep as w } from "./sleep.js";
-async function l(n, {
+async function m(y, {
   times: e = 3,
-  delay: y = 250,
-  backoff: i = 1,
-  signal: f
+  delay: i = 250,
+  backoff: o = 1,
+  signal: p
 } = {}) {
-  let t = y;
-  for (let r = 1; r <= e; r++) {
-    if (f?.aborted)
-      throw o.warn(`retry() -> Aborted after ${r - 1} attempts`), new Error("Retry aborted");
+  let r = i;
+  for (let t = 1; t <= e; t++) {
+    if (p?.aborted)
+      throw n.warn(`retry() -> Aborted after ${t - 1} attempts`), new Error("Retry aborted");
     try {
-      return await n();
+      return await y();
     } catch (a) {
-      if (r === e) throw a;
-      o.warn(`retry() -> ${a}, attempt ${r}/${e}, retrying in ${t}ms`), t > 0 && await w(t), t *= i;
+      if (t === e) throw a;
+      n.warn(`retry() -> ${a}, attempt ${t}/${e}, retrying in ${r}ms`), r > 0 && await w(r), r = typeof o == "function" ? o(t, r) : r * o;
     }
   }
   throw new Error("Retry failed unexpectedly");
 }
 export {
-  l as retry
+  m as retry
 };
 //# sourceMappingURL=retry.js.map

package/dist/function/retry.js.map

@@ -1 +1 @@
-{"version":3,"file":"retry.js","sources":["../../src/function/retry.ts"],"sourcesContent":["import { Logit } from '@vielzeug/logit';\nimport { sleep } from './sleep';\n\n/**\n * Retries an asynchronous function a specified number of times with delay and optional exponential backoff.\n *\n * @example\n * ```ts\n * retry(() => fetchData(), { times: 3, delay: 1000, backoff: 2, signal: abortSignal })\n *   .then(result => console.log(result))\n *   .catch(error => console.error(error));\n * ```\n *\n * @param fn - The asynchronous function to retry.\n * @param options - (optional) Options for retrying the function.\n * @param [options.times=3] - The number of retry attempts.\n * @param [options.delay=250] - The delay in milliseconds between retries.\n * @param [options.backoff=1] - Exponential backoff factor (default: 1 → no backoff).\n * @param [options.signal] - `AbortSignal` to allow canceling retries.\n *\n * @returns The result of the asynchronous function.\n */\nexport async function retry<T>(\n  fn: () => Promise<T>,\n  {\n    times = 3,\n    delay = 250,\n    backoff = 1,\n    signal,\n  }: {\n    times?: number;\n    delay?: number;\n    backoff?: number;\n    signal?: AbortSignal;\n  } = {},\n): Promise<T> {\n  let currentDelay = delay;\n\n  for (let attempt = 1; attempt <= times; attempt++) {\n    if (signal?.aborted) {\n      Logit.warn(`retry() -> Aborted after ${attempt - 1} attempts`);\n      throw new Error('Retry aborted');\n    }\n\n    try {\n      return await fn();\n    } catch (err) {\n      if (attempt === times) throw err;\n\n      Logit.warn(`retry() -> ${err}, attempt ${attempt}/${times}, retrying in ${currentDelay}ms`);\n      if (currentDelay > 0) await sleep(currentDelay);\n      currentDelay *= backoff;\n    }\n  }\n\n  throw new Error('Retry failed unexpectedly');\n}\n"],"names":["retry","fn","times","delay","backoff","signal","currentDelay","attempt","Logit","err","sleep"],"mappings":";;AAsBA,eAAsBA,EACpBC,GACA;AAAA,EACE,OAAAC,IAAQ;AAAA,EACR,OAAAC,IAAQ;AAAA,EACR,SAAAC,IAAU;AAAA,EACV,QAAAC;AACF,IAKI,IACQ;AACZ,MAAIC,IAAeH;AAEnB,WAASI,IAAU,GAAGA,KAAWL,GAAOK,KAAW;AACjD,QAAIF,GAAQ;AACVG,YAAAA,EAAM,KAAK,4BAA4BD,IAAU,CAAC,WAAW,GACvD,IAAI,MAAM,eAAe;AAGjC,QAAI;AACF,aAAO,MAAMN,EAAA;AAAA,IACf,SAASQ,GAAK;AACZ,UAAIF,MAAYL,EAAO,OAAMO;AAE7BD,MAAAA,EAAM,KAAK,cAAcC,CAAG,aAAaF,CAAO,IAAIL,CAAK,iBAAiBI,CAAY,IAAI,GACtFA,IAAe,KAAG,MAAMI,EAAMJ,CAAY,GAC9CA,KAAgBF;AAAA,IAClB;AAAA,EACF;AAEA,QAAM,IAAI,MAAM,2BAA2B;AAC7C;"}
+{"version":3,"file":"retry.js","sources":["../../src/function/retry.ts"],"sourcesContent":["import { Logit } from '@vielzeug/logit';\nimport { sleep } from './sleep';\n\n/**\n * Retries an asynchronous function a specified number of times with delay and optional exponential backoff.\n *\n * @example\n * ```ts\n * retry(() => fetchData(), { times: 3, delay: 1000, backoff: 2, signal: abortSignal })\n *   .then(result => console.log(result))\n *   .catch(error => console.error(error));\n * ```\n *\n * @param fn - The asynchronous function to retry.\n * @param options - (optional) Options for retrying the function.\n * @param [options.times=3] - The number of retry attempts.\n * @param [options.delay=250] - The delay in milliseconds between retries.\n * @param [options.backoff=1] - Exponential backoff factor (default: 1 → no backoff).\n * @param [options.signal] - `AbortSignal` to allow canceling retries.\n *\n * @returns The result of the asynchronous function.\n */\nexport async function retry<T>(\n  fn: () => Promise<T>,\n  {\n    times = 3,\n    delay = 250,\n    backoff = 1,\n    signal,\n  }: {\n    times?: number;\n    delay?: number;\n    backoff?: number | ((attempt: number, delay: number) => number);\n    signal?: AbortSignal;\n  } = {},\n): Promise<T> {\n  let currentDelay = delay;\n\n  for (let attempt = 1; attempt <= times; attempt++) {\n    if (signal?.aborted) {\n      Logit.warn(`retry() -> Aborted after ${attempt - 1} attempts`);\n      throw new Error('Retry aborted');\n    }\n\n    try {\n      return await fn();\n    } catch (err) {\n      if (attempt === times) throw err;\n\n      Logit.warn(`retry() -> ${err}, attempt ${attempt}/${times}, retrying in ${currentDelay}ms`);\n      if (currentDelay > 0) await sleep(currentDelay);\n\n      currentDelay = typeof backoff === 'function' ? backoff(attempt, currentDelay) : currentDelay * backoff;\n    }\n  }\n\n  throw new Error('Retry failed unexpectedly');\n}\n"],"names":["retry","fn","times","delay","backoff","signal","currentDelay","attempt","Logit","err","sleep"],"mappings":";;AAsBA,eAAsBA,EACpBC,GACA;AAAA,EACE,OAAAC,IAAQ;AAAA,EACR,OAAAC,IAAQ;AAAA,EACR,SAAAC,IAAU;AAAA,EACV,QAAAC;AACF,IAKI,IACQ;AACZ,MAAIC,IAAeH;AAEnB,WAASI,IAAU,GAAGA,KAAWL,GAAOK,KAAW;AACjD,QAAIF,GAAQ;AACVG,YAAAA,EAAM,KAAK,4BAA4BD,IAAU,CAAC,WAAW,GACvD,IAAI,MAAM,eAAe;AAGjC,QAAI;AACF,aAAO,MAAMN,EAAA;AAAA,IACf,SAASQ,GAAK;AACZ,UAAIF,MAAYL,EAAO,OAAMO;AAE7BD,MAAAA,EAAM,KAAK,cAAcC,CAAG,aAAaF,CAAO,IAAIL,CAAK,iBAAiBI,CAAY,IAAI,GACtFA,IAAe,KAAG,MAAMI,EAAMJ,CAAY,GAE9CA,IAAe,OAAOF,KAAY,aAAaA,EAAQG,GAASD,CAAY,IAAIA,IAAeF;AAAA,IACjG;AAAA,EACF;AAEA,QAAM,IAAI,MAAM,2BAA2B;AAC7C;"}

package/dist/function/sleep.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});async function n(e){return new Promise(t=>setTimeout(t,e))}exports.sleep=n;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("./assert.cjs");async function s(e){return n.assert(typeof e=="number"&&e>=0&&Number.isFinite(e),"Timeout must be a non-negative finite number",{args:{timeout:e},type:TypeError}),new Promise(r=>setTimeout(r,e))}exports.sleep=s;
 //# sourceMappingURL=sleep.cjs.map

package/dist/function/sleep.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"sleep.cjs","sources":["../../src/function/sleep.ts"],"sourcesContent":["/**\n * Creates a Promise that resolves after a specified amount of time.\n *\n * @example\n * ```ts\n * sleep(1000).then(() => console.log('Hello, world!')); // logs 'Hello, world!' after 1 second\n * ```\n *\n * @param timeout - The number of milliseconds to wait before resolving the Promise.\n *\n * @returns A Promise that resolves after the specified time.\n */\nexport async function sleep(timeout: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, timeout));\n}\n"],"names":["sleep","timeout","resolve"],"mappings":"gFAYA,eAAsBA,EAAMC,EAAgC,CAC1D,OAAO,IAAI,QAASC,GAAY,WAAWA,EAASD,CAAO,CAAC,CAC9D"}
+{"version":3,"file":"sleep.cjs","sources":["../../src/function/sleep.ts"],"sourcesContent":["import { assert } from './assert';\n\n/**\n * Creates a Promise that resolves after a specified amount of time.\n *\n * @example\n * ```ts\n * sleep(1000).then(() => console.log('Hello, world!')); // logs 'Hello, world!' after 1 second\n * ```\n *\n * @param timeout - The number of milliseconds to wait before resolving the Promise.\n *\n * @returns A Promise that resolves after the specified time.\n *\n * @throws {TypeError} If timeout is not a non-negative number.\n */\nexport async function sleep(timeout: number): Promise<void> {\n  assert(\n    typeof timeout === 'number' && timeout >= 0 && Number.isFinite(timeout),\n    'Timeout must be a non-negative finite number',\n    { args: { timeout }, type: TypeError },\n  );\n  return new Promise((resolve) => setTimeout(resolve, timeout));\n}\n"],"names":["sleep","timeout","assert","resolve"],"mappings":"gHAgBA,eAAsBA,EAAMC,EAAgC,CAC1DC,OAAAA,EAAAA,OACE,OAAOD,GAAY,UAAYA,GAAW,GAAK,OAAO,SAASA,CAAO,EACtE,+CACA,CAAE,KAAM,CAAE,QAAAA,CAAA,EAAW,KAAM,SAAA,CAAU,EAEhC,IAAI,QAASE,GAAY,WAAWA,EAASF,CAAO,CAAC,CAC9D"}

package/dist/function/sleep.js

@@ -1,7 +1,12 @@
-async function t(e) {
-  return new Promise((n) => setTimeout(n, e));
+import { assert as n } from "./assert.js";
+async function i(e) {
+  return n(
+    typeof e == "number" && e >= 0 && Number.isFinite(e),
+    "Timeout must be a non-negative finite number",
+    { args: { timeout: e }, type: TypeError }
+  ), new Promise((r) => setTimeout(r, e));
 }
 export {
-  t as sleep
+  i as sleep
 };
 //# sourceMappingURL=sleep.js.map

package/dist/function/sleep.js.map

@@ -1 +1 @@
-{"version":3,"file":"sleep.js","sources":["../../src/function/sleep.ts"],"sourcesContent":["/**\n * Creates a Promise that resolves after a specified amount of time.\n *\n * @example\n * ```ts\n * sleep(1000).then(() => console.log('Hello, world!')); // logs 'Hello, world!' after 1 second\n * ```\n *\n * @param timeout - The number of milliseconds to wait before resolving the Promise.\n *\n * @returns A Promise that resolves after the specified time.\n */\nexport async function sleep(timeout: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, timeout));\n}\n"],"names":["sleep","timeout","resolve"],"mappings":"AAYA,eAAsBA,EAAMC,GAAgC;AAC1D,SAAO,IAAI,QAAQ,CAACC,MAAY,WAAWA,GAASD,CAAO,CAAC;AAC9D;"}
+{"version":3,"file":"sleep.js","sources":["../../src/function/sleep.ts"],"sourcesContent":["import { assert } from './assert';\n\n/**\n * Creates a Promise that resolves after a specified amount of time.\n *\n * @example\n * ```ts\n * sleep(1000).then(() => console.log('Hello, world!')); // logs 'Hello, world!' after 1 second\n * ```\n *\n * @param timeout - The number of milliseconds to wait before resolving the Promise.\n *\n * @returns A Promise that resolves after the specified time.\n *\n * @throws {TypeError} If timeout is not a non-negative number.\n */\nexport async function sleep(timeout: number): Promise<void> {\n  assert(\n    typeof timeout === 'number' && timeout >= 0 && Number.isFinite(timeout),\n    'Timeout must be a non-negative finite number',\n    { args: { timeout }, type: TypeError },\n  );\n  return new Promise((resolve) => setTimeout(resolve, timeout));\n}\n"],"names":["sleep","timeout","assert","resolve"],"mappings":";AAgBA,eAAsBA,EAAMC,GAAgC;AAC1D,SAAAC;AAAA,IACE,OAAOD,KAAY,YAAYA,KAAW,KAAK,OAAO,SAASA,CAAO;AAAA,IACtE;AAAA,IACA,EAAE,MAAM,EAAE,SAAAA,EAAA,GAAW,MAAM,UAAA;AAAA,EAAU,GAEhC,IAAI,QAAQ,CAACE,MAAY,WAAWA,GAASF,CAAO,CAAC;AAC9D;"}

package/dist/function/throttle.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function l(o,n=700){let t=0;return(...r)=>{const e=Date.now();e-t>=n&&(t=e,o(...r))}}exports.throttle=l;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const p=require("./assert.cjs");function b(u,o=700,f={leading:!0,trailing:!0}){p.assert(typeof u=="function","First argument must be a function",{args:{fn:u},type:TypeError}),p.assert(typeof o=="number"&&o>=0,"Delay must be a non-negative number",{args:{delay:o},type:TypeError});const T=f.leading??!0,y=f.trailing??!1;let n,i=0,e,s,m;const c=()=>{n!==void 0&&(clearTimeout(n),n=void 0)},g=t=>{if(i=t,c(),!e)return;const r=e,l=s;return e=void 0,s=void 0,m=u.apply(l,r),m},d=t=>o-(t-i),v=()=>{const t=Date.now();e&&d(t)<=0?g(t):e?n=setTimeout(v,d(t)):c()},a=function(...t){const r=Date.now();i===0&&!T&&(i=r),e=t,s=this;const l=d(r);l<=0?g(r):y&&!n&&(n=setTimeout(v,l))};return a.cancel=()=>{c(),e=void 0,s=void 0,i=0},a.flush=()=>{if(!e)return;const t=Date.now();return g(t)},a.pending=()=>e!==void 0||n!==void 0,a}exports.throttle=b;
 //# sourceMappingURL=throttle.cjs.map

package/dist/function/throttle.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"throttle.cjs","sources":["../../src/function/throttle.ts"],"sourcesContent":["import type { Fn } from '../types';\n\n/**\n * Creates a throttled function that only invokes the provided function at most once per every specified milliseconds.\n *\n * @example\n * ```ts\n * const log = () => console.log('Hello, world!');\n * const throttledLog = throttle(log, 1000);\n *\n * throttledLog(); // logs 'Hello, world!' immediately\n * throttledLog(); // does nothing because less than 1 second has passed since the last invocation\n * setTimeout(throttledLog, 1000); // logs 'Hello, world!' after 1 second\n * ```\n *\n * @param fn - The function to throttle.\n * @param [delay=700] - The number of milliseconds to wait before invoking the function again.\n *\n * @returns A new function that throttles the input function.\n */\nexport function throttle<T extends Fn>(fn: T, delay = 700): (...args: Parameters<T>) => void {\n  let elapsed = 0;\n\n  return (...args: Parameters<T>) => {\n    const now = Date.now();\n\n    if (now - elapsed >= delay) {\n      elapsed = now;\n      fn(...args);\n    }\n  };\n}\n"],"names":["throttle","fn","delay","elapsed","args","now"],"mappings":"gFAoBO,SAASA,EAAuBC,EAAOC,EAAQ,IAAuC,CAC3F,IAAIC,EAAU,EAEd,MAAO,IAAIC,IAAwB,CACjC,MAAMC,EAAM,KAAK,IAAA,EAEbA,EAAMF,GAAWD,IACnBC,EAAUE,EACVJ,EAAG,GAAGG,CAAI,EAEd,CACF"}
+{"version":3,"file":"throttle.cjs","sources":["../../src/function/throttle.ts"],"sourcesContent":["import type { Fn } from '../types';\nimport { assert } from './assert';\n\nexport type ThrottleOptions = {\n  leading?: boolean; // invoke at the start of the window\n  trailing?: boolean; // invoke at the end with the last args\n};\n\nexport type Throttled<T extends Fn> = ((this: ThisParameterType<T>, ...args: Parameters<T>) => void) & {\n  cancel(): void;\n  flush(): ReturnType<T> | undefined;\n  pending(): boolean; // whether there's a pending call that flush() would execute\n};\n\n/**\n * Throttles a function. By default, leading and trailing are both true (lodash-like behavior).\n * The function is invoked at the leading edge and trailing edge of the throttle period.\n *\n * Example:\n * const fn = () => ...\n * const t = throttle(fn, 700);\n * const leadingOnly = throttle(fn, 700, { trailing: false });\n */\nexport function throttle<T extends Fn>(\n  fn: T,\n  delay = 700,\n  options: ThrottleOptions = { leading: true, trailing: true },\n): Throttled<T> {\n  assert(typeof fn === 'function', 'First argument must be a function', {\n    args: { fn },\n    type: TypeError,\n  });\n  assert(typeof delay === 'number' && delay >= 0, 'Delay must be a non-negative number', {\n    args: { delay },\n    type: TypeError,\n  });\n\n  const leading = options.leading ?? true;\n  const trailing = options.trailing ?? false;\n\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  let lastInvokeTime = 0;\n  let lastArgs: Parameters<T> | undefined;\n  let lastThis: ThisParameterType<T> | undefined;\n  let lastResult: ReturnType<T> | undefined;\n\n  const clearTimer = () => {\n    if (timer !== undefined) {\n      clearTimeout(timer);\n      timer = undefined;\n    }\n  };\n\n  const invoke = (now: number) => {\n    lastInvokeTime = now;\n    clearTimer();\n    if (!lastArgs) return undefined;\n    const args = lastArgs;\n    const ctx = lastThis as ThisParameterType<T>;\n    lastArgs = undefined;\n    lastThis = undefined;\n    // biome-ignore lint/suspicious/noExplicitAny: -\n    lastResult = fn.apply(ctx as any, args);\n    return lastResult;\n  };\n\n  const remaining = (now: number) => delay - (now - lastInvokeTime);\n\n  const timerExpired = () => {\n    const now = Date.now();\n    if (lastArgs && remaining(now) <= 0) {\n      // trailing edge invoke\n      invoke(now);\n    } else if (lastArgs) {\n      // reschedule until a window elapses\n      timer = setTimeout(timerExpired, remaining(now));\n    } else {\n      clearTimer();\n    }\n  };\n\n  const throttled = function (this: ThisParameterType<T>, ...args: Parameters<T>) {\n    const now = Date.now();\n    if (lastInvokeTime === 0 && !leading) {\n      // If leading is false, start the window now but don't invoke immediately\n      lastInvokeTime = now;\n    }\n\n    lastArgs = args;\n    lastThis = this;\n\n    const rem = remaining(now);\n\n    if (rem <= 0) {\n      // Window elapsed: invoke now\n      invoke(now);\n    } else if (trailing && !timer) {\n      // Schedule trailing call if not already scheduled\n      timer = setTimeout(timerExpired, rem);\n    }\n  } as Throttled<T>;\n\n  throttled.cancel = () => {\n    clearTimer();\n    lastArgs = undefined;\n    lastThis = undefined;\n    lastInvokeTime = 0;\n  };\n\n  throttled.flush = () => {\n    if (!lastArgs) return undefined;\n    const now = Date.now();\n    return invoke(now) as ReturnType<T> | undefined;\n  };\n\n  // Pending if a trailing call is scheduled OR there are queued args.\n  throttled.pending = () => lastArgs !== undefined || timer !== undefined;\n\n  return throttled;\n}\n"],"names":["throttle","fn","delay","options","assert","leading","trailing","timer","lastInvokeTime","lastArgs","lastThis","lastResult","clearTimer","invoke","now","args","ctx","remaining","timerExpired","throttled","rem"],"mappings":"gHAuBO,SAASA,EACdC,EACAC,EAAQ,IACRC,EAA2B,CAAE,QAAS,GAAM,SAAU,IACxC,CACdC,EAAAA,OAAO,OAAOH,GAAO,WAAY,oCAAqC,CACpE,KAAM,CAAE,GAAAA,CAAA,EACR,KAAM,SAAA,CACP,EACDG,EAAAA,OAAO,OAAOF,GAAU,UAAYA,GAAS,EAAG,sCAAuC,CACrF,KAAM,CAAE,MAAAA,CAAA,EACR,KAAM,SAAA,CACP,EAED,MAAMG,EAAUF,EAAQ,SAAW,GAC7BG,EAAWH,EAAQ,UAAY,GAErC,IAAII,EACAC,EAAiB,EACjBC,EACAC,EACAC,EAEJ,MAAMC,EAAa,IAAM,CACnBL,IAAU,SACZ,aAAaA,CAAK,EAClBA,EAAQ,OAEZ,EAEMM,EAAUC,GAAgB,CAG9B,GAFAN,EAAiBM,EACjBF,EAAA,EACI,CAACH,EAAU,OACf,MAAMM,EAAON,EACPO,EAAMN,EACZ,OAAAD,EAAW,OACXC,EAAW,OAEXC,EAAaV,EAAG,MAAMe,EAAYD,CAAI,EAC/BJ,CACT,EAEMM,EAAaH,GAAgBZ,GAASY,EAAMN,GAE5CU,EAAe,IAAM,CACzB,MAAMJ,EAAM,KAAK,IAAA,EACbL,GAAYQ,EAAUH,CAAG,GAAK,EAEhCD,EAAOC,CAAG,EACDL,EAETF,EAAQ,WAAWW,EAAcD,EAAUH,CAAG,CAAC,EAE/CF,EAAA,CAEJ,EAEMO,EAAY,YAAyCJ,EAAqB,CAC9E,MAAMD,EAAM,KAAK,IAAA,EACbN,IAAmB,GAAK,CAACH,IAE3BG,EAAiBM,GAGnBL,EAAWM,EACXL,EAAW,KAEX,MAAMU,EAAMH,EAAUH,CAAG,EAErBM,GAAO,EAETP,EAAOC,CAAG,EACDR,GAAY,CAACC,IAEtBA,EAAQ,WAAWW,EAAcE,CAAG,EAExC,EAEA,OAAAD,EAAU,OAAS,IAAM,CACvBP,EAAA,EACAH,EAAW,OACXC,EAAW,OACXF,EAAiB,CACnB,EAEAW,EAAU,MAAQ,IAAM,CACtB,GAAI,CAACV,EAAU,OACf,MAAMK,EAAM,KAAK,IAAA,EACjB,OAAOD,EAAOC,CAAG,CACnB,EAGAK,EAAU,QAAU,IAAMV,IAAa,QAAaF,IAAU,OAEvDY,CACT"}

package/dist/function/throttle.js

@@ -1,11 +1,38 @@
-function l(n, o = 700) {
-  let t = 0;
-  return (...r) => {
-    const e = Date.now();
-    e - t >= o && (t = e, n(...r));
+import { assert as p } from "./assert.js";
+function y(c, r = 700, g = { leading: !0, trailing: !0 }) {
+  p(typeof c == "function", "First argument must be a function", {
+    args: { fn: c },
+    type: TypeError
+  }), p(typeof r == "number" && r >= 0, "Delay must be a non-negative number", {
+    args: { delay: r },
+    type: TypeError
+  });
+  const T = g.leading ?? !0, w = g.trailing ?? !1;
+  let n, i = 0, e, s, d;
+  const u = () => {
+    n !== void 0 && (clearTimeout(n), n = void 0);
+  }, m = (t) => {
+    if (i = t, u(), !e) return;
+    const o = e, l = s;
+    return e = void 0, s = void 0, d = c.apply(l, o), d;
+  }, f = (t) => r - (t - i), v = () => {
+    const t = Date.now();
+    e && f(t) <= 0 ? m(t) : e ? n = setTimeout(v, f(t)) : u();
+  }, a = function(...t) {
+    const o = Date.now();
+    i === 0 && !T && (i = o), e = t, s = this;
+    const l = f(o);
+    l <= 0 ? m(o) : w && !n && (n = setTimeout(v, l));
   };
+  return a.cancel = () => {
+    u(), e = void 0, s = void 0, i = 0;
+  }, a.flush = () => {
+    if (!e) return;
+    const t = Date.now();
+    return m(t);
+  }, a.pending = () => e !== void 0 || n !== void 0, a;
 }
 export {
-  l as throttle
+  y as throttle
 };
 //# sourceMappingURL=throttle.js.map

package/dist/function/throttle.js.map

@@ -1 +1 @@
-{"version":3,"file":"throttle.js","sources":["../../src/function/throttle.ts"],"sourcesContent":["import type { Fn } from '../types';\n\n/**\n * Creates a throttled function that only invokes the provided function at most once per every specified milliseconds.\n *\n * @example\n * ```ts\n * const log = () => console.log('Hello, world!');\n * const throttledLog = throttle(log, 1000);\n *\n * throttledLog(); // logs 'Hello, world!' immediately\n * throttledLog(); // does nothing because less than 1 second has passed since the last invocation\n * setTimeout(throttledLog, 1000); // logs 'Hello, world!' after 1 second\n * ```\n *\n * @param fn - The function to throttle.\n * @param [delay=700] - The number of milliseconds to wait before invoking the function again.\n *\n * @returns A new function that throttles the input function.\n */\nexport function throttle<T extends Fn>(fn: T, delay = 700): (...args: Parameters<T>) => void {\n  let elapsed = 0;\n\n  return (...args: Parameters<T>) => {\n    const now = Date.now();\n\n    if (now - elapsed >= delay) {\n      elapsed = now;\n      fn(...args);\n    }\n  };\n}\n"],"names":["throttle","fn","delay","elapsed","args","now"],"mappings":"AAoBO,SAASA,EAAuBC,GAAOC,IAAQ,KAAuC;AAC3F,MAAIC,IAAU;AAEd,SAAO,IAAIC,MAAwB;AACjC,UAAMC,IAAM,KAAK,IAAA;AAEjB,IAAIA,IAAMF,KAAWD,MACnBC,IAAUE,GACVJ,EAAG,GAAGG,CAAI;AAAA,EAEd;AACF;"}
+{"version":3,"file":"throttle.js","sources":["../../src/function/throttle.ts"],"sourcesContent":["import type { Fn } from '../types';\nimport { assert } from './assert';\n\nexport type ThrottleOptions = {\n  leading?: boolean; // invoke at the start of the window\n  trailing?: boolean; // invoke at the end with the last args\n};\n\nexport type Throttled<T extends Fn> = ((this: ThisParameterType<T>, ...args: Parameters<T>) => void) & {\n  cancel(): void;\n  flush(): ReturnType<T> | undefined;\n  pending(): boolean; // whether there's a pending call that flush() would execute\n};\n\n/**\n * Throttles a function. By default, leading and trailing are both true (lodash-like behavior).\n * The function is invoked at the leading edge and trailing edge of the throttle period.\n *\n * Example:\n * const fn = () => ...\n * const t = throttle(fn, 700);\n * const leadingOnly = throttle(fn, 700, { trailing: false });\n */\nexport function throttle<T extends Fn>(\n  fn: T,\n  delay = 700,\n  options: ThrottleOptions = { leading: true, trailing: true },\n): Throttled<T> {\n  assert(typeof fn === 'function', 'First argument must be a function', {\n    args: { fn },\n    type: TypeError,\n  });\n  assert(typeof delay === 'number' && delay >= 0, 'Delay must be a non-negative number', {\n    args: { delay },\n    type: TypeError,\n  });\n\n  const leading = options.leading ?? true;\n  const trailing = options.trailing ?? false;\n\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  let lastInvokeTime = 0;\n  let lastArgs: Parameters<T> | undefined;\n  let lastThis: ThisParameterType<T> | undefined;\n  let lastResult: ReturnType<T> | undefined;\n\n  const clearTimer = () => {\n    if (timer !== undefined) {\n      clearTimeout(timer);\n      timer = undefined;\n    }\n  };\n\n  const invoke = (now: number) => {\n    lastInvokeTime = now;\n    clearTimer();\n    if (!lastArgs) return undefined;\n    const args = lastArgs;\n    const ctx = lastThis as ThisParameterType<T>;\n    lastArgs = undefined;\n    lastThis = undefined;\n    // biome-ignore lint/suspicious/noExplicitAny: -\n    lastResult = fn.apply(ctx as any, args);\n    return lastResult;\n  };\n\n  const remaining = (now: number) => delay - (now - lastInvokeTime);\n\n  const timerExpired = () => {\n    const now = Date.now();\n    if (lastArgs && remaining(now) <= 0) {\n      // trailing edge invoke\n      invoke(now);\n    } else if (lastArgs) {\n      // reschedule until a window elapses\n      timer = setTimeout(timerExpired, remaining(now));\n    } else {\n      clearTimer();\n    }\n  };\n\n  const throttled = function (this: ThisParameterType<T>, ...args: Parameters<T>) {\n    const now = Date.now();\n    if (lastInvokeTime === 0 && !leading) {\n      // If leading is false, start the window now but don't invoke immediately\n      lastInvokeTime = now;\n    }\n\n    lastArgs = args;\n    lastThis = this;\n\n    const rem = remaining(now);\n\n    if (rem <= 0) {\n      // Window elapsed: invoke now\n      invoke(now);\n    } else if (trailing && !timer) {\n      // Schedule trailing call if not already scheduled\n      timer = setTimeout(timerExpired, rem);\n    }\n  } as Throttled<T>;\n\n  throttled.cancel = () => {\n    clearTimer();\n    lastArgs = undefined;\n    lastThis = undefined;\n    lastInvokeTime = 0;\n  };\n\n  throttled.flush = () => {\n    if (!lastArgs) return undefined;\n    const now = Date.now();\n    return invoke(now) as ReturnType<T> | undefined;\n  };\n\n  // Pending if a trailing call is scheduled OR there are queued args.\n  throttled.pending = () => lastArgs !== undefined || timer !== undefined;\n\n  return throttled;\n}\n"],"names":["throttle","fn","delay","options","assert","leading","trailing","timer","lastInvokeTime","lastArgs","lastThis","lastResult","clearTimer","invoke","now","args","ctx","remaining","timerExpired","throttled","rem"],"mappings":";AAuBO,SAASA,EACdC,GACAC,IAAQ,KACRC,IAA2B,EAAE,SAAS,IAAM,UAAU,MACxC;AACd,EAAAC,EAAO,OAAOH,KAAO,YAAY,qCAAqC;AAAA,IACpE,MAAM,EAAE,IAAAA,EAAA;AAAA,IACR,MAAM;AAAA,EAAA,CACP,GACDG,EAAO,OAAOF,KAAU,YAAYA,KAAS,GAAG,uCAAuC;AAAA,IACrF,MAAM,EAAE,OAAAA,EAAA;AAAA,IACR,MAAM;AAAA,EAAA,CACP;AAED,QAAMG,IAAUF,EAAQ,WAAW,IAC7BG,IAAWH,EAAQ,YAAY;AAErC,MAAII,GACAC,IAAiB,GACjBC,GACAC,GACAC;AAEJ,QAAMC,IAAa,MAAM;AACvB,IAAIL,MAAU,WACZ,aAAaA,CAAK,GAClBA,IAAQ;AAAA,EAEZ,GAEMM,IAAS,CAACC,MAAgB;AAG9B,QAFAN,IAAiBM,GACjBF,EAAA,GACI,CAACH,EAAU;AACf,UAAMM,IAAON,GACPO,IAAMN;AACZ,WAAAD,IAAW,QACXC,IAAW,QAEXC,IAAaV,EAAG,MAAMe,GAAYD,CAAI,GAC/BJ;AAAA,EACT,GAEMM,IAAY,CAACH,MAAgBZ,KAASY,IAAMN,IAE5CU,IAAe,MAAM;AACzB,UAAMJ,IAAM,KAAK,IAAA;AACjB,IAAIL,KAAYQ,EAAUH,CAAG,KAAK,IAEhCD,EAAOC,CAAG,IACDL,IAETF,IAAQ,WAAWW,GAAcD,EAAUH,CAAG,CAAC,IAE/CF,EAAA;AAAA,EAEJ,GAEMO,IAAY,YAAyCJ,GAAqB;AAC9E,UAAMD,IAAM,KAAK,IAAA;AACjB,IAAIN,MAAmB,KAAK,CAACH,MAE3BG,IAAiBM,IAGnBL,IAAWM,GACXL,IAAW;AAEX,UAAMU,IAAMH,EAAUH,CAAG;AAEzB,IAAIM,KAAO,IAETP,EAAOC,CAAG,IACDR,KAAY,CAACC,MAEtBA,IAAQ,WAAWW,GAAcE,CAAG;AAAA,EAExC;AAEA,SAAAD,EAAU,SAAS,MAAM;AACvB,IAAAP,EAAA,GACAH,IAAW,QACXC,IAAW,QACXF,IAAiB;AAAA,EACnB,GAEAW,EAAU,QAAQ,MAAM;AACtB,QAAI,CAACV,EAAU;AACf,UAAMK,IAAM,KAAK,IAAA;AACjB,WAAOD,EAAOC,CAAG;AAAA,EACnB,GAGAK,EAAU,UAAU,MAAMV,MAAa,UAAaF,MAAU,QAEvDY;AACT;"}

package/dist/index.d.ts

@@ -264,6 +264,8 @@ export declare function clamp(n: number, min: number, max: number): number;
  * @param item - The data to clone.
  *
  * @returns A deep copy of the provided data.
+ *
+ * @throws {Error} If the item cannot be cloned.
  */
 export declare function clone<T>(item: T): T;
 
@@ -388,42 +390,23 @@ export declare namespace contains {
     var fp: boolean;
 }
 
-declare type CurriedFunction<Params extends any[], R> = Params extends [infer A, ...infer Rest] ? (arg: A) => CurriedFunction<Rest, R> : R;
+export declare type Curried<P extends readonly unknown[], R> = P extends readonly [] ? () => R : <A extends readonly [unknown, ...(readonly unknown[])]>(...args: A) => P extends readonly [...A, ...infer Rest] ? (Rest extends readonly [] ? R : Curried<Rest, R>) : never;
 
-/**
- * Curries a function, allowing it to be called with partial arguments.
- *
- * @example
- * ```ts
- * const add = (a: number, b: number) => a + b;
- * const curriedAdd = curry(add);
- * curriedAdd(1)(2) // 3;
- * ```
- *
- * @param fn - The function to curry.
- *
- * @returns A curried version of the function.
- */
-export declare const curry: <T extends (...args: any[]) => any>(fn: T) => T extends (...args: infer P) => infer R ? CurriedFunction<P, R> : never;
+export declare function curry<T extends (...args: any[]) => any>(fn: T): Curried<Parameters<T>, ReturnType<T>>;
+
+export declare function curry<T extends (...args: any[]) => any, N extends number>(fn: T, arity: N): Curried<Take<N, Parameters<T>>, ReturnType<T>>;
 
 /**
- * Creates a debounced function that delays invoking the provided function until after
- * a specified wait time has elapsed since the last invocation.
- *
- * @example
- * ```ts
- * const debouncedLog = debounce(console.log, 1000);
- *
- * debouncedLog('Hello'); // Will log after 1 second if not called again
- * debouncedLog('World'); // Resets the timer, will log 'World' after 1 second
- * ```
- *
- * @param fn - The function to debounce.
- * @param [delay=300] - - The number of milliseconds to delay invoking the function.
- *
- * @returns - A debounced function
+ * Debounce a function (trailing). Use `flush` to invoke immediately,
+ * `cancel` to clear, and `pending` to check if an invocation is scheduled.
  */
-export declare function debounce<T extends Fn>(fn: T, delay?: number): (...args: Parameters<T>) => void;
+export declare function debounce<T extends Fn>(fn: T, delay?: number): Debounced<T>;
+
+export declare type Debounced<T extends Fn> = ((this: ThisParameterType<T>, ...args: Parameters<T>) => void) & {
+    cancel(): void;
+    flush(): ReturnType<T> | undefined;
+    pending(): boolean;
+};
 
 declare type DeepMerge<T, U> = T extends Obj ? U extends Obj ? {
     [K in keyof T | keyof U]: K extends keyof T ? K extends keyof U ? DeepMerge<T[K], U[K]> : T[K] : K extends keyof U ? U[K] : never;
@@ -718,7 +701,7 @@ export declare function ge(a: unknown, b: unknown): boolean;
  *
  * @throws {TypeError} If the provided array is not an array.
  */
-export declare function group<T, K extends keyof T, R extends T[K] extends string ? T[K] : never>(array: T[], selector: Selector<T>): Record<R, T[]>;
+export declare function group<T, _K extends keyof T, R extends string | number | symbol>(array: T[], selector: Selector<T>): Record<R, T[]>;
 
 export declare namespace group {
     var fp: boolean;
@@ -1335,7 +1318,7 @@ export declare function list<T>(initialData: T[], config?: Config<T>): {
     readonly pages: T[][];
     prev(): void;
     reset(): T[];
-    search: (str: string) => void;
+    search: Debounced<(str: string) => T[]>;
     sort(fn?: (a: T, b: T) => number): T[];
     [Symbol.iterator](): Generator<T[], void, unknown>;
 };
@@ -1438,14 +1421,16 @@ export declare function median<T>(arr: T[], callback?: (item: T) => number | Dat
  * @param options - Memoization options.
  * @param [options.ttl] - (optional) time-to-live (TTL) for cache expiration (in milliseconds).
  * @param [options.maxSize] - (optional) maximum cache size (LRU eviction).
+ * @param [options.resolver] - (optional) custom function to resolve the cache key.
  *
  * @returns A new function that memorizes the input function.
  */
-export declare function memo<T extends Fn>(fn: T, { ttl, maxSize }?: MemoizeOptions): (...args: Parameters<T>) => ReturnType<T>;
+export declare function memo<T extends Fn>(fn: T, { ttl, maxSize, resolver }?: MemoizeOptions<T>): (...args: Parameters<T>) => ReturnType<T>;
 
-declare type MemoizeOptions = {
+declare type MemoizeOptions<T extends Fn> = {
     ttl?: number;
     maxSize?: number;
+    resolver?: (...args: Parameters<T>) => string;
 };
 
 declare type Merge<T extends Obj[]> = T extends [infer First, ...infer Rest] ? First extends Obj ? Rest extends Obj[] ? DeepMerge<First, Merge<Rest>> : First : Obj : Obj;
@@ -1615,7 +1600,7 @@ declare type PathValue<T, P extends string> = P extends `${infer Key}.${infer Re
  *
  * @throws {TypeError} If the first argument is not an array.
  */
-export declare function pick<T, R, C extends CallbackDynamic<T, R>>(array: T[], callback: C, predicate?: Predicate<T>): Result<C> | undefined;
+export declare function pick<T, R = T>(array: T[], callback: (item: T, index: number, array: T[]) => R, predicate?: (item: T, index: number, array: T[]) => boolean): R | undefined;
 
 export declare namespace pick {
     var fp: boolean;
@@ -1739,6 +1724,9 @@ export declare function random(min: number, max: number): number;
  * @param step - The value to increment or decrement by.
  *
  * @returns The range of numbers.
+ *
+ * @throws {TypeError} If start, stop, or step are not finite numbers.
+ * @throws {Error} If step is 0 or if range exceeds maximum size.
  */
 export declare function range(start: number, stop: number, step: number): number[];
 
@@ -1817,7 +1805,7 @@ export declare type ResultArray<C extends FnDynamic> = C extends FnAsync ? Promi
 export declare function retry<T>(fn: () => Promise<T>, { times, delay, backoff, signal, }?: {
     times?: number;
     delay?: number;
-    backoff?: number;
+    backoff?: number | ((attempt: number, delay: number) => number);
     signal?: AbortSignal;
 }): Promise<T>;
 
@@ -1984,6 +1972,8 @@ export declare function similarity(str1: unknown, str2: unknown): number;
  * @param timeout - The number of milliseconds to wait before resolving the Promise.
  *
  * @returns A Promise that resolves after the specified time.
+ *
+ * @throws {TypeError} If timeout is not a non-negative number.
  */
 export declare function sleep(timeout: number): Promise<void>;
 
@@ -2097,7 +2087,6 @@ export declare namespace substitute {
  * sum([1, 2, 3]) // 6
  * sum([{value: 1}, {value: 2}, {value: 3}], (item) => item.value) // 6
  * sum(['apple', 'banana', 'cherry']) // TypeError
- * sum([new Date('2023-01-01'), new Date('2022-01-01')]) // 467308800000
  * ```
  *
  * @param array - The array to sum.
@@ -2105,29 +2094,49 @@ export declare namespace substitute {
  *
  * @returns The sum of the numbers in the array or the sum of the mapped values.
  */
-export declare function sum<T>(array: T[], callback?: (item: T) => number | Date): number | Date | undefined;
+export declare function sum<T>(array: T[], callback?: (item: T) => number): number | undefined;
 
 declare type SyncCallback<R, T> = (prev: R, curr: T, index: number, array: T[]) => R;
 
+/** biome-ignore-all lint/suspicious/noExplicitAny: - */
 /**
- * Creates a throttled function that only invokes the provided function at most once per every specified milliseconds.
+ * Curries a function, allowing it to be called with partial arguments.
  *
  * @example
  * ```ts
- * const log = () => console.log('Hello, world!');
- * const throttledLog = throttle(log, 1000);
- *
- * throttledLog(); // logs 'Hello, world!' immediately
- * throttledLog(); // does nothing because less than 1 second has passed since the last invocation
- * setTimeout(throttledLog, 1000); // logs 'Hello, world!' after 1 second
+ * const add = (a: number, b: number) => a + b;
+ * const curriedAdd = curry(add);
+ * curriedAdd(1)(2) // 3;
  * ```
  *
- * @param fn - The function to throttle.
- * @param [delay=700] - The number of milliseconds to wait before invoking the function again.
+ * @param fn - The function to curry.
+ * @param arity - The number of arguments the function expects. Defaults to the function's length.
  *
- * @returns A new function that throttles the input function.
+ * @returns A curried version of the function.
  */
-export declare function throttle<T extends Fn>(fn: T, delay?: number): (...args: Parameters<T>) => void;
+declare type Take<N extends number, T extends readonly unknown[], Acc extends readonly unknown[] = []> = Acc['length'] extends N ? Acc : T extends readonly [infer H, ...infer R] ? Take<N, R, readonly [...Acc, H]> : Acc;
+
+/**
+ * Throttles a function. By default, leading and trailing are both true (lodash-like behavior).
+ * The function is invoked at the leading edge and trailing edge of the throttle period.
+ *
+ * Example:
+ * const fn = () => ...
+ * const t = throttle(fn, 700);
+ * const leadingOnly = throttle(fn, 700, { trailing: false });
+ */
+export declare function throttle<T extends Fn>(fn: T, delay?: number, options?: ThrottleOptions): Throttled<T>;
+
+export declare type Throttled<T extends Fn> = ((this: ThisParameterType<T>, ...args: Parameters<T>) => void) & {
+    cancel(): void;
+    flush(): ReturnType<T> | undefined;
+    pending(): boolean;
+};
+
+export declare type ThrottleOptions = {
+    leading?: boolean;
+    trailing?: boolean;
+};
 
 /**
  * Calculates the remaining time until a target date.
@@ -2178,6 +2187,8 @@ export declare type TimeUnit = 'YEAR' | 'MONTH' | 'WEEK' | 'DAY' | 'HOUR' | 'MIN
  * @param ellipsis - The characters to end the truncated string with.
  *
  * @returns The truncated string.
+ *
+ * @throws {TypeError} If str is not a string or limit is not a positive number.
  */
 export declare function truncate(str: string, limit?: number, completeWords?: boolean, ellipsis?: string): string;
 

package/dist/math/average.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("./sum.cjs");function o(t,n){if(t.length===0)return;let e;try{e=i.sum(t,n)}catch(r){if(r instanceof TypeError)return;throw r}if(typeof e=="number")return e/t.length;if(e instanceof Date)return new Date(e.getTime()/t.length)}exports.average=o;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("./sum.cjs");function u(e,n){if(e.length===0)return;if((n?n(e[0]):e[0])instanceof Date){const t=e.reduce((i,o)=>{const r=n?n(o):o;if(!(r instanceof Date))throw new TypeError("average expected all items to be Date objects");return i+r.getTime()},0);return new Date(t/e.length)}try{const t=s.sum(e,n);if(typeof t=="number")return t/e.length}catch(t){if(t instanceof TypeError)return;throw t}}exports.average=u;
 //# sourceMappingURL=average.cjs.map

package/dist/math/average.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"average.cjs","sources":["../../src/math/average.ts"],"sourcesContent":["import { sum } from './sum';\n\n/**\n * Calculates the average of an array of numbers or dates.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4, 5];\n * average(arr); // 3\n * average(arr, (num) => num * 2); // 6\n * average(arr, (num) => new Date(Date.now() + 1000 * 60 * 60 * 24 * num); // Date object representing 3 days from now\n * ```\n *\n * @param array - The array of numbers or dates to average.\n * @param callback - (optional) A callback function to map the values.\n * @returns The average of the numbers or dates in the array.\n */\n\nexport function average<T>(array: T[], callback?: (item: T) => number | Date): number | Date | undefined {\n  if (array.length === 0) return undefined;\n  let total: number | Date | undefined;\n  try {\n    total = sum(array, callback);\n  } catch (err) {\n    if (err instanceof TypeError) return undefined;\n    throw err;\n  }\n  if (typeof total === 'number') {\n    return total / array.length;\n  }\n  if (total instanceof Date) {\n    // For dates, average by dividing the timestamp sum by array length\n    return new Date(total.getTime() / array.length);\n  }\n  return undefined;\n}\n"],"names":["average","array","callback","total","sum","err"],"mappings":"6GAkBO,SAASA,EAAWC,EAAYC,EAAkE,CACvG,GAAID,EAAM,SAAW,EAAG,OACxB,IAAIE,EACJ,GAAI,CACFA,EAAQC,EAAAA,IAAIH,EAAOC,CAAQ,CAC7B,OAASG,EAAK,CACZ,GAAIA,aAAe,UAAW,OAC9B,MAAMA,CACR,CACA,GAAI,OAAOF,GAAU,SACnB,OAAOA,EAAQF,EAAM,OAEvB,GAAIE,aAAiB,KAEnB,OAAO,IAAI,KAAKA,EAAM,QAAA,EAAYF,EAAM,MAAM,CAGlD"}
+{"version":3,"file":"average.cjs","sources":["../../src/math/average.ts"],"sourcesContent":["import { sum } from './sum';\n\n/**\n * Calculates the average of an array of numbers or dates.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4, 5];\n * average(arr); // 3\n * average(arr, (num) => num * 2); // 6\n * average(arr, (num) => new Date(Date.now() + 1000 * 60 * 60 * 24 * num); // Date object representing 3 days from now\n * ```\n *\n * @param array - The array of numbers or dates to average.\n * @param callback - (optional) A callback function to map the values.\n * @returns The average of the numbers or dates in the array.\n */\n\nexport function average<T>(array: T[], callback?: (item: T) => number | Date): number | Date | undefined {\n  if (array.length === 0) return undefined;\n\n  // Check if we are dealing with Dates (either directly or via callback)\n  const firstItem = callback ? callback(array[0]) : array[0];\n  const isDate = firstItem instanceof Date;\n\n  if (isDate) {\n    const totalTimestamp = array.reduce<number>((acc, item) => {\n      const val = callback ? callback(item) : item;\n      if (!(val instanceof Date)) {\n        throw new TypeError('average expected all items to be Date objects');\n      }\n      return acc + val.getTime();\n    }, 0);\n    return new Date(totalTimestamp / array.length);\n  }\n\n  // Handle numbers\n  try {\n    const total = sum(array, callback as (item: T) => number);\n    if (typeof total === 'number') {\n      return total / array.length;\n    }\n  } catch (err) {\n    if (err instanceof TypeError) return undefined;\n    throw err;\n  }\n\n  return undefined;\n}\n"],"names":["average","array","callback","totalTimestamp","acc","item","val","total","sum","err"],"mappings":"6GAkBO,SAASA,EAAWC,EAAYC,EAAkE,CACvG,GAAID,EAAM,SAAW,EAAG,OAMxB,IAHkBC,EAAWA,EAASD,EAAM,CAAC,CAAC,EAAIA,EAAM,CAAC,aACrB,KAExB,CACV,MAAME,EAAiBF,EAAM,OAAe,CAACG,EAAKC,IAAS,CACzD,MAAMC,EAAMJ,EAAWA,EAASG,CAAI,EAAIA,EACxC,GAAI,EAAEC,aAAe,MACnB,MAAM,IAAI,UAAU,+CAA+C,EAErE,OAAOF,EAAME,EAAI,QAAA,CACnB,EAAG,CAAC,EACJ,OAAO,IAAI,KAAKH,EAAiBF,EAAM,MAAM,CAC/C,CAGA,GAAI,CACF,MAAMM,EAAQC,EAAAA,IAAIP,EAAOC,CAA+B,EACxD,GAAI,OAAOK,GAAU,SACnB,OAAOA,EAAQN,EAAM,MAEzB,OAASQ,EAAK,CACZ,GAAIA,aAAe,UAAW,OAC9B,MAAMA,CACR,CAGF"}

package/dist/math/average.js

@@ -1,19 +1,25 @@
-import { sum as o } from "./sum.js";
-function f(t, r) {
+import { sum as s } from "./sum.js";
+function p(t, n) {
   if (t.length === 0) return;
-  let e;
+  if ((n ? n(t[0]) : t[0]) instanceof Date) {
+    const e = t.reduce((i, o) => {
+      const r = n ? n(o) : o;
+      if (!(r instanceof Date))
+        throw new TypeError("average expected all items to be Date objects");
+      return i + r.getTime();
+    }, 0);
+    return new Date(e / t.length);
+  }
   try {
-    e = o(t, r);
-  } catch (n) {
-    if (n instanceof TypeError) return;
-    throw n;
+    const e = s(t, n);
+    if (typeof e == "number")
+      return e / t.length;
+  } catch (e) {
+    if (e instanceof TypeError) return;
+    throw e;
   }
-  if (typeof e == "number")
-    return e / t.length;
-  if (e instanceof Date)
-    return new Date(e.getTime() / t.length);
 }
 export {
-  f as average
+  p as average
 };
 //# sourceMappingURL=average.js.map

package/dist/math/average.js.map

@@ -1 +1 @@
-{"version":3,"file":"average.js","sources":["../../src/math/average.ts"],"sourcesContent":["import { sum } from './sum';\n\n/**\n * Calculates the average of an array of numbers or dates.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4, 5];\n * average(arr); // 3\n * average(arr, (num) => num * 2); // 6\n * average(arr, (num) => new Date(Date.now() + 1000 * 60 * 60 * 24 * num); // Date object representing 3 days from now\n * ```\n *\n * @param array - The array of numbers or dates to average.\n * @param callback - (optional) A callback function to map the values.\n * @returns The average of the numbers or dates in the array.\n */\n\nexport function average<T>(array: T[], callback?: (item: T) => number | Date): number | Date | undefined {\n  if (array.length === 0) return undefined;\n  let total: number | Date | undefined;\n  try {\n    total = sum(array, callback);\n  } catch (err) {\n    if (err instanceof TypeError) return undefined;\n    throw err;\n  }\n  if (typeof total === 'number') {\n    return total / array.length;\n  }\n  if (total instanceof Date) {\n    // For dates, average by dividing the timestamp sum by array length\n    return new Date(total.getTime() / array.length);\n  }\n  return undefined;\n}\n"],"names":["average","array","callback","total","sum","err"],"mappings":";AAkBO,SAASA,EAAWC,GAAYC,GAAkE;AACvG,MAAID,EAAM,WAAW,EAAG;AACxB,MAAIE;AACJ,MAAI;AACF,IAAAA,IAAQC,EAAIH,GAAOC,CAAQ;AAAA,EAC7B,SAASG,GAAK;AACZ,QAAIA,aAAe,UAAW;AAC9B,UAAMA;AAAA,EACR;AACA,MAAI,OAAOF,KAAU;AACnB,WAAOA,IAAQF,EAAM;AAEvB,MAAIE,aAAiB;AAEnB,WAAO,IAAI,KAAKA,EAAM,QAAA,IAAYF,EAAM,MAAM;AAGlD;"}
+{"version":3,"file":"average.js","sources":["../../src/math/average.ts"],"sourcesContent":["import { sum } from './sum';\n\n/**\n * Calculates the average of an array of numbers or dates.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4, 5];\n * average(arr); // 3\n * average(arr, (num) => num * 2); // 6\n * average(arr, (num) => new Date(Date.now() + 1000 * 60 * 60 * 24 * num); // Date object representing 3 days from now\n * ```\n *\n * @param array - The array of numbers or dates to average.\n * @param callback - (optional) A callback function to map the values.\n * @returns The average of the numbers or dates in the array.\n */\n\nexport function average<T>(array: T[], callback?: (item: T) => number | Date): number | Date | undefined {\n  if (array.length === 0) return undefined;\n\n  // Check if we are dealing with Dates (either directly or via callback)\n  const firstItem = callback ? callback(array[0]) : array[0];\n  const isDate = firstItem instanceof Date;\n\n  if (isDate) {\n    const totalTimestamp = array.reduce<number>((acc, item) => {\n      const val = callback ? callback(item) : item;\n      if (!(val instanceof Date)) {\n        throw new TypeError('average expected all items to be Date objects');\n      }\n      return acc + val.getTime();\n    }, 0);\n    return new Date(totalTimestamp / array.length);\n  }\n\n  // Handle numbers\n  try {\n    const total = sum(array, callback as (item: T) => number);\n    if (typeof total === 'number') {\n      return total / array.length;\n    }\n  } catch (err) {\n    if (err instanceof TypeError) return undefined;\n    throw err;\n  }\n\n  return undefined;\n}\n"],"names":["average","array","callback","totalTimestamp","acc","item","val","total","sum","err"],"mappings":";AAkBO,SAASA,EAAWC,GAAYC,GAAkE;AACvG,MAAID,EAAM,WAAW,EAAG;AAMxB,OAHkBC,IAAWA,EAASD,EAAM,CAAC,CAAC,IAAIA,EAAM,CAAC,cACrB,MAExB;AACV,UAAME,IAAiBF,EAAM,OAAe,CAACG,GAAKC,MAAS;AACzD,YAAMC,IAAMJ,IAAWA,EAASG,CAAI,IAAIA;AACxC,UAAI,EAAEC,aAAe;AACnB,cAAM,IAAI,UAAU,+CAA+C;AAErE,aAAOF,IAAME,EAAI,QAAA;AAAA,IACnB,GAAG,CAAC;AACJ,WAAO,IAAI,KAAKH,IAAiBF,EAAM,MAAM;AAAA,EAC/C;AAGA,MAAI;AACF,UAAMM,IAAQC,EAAIP,GAAOC,CAA+B;AACxD,QAAI,OAAOK,KAAU;AACnB,aAAOA,IAAQN,EAAM;AAAA,EAEzB,SAASQ,GAAK;AACZ,QAAIA,aAAe,UAAW;AAC9B,UAAMA;AAAA,EACR;AAGF;"}