@vielzeug/toolkit 1.1.3 → 2.1.0

package/dist/array/chunk.cjs

@@ -1,2 +1,2 @@
-"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
+const e=require(`../function/assert.cjs`),t=require(`../typed/isArray.cjs`),n=require(`../typed/isString.cjs`);function r(r,i=2,a={}){e.assert(t.isArray(r)||n.isString(r),`Argument must be an array or string.`,{args:{input:r},type:TypeError}),e.assert(i>=1,`Chunk size must be at least 1.`,{args:{size:i},type:RangeError});let{overlap:o=!1,pad:s=` `}=a;if(n.isString(r)&&o){let e=s+r+s,t=e.length-i+1;return Array.from({length:t},(t,n)=>e.slice(n,n+i))}return Array.from({length:Math.ceil(r.length/i)},(e,t)=>r.slice(t*i,t*i+i))}exports.chunk=r;
+//# 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\n// #region ChunkTypes\ntype ChunkOptions = {\n  overlap?: boolean;\n  pad?: string;\n};\n\ntype ChunkResult<T> = (T extends string ? string : T[])[];\n// #endregion ChunkTypes\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":"+LAkCO,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"}
+{"version":3,"file":"chunk.cjs","names":[],"sources":["../../src/array/chunk.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { isArray } from '../typed/isArray';\nimport { isString } from '../typed/isString';\n\n// #region ChunkTypes\ntype ChunkOptions = {\n  overlap?: boolean;\n  pad?: string;\n};\n\ntype ChunkResult<T> = (T extends string ? string : T[])[];\n// #endregion ChunkTypes\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\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"],"mappings":"+GAkCA,SAAgB,EAAS,EAAqB,EAAO,EAAG,EAAwB,EAAE,CAAkB,CAClG,EAAA,OAAO,EAAA,QAAQ,EAAa,EAAI,EAAA,SAAS,EAAM,CAAE,uCAAwC,CACvF,KAAM,CAAE,QAAO,CACf,KAAM,UACP,CAAC,CAEF,EAAA,OAAO,GAAQ,EAAG,iCAAkC,CAClD,KAAM,CAAE,OAAM,CACd,KAAM,WACP,CAAC,CAEF,GAAM,CAAE,UAAU,GAAO,MAAM,KAAQ,EAEvC,GAAI,EAAA,SAAS,EAAM,EAAI,EAAS,CAC9B,IAAM,EAAS,EAAM,EAAQ,EACvB,EAAY,EAAO,OAAS,EAAO,EAEzC,OAAO,MAAM,KAAK,CAAE,OAAQ,EAAW,EAAG,EAAG,IAAM,EAAO,MAAM,EAAG,EAAI,EAAK,CAAC,CAG/E,OAAO,MAAM,KAAK,CAAE,OAAQ,KAAK,KAAK,EAAM,OAAS,EAAK,CAAE,EAAG,EAAG,IAChE,EAAM,MAAM,EAAI,EAAM,EAAI,EAAO,EAAK,CACvC"}

package/dist/array/chunk.d.ts

@@ -0,0 +1,29 @@
+type ChunkOptions = {
+    overlap?: boolean;
+    pad?: string;
+};
+type ChunkResult<T> = (T extends string ? string : T[])[];
+/**
+ * Splits an array or string into chunks of a specified size.
+ *
+ * @example
+ * ```ts
+ * chunk([1, 2, 3, 4, 5], 2) // [[1, 2], [3, 4], [5]]
+ * chunk("hello", 2) // ["he", "ll", "o"]
+ * chunk("hello", 2, { overlap: true }) // [" h", "he", "el", "ll", "lo", "o "]
+ * ```
+ *
+ * @param input - The input array or string to be chunked.
+ * @param size - The size of each chunk.
+ * @param [options] - Additional options for chunking.
+ * @param [options.overlap] -
+ * @param [options.pad] -
+ *
+ * @returns An array of chunks.
+ *
+ * @throws {RangeError} If the chunk size is invalid.
+ * @throws {TypeError} If the input type is invalid.
+ */
+export declare function chunk<T>(input: T[] | string, size?: number, options?: ChunkOptions): ChunkResult<T>;
+export {};
+//# sourceMappingURL=chunk.d.ts.map

package/dist/array/chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../../src/array/chunk.ts"],"names":[],"mappings":"AAKA,KAAK,YAAY,GAAG;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,KAAK,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;AAG1D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,MAAM,EAAE,IAAI,SAAI,EAAE,OAAO,GAAE,YAAiB,GAAG,WAAW,CAAC,CAAC,CAAC,CAuBlG"}

package/dist/array/chunk.js

@@ -1,25 +1,23 @@
-import { assert as m } from "../function/assert.js";
-import { isArray as c } from "../typed/isArray.js";
-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: 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(t.length / r) },
-    (o, a) => t.slice(a * r, a * r + r)
-  );
+import { assert as e } from "../function/assert.js";
+import { isArray as t } from "../typed/isArray.js";
+import { isString as n } from "../typed/isString.js";
+//#region src/array/chunk.ts
+function r(r, i = 2, a = {}) {
+	e(t(r) || n(r), "Argument must be an array or string.", {
+		args: { input: r },
+		type: TypeError
+	}), e(i >= 1, "Chunk size must be at least 1.", {
+		args: { size: i },
+		type: RangeError
+	});
+	let { overlap: o = !1, pad: s = " " } = a;
+	if (n(r) && o) {
+		let e = s + r + s, t = e.length - i + 1;
+		return Array.from({ length: t }, (t, n) => e.slice(n, n + i));
+	}
+	return Array.from({ length: Math.ceil(r.length / i) }, (e, t) => r.slice(t * i, t * i + i));
 }
-export {
-  p as chunk
-};
-//# sourceMappingURL=chunk.js.map
+//#endregion
+export { r 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\n// #region ChunkTypes\ntype ChunkOptions = {\n  overlap?: boolean;\n  pad?: string;\n};\n\ntype ChunkResult<T> = (T extends string ? string : T[])[];\n// #endregion ChunkTypes\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":";;;AAkCO,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;"}
+{"version":3,"file":"chunk.js","names":[],"sources":["../../src/array/chunk.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { isArray } from '../typed/isArray';\nimport { isString } from '../typed/isString';\n\n// #region ChunkTypes\ntype ChunkOptions = {\n  overlap?: boolean;\n  pad?: string;\n};\n\ntype ChunkResult<T> = (T extends string ? string : T[])[];\n// #endregion ChunkTypes\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\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"],"mappings":";;;;AAkCA,SAAgB,EAAS,GAAqB,IAAO,GAAG,IAAwB,EAAE,EAAkB;AAMlG,CALA,EAAO,EAAQ,EAAa,IAAI,EAAS,EAAM,EAAE,wCAAwC;EACvF,MAAM,EAAE,UAAO;EACf,MAAM;EACP,CAAC,EAEF,EAAO,KAAQ,GAAG,kCAAkC;EAClD,MAAM,EAAE,SAAM;EACd,MAAM;EACP,CAAC;CAEF,IAAM,EAAE,aAAU,IAAO,SAAM,QAAQ;AAEvC,KAAI,EAAS,EAAM,IAAI,GAAS;EAC9B,IAAM,IAAS,IAAM,IAAQ,GACvB,IAAY,EAAO,SAAS,IAAO;AAEzC,SAAO,MAAM,KAAK,EAAE,QAAQ,GAAW,GAAG,GAAG,MAAM,EAAO,MAAM,GAAG,IAAI,EAAK,CAAC;;AAG/E,QAAO,MAAM,KAAK,EAAE,QAAQ,KAAK,KAAK,EAAM,SAAS,EAAK,EAAE,GAAG,GAAG,MAChE,EAAM,MAAM,IAAI,GAAM,IAAI,IAAO,EAAK,CACvC"}

package/dist/array/contains.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("../function/assert.cjs"),r=require("../typed/isArray.cjs"),o=require("../typed/isEqual.cjs");function s(e,t){return n.assert(r.isArray(e),r.IS_ARRAY_ERROR_MSG,{args:{array:e},type:TypeError}),e.some(i=>o.isEqual(i,t))}s.fp=!0;exports.contains=s;
-//# sourceMappingURL=contains.cjs.map
+const e=require(`../function/assert.cjs`),t=require(`../typed/isArray.cjs`),n=require(`../typed/isEqual.cjs`);function r(r,i){return e.assert(t.isArray(r),t.IS_ARRAY_ERROR_MSG,{args:{array:r},type:TypeError}),r.some(e=>n.isEqual(e,i))}exports.contains=r;
+//# sourceMappingURL=contains.cjs.map

package/dist/array/contains.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"contains.cjs","sources":["../../src/array/contains.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { isEqual } from '../typed/isEqual';\n\n/**\n * Checks if a value is present in an array.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, { a: 1 }, 'hello'];\n * const value = { a: 1 };\n * contains(arr, value) // true;\n * ```\n *\n * @param array - The array to check.\n * @param value - The value to search for.\n *\n * @returns true if the value is present in the array, else false.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\n\n// biome-ignore lint/suspicious/noExplicitAny: -\nexport function contains<T>(array: T[], value: any): boolean {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  return array.some((val) => isEqual(val, value));\n}\n\ncontains.fp = true;\n"],"names":["contains","array","value","assert","isArray","IS_ARRAY_ERROR_MSG","val","isEqual"],"mappings":"8LAuBO,SAASA,EAAYC,EAAYC,EAAqB,CAC3DC,OAAAA,EAAAA,OAAOC,EAAAA,QAAQH,CAAK,EAAGI,qBAAoB,CAAE,KAAM,CAAE,MAAAJ,CAAA,EAAS,KAAM,UAAW,EAExEA,EAAM,KAAMK,GAAQC,EAAAA,QAAQD,EAAKJ,CAAK,CAAC,CAChD,CAEAF,EAAS,GAAK"}
+{"version":3,"file":"contains.cjs","names":[],"sources":["../../src/array/contains.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { isEqual } from '../typed/isEqual';\n\n/**\n * Checks if a value is present in an array.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, { a: 1 }, 'hello'];\n * const value = { a: 1 };\n * contains(arr, value) // true;\n * ```\n *\n * @param array - The array to check.\n * @param value - The value to search for.\n *\n * @returns true if the value is present in the array, else false.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\n\nexport function contains<T>(array: T[], value: unknown): boolean {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  return array.some((val) => isEqual(val, value));\n}\n"],"mappings":"8GAsBA,SAAgB,EAAY,EAAY,EAAyB,CAG/D,OAFA,EAAA,OAAO,EAAA,QAAQ,EAAM,CAAE,EAAA,mBAAoB,CAAE,KAAM,CAAE,QAAO,CAAE,KAAM,UAAW,CAAC,CAEzE,EAAM,KAAM,GAAQ,EAAA,QAAQ,EAAK,EAAM,CAAC"}

package/dist/array/contains.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Checks if a value is present in an array.
+ *
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3, { a: 1 }, 'hello'];
+ * const value = { a: 1 };
+ * contains(arr, value) // true;
+ * ```
+ *
+ * @param array - The array to check.
+ * @param value - The value to search for.
+ *
+ * @returns true if the value is present in the array, else false.
+ *
+ * @throws {TypeError} If the first argument is not an array.
+ */
+export declare function contains<T>(array: T[], value: unknown): boolean;
+//# sourceMappingURL=contains.d.ts.map

package/dist/array/contains.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contains.d.ts","sourceRoot":"","sources":["../../src/array/contains.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAI/D"}

package/dist/array/contains.js

@@ -1,11 +1,14 @@
 import { assert as e } from "../function/assert.js";
-import { IS_ARRAY_ERROR_MSG as i, isArray as m } from "../typed/isArray.js";
-import { isEqual as p } from "../typed/isEqual.js";
-function s(r, o) {
-  return e(m(r), i, { args: { array: r }, type: TypeError }), r.some((t) => p(t, o));
+import { IS_ARRAY_ERROR_MSG as t, isArray as n } from "../typed/isArray.js";
+import { isEqual as r } from "../typed/isEqual.js";
+//#region src/array/contains.ts
+function i(i, a) {
+	return e(n(i), t, {
+		args: { array: i },
+		type: TypeError
+	}), i.some((e) => r(e, a));
 }
-s.fp = !0;
-export {
-  s as contains
-};
-//# sourceMappingURL=contains.js.map
+//#endregion
+export { i as contains };
+
+//# sourceMappingURL=contains.js.map

package/dist/array/contains.js.map

@@ -1 +1 @@
-{"version":3,"file":"contains.js","sources":["../../src/array/contains.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { isEqual } from '../typed/isEqual';\n\n/**\n * Checks if a value is present in an array.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, { a: 1 }, 'hello'];\n * const value = { a: 1 };\n * contains(arr, value) // true;\n * ```\n *\n * @param array - The array to check.\n * @param value - The value to search for.\n *\n * @returns true if the value is present in the array, else false.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\n\n// biome-ignore lint/suspicious/noExplicitAny: -\nexport function contains<T>(array: T[], value: any): boolean {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  return array.some((val) => isEqual(val, value));\n}\n\ncontains.fp = true;\n"],"names":["contains","array","value","assert","isArray","IS_ARRAY_ERROR_MSG","val","isEqual"],"mappings":";;;AAuBO,SAASA,EAAYC,GAAYC,GAAqB;AAC3D,SAAAC,EAAOC,EAAQH,CAAK,GAAGI,GAAoB,EAAE,MAAM,EAAE,OAAAJ,EAAA,GAAS,MAAM,WAAW,GAExEA,EAAM,KAAK,CAACK,MAAQC,EAAQD,GAAKJ,CAAK,CAAC;AAChD;AAEAF,EAAS,KAAK;"}
+{"version":3,"file":"contains.js","names":[],"sources":["../../src/array/contains.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { isEqual } from '../typed/isEqual';\n\n/**\n * Checks if a value is present in an array.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, { a: 1 }, 'hello'];\n * const value = { a: 1 };\n * contains(arr, value) // true;\n * ```\n *\n * @param array - The array to check.\n * @param value - The value to search for.\n *\n * @returns true if the value is present in the array, else false.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\n\nexport function contains<T>(array: T[], value: unknown): boolean {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  return array.some((val) => isEqual(val, value));\n}\n"],"mappings":";;;;AAsBA,SAAgB,EAAY,GAAY,GAAyB;AAG/D,QAFA,EAAO,EAAQ,EAAM,EAAE,GAAoB;EAAE,MAAM,EAAE,UAAO;EAAE,MAAM;EAAW,CAAC,EAEzE,EAAM,MAAM,MAAQ,EAAQ,GAAK,EAAM,CAAC"}

package/dist/array/fold.cjs

@@ -0,0 +1,2 @@
+const e=require(`../function/assert.cjs`),t=require(`../typed/isArray.cjs`);function n(n,r){e.assert(t.isArray(n),t.IS_ARRAY_ERROR_MSG,{args:{array:n,callback:r},type:TypeError});let i=n[0];for(let e=1;e<n.length;e++)i=r(i,n[e]);return i}exports.fold=n;
+//# sourceMappingURL=fold.cjs.map

package/dist/array/fold.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fold.cjs","names":[],"sources":["../../src/array/fold.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Folds an array down to a single value by applying a callback to each pair of\n * elements (reduce without an initial value).\n *\n * @example\n * ```ts\n * fold([1, 2, 3], (a, b) => a + b) // 6\n * fold([1, 2, 3], (a, b) => a > b ? a : b) // 3\n * fold([{ a: 1 }, { a: 2 }], (a, b) => ({ a: a.a + b.a })) // { a: 3 }\n * fold([], (a, b) => a + b) // undefined\n * fold([1], (a, b) => a + b) // 1\n * ```\n *\n * @param array - The array to fold.\n * @param callback - The function to invoke for each pair of elements.\n * @returns The folded value, or `undefined` if the array is empty.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\nexport function fold<T>(array: readonly T[], callback: (a: T, b: T) => T): T | undefined {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, {\n    args: { array, callback },\n    type: TypeError,\n  });\n\n  let result = array[0];\n\n  for (let i = 1; i < array.length; i++) {\n    result = callback(result, array[i]);\n  }\n\n  return result;\n}\n"],"mappings":"4EAsBA,SAAgB,EAAQ,EAAqB,EAA4C,CACvF,EAAA,OAAO,EAAA,QAAQ,EAAM,CAAE,EAAA,mBAAoB,CACzC,KAAM,CAAE,QAAO,WAAU,CACzB,KAAM,UACP,CAAC,CAEF,IAAI,EAAS,EAAM,GAEnB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,OAAQ,IAChC,EAAS,EAAS,EAAQ,EAAM,GAAG,CAGrC,OAAO"}

package/dist/array/fold.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Folds an array down to a single value by applying a callback to each pair of
+ * elements (reduce without an initial value).
+ *
+ * @example
+ * ```ts
+ * fold([1, 2, 3], (a, b) => a + b) // 6
+ * fold([1, 2, 3], (a, b) => a > b ? a : b) // 3
+ * fold([{ a: 1 }, { a: 2 }], (a, b) => ({ a: a.a + b.a })) // { a: 3 }
+ * fold([], (a, b) => a + b) // undefined
+ * fold([1], (a, b) => a + b) // 1
+ * ```
+ *
+ * @param array - The array to fold.
+ * @param callback - The function to invoke for each pair of elements.
+ * @returns The folded value, or `undefined` if the array is empty.
+ *
+ * @throws {TypeError} If the first argument is not an array.
+ */
+export declare function fold<T>(array: readonly T[], callback: (a: T, b: T) => T): T | undefined;
+//# sourceMappingURL=fold.d.ts.map

package/dist/array/fold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fold.d.ts","sourceRoot":"","sources":["../../src/array/fold.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,SAAS,CAavF"}

package/dist/array/fold.js

@@ -0,0 +1,19 @@
+import { assert as e } from "../function/assert.js";
+import { IS_ARRAY_ERROR_MSG as t, isArray as n } from "../typed/isArray.js";
+//#region src/array/fold.ts
+function r(r, i) {
+	e(n(r), t, {
+		args: {
+			array: r,
+			callback: i
+		},
+		type: TypeError
+	});
+	let a = r[0];
+	for (let e = 1; e < r.length; e++) a = i(a, r[e]);
+	return a;
+}
+//#endregion
+export { r as fold };
+
+//# sourceMappingURL=fold.js.map

package/dist/array/fold.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fold.js","names":[],"sources":["../../src/array/fold.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Folds an array down to a single value by applying a callback to each pair of\n * elements (reduce without an initial value).\n *\n * @example\n * ```ts\n * fold([1, 2, 3], (a, b) => a + b) // 6\n * fold([1, 2, 3], (a, b) => a > b ? a : b) // 3\n * fold([{ a: 1 }, { a: 2 }], (a, b) => ({ a: a.a + b.a })) // { a: 3 }\n * fold([], (a, b) => a + b) // undefined\n * fold([1], (a, b) => a + b) // 1\n * ```\n *\n * @param array - The array to fold.\n * @param callback - The function to invoke for each pair of elements.\n * @returns The folded value, or `undefined` if the array is empty.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\nexport function fold<T>(array: readonly T[], callback: (a: T, b: T) => T): T | undefined {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, {\n    args: { array, callback },\n    type: TypeError,\n  });\n\n  let result = array[0];\n\n  for (let i = 1; i < array.length; i++) {\n    result = callback(result, array[i]);\n  }\n\n  return result;\n}\n"],"mappings":";;;AAsBA,SAAgB,EAAQ,GAAqB,GAA4C;AACvF,GAAO,EAAQ,EAAM,EAAE,GAAoB;EACzC,MAAM;GAAE;GAAO;GAAU;EACzB,MAAM;EACP,CAAC;CAEF,IAAI,IAAS,EAAM;AAEnB,MAAK,IAAI,IAAI,GAAG,IAAI,EAAM,QAAQ,IAChC,KAAS,EAAS,GAAQ,EAAM,GAAG;AAGrC,QAAO"}

package/dist/array/group.cjs

@@ -1,2 +1,2 @@
-"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
+const e=require(`../function/assert.cjs`),t=require(`../typed/isArray.cjs`);function n(n,r){e.assert(t.isArray(n),t.IS_ARRAY_ERROR_MSG,{args:{array:n},type:TypeError});let i={},a=typeof r==`function`?r:e=>e[r];for(let e of n){let t=a(e),n=t==null?`_`:String(t);i[n]||(i[n]=[]),i[n].push(e)}return i}exports.group=n;
+//# 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 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"}
+{"version":3,"file":"group.cjs","names":[],"sources":["../../src/array/group.ts"],"sourcesContent":["import type { Selector } from '../types';\n\nimport { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\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') // { '2': [{ a: 2 }], '1': [{ 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>(array: T[], selector: Selector<T>): Record<string, T[]> {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const result: Record<string, 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);\n\n    if (!result[key]) {\n      result[key] = [];\n    }\n\n    result[key].push(item);\n  }\n\n  return result;\n}\n"],"mappings":"4EAqBA,SAAgB,EAAS,EAAY,EAA4C,CAC/E,EAAA,OAAO,EAAA,QAAQ,EAAM,CAAE,EAAA,mBAAoB,CAAE,KAAM,CAAE,QAAO,CAAE,KAAM,UAAW,CAAC,CAEhF,IAAM,EAA8B,EAAE,CAChC,EAAS,OAAO,GAAa,WAAa,EAAY,GAAY,EAAK,GAE7E,IAAK,IAAM,KAAQ,EAAO,CACxB,IAAM,EAAS,EAAO,EAAK,CACrB,EAAM,GAAmC,KAAO,IAAM,OAAO,EAAO,CAErE,EAAO,KACV,EAAO,GAAO,EAAE,EAGlB,EAAO,GAAK,KAAK,EAAK,CAGxB,OAAO"}

package/dist/array/group.d.ts

@@ -0,0 +1,19 @@
+import type { Selector } from '../types';
+/**
+ * Groups the elements of an array based on the given key.
+ *
+ * @example
+ * ```ts
+ * const data = [{ a: 2 }, { a: 1 }];
+ * group(data, 'a') // { '2': [{ a: 2 }], '1': [{ a: 1 }] };
+ * ```
+ *
+ * @param array - The array to group.
+ * @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.
+ *
+ * @returns an object with keys as the grouped values and values as arrays of elements.
+ *
+ * @throws {TypeError} If the provided array is not an array.
+ */
+export declare function group<T>(array: T[], selector: Selector<T>): Record<string, T[]>;
+//# sourceMappingURL=group.d.ts.map

package/dist/array/group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.d.ts","sourceRoot":"","sources":["../../src/array/group.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAKzC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAkB/E"}

package/dist/array/group.js

@@ -1,16 +1,19 @@
-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 e = i(o), f = e == null ? "_" : String(e);
-    t[f] || (t[f] = []), t[f].push(o);
-  }
-  return t;
+import { assert as e } from "../function/assert.js";
+import { IS_ARRAY_ERROR_MSG as t, isArray as n } from "../typed/isArray.js";
+//#region src/array/group.ts
+function r(r, i) {
+	e(n(r), t, {
+		args: { array: r },
+		type: TypeError
+	});
+	let a = {}, o = typeof i == "function" ? i : (e) => e[i];
+	for (let e of r) {
+		let t = o(e), n = t == null ? "_" : String(t);
+		a[n] || (a[n] = []), a[n].push(e);
+	}
+	return a;
 }
-c.fp = !0;
-export {
-  c as group
-};
-//# sourceMappingURL=group.js.map
+//#endregion
+export { r 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 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;"}
+{"version":3,"file":"group.js","names":[],"sources":["../../src/array/group.ts"],"sourcesContent":["import type { Selector } from '../types';\n\nimport { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\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') // { '2': [{ a: 2 }], '1': [{ 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>(array: T[], selector: Selector<T>): Record<string, T[]> {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const result: Record<string, 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);\n\n    if (!result[key]) {\n      result[key] = [];\n    }\n\n    result[key].push(item);\n  }\n\n  return result;\n}\n"],"mappings":";;;AAqBA,SAAgB,EAAS,GAAY,GAA4C;AAC/E,GAAO,EAAQ,EAAM,EAAE,GAAoB;EAAE,MAAM,EAAE,UAAO;EAAE,MAAM;EAAW,CAAC;CAEhF,IAAM,IAA8B,EAAE,EAChC,IAAS,OAAO,KAAa,aAAa,KAAY,MAAY,EAAK;AAE7E,MAAK,IAAM,KAAQ,GAAO;EACxB,IAAM,IAAS,EAAO,EAAK,EACrB,IAAM,KAAmC,OAAO,MAAM,OAAO,EAAO;AAM1E,EAJK,EAAO,OACV,EAAO,KAAO,EAAE,GAGlB,EAAO,GAAK,KAAK,EAAK;;AAGxB,QAAO"}

package/dist/array/index.d.ts

@@ -0,0 +1,16 @@
+export * from './chunk';
+export * from './contains';
+export * from './fold';
+export * from './group';
+export * from './keyBy';
+export * from './list';
+export * from './pick';
+export * from './remoteList';
+export * from './replace';
+export * from './rotate';
+export * from './search';
+export * from './select';
+export * from './sort';
+export * from './toggle';
+export * from './uniq';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/array/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC"}

package/dist/array/keyBy.cjs

@@ -0,0 +1,2 @@
+const e=require(`../function/assert.cjs`),t=require(`../typed/isArray.cjs`);function n(n,r){e.assert(t.isArray(n),t.IS_ARRAY_ERROR_MSG,{args:{array:n},type:TypeError});let i={},a=typeof r==`function`?r:e=>e[r];for(let e of n){let t=String(a(e));i[t]=e}return i}exports.keyBy=n;
+//# sourceMappingURL=keyBy.cjs.map

package/dist/array/keyBy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyBy.cjs","names":[],"sources":["../../src/array/keyBy.ts"],"sourcesContent":["import type { Selector } from '../types';\n\nimport { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Creates an object keyed by a property or selector function. When multiple\n * items share the same key, the last one wins.\n *\n * @example\n * ```ts\n * const data = [{ a: 'x', v: 1 }, { a: 'y', v: 2 }, { a: 'x', v: 3 }];\n * keyBy(data, 'a') // { x: { a: 'x', v: 3 }, y: { a: 'y', v: 2 } }\n * keyBy(data, item => item.a) // same result\n * ```\n *\n * @param array - The array to index.\n * @param selector - A property key or a function returning the key for each element.\n * @returns A record mapping each key to the corresponding element.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function keyBy<T>(array: T[], selector: Selector<T>): Record<string, T> {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const result: Record<string, T> = {};\n  const getKey = typeof selector === 'function' ? selector : (item: T) => item[selector];\n\n  for (const item of array) {\n    const key = String(getKey(item));\n\n    result[key] = item;\n  }\n\n  return result;\n}\n"],"mappings":"4EAsBA,SAAgB,EAAS,EAAY,EAA0C,CAC7E,EAAA,OAAO,EAAA,QAAQ,EAAM,CAAE,EAAA,mBAAoB,CAAE,KAAM,CAAE,QAAO,CAAE,KAAM,UAAW,CAAC,CAEhF,IAAM,EAA4B,EAAE,CAC9B,EAAS,OAAO,GAAa,WAAa,EAAY,GAAY,EAAK,GAE7E,IAAK,IAAM,KAAQ,EAAO,CACxB,IAAM,EAAM,OAAO,EAAO,EAAK,CAAC,CAEhC,EAAO,GAAO,EAGhB,OAAO"}

package/dist/array/keyBy.d.ts

@@ -0,0 +1,20 @@
+import type { Selector } from '../types';
+/**
+ * Creates an object keyed by a property or selector function. When multiple
+ * items share the same key, the last one wins.
+ *
+ * @example
+ * ```ts
+ * const data = [{ a: 'x', v: 1 }, { a: 'y', v: 2 }, { a: 'x', v: 3 }];
+ * keyBy(data, 'a') // { x: { a: 'x', v: 3 }, y: { a: 'y', v: 2 } }
+ * keyBy(data, item => item.a) // same result
+ * ```
+ *
+ * @param array - The array to index.
+ * @param selector - A property key or a function returning the key for each element.
+ * @returns A record mapping each key to the corresponding element.
+ *
+ * @throws {TypeError} If the provided array is not an array.
+ */
+export declare function keyBy<T>(array: T[], selector: Selector<T>): Record<string, T>;
+//# sourceMappingURL=keyBy.d.ts.map

package/dist/array/keyBy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyBy.d.ts","sourceRoot":"","sources":["../../src/array/keyBy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAKzC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAa7E"}

package/dist/array/keyBy.js

@@ -0,0 +1,19 @@
+import { assert as e } from "../function/assert.js";
+import { IS_ARRAY_ERROR_MSG as t, isArray as n } from "../typed/isArray.js";
+//#region src/array/keyBy.ts
+function r(r, i) {
+	e(n(r), t, {
+		args: { array: r },
+		type: TypeError
+	});
+	let a = {}, o = typeof i == "function" ? i : (e) => e[i];
+	for (let e of r) {
+		let t = String(o(e));
+		a[t] = e;
+	}
+	return a;
+}
+//#endregion
+export { r as keyBy };
+
+//# sourceMappingURL=keyBy.js.map

package/dist/array/keyBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyBy.js","names":[],"sources":["../../src/array/keyBy.ts"],"sourcesContent":["import type { Selector } from '../types';\n\nimport { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Creates an object keyed by a property or selector function. When multiple\n * items share the same key, the last one wins.\n *\n * @example\n * ```ts\n * const data = [{ a: 'x', v: 1 }, { a: 'y', v: 2 }, { a: 'x', v: 3 }];\n * keyBy(data, 'a') // { x: { a: 'x', v: 3 }, y: { a: 'y', v: 2 } }\n * keyBy(data, item => item.a) // same result\n * ```\n *\n * @param array - The array to index.\n * @param selector - A property key or a function returning the key for each element.\n * @returns A record mapping each key to the corresponding element.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function keyBy<T>(array: T[], selector: Selector<T>): Record<string, T> {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const result: Record<string, T> = {};\n  const getKey = typeof selector === 'function' ? selector : (item: T) => item[selector];\n\n  for (const item of array) {\n    const key = String(getKey(item));\n\n    result[key] = item;\n  }\n\n  return result;\n}\n"],"mappings":";;;AAsBA,SAAgB,EAAS,GAAY,GAA0C;AAC7E,GAAO,EAAQ,EAAM,EAAE,GAAoB;EAAE,MAAM,EAAE,UAAO;EAAE,MAAM;EAAW,CAAC;CAEhF,IAAM,IAA4B,EAAE,EAC9B,IAAS,OAAO,KAAa,aAAa,KAAY,MAAY,EAAK;AAE7E,MAAK,IAAM,KAAQ,GAAO;EACxB,IAAM,IAAM,OAAO,EAAO,EAAK,CAAC;AAEhC,IAAO,KAAO;;AAGhB,QAAO"}

package/dist/array/list.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const Q=require("./search.cjs");function j(S,i={}){const T=new Set,M={debounceMs:300,limit:10,searchTone:.5};let x=[...S],n=Math.max(1,i.limit??M.limit),m=i.filterFn??(()=>!0),u=i.sortFn;const y=i.searchFn??((t,e,o)=>Q.search([...t],e,o)),v=i.searchTone??M.searchTone;let c="",s=0,h=[];const d=()=>{for(const t of T)t()},g=()=>{let t=x;c&&(t=y(t,c,v)),m&&(t=t.filter(m)),t=u?[...t].sort(u):[...t];const e=Math.max(1,Math.ceil(t.length/n));s=Math.min(s,e-1),h=t},D=()=>{if(!h.length)return[];const t=s*n;return h.slice(t,t+n)},r=()=>{g(),d()};let F;const L=(t,e)=>{F&&clearTimeout(F),F=setTimeout(()=>{c=t,F=void 0,r()},e)};return g(),{batch(t){let e=n,o=m,l=u,f=c,b=x,p=s;const w=(a,E,O)=>Math.max(0,Math.min(a,Math.max(0,Math.ceil(E/O)-1)));t({goTo:a=>{p=w(a-1,h.length,e)},setData:a=>{b=[...a],p=0},setFilter:a=>{o=a},setLimit:a=>{e=Math.max(1,a)},setQuery:a=>{f=a,p=0},setSort:a=>{l=a}}),n=e,m=o,u=l,c=f,x=b,s=p,r()},get current(){return D()},goTo(t){const e=Math.max(1,Math.ceil(h.length/n));s=Math.max(0,Math.min(t-1,e-1)),d()},get meta(){const t=h.length,e=Math.max(1,Math.ceil(t/n)),o=t===0,l=Math.min(s+1,e),f=o?0:(l-1)*n+1;return{end:o?0:Math.min(l*n,t),isEmpty:o,isFirst:l<=1,isLast:l>=e,limit:n,page:l,pages:e,start:f,total:t}},next(){const t=Math.max(1,Math.ceil(h.length/n));s<t-1&&(s++,d())},prev(){s>0&&(s--,d())},reset(){n=Math.max(1,i.limit??M.limit),m=i.filterFn??(()=>!0),u=i.sortFn,c="",s=0,r()},search(t,e){c=t,s=0,e?.immediate?r():L(t,i.debounceMs??M.debounceMs)},setData(t){x=[...t],s=0,r()},setFilter(t){m=t,s=0,r()},setLimit(t){n=Math.max(1,t),s=0,r()},setSort(t){u=t,r()},subscribe(t){return T.add(t),()=>T.delete(t)}}}exports.list=j;
-//# sourceMappingURL=list.cjs.map
+const e=require(`./search.cjs`);function t(t,n={}){let r=new Set,i={debounceMs:300,limit:10,searchTone:.5},a=[...t],o=Math.max(1,n.limit??i.limit),s=n.filterFn??(()=>!0),c=n.sortFn,l=n.searchFn??((t,n,r)=>e.search([...t],n,r)),u=n.searchTone??i.searchTone,d=``,f=0,p=[],m=()=>{for(let e of r)e()},h=()=>{let e=a;d&&(e=l(e,d,u)),s&&(e=e.filter(s)),e=c?[...e].sort(c):[...e];let t=Math.max(1,Math.ceil(e.length/o));f=Math.min(f,t-1),p=e},g=()=>{if(!p.length)return[];let e=f*o;return p.slice(e,e+o)},_=()=>{h(),m()},v,y=(e,t)=>{v&&clearTimeout(v),v=setTimeout(()=>{d=e,v=void 0,_()},t)};return h(),{batch(e){let t=o,n=s,r=c,i=d,l=a,u=f,m=(e,t,n)=>Math.max(0,Math.min(e,Math.max(0,Math.ceil(t/n)-1)));e({goTo:e=>{u=m(e-1,p.length,t)},setData:e=>{l=[...e],u=0},setFilter:e=>{n=e},setLimit:e=>{t=Math.max(1,e)},setQuery:e=>{i=e,u=0},setSort:e=>{r=e}}),o=t,s=n,c=r,d=i,a=l,f=u,_()},get current(){return g()},goTo(e){let t=Math.max(1,Math.ceil(p.length/o));f=Math.max(0,Math.min(e-1,t-1)),m()},get meta(){let e=p.length,t=Math.max(1,Math.ceil(e/o)),n=e===0,r=Math.min(f+1,t),i=n?0:(r-1)*o+1;return{end:n?0:Math.min(r*o,e),isEmpty:n,isFirst:r<=1,isLast:r>=t,limit:o,page:r,pages:t,start:i,total:e}},next(){let e=Math.max(1,Math.ceil(p.length/o));f<e-1&&(f++,m())},prev(){f>0&&(f--,m())},reset(){o=Math.max(1,n.limit??i.limit),s=n.filterFn??(()=>!0),c=n.sortFn,d=``,f=0,_()},search(e,t){t?.immediate?(d=e,f=0,_()):y(e,n.debounceMs??i.debounceMs)},setData(e){a=[...e],f=0,_()},setFilter(e){s=e,f=0,_()},setLimit(e){o=Math.max(1,e),f=0,_()},setSort(e){c=e,_()},subscribe(e){return r.add(e),()=>r.delete(e)}}}exports.list=t;
+//# sourceMappingURL=list.cjs.map

package/dist/array/list.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"list.cjs","sources":["../../src/array/list.ts"],"sourcesContent":["import type { Predicate, Sorter } from '../types';\nimport { search as defaultSearch } from './search';\n\n// #region Meta\nexport type Meta = Readonly<{\n  end: number; // inclusive\n  isEmpty: boolean;\n  isFirst: boolean;\n  isLast: boolean;\n  limit: number;\n  page: number; // 1-based\n  pages: number;\n  start: number; // 1-based\n  total: number;\n}>;\n// #endregion Meta\n\n// #region List\nexport type List<T, F, S> = {\n  readonly current: readonly T[];\n  readonly meta: Meta;\n  subscribe(listener: () => void): () => void;\n\n  goTo(page: number): void;\n  next(): void;\n  prev(): void;\n  reset(): void;\n  search(query: string, opts?: { immediate?: boolean }): void;\n  setData?(data: readonly T[]): void; // implemented by local\n  setFilter(filter: F): void;\n  setLimit(n: number): void;\n  setSort(sort?: S): void;\n\n  // Batch updates across properties in one recompute/refetch\n  batch(\n    mutator: (ctx: {\n      setLimit(n: number): void;\n      setFilter(f: F): void;\n      setSort(s?: S): void;\n      setQuery(q: string): void;\n      setData?(d: readonly T[]): void; // local-only\n      goTo(p: number): void; // 1-based\n    }) => void,\n  ): void;\n};\n// #endregion List\n\n// #region LocalConfig\ntype LocalConfig<T> = Readonly<{\n  debounceMs?: number;\n  filterFn?: Predicate<T>;\n  limit?: number;\n  searchFn?: (items: readonly T[], query: string, tone: number) => readonly T[];\n  searchTone?: number;\n  sortFn?: Sorter<T>;\n}>;\n// #endregion LocalConfig\n\nexport function list<T>(initialData: readonly T[], cfg: LocalConfig<T> = {}): List<T, Predicate<T>, Sorter<T>> {\n  const listeners = new Set<() => void>();\n\n  const DEFAULTS = { debounceMs: 300, limit: 10, searchTone: 0.5 } as const;\n\n  let rawData: readonly T[] = [...initialData];\n  let limit = Math.max(1, cfg.limit ?? DEFAULTS.limit);\n  let filterFn: Predicate<T> = cfg.filterFn ?? (() => true);\n  let sortFn: Sorter<T> | undefined = cfg.sortFn;\n  const searchFn = cfg.searchFn ?? ((items: readonly T[], q: string, t: number) => defaultSearch([...items], q, t));\n  const searchTone = cfg.searchTone ?? DEFAULTS.searchTone;\n\n  let query = '';\n  let offset = 0;\n  let view: readonly T[] = [];\n\n  const notify = () => {\n    for (const l of listeners) {\n      l();\n    }\n  };\n\n  const recompute = () => {\n    let arr = rawData;\n\n    if (query) arr = searchFn(arr, query, searchTone);\n    if (filterFn) arr = arr.filter(filterFn);\n    arr = sortFn ? [...arr].sort(sortFn) : [...arr];\n\n    const pages = Math.max(1, Math.ceil(arr.length / limit));\n    offset = Math.min(offset, pages - 1);\n    view = arr;\n  };\n\n  const slice = (): readonly T[] => {\n    if (!view.length) return [];\n    const start = offset * limit;\n    return view.slice(start, start + limit);\n  };\n\n  const update = () => {\n    recompute();\n    notify();\n  };\n\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  const debouncedSearch = (q: string, ms: number) => {\n    if (timer) clearTimeout(timer);\n    timer = setTimeout(() => {\n      query = q;\n      timer = undefined;\n      void update();\n    }, ms);\n  };\n\n  // initial compute\n  recompute();\n\n  return {\n    batch(mutator) {\n      let nextLimit = limit;\n      let nextFilter = filterFn;\n      let nextSort = sortFn;\n      let nextQuery = query;\n      let nextData = rawData;\n      let nextOffset = offset;\n\n      const clamp = (i: number, total: number, lim: number) =>\n        Math.max(0, Math.min(i, Math.max(0, Math.ceil(total / lim) - 1)));\n\n      mutator({\n        goTo: (p) => {\n          nextOffset = clamp(p - 1, view.length, nextLimit);\n        },\n        setData: (d) => {\n          nextData = [...d];\n          nextOffset = 0;\n        },\n        setFilter: (f) => {\n          nextFilter = f;\n        },\n        setLimit: (n) => {\n          nextLimit = Math.max(1, n);\n        },\n        setQuery: (q) => {\n          nextQuery = q;\n          nextOffset = 0;\n        },\n        setSort: (s) => {\n          nextSort = s;\n        },\n      });\n\n      // apply once\n      limit = nextLimit;\n      filterFn = nextFilter;\n      sortFn = nextSort;\n      query = nextQuery;\n      rawData = nextData;\n      offset = nextOffset;\n\n      update();\n    },\n    get current() {\n      return slice();\n    },\n    goTo(page) {\n      const pages = Math.max(1, Math.ceil(view.length / limit));\n      offset = Math.max(0, Math.min(page - 1, pages - 1));\n      notify();\n    },\n    get meta() {\n      const total = view.length;\n      const pages = Math.max(1, Math.ceil(total / limit));\n      const isEmpty = total === 0;\n      const page = Math.min(offset + 1, pages);\n      const start = isEmpty ? 0 : (page - 1) * limit + 1;\n      const end = isEmpty ? 0 : Math.min(page * limit, total);\n      return {\n        end,\n        isEmpty,\n        isFirst: page <= 1,\n        isLast: page >= pages,\n        limit,\n        page,\n        pages,\n        start,\n        total,\n      };\n    },\n    next() {\n      const pages = Math.max(1, Math.ceil(view.length / limit));\n      if (offset < pages - 1) {\n        offset++;\n        notify();\n      }\n    },\n    prev() {\n      if (offset > 0) {\n        offset--;\n        notify();\n      }\n    },\n    reset() {\n      limit = Math.max(1, cfg.limit ?? DEFAULTS.limit);\n      filterFn = cfg.filterFn ?? (() => true);\n      sortFn = cfg.sortFn;\n      query = '';\n      offset = 0;\n      update();\n    },\n    search(q, opts) {\n      query = q;\n      offset = 0;\n      if (opts?.immediate) {\n        update();\n      } else {\n        debouncedSearch(q, cfg.debounceMs ?? DEFAULTS.debounceMs);\n      }\n    },\n    setData(data) {\n      rawData = [...data];\n      offset = 0;\n      update();\n    },\n    setFilter(f) {\n      filterFn = f;\n      offset = 0;\n      update();\n    },\n    setLimit(n) {\n      limit = Math.max(1, n);\n      offset = 0;\n      update();\n    },\n    setSort(s) {\n      sortFn = s;\n      update();\n    },\n    subscribe(listener) {\n      listeners.add(listener);\n      return () => listeners.delete(listener);\n    },\n  };\n}\n"],"names":["list","initialData","cfg","listeners","DEFAULTS","rawData","limit","filterFn","sortFn","searchFn","items","q","t","defaultSearch","searchTone","query","offset","view","notify","l","recompute","arr","pages","slice","start","update","timer","debouncedSearch","ms","mutator","nextLimit","nextFilter","nextSort","nextQuery","nextData","nextOffset","clamp","i","total","lim","p","d","f","n","s","page","isEmpty","opts","data","listener"],"mappings":"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"}
+{"version":3,"file":"list.cjs","names":[],"sources":["../../src/array/list.ts"],"sourcesContent":["import type { Predicate, Sorter } from '../types';\n\nimport { search as defaultSearch } from './search';\n\n// #region BaseMeta\n/** Minimal pagination metadata shared by both `list` and `remoteList`. */\nexport type BaseMeta = Readonly<{\n  end: number;\n  isEmpty: boolean;\n  isFirst: boolean;\n  isLast: boolean;\n  limit: number;\n  page: number;\n  pages: number;\n  start: number;\n  total: number;\n}>;\n// #endregion BaseMeta\n\n// #region BaseList\n/**\n * Minimal shared interface satisfied by both `list()` and `remoteList()` results.\n * Use this type for code that works with either.\n */\nexport type BaseList<T> = {\n  readonly current: readonly T[];\n  readonly meta: BaseMeta;\n  subscribe(listener: () => void): () => void;\n};\n// #endregion BaseList\n\n// #region Meta\nexport type Meta = BaseMeta;\n// #endregion Meta\n\n// #region List\nexport type List<T, F, S> = {\n  // Batch updates across properties in one recompute/refetch\n  batch(\n    mutator: (ctx: {\n      goTo(p: number): void; // 1-based\n      setData?(d: readonly T[]): void; // local-only\n      setFilter(f: F): void;\n      setLimit(n: number): void;\n      setQuery(q: string): void;\n      setSort(s?: S): void;\n    }) => void,\n  ): void;\n  readonly current: readonly T[];\n  goTo(page: number): void;\n\n  readonly meta: Meta;\n  next(): void;\n  prev(): void;\n  reset(): void;\n  search(query: string, opts?: { immediate?: boolean }): void;\n  setData?(data: readonly T[]): void; // implemented by local\n  setFilter(filter: F): void;\n  setLimit(n: number): void;\n  setSort(sort?: S): void;\n\n  subscribe(listener: () => void): () => void;\n};\n// #endregion List\n\n// #region LocalConfig\ntype LocalConfig<T> = Readonly<{\n  debounceMs?: number;\n  filterFn?: Predicate<T>;\n  limit?: number;\n  searchFn?: (items: readonly T[], query: string, tone: number) => readonly T[];\n  searchTone?: number;\n  sortFn?: Sorter<T>;\n}>;\n// #endregion LocalConfig\n\nexport function list<T>(initialData: readonly T[], cfg: LocalConfig<T> = {}): List<T, Predicate<T>, Sorter<T>> {\n  const listeners = new Set<() => void>();\n\n  const DEFAULTS = { debounceMs: 300, limit: 10, searchTone: 0.5 } as const;\n\n  let rawData: readonly T[] = [...initialData];\n  let limit = Math.max(1, cfg.limit ?? DEFAULTS.limit);\n  let filterFn: Predicate<T> = cfg.filterFn ?? (() => true);\n  let sortFn: Sorter<T> | undefined = cfg.sortFn;\n  const searchFn = cfg.searchFn ?? ((items: readonly T[], q: string, t: number) => defaultSearch([...items], q, t));\n  const searchTone = cfg.searchTone ?? DEFAULTS.searchTone;\n\n  let query = '';\n  let offset = 0;\n  let view: readonly T[] = [];\n\n  const notify = () => {\n    for (const l of listeners) {\n      l();\n    }\n  };\n\n  const recompute = () => {\n    let arr = rawData;\n\n    if (query) arr = searchFn(arr, query, searchTone);\n\n    if (filterFn) arr = arr.filter(filterFn);\n\n    arr = sortFn ? [...arr].sort(sortFn) : [...arr];\n\n    const pages = Math.max(1, Math.ceil(arr.length / limit));\n\n    offset = Math.min(offset, pages - 1);\n    view = arr;\n  };\n\n  const slice = (): readonly T[] => {\n    if (!view.length) return [];\n\n    const start = offset * limit;\n\n    return view.slice(start, start + limit);\n  };\n\n  const update = () => {\n    recompute();\n    notify();\n  };\n\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  const debouncedSearch = (q: string, ms: number) => {\n    if (timer) clearTimeout(timer);\n\n    timer = setTimeout(() => {\n      query = q;\n      timer = undefined;\n      void update();\n    }, ms);\n  };\n\n  // initial compute\n  recompute();\n\n  return {\n    batch(mutator) {\n      let nextLimit = limit;\n      let nextFilter = filterFn;\n      let nextSort = sortFn;\n      let nextQuery = query;\n      let nextData = rawData;\n      let nextOffset = offset;\n\n      const clamp = (i: number, total: number, lim: number) =>\n        Math.max(0, Math.min(i, Math.max(0, Math.ceil(total / lim) - 1)));\n\n      mutator({\n        goTo: (p) => {\n          nextOffset = clamp(p - 1, view.length, nextLimit);\n        },\n        setData: (d) => {\n          nextData = [...d];\n          nextOffset = 0;\n        },\n        setFilter: (f) => {\n          nextFilter = f;\n        },\n        setLimit: (n) => {\n          nextLimit = Math.max(1, n);\n        },\n        setQuery: (q) => {\n          nextQuery = q;\n          nextOffset = 0;\n        },\n        setSort: (s) => {\n          nextSort = s;\n        },\n      });\n\n      // apply once\n      limit = nextLimit;\n      filterFn = nextFilter;\n      sortFn = nextSort;\n      query = nextQuery;\n      rawData = nextData;\n      offset = nextOffset;\n\n      update();\n    },\n    get current() {\n      return slice();\n    },\n    goTo(page) {\n      const pages = Math.max(1, Math.ceil(view.length / limit));\n\n      offset = Math.max(0, Math.min(page - 1, pages - 1));\n      notify();\n    },\n    get meta() {\n      const total = view.length;\n      const pages = Math.max(1, Math.ceil(total / limit));\n      const isEmpty = total === 0;\n      const page = Math.min(offset + 1, pages);\n      const start = isEmpty ? 0 : (page - 1) * limit + 1;\n      const end = isEmpty ? 0 : Math.min(page * limit, total);\n\n      return {\n        end,\n        isEmpty,\n        isFirst: page <= 1,\n        isLast: page >= pages,\n        limit,\n        page,\n        pages,\n        start,\n        total,\n      };\n    },\n    next() {\n      const pages = Math.max(1, Math.ceil(view.length / limit));\n\n      if (offset < pages - 1) {\n        offset++;\n        notify();\n      }\n    },\n    prev() {\n      if (offset > 0) {\n        offset--;\n        notify();\n      }\n    },\n    reset() {\n      limit = Math.max(1, cfg.limit ?? DEFAULTS.limit);\n      filterFn = cfg.filterFn ?? (() => true);\n      sortFn = cfg.sortFn;\n      query = '';\n      offset = 0;\n      update();\n    },\n    search(q, opts) {\n      if (opts?.immediate) {\n        query = q;\n        offset = 0;\n        update();\n      } else {\n        debouncedSearch(q, cfg.debounceMs ?? DEFAULTS.debounceMs);\n      }\n    },\n    setData(data) {\n      rawData = [...data];\n      offset = 0;\n      update();\n    },\n    setFilter(f) {\n      filterFn = f;\n      offset = 0;\n      update();\n    },\n    setLimit(n) {\n      limit = Math.max(1, n);\n      offset = 0;\n      update();\n    },\n    setSort(s) {\n      sortFn = s;\n      update();\n    },\n    subscribe(listener) {\n      listeners.add(listener);\n\n      return () => listeners.delete(listener);\n    },\n  };\n}\n"],"mappings":"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"}