@vielzeug/toolkit 1.1.2 → 2.0.0

package/dist/function/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../src/function/compose.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAInC,KAAK,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,GAAG,EAAE,MAAM,IAAI,SAAS,EAAE,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;AAC9F,KAAK,eAAe,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,SAAS,EAAE,EAAE,GAAG,GAAG,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;AAEjG;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,eAAe,CAAC,CAAC,CAAC,CASrG"}

package/dist/function/compose.js

@@ -1,14 +1,11 @@
-import { isPromise as c } from "../typed/isPromise.js";
-import { assert as n } from "./assert.js";
-function l(...t) {
-  n(t.length > 0, "compose requires at least one function", { args: { fns: t } });
-  const r = t[t.length - 1], s = t.slice(0, -1);
-  return ((...i) => s.reduceRight(
-    (e, o) => c(e) ? e.then(o) : o(e),
-    r(...i)
-  ));
+import { assert as e } from "./assert.js";
+//#region src/function/compose.ts
+function t(...t) {
+	e(t.length > 0, "compose requires at least one function", { args: { fns: t } });
+	let n = t[t.length - 1], r = t.slice(0, -1);
+	return ((...e) => r.reduceRight((e, t) => t(e), n(...e)));
 }
-export {
-  l as compose
-};
-//# sourceMappingURL=compose.js.map
+//#endregion
+export { t as compose };
+
+//# sourceMappingURL=compose.js.map

package/dist/function/compose.js.map

@@ -1 +1 @@
-{"version":3,"file":"compose.js","sources":["../../src/function/compose.ts"],"sourcesContent":["/** biome-ignore-all lint/suspicious/noExplicitAny: - */\n\nimport { isPromise } from '../typed/isPromise';\nimport type { FnDynamic } from '../types';\nimport { assert } from './assert';\n\ntype LastParameters<T> = T extends [...any, infer Last extends FnDynamic] ? Parameters<Last> : never;\ntype FirstReturnType<F> = F extends [infer First extends FnDynamic, ...any] ? ReturnType<First> : never;\ntype ComposeReturn<T extends FnDynamic[]> = (\n  ...args: LastParameters<T>\n) => FirstReturnType<T> extends Promise<any> ? Promise<Awaited<FirstReturnType<T>>> : FirstReturnType<T>;\n/**\n * Composes multiple functions into a single function. It starts from the rightmost function and proceeds to the left.\n *\n * @example\n * ```ts\n * const add = (x) => x + 2;\n * const multiply = (x) => x * 3;\n * const subtract = (x) => x - 4;\n * const composedFn = compose(subtract, multiply, add);\n * composedFn(5); // ((5 + 2) * 3) - 4 = 17\n * ```\n *\n * @example\n * ```ts\n * const square = async (x) => x * x;\n * const add = async (x) => x + 2;\n * const composedFn = compose(square, add);\n * await composedFn(4); // (4 * 4) + 2 = 18\n * ```\n *\n * @param fns - List of the functions to be composed.\n *\n * @returns A new function that is the composition of the input functions.\n */\nexport function compose<T extends FnDynamic[]>(...fns: T): ComposeReturn<T> {\n  assert(fns.length > 0, 'compose requires at least one function', { args: { fns } });\n\n  const lastFn = fns[fns.length - 1];\n  const restFns = fns.slice(0, -1);\n\n  return ((...args: LastParameters<T>) =>\n    restFns.reduceRight(\n      (prev, fn) => (isPromise(prev) ? prev.then(fn) : fn(prev)),\n      lastFn(...args),\n    )) as ComposeReturn<T>;\n}\n"],"names":["compose","fns","assert","lastFn","restFns","args","prev","fn","isPromise"],"mappings":";;AAmCO,SAASA,KAAkCC,GAA0B;AAC1E,EAAAC,EAAOD,EAAI,SAAS,GAAG,0CAA0C,EAAE,MAAM,EAAE,KAAAA,EAAA,GAAO;AAElF,QAAME,IAASF,EAAIA,EAAI,SAAS,CAAC,GAC3BG,IAAUH,EAAI,MAAM,GAAG,EAAE;AAE/B,UAAQ,IAAII,MACVD,EAAQ;AAAA,IACN,CAACE,GAAMC,MAAQC,EAAUF,CAAI,IAAIA,EAAK,KAAKC,CAAE,IAAIA,EAAGD,CAAI;AAAA,IACxDH,EAAO,GAAGE,CAAI;AAAA,EAAA;AAEpB;"}
+{"version":3,"file":"compose.js","names":[],"sources":["../../src/function/compose.ts"],"sourcesContent":["import type { Fn } from '../types';\n\nimport { assert } from './assert';\n\ntype LastParameters<T> = T extends [...any, infer Last extends Fn] ? Parameters<Last> : never;\ntype FirstReturnType<F> = F extends [infer First extends Fn, ...any] ? ReturnType<First> : never;\n\n/**\n * Composes multiple functions into a single function. It starts from the rightmost function and proceeds to the left.\n *\n * @example\n * ```ts\n * const add = (x) => x + 2;\n * const multiply = (x) => x * 3;\n * const subtract = (x) => x - 4;\n * const composedFn = compose(subtract, multiply, add);\n * composedFn(5); // ((5 + 2) * 3) - 4 = 17\n * ```\n *\n * @param fns - List of the functions to be composed.\n *\n * @returns A new function that is the composition of the input functions.\n */\nexport function compose<T extends Fn[]>(...fns: T): (...args: LastParameters<T>) => FirstReturnType<T> {\n  assert(fns.length > 0, 'compose requires at least one function', { args: { fns } });\n\n  const lastFn = fns[fns.length - 1];\n  const restFns = fns.slice(0, -1);\n\n  return ((...args: LastParameters<T>) => restFns.reduceRight((prev, fn) => fn(prev), lastFn(...args))) as (\n    ...args: LastParameters<T>\n  ) => FirstReturnType<T>;\n}\n"],"mappings":";;AAuBA,SAAgB,EAAwB,GAAG,GAA4D;AACrG,GAAO,EAAI,SAAS,GAAG,0CAA0C,EAAE,MAAM,EAAE,QAAK,EAAE,CAAC;CAEnF,IAAM,IAAS,EAAI,EAAI,SAAS,IAC1B,IAAU,EAAI,MAAM,GAAG,GAAG;AAEhC,UAAS,GAAG,MAA4B,EAAQ,aAAa,GAAM,MAAO,EAAG,EAAK,EAAE,EAAO,GAAG,EAAK,CAAC"}

package/dist/function/curry.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function c(e,u=e.length){const t=(...r)=>r.length>=u?e(...r):(...n)=>t(...r,...n);return t}exports.curry=c;
-//# sourceMappingURL=curry.cjs.map
+function e(e,t=e.length){let n=(...r)=>r.length>=t?e(...r):(...e)=>n(...r,...e);return n}exports.curry=e;
+//# sourceMappingURL=curry.cjs.map

package/dist/function/curry.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"curry.cjs","sources":["../../src/function/curry.ts"],"sourcesContent":["/** biome-ignore-all lint/suspicious/noExplicitAny: - */\n\n/**\n * Curries a function, allowing it to be called with partial arguments.\n *\n * @example\n * ```ts\n * const add = (a: number, b: number) => a + b;\n * const curriedAdd = curry(add);\n * curriedAdd(1)(2) // 3;\n * ```\n *\n * @param fn - The function to curry.\n * @param arity - The number of arguments the function expects. Defaults to the function's length.\n *\n * @returns A curried version of the function.\n */\n\n// Take first N items from tuple T\ntype Take<N extends number, T extends readonly unknown[], Acc extends readonly unknown[] = []> = Acc['length'] extends N\n  ? Acc\n  : T extends readonly [infer H, ...infer R]\n    ? Take<N, R, readonly [...Acc, H]>\n    : Acc;\n// Curried: at each step, accept a non-empty tuple of args A,\n// ensure it's a prefix of P, then either return R (if done) or recurse.\nexport type Curried<P extends readonly unknown[], R> = P extends readonly []\n  ? () => R\n  : <A extends readonly [unknown, ...(readonly unknown[])]>(\n      ...args: A\n    ) => P extends readonly [...A, ...infer Rest] ? (Rest extends readonly [] ? R : Curried<Rest, R>) : never;\n// Overloads to reflect default arity vs. a custom arity.\nexport function curry<T extends (...args: any[]) => any>(fn: T): Curried<Parameters<T>, ReturnType<T>>;\nexport function curry<T extends (...args: any[]) => any, N extends number>(\n  fn: T,\n  arity: N,\n): Curried<Take<N, Parameters<T>>, ReturnType<T>>;\n// Runtime implementation\nexport function curry(fn: (...args: any[]) => any, arity = fn.length) {\n  const curried = (...args: any[]): any => {\n    if (args.length >= arity) {\n      return fn(...args);\n    }\n    return (...rest: any[]) => curried(...args, ...rest);\n  };\n  return curried as any;\n}\n"],"names":["curry","fn","arity","curried","args","rest"],"mappings":"gFAsCO,SAASA,EAAMC,EAA6BC,EAAQD,EAAG,OAAQ,CACpE,MAAME,EAAU,IAAIC,IACdA,EAAK,QAAUF,EACVD,EAAG,GAAGG,CAAI,EAEZ,IAAIC,IAAgBF,EAAQ,GAAGC,EAAM,GAAGC,CAAI,EAErD,OAAOF,CACT"}
+{"version":3,"file":"curry.cjs","names":[],"sources":["../../src/function/curry.ts"],"sourcesContent":["/**\n * Curries a function, allowing it to be called with partial arguments.\n *\n * @example\n * ```ts\n * const add = (a: number, b: number) => a + b;\n * const curriedAdd = curry(add);\n * curriedAdd(1)(2) // 3;\n * ```\n *\n * @param fn - The function to curry.\n * @param arity - The number of arguments the function expects. Defaults to the function's length.\n *\n * @returns A curried version of the function.\n */\n\n// Take first N items from tuple T\ntype Take<N extends number, T extends readonly unknown[], Acc extends readonly unknown[] = []> = Acc['length'] extends N\n  ? Acc\n  : T extends readonly [infer H, ...infer R]\n    ? Take<N, R, readonly [...Acc, H]>\n    : Acc;\n// Curried: at each step, accept a non-empty tuple of args A,\n// ensure it's a prefix of P, then either return R (if done) or recurse.\nexport type Curried<P extends readonly unknown[], R> = P extends readonly []\n  ? () => R\n  : <A extends readonly [unknown, ...(readonly unknown[])]>(\n      ...args: A\n    ) => P extends readonly [...A, ...infer Rest] ? (Rest extends readonly [] ? R : Curried<Rest, R>) : never;\n// Overloads to reflect default arity vs. a custom arity.\nexport function curry<T extends (...args: any[]) => any>(fn: T): Curried<Parameters<T>, ReturnType<T>>;\nexport function curry<T extends (...args: any[]) => any, N extends number>(\n  fn: T,\n  arity: N,\n): Curried<Take<N, Parameters<T>>, ReturnType<T>>;\n// Runtime implementation\nexport function curry(fn: (...args: any[]) => any, arity = fn.length) {\n  const curried = (...args: any[]): any => {\n    if (args.length >= arity) {\n      return fn(...args);\n    }\n\n    return (...rest: any[]) => curried(...args, ...rest);\n  };\n\n  return curried as any;\n}\n"],"mappings":"AAoCA,SAAgB,EAAM,EAA6B,EAAQ,EAAG,OAAQ,CACpE,IAAM,GAAW,GAAG,IACd,EAAK,QAAU,EACV,EAAG,GAAG,EAAK,EAGZ,GAAG,IAAgB,EAAQ,GAAG,EAAM,GAAG,EAAK,CAGtD,OAAO"}

package/dist/function/curry.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ * @param arity - The number of arguments the function expects. Defaults to the function's length.
+ *
+ * @returns A curried version of the function.
+ */
+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;
+export 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;
+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>>;
+export {};
+//# sourceMappingURL=curry.d.ts.map

package/dist/function/curry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry.d.ts","sourceRoot":"","sources":["../../src/function/curry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,KAAK,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,GAAG,SAAS,SAAS,OAAO,EAAE,GAAG,EAAE,IAAI,GAAG,CAAC,QAAQ,CAAC,SAAS,CAAC,GACpH,GAAG,GACH,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,GACtC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,GAChC,GAAG,CAAC;AAGV,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,SAAS,EAAE,GACxE,MAAM,CAAC,GACP,CAAC,CAAC,SAAS,SAAS,CAAC,OAAO,EAAE,GAAG,CAAC,SAAS,OAAO,EAAE,CAAC,CAAC,EACpD,GAAG,IAAI,EAAE,CAAC,KACP,CAAC,SAAS,SAAS,CAAC,GAAG,CAAC,EAAE,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,IAAI,SAAS,SAAS,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;AAE9G,wBAAgB,KAAK,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;AACvG,wBAAgB,KAAK,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,CAAC,SAAS,MAAM,EACvE,EAAE,EAAE,CAAC,EACL,KAAK,EAAE,CAAC,GACP,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/dist/function/curry.js

@@ -1,8 +1,9 @@
-function c(t, n = t.length) {
-  const e = (...r) => r.length >= n ? t(...r) : (...u) => e(...r, ...u);
-  return e;
+//#region src/function/curry.ts
+function e(e, t = e.length) {
+	let n = (...r) => r.length >= t ? e(...r) : (...e) => n(...r, ...e);
+	return n;
 }
-export {
-  c as curry
-};
-//# sourceMappingURL=curry.js.map
+//#endregion
+export { e as curry };
+
+//# sourceMappingURL=curry.js.map

package/dist/function/curry.js.map

@@ -1 +1 @@
-{"version":3,"file":"curry.js","sources":["../../src/function/curry.ts"],"sourcesContent":["/** biome-ignore-all lint/suspicious/noExplicitAny: - */\n\n/**\n * Curries a function, allowing it to be called with partial arguments.\n *\n * @example\n * ```ts\n * const add = (a: number, b: number) => a + b;\n * const curriedAdd = curry(add);\n * curriedAdd(1)(2) // 3;\n * ```\n *\n * @param fn - The function to curry.\n * @param arity - The number of arguments the function expects. Defaults to the function's length.\n *\n * @returns A curried version of the function.\n */\n\n// Take first N items from tuple T\ntype Take<N extends number, T extends readonly unknown[], Acc extends readonly unknown[] = []> = Acc['length'] extends N\n  ? Acc\n  : T extends readonly [infer H, ...infer R]\n    ? Take<N, R, readonly [...Acc, H]>\n    : Acc;\n// Curried: at each step, accept a non-empty tuple of args A,\n// ensure it's a prefix of P, then either return R (if done) or recurse.\nexport type Curried<P extends readonly unknown[], R> = P extends readonly []\n  ? () => R\n  : <A extends readonly [unknown, ...(readonly unknown[])]>(\n      ...args: A\n    ) => P extends readonly [...A, ...infer Rest] ? (Rest extends readonly [] ? R : Curried<Rest, R>) : never;\n// Overloads to reflect default arity vs. a custom arity.\nexport function curry<T extends (...args: any[]) => any>(fn: T): Curried<Parameters<T>, ReturnType<T>>;\nexport function curry<T extends (...args: any[]) => any, N extends number>(\n  fn: T,\n  arity: N,\n): Curried<Take<N, Parameters<T>>, ReturnType<T>>;\n// Runtime implementation\nexport function curry(fn: (...args: any[]) => any, arity = fn.length) {\n  const curried = (...args: any[]): any => {\n    if (args.length >= arity) {\n      return fn(...args);\n    }\n    return (...rest: any[]) => curried(...args, ...rest);\n  };\n  return curried as any;\n}\n"],"names":["curry","fn","arity","curried","args","rest"],"mappings":"AAsCO,SAASA,EAAMC,GAA6BC,IAAQD,EAAG,QAAQ;AACpE,QAAME,IAAU,IAAIC,MACdA,EAAK,UAAUF,IACVD,EAAG,GAAGG,CAAI,IAEZ,IAAIC,MAAgBF,EAAQ,GAAGC,GAAM,GAAGC,CAAI;AAErD,SAAOF;AACT;"}
+{"version":3,"file":"curry.js","names":[],"sources":["../../src/function/curry.ts"],"sourcesContent":["/**\n * Curries a function, allowing it to be called with partial arguments.\n *\n * @example\n * ```ts\n * const add = (a: number, b: number) => a + b;\n * const curriedAdd = curry(add);\n * curriedAdd(1)(2) // 3;\n * ```\n *\n * @param fn - The function to curry.\n * @param arity - The number of arguments the function expects. Defaults to the function's length.\n *\n * @returns A curried version of the function.\n */\n\n// Take first N items from tuple T\ntype Take<N extends number, T extends readonly unknown[], Acc extends readonly unknown[] = []> = Acc['length'] extends N\n  ? Acc\n  : T extends readonly [infer H, ...infer R]\n    ? Take<N, R, readonly [...Acc, H]>\n    : Acc;\n// Curried: at each step, accept a non-empty tuple of args A,\n// ensure it's a prefix of P, then either return R (if done) or recurse.\nexport type Curried<P extends readonly unknown[], R> = P extends readonly []\n  ? () => R\n  : <A extends readonly [unknown, ...(readonly unknown[])]>(\n      ...args: A\n    ) => P extends readonly [...A, ...infer Rest] ? (Rest extends readonly [] ? R : Curried<Rest, R>) : never;\n// Overloads to reflect default arity vs. a custom arity.\nexport function curry<T extends (...args: any[]) => any>(fn: T): Curried<Parameters<T>, ReturnType<T>>;\nexport function curry<T extends (...args: any[]) => any, N extends number>(\n  fn: T,\n  arity: N,\n): Curried<Take<N, Parameters<T>>, ReturnType<T>>;\n// Runtime implementation\nexport function curry(fn: (...args: any[]) => any, arity = fn.length) {\n  const curried = (...args: any[]): any => {\n    if (args.length >= arity) {\n      return fn(...args);\n    }\n\n    return (...rest: any[]) => curried(...args, ...rest);\n  };\n\n  return curried as any;\n}\n"],"mappings":";AAoCA,SAAgB,EAAM,GAA6B,IAAQ,EAAG,QAAQ;CACpE,IAAM,KAAW,GAAG,MACd,EAAK,UAAU,IACV,EAAG,GAAG,EAAK,IAGZ,GAAG,MAAgB,EAAQ,GAAG,GAAM,GAAG,EAAK;AAGtD,QAAO"}

package/dist/function/debounce.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l=require("./assert.cjs");function v(s,o=300){l.assert(typeof s=="function","First argument must be a function",{args:{fn:s},type:TypeError}),l.assert(typeof o=="number"&&o>=0,"Delay must be a non-negative number",{args:{delay:o},type:TypeError});let e,t,r,c;const i=()=>{e!==void 0&&(clearTimeout(e),e=void 0)},a=()=>{if(i(),!t)return;const u=t,d=r;return t=void 0,r=void 0,c=s.apply(d,u),c},n=function(...u){t=u,r=this,i(),e=setTimeout(a,o)};return n.cancel=()=>{i(),t=void 0,r=void 0},n.flush=()=>a(),n.pending=()=>e!==void 0,n}exports.debounce=v;
-//# sourceMappingURL=debounce.cjs.map
+const e=require(`./assert.cjs`),t=require(`../async/scheduler.cjs`);function n(n,r=300){e.assert(typeof n==`function`,`First argument must be a function`,{args:{fn:n},type:TypeError}),e.assert(typeof r==`number`&&r>=0,`Delay must be a non-negative number`,{args:{delay:r},type:TypeError});let i,a,o,s=()=>{i!==void 0&&(i.abort(),i=void 0)},c=()=>{let e=new AbortController,n=new t.Scheduler;i=e,n.postTask(l,{delay:r,priority:`user-visible`,signal:e.signal}).catch(()=>{})},l=()=>{if(s(),!a)return;let e=a,t=o;return a=void 0,o=void 0,n.apply(t,e)},u=function(...e){a=e,o=this,s(),c()};return u.cancel=()=>{s(),a=void 0,o=void 0},u.flush=()=>l(),u.pending=()=>i!==void 0,u}exports.debounce=n;
+//# sourceMappingURL=debounce.cjs.map

package/dist/function/debounce.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"debounce.cjs","sources":["../../src/function/debounce.ts"],"sourcesContent":["import type { Fn } from '../types';\nimport { assert } from './assert';\n\nexport type Debounced<T extends Fn> = ((this: ThisParameterType<T>, ...args: Parameters<T>) => void) & {\n  cancel(): void;\n  flush(): ReturnType<T> | undefined;\n  pending(): boolean;\n};\n\n/**\n * Debounce a function (trailing). Use `flush` to invoke immediately,\n * `cancel` to clear, and `pending` to check if an invocation is scheduled.\n */\nexport function debounce<T extends Fn>(fn: T, delay = 300): Debounced<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  let timer: ReturnType<typeof setTimeout> | undefined;\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 = () => {\n    clearTimer();\n    if (!lastArgs) return undefined; // nothing to invoke\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 debounced = function (this: ThisParameterType<T>, ...args: Parameters<T>) {\n    lastArgs = args;\n    lastThis = this;\n    clearTimer();\n    timer = setTimeout(invoke, delay);\n  } as Debounced<T>;\n\n  debounced.cancel = () => {\n    clearTimer();\n    lastArgs = undefined;\n    lastThis = undefined;\n  };\n\n  debounced.flush = () => invoke() as ReturnType<T> | undefined;\n\n  debounced.pending = () => timer !== undefined;\n\n  return debounced;\n}\n"],"names":["debounce","fn","delay","assert","timer","lastArgs","lastThis","lastResult","clearTimer","invoke","args","ctx","debounced"],"mappings":"gHAaO,SAASA,EAAuBC,EAAOC,EAAQ,IAAmB,CACvEC,EAAAA,OAAO,OAAOF,GAAO,WAAY,oCAAqC,CACpE,KAAM,CAAE,GAAAA,CAAA,EACR,KAAM,SAAA,CACP,EACDE,EAAAA,OAAO,OAAOD,GAAU,UAAYA,GAAS,EAAG,sCAAuC,CACrF,KAAM,CAAE,MAAAA,CAAA,EACR,KAAM,SAAA,CACP,EAED,IAAIE,EACAC,EACAC,EACAC,EAEJ,MAAMC,EAAa,IAAM,CACnBJ,IAAU,SACZ,aAAaA,CAAK,EAClBA,EAAQ,OAEZ,EAEMK,EAAS,IAAM,CAEnB,GADAD,EAAA,EACI,CAACH,EAAU,OACf,MAAMK,EAAOL,EACPM,EAAML,EACZ,OAAAD,EAAW,OACXC,EAAW,OAEXC,EAAaN,EAAG,MAAMU,EAAYD,CAAI,EAC/BH,CACT,EAEMK,EAAY,YAAyCF,EAAqB,CAC9EL,EAAWK,EACXJ,EAAW,KACXE,EAAA,EACAJ,EAAQ,WAAWK,EAAQP,CAAK,CAClC,EAEA,OAAAU,EAAU,OAAS,IAAM,CACvBJ,EAAA,EACAH,EAAW,OACXC,EAAW,MACb,EAEAM,EAAU,MAAQ,IAAMH,EAAA,EAExBG,EAAU,QAAU,IAAMR,IAAU,OAE7BQ,CACT"}
+{"version":3,"file":"debounce.cjs","names":[],"sources":["../../src/function/debounce.ts"],"sourcesContent":["import type { Fn } from '../types';\n\nimport { Scheduler } from '../async/scheduler';\nimport { assert } from './assert';\n\nexport type Debounced<T extends Fn> = ((this: ThisParameterType<T>, ...args: Parameters<T>) => void) & {\n  cancel(): void;\n  flush(): ReturnType<T> | undefined;\n  pending(): boolean;\n};\n\n/**\n * Debounce a function (trailing). Use `flush` to invoke immediately,\n * `cancel` to clear, and `pending` to check if an invocation is scheduled.\n */\nexport function debounce<T extends Fn>(fn: T, delay = 300): Debounced<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  let timerController: AbortController | undefined;\n  let lastArgs: Parameters<T> | undefined;\n  let lastThis: ThisParameterType<T> | undefined;\n\n  const clearTimer = () => {\n    if (timerController !== undefined) {\n      timerController.abort();\n      timerController = undefined;\n    }\n  };\n\n  const scheduleInvoke = () => {\n    const controller = new AbortController();\n    const scheduler = new Scheduler();\n\n    timerController = controller;\n    void scheduler\n      .postTask(invoke, {\n        delay,\n        priority: 'user-visible',\n        signal: controller.signal,\n      })\n      .catch(() => {\n        // Aborts are expected when debounce is rescheduled or canceled.\n      });\n  };\n\n  const invoke = () => {\n    clearTimer();\n\n    if (!lastArgs) return undefined; // nothing to invoke\n\n    const args = lastArgs;\n    const ctx = lastThis as ThisParameterType<T>;\n\n    lastArgs = undefined;\n    lastThis = undefined;\n\n    return fn.apply(ctx as any, args) as ReturnType<T>;\n  };\n\n  const debounced = function (this: ThisParameterType<T>, ...args: Parameters<T>) {\n    lastArgs = args;\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    lastThis = this;\n    clearTimer();\n    scheduleInvoke();\n  } as Debounced<T>;\n\n  debounced.cancel = () => {\n    clearTimer();\n    lastArgs = undefined;\n    lastThis = undefined;\n  };\n\n  debounced.flush = () => invoke() as ReturnType<T> | undefined;\n\n  debounced.pending = () => timerController !== undefined;\n\n  return debounced;\n}\n"],"mappings":"oEAeA,SAAgB,EAAuB,EAAO,EAAQ,IAAmB,CACvE,EAAA,OAAO,OAAO,GAAO,WAAY,oCAAqC,CACpE,KAAM,CAAE,KAAI,CACZ,KAAM,UACP,CAAC,CACF,EAAA,OAAO,OAAO,GAAU,UAAY,GAAS,EAAG,sCAAuC,CACrF,KAAM,CAAE,QAAO,CACf,KAAM,UACP,CAAC,CAEF,IAAI,EACA,EACA,EAEE,MAAmB,CACnB,IAAoB,IAAA,KACtB,EAAgB,OAAO,CACvB,EAAkB,IAAA,KAIhB,MAAuB,CAC3B,IAAM,EAAa,IAAI,gBACjB,EAAY,IAAI,EAAA,UAEtB,EAAkB,EACb,EACF,SAAS,EAAQ,CAChB,QACA,SAAU,eACV,OAAQ,EAAW,OACpB,CAAC,CACD,UAAY,GAEX,EAGA,MAAe,CAGnB,GAFA,GAAY,CAER,CAAC,EAAU,OAEf,IAAM,EAAO,EACP,EAAM,EAKZ,MAHA,GAAW,IAAA,GACX,EAAW,IAAA,GAEJ,EAAG,MAAM,EAAY,EAAK,EAG7B,EAAY,SAAsC,GAAG,EAAqB,CAC9E,EAAW,EAEX,EAAW,KACX,GAAY,CACZ,GAAgB,EAalB,MAVA,GAAU,WAAe,CACvB,GAAY,CACZ,EAAW,IAAA,GACX,EAAW,IAAA,IAGb,EAAU,UAAc,GAAQ,CAEhC,EAAU,YAAgB,IAAoB,IAAA,GAEvC"}

package/dist/function/debounce.d.ts

@@ -0,0 +1,12 @@
+import type { Fn } from '../types';
+export type Debounced<T extends Fn> = ((this: ThisParameterType<T>, ...args: Parameters<T>) => void) & {
+    cancel(): void;
+    flush(): ReturnType<T> | undefined;
+    pending(): boolean;
+};
+/**
+ * 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): Debounced<T>;
+//# sourceMappingURL=debounce.d.ts.map

package/dist/function/debounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../src/function/debounce.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAKnC,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,GAAG;IACrG,MAAM,IAAI,IAAI,CAAC;IACf,KAAK,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IACnC,OAAO,IAAI,OAAO,CAAC;CACpB,CAAC;AAEF;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,SAAM,GAAG,SAAS,CAAC,CAAC,CAAC,CAsEvE"}

package/dist/function/debounce.js

@@ -1,27 +1,35 @@
-import { assert as l } from "./assert.js";
-function v(i, o = 300) {
-  l(typeof i == "function", "First argument must be a function", {
-    args: { fn: i },
-    type: TypeError
-  }), l(typeof o == "number" && o >= 0, "Delay must be a non-negative number", {
-    args: { delay: o },
-    type: TypeError
-  });
-  let t, e, r, c;
-  const s = () => {
-    t !== void 0 && (clearTimeout(t), t = void 0);
-  }, a = () => {
-    if (s(), !e) return;
-    const u = e, m = r;
-    return e = void 0, r = void 0, c = i.apply(m, u), c;
-  }, n = function(...u) {
-    e = u, r = this, s(), t = setTimeout(a, o);
-  };
-  return n.cancel = () => {
-    s(), e = void 0, r = void 0;
-  }, n.flush = () => a(), n.pending = () => t !== void 0, n;
+import { assert as e } from "./assert.js";
+import { Scheduler as t } from "../async/scheduler.js";
+//#region src/function/debounce.ts
+function n(n, r = 300) {
+	e(typeof n == "function", "First argument must be a function", {
+		args: { fn: n },
+		type: TypeError
+	}), e(typeof r == "number" && r >= 0, "Delay must be a non-negative number", {
+		args: { delay: r },
+		type: TypeError
+	});
+	let i, a, o, s = () => {
+		i !== void 0 && (i.abort(), i = void 0);
+	}, c = () => {
+		let e = new AbortController(), n = new t();
+		i = e, n.postTask(l, {
+			delay: r,
+			priority: "user-visible",
+			signal: e.signal
+		}).catch(() => {});
+	}, l = () => {
+		if (s(), !a) return;
+		let e = a, t = o;
+		return a = void 0, o = void 0, n.apply(t, e);
+	}, u = function(...e) {
+		a = e, o = this, s(), c();
+	};
+	return u.cancel = () => {
+		s(), a = void 0, o = void 0;
+	}, u.flush = () => l(), u.pending = () => i !== void 0, u;
 }
-export {
-  v as debounce
-};
-//# sourceMappingURL=debounce.js.map
+//#endregion
+export { n as debounce };
+
+//# sourceMappingURL=debounce.js.map

package/dist/function/debounce.js.map

@@ -1 +1 @@
-{"version":3,"file":"debounce.js","sources":["../../src/function/debounce.ts"],"sourcesContent":["import type { Fn } from '../types';\nimport { assert } from './assert';\n\nexport type Debounced<T extends Fn> = ((this: ThisParameterType<T>, ...args: Parameters<T>) => void) & {\n  cancel(): void;\n  flush(): ReturnType<T> | undefined;\n  pending(): boolean;\n};\n\n/**\n * Debounce a function (trailing). Use `flush` to invoke immediately,\n * `cancel` to clear, and `pending` to check if an invocation is scheduled.\n */\nexport function debounce<T extends Fn>(fn: T, delay = 300): Debounced<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  let timer: ReturnType<typeof setTimeout> | undefined;\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 = () => {\n    clearTimer();\n    if (!lastArgs) return undefined; // nothing to invoke\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 debounced = function (this: ThisParameterType<T>, ...args: Parameters<T>) {\n    lastArgs = args;\n    lastThis = this;\n    clearTimer();\n    timer = setTimeout(invoke, delay);\n  } as Debounced<T>;\n\n  debounced.cancel = () => {\n    clearTimer();\n    lastArgs = undefined;\n    lastThis = undefined;\n  };\n\n  debounced.flush = () => invoke() as ReturnType<T> | undefined;\n\n  debounced.pending = () => timer !== undefined;\n\n  return debounced;\n}\n"],"names":["debounce","fn","delay","assert","timer","lastArgs","lastThis","lastResult","clearTimer","invoke","args","ctx","debounced"],"mappings":";AAaO,SAASA,EAAuBC,GAAOC,IAAQ,KAAmB;AACvE,EAAAC,EAAO,OAAOF,KAAO,YAAY,qCAAqC;AAAA,IACpE,MAAM,EAAE,IAAAA,EAAA;AAAA,IACR,MAAM;AAAA,EAAA,CACP,GACDE,EAAO,OAAOD,KAAU,YAAYA,KAAS,GAAG,uCAAuC;AAAA,IACrF,MAAM,EAAE,OAAAA,EAAA;AAAA,IACR,MAAM;AAAA,EAAA,CACP;AAED,MAAIE,GACAC,GACAC,GACAC;AAEJ,QAAMC,IAAa,MAAM;AACvB,IAAIJ,MAAU,WACZ,aAAaA,CAAK,GAClBA,IAAQ;AAAA,EAEZ,GAEMK,IAAS,MAAM;AAEnB,QADAD,EAAA,GACI,CAACH,EAAU;AACf,UAAMK,IAAOL,GACPM,IAAML;AACZ,WAAAD,IAAW,QACXC,IAAW,QAEXC,IAAaN,EAAG,MAAMU,GAAYD,CAAI,GAC/BH;AAAA,EACT,GAEMK,IAAY,YAAyCF,GAAqB;AAC9E,IAAAL,IAAWK,GACXJ,IAAW,MACXE,EAAA,GACAJ,IAAQ,WAAWK,GAAQP,CAAK;AAAA,EAClC;AAEA,SAAAU,EAAU,SAAS,MAAM;AACvB,IAAAJ,EAAA,GACAH,IAAW,QACXC,IAAW;AAAA,EACb,GAEAM,EAAU,QAAQ,MAAMH,EAAA,GAExBG,EAAU,UAAU,MAAMR,MAAU,QAE7BQ;AACT;"}
+{"version":3,"file":"debounce.js","names":[],"sources":["../../src/function/debounce.ts"],"sourcesContent":["import type { Fn } from '../types';\n\nimport { Scheduler } from '../async/scheduler';\nimport { assert } from './assert';\n\nexport type Debounced<T extends Fn> = ((this: ThisParameterType<T>, ...args: Parameters<T>) => void) & {\n  cancel(): void;\n  flush(): ReturnType<T> | undefined;\n  pending(): boolean;\n};\n\n/**\n * Debounce a function (trailing). Use `flush` to invoke immediately,\n * `cancel` to clear, and `pending` to check if an invocation is scheduled.\n */\nexport function debounce<T extends Fn>(fn: T, delay = 300): Debounced<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  let timerController: AbortController | undefined;\n  let lastArgs: Parameters<T> | undefined;\n  let lastThis: ThisParameterType<T> | undefined;\n\n  const clearTimer = () => {\n    if (timerController !== undefined) {\n      timerController.abort();\n      timerController = undefined;\n    }\n  };\n\n  const scheduleInvoke = () => {\n    const controller = new AbortController();\n    const scheduler = new Scheduler();\n\n    timerController = controller;\n    void scheduler\n      .postTask(invoke, {\n        delay,\n        priority: 'user-visible',\n        signal: controller.signal,\n      })\n      .catch(() => {\n        // Aborts are expected when debounce is rescheduled or canceled.\n      });\n  };\n\n  const invoke = () => {\n    clearTimer();\n\n    if (!lastArgs) return undefined; // nothing to invoke\n\n    const args = lastArgs;\n    const ctx = lastThis as ThisParameterType<T>;\n\n    lastArgs = undefined;\n    lastThis = undefined;\n\n    return fn.apply(ctx as any, args) as ReturnType<T>;\n  };\n\n  const debounced = function (this: ThisParameterType<T>, ...args: Parameters<T>) {\n    lastArgs = args;\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    lastThis = this;\n    clearTimer();\n    scheduleInvoke();\n  } as Debounced<T>;\n\n  debounced.cancel = () => {\n    clearTimer();\n    lastArgs = undefined;\n    lastThis = undefined;\n  };\n\n  debounced.flush = () => invoke() as ReturnType<T> | undefined;\n\n  debounced.pending = () => timerController !== undefined;\n\n  return debounced;\n}\n"],"mappings":";;;AAeA,SAAgB,EAAuB,GAAO,IAAQ,KAAmB;AAKvE,CAJA,EAAO,OAAO,KAAO,YAAY,qCAAqC;EACpE,MAAM,EAAE,OAAI;EACZ,MAAM;EACP,CAAC,EACF,EAAO,OAAO,KAAU,YAAY,KAAS,GAAG,uCAAuC;EACrF,MAAM,EAAE,UAAO;EACf,MAAM;EACP,CAAC;CAEF,IAAI,GACA,GACA,GAEE,UAAmB;AACvB,EAAI,MAAoB,KAAA,MACtB,EAAgB,OAAO,EACvB,IAAkB,KAAA;IAIhB,UAAuB;EAC3B,IAAM,IAAa,IAAI,iBAAiB,EAClC,IAAY,IAAI,GAAW;AAG5B,EADL,IAAkB,GACb,EACF,SAAS,GAAQ;GAChB;GACA,UAAU;GACV,QAAQ,EAAW;GACpB,CAAC,CACD,YAAY,GAEX;IAGA,UAAe;AAGnB,MAFA,GAAY,EAER,CAAC,EAAU;EAEf,IAAM,IAAO,GACP,IAAM;AAKZ,SAHA,IAAW,KAAA,GACX,IAAW,KAAA,GAEJ,EAAG,MAAM,GAAY,EAAK;IAG7B,IAAY,SAAsC,GAAG,GAAqB;AAK9E,EAJA,IAAW,GAEX,IAAW,MACX,GAAY,EACZ,GAAgB;;AAalB,QAVA,EAAU,eAAe;AAGvB,EAFA,GAAY,EACZ,IAAW,KAAA,GACX,IAAW,KAAA;IAGb,EAAU,cAAc,GAAQ,EAEhC,EAAU,gBAAgB,MAAoB,KAAA,GAEvC"}

package/dist/function/fp.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./assert.cjs"),o=(e,...n)=>(r.assert(e.fp,`"${e.name}" cannot be used in functional programming mode. Please use the original function.`),t=>e(t,...n));exports.fp=o;
-//# sourceMappingURL=fp.cjs.map
+var e=(e,...t)=>n=>e(n,...t);exports.partial=e;
+//# sourceMappingURL=fp.cjs.map

package/dist/function/fp.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"fp.cjs","sources":["../../src/function/fp.ts"],"sourcesContent":["import type { Fn } from '../types';\nimport { assert } from './assert';\n\n// biome-ignore lint/suspicious/noExplicitAny: -\ntype RemoveFirstParameter<T extends Fn> = T extends (first: any, ...rest: infer R) => any ? R : never;\n\n/**\n * Creates a function that can be used in functional programming mode.\n * This function is a wrapper around the original function, allowing you to pass the first argument as an array.\n *\n * @example\n * ```ts\n * import { fp } from './fp';\n * import { map } from './map';\n *\n * const double = (num: number) => num * 2;\n * const doubleArray = fp(map, double);\n *\n * doubleArray([1, 2, 3]) // [2, 4, 6]\n * ```\n *\n * @param callback - The function to be wrapped.\n * @param args - The arguments to be passed to the function.\n *\n * @returns A function that takes an array and applies the original function to it.\n *\n * @throws {TypeError} If the function cannot be used in functional programming mode.\n */\nexport const fp = <T, F extends Fn = Fn>(callback: F, ...args: RemoveFirstParameter<F>) => {\n  assert(\n    // biome-ignore lint/suspicious/noExplicitAny: -\n    (callback as any).fp,\n    `\"${callback.name}\" cannot be used in functional programming mode. Please use the original function.`,\n  );\n  return (array: T[]) => callback(array, ...args);\n};\n"],"names":["fp","callback","args","assert","array"],"mappings":"gHA4BaA,EAAK,CAAuBC,KAAgBC,KACvDC,EAAAA,OAEGF,EAAiB,GAClB,IAAIA,EAAS,IAAI,oFAAA,EAEXG,GAAeH,EAASG,EAAO,GAAGF,CAAI"}
+{"version":3,"file":"fp.cjs","names":[],"sources":["../../src/function/fp.ts"],"sourcesContent":["import type { Fn } from '../types';\n\ntype RemoveFirstParameter<T extends Fn> = T extends (first: any, ...rest: infer R) => any ? R : never;\ntype FirstParameter<T extends Fn> = T extends (first: infer A, ...rest: any[]) => any ? A : never;\n\n/**\n * Partially applies a multi-arg function by pre-filling every argument\n * except the first — returning a unary function useful for pipeline composition.\n *\n * @example\n * ```ts\n * const double = (num: number) => num * 2;\n * const doubleAll = partial(select, double);\n * doubleAll([1, 2, 3]); // [2, 4, 6]\n *\n * // In a pipe\n * pipe(partial(select, (x: number) => x > 1 ? x * 2 : null))([1, 2, 3]); // [4, 6]\n * ```\n *\n * @param callback - Any function whose first argument is the collection.\n * @param args - The remaining arguments to pre-apply.\n * @returns A unary function `(collection) => ReturnType<F>`.\n */\nexport const partial = <F extends Fn>(callback: F, ...args: RemoveFirstParameter<F>) => {\n  return (collection: FirstParameter<F>) => callback(collection, ...args);\n};\n"],"mappings":"AAuBA,IAAa,GAAyB,EAAa,GAAG,IAC5C,GAAkC,EAAS,EAAY,GAAG,EAAK"}

package/dist/function/fp.d.ts

@@ -0,0 +1,24 @@
+import type { Fn } from '../types';
+type RemoveFirstParameter<T extends Fn> = T extends (first: any, ...rest: infer R) => any ? R : never;
+type FirstParameter<T extends Fn> = T extends (first: infer A, ...rest: any[]) => any ? A : never;
+/**
+ * Partially applies a multi-arg function by pre-filling every argument
+ * except the first — returning a unary function useful for pipeline composition.
+ *
+ * @example
+ * ```ts
+ * const double = (num: number) => num * 2;
+ * const doubleAll = partial(select, double);
+ * doubleAll([1, 2, 3]); // [2, 4, 6]
+ *
+ * // In a pipe
+ * pipe(partial(select, (x: number) => x > 1 ? x * 2 : null))([1, 2, 3]); // [4, 6]
+ * ```
+ *
+ * @param callback - Any function whose first argument is the collection.
+ * @param args - The remaining arguments to pre-apply.
+ * @returns A unary function `(collection) => ReturnType<F>`.
+ */
+export declare const partial: <F extends Fn>(callback: F, ...args: RemoveFirstParameter<F>) => (collection: FirstParameter<F>) => any;
+export {};
+//# sourceMappingURL=fp.d.ts.map

package/dist/function/fp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fp.d.ts","sourceRoot":"","sources":["../../src/function/fp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC,KAAK,oBAAoB,CAAC,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,MAAM,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,KAAK,CAAC;AACtG,KAAK,cAAc,CAAC,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAAG,CAAC,GAAG,KAAK,CAAC;AAElG;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,GAAG,MAAM,oBAAoB,CAAC,CAAC,CAAC,MACzE,YAAY,cAAc,CAAC,CAAC,CAAC,QACtC,CAAC"}

package/dist/function/fp.js

@@ -1,10 +1,6 @@
-import { assert as r } from "./assert.js";
-const i = (n, ...e) => (r(
-  // biome-ignore lint/suspicious/noExplicitAny: -
-  n.fp,
-  `"${n.name}" cannot be used in functional programming mode. Please use the original function.`
-), (o) => n(o, ...e));
-export {
-  i as fp
-};
-//# sourceMappingURL=fp.js.map
+//#region src/function/fp.ts
+var e = (e, ...t) => (n) => e(n, ...t);
+//#endregion
+export { e as partial };
+
+//# sourceMappingURL=fp.js.map

package/dist/function/fp.js.map

@@ -1 +1 @@
-{"version":3,"file":"fp.js","sources":["../../src/function/fp.ts"],"sourcesContent":["import type { Fn } from '../types';\nimport { assert } from './assert';\n\n// biome-ignore lint/suspicious/noExplicitAny: -\ntype RemoveFirstParameter<T extends Fn> = T extends (first: any, ...rest: infer R) => any ? R : never;\n\n/**\n * Creates a function that can be used in functional programming mode.\n * This function is a wrapper around the original function, allowing you to pass the first argument as an array.\n *\n * @example\n * ```ts\n * import { fp } from './fp';\n * import { map } from './map';\n *\n * const double = (num: number) => num * 2;\n * const doubleArray = fp(map, double);\n *\n * doubleArray([1, 2, 3]) // [2, 4, 6]\n * ```\n *\n * @param callback - The function to be wrapped.\n * @param args - The arguments to be passed to the function.\n *\n * @returns A function that takes an array and applies the original function to it.\n *\n * @throws {TypeError} If the function cannot be used in functional programming mode.\n */\nexport const fp = <T, F extends Fn = Fn>(callback: F, ...args: RemoveFirstParameter<F>) => {\n  assert(\n    // biome-ignore lint/suspicious/noExplicitAny: -\n    (callback as any).fp,\n    `\"${callback.name}\" cannot be used in functional programming mode. Please use the original function.`,\n  );\n  return (array: T[]) => callback(array, ...args);\n};\n"],"names":["fp","callback","args","assert","array"],"mappings":";AA4BO,MAAMA,IAAK,CAAuBC,MAAgBC,OACvDC;AAAA;AAAA,EAEGF,EAAiB;AAAA,EAClB,IAAIA,EAAS,IAAI;AAAA,GAEZ,CAACG,MAAeH,EAASG,GAAO,GAAGF,CAAI;"}
+{"version":3,"file":"fp.js","names":[],"sources":["../../src/function/fp.ts"],"sourcesContent":["import type { Fn } from '../types';\n\ntype RemoveFirstParameter<T extends Fn> = T extends (first: any, ...rest: infer R) => any ? R : never;\ntype FirstParameter<T extends Fn> = T extends (first: infer A, ...rest: any[]) => any ? A : never;\n\n/**\n * Partially applies a multi-arg function by pre-filling every argument\n * except the first — returning a unary function useful for pipeline composition.\n *\n * @example\n * ```ts\n * const double = (num: number) => num * 2;\n * const doubleAll = partial(select, double);\n * doubleAll([1, 2, 3]); // [2, 4, 6]\n *\n * // In a pipe\n * pipe(partial(select, (x: number) => x > 1 ? x * 2 : null))([1, 2, 3]); // [4, 6]\n * ```\n *\n * @param callback - Any function whose first argument is the collection.\n * @param args - The remaining arguments to pre-apply.\n * @returns A unary function `(collection) => ReturnType<F>`.\n */\nexport const partial = <F extends Fn>(callback: F, ...args: RemoveFirstParameter<F>) => {\n  return (collection: FirstParameter<F>) => callback(collection, ...args);\n};\n"],"mappings":";AAuBA,IAAa,KAAyB,GAAa,GAAG,OAC5C,MAAkC,EAAS,GAAY,GAAG,EAAK"}

package/dist/function/index.d.ts

@@ -0,0 +1,13 @@
+export * from './assert';
+export * from './assertParams';
+export * from './compare';
+export * from './compareBy';
+export * from './compose';
+export * from './curry';
+export * from './debounce';
+export * from './fp';
+export * from './memo';
+export * from './once';
+export * from './pipe';
+export * from './throttle';
+//# sourceMappingURL=index.d.ts.map

package/dist/function/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/function/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,MAAM,CAAC;AACrB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC"}

package/dist/function/memo.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function m(f,{ttl:o,maxSize:i,resolver:c}={}){const n=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(t)};return(...t)=>{const e=s(t),r=Date.now(),u=n.get(e);if(u&&(!o||r-u.timestamp<o))return n.delete(e),n.set(e,u),u.value;const l=f(...t);return n.set(e,{timestamp:r,value:l}),i&&n.size>i&&n.delete(n.keys().next().value),l}}exports.memo=m;
-//# sourceMappingURL=memo.cjs.map
+function e(e,{maxSize:t,resolver:n,ttl:r}={}){let i=new Map,a=e=>n?n(...e):JSON.stringify(e,(e,t)=>t===void 0?`__undefined__`:t);return(...n)=>{let o=a(n),s=Date.now(),c=i.get(o);if(c&&(!r||s-c.timestamp<r))return i.delete(o),i.set(o,c),c.value;let l=e(...n);return i.set(o,{timestamp:s,value:l}),l instanceof Promise&&l.catch(()=>i.delete(o)),t&&i.size>t&&i.delete(i.keys().next().value),l}}exports.memo=e;
+//# sourceMappingURL=memo.cjs.map

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\n// #region MemoizeOptions\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// #endregion MemoizeOptions\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":"gFAqCO,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"}
+{"version":3,"file":"memo.cjs","names":[],"sources":["../../src/function/memo.ts"],"sourcesContent":["import type { Fn } from '../types';\n\n// #region MemoizeOptions\ntype MemoizeOptions<T extends Fn> = {\n  maxSize?: number; // Maximum number of items in cache\n  resolver?: (...args: Parameters<T>) => string; // Custom key generator\n  ttl?: number; // Time-to-live in milliseconds\n};\n// #endregion MemoizeOptions\n\ntype CacheEntry<T extends Fn> = {\n  timestamp: number;\n  value: ReturnType<T>;\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  { maxSize, resolver, ttl }: MemoizeOptions<T> = {},\n): (...args: Parameters<T>) => ReturnType<T> {\n  const cache = new Map<string, CacheEntry<T>>();\n\n  const keyGen = (args: Parameters<T>): string => {\n    if (resolver) return resolver(...args);\n\n    // Use a replacer to distinguish undefined from null (JSON.stringify collapses both to null)\n    return JSON.stringify(args, (_, v) => (v === undefined ? '__undefined__' : v));\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\n      return cached.value;\n    }\n\n    const result = fn(...args);\n\n    cache.set(key, { timestamp: now, value: result });\n\n    if (result instanceof Promise) {\n      // Evict on rejection so subsequent calls retry instead of returning a settled failure\n      (result as Promise<unknown>).catch(() => cache.delete(key));\n    }\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"],"mappings":"AAoCA,SAAgB,EACd,EACA,CAAE,UAAS,WAAU,OAA2B,EAAE,CACP,CAC3C,IAAM,EAAQ,IAAI,IAEZ,EAAU,GACV,EAAiB,EAAS,GAAG,EAAK,CAG/B,KAAK,UAAU,GAAO,EAAG,IAAO,IAAM,IAAA,GAAY,gBAAkB,EAAG,CAGhF,OAAQ,GAAG,IAAuC,CAChD,IAAM,EAAM,EAAO,EAAK,CAClB,EAAM,KAAK,KAAK,CAChB,EAAS,EAAM,IAAI,EAAI,CAE7B,GAAI,IAAW,CAAC,GAAO,EAAM,EAAO,UAAY,GAI9C,OAHA,EAAM,OAAO,EAAI,CACjB,EAAM,IAAI,EAAK,EAAO,CAEf,EAAO,MAGhB,IAAM,EAAS,EAAG,GAAG,EAAK,CAa1B,OAXA,EAAM,IAAI,EAAK,CAAE,UAAW,EAAK,MAAO,EAAQ,CAAC,CAE7C,aAAkB,SAEnB,EAA4B,UAAY,EAAM,OAAO,EAAI,CAAC,CAGzD,GAAW,EAAM,KAAO,GAC1B,EAAM,OAAO,EAAM,MAAM,CAAC,MAAM,CAAC,MAAO,CAGnC"}

package/dist/function/memo.d.ts

@@ -0,0 +1,30 @@
+import type { Fn } from '../types';
+type MemoizeOptions<T extends Fn> = {
+    maxSize?: number;
+    resolver?: (...args: Parameters<T>) => string;
+    ttl?: number;
+};
+/**
+ * Creates a function that memorizes the result of the provided function.
+ * Supports expiration (TTL) and limited cache size (LRU).
+ *
+ * @example
+ * ```ts
+ * const add = (x, y) => x + y;
+ * const memoizedAdd = memo(add, { ttl: 5000, maxSize: 10 });
+ *
+ * memoizedAdd(1, 2); // 3 (caches the result)
+ * memoizedAdd(1, 2); // 3 (from cache)
+ * ```
+ *
+ * @param fn - The function to memorize.
+ * @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, { maxSize, resolver, ttl }?: MemoizeOptions<T>): (...args: Parameters<T>) => ReturnType<T>;
+export {};
+//# sourceMappingURL=memo.d.ts.map

package/dist/function/memo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memo.d.ts","sourceRoot":"","sources":["../../src/function/memo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC,KAAK,cAAc,CAAC,CAAC,SAAS,EAAE,IAAI;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;IAC9C,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAQF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,EAAE,EAC/B,EAAE,EAAE,CAAC,EACL,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAE,cAAc,CAAC,CAAC,CAAM,GACjD,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAqC3C"}

package/dist/function/memo.js

@@ -1,25 +1,17 @@
-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(t);
-  };
-  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;
-  };
+//#region src/function/memo.ts
+function e(e, { maxSize: t, resolver: n, ttl: r } = {}) {
+	let i = /* @__PURE__ */ new Map(), a = (e) => n ? n(...e) : JSON.stringify(e, (e, t) => t === void 0 ? "__undefined__" : t);
+	return (...n) => {
+		let o = a(n), s = Date.now(), c = i.get(o);
+		if (c && (!r || s - c.timestamp < r)) return i.delete(o), i.set(o, c), c.value;
+		let l = e(...n);
+		return i.set(o, {
+			timestamp: s,
+			value: l
+		}), l instanceof Promise && l.catch(() => i.delete(o)), t && i.size > t && i.delete(i.keys().next().value), l;
+	};
 }
-export {
-  m as memo
-};
-//# sourceMappingURL=memo.js.map
+//#endregion
+export { e 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\n// #region MemoizeOptions\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// #endregion MemoizeOptions\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":"AAqCO,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;"}
+{"version":3,"file":"memo.js","names":[],"sources":["../../src/function/memo.ts"],"sourcesContent":["import type { Fn } from '../types';\n\n// #region MemoizeOptions\ntype MemoizeOptions<T extends Fn> = {\n  maxSize?: number; // Maximum number of items in cache\n  resolver?: (...args: Parameters<T>) => string; // Custom key generator\n  ttl?: number; // Time-to-live in milliseconds\n};\n// #endregion MemoizeOptions\n\ntype CacheEntry<T extends Fn> = {\n  timestamp: number;\n  value: ReturnType<T>;\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  { maxSize, resolver, ttl }: MemoizeOptions<T> = {},\n): (...args: Parameters<T>) => ReturnType<T> {\n  const cache = new Map<string, CacheEntry<T>>();\n\n  const keyGen = (args: Parameters<T>): string => {\n    if (resolver) return resolver(...args);\n\n    // Use a replacer to distinguish undefined from null (JSON.stringify collapses both to null)\n    return JSON.stringify(args, (_, v) => (v === undefined ? '__undefined__' : v));\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\n      return cached.value;\n    }\n\n    const result = fn(...args);\n\n    cache.set(key, { timestamp: now, value: result });\n\n    if (result instanceof Promise) {\n      // Evict on rejection so subsequent calls retry instead of returning a settled failure\n      (result as Promise<unknown>).catch(() => cache.delete(key));\n    }\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"],"mappings":";AAoCA,SAAgB,EACd,GACA,EAAE,YAAS,aAAU,WAA2B,EAAE,EACP;CAC3C,IAAM,oBAAQ,IAAI,KAA4B,EAExC,KAAU,MACV,IAAiB,EAAS,GAAG,EAAK,GAG/B,KAAK,UAAU,IAAO,GAAG,MAAO,MAAM,KAAA,IAAY,kBAAkB,EAAG;AAGhF,SAAQ,GAAG,MAAuC;EAChD,IAAM,IAAM,EAAO,EAAK,EAClB,IAAM,KAAK,KAAK,EAChB,IAAS,EAAM,IAAI,EAAI;AAE7B,MAAI,MAAW,CAAC,KAAO,IAAM,EAAO,YAAY,GAI9C,QAHA,EAAM,OAAO,EAAI,EACjB,EAAM,IAAI,GAAK,EAAO,EAEf,EAAO;EAGhB,IAAM,IAAS,EAAG,GAAG,EAAK;AAa1B,SAXA,EAAM,IAAI,GAAK;GAAE,WAAW;GAAK,OAAO;GAAQ,CAAC,EAE7C,aAAkB,WAEnB,EAA4B,YAAY,EAAM,OAAO,EAAI,CAAC,EAGzD,KAAW,EAAM,OAAO,KAC1B,EAAM,OAAO,EAAM,MAAM,CAAC,MAAM,CAAC,MAAO,EAGnC"}

package/dist/function/once.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=l=>{let e,t=!1;const r=((...n)=>(t||(e=l(...n),t=!0),e));return r.reset=()=>{e=void 0,t=!1},r};exports.once=o;
-//# sourceMappingURL=once.cjs.map
+var e=e=>{let t,n=!1,r=((...r)=>(n||=(t=e(...r),!0),t));return r.reset=()=>{t=void 0,n=!1},r};exports.once=e;
+//# sourceMappingURL=once.cjs.map

package/dist/function/once.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"once.cjs","sources":["../../src/function/once.ts"],"sourcesContent":["import type { Fn } from '../types';\n\n/**\n * Create a function that runs once and returns the first result.\n *\n * @example\n * ```ts\n * const onceRandom = once(() => Math.random())\n * onceRandom() // 0.3\n * onceRandom() // 0.3\n *\n * onceRandom.reset()\n *\n * onceRandom() // 0.2\n * onceRandom() // 0.2\n * ```\n *\n * @param fn - The function to wrap.\n *\n * @returns A function that can only be called once.\n */\nexport const once = <T extends Fn>(fn: T): T & { reset: () => void } => {\n  let result: ReturnType<T> | undefined;\n  let called = false;\n\n  const wrappedFn = ((...args: Parameters<T>): ReturnType<T> => {\n    if (!called) {\n      result = fn(...args);\n      called = true;\n    }\n    return result as ReturnType<T>;\n  }) as T & { reset: () => void };\n\n  wrappedFn.reset = () => {\n    result = undefined;\n    called = false;\n  };\n\n  return wrappedFn;\n};\n"],"names":["once","fn","result","called","wrappedFn","args"],"mappings":"gFAqBO,MAAMA,EAAsBC,GAAqC,CACtE,IAAIC,EACAC,EAAS,GAEb,MAAMC,GAAa,IAAIC,KAChBF,IACHD,EAASD,EAAG,GAAGI,CAAI,EACnBF,EAAS,IAEJD,IAGT,OAAAE,EAAU,MAAQ,IAAM,CACtBF,EAAS,OACTC,EAAS,EACX,EAEOC,CACT"}
+{"version":3,"file":"once.cjs","names":[],"sources":["../../src/function/once.ts"],"sourcesContent":["import type { Fn } from '../types';\n\n/**\n * Create a function that runs once and returns the first result.\n *\n * @example\n * ```ts\n * const onceRandom = once(() => Math.random())\n * onceRandom() // 0.3\n * onceRandom() // 0.3\n *\n * onceRandom.reset()\n *\n * onceRandom() // 0.2\n * onceRandom() // 0.2\n * ```\n *\n * @param fn - The function to wrap.\n *\n * @returns A function that can only be called once.\n */\nexport const once = <T extends Fn>(fn: T): T & { reset: () => void } => {\n  let result: ReturnType<T> | undefined;\n  let called = false;\n\n  const wrappedFn = ((...args: Parameters<T>): ReturnType<T> => {\n    if (!called) {\n      result = fn(...args);\n      called = true;\n    }\n\n    return result as ReturnType<T>;\n  }) as T & { reset: () => void };\n\n  wrappedFn.reset = () => {\n    result = undefined;\n    called = false;\n  };\n\n  return wrappedFn;\n};\n"],"mappings":"AAqBA,IAAa,EAAsB,GAAqC,CACtE,IAAI,EACA,EAAS,GAEP,IAAc,GAAG,KACrB,AAEE,KADA,EAAS,EAAG,GAAG,EAAK,CACX,IAGJ,IAQT,MALA,GAAU,UAAc,CACtB,EAAS,IAAA,GACT,EAAS,IAGJ"}

package/dist/function/once.d.ts

@@ -0,0 +1,24 @@
+import type { Fn } from '../types';
+/**
+ * Create a function that runs once and returns the first result.
+ *
+ * @example
+ * ```ts
+ * const onceRandom = once(() => Math.random())
+ * onceRandom() // 0.3
+ * onceRandom() // 0.3
+ *
+ * onceRandom.reset()
+ *
+ * onceRandom() // 0.2
+ * onceRandom() // 0.2
+ * ```
+ *
+ * @param fn - The function to wrap.
+ *
+ * @returns A function that can only be called once.
+ */
+export declare const once: <T extends Fn>(fn: T) => T & {
+    reset: () => void;
+};
+//# sourceMappingURL=once.d.ts.map

package/dist/function/once.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"once.d.ts","sourceRoot":"","sources":["../../src/function/once.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,EAAE,EAAE,IAAI,CAAC,KAAG,CAAC,GAAG;IAAE,KAAK,EAAE,MAAM,IAAI,CAAA;CAmBjE,CAAC"}

package/dist/function/once.js

@@ -1,11 +1,11 @@
-const s = (l) => {
-  let e, t = !1;
-  const r = ((...n) => (t || (e = l(...n), t = !0), e));
-  return r.reset = () => {
-    e = void 0, t = !1;
-  }, r;
+//#region src/function/once.ts
+var e = (e) => {
+	let t, n = !1, r = ((...r) => (n ||= (t = e(...r), !0), t));
+	return r.reset = () => {
+		t = void 0, n = !1;
+	}, r;
 };
-export {
-  s as once
-};
-//# sourceMappingURL=once.js.map
+//#endregion
+export { e as once };
+
+//# sourceMappingURL=once.js.map

package/dist/function/once.js.map

@@ -1 +1 @@
-{"version":3,"file":"once.js","sources":["../../src/function/once.ts"],"sourcesContent":["import type { Fn } from '../types';\n\n/**\n * Create a function that runs once and returns the first result.\n *\n * @example\n * ```ts\n * const onceRandom = once(() => Math.random())\n * onceRandom() // 0.3\n * onceRandom() // 0.3\n *\n * onceRandom.reset()\n *\n * onceRandom() // 0.2\n * onceRandom() // 0.2\n * ```\n *\n * @param fn - The function to wrap.\n *\n * @returns A function that can only be called once.\n */\nexport const once = <T extends Fn>(fn: T): T & { reset: () => void } => {\n  let result: ReturnType<T> | undefined;\n  let called = false;\n\n  const wrappedFn = ((...args: Parameters<T>): ReturnType<T> => {\n    if (!called) {\n      result = fn(...args);\n      called = true;\n    }\n    return result as ReturnType<T>;\n  }) as T & { reset: () => void };\n\n  wrappedFn.reset = () => {\n    result = undefined;\n    called = false;\n  };\n\n  return wrappedFn;\n};\n"],"names":["once","fn","result","called","wrappedFn","args"],"mappings":"AAqBO,MAAMA,IAAO,CAAeC,MAAqC;AACtE,MAAIC,GACAC,IAAS;AAEb,QAAMC,KAAa,IAAIC,OAChBF,MACHD,IAASD,EAAG,GAAGI,CAAI,GACnBF,IAAS,KAEJD;AAGT,SAAAE,EAAU,QAAQ,MAAM;AACtB,IAAAF,IAAS,QACTC,IAAS;AAAA,EACX,GAEOC;AACT;"}
+{"version":3,"file":"once.js","names":[],"sources":["../../src/function/once.ts"],"sourcesContent":["import type { Fn } from '../types';\n\n/**\n * Create a function that runs once and returns the first result.\n *\n * @example\n * ```ts\n * const onceRandom = once(() => Math.random())\n * onceRandom() // 0.3\n * onceRandom() // 0.3\n *\n * onceRandom.reset()\n *\n * onceRandom() // 0.2\n * onceRandom() // 0.2\n * ```\n *\n * @param fn - The function to wrap.\n *\n * @returns A function that can only be called once.\n */\nexport const once = <T extends Fn>(fn: T): T & { reset: () => void } => {\n  let result: ReturnType<T> | undefined;\n  let called = false;\n\n  const wrappedFn = ((...args: Parameters<T>): ReturnType<T> => {\n    if (!called) {\n      result = fn(...args);\n      called = true;\n    }\n\n    return result as ReturnType<T>;\n  }) as T & { reset: () => void };\n\n  wrappedFn.reset = () => {\n    result = undefined;\n    called = false;\n  };\n\n  return wrappedFn;\n};\n"],"mappings":";AAqBA,IAAa,KAAsB,MAAqC;CACtE,IAAI,GACA,IAAS,IAEP,MAAc,GAAG,OACrB,AAEE,OADA,IAAS,EAAG,GAAG,EAAK,EACX,KAGJ;AAQT,QALA,EAAU,cAAc;AAEtB,EADA,IAAS,KAAA,GACT,IAAS;IAGJ"}