@vielzeug/toolkit 1.0.11 → 1.0.13

package/dist/array/chunk.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l=require("../function/assert.cjs"),y=require("../typed/isArray.cjs"),o=require("../typed/isString.cjs");function h(r,e=2,c={}){l.assert(y.isArray(r)||o.isString(r),"Argument must be an array or string.",{args:{input:r},type:TypeError});const{overlap:g=!1,pad:n=" "}=c;if(o.isString(r)&&g){const t=`${n}${r}${n}`;return Array.from({length:t.length-e+1},(a,s)=>t.slice(s,s+e))}return Array.from({length:Math.ceil(r.length/e)},(t,a)=>r.slice(a*e,a*e+e))}exports.chunk=h;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("../function/assert.cjs"),u=require("../typed/isArray.cjs"),c=require("../typed/isString.cjs");function y(e,r=2,g={}){o.assert(u.isArray(e)||c.isString(e),"Argument must be an array or string.",{args:{input:e},type:TypeError}),o.assert(r>=1,"Chunk size must be at least 1.",{args:{size:r},type:RangeError});const{overlap:l=!1,pad:a=" "}=g;if(c.isString(e)&&l){const s=a+e+a,t=s.length-r+1;return Array.from({length:t},(h,n)=>s.slice(n,n+r))}return Array.from({length:Math.ceil(e.length/r)},(s,t)=>e.slice(t*r,t*r+r))}exports.chunk=y;
 //# sourceMappingURL=chunk.cjs.map

package/dist/array/chunk.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"chunk.cjs","sources":["../../src/array/chunk.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { isArray } from '../typed/isArray';\nimport { isString } from '../typed/isString';\n\ntype ChunkOptions = {\n  overlap?: boolean;\n  pad?: string;\n};\n\ntype ChunkResult<T> = (T extends string ? string : T[])[];\n\n/**\n * Splits an array or string into chunks of a specified size.\n *\n * @example\n * ```ts\n * chunk([1, 2, 3, 4, 5], 2) // [[1, 2], [3, 4], [5]]\n * chunk(\"hello\", 2) // [\"he\", \"ll\", \"o\"]\n * chunk(\"hello\", 2, { overlap: true }) // [\" h\", \"he\", \"el\", \"ll\", \"lo\", \"o \"]\n * ```\n *\n * @param input - The input array or string to be chunked.\n * @param size - The size of each chunk.\n * @param [options] - Additional options for chunking.\n * @param [options.overlap] -\n * @param [options.pad] -\n *\n * @returns An array of chunks.\n *\n * @throws {RangeError} If the chunk size is invalid.\n * @throws {TypeError} If the input type is invalid.\n */\nexport function chunk<T>(input: T[] | string, size = 2, options: ChunkOptions = {}): ChunkResult<T> {\n  assert(isArray(input as T[]) || isString(input), 'Argument must be an array or string.', {\n    args: { input },\n    type: TypeError,\n  });\n\n  const { overlap = false, pad = ' ' } = options;\n\n  if (isString(input) && overlap) {\n    const padded = `${pad}${input}${pad}`;\n    return Array.from({ length: padded.length - size + 1 }, (_, i) => padded.slice(i, i + size)) as ChunkResult<T>;\n  }\n\n  return Array.from({ length: Math.ceil(input.length / size) }, (_, i) =>\n    input.slice(i * size, i * size + size),\n  ) as ChunkResult<T>;\n}\n"],"names":["chunk","input","size","options","assert","isArray","isString","overlap","pad","padded","_","i"],"mappings":"+LAgCO,SAASA,EAASC,EAAqBC,EAAO,EAAGC,EAAwB,CAAA,EAAoB,CAClGC,EAAAA,OAAOC,EAAAA,QAAQJ,CAAY,GAAKK,EAAAA,SAASL,CAAK,EAAG,uCAAwC,CACvF,KAAM,CAAE,MAAAA,CAAA,EACR,KAAM,SAAA,CACP,EAED,KAAM,CAAE,QAAAM,EAAU,GAAO,IAAAC,EAAM,KAAQL,EAEvC,GAAIG,EAAAA,SAASL,CAAK,GAAKM,EAAS,CAC9B,MAAME,EAAS,GAAGD,CAAG,GAAGP,CAAK,GAAGO,CAAG,GACnC,OAAO,MAAM,KAAK,CAAE,OAAQC,EAAO,OAASP,EAAO,CAAA,EAAK,CAACQ,EAAGC,IAAMF,EAAO,MAAME,EAAGA,EAAIT,CAAI,CAAC,CAC7F,CAEA,OAAO,MAAM,KAAK,CAAE,OAAQ,KAAK,KAAKD,EAAM,OAASC,CAAI,CAAA,EAAK,CAACQ,EAAGC,IAChEV,EAAM,MAAMU,EAAIT,EAAMS,EAAIT,EAAOA,CAAI,CAAA,CAEzC"}
+{"version":3,"file":"chunk.cjs","sources":["../../src/array/chunk.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { isArray } from '../typed/isArray';\nimport { isString } from '../typed/isString';\n\ntype ChunkOptions = {\n  overlap?: boolean;\n  pad?: string;\n};\n\ntype ChunkResult<T> = (T extends string ? string : T[])[];\n\n/**\n * Splits an array or string into chunks of a specified size.\n *\n * @example\n * ```ts\n * chunk([1, 2, 3, 4, 5], 2) // [[1, 2], [3, 4], [5]]\n * chunk(\"hello\", 2) // [\"he\", \"ll\", \"o\"]\n * chunk(\"hello\", 2, { overlap: true }) // [\" h\", \"he\", \"el\", \"ll\", \"lo\", \"o \"]\n * ```\n *\n * @param input - The input array or string to be chunked.\n * @param size - The size of each chunk.\n * @param [options] - Additional options for chunking.\n * @param [options.overlap] -\n * @param [options.pad] -\n *\n * @returns An array of chunks.\n *\n * @throws {RangeError} If the chunk size is invalid.\n * @throws {TypeError} If the input type is invalid.\n */\nexport function chunk<T>(input: T[] | string, size = 2, options: ChunkOptions = {}): ChunkResult<T> {\n  assert(isArray(input as T[]) || isString(input), 'Argument must be an array or string.', {\n    args: { input },\n    type: TypeError,\n  });\n\n  assert(size >= 1, 'Chunk size must be at least 1.', {\n    args: { size },\n    type: RangeError,\n  });\n\n  const { overlap = false, pad = ' ' } = options;\n\n  if (isString(input) && overlap) {\n    const padded = pad + input + pad;\n    const numChunks = padded.length - size + 1;\n    return Array.from({ length: numChunks }, (_, i) => padded.slice(i, i + size)) as ChunkResult<T>;\n  }\n\n  return Array.from({ length: Math.ceil(input.length / size) }, (_, i) =>\n    input.slice(i * size, i * size + size),\n  ) as ChunkResult<T>;\n}\n"],"names":["chunk","input","size","options","assert","isArray","isString","overlap","pad","padded","numChunks","_","i"],"mappings":"+LAgCO,SAASA,EAASC,EAAqBC,EAAO,EAAGC,EAAwB,CAAA,EAAoB,CAClGC,EAAAA,OAAOC,EAAAA,QAAQJ,CAAY,GAAKK,EAAAA,SAASL,CAAK,EAAG,uCAAwC,CACvF,KAAM,CAAE,MAAAA,CAAA,EACR,KAAM,SAAA,CACP,EAEDG,SAAOF,GAAQ,EAAG,iCAAkC,CAClD,KAAM,CAAE,KAAAA,CAAA,EACR,KAAM,UAAA,CACP,EAED,KAAM,CAAE,QAAAK,EAAU,GAAO,IAAAC,EAAM,KAAQL,EAEvC,GAAIG,EAAAA,SAASL,CAAK,GAAKM,EAAS,CAC9B,MAAME,EAASD,EAAMP,EAAQO,EACvBE,EAAYD,EAAO,OAASP,EAAO,EACzC,OAAO,MAAM,KAAK,CAAE,OAAQQ,GAAa,CAACC,EAAGC,IAAMH,EAAO,MAAMG,EAAGA,EAAIV,CAAI,CAAC,CAC9E,CAEA,OAAO,MAAM,KAAK,CAAE,OAAQ,KAAK,KAAKD,EAAM,OAASC,CAAI,CAAA,EAAK,CAACS,EAAGC,IAChEX,EAAM,MAAMW,EAAIV,EAAMU,EAAIV,EAAOA,CAAI,CAAA,CAEzC"}

package/dist/array/chunk.js

@@ -1,22 +1,25 @@
-import { assert as g } from "../function/assert.js";
+import { assert as m } from "../function/assert.js";
 import { isArray as c } from "../typed/isArray.js";
-import { isString as l } from "../typed/isString.js";
-function d(r, o = 2, n = {}) {
-  g(c(r) || l(r), "Argument must be an array or string.", {
-    args: { input: r },
+import { isString as s } from "../typed/isString.js";
+function p(t, r = 2, g = {}) {
+  m(c(t) || s(t), "Argument must be an array or string.", {
+    args: { input: t },
     type: TypeError
+  }), m(r >= 1, "Chunk size must be at least 1.", {
+    args: { size: r },
+    type: RangeError
   });
-  const { overlap: f = !1, pad: e = " " } = n;
-  if (l(r) && f) {
-    const t = `${e}${r}${e}`;
-    return Array.from({ length: t.length - o + 1 }, (a, m) => t.slice(m, m + o));
+  const { overlap: l = !1, pad: e = " " } = g;
+  if (s(t) && l) {
+    const o = e + t + e, a = o.length - r + 1;
+    return Array.from({ length: a }, (f, n) => o.slice(n, n + r));
   }
   return Array.from(
-    { length: Math.ceil(r.length / o) },
-    (t, a) => r.slice(a * o, a * o + o)
+    { length: Math.ceil(t.length / r) },
+    (o, a) => t.slice(a * r, a * r + r)
   );
 }
 export {
-  d as chunk
+  p as chunk
 };
 //# sourceMappingURL=chunk.js.map

package/dist/array/chunk.js.map

@@ -1 +1 @@
-{"version":3,"file":"chunk.js","sources":["../../src/array/chunk.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { isArray } from '../typed/isArray';\nimport { isString } from '../typed/isString';\n\ntype ChunkOptions = {\n  overlap?: boolean;\n  pad?: string;\n};\n\ntype ChunkResult<T> = (T extends string ? string : T[])[];\n\n/**\n * Splits an array or string into chunks of a specified size.\n *\n * @example\n * ```ts\n * chunk([1, 2, 3, 4, 5], 2) // [[1, 2], [3, 4], [5]]\n * chunk(\"hello\", 2) // [\"he\", \"ll\", \"o\"]\n * chunk(\"hello\", 2, { overlap: true }) // [\" h\", \"he\", \"el\", \"ll\", \"lo\", \"o \"]\n * ```\n *\n * @param input - The input array or string to be chunked.\n * @param size - The size of each chunk.\n * @param [options] - Additional options for chunking.\n * @param [options.overlap] -\n * @param [options.pad] -\n *\n * @returns An array of chunks.\n *\n * @throws {RangeError} If the chunk size is invalid.\n * @throws {TypeError} If the input type is invalid.\n */\nexport function chunk<T>(input: T[] | string, size = 2, options: ChunkOptions = {}): ChunkResult<T> {\n  assert(isArray(input as T[]) || isString(input), 'Argument must be an array or string.', {\n    args: { input },\n    type: TypeError,\n  });\n\n  const { overlap = false, pad = ' ' } = options;\n\n  if (isString(input) && overlap) {\n    const padded = `${pad}${input}${pad}`;\n    return Array.from({ length: padded.length - size + 1 }, (_, i) => padded.slice(i, i + size)) as ChunkResult<T>;\n  }\n\n  return Array.from({ length: Math.ceil(input.length / size) }, (_, i) =>\n    input.slice(i * size, i * size + size),\n  ) as ChunkResult<T>;\n}\n"],"names":["chunk","input","size","options","assert","isArray","isString","overlap","pad","padded","_","i"],"mappings":";;;AAgCO,SAASA,EAASC,GAAqBC,IAAO,GAAGC,IAAwB,CAAA,GAAoB;AAClG,EAAAC,EAAOC,EAAQJ,CAAY,KAAKK,EAASL,CAAK,GAAG,wCAAwC;AAAA,IACvF,MAAM,EAAE,OAAAA,EAAA;AAAA,IACR,MAAM;AAAA,EAAA,CACP;AAED,QAAM,EAAE,SAAAM,IAAU,IAAO,KAAAC,IAAM,QAAQL;AAEvC,MAAIG,EAASL,CAAK,KAAKM,GAAS;AAC9B,UAAME,IAAS,GAAGD,CAAG,GAAGP,CAAK,GAAGO,CAAG;AACnC,WAAO,MAAM,KAAK,EAAE,QAAQC,EAAO,SAASP,IAAO,EAAA,GAAK,CAACQ,GAAGC,MAAMF,EAAO,MAAME,GAAGA,IAAIT,CAAI,CAAC;AAAA,EAC7F;AAEA,SAAO,MAAM;AAAA,IAAK,EAAE,QAAQ,KAAK,KAAKD,EAAM,SAASC,CAAI,EAAA;AAAA,IAAK,CAACQ,GAAGC,MAChEV,EAAM,MAAMU,IAAIT,GAAMS,IAAIT,IAAOA,CAAI;AAAA,EAAA;AAEzC;"}
+{"version":3,"file":"chunk.js","sources":["../../src/array/chunk.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { isArray } from '../typed/isArray';\nimport { isString } from '../typed/isString';\n\ntype ChunkOptions = {\n  overlap?: boolean;\n  pad?: string;\n};\n\ntype ChunkResult<T> = (T extends string ? string : T[])[];\n\n/**\n * Splits an array or string into chunks of a specified size.\n *\n * @example\n * ```ts\n * chunk([1, 2, 3, 4, 5], 2) // [[1, 2], [3, 4], [5]]\n * chunk(\"hello\", 2) // [\"he\", \"ll\", \"o\"]\n * chunk(\"hello\", 2, { overlap: true }) // [\" h\", \"he\", \"el\", \"ll\", \"lo\", \"o \"]\n * ```\n *\n * @param input - The input array or string to be chunked.\n * @param size - The size of each chunk.\n * @param [options] - Additional options for chunking.\n * @param [options.overlap] -\n * @param [options.pad] -\n *\n * @returns An array of chunks.\n *\n * @throws {RangeError} If the chunk size is invalid.\n * @throws {TypeError} If the input type is invalid.\n */\nexport function chunk<T>(input: T[] | string, size = 2, options: ChunkOptions = {}): ChunkResult<T> {\n  assert(isArray(input as T[]) || isString(input), 'Argument must be an array or string.', {\n    args: { input },\n    type: TypeError,\n  });\n\n  assert(size >= 1, 'Chunk size must be at least 1.', {\n    args: { size },\n    type: RangeError,\n  });\n\n  const { overlap = false, pad = ' ' } = options;\n\n  if (isString(input) && overlap) {\n    const padded = pad + input + pad;\n    const numChunks = padded.length - size + 1;\n    return Array.from({ length: numChunks }, (_, i) => padded.slice(i, i + size)) as ChunkResult<T>;\n  }\n\n  return Array.from({ length: Math.ceil(input.length / size) }, (_, i) =>\n    input.slice(i * size, i * size + size),\n  ) as ChunkResult<T>;\n}\n"],"names":["chunk","input","size","options","assert","isArray","isString","overlap","pad","padded","numChunks","_","i"],"mappings":";;;AAgCO,SAASA,EAASC,GAAqBC,IAAO,GAAGC,IAAwB,CAAA,GAAoB;AAClG,EAAAC,EAAOC,EAAQJ,CAAY,KAAKK,EAASL,CAAK,GAAG,wCAAwC;AAAA,IACvF,MAAM,EAAE,OAAAA,EAAA;AAAA,IACR,MAAM;AAAA,EAAA,CACP,GAEDG,EAAOF,KAAQ,GAAG,kCAAkC;AAAA,IAClD,MAAM,EAAE,MAAAA,EAAA;AAAA,IACR,MAAM;AAAA,EAAA,CACP;AAED,QAAM,EAAE,SAAAK,IAAU,IAAO,KAAAC,IAAM,QAAQL;AAEvC,MAAIG,EAASL,CAAK,KAAKM,GAAS;AAC9B,UAAME,IAASD,IAAMP,IAAQO,GACvBE,IAAYD,EAAO,SAASP,IAAO;AACzC,WAAO,MAAM,KAAK,EAAE,QAAQQ,KAAa,CAACC,GAAGC,MAAMH,EAAO,MAAMG,GAAGA,IAAIV,CAAI,CAAC;AAAA,EAC9E;AAEA,SAAO,MAAM;AAAA,IAAK,EAAE,QAAQ,KAAK,KAAKD,EAAM,SAASC,CAAI,EAAA;AAAA,IAAK,CAACS,GAAGC,MAChEX,EAAM,MAAMW,IAAIV,GAAMU,IAAIV,IAAOA,CAAI;AAAA,EAAA;AAEzC;"}

package/dist/array/group.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("../function/assert.cjs"),n=require("../typed/isArray.cjs");function u(r,o){c.assert(n.isArray(r),n.IS_ARRAY_ERROR_MSG,{args:{array:r},type:TypeError});const t={},i=typeof o=="function"?o:e=>e[o];for(const e of r){const s=i(e)||"_";t[s]||(t[s]=[]),t[s].push(e)}return t}u.fp=!0;exports.group=u;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const f=require("../function/assert.cjs"),u=require("../typed/isArray.cjs");function i(e,o){f.assert(u.isArray(e),u.IS_ARRAY_ERROR_MSG,{args:{array:e},type:TypeError});const t={},c=typeof o=="function"?o:r=>r[o];for(const r of e){const n=c(r),s=n==null?"_":String(n);t[s]||(t[s]=[]),t[s].push(r)}return t}i.fp=!0;exports.group=i;
 //# sourceMappingURL=group.cjs.map

package/dist/array/group.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"group.cjs","sources":["../../src/array/group.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport type { Selector } from '../types';\n\n/**\n * Groups the elements of an array based on the given key.\n *\n * @example\n * ```ts\n * const data = [{ a: 2 }, { a: 1 }];\n * group(data, 'a') // { '1': [{ a: 2 }], '2': [{ a: 1 }] };\n * ```\n *\n * @param array - The array to group.\n * @param selector - The function to generate the key for each element. It can be a string representing the key or a function that returns the key.\n *\n * @returns an object with keys as the grouped values and values as arrays of elements.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function group<T, K extends keyof T, R extends T[K] extends string ? T[K] : never>(\n  array: T[],\n  selector: Selector<T>,\n): Record<R, T[]> {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const result = {} as Record<R, T[]>;\n  const getKey = typeof selector === 'function' ? selector : (item: T) => item[selector];\n\n  for (const item of array) {\n    const key = (getKey(item) || '_') as R;\n\n    if (!result[key]) {\n      result[key] = [];\n    }\n    result[key].push(item);\n  }\n\n  return result;\n}\n\ngroup.fp = true;\n"],"names":["group","array","selector","assert","isArray","IS_ARRAY_ERROR_MSG","result","getKey","item","key"],"mappings":"4JAoBO,SAASA,EACdC,EACAC,EACgB,CAChBC,EAAAA,OAAOC,EAAAA,QAAQH,CAAK,EAAGI,qBAAoB,CAAE,KAAM,CAAE,MAAAJ,CAAA,EAAS,KAAM,UAAW,EAE/E,MAAMK,EAAS,CAAA,EACTC,EAAS,OAAOL,GAAa,WAAaA,EAAYM,GAAYA,EAAKN,CAAQ,EAErF,UAAWM,KAAQP,EAAO,CACxB,MAAMQ,EAAOF,EAAOC,CAAI,GAAK,IAExBF,EAAOG,CAAG,IACbH,EAAOG,CAAG,EAAI,CAAA,GAEhBH,EAAOG,CAAG,EAAE,KAAKD,CAAI,CACvB,CAEA,OAAOF,CACT,CAEAN,EAAM,GAAK"}
+{"version":3,"file":"group.cjs","sources":["../../src/array/group.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport type { Selector } from '../types';\n\n/**\n * Groups the elements of an array based on the given key.\n *\n * @example\n * ```ts\n * const data = [{ a: 2 }, { a: 1 }];\n * group(data, 'a') // { '1': [{ a: 2 }], '2': [{ a: 1 }] };\n * ```\n *\n * @param array - The array to group.\n * @param selector - The function to generate the key for each element. It can be a string representing the key or a function that returns the key.\n *\n * @returns an object with keys as the grouped values and values as arrays of elements.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function group<T, _K extends keyof T, R extends string | number | symbol>(\n  array: T[],\n  selector: Selector<T>,\n): Record<R, T[]> {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const result = {} as Record<R, T[]>;\n  const getKey = typeof selector === 'function' ? selector : (item: T) => item[selector];\n\n  for (const item of array) {\n    const rawKey = getKey(item);\n    const key = (rawKey === undefined || rawKey === null ? '_' : String(rawKey)) as R;\n\n    if (!result[key]) {\n      result[key] = [];\n    }\n    result[key].push(item);\n  }\n\n  return result;\n}\n\ngroup.fp = true;\n"],"names":["group","array","selector","assert","isArray","IS_ARRAY_ERROR_MSG","result","getKey","item","rawKey","key"],"mappings":"4JAoBO,SAASA,EACdC,EACAC,EACgB,CAChBC,EAAAA,OAAOC,EAAAA,QAAQH,CAAK,EAAGI,qBAAoB,CAAE,KAAM,CAAE,MAAAJ,CAAA,EAAS,KAAM,UAAW,EAE/E,MAAMK,EAAS,CAAA,EACTC,EAAS,OAAOL,GAAa,WAAaA,EAAYM,GAAYA,EAAKN,CAAQ,EAErF,UAAWM,KAAQP,EAAO,CACxB,MAAMQ,EAASF,EAAOC,CAAI,EACpBE,EAA+BD,GAAW,KAAO,IAAM,OAAOA,CAAM,EAErEH,EAAOI,CAAG,IACbJ,EAAOI,CAAG,EAAI,CAAA,GAEhBJ,EAAOI,CAAG,EAAE,KAAKF,CAAI,CACvB,CAEA,OAAOF,CACT,CAEAN,EAAM,GAAK"}

package/dist/array/group.js

@@ -1,16 +1,16 @@
-import { assert as e } from "../function/assert.js";
-import { IS_ARRAY_ERROR_MSG as s, isArray as i } from "../typed/isArray.js";
-function u(r, f) {
-  e(i(r), s, { args: { array: r }, type: TypeError });
-  const t = {}, p = typeof f == "function" ? f : (o) => o[f];
+import { assert as p } from "../function/assert.js";
+import { IS_ARRAY_ERROR_MSG as s, isArray as u } from "../typed/isArray.js";
+function c(r, n) {
+  p(u(r), s, { args: { array: r }, type: TypeError });
+  const t = {}, i = typeof n == "function" ? n : (o) => o[n];
   for (const o of r) {
-    const n = p(o) || "_";
-    t[n] || (t[n] = []), t[n].push(o);
+    const e = i(o), f = e == null ? "_" : String(e);
+    t[f] || (t[f] = []), t[f].push(o);
   }
   return t;
 }
-u.fp = !0;
+c.fp = !0;
 export {
-  u as group
+  c as group
 };
 //# sourceMappingURL=group.js.map

package/dist/array/group.js.map

@@ -1 +1 @@
-{"version":3,"file":"group.js","sources":["../../src/array/group.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport type { Selector } from '../types';\n\n/**\n * Groups the elements of an array based on the given key.\n *\n * @example\n * ```ts\n * const data = [{ a: 2 }, { a: 1 }];\n * group(data, 'a') // { '1': [{ a: 2 }], '2': [{ a: 1 }] };\n * ```\n *\n * @param array - The array to group.\n * @param selector - The function to generate the key for each element. It can be a string representing the key or a function that returns the key.\n *\n * @returns an object with keys as the grouped values and values as arrays of elements.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function group<T, K extends keyof T, R extends T[K] extends string ? T[K] : never>(\n  array: T[],\n  selector: Selector<T>,\n): Record<R, T[]> {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const result = {} as Record<R, T[]>;\n  const getKey = typeof selector === 'function' ? selector : (item: T) => item[selector];\n\n  for (const item of array) {\n    const key = (getKey(item) || '_') as R;\n\n    if (!result[key]) {\n      result[key] = [];\n    }\n    result[key].push(item);\n  }\n\n  return result;\n}\n\ngroup.fp = true;\n"],"names":["group","array","selector","assert","isArray","IS_ARRAY_ERROR_MSG","result","getKey","item","key"],"mappings":";;AAoBO,SAASA,EACdC,GACAC,GACgB;AAChB,EAAAC,EAAOC,EAAQH,CAAK,GAAGI,GAAoB,EAAE,MAAM,EAAE,OAAAJ,EAAA,GAAS,MAAM,WAAW;AAE/E,QAAMK,IAAS,CAAA,GACTC,IAAS,OAAOL,KAAa,aAAaA,IAAW,CAACM,MAAYA,EAAKN,CAAQ;AAErF,aAAWM,KAAQP,GAAO;AACxB,UAAMQ,IAAOF,EAAOC,CAAI,KAAK;AAE7B,IAAKF,EAAOG,CAAG,MACbH,EAAOG,CAAG,IAAI,CAAA,IAEhBH,EAAOG,CAAG,EAAE,KAAKD,CAAI;AAAA,EACvB;AAEA,SAAOF;AACT;AAEAN,EAAM,KAAK;"}
+{"version":3,"file":"group.js","sources":["../../src/array/group.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport type { Selector } from '../types';\n\n/**\n * Groups the elements of an array based on the given key.\n *\n * @example\n * ```ts\n * const data = [{ a: 2 }, { a: 1 }];\n * group(data, 'a') // { '1': [{ a: 2 }], '2': [{ a: 1 }] };\n * ```\n *\n * @param array - The array to group.\n * @param selector - The function to generate the key for each element. It can be a string representing the key or a function that returns the key.\n *\n * @returns an object with keys as the grouped values and values as arrays of elements.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function group<T, _K extends keyof T, R extends string | number | symbol>(\n  array: T[],\n  selector: Selector<T>,\n): Record<R, T[]> {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const result = {} as Record<R, T[]>;\n  const getKey = typeof selector === 'function' ? selector : (item: T) => item[selector];\n\n  for (const item of array) {\n    const rawKey = getKey(item);\n    const key = (rawKey === undefined || rawKey === null ? '_' : String(rawKey)) as R;\n\n    if (!result[key]) {\n      result[key] = [];\n    }\n    result[key].push(item);\n  }\n\n  return result;\n}\n\ngroup.fp = true;\n"],"names":["group","array","selector","assert","isArray","IS_ARRAY_ERROR_MSG","result","getKey","item","rawKey","key"],"mappings":";;AAoBO,SAASA,EACdC,GACAC,GACgB;AAChB,EAAAC,EAAOC,EAAQH,CAAK,GAAGI,GAAoB,EAAE,MAAM,EAAE,OAAAJ,EAAA,GAAS,MAAM,WAAW;AAE/E,QAAMK,IAAS,CAAA,GACTC,IAAS,OAAOL,KAAa,aAAaA,IAAW,CAACM,MAAYA,EAAKN,CAAQ;AAErF,aAAWM,KAAQP,GAAO;AACxB,UAAMQ,IAASF,EAAOC,CAAI,GACpBE,IAA+BD,KAAW,OAAO,MAAM,OAAOA,CAAM;AAE1E,IAAKH,EAAOI,CAAG,MACbJ,EAAOI,CAAG,IAAI,CAAA,IAEhBJ,EAAOI,CAAG,EAAE,KAAKF,CAAI;AAAA,EACvB;AAEA,SAAOF;AACT;AAEAN,EAAM,KAAK;"}

package/dist/array/list.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const p=require("../function/debounce.cjs"),d=require("./chunk.cjs"),x=require("./search.cjs"),T=10,b=.5,y=1;function f(s,i,e){const a=e?[...s].sort(e):[...s];return d.chunk(a,i)}function m(s,i,e=""){return(e?x.search(s,e,b):s).filter(i)}function D(s,i={}){let{limit:e=T,filterFn:a=()=>!0,sortFn:o}=i,c=[...s],t=0,h="",l=m(c,a),n=f(l,e,o);const u=()=>(l=m(c,a,h),n=f(l,e,o),t=Math.max(0,Math.min(t,n.length-1)),n[t]??[]);return{get current(){return n[t]??[]},set data(r){c=[...r],t=0,u()},filter(r){return a=r,t=0,u()},set limit(r){e=Math.max(y,r),u()},get meta(){return{end:Math.min(e*(t+1),l.length),isEmpty:l.length===0,isFirst:t===0,isLast:t===n.length-1,limit:e,page:t+1,pages:Math.ceil(l.length/e),start:Math.max(0,e*t+1),total:l.length}},next(){t<n.length-1&&t++},set page(r){const g=r-1,M=g<0?n.length+g:g;t=Math.max(0,Math.min(M,n.length-1))},get pages(){return n},prev(){t>0&&t--},reset(){return t=0,h="",a=i.filterFn??(()=>!0),u()},search:p.debounce(r=>(h=r,u())),sort(r){return o=r,u()},*[Symbol.iterator](){for(const r of n)yield r}}}exports.list=D;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const p=require("../function/debounce.cjs"),d=require("./chunk.cjs"),x=require("./search.cjs"),T=10,b=.5,y=1;function f(s,i,r){const a=r?[...s].sort(r):[...s];return d.chunk(a,i)}function m(s,i,r=""){return(r?x.search(s,r,b):s).filter(i)}function D(s,i={}){let{limit:r=T,filterFn:a=()=>!0,sortFn:o}=i,c=[...s],t=0,h="",l=m(c,a),n=f(l,r,o);const u=()=>{l=m(c,a,h),n=f(l,r,o);const e=Math.max(0,n.length-1);return t=Math.max(0,Math.min(t,e)),n[t]??[]};return{get current(){return n[t]??[]},set data(e){c=[...e],t=0,u()},filter(e){return a=e,t=0,u()},set limit(e){r=Math.max(y,e),u()},get meta(){return{end:Math.min(r*(t+1),l.length),isEmpty:l.length===0,isFirst:t===0,isLast:t===n.length-1,limit:r,page:t+1,pages:Math.ceil(l.length/r),start:Math.max(0,r*t+1),total:l.length}},next(){t<n.length-1&&t++},set page(e){const g=e-1,M=g<0?n.length+g:g;t=Math.max(0,Math.min(M,n.length-1))},get pages(){return n},prev(){t>0&&t--},reset(){return t=0,h="",a=i.filterFn??(()=>!0),u()},search:p.debounce(e=>(h=e,u())),sort(e){return o=e,u()},*[Symbol.iterator](){for(const e of n)yield e}}}exports.list=D;
 //# sourceMappingURL=list.cjs.map

package/dist/array/list.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"list.cjs","sources":["../../src/array/list.ts"],"sourcesContent":["import { debounce } from '../function/debounce';\nimport type { Predicate } from '../types';\nimport { chunk } from './chunk';\nimport { search } from './search';\n\ntype Config<T> = {\n  filterFn?: Predicate<T>;\n  limit?: number;\n  sortFn?: (a: T, b: T) => number;\n};\n\nconst DEFAULT_LIMIT = 10;\nconst DEFAULT_SEARCH_TONE = 0.5;\nconst MIN_LIMIT = 1;\n\nfunction getPages<T>(data: T[], size: number, sortFn: Config<T>['sortFn']): T[][] {\n  const sortedData = sortFn ? [...data].sort(sortFn) : [...data];\n  return chunk<T>(sortedData, size) as T[][];\n}\n\nfunction getData<T>(data: T[], currentFilterFn: Predicate<T>, query = ''): T[] {\n  const searchResults = query ? search(data, query, DEFAULT_SEARCH_TONE) : data;\n  return searchResults.filter(currentFilterFn) as T[];\n}\n\nexport function list<T>(initialData: T[], config: Config<T> = {}) {\n  let { limit = DEFAULT_LIMIT, filterFn = () => true, sortFn } = config;\n  let rawData = [...initialData];\n  let offset = 0;\n  let query = '';\n  let data = getData(rawData, filterFn);\n  let pages = getPages(data, limit, sortFn);\n\n  const update = () => {\n    data = getData(rawData, filterFn, query);\n    pages = getPages(data, limit, sortFn);\n    offset = Math.max(0, Math.min(offset, pages.length - 1));\n    return pages[offset] ?? [];\n  };\n\n  return {\n    get current() {\n      return pages[offset] ?? [];\n    },\n    set data(newData: T[]) {\n      rawData = [...newData];\n      offset = 0;\n      update();\n    },\n    filter(predicate: (item: T) => boolean) {\n      filterFn = predicate;\n      offset = 0;\n      return update();\n    },\n    set limit(newLimit: number) {\n      limit = Math.max(MIN_LIMIT, newLimit);\n      update();\n    },\n    get meta() {\n      return {\n        end: Math.min(limit * (offset + 1), data.length),\n        isEmpty: data.length === 0,\n        isFirst: offset === 0,\n        isLast: offset === pages.length - 1,\n        limit: limit,\n        page: offset + 1,\n        pages: Math.ceil(data.length / limit),\n        start: Math.max(0, limit * offset + 1),\n        total: data.length,\n      };\n    },\n    next() {\n      if (offset < pages.length - 1) {\n        offset++;\n      }\n    },\n    set page(page: number) {\n      const index = page - 1;\n      const value = index < 0 ? pages.length + index : index;\n      offset = Math.max(0, Math.min(value, pages.length - 1));\n    },\n    get pages() {\n      return pages;\n    },\n    prev() {\n      if (offset > 0) {\n        offset--;\n      }\n    },\n    reset() {\n      offset = 0;\n      query = '';\n      filterFn = config.filterFn ?? (() => true);\n      return update();\n    },\n    search: debounce((str: string) => {\n      query = str;\n      return update();\n    }),\n    sort(fn?: (a: T, b: T) => number) {\n      sortFn = fn;\n      return update();\n    },\n    *[Symbol.iterator]() {\n      for (const page of pages) {\n        yield page;\n      }\n    },\n  };\n}\n"],"names":["DEFAULT_LIMIT","DEFAULT_SEARCH_TONE","MIN_LIMIT","getPages","data","size","sortFn","sortedData","chunk","getData","currentFilterFn","query","search","list","initialData","config","limit","filterFn","rawData","offset","pages","update","newData","predicate","newLimit","page","index","value","debounce","str","fn"],"mappings":"+KAWMA,EAAgB,GAChBC,EAAsB,GACtBC,EAAY,EAElB,SAASC,EAAYC,EAAWC,EAAcC,EAAoC,CAChF,MAAMC,EAAaD,EAAS,CAAC,GAAGF,CAAI,EAAE,KAAKE,CAAM,EAAI,CAAC,GAAGF,CAAI,EAC7D,OAAOI,EAAAA,MAASD,EAAYF,CAAI,CAClC,CAEA,SAASI,EAAWL,EAAWM,EAA+BC,EAAQ,GAAS,CAE7E,OADsBA,EAAQC,EAAAA,OAAOR,EAAMO,EAAOV,CAAmB,EAAIG,GACpD,OAAOM,CAAe,CAC7C,CAEO,SAASG,EAAQC,EAAkBC,EAAoB,GAAI,CAChE,GAAI,CAAE,MAAAC,EAAQhB,EAAe,SAAAiB,EAAW,IAAM,GAAM,OAAAX,GAAWS,EAC3DG,EAAU,CAAC,GAAGJ,CAAW,EACzBK,EAAS,EACTR,EAAQ,GACRP,EAAOK,EAAQS,EAASD,CAAQ,EAChCG,EAAQjB,EAASC,EAAMY,EAAOV,CAAM,EAExC,MAAMe,EAAS,KACbjB,EAAOK,EAAQS,EAASD,EAAUN,CAAK,EACvCS,EAAQjB,EAASC,EAAMY,EAAOV,CAAM,EACpCa,EAAS,KAAK,IAAI,EAAG,KAAK,IAAIA,EAAQC,EAAM,OAAS,CAAC,CAAC,EAChDA,EAAMD,CAAM,GAAK,CAAA,GAG1B,MAAO,CACL,IAAI,SAAU,CACZ,OAAOC,EAAMD,CAAM,GAAK,CAAA,CAC1B,EACA,IAAI,KAAKG,EAAc,CACrBJ,EAAU,CAAC,GAAGI,CAAO,EACrBH,EAAS,EACTE,EAAA,CACF,EACA,OAAOE,EAAiC,CACtC,OAAAN,EAAWM,EACXJ,EAAS,EACFE,EAAA,CACT,EACA,IAAI,MAAMG,EAAkB,CAC1BR,EAAQ,KAAK,IAAId,EAAWsB,CAAQ,EACpCH,EAAA,CACF,EACA,IAAI,MAAO,CACT,MAAO,CACL,IAAK,KAAK,IAAIL,GAASG,EAAS,GAAIf,EAAK,MAAM,EAC/C,QAASA,EAAK,SAAW,EACzB,QAASe,IAAW,EACpB,OAAQA,IAAWC,EAAM,OAAS,EAClC,MAAAJ,EACA,KAAMG,EAAS,EACf,MAAO,KAAK,KAAKf,EAAK,OAASY,CAAK,EACpC,MAAO,KAAK,IAAI,EAAGA,EAAQG,EAAS,CAAC,EACrC,MAAOf,EAAK,MAAA,CAEhB,EACA,MAAO,CACDe,EAASC,EAAM,OAAS,GAC1BD,GAEJ,EACA,IAAI,KAAKM,EAAc,CACrB,MAAMC,EAAQD,EAAO,EACfE,EAAQD,EAAQ,EAAIN,EAAM,OAASM,EAAQA,EACjDP,EAAS,KAAK,IAAI,EAAG,KAAK,IAAIQ,EAAOP,EAAM,OAAS,CAAC,CAAC,CACxD,EACA,IAAI,OAAQ,CACV,OAAOA,CACT,EACA,MAAO,CACDD,EAAS,GACXA,GAEJ,EACA,OAAQ,CACN,OAAAA,EAAS,EACTR,EAAQ,GACRM,EAAWF,EAAO,WAAa,IAAM,IAC9BM,EAAA,CACT,EACA,OAAQO,EAAAA,SAAUC,IAChBlB,EAAQkB,EACDR,EAAA,EACR,EACD,KAAKS,EAA6B,CAChC,OAAAxB,EAASwB,EACFT,EAAA,CACT,EACA,EAAE,OAAO,QAAQ,GAAI,CACnB,UAAWI,KAAQL,EACjB,MAAMK,CAEV,CAAA,CAEJ"}
+{"version":3,"file":"list.cjs","sources":["../../src/array/list.ts"],"sourcesContent":["import { debounce } from '../function/debounce';\nimport type { Predicate } from '../types';\nimport { chunk } from './chunk';\nimport { search } from './search';\n\ntype Config<T> = {\n  filterFn?: Predicate<T>;\n  limit?: number;\n  sortFn?: (a: T, b: T) => number;\n};\n\nconst DEFAULT_LIMIT = 10;\nconst DEFAULT_SEARCH_TONE = 0.5;\nconst MIN_LIMIT = 1;\n\nfunction getPages<T>(data: T[], size: number, sortFn: Config<T>['sortFn']): T[][] {\n  const sortedData = sortFn ? [...data].sort(sortFn) : [...data];\n  return chunk<T>(sortedData, size) as T[][];\n}\n\nfunction getData<T>(data: T[], currentFilterFn: Predicate<T>, query = ''): T[] {\n  const searchResults = query ? search(data, query, DEFAULT_SEARCH_TONE) : data;\n  return searchResults.filter(currentFilterFn) as T[];\n}\n\nexport function list<T>(initialData: T[], config: Config<T> = {}) {\n  let { limit = DEFAULT_LIMIT, filterFn = () => true, sortFn } = config;\n  let rawData = [...initialData];\n  let offset = 0;\n  let query = '';\n  let data = getData(rawData, filterFn);\n  let pages = getPages(data, limit, sortFn);\n\n  const update = () => {\n    data = getData(rawData, filterFn, query);\n    pages = getPages(data, limit, sortFn);\n    // Ensure offset is valid for the new page count\n    // If pages is empty, offset should be 0. Max index is pages.length - 1\n    const maxOffset = Math.max(0, pages.length - 1);\n    offset = Math.max(0, Math.min(offset, maxOffset));\n    return pages[offset] ?? [];\n  };\n\n  return {\n    get current() {\n      return pages[offset] ?? [];\n    },\n    set data(newData: T[]) {\n      rawData = [...newData];\n      offset = 0;\n      update();\n    },\n    filter(predicate: (item: T) => boolean) {\n      filterFn = predicate;\n      offset = 0;\n      return update();\n    },\n    set limit(newLimit: number) {\n      limit = Math.max(MIN_LIMIT, newLimit);\n      update();\n    },\n    get meta() {\n      return {\n        end: Math.min(limit * (offset + 1), data.length),\n        isEmpty: data.length === 0,\n        isFirst: offset === 0,\n        isLast: offset === pages.length - 1,\n        limit: limit,\n        page: offset + 1,\n        pages: Math.ceil(data.length / limit),\n        start: Math.max(0, limit * offset + 1),\n        total: data.length,\n      };\n    },\n    next() {\n      if (offset < pages.length - 1) {\n        offset++;\n      }\n    },\n    set page(page: number) {\n      const index = page - 1;\n      const value = index < 0 ? pages.length + index : index;\n      offset = Math.max(0, Math.min(value, pages.length - 1));\n    },\n    get pages() {\n      return pages;\n    },\n    prev() {\n      if (offset > 0) {\n        offset--;\n      }\n    },\n    reset() {\n      offset = 0;\n      query = '';\n      filterFn = config.filterFn ?? (() => true);\n      return update();\n    },\n    search: debounce((str: string) => {\n      query = str;\n      return update();\n    }),\n    sort(fn?: (a: T, b: T) => number) {\n      sortFn = fn;\n      return update();\n    },\n    *[Symbol.iterator]() {\n      for (const page of pages) {\n        yield page;\n      }\n    },\n  };\n}\n"],"names":["DEFAULT_LIMIT","DEFAULT_SEARCH_TONE","MIN_LIMIT","getPages","data","size","sortFn","sortedData","chunk","getData","currentFilterFn","query","search","list","initialData","config","limit","filterFn","rawData","offset","pages","update","maxOffset","newData","predicate","newLimit","page","index","value","debounce","str","fn"],"mappings":"+KAWMA,EAAgB,GAChBC,EAAsB,GACtBC,EAAY,EAElB,SAASC,EAAYC,EAAWC,EAAcC,EAAoC,CAChF,MAAMC,EAAaD,EAAS,CAAC,GAAGF,CAAI,EAAE,KAAKE,CAAM,EAAI,CAAC,GAAGF,CAAI,EAC7D,OAAOI,EAAAA,MAASD,EAAYF,CAAI,CAClC,CAEA,SAASI,EAAWL,EAAWM,EAA+BC,EAAQ,GAAS,CAE7E,OADsBA,EAAQC,EAAAA,OAAOR,EAAMO,EAAOV,CAAmB,EAAIG,GACpD,OAAOM,CAAe,CAC7C,CAEO,SAASG,EAAQC,EAAkBC,EAAoB,GAAI,CAChE,GAAI,CAAE,MAAAC,EAAQhB,EAAe,SAAAiB,EAAW,IAAM,GAAM,OAAAX,GAAWS,EAC3DG,EAAU,CAAC,GAAGJ,CAAW,EACzBK,EAAS,EACTR,EAAQ,GACRP,EAAOK,EAAQS,EAASD,CAAQ,EAChCG,EAAQjB,EAASC,EAAMY,EAAOV,CAAM,EAExC,MAAMe,EAAS,IAAM,CACnBjB,EAAOK,EAAQS,EAASD,EAAUN,CAAK,EACvCS,EAAQjB,EAASC,EAAMY,EAAOV,CAAM,EAGpC,MAAMgB,EAAY,KAAK,IAAI,EAAGF,EAAM,OAAS,CAAC,EAC9C,OAAAD,EAAS,KAAK,IAAI,EAAG,KAAK,IAAIA,EAAQG,CAAS,CAAC,EACzCF,EAAMD,CAAM,GAAK,CAAA,CAC1B,EAEA,MAAO,CACL,IAAI,SAAU,CACZ,OAAOC,EAAMD,CAAM,GAAK,CAAA,CAC1B,EACA,IAAI,KAAKI,EAAc,CACrBL,EAAU,CAAC,GAAGK,CAAO,EACrBJ,EAAS,EACTE,EAAA,CACF,EACA,OAAOG,EAAiC,CACtC,OAAAP,EAAWO,EACXL,EAAS,EACFE,EAAA,CACT,EACA,IAAI,MAAMI,EAAkB,CAC1BT,EAAQ,KAAK,IAAId,EAAWuB,CAAQ,EACpCJ,EAAA,CACF,EACA,IAAI,MAAO,CACT,MAAO,CACL,IAAK,KAAK,IAAIL,GAASG,EAAS,GAAIf,EAAK,MAAM,EAC/C,QAASA,EAAK,SAAW,EACzB,QAASe,IAAW,EACpB,OAAQA,IAAWC,EAAM,OAAS,EAClC,MAAAJ,EACA,KAAMG,EAAS,EACf,MAAO,KAAK,KAAKf,EAAK,OAASY,CAAK,EACpC,MAAO,KAAK,IAAI,EAAGA,EAAQG,EAAS,CAAC,EACrC,MAAOf,EAAK,MAAA,CAEhB,EACA,MAAO,CACDe,EAASC,EAAM,OAAS,GAC1BD,GAEJ,EACA,IAAI,KAAKO,EAAc,CACrB,MAAMC,EAAQD,EAAO,EACfE,EAAQD,EAAQ,EAAIP,EAAM,OAASO,EAAQA,EACjDR,EAAS,KAAK,IAAI,EAAG,KAAK,IAAIS,EAAOR,EAAM,OAAS,CAAC,CAAC,CACxD,EACA,IAAI,OAAQ,CACV,OAAOA,CACT,EACA,MAAO,CACDD,EAAS,GACXA,GAEJ,EACA,OAAQ,CACN,OAAAA,EAAS,EACTR,EAAQ,GACRM,EAAWF,EAAO,WAAa,IAAM,IAC9BM,EAAA,CACT,EACA,OAAQQ,EAAAA,SAAUC,IAChBnB,EAAQmB,EACDT,EAAA,EACR,EACD,KAAKU,EAA6B,CAChC,OAAAzB,EAASyB,EACFV,EAAA,CACT,EACA,EAAE,OAAO,QAAQ,GAAI,CACnB,UAAWK,KAAQN,EACjB,MAAMM,CAEV,CAAA,CAEJ"}

package/dist/array/list.js

@@ -2,47 +2,51 @@ import { debounce as M } from "../function/debounce.js";
 import { chunk as x } from "./chunk.js";
 import { search as d } from "./search.js";
 const D = 10, E = 0.5, F = 1;
-function m(a, o, e) {
-  const s = e ? [...a].sort(e) : [...a];
+function m(a, o, r) {
+  const s = r ? [...a].sort(r) : [...a];
   return x(s, o);
 }
-function f(a, o, e = "") {
-  return (e ? d(a, e, E) : a).filter(o);
+function f(a, o, r = "") {
+  return (r ? d(a, r, E) : a).filter(o);
 }
 function _(a, o = {}) {
-  let { limit: e = D, filterFn: s = () => !0, sortFn: u } = o, h = [...a], t = 0, g = "", l = f(h, s), n = m(l, e, u);
-  const i = () => (l = f(h, s, g), n = m(l, e, u), t = Math.max(0, Math.min(t, n.length - 1)), n[t] ?? []);
+  let { limit: r = D, filterFn: s = () => !0, sortFn: h } = o, u = [...a], t = 0, c = "", l = f(u, s), n = m(l, r, h);
+  const i = () => {
+    l = f(u, s, c), n = m(l, r, h);
+    const e = Math.max(0, n.length - 1);
+    return t = Math.max(0, Math.min(t, e)), n[t] ?? [];
+  };
   return {
     get current() {
       return n[t] ?? [];
     },
-    set data(r) {
-      h = [...r], t = 0, i();
+    set data(e) {
+      u = [...e], t = 0, i();
     },
-    filter(r) {
-      return s = r, t = 0, i();
+    filter(e) {
+      return s = e, t = 0, i();
     },
-    set limit(r) {
-      e = Math.max(F, r), i();
+    set limit(e) {
+      r = Math.max(F, e), i();
     },
     get meta() {
       return {
-        end: Math.min(e * (t + 1), l.length),
+        end: Math.min(r * (t + 1), l.length),
         isEmpty: l.length === 0,
         isFirst: t === 0,
         isLast: t === n.length - 1,
-        limit: e,
+        limit: r,
         page: t + 1,
-        pages: Math.ceil(l.length / e),
-        start: Math.max(0, e * t + 1),
+        pages: Math.ceil(l.length / r),
+        start: Math.max(0, r * t + 1),
         total: l.length
       };
     },
     next() {
       t < n.length - 1 && t++;
     },
-    set page(r) {
-      const c = r - 1, p = c < 0 ? n.length + c : c;
+    set page(e) {
+      const g = e - 1, p = g < 0 ? n.length + g : g;
       t = Math.max(0, Math.min(p, n.length - 1));
     },
     get pages() {
@@ -52,15 +56,15 @@ function _(a, o = {}) {
       t > 0 && t--;
     },
     reset() {
-      return t = 0, g = "", s = o.filterFn ?? (() => !0), i();
+      return t = 0, c = "", s = o.filterFn ?? (() => !0), i();
     },
-    search: M((r) => (g = r, i())),
-    sort(r) {
-      return u = r, i();
+    search: M((e) => (c = e, i())),
+    sort(e) {
+      return h = e, i();
     },
     *[Symbol.iterator]() {
-      for (const r of n)
-        yield r;
+      for (const e of n)
+        yield e;
     }
   };
 }

package/dist/array/list.js.map

@@ -1 +1 @@
-{"version":3,"file":"list.js","sources":["../../src/array/list.ts"],"sourcesContent":["import { debounce } from '../function/debounce';\nimport type { Predicate } from '../types';\nimport { chunk } from './chunk';\nimport { search } from './search';\n\ntype Config<T> = {\n  filterFn?: Predicate<T>;\n  limit?: number;\n  sortFn?: (a: T, b: T) => number;\n};\n\nconst DEFAULT_LIMIT = 10;\nconst DEFAULT_SEARCH_TONE = 0.5;\nconst MIN_LIMIT = 1;\n\nfunction getPages<T>(data: T[], size: number, sortFn: Config<T>['sortFn']): T[][] {\n  const sortedData = sortFn ? [...data].sort(sortFn) : [...data];\n  return chunk<T>(sortedData, size) as T[][];\n}\n\nfunction getData<T>(data: T[], currentFilterFn: Predicate<T>, query = ''): T[] {\n  const searchResults = query ? search(data, query, DEFAULT_SEARCH_TONE) : data;\n  return searchResults.filter(currentFilterFn) as T[];\n}\n\nexport function list<T>(initialData: T[], config: Config<T> = {}) {\n  let { limit = DEFAULT_LIMIT, filterFn = () => true, sortFn } = config;\n  let rawData = [...initialData];\n  let offset = 0;\n  let query = '';\n  let data = getData(rawData, filterFn);\n  let pages = getPages(data, limit, sortFn);\n\n  const update = () => {\n    data = getData(rawData, filterFn, query);\n    pages = getPages(data, limit, sortFn);\n    offset = Math.max(0, Math.min(offset, pages.length - 1));\n    return pages[offset] ?? [];\n  };\n\n  return {\n    get current() {\n      return pages[offset] ?? [];\n    },\n    set data(newData: T[]) {\n      rawData = [...newData];\n      offset = 0;\n      update();\n    },\n    filter(predicate: (item: T) => boolean) {\n      filterFn = predicate;\n      offset = 0;\n      return update();\n    },\n    set limit(newLimit: number) {\n      limit = Math.max(MIN_LIMIT, newLimit);\n      update();\n    },\n    get meta() {\n      return {\n        end: Math.min(limit * (offset + 1), data.length),\n        isEmpty: data.length === 0,\n        isFirst: offset === 0,\n        isLast: offset === pages.length - 1,\n        limit: limit,\n        page: offset + 1,\n        pages: Math.ceil(data.length / limit),\n        start: Math.max(0, limit * offset + 1),\n        total: data.length,\n      };\n    },\n    next() {\n      if (offset < pages.length - 1) {\n        offset++;\n      }\n    },\n    set page(page: number) {\n      const index = page - 1;\n      const value = index < 0 ? pages.length + index : index;\n      offset = Math.max(0, Math.min(value, pages.length - 1));\n    },\n    get pages() {\n      return pages;\n    },\n    prev() {\n      if (offset > 0) {\n        offset--;\n      }\n    },\n    reset() {\n      offset = 0;\n      query = '';\n      filterFn = config.filterFn ?? (() => true);\n      return update();\n    },\n    search: debounce((str: string) => {\n      query = str;\n      return update();\n    }),\n    sort(fn?: (a: T, b: T) => number) {\n      sortFn = fn;\n      return update();\n    },\n    *[Symbol.iterator]() {\n      for (const page of pages) {\n        yield page;\n      }\n    },\n  };\n}\n"],"names":["DEFAULT_LIMIT","DEFAULT_SEARCH_TONE","MIN_LIMIT","getPages","data","size","sortFn","sortedData","chunk","getData","currentFilterFn","query","search","list","initialData","config","limit","filterFn","rawData","offset","pages","update","newData","predicate","newLimit","page","index","value","debounce","str","fn"],"mappings":";;;AAWA,MAAMA,IAAgB,IAChBC,IAAsB,KACtBC,IAAY;AAElB,SAASC,EAAYC,GAAWC,GAAcC,GAAoC;AAChF,QAAMC,IAAaD,IAAS,CAAC,GAAGF,CAAI,EAAE,KAAKE,CAAM,IAAI,CAAC,GAAGF,CAAI;AAC7D,SAAOI,EAASD,GAAYF,CAAI;AAClC;AAEA,SAASI,EAAWL,GAAWM,GAA+BC,IAAQ,IAAS;AAE7E,UADsBA,IAAQC,EAAOR,GAAMO,GAAOV,CAAmB,IAAIG,GACpD,OAAOM,CAAe;AAC7C;AAEO,SAASG,EAAQC,GAAkBC,IAAoB,IAAI;AAChE,MAAI,EAAE,OAAAC,IAAQhB,GAAe,UAAAiB,IAAW,MAAM,IAAM,QAAAX,MAAWS,GAC3DG,IAAU,CAAC,GAAGJ,CAAW,GACzBK,IAAS,GACTR,IAAQ,IACRP,IAAOK,EAAQS,GAASD,CAAQ,GAChCG,IAAQjB,EAASC,GAAMY,GAAOV,CAAM;AAExC,QAAMe,IAAS,OACbjB,IAAOK,EAAQS,GAASD,GAAUN,CAAK,GACvCS,IAAQjB,EAASC,GAAMY,GAAOV,CAAM,GACpCa,IAAS,KAAK,IAAI,GAAG,KAAK,IAAIA,GAAQC,EAAM,SAAS,CAAC,CAAC,GAChDA,EAAMD,CAAM,KAAK,CAAA;AAG1B,SAAO;AAAA,IACL,IAAI,UAAU;AACZ,aAAOC,EAAMD,CAAM,KAAK,CAAA;AAAA,IAC1B;AAAA,IACA,IAAI,KAAKG,GAAc;AACrB,MAAAJ,IAAU,CAAC,GAAGI,CAAO,GACrBH,IAAS,GACTE,EAAA;AAAA,IACF;AAAA,IACA,OAAOE,GAAiC;AACtC,aAAAN,IAAWM,GACXJ,IAAS,GACFE,EAAA;AAAA,IACT;AAAA,IACA,IAAI,MAAMG,GAAkB;AAC1B,MAAAR,IAAQ,KAAK,IAAId,GAAWsB,CAAQ,GACpCH,EAAA;AAAA,IACF;AAAA,IACA,IAAI,OAAO;AACT,aAAO;AAAA,QACL,KAAK,KAAK,IAAIL,KAASG,IAAS,IAAIf,EAAK,MAAM;AAAA,QAC/C,SAASA,EAAK,WAAW;AAAA,QACzB,SAASe,MAAW;AAAA,QACpB,QAAQA,MAAWC,EAAM,SAAS;AAAA,QAClC,OAAAJ;AAAA,QACA,MAAMG,IAAS;AAAA,QACf,OAAO,KAAK,KAAKf,EAAK,SAASY,CAAK;AAAA,QACpC,OAAO,KAAK,IAAI,GAAGA,IAAQG,IAAS,CAAC;AAAA,QACrC,OAAOf,EAAK;AAAA,MAAA;AAAA,IAEhB;AAAA,IACA,OAAO;AACL,MAAIe,IAASC,EAAM,SAAS,KAC1BD;AAAA,IAEJ;AAAA,IACA,IAAI,KAAKM,GAAc;AACrB,YAAMC,IAAQD,IAAO,GACfE,IAAQD,IAAQ,IAAIN,EAAM,SAASM,IAAQA;AACjD,MAAAP,IAAS,KAAK,IAAI,GAAG,KAAK,IAAIQ,GAAOP,EAAM,SAAS,CAAC,CAAC;AAAA,IACxD;AAAA,IACA,IAAI,QAAQ;AACV,aAAOA;AAAA,IACT;AAAA,IACA,OAAO;AACL,MAAID,IAAS,KACXA;AAAA,IAEJ;AAAA,IACA,QAAQ;AACN,aAAAA,IAAS,GACTR,IAAQ,IACRM,IAAWF,EAAO,aAAa,MAAM,KAC9BM,EAAA;AAAA,IACT;AAAA,IACA,QAAQO,EAAS,CAACC,OAChBlB,IAAQkB,GACDR,EAAA,EACR;AAAA,IACD,KAAKS,GAA6B;AAChC,aAAAxB,IAASwB,GACFT,EAAA;AAAA,IACT;AAAA,IACA,EAAE,OAAO,QAAQ,IAAI;AACnB,iBAAWI,KAAQL;AACjB,cAAMK;AAAA,IAEV;AAAA,EAAA;AAEJ;"}
+{"version":3,"file":"list.js","sources":["../../src/array/list.ts"],"sourcesContent":["import { debounce } from '../function/debounce';\nimport type { Predicate } from '../types';\nimport { chunk } from './chunk';\nimport { search } from './search';\n\ntype Config<T> = {\n  filterFn?: Predicate<T>;\n  limit?: number;\n  sortFn?: (a: T, b: T) => number;\n};\n\nconst DEFAULT_LIMIT = 10;\nconst DEFAULT_SEARCH_TONE = 0.5;\nconst MIN_LIMIT = 1;\n\nfunction getPages<T>(data: T[], size: number, sortFn: Config<T>['sortFn']): T[][] {\n  const sortedData = sortFn ? [...data].sort(sortFn) : [...data];\n  return chunk<T>(sortedData, size) as T[][];\n}\n\nfunction getData<T>(data: T[], currentFilterFn: Predicate<T>, query = ''): T[] {\n  const searchResults = query ? search(data, query, DEFAULT_SEARCH_TONE) : data;\n  return searchResults.filter(currentFilterFn) as T[];\n}\n\nexport function list<T>(initialData: T[], config: Config<T> = {}) {\n  let { limit = DEFAULT_LIMIT, filterFn = () => true, sortFn } = config;\n  let rawData = [...initialData];\n  let offset = 0;\n  let query = '';\n  let data = getData(rawData, filterFn);\n  let pages = getPages(data, limit, sortFn);\n\n  const update = () => {\n    data = getData(rawData, filterFn, query);\n    pages = getPages(data, limit, sortFn);\n    // Ensure offset is valid for the new page count\n    // If pages is empty, offset should be 0. Max index is pages.length - 1\n    const maxOffset = Math.max(0, pages.length - 1);\n    offset = Math.max(0, Math.min(offset, maxOffset));\n    return pages[offset] ?? [];\n  };\n\n  return {\n    get current() {\n      return pages[offset] ?? [];\n    },\n    set data(newData: T[]) {\n      rawData = [...newData];\n      offset = 0;\n      update();\n    },\n    filter(predicate: (item: T) => boolean) {\n      filterFn = predicate;\n      offset = 0;\n      return update();\n    },\n    set limit(newLimit: number) {\n      limit = Math.max(MIN_LIMIT, newLimit);\n      update();\n    },\n    get meta() {\n      return {\n        end: Math.min(limit * (offset + 1), data.length),\n        isEmpty: data.length === 0,\n        isFirst: offset === 0,\n        isLast: offset === pages.length - 1,\n        limit: limit,\n        page: offset + 1,\n        pages: Math.ceil(data.length / limit),\n        start: Math.max(0, limit * offset + 1),\n        total: data.length,\n      };\n    },\n    next() {\n      if (offset < pages.length - 1) {\n        offset++;\n      }\n    },\n    set page(page: number) {\n      const index = page - 1;\n      const value = index < 0 ? pages.length + index : index;\n      offset = Math.max(0, Math.min(value, pages.length - 1));\n    },\n    get pages() {\n      return pages;\n    },\n    prev() {\n      if (offset > 0) {\n        offset--;\n      }\n    },\n    reset() {\n      offset = 0;\n      query = '';\n      filterFn = config.filterFn ?? (() => true);\n      return update();\n    },\n    search: debounce((str: string) => {\n      query = str;\n      return update();\n    }),\n    sort(fn?: (a: T, b: T) => number) {\n      sortFn = fn;\n      return update();\n    },\n    *[Symbol.iterator]() {\n      for (const page of pages) {\n        yield page;\n      }\n    },\n  };\n}\n"],"names":["DEFAULT_LIMIT","DEFAULT_SEARCH_TONE","MIN_LIMIT","getPages","data","size","sortFn","sortedData","chunk","getData","currentFilterFn","query","search","list","initialData","config","limit","filterFn","rawData","offset","pages","update","maxOffset","newData","predicate","newLimit","page","index","value","debounce","str","fn"],"mappings":";;;AAWA,MAAMA,IAAgB,IAChBC,IAAsB,KACtBC,IAAY;AAElB,SAASC,EAAYC,GAAWC,GAAcC,GAAoC;AAChF,QAAMC,IAAaD,IAAS,CAAC,GAAGF,CAAI,EAAE,KAAKE,CAAM,IAAI,CAAC,GAAGF,CAAI;AAC7D,SAAOI,EAASD,GAAYF,CAAI;AAClC;AAEA,SAASI,EAAWL,GAAWM,GAA+BC,IAAQ,IAAS;AAE7E,UADsBA,IAAQC,EAAOR,GAAMO,GAAOV,CAAmB,IAAIG,GACpD,OAAOM,CAAe;AAC7C;AAEO,SAASG,EAAQC,GAAkBC,IAAoB,IAAI;AAChE,MAAI,EAAE,OAAAC,IAAQhB,GAAe,UAAAiB,IAAW,MAAM,IAAM,QAAAX,MAAWS,GAC3DG,IAAU,CAAC,GAAGJ,CAAW,GACzBK,IAAS,GACTR,IAAQ,IACRP,IAAOK,EAAQS,GAASD,CAAQ,GAChCG,IAAQjB,EAASC,GAAMY,GAAOV,CAAM;AAExC,QAAMe,IAAS,MAAM;AACnB,IAAAjB,IAAOK,EAAQS,GAASD,GAAUN,CAAK,GACvCS,IAAQjB,EAASC,GAAMY,GAAOV,CAAM;AAGpC,UAAMgB,IAAY,KAAK,IAAI,GAAGF,EAAM,SAAS,CAAC;AAC9C,WAAAD,IAAS,KAAK,IAAI,GAAG,KAAK,IAAIA,GAAQG,CAAS,CAAC,GACzCF,EAAMD,CAAM,KAAK,CAAA;AAAA,EAC1B;AAEA,SAAO;AAAA,IACL,IAAI,UAAU;AACZ,aAAOC,EAAMD,CAAM,KAAK,CAAA;AAAA,IAC1B;AAAA,IACA,IAAI,KAAKI,GAAc;AACrB,MAAAL,IAAU,CAAC,GAAGK,CAAO,GACrBJ,IAAS,GACTE,EAAA;AAAA,IACF;AAAA,IACA,OAAOG,GAAiC;AACtC,aAAAP,IAAWO,GACXL,IAAS,GACFE,EAAA;AAAA,IACT;AAAA,IACA,IAAI,MAAMI,GAAkB;AAC1B,MAAAT,IAAQ,KAAK,IAAId,GAAWuB,CAAQ,GACpCJ,EAAA;AAAA,IACF;AAAA,IACA,IAAI,OAAO;AACT,aAAO;AAAA,QACL,KAAK,KAAK,IAAIL,KAASG,IAAS,IAAIf,EAAK,MAAM;AAAA,QAC/C,SAASA,EAAK,WAAW;AAAA,QACzB,SAASe,MAAW;AAAA,QACpB,QAAQA,MAAWC,EAAM,SAAS;AAAA,QAClC,OAAAJ;AAAA,QACA,MAAMG,IAAS;AAAA,QACf,OAAO,KAAK,KAAKf,EAAK,SAASY,CAAK;AAAA,QACpC,OAAO,KAAK,IAAI,GAAGA,IAAQG,IAAS,CAAC;AAAA,QACrC,OAAOf,EAAK;AAAA,MAAA;AAAA,IAEhB;AAAA,IACA,OAAO;AACL,MAAIe,IAASC,EAAM,SAAS,KAC1BD;AAAA,IAEJ;AAAA,IACA,IAAI,KAAKO,GAAc;AACrB,YAAMC,IAAQD,IAAO,GACfE,IAAQD,IAAQ,IAAIP,EAAM,SAASO,IAAQA;AACjD,MAAAR,IAAS,KAAK,IAAI,GAAG,KAAK,IAAIS,GAAOR,EAAM,SAAS,CAAC,CAAC;AAAA,IACxD;AAAA,IACA,IAAI,QAAQ;AACV,aAAOA;AAAA,IACT;AAAA,IACA,OAAO;AACL,MAAID,IAAS,KACXA;AAAA,IAEJ;AAAA,IACA,QAAQ;AACN,aAAAA,IAAS,GACTR,IAAQ,IACRM,IAAWF,EAAO,aAAa,MAAM,KAC9BM,EAAA;AAAA,IACT;AAAA,IACA,QAAQQ,EAAS,CAACC,OAChBnB,IAAQmB,GACDT,EAAA,EACR;AAAA,IACD,KAAKU,GAA6B;AAChC,aAAAzB,IAASyB,GACFV,EAAA;AAAA,IACT;AAAA,IACA,EAAE,OAAO,QAAQ,IAAI;AACnB,iBAAWK,KAAQN;AACjB,cAAMM;AAAA,IAEV;AAAA,EAAA;AAEJ;"}

package/dist/array/pick.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"pick.cjs","sources":["../../src/array/pick.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { isNil } from '../typed/isNil';\nimport type { CallbackDynamic, Predicate, Result } from '../types';\n\n/**\n * Picks the first element from an array that satisfies a predicate function\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4];\n * pick(arr, x => x * x, x => x > 2) // 9\n * await pick(arr, async x => x * x, x => x > 2) // 9\n * ```\n *\n * @param array - The array to search.\n * @param callback - A function that is called for each element in the array.\n * @param predicate - A function that is called to validate each element in the array.\n *\n * @return The first element that satisfies the predicate, or undefined if no such element is found.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\nexport function pick<T, R, C extends CallbackDynamic<T, R>>(\n  array: T[],\n  callback: C,\n  predicate?: Predicate<T>,\n): Result<C> | undefined {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const isValid = predicate ?? ((value: T) => !isNil(value));\n\n  for (let index = 0; index < array.length; index++) {\n    if (isValid(array[index], index, array)) {\n      return callback(array[index], index, array) as Result<C>;\n    }\n  }\n\n  return undefined;\n}\n\npick.fp = true;\n"],"names":["pick","array","callback","predicate","assert","isArray","IS_ARRAY_ERROR_MSG","isValid","value","isNil","index"],"mappings":"4LAuBO,SAASA,EACdC,EACAC,EACAC,EACuB,CACvBC,EAAAA,OAAOC,EAAAA,QAAQJ,CAAK,EAAGK,qBAAoB,CAAE,KAAM,CAAE,MAAAL,CAAA,EAAS,KAAM,UAAW,EAE/E,MAAMM,EAAUJ,IAAeK,GAAa,CAACC,EAAAA,MAAMD,CAAK,GAExD,QAASE,EAAQ,EAAGA,EAAQT,EAAM,OAAQS,IACxC,GAAIH,EAAQN,EAAMS,CAAK,EAAGA,EAAOT,CAAK,EACpC,OAAOC,EAASD,EAAMS,CAAK,EAAGA,EAAOT,CAAK,CAKhD,CAEAD,EAAK,GAAK"}
+{"version":3,"file":"pick.cjs","sources":["../../src/array/pick.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { isNil } from '../typed/isNil';\n\n/**\n * Picks the first element from an array that satisfies a predicate function\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4];\n * pick(arr, x => x * x, x => x > 2) // 9\n * await pick(arr, async x => x * x, x => x > 2) // 9\n * ```\n *\n * @param array - The array to search.\n * @param callback - A function that is called for each element in the array.\n * @param predicate - A function that is called to validate each element in the array.\n *\n * @return The first element that satisfies the predicate, or undefined if no such element is found.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\nexport function pick<T, R = T>(\n  array: T[],\n  callback: (item: T, index: number, array: T[]) => R,\n  predicate?: (item: T, index: number, array: T[]) => boolean,\n): R | undefined {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const isValid = predicate ?? ((value: T) => !isNil(value));\n\n  for (let index = 0; index < array.length; index++) {\n    if (isValid(array[index], index, array)) {\n      return callback(array[index], index, array);\n    }\n  }\n\n  return undefined;\n}\n\npick.fp = true;\n"],"names":["pick","array","callback","predicate","assert","isArray","IS_ARRAY_ERROR_MSG","isValid","value","isNil","index"],"mappings":"4LAsBO,SAASA,EACdC,EACAC,EACAC,EACe,CACfC,EAAAA,OAAOC,EAAAA,QAAQJ,CAAK,EAAGK,qBAAoB,CAAE,KAAM,CAAE,MAAAL,CAAA,EAAS,KAAM,UAAW,EAE/E,MAAMM,EAAUJ,IAAeK,GAAa,CAACC,EAAAA,MAAMD,CAAK,GAExD,QAASE,EAAQ,EAAGA,EAAQT,EAAM,OAAQS,IACxC,GAAIH,EAAQN,EAAMS,CAAK,EAAGA,EAAOT,CAAK,EACpC,OAAOC,EAASD,EAAMS,CAAK,EAAGA,EAAOT,CAAK,CAKhD,CAEAD,EAAK,GAAK"}

package/dist/array/pick.js.map

@@ -1 +1 @@
-{"version":3,"file":"pick.js","sources":["../../src/array/pick.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { isNil } from '../typed/isNil';\nimport type { CallbackDynamic, Predicate, Result } from '../types';\n\n/**\n * Picks the first element from an array that satisfies a predicate function\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4];\n * pick(arr, x => x * x, x => x > 2) // 9\n * await pick(arr, async x => x * x, x => x > 2) // 9\n * ```\n *\n * @param array - The array to search.\n * @param callback - A function that is called for each element in the array.\n * @param predicate - A function that is called to validate each element in the array.\n *\n * @return The first element that satisfies the predicate, or undefined if no such element is found.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\nexport function pick<T, R, C extends CallbackDynamic<T, R>>(\n  array: T[],\n  callback: C,\n  predicate?: Predicate<T>,\n): Result<C> | undefined {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const isValid = predicate ?? ((value: T) => !isNil(value));\n\n  for (let index = 0; index < array.length; index++) {\n    if (isValid(array[index], index, array)) {\n      return callback(array[index], index, array) as Result<C>;\n    }\n  }\n\n  return undefined;\n}\n\npick.fp = true;\n"],"names":["pick","array","callback","predicate","assert","isArray","IS_ARRAY_ERROR_MSG","isValid","value","isNil","index"],"mappings":";;;AAuBO,SAASA,EACdC,GACAC,GACAC,GACuB;AACvB,EAAAC,EAAOC,EAAQJ,CAAK,GAAGK,GAAoB,EAAE,MAAM,EAAE,OAAAL,EAAA,GAAS,MAAM,WAAW;AAE/E,QAAMM,IAAUJ,MAAc,CAACK,MAAa,CAACC,EAAMD,CAAK;AAExD,WAASE,IAAQ,GAAGA,IAAQT,EAAM,QAAQS;AACxC,QAAIH,EAAQN,EAAMS,CAAK,GAAGA,GAAOT,CAAK;AACpC,aAAOC,EAASD,EAAMS,CAAK,GAAGA,GAAOT,CAAK;AAKhD;AAEAD,EAAK,KAAK;"}
+{"version":3,"file":"pick.js","sources":["../../src/array/pick.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { isNil } from '../typed/isNil';\n\n/**\n * Picks the first element from an array that satisfies a predicate function\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4];\n * pick(arr, x => x * x, x => x > 2) // 9\n * await pick(arr, async x => x * x, x => x > 2) // 9\n * ```\n *\n * @param array - The array to search.\n * @param callback - A function that is called for each element in the array.\n * @param predicate - A function that is called to validate each element in the array.\n *\n * @return The first element that satisfies the predicate, or undefined if no such element is found.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\nexport function pick<T, R = T>(\n  array: T[],\n  callback: (item: T, index: number, array: T[]) => R,\n  predicate?: (item: T, index: number, array: T[]) => boolean,\n): R | undefined {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const isValid = predicate ?? ((value: T) => !isNil(value));\n\n  for (let index = 0; index < array.length; index++) {\n    if (isValid(array[index], index, array)) {\n      return callback(array[index], index, array);\n    }\n  }\n\n  return undefined;\n}\n\npick.fp = true;\n"],"names":["pick","array","callback","predicate","assert","isArray","IS_ARRAY_ERROR_MSG","isValid","value","isNil","index"],"mappings":";;;AAsBO,SAASA,EACdC,GACAC,GACAC,GACe;AACf,EAAAC,EAAOC,EAAQJ,CAAK,GAAGK,GAAoB,EAAE,MAAM,EAAE,OAAAL,EAAA,GAAS,MAAM,WAAW;AAE/E,QAAMM,IAAUJ,MAAc,CAACK,MAAa,CAACC,EAAMD,CAAK;AAExD,WAASE,IAAQ,GAAGA,IAAQT,EAAM,QAAQS;AACxC,QAAIH,EAAQN,EAAMS,CAAK,GAAGA,GAAOT,CAAK;AACpC,aAAOC,EAASD,EAAMS,CAAK,GAAGA,GAAOT,CAAK;AAKhD;AAEAD,EAAK,KAAK;"}

package/dist/date/timeDiff.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});let a=["YEAR","MONTH","WEEK","DAY","HOUR","MINUTE","SECOND"];const f=1e3,c=60*f,N=60*c,e=24*N,D=7*e,_=30*e,S=365*e,R=[{ms:S,unit:"YEAR"},{ms:_,unit:"MONTH"},{ms:D,unit:"WEEK"},{ms:e,unit:"DAY"},{ms:N,unit:"HOUR"},{ms:c,unit:"MINUTE"},{ms:f,unit:"SECOND"}];function M(t,i=new Date,l=a){const o=typeof t=="string"?Date.parse(t):t.getTime(),E=typeof i=="string"?Date.parse(i):i.getTime();if(Number.isNaN(o)||Number.isNaN(E))return{unit:"INVALID_DATE",value:0};const s=R.filter(n=>l.includes(n.unit)),u=Math.abs(o-E),r=s[s.length-1]?.unit??"SECOND";if(u<=0)return{unit:r,value:0};for(const{ms:n,unit:m}of s)if(u>=n)return{unit:m,value:Math.floor(u/n)};return{unit:r,value:0}}M.defaultUnits=t=>{a=t};exports.timeDiff=M;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});let c=["YEAR","MONTH","WEEK","DAY","HOUR","MINUTE","SECOND"];const f=1e3,N=60*f,m=60*N,n=24*m,D=7*n,_=30*n,S=365*n,R=[{ms:S,unit:"YEAR"},{ms:_,unit:"MONTH"},{ms:D,unit:"WEEK"},{ms:n,unit:"DAY"},{ms:m,unit:"HOUR"},{ms:N,unit:"MINUTE"},{ms:f,unit:"SECOND"}];function M(t,e=new Date,l=c){const o=typeof t=="string"?Date.parse(t):t.getTime(),a=typeof e=="string"?Date.parse(e):e.getTime();if(Number.isNaN(o)||Number.isNaN(a))return{unit:"INVALID_DATE",value:0};const i=R.filter(E=>l.includes(E.unit)),s=Math.abs(o-a),r=i[i.length-1]?.unit??"SECOND";if(s<=0)return{unit:r,value:0};const u=i.find(E=>s>=E.ms);return u?{unit:u.unit,value:Math.floor(s/u.ms)}:{unit:r,value:0}}M.defaultUnits=t=>{c=t};exports.timeDiff=M;
 //# sourceMappingURL=timeDiff.cjs.map

package/dist/date/timeDiff.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"timeDiff.cjs","sources":["../../src/date/timeDiff.ts"],"sourcesContent":["export type TimeUnit = 'YEAR' | 'MONTH' | 'WEEK' | 'DAY' | 'HOUR' | 'MINUTE' | 'SECOND' | 'INVALID_DATE';\nexport type TimeDirection = 'FUTURE' | 'PAST';\nexport type TimeResult = { unit: TimeUnit; value: number };\n\nlet defaultUnits: TimeUnit[] = ['YEAR', 'MONTH', 'WEEK', 'DAY', 'HOUR', 'MINUTE', 'SECOND'];\n\nconst MS_PER_SECOND = 1000;\nconst MS_PER_MINUTE = 60 * MS_PER_SECOND;\nconst MS_PER_HOUR = 60 * MS_PER_MINUTE;\nconst MS_PER_DAY = 24 * MS_PER_HOUR;\nconst MS_PER_WEEK = 7 * MS_PER_DAY;\nconst MS_PER_MONTH = 30 * MS_PER_DAY;\nconst MS_PER_YEAR = 365 * MS_PER_DAY;\n\nconst TIME_UNITS = [\n  { ms: MS_PER_YEAR, unit: 'YEAR' as const },\n  { ms: MS_PER_MONTH, unit: 'MONTH' as const },\n  { ms: MS_PER_WEEK, unit: 'WEEK' as const },\n  { ms: MS_PER_DAY, unit: 'DAY' as const },\n  { ms: MS_PER_HOUR, unit: 'HOUR' as const },\n  { ms: MS_PER_MINUTE, unit: 'MINUTE' as const },\n  { ms: MS_PER_SECOND, unit: 'SECOND' as const },\n];\n\n/**\n * Calculates the remaining time until a target date.\n *\n * @example\n * ```ts\n * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 5)); // { value: 5, unit: 'DAY' }\n * timeDiff(new Date(Date.now() - 1000 * 60 * 60 * 24 * 3), 'past'); // { value: 3, unit: 'DAY' }\n * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 31)); // { value: 1, unit: 'MONTH' }\n * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 365)); // { value: 1, unit: 'YEAR' }\n * ```\n *\n * @param a - The target date (Date object or ISO string).\n * @param b - The target date (Date object or ISO string).\n * @param allowedUnits - (optional) array of units to filter the result. If provided, only these units will be considered.\n *\n * @returns An object containing the remaining time and its unit ('DAY', 'HOUR', or 'MINUTE').\n */\nexport function timeDiff(\n  a: Date | string,\n  b: Date | string = new Date(),\n  allowedUnits: TimeUnit[] = defaultUnits,\n): TimeResult {\n  const aDate = typeof a === 'string' ? Date.parse(a) : a.getTime();\n  const bDate = typeof b === 'string' ? Date.parse(b) : b.getTime();\n\n  if (Number.isNaN(aDate) || Number.isNaN(bDate)) {\n    return { unit: 'INVALID_DATE', value: 0 };\n  }\n\n  const units = TIME_UNITS.filter((u) => allowedUnits.includes(u.unit));\n  const diff = Math.abs(aDate - bDate);\n  const smallestUnit = units[units.length - 1]?.unit ?? 'SECOND';\n\n  if (diff <= 0) {\n    return { unit: smallestUnit, value: 0 };\n  }\n\n  for (const { ms, unit } of units) {\n    if (diff >= ms) {\n      return { unit, value: Math.floor(diff / ms) };\n    }\n  }\n\n  return { unit: smallestUnit, value: 0 };\n}\n\ntimeDiff.defaultUnits = (units: TimeUnit[]) => {\n  defaultUnits = units;\n};\n"],"names":["defaultUnits","MS_PER_SECOND","MS_PER_MINUTE","MS_PER_HOUR","MS_PER_DAY","MS_PER_WEEK","MS_PER_MONTH","MS_PER_YEAR","TIME_UNITS","timeDiff","a","b","allowedUnits","aDate","bDate","units","u","diff","smallestUnit","ms","unit"],"mappings":"gFAIA,IAAIA,EAA2B,CAAC,OAAQ,QAAS,OAAQ,MAAO,OAAQ,SAAU,QAAQ,EAE1F,MAAMC,EAAgB,IAChBC,EAAgB,GAAKD,EACrBE,EAAc,GAAKD,EACnBE,EAAa,GAAKD,EAClBE,EAAc,EAAID,EAClBE,EAAe,GAAKF,EACpBG,EAAc,IAAMH,EAEpBI,EAAa,CACjB,CAAE,GAAID,EAAa,KAAM,MAAA,EACzB,CAAE,GAAID,EAAc,KAAM,OAAA,EAC1B,CAAE,GAAID,EAAa,KAAM,MAAA,EACzB,CAAE,GAAID,EAAY,KAAM,KAAA,EACxB,CAAE,GAAID,EAAa,KAAM,MAAA,EACzB,CAAE,GAAID,EAAe,KAAM,QAAA,EAC3B,CAAE,GAAID,EAAe,KAAM,QAAA,CAC7B,EAmBO,SAASQ,EACdC,EACAC,MAAuB,KACvBC,EAA2BZ,EACf,CACZ,MAAMa,EAAQ,OAAOH,GAAM,SAAW,KAAK,MAAMA,CAAC,EAAIA,EAAE,QAAA,EAClDI,EAAQ,OAAOH,GAAM,SAAW,KAAK,MAAMA,CAAC,EAAIA,EAAE,QAAA,EAExD,GAAI,OAAO,MAAME,CAAK,GAAK,OAAO,MAAMC,CAAK,EAC3C,MAAO,CAAE,KAAM,eAAgB,MAAO,CAAA,EAGxC,MAAMC,EAAQP,EAAW,OAAQQ,GAAMJ,EAAa,SAASI,EAAE,IAAI,CAAC,EAC9DC,EAAO,KAAK,IAAIJ,EAAQC,CAAK,EAC7BI,EAAeH,EAAMA,EAAM,OAAS,CAAC,GAAG,MAAQ,SAEtD,GAAIE,GAAQ,EACV,MAAO,CAAE,KAAMC,EAAc,MAAO,CAAA,EAGtC,SAAW,CAAE,GAAAC,EAAI,KAAAC,CAAA,IAAUL,EACzB,GAAIE,GAAQE,EACV,MAAO,CAAE,KAAAC,EAAM,MAAO,KAAK,MAAMH,EAAOE,CAAE,CAAA,EAI9C,MAAO,CAAE,KAAMD,EAAc,MAAO,CAAA,CACtC,CAEAT,EAAS,aAAgBM,GAAsB,CAC7Cf,EAAee,CACjB"}
+{"version":3,"file":"timeDiff.cjs","sources":["../../src/date/timeDiff.ts"],"sourcesContent":["export type TimeUnit = 'YEAR' | 'MONTH' | 'WEEK' | 'DAY' | 'HOUR' | 'MINUTE' | 'SECOND' | 'INVALID_DATE';\nexport type TimeDirection = 'FUTURE' | 'PAST';\nexport type TimeResult = { unit: TimeUnit; value: number };\n\nlet defaultUnits: TimeUnit[] = ['YEAR', 'MONTH', 'WEEK', 'DAY', 'HOUR', 'MINUTE', 'SECOND'];\n\nconst MS_PER_SECOND = 1000;\nconst MS_PER_MINUTE = 60 * MS_PER_SECOND;\nconst MS_PER_HOUR = 60 * MS_PER_MINUTE;\nconst MS_PER_DAY = 24 * MS_PER_HOUR;\nconst MS_PER_WEEK = 7 * MS_PER_DAY;\nconst MS_PER_MONTH = 30 * MS_PER_DAY;\nconst MS_PER_YEAR = 365 * MS_PER_DAY;\n\nconst TIME_UNITS = [\n  { ms: MS_PER_YEAR, unit: 'YEAR' as const },\n  { ms: MS_PER_MONTH, unit: 'MONTH' as const },\n  { ms: MS_PER_WEEK, unit: 'WEEK' as const },\n  { ms: MS_PER_DAY, unit: 'DAY' as const },\n  { ms: MS_PER_HOUR, unit: 'HOUR' as const },\n  { ms: MS_PER_MINUTE, unit: 'MINUTE' as const },\n  { ms: MS_PER_SECOND, unit: 'SECOND' as const },\n];\n\n/**\n * Calculates the remaining time until a target date.\n *\n * @example\n * ```ts\n * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 5)); // { value: 5, unit: 'DAY' }\n * timeDiff(new Date(Date.now() - 1000 * 60 * 60 * 24 * 3), 'past'); // { value: 3, unit: 'DAY' }\n * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 31)); // { value: 1, unit: 'MONTH' }\n * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 365)); // { value: 1, unit: 'YEAR' }\n * ```\n *\n * @param a - The target date (Date object or ISO string).\n * @param b - The target date (Date object or ISO string).\n * @param allowedUnits - (optional) array of units to filter the result. If provided, only these units will be considered.\n *\n * @returns An object containing the remaining time and its unit ('DAY', 'HOUR', or 'MINUTE').\n */\nexport function timeDiff(\n  a: Date | string,\n  b: Date | string = new Date(),\n  allowedUnits: TimeUnit[] = defaultUnits,\n): TimeResult {\n  const aDate = typeof a === 'string' ? Date.parse(a) : a.getTime();\n  const bDate = typeof b === 'string' ? Date.parse(b) : b.getTime();\n\n  if (Number.isNaN(aDate) || Number.isNaN(bDate)) {\n    return { unit: 'INVALID_DATE', value: 0 };\n  }\n\n  const units = TIME_UNITS.filter((u) => allowedUnits.includes(u.unit));\n  const diff = Math.abs(aDate - bDate);\n  const smallestUnit = units[units.length - 1]?.unit ?? 'SECOND';\n\n  if (diff <= 0) {\n    return { unit: smallestUnit, value: 0 };\n  }\n\n  // Find the largest unit that fits\n  const bestUnit = units.find((u) => diff >= u.ms);\n\n  if (bestUnit) {\n    return { unit: bestUnit.unit, value: Math.floor(diff / bestUnit.ms) };\n  }\n\n  return { unit: smallestUnit, value: 0 };\n}\n\ntimeDiff.defaultUnits = (units: TimeUnit[]) => {\n  defaultUnits = units;\n};\n"],"names":["defaultUnits","MS_PER_SECOND","MS_PER_MINUTE","MS_PER_HOUR","MS_PER_DAY","MS_PER_WEEK","MS_PER_MONTH","MS_PER_YEAR","TIME_UNITS","timeDiff","a","b","allowedUnits","aDate","bDate","units","u","diff","smallestUnit","bestUnit"],"mappings":"gFAIA,IAAIA,EAA2B,CAAC,OAAQ,QAAS,OAAQ,MAAO,OAAQ,SAAU,QAAQ,EAE1F,MAAMC,EAAgB,IAChBC,EAAgB,GAAKD,EACrBE,EAAc,GAAKD,EACnBE,EAAa,GAAKD,EAClBE,EAAc,EAAID,EAClBE,EAAe,GAAKF,EACpBG,EAAc,IAAMH,EAEpBI,EAAa,CACjB,CAAE,GAAID,EAAa,KAAM,MAAA,EACzB,CAAE,GAAID,EAAc,KAAM,OAAA,EAC1B,CAAE,GAAID,EAAa,KAAM,MAAA,EACzB,CAAE,GAAID,EAAY,KAAM,KAAA,EACxB,CAAE,GAAID,EAAa,KAAM,MAAA,EACzB,CAAE,GAAID,EAAe,KAAM,QAAA,EAC3B,CAAE,GAAID,EAAe,KAAM,QAAA,CAC7B,EAmBO,SAASQ,EACdC,EACAC,MAAuB,KACvBC,EAA2BZ,EACf,CACZ,MAAMa,EAAQ,OAAOH,GAAM,SAAW,KAAK,MAAMA,CAAC,EAAIA,EAAE,QAAA,EAClDI,EAAQ,OAAOH,GAAM,SAAW,KAAK,MAAMA,CAAC,EAAIA,EAAE,QAAA,EAExD,GAAI,OAAO,MAAME,CAAK,GAAK,OAAO,MAAMC,CAAK,EAC3C,MAAO,CAAE,KAAM,eAAgB,MAAO,CAAA,EAGxC,MAAMC,EAAQP,EAAW,OAAQQ,GAAMJ,EAAa,SAASI,EAAE,IAAI,CAAC,EAC9DC,EAAO,KAAK,IAAIJ,EAAQC,CAAK,EAC7BI,EAAeH,EAAMA,EAAM,OAAS,CAAC,GAAG,MAAQ,SAEtD,GAAIE,GAAQ,EACV,MAAO,CAAE,KAAMC,EAAc,MAAO,CAAA,EAItC,MAAMC,EAAWJ,EAAM,KAAMC,GAAMC,GAAQD,EAAE,EAAE,EAE/C,OAAIG,EACK,CAAE,KAAMA,EAAS,KAAM,MAAO,KAAK,MAAMF,EAAOE,EAAS,EAAE,CAAA,EAG7D,CAAE,KAAMD,EAAc,MAAO,CAAA,CACtC,CAEAT,EAAS,aAAgBM,GAAsB,CAC7Cf,EAAee,CACjB"}

package/dist/date/timeDiff.js

@@ -8,22 +8,20 @@ const N = [
   { ms: 6e4, unit: "MINUTE" },
   { ms: 1e3, unit: "SECOND" }
 ];
-function o(t, n = /* @__PURE__ */ new Date(), u = R) {
-  const e = typeof t == "string" ? Date.parse(t) : t.getTime(), i = typeof n == "string" ? Date.parse(n) : n.getTime();
-  if (Number.isNaN(e) || Number.isNaN(i))
+function D(t, n = /* @__PURE__ */ new Date(), S = R) {
+  const i = typeof t == "string" ? Date.parse(t) : t.getTime(), M = typeof n == "string" ? Date.parse(n) : n.getTime();
+  if (Number.isNaN(i) || Number.isNaN(M))
     return { unit: "INVALID_DATE", value: 0 };
-  const _ = N.filter((E) => u.includes(E.unit)), s = Math.abs(e - i), M = _[_.length - 1]?.unit ?? "SECOND";
-  if (s <= 0)
-    return { unit: M, value: 0 };
-  for (const { ms: E, unit: S } of _)
-    if (s >= E)
-      return { unit: S, value: Math.floor(s / E) };
-  return { unit: M, value: 0 };
+  const E = N.filter((e) => S.includes(e.unit)), _ = Math.abs(i - M), u = E[E.length - 1]?.unit ?? "SECOND";
+  if (_ <= 0)
+    return { unit: u, value: 0 };
+  const s = E.find((e) => _ >= e.ms);
+  return s ? { unit: s.unit, value: Math.floor(_ / s.ms) } : { unit: u, value: 0 };
 }
-o.defaultUnits = (t) => {
+D.defaultUnits = (t) => {
   R = t;
 };
 export {
-  o as timeDiff
+  D as timeDiff
 };
 //# sourceMappingURL=timeDiff.js.map

package/dist/date/timeDiff.js.map

@@ -1 +1 @@
-{"version":3,"file":"timeDiff.js","sources":["../../src/date/timeDiff.ts"],"sourcesContent":["export type TimeUnit = 'YEAR' | 'MONTH' | 'WEEK' | 'DAY' | 'HOUR' | 'MINUTE' | 'SECOND' | 'INVALID_DATE';\nexport type TimeDirection = 'FUTURE' | 'PAST';\nexport type TimeResult = { unit: TimeUnit; value: number };\n\nlet defaultUnits: TimeUnit[] = ['YEAR', 'MONTH', 'WEEK', 'DAY', 'HOUR', 'MINUTE', 'SECOND'];\n\nconst MS_PER_SECOND = 1000;\nconst MS_PER_MINUTE = 60 * MS_PER_SECOND;\nconst MS_PER_HOUR = 60 * MS_PER_MINUTE;\nconst MS_PER_DAY = 24 * MS_PER_HOUR;\nconst MS_PER_WEEK = 7 * MS_PER_DAY;\nconst MS_PER_MONTH = 30 * MS_PER_DAY;\nconst MS_PER_YEAR = 365 * MS_PER_DAY;\n\nconst TIME_UNITS = [\n  { ms: MS_PER_YEAR, unit: 'YEAR' as const },\n  { ms: MS_PER_MONTH, unit: 'MONTH' as const },\n  { ms: MS_PER_WEEK, unit: 'WEEK' as const },\n  { ms: MS_PER_DAY, unit: 'DAY' as const },\n  { ms: MS_PER_HOUR, unit: 'HOUR' as const },\n  { ms: MS_PER_MINUTE, unit: 'MINUTE' as const },\n  { ms: MS_PER_SECOND, unit: 'SECOND' as const },\n];\n\n/**\n * Calculates the remaining time until a target date.\n *\n * @example\n * ```ts\n * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 5)); // { value: 5, unit: 'DAY' }\n * timeDiff(new Date(Date.now() - 1000 * 60 * 60 * 24 * 3), 'past'); // { value: 3, unit: 'DAY' }\n * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 31)); // { value: 1, unit: 'MONTH' }\n * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 365)); // { value: 1, unit: 'YEAR' }\n * ```\n *\n * @param a - The target date (Date object or ISO string).\n * @param b - The target date (Date object or ISO string).\n * @param allowedUnits - (optional) array of units to filter the result. If provided, only these units will be considered.\n *\n * @returns An object containing the remaining time and its unit ('DAY', 'HOUR', or 'MINUTE').\n */\nexport function timeDiff(\n  a: Date | string,\n  b: Date | string = new Date(),\n  allowedUnits: TimeUnit[] = defaultUnits,\n): TimeResult {\n  const aDate = typeof a === 'string' ? Date.parse(a) : a.getTime();\n  const bDate = typeof b === 'string' ? Date.parse(b) : b.getTime();\n\n  if (Number.isNaN(aDate) || Number.isNaN(bDate)) {\n    return { unit: 'INVALID_DATE', value: 0 };\n  }\n\n  const units = TIME_UNITS.filter((u) => allowedUnits.includes(u.unit));\n  const diff = Math.abs(aDate - bDate);\n  const smallestUnit = units[units.length - 1]?.unit ?? 'SECOND';\n\n  if (diff <= 0) {\n    return { unit: smallestUnit, value: 0 };\n  }\n\n  for (const { ms, unit } of units) {\n    if (diff >= ms) {\n      return { unit, value: Math.floor(diff / ms) };\n    }\n  }\n\n  return { unit: smallestUnit, value: 0 };\n}\n\ntimeDiff.defaultUnits = (units: TimeUnit[]) => {\n  defaultUnits = units;\n};\n"],"names":["defaultUnits","TIME_UNITS","timeDiff","a","b","allowedUnits","aDate","bDate","units","u","diff","smallestUnit","ms","unit"],"mappings":"AAIA,IAAIA,IAA2B,CAAC,QAAQ,SAAS,QAAQ,OAAO,QAAQ,UAAU,QAAQ;AAU1F,MAAMC,IAAa;AAAA,EACjB,EAAE,IAAI,SAAa,MAAM,OAAA;AAAA,EACzB,EAAE,IAAI,QAAc,MAAM,QAAA;AAAA,EAC1B,EAAE,IAAI,QAAa,MAAM,OAAA;AAAA,EACzB,EAAE,IAAI,OAAY,MAAM,MAAA;AAAA,EACxB,EAAE,IAAI,MAAa,MAAM,OAAA;AAAA,EACzB,EAAE,IAAI,KAAe,MAAM,SAAA;AAAA,EAC3B,EAAE,IAAI,KAAe,MAAM,SAAA;AAC7B;AAmBO,SAASC,EACdC,GACAC,wBAAuB,KAAA,GACvBC,IAA2BL,GACf;AACZ,QAAMM,IAAQ,OAAOH,KAAM,WAAW,KAAK,MAAMA,CAAC,IAAIA,EAAE,QAAA,GAClDI,IAAQ,OAAOH,KAAM,WAAW,KAAK,MAAMA,CAAC,IAAIA,EAAE,QAAA;AAExD,MAAI,OAAO,MAAME,CAAK,KAAK,OAAO,MAAMC,CAAK;AAC3C,WAAO,EAAE,MAAM,gBAAgB,OAAO,EAAA;AAGxC,QAAMC,IAAQP,EAAW,OAAO,CAACQ,MAAMJ,EAAa,SAASI,EAAE,IAAI,CAAC,GAC9DC,IAAO,KAAK,IAAIJ,IAAQC,CAAK,GAC7BI,IAAeH,EAAMA,EAAM,SAAS,CAAC,GAAG,QAAQ;AAEtD,MAAIE,KAAQ;AACV,WAAO,EAAE,MAAMC,GAAc,OAAO,EAAA;AAGtC,aAAW,EAAE,IAAAC,GAAI,MAAAC,EAAA,KAAUL;AACzB,QAAIE,KAAQE;AACV,aAAO,EAAE,MAAAC,GAAM,OAAO,KAAK,MAAMH,IAAOE,CAAE,EAAA;AAI9C,SAAO,EAAE,MAAMD,GAAc,OAAO,EAAA;AACtC;AAEAT,EAAS,eAAe,CAACM,MAAsB;AAC7C,EAAAR,IAAeQ;AACjB;"}
+{"version":3,"file":"timeDiff.js","sources":["../../src/date/timeDiff.ts"],"sourcesContent":["export type TimeUnit = 'YEAR' | 'MONTH' | 'WEEK' | 'DAY' | 'HOUR' | 'MINUTE' | 'SECOND' | 'INVALID_DATE';\nexport type TimeDirection = 'FUTURE' | 'PAST';\nexport type TimeResult = { unit: TimeUnit; value: number };\n\nlet defaultUnits: TimeUnit[] = ['YEAR', 'MONTH', 'WEEK', 'DAY', 'HOUR', 'MINUTE', 'SECOND'];\n\nconst MS_PER_SECOND = 1000;\nconst MS_PER_MINUTE = 60 * MS_PER_SECOND;\nconst MS_PER_HOUR = 60 * MS_PER_MINUTE;\nconst MS_PER_DAY = 24 * MS_PER_HOUR;\nconst MS_PER_WEEK = 7 * MS_PER_DAY;\nconst MS_PER_MONTH = 30 * MS_PER_DAY;\nconst MS_PER_YEAR = 365 * MS_PER_DAY;\n\nconst TIME_UNITS = [\n  { ms: MS_PER_YEAR, unit: 'YEAR' as const },\n  { ms: MS_PER_MONTH, unit: 'MONTH' as const },\n  { ms: MS_PER_WEEK, unit: 'WEEK' as const },\n  { ms: MS_PER_DAY, unit: 'DAY' as const },\n  { ms: MS_PER_HOUR, unit: 'HOUR' as const },\n  { ms: MS_PER_MINUTE, unit: 'MINUTE' as const },\n  { ms: MS_PER_SECOND, unit: 'SECOND' as const },\n];\n\n/**\n * Calculates the remaining time until a target date.\n *\n * @example\n * ```ts\n * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 5)); // { value: 5, unit: 'DAY' }\n * timeDiff(new Date(Date.now() - 1000 * 60 * 60 * 24 * 3), 'past'); // { value: 3, unit: 'DAY' }\n * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 31)); // { value: 1, unit: 'MONTH' }\n * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 365)); // { value: 1, unit: 'YEAR' }\n * ```\n *\n * @param a - The target date (Date object or ISO string).\n * @param b - The target date (Date object or ISO string).\n * @param allowedUnits - (optional) array of units to filter the result. If provided, only these units will be considered.\n *\n * @returns An object containing the remaining time and its unit ('DAY', 'HOUR', or 'MINUTE').\n */\nexport function timeDiff(\n  a: Date | string,\n  b: Date | string = new Date(),\n  allowedUnits: TimeUnit[] = defaultUnits,\n): TimeResult {\n  const aDate = typeof a === 'string' ? Date.parse(a) : a.getTime();\n  const bDate = typeof b === 'string' ? Date.parse(b) : b.getTime();\n\n  if (Number.isNaN(aDate) || Number.isNaN(bDate)) {\n    return { unit: 'INVALID_DATE', value: 0 };\n  }\n\n  const units = TIME_UNITS.filter((u) => allowedUnits.includes(u.unit));\n  const diff = Math.abs(aDate - bDate);\n  const smallestUnit = units[units.length - 1]?.unit ?? 'SECOND';\n\n  if (diff <= 0) {\n    return { unit: smallestUnit, value: 0 };\n  }\n\n  // Find the largest unit that fits\n  const bestUnit = units.find((u) => diff >= u.ms);\n\n  if (bestUnit) {\n    return { unit: bestUnit.unit, value: Math.floor(diff / bestUnit.ms) };\n  }\n\n  return { unit: smallestUnit, value: 0 };\n}\n\ntimeDiff.defaultUnits = (units: TimeUnit[]) => {\n  defaultUnits = units;\n};\n"],"names":["defaultUnits","TIME_UNITS","timeDiff","a","b","allowedUnits","aDate","bDate","units","u","diff","smallestUnit","bestUnit"],"mappings":"AAIA,IAAIA,IAA2B,CAAC,QAAQ,SAAS,QAAQ,OAAO,QAAQ,UAAU,QAAQ;AAU1F,MAAMC,IAAa;AAAA,EACjB,EAAE,IAAI,SAAa,MAAM,OAAA;AAAA,EACzB,EAAE,IAAI,QAAc,MAAM,QAAA;AAAA,EAC1B,EAAE,IAAI,QAAa,MAAM,OAAA;AAAA,EACzB,EAAE,IAAI,OAAY,MAAM,MAAA;AAAA,EACxB,EAAE,IAAI,MAAa,MAAM,OAAA;AAAA,EACzB,EAAE,IAAI,KAAe,MAAM,SAAA;AAAA,EAC3B,EAAE,IAAI,KAAe,MAAM,SAAA;AAC7B;AAmBO,SAASC,EACdC,GACAC,wBAAuB,KAAA,GACvBC,IAA2BL,GACf;AACZ,QAAMM,IAAQ,OAAOH,KAAM,WAAW,KAAK,MAAMA,CAAC,IAAIA,EAAE,QAAA,GAClDI,IAAQ,OAAOH,KAAM,WAAW,KAAK,MAAMA,CAAC,IAAIA,EAAE,QAAA;AAExD,MAAI,OAAO,MAAME,CAAK,KAAK,OAAO,MAAMC,CAAK;AAC3C,WAAO,EAAE,MAAM,gBAAgB,OAAO,EAAA;AAGxC,QAAMC,IAAQP,EAAW,OAAO,CAACQ,MAAMJ,EAAa,SAASI,EAAE,IAAI,CAAC,GAC9DC,IAAO,KAAK,IAAIJ,IAAQC,CAAK,GAC7BI,IAAeH,EAAMA,EAAM,SAAS,CAAC,GAAG,QAAQ;AAEtD,MAAIE,KAAQ;AACV,WAAO,EAAE,MAAMC,GAAc,OAAO,EAAA;AAItC,QAAMC,IAAWJ,EAAM,KAAK,CAACC,MAAMC,KAAQD,EAAE,EAAE;AAE/C,SAAIG,IACK,EAAE,MAAMA,EAAS,MAAM,OAAO,KAAK,MAAMF,IAAOE,EAAS,EAAE,EAAA,IAG7D,EAAE,MAAMD,GAAc,OAAO,EAAA;AACtC;AAEAT,EAAS,eAAe,CAACM,MAAsB;AAC7C,EAAAR,IAAeQ;AACjB;"}

package/dist/function/curry.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=t=>{const e=(...r)=>r.length>=t.length?t(...r):(...c)=>e(...r.concat(c));return e};exports.curry=n;
+"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

package/dist/function/curry.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"curry.cjs","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 *\n * @returns A curried version of the function.\n */\n\n// biome-ignore lint/suspicious/noExplicitAny: -\nexport const curry = <T extends (...args: any[]) => any>(fn: T) => {\n  // biome-ignore lint/suspicious/noExplicitAny: -\n  const curried = (...args: Parameters<T>): any => {\n    if (args.length >= fn.length) {\n      return fn(...args);\n    }\n    return (...rest: Exclude<Parameters<T>, typeof args>) => curried(...(args.concat(rest) as Parameters<T>));\n  };\n  return curried as T extends (...args: infer P) => infer R ? CurriedFunction<P, R> : never;\n};\n\n// biome-ignore lint/suspicious/noExplicitAny: -\ntype CurriedFunction<Params extends any[], R> = Params extends [infer A, ...infer Rest]\n  ? (arg: A) => CurriedFunction<Rest, R>\n  : R;\n"],"names":["curry","fn","curried","args","rest"],"mappings":"gFAgBO,MAAMA,EAA4CC,GAAU,CAEjE,MAAMC,EAAU,IAAIC,IACdA,EAAK,QAAUF,EAAG,OACbA,EAAG,GAAGE,CAAI,EAEZ,IAAIC,IAA8CF,EAAQ,GAAIC,EAAK,OAAOC,CAAI,CAAmB,EAE1G,OAAOF,CACT"}
+{"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"}

package/dist/function/curry.js

@@ -1,7 +1,7 @@
-const c = (t) => {
-  const e = (...r) => r.length >= t.length ? t(...r) : (...n) => e(...r.concat(n));
+function c(t, n = t.length) {
+  const e = (...r) => r.length >= n ? t(...r) : (...u) => e(...r, ...u);
   return e;
-};
+}
 export {
   c as curry
 };

package/dist/function/curry.js.map

@@ -1 +1 @@
-{"version":3,"file":"curry.js","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 *\n * @returns A curried version of the function.\n */\n\n// biome-ignore lint/suspicious/noExplicitAny: -\nexport const curry = <T extends (...args: any[]) => any>(fn: T) => {\n  // biome-ignore lint/suspicious/noExplicitAny: -\n  const curried = (...args: Parameters<T>): any => {\n    if (args.length >= fn.length) {\n      return fn(...args);\n    }\n    return (...rest: Exclude<Parameters<T>, typeof args>) => curried(...(args.concat(rest) as Parameters<T>));\n  };\n  return curried as T extends (...args: infer P) => infer R ? CurriedFunction<P, R> : never;\n};\n\n// biome-ignore lint/suspicious/noExplicitAny: -\ntype CurriedFunction<Params extends any[], R> = Params extends [infer A, ...infer Rest]\n  ? (arg: A) => CurriedFunction<Rest, R>\n  : R;\n"],"names":["curry","fn","curried","args","rest"],"mappings":"AAgBO,MAAMA,IAAQ,CAAoCC,MAAU;AAEjE,QAAMC,IAAU,IAAIC,MACdA,EAAK,UAAUF,EAAG,SACbA,EAAG,GAAGE,CAAI,IAEZ,IAAIC,MAA8CF,EAAQ,GAAIC,EAAK,OAAOC,CAAI,CAAmB;AAE1G,SAAOF;AACT;"}
+{"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;"}

package/dist/function/debounce.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function i(t,o=300){let e;return(...u)=>{clearTimeout(e),e=setTimeout(()=>t(...u),o)}}exports.debounce=i;
+"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

package/dist/function/debounce.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"debounce.cjs","sources":["../../src/function/debounce.ts"],"sourcesContent":["import type { Fn } from '../types';\n\n/**\n * Creates a debounced function that delays invoking the provided function until after\n * a specified wait time has elapsed since the last invocation.\n *\n * @example\n * ```ts\n * const debouncedLog = debounce(console.log, 1000);\n *\n * debouncedLog('Hello'); // Will log after 1 second if not called again\n * debouncedLog('World'); // Resets the timer, will log 'World' after 1 second\n * ```\n *\n * @param fn - The function to debounce.\n * @param [delay=300] - - The number of milliseconds to delay invoking the function.\n *\n * @returns - A debounced function\n */\nexport function debounce<T extends Fn>(fn: T, delay = 300): (...args: Parameters<T>) => void {\n  let timeoutId: ReturnType<typeof setTimeout>;\n\n  return (...args: Parameters<T>) => {\n    clearTimeout(timeoutId);\n    timeoutId = setTimeout(() => fn(...args), delay);\n  };\n}\n"],"names":["debounce","fn","delay","timeoutId","args"],"mappings":"gFAmBO,SAASA,EAAuBC,EAAOC,EAAQ,IAAuC,CAC3F,IAAIC,EAEJ,MAAO,IAAIC,IAAwB,CACjC,aAAaD,CAAS,EACtBA,EAAY,WAAW,IAAMF,EAAG,GAAGG,CAAI,EAAGF,CAAK,CACjD,CACF"}
+{"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"}

package/dist/function/debounce.js

@@ -1,10 +1,27 @@
-function i(t, o = 300) {
-  let e;
-  return (...u) => {
-    clearTimeout(e), e = setTimeout(() => t(...u), o);
+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;
 }
 export {
-  i as debounce
+  v 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';\n\n/**\n * Creates a debounced function that delays invoking the provided function until after\n * a specified wait time has elapsed since the last invocation.\n *\n * @example\n * ```ts\n * const debouncedLog = debounce(console.log, 1000);\n *\n * debouncedLog('Hello'); // Will log after 1 second if not called again\n * debouncedLog('World'); // Resets the timer, will log 'World' after 1 second\n * ```\n *\n * @param fn - The function to debounce.\n * @param [delay=300] - - The number of milliseconds to delay invoking the function.\n *\n * @returns - A debounced function\n */\nexport function debounce<T extends Fn>(fn: T, delay = 300): (...args: Parameters<T>) => void {\n  let timeoutId: ReturnType<typeof setTimeout>;\n\n  return (...args: Parameters<T>) => {\n    clearTimeout(timeoutId);\n    timeoutId = setTimeout(() => fn(...args), delay);\n  };\n}\n"],"names":["debounce","fn","delay","timeoutId","args"],"mappings":"AAmBO,SAASA,EAAuBC,GAAOC,IAAQ,KAAuC;AAC3F,MAAIC;AAEJ,SAAO,IAAIC,MAAwB;AACjC,iBAAaD,CAAS,GACtBA,IAAY,WAAW,MAAMF,EAAG,GAAGG,CAAI,GAAGF,CAAK;AAAA,EACjD;AACF;"}
+{"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;"}

package/dist/function/memo.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function f(l,{ttl:u,maxSize:i}={}){const t=new Map,s=n=>{if(n.length===0)return"__empty__";if(n.length===1){const e=n[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(...n)=>{const e=s(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=l(...n);return t.set(e,{timestamp:r,value:c}),i&&t.size>i&&t.delete(t.keys().next().value),c}}exports.memo=f;
+"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