es-toolkit 1.0.3 → 1.0.4-dev.39

package/dist/array/union.mjs

@@ -0,0 +1,9 @@
+import {
+  union
+} from "../chunk-RLDY4N3Q.mjs";
+import "../chunk-QRQPLMV4.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  union
+};
+//# sourceMappingURL=union.mjs.map

package/dist/array/union.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/{esm/array/unionBy.mjs → dist/array/unionBy.d.mts}

@@ -1,35 +1,23 @@
-import { toConsumableArray as _toConsumableArray } from './_virtual/_rollupPluginBabelHelpers.mjs';
-
 /**
  * Creates an array of unique values, in order, from all given arrays using a provided mapping function to determine equality.
- * 
+ *
  * @param {T[]} arr1 - The first array.
  * @param {T[]} arr2 - The second array.
  * @param {function(item: T): U} mapper - The function to map array elements to comparison values.
  * @returns {T[]} A new array containing the union of unique elements from `arr1` and `arr2`, based on the values returned by the mapping function.
- * 
+ *
  * @example
  * // Custom mapping function for numbers (modulo comparison)
  * const moduloMapper = (x) => x % 3;
  * unionBy([1, 2, 3], [4, 5, 6], moduloMapper);
  * // Returns [1, 2, 3]
- * 
+ *
  * @example
  * // Custom mapping function for objects with an 'id' property
  * const idMapper = (obj) => obj.id;
  * unionBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);
  * // Returns [{ id: 1 }, { id: 2 }, { id: 3 }]
  */
-function unionBy(arr1, arr2, mapper) {
-  var map = new Map();
-  for (var _i = 0, _arr = [].concat(_toConsumableArray(arr1), _toConsumableArray(arr2)); _i < _arr.length; _i++) {
-    var item = _arr[_i];
-    var key = mapper(item);
-    if (!map.has(key)) {
-      map.set(key, item);
-    }
-  }
-  return _toConsumableArray(map.values());
-}
+declare function unionBy<T, U>(arr1: T[], arr2: T[], mapper: (item: T) => U): T[];
 
 export { unionBy };

package/dist/array/unionBy.d.ts

@@ -18,4 +18,6 @@
  * unionBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);
  * // Returns [{ id: 1 }, { id: 2 }, { id: 3 }]
  */
-export declare function unionBy<T, U>(arr1: T[], arr2: T[], mapper: (item: T) => U): T[];
+declare function unionBy<T, U>(arr1: T[], arr2: T[], mapper: (item: T) => U): T[];
+
+export { unionBy };

package/dist/array/unionBy.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/array/unionBy.ts
+var unionBy_exports = {};
+__export(unionBy_exports, {
+  unionBy: () => unionBy
+});
+module.exports = __toCommonJS(unionBy_exports);
+function unionBy(arr1, arr2, mapper) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of [...arr1, ...arr2]) {
+    const key = mapper(item);
+    if (!map.has(key)) {
+      map.set(key, item);
+    }
+  }
+  return [...map.values()];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  unionBy
+});
+//# sourceMappingURL=unionBy.js.map

package/dist/array/unionBy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/unionBy.ts"],"sourcesContent":["/**\n * Creates an array of unique values, in order, from all given arrays using a provided mapping function to determine equality.\n * \n * @param {T[]} arr1 - The first array.\n * @param {T[]} arr2 - The second array.\n * @param {function(item: T): U} mapper - The function to map array elements to comparison values.\n * @returns {T[]} A new array containing the union of unique elements from `arr1` and `arr2`, based on the values returned by the mapping function.\n * \n * @example\n * // Custom mapping function for numbers (modulo comparison)\n * const moduloMapper = (x) => x % 3;\n * unionBy([1, 2, 3], [4, 5, 6], moduloMapper);\n * // Returns [1, 2, 3]\n * \n * @example\n * // Custom mapping function for objects with an 'id' property\n * const idMapper = (obj) => obj.id;\n * unionBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);\n * // Returns [{ id: 1 }, { id: 2 }, { id: 3 }]\n */\nexport function unionBy<T, U>(arr1: T[], arr2: T[], mapper: (item: T) => U): T[] {\n  const map = new Map<U, T>();\n\n  for (const item of [...arr1, ...arr2]) {\n    const key = mapper(item);\n    if (!map.has(key)) {\n      map.set(key, item);\n    }\n  }\n\n  return [...map.values()];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBO,SAAS,QAAc,MAAW,MAAW,QAA6B;AAC/E,QAAM,MAAM,oBAAI,IAAU;AAE1B,aAAW,QAAQ,CAAC,GAAG,MAAM,GAAG,IAAI,GAAG;AACrC,UAAM,MAAM,OAAO,IAAI;AACvB,QAAI,CAAC,IAAI,IAAI,GAAG,GAAG;AACjB,UAAI,IAAI,KAAK,IAAI;AAAA,IACnB;AAAA,EACF;AAEA,SAAO,CAAC,GAAG,IAAI,OAAO,CAAC;AACzB;","names":[]}

package/dist/array/unionBy.mjs

@@ -0,0 +1,8 @@
+import {
+  unionBy
+} from "../chunk-7PPND7QY.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  unionBy
+};
+//# sourceMappingURL=unionBy.mjs.map

package/dist/array/unionBy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/{esm/array/unionWith.mjs → dist/array/unionWith.d.mts}

@@ -1,14 +1,12 @@
-import { uniqWith } from './uniqWith.mjs';
-
 /**
  * Creates an array of unique values from two given arrays based on a custom equality function.
- * 
- * This function takes two arrays and a custom equality function, merges the arrays, and returns 
+ *
+ * This function takes two arrays and a custom equality function, merges the arrays, and returns
  * a new array containing only the unique values as determined by the custom equality function.
  *
  * @param {T[]} arr1 - The first array to merge and filter for unique values.
  * @param {T[]} arr2 - The second array to merge and filter for unique values.
- * @param {(item1: T, item2: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal. 
+ * @param {(item1: T, item2: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal.
  * It takes two arguments and returns `true` if the elements are considered equal, and `false` otherwise.
  * @returns {T[]} A new array of unique values based on the custom equality function.
  *
@@ -19,8 +17,6 @@ import { uniqWith } from './uniqWith.mjs';
  * const result = unionWith(array1, array2, areItemsEqual);
  * // result will be [{ id: 1 }, { id: 2 }, { id: 3 }] since { id: 2 } is considered equal in both arrays
  */
-function unionWith(arr1, arr2, areItemsEqual) {
-  return uniqWith(arr1.concat(arr2), areItemsEqual);
-}
+declare function unionWith<T>(arr1: T[], arr2: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[];
 
 export { unionWith };

package/dist/array/unionWith.d.ts

@@ -17,4 +17,6 @@
  * const result = unionWith(array1, array2, areItemsEqual);
  * // result will be [{ id: 1 }, { id: 2 }, { id: 3 }] since { id: 2 } is considered equal in both arrays
  */
-export declare function unionWith<T>(arr1: T[], arr2: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[];
+declare function unionWith<T>(arr1: T[], arr2: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[];
+
+export { unionWith };

package/dist/array/unionWith.js

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/array/unionWith.ts
+var unionWith_exports = {};
+__export(unionWith_exports, {
+  unionWith: () => unionWith
+});
+module.exports = __toCommonJS(unionWith_exports);
+
+// src/array/uniqWith.ts
+function uniqWith(arr, areItemsEqual) {
+  const result = [];
+  for (const item of arr) {
+    const isUniq = result.every((v) => !areItemsEqual(v, item));
+    if (isUniq) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+
+// src/array/unionWith.ts
+function unionWith(arr1, arr2, areItemsEqual) {
+  return uniqWith(arr1.concat(arr2), areItemsEqual);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  unionWith
+});
+//# sourceMappingURL=unionWith.js.map

package/dist/array/unionWith.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/unionWith.ts","../../src/array/uniqWith.ts"],"sourcesContent":["import { uniqWith } from \"./uniqWith\";\n\n/**\n * Creates an array of unique values from two given arrays based on a custom equality function.\n * \n * This function takes two arrays and a custom equality function, merges the arrays, and returns \n * a new array containing only the unique values as determined by the custom equality function.\n *\n * @param {T[]} arr1 - The first array to merge and filter for unique values.\n * @param {T[]} arr2 - The second array to merge and filter for unique values.\n * @param {(item1: T, item2: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal. \n * It takes two arguments and returns `true` if the elements are considered equal, and `false` otherwise.\n * @returns {T[]} A new array of unique values based on the custom equality function.\n *\n * @example\n * const array1 = [{ id: 1 }, { id: 2 }];\n * const array2 = [{ id: 2 }, { id: 3 }];\n * const areItemsEqual = (a, b) => a.id === b.id;\n * const result = unionWith(array1, array2, areItemsEqual);\n * // result will be [{ id: 1 }, { id: 2 }, { id: 3 }] since { id: 2 } is considered equal in both arrays\n */\nexport function unionWith<T>(arr1: T[], arr2: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[] {\n  return uniqWith(arr1.concat(arr2), areItemsEqual);\n}\n","/**\n * The `uniqWith` function takes an array as its first argument and a 'comparator' function as the second.\n *\n * It evaluates the elements of the array using the comparator function, and if true is returned, it considers those elements as duplicates and removes them.\n *\n * @example\n * ```ts\n * uniqWith([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], (a, b) => Math.abs(a - b) < 1);\n * // [1, 2, 3, 5, 7]\n * ```\n */\nexport function uniqWith<T>(\n  arr: T[],\n  areItemsEqual: (item1: T, item2: T) => boolean\n): T[] {\n  const result: T[] = [];\n\n  for (const item of arr) {\n    const isUniq = result.every((v) => !areItemsEqual(v, item));\n\n    if (isUniq) {\n      result.push(item);\n    }\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACWO,SAAS,SACd,KACA,eACK;AACL,QAAM,SAAc,CAAC;AAErB,aAAW,QAAQ,KAAK;AACtB,UAAM,SAAS,OAAO,MAAM,CAAC,MAAM,CAAC,cAAc,GAAG,IAAI,CAAC;AAE1D,QAAI,QAAQ;AACV,aAAO,KAAK,IAAI;AAAA,IAClB;AAAA,EACF;AAEA,SAAO;AACT;;;ADLO,SAAS,UAAa,MAAW,MAAW,eAAqD;AACtG,SAAO,SAAS,KAAK,OAAO,IAAI,GAAG,aAAa;AAClD;","names":[]}

package/dist/array/unionWith.mjs

@@ -0,0 +1,9 @@
+import {
+  unionWith
+} from "../chunk-VJGGYY4Y.mjs";
+import "../chunk-EAI4DDCQ.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  unionWith
+};
+//# sourceMappingURL=unionWith.mjs.map

package/dist/array/unionWith.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/array/uniq.d.mts

@@ -0,0 +1,17 @@
+/**
+ * Creates a duplicate-free version of an array.
+ *
+ * This function takes an array and returns a new array containing only the unique values
+ * from the original array, preserving the order of first occurrence.
+ *
+ * @param {T[]} arr - The array to process.
+ * @returns {T[]} A new array with only unique values from the original array.
+ *
+ * @example
+ *  * const array = [1, 2, 2, 3, 4, 4, 5];
+ * const result = uniq(array);
+ * // result will be [1, 2, 3, 4, 5]
+ */
+declare function uniq<T>(arr: T[]): T[];
+
+export { uniq };

package/dist/array/uniq.d.ts

@@ -12,4 +12,6 @@
  * const result = uniq(array);
  * // result will be [1, 2, 3, 4, 5]
  */
-export declare function uniq<T>(arr: T[]): T[];
+declare function uniq<T>(arr: T[]): T[];
+
+export { uniq };

package/dist/array/uniq.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/array/uniq.ts
+var uniq_exports = {};
+__export(uniq_exports, {
+  uniq: () => uniq
+});
+module.exports = __toCommonJS(uniq_exports);
+function uniq(arr) {
+  const result = [];
+  for (const item of arr) {
+    if (result.includes(item)) {
+      continue;
+    }
+    result.push(item);
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  uniq
+});
+//# sourceMappingURL=uniq.js.map

package/dist/array/uniq.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/uniq.ts"],"sourcesContent":["/**\n * Creates a duplicate-free version of an array.\n * \n * This function takes an array and returns a new array containing only the unique values \n * from the original array, preserving the order of first occurrence.\n *\n * @param {T[]} arr - The array to process.\n * @returns {T[]} A new array with only unique values from the original array.\n *\n * @example\n *  * const array = [1, 2, 2, 3, 4, 4, 5];\n * const result = uniq(array);\n * // result will be [1, 2, 3, 4, 5]\n */\nexport function uniq<T>(arr: T[]): T[] {\n  const result: T[] = [];\n\n  for (const item of arr) {\n    if (result.includes(item)) {\n      continue;\n    }\n\n    result.push(item);\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAcO,SAAS,KAAQ,KAAe;AACrC,QAAM,SAAc,CAAC;AAErB,aAAW,QAAQ,KAAK;AACtB,QAAI,OAAO,SAAS,IAAI,GAAG;AACzB;AAAA,IACF;AAEA,WAAO,KAAK,IAAI;AAAA,EAClB;AAEA,SAAO;AACT;","names":[]}

package/dist/array/uniq.mjs

@@ -0,0 +1,8 @@
+import {
+  uniq
+} from "../chunk-QRQPLMV4.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  uniq
+};
+//# sourceMappingURL=uniq.mjs.map

package/dist/array/uniq.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/{esm/array/uniqBy.mjs → dist/array/uniqBy.d.mts}

@@ -1,5 +1,3 @@
-import { uniqWith } from './uniqWith.mjs';
-
 /**
  * The `uniqBy` function takes an array as its first argument and a 'converter' function as the second. It maps the array elements using the converter function, then removes any duplicates.
  *
@@ -11,10 +9,6 @@ import { uniqWith } from './uniqWith.mjs';
  * // [1.2, 2.1, 3.3, 5.7, 7.19]
  * ```
  */
-function uniqBy(arr, converter) {
-  return uniqWith(arr, function (item1, item2) {
-    return converter(item1) === converter(item2);
-  });
-}
+declare function uniqBy<T, U>(arr: T[], converter: (item: T) => U): T[];
 
 export { uniqBy };

package/dist/array/uniqBy.d.ts

@@ -9,4 +9,6 @@
  * // [1.2, 2.1, 3.3, 5.7, 7.19]
  * ```
  */
-export declare function uniqBy<T, U>(arr: T[], converter: (item: T) => U): T[];
+declare function uniqBy<T, U>(arr: T[], converter: (item: T) => U): T[];
+
+export { uniqBy };

package/dist/array/uniqBy.js

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/array/uniqBy.ts
+var uniqBy_exports = {};
+__export(uniqBy_exports, {
+  uniqBy: () => uniqBy
+});
+module.exports = __toCommonJS(uniqBy_exports);
+
+// src/array/uniqWith.ts
+function uniqWith(arr, areItemsEqual) {
+  const result = [];
+  for (const item of arr) {
+    const isUniq = result.every((v) => !areItemsEqual(v, item));
+    if (isUniq) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+
+// src/array/uniqBy.ts
+function uniqBy(arr, converter) {
+  return uniqWith(arr, (item1, item2) => converter(item1) === converter(item2));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  uniqBy
+});
+//# sourceMappingURL=uniqBy.js.map

package/dist/array/uniqBy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/uniqBy.ts","../../src/array/uniqWith.ts"],"sourcesContent":["import { uniqWith } from \"./uniqWith\";\n\n/**\n * The `uniqBy` function takes an array as its first argument and a 'converter' function as the second. It maps the array elements using the converter function, then removes any duplicates.\n *\n * It filters out elements with the same value, meaning it does not check for duplicates in data types like Objects.\n *\n * @example\n * ```ts\n * uniqBy([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], Math.floor);\n * // [1.2, 2.1, 3.3, 5.7, 7.19]\n * ```\n */\nexport function uniqBy<T, U>(arr: T[], converter: (item: T) => U): T[] {\n  return uniqWith(arr, (item1, item2) => converter(item1) === converter(item2));\n}\n","/**\n * The `uniqWith` function takes an array as its first argument and a 'comparator' function as the second.\n *\n * It evaluates the elements of the array using the comparator function, and if true is returned, it considers those elements as duplicates and removes them.\n *\n * @example\n * ```ts\n * uniqWith([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], (a, b) => Math.abs(a - b) < 1);\n * // [1, 2, 3, 5, 7]\n * ```\n */\nexport function uniqWith<T>(\n  arr: T[],\n  areItemsEqual: (item1: T, item2: T) => boolean\n): T[] {\n  const result: T[] = [];\n\n  for (const item of arr) {\n    const isUniq = result.every((v) => !areItemsEqual(v, item));\n\n    if (isUniq) {\n      result.push(item);\n    }\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACWO,SAAS,SACd,KACA,eACK;AACL,QAAM,SAAc,CAAC;AAErB,aAAW,QAAQ,KAAK;AACtB,UAAM,SAAS,OAAO,MAAM,CAAC,MAAM,CAAC,cAAc,GAAG,IAAI,CAAC;AAE1D,QAAI,QAAQ;AACV,aAAO,KAAK,IAAI;AAAA,IAClB;AAAA,EACF;AAEA,SAAO;AACT;;;ADbO,SAAS,OAAa,KAAU,WAAgC;AACrE,SAAO,SAAS,KAAK,CAAC,OAAO,UAAU,UAAU,KAAK,MAAM,UAAU,KAAK,CAAC;AAC9E;","names":[]}

package/dist/array/uniqBy.mjs

@@ -0,0 +1,9 @@
+import {
+  uniqBy
+} from "../chunk-JMLFPGZ3.mjs";
+import "../chunk-EAI4DDCQ.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  uniqBy
+};
+//# sourceMappingURL=uniqBy.mjs.map

package/dist/array/uniqBy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/array/uniqWith.d.mts

@@ -0,0 +1,14 @@
+/**
+ * The `uniqWith` function takes an array as its first argument and a 'comparator' function as the second.
+ *
+ * It evaluates the elements of the array using the comparator function, and if true is returned, it considers those elements as duplicates and removes them.
+ *
+ * @example
+ * ```ts
+ * uniqWith([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], (a, b) => Math.abs(a - b) < 1);
+ * // [1, 2, 3, 5, 7]
+ * ```
+ */
+declare function uniqWith<T>(arr: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[];
+
+export { uniqWith };

package/dist/array/uniqWith.d.ts

@@ -9,4 +9,6 @@
  * // [1, 2, 3, 5, 7]
  * ```
  */
-export declare function uniqWith<T>(arr: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[];
+declare function uniqWith<T>(arr: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[];
+
+export { uniqWith };

package/dist/array/uniqWith.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/array/uniqWith.ts
+var uniqWith_exports = {};
+__export(uniqWith_exports, {
+  uniqWith: () => uniqWith
+});
+module.exports = __toCommonJS(uniqWith_exports);
+function uniqWith(arr, areItemsEqual) {
+  const result = [];
+  for (const item of arr) {
+    const isUniq = result.every((v) => !areItemsEqual(v, item));
+    if (isUniq) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  uniqWith
+});
+//# sourceMappingURL=uniqWith.js.map

package/dist/array/uniqWith.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/uniqWith.ts"],"sourcesContent":["/**\n * The `uniqWith` function takes an array as its first argument and a 'comparator' function as the second.\n *\n * It evaluates the elements of the array using the comparator function, and if true is returned, it considers those elements as duplicates and removes them.\n *\n * @example\n * ```ts\n * uniqWith([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], (a, b) => Math.abs(a - b) < 1);\n * // [1, 2, 3, 5, 7]\n * ```\n */\nexport function uniqWith<T>(\n  arr: T[],\n  areItemsEqual: (item1: T, item2: T) => boolean\n): T[] {\n  const result: T[] = [];\n\n  for (const item of arr) {\n    const isUniq = result.every((v) => !areItemsEqual(v, item));\n\n    if (isUniq) {\n      result.push(item);\n    }\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWO,SAAS,SACd,KACA,eACK;AACL,QAAM,SAAc,CAAC;AAErB,aAAW,QAAQ,KAAK;AACtB,UAAM,SAAS,OAAO,MAAM,CAAC,MAAM,CAAC,cAAc,GAAG,IAAI,CAAC;AAE1D,QAAI,QAAQ;AACV,aAAO,KAAK,IAAI;AAAA,IAClB;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/array/uniqWith.mjs

@@ -0,0 +1,8 @@
+import {
+  uniqWith
+} from "../chunk-EAI4DDCQ.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  uniqWith
+};
+//# sourceMappingURL=uniqWith.mjs.map

package/dist/array/uniqWith.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/{esm/array/xor.mjs → dist/array/xor.d.mts}

@@ -1,25 +1,19 @@
-import { difference } from './difference.mjs';
-import { intersection } from './intersection.mjs';
-import { union } from './union.mjs';
-
 /**
  * Computes the symmetric difference between two arrays. The symmetric difference is the set of elements
  * which are in either of the arrays, but not in their intersection.
- * 
+ *
  * @param {T[]} arr1 - The first array.
  * @param {T[]} arr2 - The second array.
  * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both.
- * 
+ *
  * @example
  * // Returns [1, 2, 5, 6]
  * xor([1, 2, 3, 4], [3, 4, 5, 6]);
- * 
+ *
  * @example
  * // Returns ['a', 'c']
  * xor(['a', 'b'], ['b', 'c']);
  */
-function xor(arr1, arr2) {
-  return difference(union(arr1, arr2), intersection(arr1, arr2));
-}
+declare function xor<T>(arr1: T[], arr2: T[]): T[];
 
 export { xor };

package/dist/array/xor.d.ts

@@ -14,4 +14,6 @@
  * // Returns ['a', 'c']
  * xor(['a', 'b'], ['b', 'c']);
  */
-export declare function xor<T>(arr1: T[], arr2: T[]): T[];
+declare function xor<T>(arr1: T[], arr2: T[]): T[];
+
+export { xor };

package/dist/array/xor.js

@@ -0,0 +1,66 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/array/xor.ts
+var xor_exports = {};
+__export(xor_exports, {
+  xor: () => xor
+});
+module.exports = __toCommonJS(xor_exports);
+
+// src/array/difference.ts
+function difference(firstArr, secondArr) {
+  return firstArr.filter((item) => {
+    return !secondArr.includes(item);
+  });
+}
+
+// src/array/intersection.ts
+function intersection(firstArr, secondArr) {
+  return firstArr.filter((item) => {
+    return secondArr.includes(item);
+  });
+}
+
+// src/array/uniq.ts
+function uniq(arr) {
+  const result = [];
+  for (const item of arr) {
+    if (result.includes(item)) {
+      continue;
+    }
+    result.push(item);
+  }
+  return result;
+}
+
+// src/array/union.ts
+function union(arr1, arr2) {
+  return uniq(arr1.concat(arr2));
+}
+
+// src/array/xor.ts
+function xor(arr1, arr2) {
+  return difference(union(arr1, arr2), intersection(arr1, arr2));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  xor
+});
+//# sourceMappingURL=xor.js.map

package/dist/array/xor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/xor.ts","../../src/array/difference.ts","../../src/array/intersection.ts","../../src/array/uniq.ts","../../src/array/union.ts"],"sourcesContent":["import { difference } from \"./difference\";\nimport { intersection } from \"./intersection\";\nimport { union } from \"./union\";\n\n/**\n * Computes the symmetric difference between two arrays. The symmetric difference is the set of elements\n * which are in either of the arrays, but not in their intersection.\n * \n * @param {T[]} arr1 - The first array.\n * @param {T[]} arr2 - The second array.\n * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both.\n * \n * @example\n * // Returns [1, 2, 5, 6]\n * xor([1, 2, 3, 4], [3, 4, 5, 6]);\n * \n * @example\n * // Returns ['a', 'c']\n * xor(['a', 'b'], ['b', 'c']);\n */\nexport function xor<T>(arr1: T[], arr2: T[]): T[] {\n  return difference(union(arr1, arr2), intersection(arr1, arr2));\n}","/**\n * Computes the difference between two arrays.\n * \n * This function takes two arrays and returns a new array containing the elements \n * that are present in the first array but not in the second array. It effectively \n * filters out any elements from the first array that also appear in the second array.\n *\n * @template T\n * @param {T[]} firstArr - The array from which to derive the difference. This is the primary array \n * from which elements will be compared and filtered.\n * @param {T[]} secondArr - The array containing elements to be excluded from the first array. \n * Each element in this array will be checked against the first array, and if a match is found, \n * that element will be excluded from the result.\n * @returns {T[]} A new array containing the elements that are present in the first array but not \n * in the second array.\n *\n * @example\n *  * const array1 = [1, 2, 3, 4, 5];\n * const array2 = [2, 4];\n * const result = difference(array1, array2);\n * // result will be [1, 3, 5] since 2 and 4 are in both arrays and are excluded from the result.\n */\nexport function difference<T>(firstArr: T[], secondArr: T[]): T[] {\n  return firstArr.filter(item => {\n    return !secondArr.includes(item)\n  });\n}","/**\n * Returns the intersection of two arrays.\n * \n * This function takes two arrays and returns a new array containing the elements that are \n * present in both arrays. It effectively filters out any elements from the first array that \n * are not found in the second array.\n *\n * @param {T[]} firstArr - The first array to compare.\n * @param {T[]} secondArr - The second array to compare.\n * @returns {T[]} A new array containing the elements that are present in both arrays.\n *\n * @example\n * const array1 = [1, 2, 3, 4, 5];\n * const array2 = [3, 4, 5, 6, 7];\n * const result = intersection(array1, array2);\n * // result will be [3, 4, 5] since these elements are in both arrays.\n */\nexport function intersection<T>(firstArr: T[], secondArr: T[]): T[] {\n  return firstArr.filter(item => {\n    return secondArr.includes(item);\n  });\n}\n","/**\n * Creates a duplicate-free version of an array.\n * \n * This function takes an array and returns a new array containing only the unique values \n * from the original array, preserving the order of first occurrence.\n *\n * @param {T[]} arr - The array to process.\n * @returns {T[]} A new array with only unique values from the original array.\n *\n * @example\n *  * const array = [1, 2, 2, 3, 4, 4, 5];\n * const result = uniq(array);\n * // result will be [1, 2, 3, 4, 5]\n */\nexport function uniq<T>(arr: T[]): T[] {\n  const result: T[] = [];\n\n  for (const item of arr) {\n    if (result.includes(item)) {\n      continue;\n    }\n\n    result.push(item);\n  }\n\n  return result;\n}\n","import { uniq } from \"./uniq\";\n\n/**\n * Creates an array of unique values from all given arrays.\n * \n * This function takes two arrays, merges them into a single array, and returns a new array \n * containing only the unique values from the merged array.\n *\n * @param {T[]} arr1 - The first array to merge and filter for unique values.\n * @param {T[]} arr2 - The second array to merge and filter for unique values.\n * @returns {T[]} A new array of unique values.\n *\n * @example\n * const array1 = [1, 2, 3];\n * const array2 = [3, 4, 5];\n * const result = union(array1, array2);\n * // result will be [1, 2, 3, 4, 5]\n */\nexport function union<T>(arr1: T[], arr2: T[]): T[] {\n  return uniq(arr1.concat(arr2));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACsBO,SAAS,WAAc,UAAe,WAAqB;AAChE,SAAO,SAAS,OAAO,UAAQ;AAC7B,WAAO,CAAC,UAAU,SAAS,IAAI;AAAA,EACjC,CAAC;AACH;;;ACTO,SAAS,aAAgB,UAAe,WAAqB;AAClE,SAAO,SAAS,OAAO,UAAQ;AAC7B,WAAO,UAAU,SAAS,IAAI;AAAA,EAChC,CAAC;AACH;;;ACPO,SAAS,KAAQ,KAAe;AACrC,QAAM,SAAc,CAAC;AAErB,aAAW,QAAQ,KAAK;AACtB,QAAI,OAAO,SAAS,IAAI,GAAG;AACzB;AAAA,IACF;AAEA,WAAO,KAAK,IAAI;AAAA,EAClB;AAEA,SAAO;AACT;;;ACRO,SAAS,MAAS,MAAW,MAAgB;AAClD,SAAO,KAAK,KAAK,OAAO,IAAI,CAAC;AAC/B;;;AJAO,SAAS,IAAO,MAAW,MAAgB;AAChD,SAAO,WAAW,MAAM,MAAM,IAAI,GAAG,aAAa,MAAM,IAAI,CAAC;AAC/D;","names":[]}

package/dist/array/xor.mjs

@@ -0,0 +1,12 @@
+import {
+  xor
+} from "../chunk-7OZZODAE.mjs";
+import "../chunk-RLDY4N3Q.mjs";
+import "../chunk-QRQPLMV4.mjs";
+import "../chunk-7GWOR247.mjs";
+import "../chunk-PTQLD7TG.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  xor
+};
+//# sourceMappingURL=xor.mjs.map

package/dist/array/xor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}