@vielzeug/toolkit 1.1.2 → 2.0.0

package/dist/array/replace.d.ts

@@ -0,0 +1,20 @@
+import type { Predicate } from '../types';
+/**
+ * Replaces the first element in an array that satisfies the provided predicate
+ * function with a new value.
+ *
+ * @example
+ * ```ts
+ * replace([1, 2, 3], (n) => n === 2, 4) // [1, 4, 3]
+ * ```
+ *
+ * @param array - The array to search.
+ * @param predicate - A function to test each element of the array.
+ * @param value - The new value to replace the found element.
+ *
+ * @return A new array with the replaced value.
+ *
+ * @throws {TypeError} If the first argument is not an array.
+ */
+export declare function replace<T>(array: T[], predicate: Predicate<T>, value: T): T[];
+//# sourceMappingURL=replace.d.ts.map

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

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

package/dist/array/replace.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/replace.ts
+function r(r, i, a) {
+	e(n(r), t, {
+		args: { array: r },
+		type: TypeError
+	});
+	let o = r.findIndex(i);
+	return o === -1 ? r : [
+		...r.slice(0, o),
+		a,
+		...r.slice(o + 1)
+	];
+}
+//#endregion
+export { r as replace };
+
+//# sourceMappingURL=replace.js.map

package/dist/array/replace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replace.js","names":[],"sources":["../../src/array/replace.ts"],"sourcesContent":["import type { Predicate } from '../types';\n\nimport { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Replaces the first element in an array that satisfies the provided predicate\n * function with a new value.\n *\n * @example\n * ```ts\n * replace([1, 2, 3], (n) => n === 2, 4) // [1, 4, 3]\n * ```\n *\n * @param array - The array to search.\n * @param predicate - A function to test each element of the array.\n * @param value - The new value to replace the found element.\n *\n * @return A new array with the replaced value.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\nexport function replace<T>(array: T[], predicate: Predicate<T>, value: T): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const index = array.findIndex(predicate);\n\n  if (index === -1) return array;\n\n  return [...array.slice(0, index), value, ...array.slice(index + 1)];\n}\n"],"mappings":";;;AAsBA,SAAgB,EAAW,GAAY,GAAyB,GAAe;AAC7E,GAAO,EAAQ,EAAM,EAAE,GAAoB;EAAE,MAAM,EAAE,UAAO;EAAE,MAAM;EAAW,CAAC;CAEhF,IAAM,IAAQ,EAAM,UAAU,EAAU;AAIxC,QAFI,MAAU,KAAW,IAElB;EAAC,GAAG,EAAM,MAAM,GAAG,EAAM;EAAE;EAAO,GAAG,EAAM,MAAM,IAAQ,EAAE;EAAC"}

package/dist/array/rotate.cjs

@@ -0,0 +1,2 @@
+const e=require(`../function/assert.cjs`),t=require(`../typed/isArray.cjs`),n=require(`../typed/isNumber.cjs`);function r(r,i,{wrap:a=!1}={}){if(e.assert(t.isArray(r),t.IS_ARRAY_ERROR_MSG,{args:{array:r},type:TypeError}),e.assert(n.isNumber(i),n.IS_NUMBER_ERROR_MSG,{args:{positions:i},type:TypeError}),r.length===0)return r;let o=(i%r.length+r.length)%r.length,s=r.slice(o);return a?[...s,...r.slice(0,o)]:s}exports.rotate=r;
+//# sourceMappingURL=rotate.cjs.map

package/dist/array/rotate.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotate.cjs","names":[],"sources":["../../src/array/rotate.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { IS_NUMBER_ERROR_MSG, isNumber } from '../typed/isNumber';\n\n/**\n * Rotates the elements of an array by a specified number of positions.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4, 5];\n * rotate(arr, 2); // [3, 4, 5]\n * rotate(arr, 2, { wrap: true }); // [3, 4, 5, 1, 2]\n * ```\n * @param array - The array to rotate.\n * @param positions - The number of positions to rotate the array.\n * @param [options] - Options for the rotate operation.\n * @param [options.wrap] - If `true`, the rotated-out elements are appended to the end.\n *\n * @returns A new array with the elements rotated.\n *\n * @throws {TypeError} If the first argument is not an array, or the second argument is not a number.\n */\nexport function rotate<T>(array: T[], positions: number, { wrap = false }: { wrap?: boolean } = {}): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n  assert(isNumber(positions), IS_NUMBER_ERROR_MSG, { args: { positions }, type: TypeError });\n\n  if (array.length === 0) return array;\n\n  const normalizedPos = ((positions % array.length) + array.length) % array.length;\n  const rotated = array.slice(normalizedPos);\n\n  return wrap ? [...rotated, ...array.slice(0, normalizedPos)] : rotated;\n}\n"],"mappings":"+GAsBA,SAAgB,EAAU,EAAY,EAAmB,CAAE,OAAO,IAA8B,EAAE,CAAO,CAIvG,GAHA,EAAA,OAAO,EAAA,QAAQ,EAAM,CAAE,EAAA,mBAAoB,CAAE,KAAM,CAAE,QAAO,CAAE,KAAM,UAAW,CAAC,CAChF,EAAA,OAAO,EAAA,SAAS,EAAU,CAAE,EAAA,oBAAqB,CAAE,KAAM,CAAE,YAAW,CAAE,KAAM,UAAW,CAAC,CAEtF,EAAM,SAAW,EAAG,OAAO,EAE/B,IAAM,GAAkB,EAAY,EAAM,OAAU,EAAM,QAAU,EAAM,OACpE,EAAU,EAAM,MAAM,EAAc,CAE1C,OAAO,EAAO,CAAC,GAAG,EAAS,GAAG,EAAM,MAAM,EAAG,EAAc,CAAC,CAAG"}

package/dist/array/rotate.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Rotates the elements of an array by a specified number of positions.
+ *
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3, 4, 5];
+ * rotate(arr, 2); // [3, 4, 5]
+ * rotate(arr, 2, { wrap: true }); // [3, 4, 5, 1, 2]
+ * ```
+ * @param array - The array to rotate.
+ * @param positions - The number of positions to rotate the array.
+ * @param [options] - Options for the rotate operation.
+ * @param [options.wrap] - If `true`, the rotated-out elements are appended to the end.
+ *
+ * @returns A new array with the elements rotated.
+ *
+ * @throws {TypeError} If the first argument is not an array, or the second argument is not a number.
+ */
+export declare function rotate<T>(array: T[], positions: number, { wrap }?: {
+    wrap?: boolean;
+}): T[];
+//# sourceMappingURL=rotate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rotate.d.ts","sourceRoot":"","sources":["../../src/array/rotate.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,IAAY,EAAE,GAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,CAAC,EAAE,CAUvG"}

package/dist/array/rotate.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";
+import { IS_NUMBER_ERROR_MSG as r, isNumber as i } from "../typed/isNumber.js";
+//#region src/array/rotate.ts
+function a(a, o, { wrap: s = !1 } = {}) {
+	if (e(n(a), t, {
+		args: { array: a },
+		type: TypeError
+	}), e(i(o), r, {
+		args: { positions: o },
+		type: TypeError
+	}), a.length === 0) return a;
+	let c = (o % a.length + a.length) % a.length, l = a.slice(c);
+	return s ? [...l, ...a.slice(0, c)] : l;
+}
+//#endregion
+export { a as rotate };
+
+//# sourceMappingURL=rotate.js.map

package/dist/array/rotate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotate.js","names":[],"sources":["../../src/array/rotate.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { IS_NUMBER_ERROR_MSG, isNumber } from '../typed/isNumber';\n\n/**\n * Rotates the elements of an array by a specified number of positions.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4, 5];\n * rotate(arr, 2); // [3, 4, 5]\n * rotate(arr, 2, { wrap: true }); // [3, 4, 5, 1, 2]\n * ```\n * @param array - The array to rotate.\n * @param positions - The number of positions to rotate the array.\n * @param [options] - Options for the rotate operation.\n * @param [options.wrap] - If `true`, the rotated-out elements are appended to the end.\n *\n * @returns A new array with the elements rotated.\n *\n * @throws {TypeError} If the first argument is not an array, or the second argument is not a number.\n */\nexport function rotate<T>(array: T[], positions: number, { wrap = false }: { wrap?: boolean } = {}): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n  assert(isNumber(positions), IS_NUMBER_ERROR_MSG, { args: { positions }, type: TypeError });\n\n  if (array.length === 0) return array;\n\n  const normalizedPos = ((positions % array.length) + array.length) % array.length;\n  const rotated = array.slice(normalizedPos);\n\n  return wrap ? [...rotated, ...array.slice(0, normalizedPos)] : rotated;\n}\n"],"mappings":";;;;AAsBA,SAAgB,EAAU,GAAY,GAAmB,EAAE,UAAO,OAA8B,EAAE,EAAO;AAIvG,KAHA,EAAO,EAAQ,EAAM,EAAE,GAAoB;EAAE,MAAM,EAAE,UAAO;EAAE,MAAM;EAAW,CAAC,EAChF,EAAO,EAAS,EAAU,EAAE,GAAqB;EAAE,MAAM,EAAE,cAAW;EAAE,MAAM;EAAW,CAAC,EAEtF,EAAM,WAAW,EAAG,QAAO;CAE/B,IAAM,KAAkB,IAAY,EAAM,SAAU,EAAM,UAAU,EAAM,QACpE,IAAU,EAAM,MAAM,EAAc;AAE1C,QAAO,IAAO,CAAC,GAAG,GAAS,GAAG,EAAM,MAAM,GAAG,EAAc,CAAC,GAAG"}

package/dist/array/search.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("../function/assert.cjs"),c=require("../object/seek.cjs"),t=require("../typed/isString.cjs"),i=require("../typed/isWithin.cjs"),S=require("./filter.cjs");function u(n,r,e=.25){if(s.assert(t.isString(r),t.IS_STRING_ERROR_MSG,{args:{query:r},type:TypeError}),s.assert(i.isWithin(e,0,1),i.IS_WITHIN_ERROR_MSG,{args:{max:1,min:0,tone:e},type:TypeError}),!r)return[];const o=r.toLowerCase();return S.filter(n,a=>c.seek(a,o,e))}exports.search=u;
-//# sourceMappingURL=search.cjs.map
+const e=require(`../function/assert.cjs`),t=require(`../typed/isString.cjs`),n=require(`../typed/isWithin.cjs`),r=require(`../object/seek.cjs`);function i(i,a,o=.25){if(e.assert(t.isString(a),t.IS_STRING_ERROR_MSG,{args:{query:a},type:TypeError}),e.assert(n.isWithin(o,0,1),n.IS_WITHIN_ERROR_MSG,{args:{max:1,min:0,tone:o},type:TypeError}),!a)return[...i];let s=a.toLowerCase();return i.filter(e=>r.seek(e,s,o))}exports.search=i;
+//# sourceMappingURL=search.cjs.map

package/dist/array/search.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"search.cjs","sources":["../../src/array/search.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { seek } from '../object/seek';\nimport { IS_STRING_ERROR_MSG, isString } from '../typed/isString';\nimport { IS_WITHIN_ERROR_MSG, isWithin } from '../typed/isWithin';\nimport { filter } from './filter';\n\n/**\n * Performs a search on an array of objects, checking all values for a match with the search string.\n *\n * @example\n * ```ts\n * const data = [{ name: 'John Doe', age: 25 }, { name: 'Jane Doe', age: 30 }];\n * search(data, 'doe', 0.5); // [{ name: 'John Doe', age: 25 }, { name: 'Jane Doe', age: 30 }]\n * ```\n *\n * @param array - The array of objects to search.\n * @param query - The string to search for.\n * @param [tone=0.25] - Degree of similarity between 0 and 1.\n *\n * @returns The filtered array of objects that match the search string.\n *\n * @throws {Error} If input values are invalid.\n */\nexport function search<T>(array: T[], query: string, tone = 0.25): T[] {\n  assert(isString(query), IS_STRING_ERROR_MSG, { args: { query }, type: TypeError });\n  assert(isWithin(tone, 0, 1), IS_WITHIN_ERROR_MSG, { args: { max: 1, min: 0, tone }, type: TypeError });\n\n  if (!query) return [];\n\n  const searchTerm = query.toLowerCase();\n\n  return filter(array, (obj) => seek(obj, searchTerm, tone));\n}\n"],"names":["search","array","query","tone","assert","isString","IS_STRING_ERROR_MSG","isWithin","IS_WITHIN_ERROR_MSG","searchTerm","filter","obj","seek"],"mappings":"0PAuBO,SAASA,EAAUC,EAAYC,EAAeC,EAAO,IAAW,CAIrE,GAHAC,EAAAA,OAAOC,EAAAA,SAASH,CAAK,EAAGI,sBAAqB,CAAE,KAAM,CAAE,MAAAJ,CAAA,EAAS,KAAM,UAAW,EACjFE,EAAAA,OAAOG,EAAAA,SAASJ,EAAM,EAAG,CAAC,EAAGK,EAAAA,oBAAqB,CAAE,KAAM,CAAE,IAAK,EAAG,IAAK,EAAG,KAAAL,GAAQ,KAAM,UAAW,EAEjG,CAACD,EAAO,MAAO,CAAA,EAEnB,MAAMO,EAAaP,EAAM,YAAA,EAEzB,OAAOQ,EAAAA,OAAOT,EAAQU,GAAQC,EAAAA,KAAKD,EAAKF,EAAYN,CAAI,CAAC,CAC3D"}
+{"version":3,"file":"search.cjs","names":[],"sources":["../../src/array/search.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { seek } from '../object/seek';\nimport { IS_STRING_ERROR_MSG, isString } from '../typed/isString';\nimport { IS_WITHIN_ERROR_MSG, isWithin } from '../typed/isWithin';\n\n/**\n * Performs a search on an array of objects, checking all values for a match with the search string.\n *\n * @example\n * ```ts\n * const data = [{ name: 'John Doe', age: 25 }, { name: 'Jane Doe', age: 30 }];\n * search(data, 'doe', 0.5); // [{ name: 'John Doe', age: 25 }, { name: 'Jane Doe', age: 30 }]\n * ```\n *\n * @param array - The array of objects to search.\n * @param query - The string to search for.\n * @param [tone=0.25] - Degree of similarity between 0 and 1.\n *\n * @returns The filtered array of objects that match the search string.\n *\n * @throws {Error} If input values are invalid.\n */\nexport function search<T>(array: T[], query: string, tone = 0.25): T[] {\n  assert(isString(query), IS_STRING_ERROR_MSG, { args: { query }, type: TypeError });\n  assert(isWithin(tone, 0, 1), IS_WITHIN_ERROR_MSG, { args: { max: 1, min: 0, tone }, type: TypeError });\n\n  if (!query) return [...array];\n\n  const searchTerm = query.toLowerCase();\n\n  return array.filter((obj) => seek(obj as object, searchTerm, tone));\n}\n"],"mappings":"gJAsBA,SAAgB,EAAU,EAAY,EAAe,EAAO,IAAW,CAIrE,GAHA,EAAA,OAAO,EAAA,SAAS,EAAM,CAAE,EAAA,oBAAqB,CAAE,KAAM,CAAE,QAAO,CAAE,KAAM,UAAW,CAAC,CAClF,EAAA,OAAO,EAAA,SAAS,EAAM,EAAG,EAAE,CAAE,EAAA,oBAAqB,CAAE,KAAM,CAAE,IAAK,EAAG,IAAK,EAAG,OAAM,CAAE,KAAM,UAAW,CAAC,CAElG,CAAC,EAAO,MAAO,CAAC,GAAG,EAAM,CAE7B,IAAM,EAAa,EAAM,aAAa,CAEtC,OAAO,EAAM,OAAQ,GAAQ,EAAA,KAAK,EAAe,EAAY,EAAK,CAAC"}

package/dist/array/search.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Performs a search on an array of objects, checking all values for a match with the search string.
+ *
+ * @example
+ * ```ts
+ * const data = [{ name: 'John Doe', age: 25 }, { name: 'Jane Doe', age: 30 }];
+ * search(data, 'doe', 0.5); // [{ name: 'John Doe', age: 25 }, { name: 'Jane Doe', age: 30 }]
+ * ```
+ *
+ * @param array - The array of objects to search.
+ * @param query - The string to search for.
+ * @param [tone=0.25] - Degree of similarity between 0 and 1.
+ *
+ * @returns The filtered array of objects that match the search string.
+ *
+ * @throws {Error} If input values are invalid.
+ */
+export declare function search<T>(array: T[], query: string, tone?: number): T[];
+//# sourceMappingURL=search.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/array/search.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,SAAO,GAAG,CAAC,EAAE,CASrE"}

package/dist/array/search.js

@@ -1,14 +1,24 @@
-import { assert as t } from "../function/assert.js";
-import { seek as s } from "../object/seek.js";
-import { IS_STRING_ERROR_MSG as p, isString as f } from "../typed/isString.js";
-import { IS_WITHIN_ERROR_MSG as a, isWithin as R } from "../typed/isWithin.js";
-import { filter as n } from "./filter.js";
-function E(i, r, o = 0.25) {
-  if (t(f(r), p, { args: { query: r }, type: TypeError }), t(R(o, 0, 1), a, { args: { max: 1, min: 0, tone: o }, type: TypeError }), !r) return [];
-  const m = r.toLowerCase();
-  return n(i, (e) => s(e, m, o));
+import { assert as e } from "../function/assert.js";
+import { IS_STRING_ERROR_MSG as t, isString as n } from "../typed/isString.js";
+import { IS_WITHIN_ERROR_MSG as r, isWithin as i } from "../typed/isWithin.js";
+import { seek as a } from "../object/seek.js";
+//#region src/array/search.ts
+function o(o, s, c = .25) {
+	if (e(n(s), t, {
+		args: { query: s },
+		type: TypeError
+	}), e(i(c, 0, 1), r, {
+		args: {
+			max: 1,
+			min: 0,
+			tone: c
+		},
+		type: TypeError
+	}), !s) return [...o];
+	let l = s.toLowerCase();
+	return o.filter((e) => a(e, l, c));
 }
-export {
-  E as search
-};
-//# sourceMappingURL=search.js.map
+//#endregion
+export { o as search };
+
+//# sourceMappingURL=search.js.map

package/dist/array/search.js.map

@@ -1 +1 @@
-{"version":3,"file":"search.js","sources":["../../src/array/search.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { seek } from '../object/seek';\nimport { IS_STRING_ERROR_MSG, isString } from '../typed/isString';\nimport { IS_WITHIN_ERROR_MSG, isWithin } from '../typed/isWithin';\nimport { filter } from './filter';\n\n/**\n * Performs a search on an array of objects, checking all values for a match with the search string.\n *\n * @example\n * ```ts\n * const data = [{ name: 'John Doe', age: 25 }, { name: 'Jane Doe', age: 30 }];\n * search(data, 'doe', 0.5); // [{ name: 'John Doe', age: 25 }, { name: 'Jane Doe', age: 30 }]\n * ```\n *\n * @param array - The array of objects to search.\n * @param query - The string to search for.\n * @param [tone=0.25] - Degree of similarity between 0 and 1.\n *\n * @returns The filtered array of objects that match the search string.\n *\n * @throws {Error} If input values are invalid.\n */\nexport function search<T>(array: T[], query: string, tone = 0.25): T[] {\n  assert(isString(query), IS_STRING_ERROR_MSG, { args: { query }, type: TypeError });\n  assert(isWithin(tone, 0, 1), IS_WITHIN_ERROR_MSG, { args: { max: 1, min: 0, tone }, type: TypeError });\n\n  if (!query) return [];\n\n  const searchTerm = query.toLowerCase();\n\n  return filter(array, (obj) => seek(obj, searchTerm, tone));\n}\n"],"names":["search","array","query","tone","assert","isString","IS_STRING_ERROR_MSG","isWithin","IS_WITHIN_ERROR_MSG","searchTerm","filter","obj","seek"],"mappings":";;;;;AAuBO,SAASA,EAAUC,GAAYC,GAAeC,IAAO,MAAW;AAIrE,MAHAC,EAAOC,EAASH,CAAK,GAAGI,GAAqB,EAAE,MAAM,EAAE,OAAAJ,EAAA,GAAS,MAAM,WAAW,GACjFE,EAAOG,EAASJ,GAAM,GAAG,CAAC,GAAGK,GAAqB,EAAE,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,MAAAL,KAAQ,MAAM,WAAW,GAEjG,CAACD,EAAO,QAAO,CAAA;AAEnB,QAAMO,IAAaP,EAAM,YAAA;AAEzB,SAAOQ,EAAOT,GAAO,CAACU,MAAQC,EAAKD,GAAKF,GAAYN,CAAI,CAAC;AAC3D;"}
+{"version":3,"file":"search.js","names":[],"sources":["../../src/array/search.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { seek } from '../object/seek';\nimport { IS_STRING_ERROR_MSG, isString } from '../typed/isString';\nimport { IS_WITHIN_ERROR_MSG, isWithin } from '../typed/isWithin';\n\n/**\n * Performs a search on an array of objects, checking all values for a match with the search string.\n *\n * @example\n * ```ts\n * const data = [{ name: 'John Doe', age: 25 }, { name: 'Jane Doe', age: 30 }];\n * search(data, 'doe', 0.5); // [{ name: 'John Doe', age: 25 }, { name: 'Jane Doe', age: 30 }]\n * ```\n *\n * @param array - The array of objects to search.\n * @param query - The string to search for.\n * @param [tone=0.25] - Degree of similarity between 0 and 1.\n *\n * @returns The filtered array of objects that match the search string.\n *\n * @throws {Error} If input values are invalid.\n */\nexport function search<T>(array: T[], query: string, tone = 0.25): T[] {\n  assert(isString(query), IS_STRING_ERROR_MSG, { args: { query }, type: TypeError });\n  assert(isWithin(tone, 0, 1), IS_WITHIN_ERROR_MSG, { args: { max: 1, min: 0, tone }, type: TypeError });\n\n  if (!query) return [...array];\n\n  const searchTerm = query.toLowerCase();\n\n  return array.filter((obj) => seek(obj as object, searchTerm, tone));\n}\n"],"mappings":";;;;;AAsBA,SAAgB,EAAU,GAAY,GAAe,IAAO,KAAW;AAIrE,KAHA,EAAO,EAAS,EAAM,EAAE,GAAqB;EAAE,MAAM,EAAE,UAAO;EAAE,MAAM;EAAW,CAAC,EAClF,EAAO,EAAS,GAAM,GAAG,EAAE,EAAE,GAAqB;EAAE,MAAM;GAAE,KAAK;GAAG,KAAK;GAAG;GAAM;EAAE,MAAM;EAAW,CAAC,EAElG,CAAC,EAAO,QAAO,CAAC,GAAG,EAAM;CAE7B,IAAM,IAAa,EAAM,aAAa;AAEtC,QAAO,EAAM,QAAQ,MAAQ,EAAK,GAAe,GAAY,EAAK,CAAC"}

package/dist/array/select.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l=require("../function/assert.cjs"),r=require("../typed/isArray.cjs"),c=require("../typed/isNil.cjs"),f=require("../typed/isPromise.cjs");function o(s,t,n){l.assert(r.isArray(s),r.IS_ARRAY_ERROR_MSG,{args:{array:s},type:TypeError});const i=[],u=n??(e=>!c.isNil(e));for(let e=0;e<s.length;e++)u(s[e],e,s)&&i.push(t(s[e],e,s));return f.isPromise(t)?Promise.all(i):i}o.fp=!0;exports.select=o;
-//# sourceMappingURL=select.cjs.map
+const e=require(`../function/assert.cjs`),t=require(`../typed/isArray.cjs`),n=require(`../typed/isNil.cjs`);function r(r,i,a){e.assert(t.isArray(r),t.IS_ARRAY_ERROR_MSG,{args:{array:r},type:TypeError});let o=a??(e=>!n.isNil(e)),s=[];for(let e=0;e<r.length;e++)o(r[e],e,r)&&s.push(i(r[e],e,r));return s}exports.select=r;
+//# sourceMappingURL=select.cjs.map

package/dist/array/select.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"select.cjs","sources":["../../src/array/select.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { isNil } from '../typed/isNil';\nimport { isPromise } from '../typed/isPromise';\nimport type { CallbackDynamic, Predicate, ResultArray } from '../types';\n\n/**\n * Selects elements from an array based on a callback function and an optional predicate function.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4];\n * select(arr, x => x * x, x => x > 2) // [9, 16]\n * await select(arr, async x => x * x, x => x > 2) // [9, 16]\n * ```\n *\n * @param array - The array to select from.\n * @param callback - The function to map the values.\n * @param [predicate] - (optional) The function to filter the values.\n *\n * @returns A new array with the selected values.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function select<T, R, C extends CallbackDynamic<T, R>>(\n  array: T[],\n  callback: C,\n  predicate?: Predicate<T>,\n): ResultArray<C> {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const result = [];\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      result.push(callback(array[index], index, array));\n    }\n  }\n\n  return (isPromise(callback) ? Promise.all(result) : result) as ResultArray<C>;\n}\n\nselect.fp = true;\n"],"names":["select","array","callback","predicate","assert","isArray","IS_ARRAY_ERROR_MSG","result","isValid","value","isNil","index","isPromise"],"mappings":"gOAwBO,SAASA,EACdC,EACAC,EACAC,EACgB,CAChBC,EAAAA,OAAOC,EAAAA,QAAQJ,CAAK,EAAGK,qBAAoB,CAAE,KAAM,CAAE,MAAAL,CAAA,EAAS,KAAM,UAAW,EAE/E,MAAMM,EAAS,CAAA,EAETC,EAAUL,IAAeM,GAAa,CAACC,EAAAA,MAAMD,CAAK,GAExD,QAASE,EAAQ,EAAGA,EAAQV,EAAM,OAAQU,IACpCH,EAAQP,EAAMU,CAAK,EAAGA,EAAOV,CAAK,GACpCM,EAAO,KAAKL,EAASD,EAAMU,CAAK,EAAGA,EAAOV,CAAK,CAAC,EAIpD,OAAQW,EAAAA,UAAUV,CAAQ,EAAI,QAAQ,IAAIK,CAAM,EAAIA,CACtD,CAEAP,EAAO,GAAK"}
+{"version":3,"file":"select.cjs","names":[],"sources":["../../src/array/select.ts"],"sourcesContent":["import type { Predicate } from '../types';\n\nimport { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { isNil } from '../typed/isNil';\n\n/**\n * Selects elements from an array based on a callback function and an optional predicate function.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4];\n * select(arr, x => x * x, x => x > 2) // [9, 16]\n * select(arr, x => x * x) // [1, 4, 9, 16]\n * ```\n *\n * @param array - The array to select from.\n * @param callback - The function to map the values.\n * @param [predicate] - (optional) The function to filter the values.\n *\n * @returns A new array with the selected values.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function select<T, R>(\n  array: T[],\n  callback: (item: T, index: number, array: T[]) => R,\n  predicate?: Predicate<T>,\n): R[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const isValid = predicate ?? ((value: T) => !isNil(value));\n  const result: R[] = [];\n\n  for (let index = 0; index < array.length; index++) {\n    if (isValid(array[index], index, array)) {\n      result.push(callback(array[index], index, array));\n    }\n  }\n\n  return result;\n}\n"],"mappings":"4GAwBA,SAAgB,EACd,EACA,EACA,EACK,CACL,EAAA,OAAO,EAAA,QAAQ,EAAM,CAAE,EAAA,mBAAoB,CAAE,KAAM,CAAE,QAAO,CAAE,KAAM,UAAW,CAAC,CAEhF,IAAM,EAAU,IAAe,GAAa,CAAC,EAAA,MAAM,EAAM,EACnD,EAAc,EAAE,CAEtB,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAM,OAAQ,IACpC,EAAQ,EAAM,GAAQ,EAAO,EAAM,EACrC,EAAO,KAAK,EAAS,EAAM,GAAQ,EAAO,EAAM,CAAC,CAIrD,OAAO"}

package/dist/array/select.d.ts

@@ -0,0 +1,21 @@
+import type { Predicate } from '../types';
+/**
+ * Selects elements from an array based on a callback function and an optional predicate function.
+ *
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3, 4];
+ * select(arr, x => x * x, x => x > 2) // [9, 16]
+ * select(arr, x => x * x) // [1, 4, 9, 16]
+ * ```
+ *
+ * @param array - The array to select from.
+ * @param callback - The function to map the values.
+ * @param [predicate] - (optional) The function to filter the values.
+ *
+ * @returns A new array with the selected values.
+ *
+ * @throws {TypeError} If the provided array is not an array.
+ */
+export declare function select<T, R>(array: T[], callback: (item: T, index: number, array: T[]) => R, predicate?: Predicate<T>): R[];
+//# sourceMappingURL=select.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../../src/array/select.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAM1C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,KAAK,EAAE,CAAC,EAAE,EACV,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,EACnD,SAAS,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,GACvB,CAAC,EAAE,CAaL"}

package/dist/array/select.js

@@ -1,16 +1,17 @@
-import { assert as m } from "../function/assert.js";
-import { IS_ARRAY_ERROR_MSG as p, isArray as f } from "../typed/isArray.js";
-import { isNil as n } from "../typed/isNil.js";
-import { isPromise as l } from "../typed/isPromise.js";
-function u(t, e, s) {
-  m(f(t), p, { args: { array: t }, type: TypeError });
-  const i = [], r = s ?? ((o) => !n(o));
-  for (let o = 0; o < t.length; o++)
-    r(t[o], o, t) && i.push(e(t[o], o, t));
-  return l(e) ? Promise.all(i) : i;
+import { assert as e } from "../function/assert.js";
+import { IS_ARRAY_ERROR_MSG as t, isArray as n } from "../typed/isArray.js";
+import { isNil as r } from "../typed/isNil.js";
+//#region src/array/select.ts
+function i(i, a, o) {
+	e(n(i), t, {
+		args: { array: i },
+		type: TypeError
+	});
+	let s = o ?? ((e) => !r(e)), c = [];
+	for (let e = 0; e < i.length; e++) s(i[e], e, i) && c.push(a(i[e], e, i));
+	return c;
 }
-u.fp = !0;
-export {
-  u as select
-};
-//# sourceMappingURL=select.js.map
+//#endregion
+export { i as select };
+
+//# sourceMappingURL=select.js.map

package/dist/array/select.js.map

@@ -1 +1 @@
-{"version":3,"file":"select.js","sources":["../../src/array/select.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { isNil } from '../typed/isNil';\nimport { isPromise } from '../typed/isPromise';\nimport type { CallbackDynamic, Predicate, ResultArray } from '../types';\n\n/**\n * Selects elements from an array based on a callback function and an optional predicate function.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4];\n * select(arr, x => x * x, x => x > 2) // [9, 16]\n * await select(arr, async x => x * x, x => x > 2) // [9, 16]\n * ```\n *\n * @param array - The array to select from.\n * @param callback - The function to map the values.\n * @param [predicate] - (optional) The function to filter the values.\n *\n * @returns A new array with the selected values.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function select<T, R, C extends CallbackDynamic<T, R>>(\n  array: T[],\n  callback: C,\n  predicate?: Predicate<T>,\n): ResultArray<C> {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const result = [];\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      result.push(callback(array[index], index, array));\n    }\n  }\n\n  return (isPromise(callback) ? Promise.all(result) : result) as ResultArray<C>;\n}\n\nselect.fp = true;\n"],"names":["select","array","callback","predicate","assert","isArray","IS_ARRAY_ERROR_MSG","result","isValid","value","isNil","index","isPromise"],"mappings":";;;;AAwBO,SAASA,EACdC,GACAC,GACAC,GACgB;AAChB,EAAAC,EAAOC,EAAQJ,CAAK,GAAGK,GAAoB,EAAE,MAAM,EAAE,OAAAL,EAAA,GAAS,MAAM,WAAW;AAE/E,QAAMM,IAAS,CAAA,GAETC,IAAUL,MAAc,CAACM,MAAa,CAACC,EAAMD,CAAK;AAExD,WAASE,IAAQ,GAAGA,IAAQV,EAAM,QAAQU;AACxC,IAAIH,EAAQP,EAAMU,CAAK,GAAGA,GAAOV,CAAK,KACpCM,EAAO,KAAKL,EAASD,EAAMU,CAAK,GAAGA,GAAOV,CAAK,CAAC;AAIpD,SAAQW,EAAUV,CAAQ,IAAI,QAAQ,IAAIK,CAAM,IAAIA;AACtD;AAEAP,EAAO,KAAK;"}
+{"version":3,"file":"select.js","names":[],"sources":["../../src/array/select.ts"],"sourcesContent":["import type { Predicate } from '../types';\n\nimport { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { isNil } from '../typed/isNil';\n\n/**\n * Selects elements from an array based on a callback function and an optional predicate function.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4];\n * select(arr, x => x * x, x => x > 2) // [9, 16]\n * select(arr, x => x * x) // [1, 4, 9, 16]\n * ```\n *\n * @param array - The array to select from.\n * @param callback - The function to map the values.\n * @param [predicate] - (optional) The function to filter the values.\n *\n * @returns A new array with the selected values.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function select<T, R>(\n  array: T[],\n  callback: (item: T, index: number, array: T[]) => R,\n  predicate?: Predicate<T>,\n): R[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const isValid = predicate ?? ((value: T) => !isNil(value));\n  const result: R[] = [];\n\n  for (let index = 0; index < array.length; index++) {\n    if (isValid(array[index], index, array)) {\n      result.push(callback(array[index], index, array));\n    }\n  }\n\n  return result;\n}\n"],"mappings":";;;;AAwBA,SAAgB,EACd,GACA,GACA,GACK;AACL,GAAO,EAAQ,EAAM,EAAE,GAAoB;EAAE,MAAM,EAAE,UAAO;EAAE,MAAM;EAAW,CAAC;CAEhF,IAAM,IAAU,OAAe,MAAa,CAAC,EAAM,EAAM,GACnD,IAAc,EAAE;AAEtB,MAAK,IAAI,IAAQ,GAAG,IAAQ,EAAM,QAAQ,IACxC,CAAI,EAAQ,EAAM,IAAQ,GAAO,EAAM,IACrC,EAAO,KAAK,EAAS,EAAM,IAAQ,GAAO,EAAM,CAAC;AAIrD,QAAO"}

package/dist/array/sort.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("../function/assert.cjs"),p=require("../function/compare.cjs"),t=require("../typed/isArray.cjs"),s=(r,e,o=!1)=>{n.assert(t.isArray(r),t.IS_ARRAY_ERROR_MSG,{args:{array:r},type:TypeError});const i=o?-1:1;return[...r].sort((u,c)=>p.compare(e(u),e(c))*i)};s.fp=!0;exports.sort=s;
-//# sourceMappingURL=sort.cjs.map
+const e=require(`../function/assert.cjs`),t=require(`../typed/isArray.cjs`),n=require(`../function/compare.cjs`),r=require(`../function/compareBy.cjs`);function i(i,a,o=`asc`){if(e.assert(t.isArray(i),t.IS_ARRAY_ERROR_MSG,{args:{array:i},type:TypeError}),typeof a==`function`){let e=o===`desc`?-1:1;return[...i].sort((t,r)=>n.compare(a(t),a(r))*e)}return[...i].sort(r.compareBy(a))}exports.sort=i;
+//# sourceMappingURL=sort.cjs.map

package/dist/array/sort.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"sort.cjs","sources":["../../src/array/sort.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { compare } from '../function/compare';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Sorts an array of objects by a specific key in ascending order.\n *\n * @example\n * ```ts\n * const data = [{ a: 2 }, { a: 3 }, { a: 1 }];\n * sort(data, (item) => item.a); // [{ a: 1 }, { a: 2 }, { a: 3 }]\n * ```\n *\n * @param array - The array of objects to sort.\n * @param selector - A function that extracts the key to sort by.\n * @param desc - A boolean indicating whether to sort in descending order (default: false).\n *\n * @returns A new array sorted by the specified key.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\n// biome-ignore lint/suspicious/noExplicitAny: -\nexport const sort = <T>(array: T[], selector: (item: T) => any, desc = false) => {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const multiplier = desc ? -1 : 1;\n\n  return [...array].sort((a, b) => compare(selector(a), selector(b)) * multiplier);\n};\n\nsort.fp = true;\n"],"names":["sort","array","selector","desc","assert","isArray","IS_ARRAY_ERROR_MSG","multiplier","a","b","compare"],"mappings":"iMAsBaA,EAAO,CAAIC,EAAYC,EAA4BC,EAAO,KAAU,CAC/EC,EAAAA,OAAOC,EAAAA,QAAQJ,CAAK,EAAGK,qBAAoB,CAAE,KAAM,CAAE,MAAAL,CAAA,EAAS,KAAM,UAAW,EAE/E,MAAMM,EAAaJ,EAAO,GAAK,EAE/B,MAAO,CAAC,GAAGF,CAAK,EAAE,KAAK,CAACO,EAAGC,IAAMC,EAAAA,QAAQR,EAASM,CAAC,EAAGN,EAASO,CAAC,CAAC,EAAIF,CAAU,CACjF,EAEAP,EAAK,GAAK"}
+{"version":3,"file":"sort.cjs","names":[],"sources":["../../src/array/sort.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { compare } from '../function/compare';\nimport { compareBy } from '../function/compareBy';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\nexport type SortDirection = 'asc' | 'desc';\nexport type SortSelectors<T> = Partial<Record<keyof T, SortDirection>>;\n\n/**\n * Sorts an array by a selector function (single-field) or by a multi-field\n * object of `{ key: 'asc' | 'desc' }` entries.\n *\n * @example\n * ```ts\n * // Single field\n * sort([{ a: 2 }, { a: 1 }], item => item.a); // [{ a:1 }, { a:2 }]\n * sort([{ a: 2 }, { a: 1 }], item => item.a, 'desc'); // [{ a:2 }, { a:1 }]\n *\n * // Multi-field\n * sort(users, { name: 'asc', age: 'desc' });\n * ```\n *\n * @param array - The array to sort.\n * @param selector - A function extracting the sort key, or a multi-field object.\n * @param direction - `'asc'` (default) or `'desc'` — only applies to single-field mode.\n * @returns A new sorted array.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\nexport function sort<T>(array: T[], selector: (item: T) => unknown, direction?: SortDirection): T[];\nexport function sort<T>(array: T[], selectors: SortSelectors<T>): T[];\nexport function sort<T>(\n  array: T[],\n  selectorOrSelectors: ((item: T) => unknown) | SortSelectors<T>,\n  direction: SortDirection = 'asc',\n): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  if (typeof selectorOrSelectors === 'function') {\n    const multiplier = direction === 'desc' ? -1 : 1;\n\n    return [...array].sort((a, b) => compare(selectorOrSelectors(a), selectorOrSelectors(b)) * multiplier);\n  }\n\n  return [...array].sort(compareBy(selectorOrSelectors));\n}\n"],"mappings":"wJA+BA,SAAgB,EACd,EACA,EACA,EAA2B,MACtB,CAGL,GAFA,EAAA,OAAO,EAAA,QAAQ,EAAM,CAAE,EAAA,mBAAoB,CAAE,KAAM,CAAE,QAAO,CAAE,KAAM,UAAW,CAAC,CAE5E,OAAO,GAAwB,WAAY,CAC7C,IAAM,EAAa,IAAc,OAAS,GAAK,EAE/C,MAAO,CAAC,GAAG,EAAM,CAAC,MAAM,EAAG,IAAM,EAAA,QAAQ,EAAoB,EAAE,CAAE,EAAoB,EAAE,CAAC,CAAG,EAAW,CAGxG,MAAO,CAAC,GAAG,EAAM,CAAC,KAAK,EAAA,UAAU,EAAoB,CAAC"}

package/dist/array/sort.d.ts

@@ -0,0 +1,26 @@
+export type SortDirection = 'asc' | 'desc';
+export type SortSelectors<T> = Partial<Record<keyof T, SortDirection>>;
+/**
+ * Sorts an array by a selector function (single-field) or by a multi-field
+ * object of `{ key: 'asc' | 'desc' }` entries.
+ *
+ * @example
+ * ```ts
+ * // Single field
+ * sort([{ a: 2 }, { a: 1 }], item => item.a); // [{ a:1 }, { a:2 }]
+ * sort([{ a: 2 }, { a: 1 }], item => item.a, 'desc'); // [{ a:2 }, { a:1 }]
+ *
+ * // Multi-field
+ * sort(users, { name: 'asc', age: 'desc' });
+ * ```
+ *
+ * @param array - The array to sort.
+ * @param selector - A function extracting the sort key, or a multi-field object.
+ * @param direction - `'asc'` (default) or `'desc'` — only applies to single-field mode.
+ * @returns A new sorted array.
+ *
+ * @throws {TypeError} If the first argument is not an array.
+ */
+export declare function sort<T>(array: T[], selector: (item: T) => unknown, direction?: SortDirection): T[];
+export declare function sort<T>(array: T[], selectors: SortSelectors<T>): T[];
+//# sourceMappingURL=sort.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../src/array/sort.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,MAAM,CAAC;AAC3C,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAAE,SAAS,CAAC,EAAE,aAAa,GAAG,CAAC,EAAE,CAAC;AACpG,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC"}

package/dist/array/sort.js

@@ -1,13 +1,19 @@
 import { assert as e } from "../function/assert.js";
-import { compare as i } from "../function/compare.js";
-import { IS_ARRAY_ERROR_MSG as f, isArray as R } from "../typed/isArray.js";
-const n = (r, o, t = !1) => {
-  e(R(r), f, { args: { array: r }, type: TypeError });
-  const p = t ? -1 : 1;
-  return [...r].sort((m, s) => i(o(m), o(s)) * p);
-};
-n.fp = !0;
-export {
-  n as sort
-};
-//# sourceMappingURL=sort.js.map
+import { IS_ARRAY_ERROR_MSG as t, isArray as n } from "../typed/isArray.js";
+import { compare as r } from "../function/compare.js";
+import { compareBy as i } from "../function/compareBy.js";
+//#region src/array/sort.ts
+function a(a, o, s = "asc") {
+	if (e(n(a), t, {
+		args: { array: a },
+		type: TypeError
+	}), typeof o == "function") {
+		let e = s === "desc" ? -1 : 1;
+		return [...a].sort((t, n) => r(o(t), o(n)) * e);
+	}
+	return [...a].sort(i(o));
+}
+//#endregion
+export { a as sort };
+
+//# sourceMappingURL=sort.js.map

package/dist/array/sort.js.map

@@ -1 +1 @@
-{"version":3,"file":"sort.js","sources":["../../src/array/sort.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { compare } from '../function/compare';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Sorts an array of objects by a specific key in ascending order.\n *\n * @example\n * ```ts\n * const data = [{ a: 2 }, { a: 3 }, { a: 1 }];\n * sort(data, (item) => item.a); // [{ a: 1 }, { a: 2 }, { a: 3 }]\n * ```\n *\n * @param array - The array of objects to sort.\n * @param selector - A function that extracts the key to sort by.\n * @param desc - A boolean indicating whether to sort in descending order (default: false).\n *\n * @returns A new array sorted by the specified key.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\n// biome-ignore lint/suspicious/noExplicitAny: -\nexport const sort = <T>(array: T[], selector: (item: T) => any, desc = false) => {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const multiplier = desc ? -1 : 1;\n\n  return [...array].sort((a, b) => compare(selector(a), selector(b)) * multiplier);\n};\n\nsort.fp = true;\n"],"names":["sort","array","selector","desc","assert","isArray","IS_ARRAY_ERROR_MSG","multiplier","a","b","compare"],"mappings":";;;AAsBO,MAAMA,IAAO,CAAIC,GAAYC,GAA4BC,IAAO,OAAU;AAC/E,EAAAC,EAAOC,EAAQJ,CAAK,GAAGK,GAAoB,EAAE,MAAM,EAAE,OAAAL,EAAA,GAAS,MAAM,WAAW;AAE/E,QAAMM,IAAaJ,IAAO,KAAK;AAE/B,SAAO,CAAC,GAAGF,CAAK,EAAE,KAAK,CAACO,GAAGC,MAAMC,EAAQR,EAASM,CAAC,GAAGN,EAASO,CAAC,CAAC,IAAIF,CAAU;AACjF;AAEAP,EAAK,KAAK;"}
+{"version":3,"file":"sort.js","names":[],"sources":["../../src/array/sort.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { compare } from '../function/compare';\nimport { compareBy } from '../function/compareBy';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\nexport type SortDirection = 'asc' | 'desc';\nexport type SortSelectors<T> = Partial<Record<keyof T, SortDirection>>;\n\n/**\n * Sorts an array by a selector function (single-field) or by a multi-field\n * object of `{ key: 'asc' | 'desc' }` entries.\n *\n * @example\n * ```ts\n * // Single field\n * sort([{ a: 2 }, { a: 1 }], item => item.a); // [{ a:1 }, { a:2 }]\n * sort([{ a: 2 }, { a: 1 }], item => item.a, 'desc'); // [{ a:2 }, { a:1 }]\n *\n * // Multi-field\n * sort(users, { name: 'asc', age: 'desc' });\n * ```\n *\n * @param array - The array to sort.\n * @param selector - A function extracting the sort key, or a multi-field object.\n * @param direction - `'asc'` (default) or `'desc'` — only applies to single-field mode.\n * @returns A new sorted array.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\nexport function sort<T>(array: T[], selector: (item: T) => unknown, direction?: SortDirection): T[];\nexport function sort<T>(array: T[], selectors: SortSelectors<T>): T[];\nexport function sort<T>(\n  array: T[],\n  selectorOrSelectors: ((item: T) => unknown) | SortSelectors<T>,\n  direction: SortDirection = 'asc',\n): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  if (typeof selectorOrSelectors === 'function') {\n    const multiplier = direction === 'desc' ? -1 : 1;\n\n    return [...array].sort((a, b) => compare(selectorOrSelectors(a), selectorOrSelectors(b)) * multiplier);\n  }\n\n  return [...array].sort(compareBy(selectorOrSelectors));\n}\n"],"mappings":";;;;;AA+BA,SAAgB,EACd,GACA,GACA,IAA2B,OACtB;AAGL,KAFA,EAAO,EAAQ,EAAM,EAAE,GAAoB;EAAE,MAAM,EAAE,UAAO;EAAE,MAAM;EAAW,CAAC,EAE5E,OAAO,KAAwB,YAAY;EAC7C,IAAM,IAAa,MAAc,SAAS,KAAK;AAE/C,SAAO,CAAC,GAAG,EAAM,CAAC,MAAM,GAAG,MAAM,EAAQ,EAAoB,EAAE,EAAE,EAAoB,EAAE,CAAC,GAAG,EAAW;;AAGxG,QAAO,CAAC,GAAG,EAAM,CAAC,KAAK,EAAU,EAAoB,CAAC"}

package/dist/array/toggle.cjs

@@ -0,0 +1,2 @@
+function e(e,t,n,r={}){let{strategy:i=`append`}=r,a=n?e=>n(e)===n(t):e=>e===t,o=e.findIndex(a);return o===-1?i===`prepend`?[t,...e]:[...e,t]:[...e.slice(0,o),...e.slice(o+1)]}exports.toggle=e;
+//# sourceMappingURL=toggle.cjs.map

package/dist/array/toggle.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"toggle.cjs","names":[],"sources":["../../src/array/toggle.ts"],"sourcesContent":["import type { Primitive } from '../types';\n\n/**\n * Either adds or removes an item from an array, based on whether it already\n * exists in the array (toggle behaviour).\n *\n * @example\n * ```ts\n * toggle([1, 2, 3], 4) // [1, 2, 3, 4]\n * toggle([1, 2, 3], 2) // [1, 3]\n *\n * toggle(\n *   [{ id: 1 }, { id: 2 }],\n *   { id: 3 },\n *   (obj) => obj.id,\n *   { strategy: 'prepend' }\n * ) // [{ id: 3 }, { id: 1 }, { id: 2 }]\n * ```\n *\n * @param array - The array to modify.\n * @param item - The item to add or remove.\n * @param selector - A function to determine item identity.\n * @param [options] - Options for the toggle operation.\n * @param [options.strategy] - Where to insert when adding: 'prepend' or 'append' (default).\n * @returns A new array with the item toggled.\n */\nexport function toggle<T>(\n  array: T[],\n  item: T,\n  selector?: (item: T) => Primitive,\n  options: { strategy?: 'prepend' | 'append' } = {},\n): T[] {\n  const { strategy = 'append' } = options;\n  const compareFn = selector ? (el: T) => selector(el) === selector(item) : (el: T) => el === item;\n\n  const index = array.findIndex(compareFn);\n\n  if (index !== -1) {\n    return [...array.slice(0, index), ...array.slice(index + 1)];\n  }\n\n  return strategy === 'prepend' ? [item, ...array] : [...array, item];\n}\n"],"mappings":"AA0BA,SAAgB,EACd,EACA,EACA,EACA,EAA+C,EAAE,CAC5C,CACL,GAAM,CAAE,WAAW,UAAa,EAC1B,EAAY,EAAY,GAAU,EAAS,EAAG,GAAK,EAAS,EAAK,CAAI,GAAU,IAAO,EAEtF,EAAQ,EAAM,UAAU,EAAU,CAMxC,OAJI,IAAU,GAIP,IAAa,UAAY,CAAC,EAAM,GAAG,EAAM,CAAG,CAAC,GAAG,EAAO,EAAK,CAH1D,CAAC,GAAG,EAAM,MAAM,EAAG,EAAM,CAAE,GAAG,EAAM,MAAM,EAAQ,EAAE,CAAC"}

package/dist/array/toggle.d.ts

@@ -0,0 +1,29 @@
+import type { Primitive } from '../types';
+/**
+ * Either adds or removes an item from an array, based on whether it already
+ * exists in the array (toggle behaviour).
+ *
+ * @example
+ * ```ts
+ * toggle([1, 2, 3], 4) // [1, 2, 3, 4]
+ * toggle([1, 2, 3], 2) // [1, 3]
+ *
+ * toggle(
+ *   [{ id: 1 }, { id: 2 }],
+ *   { id: 3 },
+ *   (obj) => obj.id,
+ *   { strategy: 'prepend' }
+ * ) // [{ id: 3 }, { id: 1 }, { id: 2 }]
+ * ```
+ *
+ * @param array - The array to modify.
+ * @param item - The item to add or remove.
+ * @param selector - A function to determine item identity.
+ * @param [options] - Options for the toggle operation.
+ * @param [options.strategy] - Where to insert when adding: 'prepend' or 'append' (default).
+ * @returns A new array with the item toggled.
+ */
+export declare function toggle<T>(array: T[], item: T, selector?: (item: T) => Primitive, options?: {
+    strategy?: 'prepend' | 'append';
+}): T[];
+//# sourceMappingURL=toggle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toggle.d.ts","sourceRoot":"","sources":["../../src/array/toggle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,CAAC,EAAE,EACV,IAAI,EAAE,CAAC,EACP,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,SAAS,EACjC,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAA;CAAO,GAChD,CAAC,EAAE,CAWL"}

package/dist/array/toggle.js

@@ -0,0 +1,9 @@
+//#region src/array/toggle.ts
+function e(e, t, n, r = {}) {
+	let { strategy: i = "append" } = r, a = n ? (e) => n(e) === n(t) : (e) => e === t, o = e.findIndex(a);
+	return o === -1 ? i === "prepend" ? [t, ...e] : [...e, t] : [...e.slice(0, o), ...e.slice(o + 1)];
+}
+//#endregion
+export { e as toggle };
+
+//# sourceMappingURL=toggle.js.map

package/dist/array/toggle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toggle.js","names":[],"sources":["../../src/array/toggle.ts"],"sourcesContent":["import type { Primitive } from '../types';\n\n/**\n * Either adds or removes an item from an array, based on whether it already\n * exists in the array (toggle behaviour).\n *\n * @example\n * ```ts\n * toggle([1, 2, 3], 4) // [1, 2, 3, 4]\n * toggle([1, 2, 3], 2) // [1, 3]\n *\n * toggle(\n *   [{ id: 1 }, { id: 2 }],\n *   { id: 3 },\n *   (obj) => obj.id,\n *   { strategy: 'prepend' }\n * ) // [{ id: 3 }, { id: 1 }, { id: 2 }]\n * ```\n *\n * @param array - The array to modify.\n * @param item - The item to add or remove.\n * @param selector - A function to determine item identity.\n * @param [options] - Options for the toggle operation.\n * @param [options.strategy] - Where to insert when adding: 'prepend' or 'append' (default).\n * @returns A new array with the item toggled.\n */\nexport function toggle<T>(\n  array: T[],\n  item: T,\n  selector?: (item: T) => Primitive,\n  options: { strategy?: 'prepend' | 'append' } = {},\n): T[] {\n  const { strategy = 'append' } = options;\n  const compareFn = selector ? (el: T) => selector(el) === selector(item) : (el: T) => el === item;\n\n  const index = array.findIndex(compareFn);\n\n  if (index !== -1) {\n    return [...array.slice(0, index), ...array.slice(index + 1)];\n  }\n\n  return strategy === 'prepend' ? [item, ...array] : [...array, item];\n}\n"],"mappings":";AA0BA,SAAgB,EACd,GACA,GACA,GACA,IAA+C,EAAE,EAC5C;CACL,IAAM,EAAE,cAAW,aAAa,GAC1B,IAAY,KAAY,MAAU,EAAS,EAAG,KAAK,EAAS,EAAK,IAAI,MAAU,MAAO,GAEtF,IAAQ,EAAM,UAAU,EAAU;AAMxC,QAJI,MAAU,KAIP,MAAa,YAAY,CAAC,GAAM,GAAG,EAAM,GAAG,CAAC,GAAG,GAAO,EAAK,GAH1D,CAAC,GAAG,EAAM,MAAM,GAAG,EAAM,EAAE,GAAG,EAAM,MAAM,IAAQ,EAAE,CAAC"}

package/dist/array/uniq.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("../function/assert.cjs"),i=require("../typed/isArray.cjs");function s(e,t){if(o.assert(i.isArray(e),i.IS_ARRAY_ERROR_MSG,{type:TypeError}),e.length<=1)return[...e];if(!t)return[...new Set(e)];const r=new Map,f=typeof t=="function"?t:n=>n[t];return e.filter(n=>{const u=f(n);return r.has(u)?!1:(r.set(u,n),!0)})}s.fp=!0;exports.uniq=s;
-//# sourceMappingURL=uniq.cjs.map
+const e=require(`../function/assert.cjs`),t=require(`../typed/isArray.cjs`);function n(n,r){if(e.assert(t.isArray(n),t.IS_ARRAY_ERROR_MSG,{type:TypeError}),n.length<=1)return[...n];if(!r)return[...new Set(n)];let i=new Set,a=typeof r==`function`?r:e=>e[r];return n.filter(e=>{let t=a(e);return i.has(t)?!1:(i.add(t),!0)})}exports.uniq=n;
+//# sourceMappingURL=uniq.cjs.map

package/dist/array/uniq.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"uniq.cjs","sources":["../../src/array/uniq.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport type { Primitive, Selector } from '../types';\n\n/**\n * Creates a new array with duplicate values removed.\n *\n * @example\n * ```ts\n * uniq([1, 2, 2, 3, 3, 3]); // [1, 2, 3]\n * const arrObj = [{ id: 1 }, { id: 2 }, { id: 2 }, { id: 3 }, { id: 3 }, { id: 3 }];\n * uniq(arrObj, 'id'); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * uniq(arrObj, item => item.id); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * ```\n *\n * @param array - The array to process.\n * @param [selector] - The key(s) to compare objects or a function to generate comparison values.\n\n * @returns A new duplicate-free array.\n\n * @throws {TypeError} - If the input is not an array or if the key is invalid.\n */\nexport function uniq<T>(array: T[], selector?: Selector<T>): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { type: TypeError });\n\n  if (array.length <= 1) {\n    return [...array];\n  }\n\n  if (!selector) {\n    return [...new Set(array)];\n  }\n\n  const seen = new Map<Primitive, T>();\n  const getKey = typeof selector === 'function' ? selector : (item: T) => item[selector];\n\n  return array.filter((item) => {\n    const key = getKey(item) as Primitive;\n    if (seen.has(key)) {\n      return false;\n    }\n    seen.set(key, item);\n    return true;\n  });\n}\n\nuniq.fp = true;\n"],"names":["uniq","array","selector","assert","isArray","IS_ARRAY_ERROR_MSG","seen","getKey","item","key"],"mappings":"4JAsBO,SAASA,EAAQC,EAAYC,EAA6B,CAG/D,GAFAC,EAAAA,OAAOC,EAAAA,QAAQH,CAAK,EAAGI,EAAAA,mBAAoB,CAAE,KAAM,UAAW,EAE1DJ,EAAM,QAAU,EAClB,MAAO,CAAC,GAAGA,CAAK,EAGlB,GAAI,CAACC,EACH,MAAO,CAAC,GAAG,IAAI,IAAID,CAAK,CAAC,EAG3B,MAAMK,MAAW,IACXC,EAAS,OAAOL,GAAa,WAAaA,EAAYM,GAAYA,EAAKN,CAAQ,EAErF,OAAOD,EAAM,OAAQO,GAAS,CAC5B,MAAMC,EAAMF,EAAOC,CAAI,EACvB,OAAIF,EAAK,IAAIG,CAAG,EACP,IAETH,EAAK,IAAIG,EAAKD,CAAI,EACX,GACT,CAAC,CACH,CAEAR,EAAK,GAAK"}
+{"version":3,"file":"uniq.cjs","names":[],"sources":["../../src/array/uniq.ts"],"sourcesContent":["import type { Primitive, Selector } from '../types';\n\nimport { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Creates a new array with duplicate values removed.\n *\n * @example\n * ```ts\n * uniq([1, 2, 2, 3, 3, 3]); // [1, 2, 3]\n * const arrObj = [{ id: 1 }, { id: 2 }, { id: 2 }, { id: 3 }, { id: 3 }, { id: 3 }];\n * uniq(arrObj, 'id'); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * uniq(arrObj, item => item.id); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * ```\n *\n * @param array - The array to process.\n * @param [selector] - The key(s) to compare objects or a function to generate comparison values.\n\n * @returns A new duplicate-free array.\n\n * @throws {TypeError} - If the input is not an array or if the key is invalid.\n */\nexport function uniq<T>(array: T[], selector?: Selector<T>): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { type: TypeError });\n\n  if (array.length <= 1) {\n    return [...array];\n  }\n\n  if (!selector) {\n    return [...new Set(array)];\n  }\n\n  const seen = new Set<Primitive>();\n  const getKey = typeof selector === 'function' ? selector : (item: T) => item[selector];\n\n  return array.filter((item) => {\n    const key = getKey(item) as Primitive;\n\n    if (seen.has(key)) {\n      return false;\n    }\n\n    seen.add(key);\n\n    return true;\n  });\n}\n"],"mappings":"4EAuBA,SAAgB,EAAQ,EAAY,EAA6B,CAG/D,GAFA,EAAA,OAAO,EAAA,QAAQ,EAAM,CAAE,EAAA,mBAAoB,CAAE,KAAM,UAAW,CAAC,CAE3D,EAAM,QAAU,EAClB,MAAO,CAAC,GAAG,EAAM,CAGnB,GAAI,CAAC,EACH,MAAO,CAAC,GAAG,IAAI,IAAI,EAAM,CAAC,CAG5B,IAAM,EAAO,IAAI,IACX,EAAS,OAAO,GAAa,WAAa,EAAY,GAAY,EAAK,GAE7E,OAAO,EAAM,OAAQ,GAAS,CAC5B,IAAM,EAAM,EAAO,EAAK,CAQxB,OANI,EAAK,IAAI,EAAI,CACR,IAGT,EAAK,IAAI,EAAI,CAEN,KACP"}

package/dist/array/uniq.d.ts

@@ -0,0 +1,21 @@
+import type { Selector } from '../types';
+/**
+ * Creates a new array with duplicate values removed.
+ *
+ * @example
+ * ```ts
+ * uniq([1, 2, 2, 3, 3, 3]); // [1, 2, 3]
+ * const arrObj = [{ id: 1 }, { id: 2 }, { id: 2 }, { id: 3 }, { id: 3 }, { id: 3 }];
+ * uniq(arrObj, 'id'); // [{ id: 1 }, { id: 2 }, { id: 3 }]
+ * uniq(arrObj, item => item.id); // [{ id: 1 }, { id: 2 }, { id: 3 }]
+ * ```
+ *
+ * @param array - The array to process.
+ * @param [selector] - The key(s) to compare objects or a function to generate comparison values.
+
+ * @returns A new duplicate-free array.
+
+ * @throws {TypeError} - If the input is not an array or if the key is invalid.
+ */
+export declare function uniq<T>(array: T[], selector?: Selector<T>): T[];
+//# sourceMappingURL=uniq.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uniq.d.ts","sourceRoot":"","sources":["../../src/array/uniq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,QAAQ,EAAE,MAAM,UAAU,CAAC;AAKpD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAyB/D"}

package/dist/array/uniq.js

@@ -1,18 +1,16 @@
-import { assert as i } from "../function/assert.js";
-import { IS_ARRAY_ERROR_MSG as o, isArray as p } from "../typed/isArray.js";
-function s(t, e) {
-  if (i(p(t), o, { type: TypeError }), t.length <= 1)
-    return [...t];
-  if (!e)
-    return [...new Set(t)];
-  const r = /* @__PURE__ */ new Map(), u = typeof e == "function" ? e : (n) => n[e];
-  return t.filter((n) => {
-    const f = u(n);
-    return r.has(f) ? !1 : (r.set(f, n), !0);
-  });
+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/uniq.ts
+function r(r, i) {
+	if (e(n(r), t, { type: TypeError }), r.length <= 1) return [...r];
+	if (!i) return [...new Set(r)];
+	let a = /* @__PURE__ */ new Set(), o = typeof i == "function" ? i : (e) => e[i];
+	return r.filter((e) => {
+		let t = o(e);
+		return a.has(t) ? !1 : (a.add(t), !0);
+	});
 }
-s.fp = !0;
-export {
-  s as uniq
-};
-//# sourceMappingURL=uniq.js.map
+//#endregion
+export { r as uniq };
+
+//# sourceMappingURL=uniq.js.map

package/dist/array/uniq.js.map

@@ -1 +1 @@
-{"version":3,"file":"uniq.js","sources":["../../src/array/uniq.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport type { Primitive, Selector } from '../types';\n\n/**\n * Creates a new array with duplicate values removed.\n *\n * @example\n * ```ts\n * uniq([1, 2, 2, 3, 3, 3]); // [1, 2, 3]\n * const arrObj = [{ id: 1 }, { id: 2 }, { id: 2 }, { id: 3 }, { id: 3 }, { id: 3 }];\n * uniq(arrObj, 'id'); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * uniq(arrObj, item => item.id); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * ```\n *\n * @param array - The array to process.\n * @param [selector] - The key(s) to compare objects or a function to generate comparison values.\n\n * @returns A new duplicate-free array.\n\n * @throws {TypeError} - If the input is not an array or if the key is invalid.\n */\nexport function uniq<T>(array: T[], selector?: Selector<T>): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { type: TypeError });\n\n  if (array.length <= 1) {\n    return [...array];\n  }\n\n  if (!selector) {\n    return [...new Set(array)];\n  }\n\n  const seen = new Map<Primitive, T>();\n  const getKey = typeof selector === 'function' ? selector : (item: T) => item[selector];\n\n  return array.filter((item) => {\n    const key = getKey(item) as Primitive;\n    if (seen.has(key)) {\n      return false;\n    }\n    seen.set(key, item);\n    return true;\n  });\n}\n\nuniq.fp = true;\n"],"names":["uniq","array","selector","assert","isArray","IS_ARRAY_ERROR_MSG","seen","getKey","item","key"],"mappings":";;AAsBO,SAASA,EAAQC,GAAYC,GAA6B;AAG/D,MAFAC,EAAOC,EAAQH,CAAK,GAAGI,GAAoB,EAAE,MAAM,WAAW,GAE1DJ,EAAM,UAAU;AAClB,WAAO,CAAC,GAAGA,CAAK;AAGlB,MAAI,CAACC;AACH,WAAO,CAAC,GAAG,IAAI,IAAID,CAAK,CAAC;AAG3B,QAAMK,wBAAW,IAAA,GACXC,IAAS,OAAOL,KAAa,aAAaA,IAAW,CAACM,MAAYA,EAAKN,CAAQ;AAErF,SAAOD,EAAM,OAAO,CAACO,MAAS;AAC5B,UAAMC,IAAMF,EAAOC,CAAI;AACvB,WAAIF,EAAK,IAAIG,CAAG,IACP,MAETH,EAAK,IAAIG,GAAKD,CAAI,GACX;AAAA,EACT,CAAC;AACH;AAEAR,EAAK,KAAK;"}
+{"version":3,"file":"uniq.js","names":[],"sources":["../../src/array/uniq.ts"],"sourcesContent":["import type { Primitive, Selector } from '../types';\n\nimport { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Creates a new array with duplicate values removed.\n *\n * @example\n * ```ts\n * uniq([1, 2, 2, 3, 3, 3]); // [1, 2, 3]\n * const arrObj = [{ id: 1 }, { id: 2 }, { id: 2 }, { id: 3 }, { id: 3 }, { id: 3 }];\n * uniq(arrObj, 'id'); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * uniq(arrObj, item => item.id); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * ```\n *\n * @param array - The array to process.\n * @param [selector] - The key(s) to compare objects or a function to generate comparison values.\n\n * @returns A new duplicate-free array.\n\n * @throws {TypeError} - If the input is not an array or if the key is invalid.\n */\nexport function uniq<T>(array: T[], selector?: Selector<T>): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { type: TypeError });\n\n  if (array.length <= 1) {\n    return [...array];\n  }\n\n  if (!selector) {\n    return [...new Set(array)];\n  }\n\n  const seen = new Set<Primitive>();\n  const getKey = typeof selector === 'function' ? selector : (item: T) => item[selector];\n\n  return array.filter((item) => {\n    const key = getKey(item) as Primitive;\n\n    if (seen.has(key)) {\n      return false;\n    }\n\n    seen.add(key);\n\n    return true;\n  });\n}\n"],"mappings":";;;AAuBA,SAAgB,EAAQ,GAAY,GAA6B;AAG/D,KAFA,EAAO,EAAQ,EAAM,EAAE,GAAoB,EAAE,MAAM,WAAW,CAAC,EAE3D,EAAM,UAAU,EAClB,QAAO,CAAC,GAAG,EAAM;AAGnB,KAAI,CAAC,EACH,QAAO,CAAC,GAAG,IAAI,IAAI,EAAM,CAAC;CAG5B,IAAM,oBAAO,IAAI,KAAgB,EAC3B,IAAS,OAAO,KAAa,aAAa,KAAY,MAAY,EAAK;AAE7E,QAAO,EAAM,QAAQ,MAAS;EAC5B,IAAM,IAAM,EAAO,EAAK;AAQxB,SANI,EAAK,IAAI,EAAI,GACR,MAGT,EAAK,IAAI,EAAI,EAEN;GACP"}