es-toolkit 1.0.3 → 1.0.4-dev.39

package/dist/array/index.js

@@ -1,562 +1,192 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-/**
- * Splits an array into smaller arrays of a specified length.
- *
- * This function takes an input array and divides it into multiple smaller arrays,
- * each of a specified length. If the input array cannot be evenly divided,
- * the final sub-array will contain the remaining elements.
- *
- * @template T The type of elements in the array.
- * @param {T[]} arr - The array to be chunked into smaller arrays.
- * @param {number} size - The size of each smaller array. Must be a positive integer.
- * @returns {T[][]} A two-dimensional array where each sub-array has a maximum length of `size`.
- * @throws {Error} Throws an error if `size` is not a positive integer.
- *
- * @example
- * // Splits an array of numbers into sub-arrays of length 2
- * chunk([1, 2, 3, 4, 5], 2);
- * // Returns: [[1, 2], [3, 4], [5]]
- *
- * @example
- * // Splits an array of strings into sub-arrays of length 3
- * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);
- * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
- */
+"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/index.ts
+var array_exports = {};
+__export(array_exports, {
+  chunk: () => chunk,
+  difference: () => difference,
+  differenceBy: () => differenceBy,
+  differenceWith: () => differenceWith,
+  drop: () => drop,
+  dropRight: () => dropRight,
+  dropRightWhile: () => dropRightWhile,
+  dropWhile: () => dropWhile,
+  groupBy: () => groupBy,
+  intersection: () => intersection,
+  intersectionBy: () => intersectionBy,
+  intersectionWith: () => intersectionWith,
+  partition: () => partition,
+  sample: () => sample,
+  shuffle: () => shuffle,
+  take: () => take,
+  takeRight: () => takeRight,
+  takeRightWhile: () => takeRightWhile,
+  takeWhile: () => takeWhile,
+  union: () => union,
+  unionBy: () => unionBy,
+  unionWith: () => unionWith,
+  uniq: () => uniq,
+  uniqBy: () => uniqBy,
+  uniqWith: () => uniqWith,
+  xor: () => xor,
+  xorBy: () => xorBy,
+  xorWith: () => xorWith,
+  zip: () => zip,
+  zipWith: () => zipWith
+});
+module.exports = __toCommonJS(array_exports);
+
+// src/array/chunk.ts
 function chunk(arr, size) {
   if (!Number.isInteger(size) || size <= 0) {
-    throw new Error('Size must be an integer greater than zero.');
+    throw new Error("Size must be an integer greater than zero.");
   }
-  var chunkLength = Math.ceil(arr.length / size);
-  var result = Array(chunkLength);
-  for (var index = 0; index < chunkLength; index++) {
-    var start = index * size;
-    var end = start + size;
+  const chunkLength = Math.ceil(arr.length / size);
+  const result = Array(chunkLength);
+  for (let index = 0; index < chunkLength; index++) {
+    const start = index * size;
+    const end = start + size;
     result[index] = arr.slice(start, end);
   }
   return result;
 }
 
-/**
- * Computes the difference between two arrays.
- * 
- * This function takes two arrays and returns a new array containing the elements 
- * that are present in the first array but not in the second array. It effectively 
- * filters out any elements from the first array that also appear in the second array.
- *
- * @template T
- * @param {T[]} firstArr - The array from which to derive the difference. This is the primary array 
- * from which elements will be compared and filtered.
- * @param {T[]} secondArr - The array containing elements to be excluded from the first array. 
- * Each element in this array will be checked against the first array, and if a match is found, 
- * that element will be excluded from the result.
- * @returns {T[]} A new array containing the elements that are present in the first array but not 
- * in the second array.
- *
- * @example
- *  * const array1 = [1, 2, 3, 4, 5];
- * const array2 = [2, 4];
- * const result = difference(array1, array2);
- * // result will be [1, 3, 5] since 2 and 4 are in both arrays and are excluded from the result.
- */
+// src/array/difference.ts
 function difference(firstArr, secondArr) {
-  return firstArr.filter(function (item) {
+  return firstArr.filter((item) => {
     return !secondArr.includes(item);
   });
 }
 
-/**
- * Computes the difference between two arrays after mapping their elements through a provided function.
- * 
- * This function takes two arrays and a mapper function. It returns a new array containing the elements 
- * that are present in the first array but not in the second array, based on the identity calculated 
- * by the mapper function. 
- * 
- * Essentially, it filters out any elements from the first array that, when 
- * mapped, match an element in the mapped version of the second array.
- *
- * @template T, U
- * @param {T[]} firstArr - The primary array from which to derive the difference. 
- * @param {T[]} secondArr - The array containing elements to be excluded from the first array.
- * @param {(value: T) => U} mapper - The function to map the elements of both arrays. This function 
- * is applied to each element in both arrays, and the comparison is made based on the mapped values.
- * @returns {T[]} A new array containing the elements from the first array that do not have a corresponding 
- * mapped identity in the second array.
- *
- * @example
- *  * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
- * const array2 = [{ id: 2 }, { id: 4 }];
- * const mapper = item => item.id;
- * const result = differenceBy(array1, array2, mapper);
- * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are in both arrays and are excluded from the result.
- */
+// src/array/differenceBy.ts
 function differenceBy(firstArr, secondArr, mapper) {
-  var mappedSecondArr = secondArr.map(function (item) {
-    return mapper(item);
-  });
-  return firstArr.filter(function (item) {
+  const mappedSecondArr = secondArr.map((item) => mapper(item));
+  return firstArr.filter((item) => {
     return !mappedSecondArr.includes(mapper(item));
   });
 }
 
-/**
- * Computes the difference between two arrays based on a custom equality function.
- * 
- * This function takes two arrays and a custom comparison function. It returns a new array containing 
- * the elements that are present in the first array but not in the second array. The comparison to determine 
- * if elements are equal is made using the provided custom function.
- *
- * @template T
- * @param {T[]} firstArr - The array from which to get the difference.
- * @param {T[]} secondArr - The array containing elements to exclude from the first array. 
- * @param {(x: T, y: T) => boolean} areItemsEqual - A function to determine if two items are equal.
- * @returns {T[]} A new array containing the elements from the first array that do not match any elements in the second array 
- * according to the custom equality function.
- *
- * @example
- *  * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
- * const array2 = [{ id: 2 }, { id: 4 }];
- * const areItemsEqual = (a, b) => a.id === b.id;
- * const result = differenceWith(array1, array2, areItemsEqual);
- * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are considered equal and are excluded from the result.
- */
+// src/array/differenceWith.ts
 function differenceWith(firstArr, secondArr, areItemsEqual) {
-  return firstArr.filter(function (firstItem) {
-    return secondArr.every(function (secondItem) {
+  return firstArr.filter((firstItem) => {
+    return secondArr.every((secondItem) => {
       return !areItemsEqual(firstItem, secondItem);
     });
   });
 }
 
-/**
- * Removes a specified number of elements from the beginning of an array and returns the rest.
- * 
- * This function takes an array and a number, and returns a new array with the specified number 
- * of elements removed from the start.
- *
- * @param {T[]} arr - The array from which to drop elements.
- * @param {number} itemsCount - The number of elements to drop from the beginning of the array.
- * @returns {T[]} A new array with the specified number of elements removed from the start.
- * 
- * @example
- *  * const array = [1, 2, 3, 4, 5];
- * const result = drop(array, 2);
- * // result will be [3, 4, 5] since the first two elements are dropped.
- */
+// src/array/drop.ts
 function drop(arr, itemsCount) {
   return arr.slice(itemsCount);
 }
 
-/**
- * Removes a specified number of elements from the end of an array and returns the rest.
- * 
- * This function takes an array and a number, and returns a new array with the specified number 
- * of elements removed from the end.
- *
- * @param {T[]} arr - The array from which to drop elements.
- * @param {number} itemsCount - The number of elements to drop from the end of the array.
- * @returns {T[]} A new array with the specified number of elements removed from the end.
- *
- * @example
- *  * const array = [1, 2, 3, 4, 5];
- * const result = dropRight(array, 2);
- * // result will be [1, 2, 3] since the last two elements are dropped.
- */
+// src/array/dropRight.ts
 function dropRight(arr, itemsCount) {
   return arr.slice(0, -itemsCount);
 }
 
-/**
- * Removes elements from the beginning of an array until the predicate returns false.
- * 
- * This function iterates over an array and drops elements from the start until the provided 
- * predicate function returns false. It then returns a new array with the remaining elements.
- *
- * @param {T[]} arr - The array from which to drop elements.
- * @param {(item: T) => boolean} canContinueDropping - A predicate function that determines 
- * whether to continue dropping elements. The function is called with each element, and dropping 
- * continues as long as it returns true.
- * @returns {T[]} A new array with the elements remaining after the predicate returns false.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * const result = dropWhile(array, x => x < 3);
- * // result will be [3, 4, 5] since elements less than 3 are dropped.
- */
+// src/array/dropWhile.ts
 function dropWhile(arr, canContinueDropping) {
-  var dropEndIndex = arr.findIndex(function (item) {
-    return !canContinueDropping(item);
-  });
+  const dropEndIndex = arr.findIndex((item) => !canContinueDropping(item));
   return arr.slice(dropEndIndex);
 }
 
-/**
- * Removes elements from the end of an array until the predicate returns false.
- * 
- * This function iterates over an array from the end and drops elements until the provided 
- * predicate function returns false. It then returns a new array with the remaining elements.
- *
- * @param {T[]} arr - The array from which to drop elements.
- * @param {function(item: T): boolean} canContinueDropping - A predicate function that determines 
- * whether to continue dropping elements. The function is called with each element from the end, 
- * and dropping continues as long as it returns true.
- * @returns {T[]} A new array with the elements remaining after the predicate returns false.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * const result = dropRightWhile(array, x => x > 3);
- * // result will be [1, 2, 3] since elements greater than 3 are dropped from the end.
- */
+// src/array/dropRightWhile.ts
 function dropRightWhile(arr, canContinueDropping) {
-  var reversed = arr.slice().reverse();
-  var dropped = dropWhile(reversed, canContinueDropping);
+  const reversed = arr.slice().reverse();
+  const dropped = dropWhile(reversed, canContinueDropping);
   return dropped.slice().reverse();
 }
 
-function _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-}
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-}
-function _iterableToArray(iter) {
-  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-  return arr2;
-}
-function _nonIterableSpread() {
-  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _createForOfIteratorHelper(o, allowArrayLike) {
-  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-  if (!it) {
-    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-      if (it) o = it;
-      var i = 0;
-      var F = function () {};
-      return {
-        s: F,
-        n: function () {
-          if (i >= o.length) return {
-            done: true
-          };
-          return {
-            done: false,
-            value: o[i++]
-          };
-        },
-        e: function (e) {
-          throw e;
-        },
-        f: F
-      };
-    }
-    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-  var normalCompletion = true,
-    didErr = false,
-    err;
-  return {
-    s: function () {
-      it = it.call(o);
-    },
-    n: function () {
-      var step = it.next();
-      normalCompletion = step.done;
-      return step;
-    },
-    e: function (e) {
-      didErr = true;
-      err = e;
-    },
-    f: function () {
-      try {
-        if (!normalCompletion && it.return != null) it.return();
-      } finally {
-        if (didErr) throw err;
-      }
-    }
-  };
-}
-
-/**
- * Groups the elements of an array based on a provided key-generating function.
- * 
- * This function takes an array and a function that generates a key from each element. It returns 
- * an object where the keys are the generated keys and the values are arrays of elements that share 
- * the same key.
- *
- * @param {T[]} arr - The array to group.
- * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.
- * @returns {Record<K, T[]>} An object where each key is associated with an array of elements that 
- * share that key.
- *
- * @example
- * const array = [
- *   { category: 'fruit', name: 'apple' },
- *   { category: 'fruit', name: 'banana' },
- *   { category: 'vegetable', name: 'carrot' }
- * ];
- * const result = groupBy(array, item => item.category);
- * // result will be:
- * // {
- * //   fruit: [
- * //     { category: 'fruit', name: 'apple' },
- * //     { category: 'fruit', name: 'banana' }
- * //   ],
- * //   vegetable: [
- * //     { category: 'vegetable', name: 'carrot' }
- * //   ]
- * // }
- */
+// src/array/groupBy.ts
 function groupBy(arr, getKeyFromItem) {
-  var result = {};
-  var _iterator = _createForOfIteratorHelper(arr),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var item = _step.value;
-      var key = getKeyFromItem(item);
-      if (result[key] == null) {
-        result[key] = [];
-      }
-      result[key].push(item);
+  const result = {};
+  for (const item of arr) {
+    const key = getKeyFromItem(item);
+    if (result[key] == null) {
+      result[key] = [];
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+    result[key].push(item);
   }
   return result;
 }
 
-/**
- * Returns the intersection of two arrays.
- * 
- * This function takes two arrays and returns a new array containing the elements that are 
- * present in both arrays. It effectively filters out any elements from the first array that 
- * are not found in the second array.
- *
- * @param {T[]} firstArr - The first array to compare.
- * @param {T[]} secondArr - The second array to compare.
- * @returns {T[]} A new array containing the elements that are present in both arrays.
- *
- * @example
- * const array1 = [1, 2, 3, 4, 5];
- * const array2 = [3, 4, 5, 6, 7];
- * const result = intersection(array1, array2);
- * // result will be [3, 4, 5] since these elements are in both arrays.
- */
+// src/array/intersection.ts
 function intersection(firstArr, secondArr) {
-  return firstArr.filter(function (item) {
+  return firstArr.filter((item) => {
     return secondArr.includes(item);
   });
 }
 
-/**
- * Returns the intersection of two arrays based on a mapping function.
- * 
- * This function takes two arrays and a mapping function. It returns a new array containing 
- * the elements from the first array that, when mapped using the provided function, have matching 
- * mapped elements in the second array. It effectively filters out any elements from the first array 
- * that do not have corresponding mapped values in the second array.
- *
- * @param {T[]} firstArr - The first array to compare.
- * @param {T[]} secondArr - The second array to compare.
- * @param {(item: T) => U} mapper - A function to map the elements of both arrays for comparison.
- * @returns {T[]} A new array containing the elements from the first array that have corresponding mapped values in the second array.
- *
- * @example
- * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
- * const array2 = [{ id: 2 }, { id: 4 }];
- * const mapper = item => item.id;
- * const result = intersectionBy(array1, array2, mapper);
- * // result will be [{ id: 2 }] since only this element has a matching id in both arrays.
- */
+// src/array/intersectionBy.ts
 function intersectionBy(firstArr, secondArr, mapper) {
-  var mappedSecondArr = secondArr.map(function (x) {
-    return mapper(x);
-  });
-  return firstArr.filter(function (item) {
+  const mappedSecondArr = secondArr.map((x) => mapper(x));
+  return firstArr.filter((item) => {
     return mappedSecondArr.includes(mapper(item));
   });
 }
 
-/**
- * Returns the intersection of two arrays based on a custom equality function.
- * 
- * This function takes two arrays and a custom equality function. It returns a new array containing 
- * the elements from the first array that have matching elements in the second array, as determined 
- * by the custom equality function. It effectively filters out any elements from the first array that 
- * do not have corresponding matches in the second array according to the equality function.
- *
- * @param {T[]} firstArr - The first array to compare.
- * @param {T[]} secondArr - The second array to compare.
- * @param {(x: T, y: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal. 
- * This function takes two arguments, one from each array, and returns `true` if the elements are considered equal, and `false` otherwise.
- * @returns {T[]} A new array containing the elements from the first array that have corresponding matches in the second array according to the custom equality function.
- *
- * @example
- *  * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
- * const array2 = [{ id: 2 }, { id: 4 }];
- * const areItemsEqual = (a, b) => a.id === b.id;
- * const result = intersectionWith(array1, array2, areItemsEqual);
- * // result will be [{ id: 2 }] since this element has a matching id in both arrays.
- */
+// src/array/intersectionWith.ts
 function intersectionWith(firstArr, secondArr, areItemsEqual) {
-  return firstArr.filter(function (firstItem) {
-    return secondArr.some(function (secondItem) {
+  return firstArr.filter((firstItem) => {
+    return secondArr.some((secondItem) => {
       return areItemsEqual(firstItem, secondItem);
     });
   });
 }
 
-/**
- * Splits an array into two groups based on a predicate function.
- * 
- * This function takes an array and a predicate function. It returns a tuple of two arrays: 
- * the first array contains elements for which the predicate function returns true, and 
- * the second array contains elements for which the predicate function returns false.
- *
- * @param {T[]} arr - The array to partition.
- * @param {(value: T) => boolean} isInTruthy - A predicate function that determines 
- * whether an element should be placed in the truthy array. The function is called with each 
- * element of the array.
- * @returns {[T[], T[]]} A tuple containing two arrays: the first array contains elements for 
- * which the predicate returned true, and the second array contains elements for which the 
- * predicate returned false.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * const isEven = x => x % 2 === 0;
- * const [even, odd] = partition(array, isEven);
- * // even will be [2, 4], and odd will be [1, 3, 5]
- */
+// src/array/partition.ts
 function partition(arr, isInTruthy) {
-  var truthy = [];
-  var falsy = [];
-  var _iterator = _createForOfIteratorHelper(arr),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var item = _step.value;
-      if (isInTruthy(item)) {
-        truthy.push(item);
-      } else {
-        falsy.push(item);
-      }
+  const truthy = [];
+  const falsy = [];
+  for (const item of arr) {
+    if (isInTruthy(item)) {
+      truthy.push(item);
+    } else {
+      falsy.push(item);
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
   }
   return [truthy, falsy];
 }
 
-/**
- * Returns a random element from an array.
- * 
- * This function takes an array and returns a single element selected randomly from the array.
- *
- * @param {T[]} arr - The array to sample from.
- * @returns {T} A random element from the array.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * const randomElement = sample(array);
- * // randomElement will be one of the elements from the array, selected randomly.
- */
+// src/array/sample.ts
 function sample(arr) {
-  var randomIndex = Math.floor(Math.random() * arr.length);
+  const randomIndex = Math.floor(Math.random() * arr.length);
   return arr[randomIndex];
 }
 
-/**
- * Randomizes the order of elements in an array using the Fisher-Yates algorithm.
- * 
- * This function takes an array and returns a new array with its elements shuffled in a random order.
- *
- * @param {T[]} arr - The array to shuffle.
- * @returns {T[]} A new array with its elements shuffled in random order.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * const shuffledArray = shuffle(array);
- * // shuffledArray will be a new array with elements of array in random order, e.g., [3, 1, 4, 5, 2]
- */
+// src/array/shuffle.ts
 function shuffle(arr) {
-  /**
-   * https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm
-   */
-  for (var i = arr.length - 1; i >= 1; i--) {
-    var j = Math.floor(Math.random() * (i + 1));
-    var _ref = [arr[j], arr[i]];
-    arr[i] = _ref[0];
-    arr[j] = _ref[1];
+  for (let i = arr.length - 1; i >= 1; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [arr[i], arr[j]] = [arr[j], arr[i]];
   }
   return arr;
 }
 
-/**
- * Returns a new array containing the first `count` elements from the input array `arr`.
- * If `count` is greater than the length of `arr`, the entire array is returned.
- *
- * @template T - Type of elements in the input array.
- * 
- * @param {T[]} arr - The array to take elements from.
- * @param {number} count - The number of elements to take.
- * @returns {T[]} A new array containing the first `count` elements from `arr`.
- * 
- * @example
- * // Returns [1, 2, 3]
- * take([1, 2, 3, 4, 5], 3);
- * 
- * @example
- * // Returns ['a', 'b']
- * take(['a', 'b', 'c'], 2);
- * 
- * @example
- * // Returns [1, 2, 3]
- * take([1, 2, 3], 5);
- */
+// src/array/take.ts
 function take(arr, count) {
   return arr.slice(0, count);
 }
 
-/**
- * Returns a new array containing the last `count` elements from the input array `arr`.
- * If `count` is greater than the length of `arr`, the entire array is returned.
- * 
- * @param {T[]} arr - The array to take elements from.
- * @param {number} count - The number of elements to take.
- * @returns {T[]} A new array containing the last `count` elements from `arr`.
- * 
- * @example
- * // Returns [4, 5]
- * takeRight([1, 2, 3, 4, 5], 2);
- * 
- * @example
- * // Returns ['b', 'c']
- * takeRight(['a', 'b', 'c'], 2);
- * 
- * @example
- * // Returns [1, 2, 3]
- * takeRight([1, 2, 3], 5);
- */
+// src/array/takeRight.ts
 function takeRight(arr, count) {
   if (count === 0) {
     return [];
@@ -564,25 +194,9 @@ function takeRight(arr, count) {
   return arr.slice(-count);
 }
 
-/**
- * Takes elements from the end of the array while the predicate function returns `true`.
- * 
- * @template T - Type of elements in the input array.
- * 
- * @param {T[]} arr - The array to take elements from.
- * @param {function(T): boolean} shouldContinueTaking - The function invoked per element.
- * @returns {T[]} A new array containing the elements taken from the end while the predicate returns `true`.
- * 
- * @example
- * // Returns [3, 2, 1]
- * takeRightWhile([5, 4, 3, 2, 1], n => n < 4);
- * 
- * @example
- * // Returns []
- * takeRightWhile([1, 2, 3], n => n > 3);
- */
+// src/array/takeRightWhile.ts
 function takeRightWhile(arr, shouldContinueTaking) {
-  for (var i = arr.length - 1; i >= 0; i--) {
+  for (let i = arr.length - 1; i >= 0; i--) {
     if (!shouldContinueTaking(arr[i])) {
       return arr.slice(i + 1);
     }
@@ -590,402 +204,145 @@ function takeRightWhile(arr, shouldContinueTaking) {
   return arr.slice();
 }
 
-/**
- * Returns a new array containing the leading elements of the provided array
- * that satisfy the provided predicate function. It stops taking elements as soon
- * as an element does not satisfy the predicate.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array to process.
- * @param {(element: T) => boolean} shouldContinueTaking - The predicate function that is called with each element. Elements are included in the result as long as this function returns true.
- * @returns {T[]} A new array containing the leading elements that satisfy the predicate.
- *
- * @example
- * // Returns [1, 2]
- * takeWhile([1, 2, 3, 4], x => x < 3);
- *
- * @example
- * // Returns []
- * takeWhile([1, 2, 3, 4], x => x > 3);
- */
+// src/array/takeWhile.ts
 function takeWhile(arr, shouldContinueTaking) {
-  var result = [];
-  var _iterator = _createForOfIteratorHelper(arr),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var item = _step.value;
-      if (!shouldContinueTaking(item)) {
-        break;
-      }
-      result.push(item);
+  const result = [];
+  for (const item of arr) {
+    if (!shouldContinueTaking(item)) {
+      break;
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+    result.push(item);
   }
   return result;
 }
 
-/**
- * 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]
- */
+// src/array/uniq.ts
 function uniq(arr) {
-  var result = [];
-  var _iterator = _createForOfIteratorHelper(arr),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var item = _step.value;
-      if (result.includes(item)) {
-        continue;
-      }
-      result.push(item);
+  const result = [];
+  for (const item of arr) {
+    if (result.includes(item)) {
+      continue;
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+    result.push(item);
   }
   return result;
 }
 
-/**
- * Creates an array of unique values from all given arrays.
- * 
- * This function takes two arrays, merges them into a single array, and returns a new array 
- * containing only the unique values from the merged array.
- *
- * @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.
- * @returns {T[]} A new array of unique values.
- *
- * @example
- * const array1 = [1, 2, 3];
- * const array2 = [3, 4, 5];
- * const result = union(array1, array2);
- * // result will be [1, 2, 3, 4, 5]
- */
+// src/array/union.ts
 function union(arr1, arr2) {
   return uniq(arr1.concat(arr2));
 }
 
-/**
- * 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 }]
- */
+// src/array/unionBy.ts
 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);
+  const map = /* @__PURE__ */ new Map();
+  for (const item of [...arr1, ...arr2]) {
+    const key = mapper(item);
     if (!map.has(key)) {
       map.set(key, item);
     }
   }
-  return _toConsumableArray(map.values());
+  return [...map.values()];
 }
 
-/**
- * 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]
- * ```
- */
+// src/array/uniqWith.ts
 function uniqWith(arr, areItemsEqual) {
-  var result = [];
-  var _iterator = _createForOfIteratorHelper(arr),
-    _step;
-  try {
-    var _loop = function _loop() {
-      var item = _step.value;
-      var isUniq = result.every(function (v) {
-        return !areItemsEqual(v, item);
-      });
-      if (isUniq) {
-        result.push(item);
-      }
-    };
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      _loop();
+  const result = [];
+  for (const item of arr) {
+    const isUniq = result.every((v) => !areItemsEqual(v, item));
+    if (isUniq) {
+      result.push(item);
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
   }
   return result;
 }
 
-/**
- * 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 
- * 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. 
- * 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.
- *
- * @example
- * const array1 = [{ id: 1 }, { id: 2 }];
- * const array2 = [{ id: 2 }, { id: 3 }];
- * const areItemsEqual = (a, b) => a.id === b.id;
- * const result = unionWith(array1, array2, areItemsEqual);
- * // result will be [{ id: 1 }, { id: 2 }, { id: 3 }] since { id: 2 } is considered equal in both arrays
- */
+// src/array/unionWith.ts
 function unionWith(arr1, arr2, areItemsEqual) {
   return uniqWith(arr1.concat(arr2), areItemsEqual);
 }
 
-/**
- * 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.
- *
- * It filters out elements with the same value, meaning it does not check for duplicates in data types like Objects.
- *
- * @example
- * ```ts
- * uniqBy([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], Math.floor);
- * // [1.2, 2.1, 3.3, 5.7, 7.19]
- * ```
- */
+// src/array/uniqBy.ts
 function uniqBy(arr, converter) {
-  return uniqWith(arr, function (item1, item2) {
-    return converter(item1) === converter(item2);
-  });
+  return uniqWith(arr, (item1, item2) => converter(item1) === converter(item2));
 }
 
-/**
- * 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']);
- */
+// src/array/xor.ts
 function xor(arr1, arr2) {
   return difference(union(arr1, arr2), intersection(arr1, arr2));
 }
 
-/**
- * Computes the symmetric difference between two arrays using a custom mapping function. 
- * The symmetric difference is the set of elements which are in either of the arrays, 
- * but not in their intersection, determined by the result of the mapping function.
- *
- * @template T - Type of elements in the input arrays.
- * @template U - Type of the values returned by the mapping function.
- * 
- * @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[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the values returned by the mapping function.
- * 
- * @example
- * // Custom mapping function for objects with an 'id' property
- * const idMapper = obj => obj.id;
- * xorBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);
- * // Returns [{ id: 1 }, { id: 3 }]
- */
+// src/array/xorBy.ts
 function xorBy(arr1, arr2, mapper) {
-  var union = unionBy(arr1, arr2, mapper);
-  var intersection = intersectionBy(arr1, arr2, mapper);
-  return differenceBy(union, intersection, mapper);
+  const union2 = unionBy(arr1, arr2, mapper);
+  const intersection2 = intersectionBy(arr1, arr2, mapper);
+  return differenceBy(union2, intersection2, mapper);
 }
 
-/**
- * Computes the symmetric difference between two arrays using a custom equality function. 
- * The symmetric difference is the set of elements which are in either of the arrays, 
- * but not in their intersection.
- *
- * @template T - Type of elements in the input arrays.
- * 
- * @param {T[]} arr1 - The first array.
- * @param {T[]} arr2 - The second array.
- * @param {(item1: T, item2: T) => boolean} areElementsEqual - The custom equality function to compare elements.
- * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the custom equality function.
- * 
- * @example
- * // Custom equality function for objects with an 'id' property
- * const areObjectsEqual = (a, b) => a.id === b.id;
- * xorWith([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], areObjectsEqual);
- * // Returns [{ id: 1 }, { id: 3 }]
- */
+// src/array/xorWith.ts
 function xorWith(arr1, arr2, areElementsEqual) {
-  var union = unionWith(arr1, arr2, areElementsEqual);
-  var intersection = intersectionWith(arr1, arr2, areElementsEqual);
-  return differenceWith(union, intersection, areElementsEqual);
-}
-
-/**
- * Combines multiple arrays into a single array of tuples.
- * 
- * This function takes multiple arrays and returns a new array where each element is a tuple 
- * containing the corresponding elements from the input arrays. If the input arrays are of 
- * different lengths, the resulting array will have the length of the longest input array, 
- * with undefined values for missing elements.
- *
- * @param {...T[][]} arrs - The arrays to zip together.
- * @returns {T[][]} A new array of tuples containing the corresponding elements from the input arrays.
- *
- * @example
- * const arr1 = [1, 2, 3];
- * const arr2 = ['a', 'b', 'c'];
- * const result = zip(arr1, arr2);
- * // result will be [[1, 'a'], [2, 'b'], [3, 'c']]
- *
- * const arr3 = [true, false];
- * const result2 = zip(arr1, arr2, arr3);
- * // result2 will be [[1, 'a', true], [2, 'b', false], [3, 'c', undefined]]
- */
-
-function zip() {
-  var result = [];
-  for (var _len = arguments.length, arrs = new Array(_len), _key = 0; _key < _len; _key++) {
-    arrs[_key] = arguments[_key];
-  }
-  var maxIndex = Math.max.apply(Math, _toConsumableArray(arrs.map(function (x) {
-    return x.length;
-  })));
-  for (var i = 0; i < maxIndex; i++) {
-    var element = [];
-    var _iterator = _createForOfIteratorHelper(arrs),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var arr = _step.value;
-        element.push(arr[i]);
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
+  const union2 = unionWith(arr1, arr2, areElementsEqual);
+  const intersection2 = intersectionWith(arr1, arr2, areElementsEqual);
+  return differenceWith(union2, intersection2, areElementsEqual);
+}
+
+// src/array/zip.ts
+function zip(...arrs) {
+  const result = [];
+  const maxIndex = Math.max(...arrs.map((x) => x.length));
+  for (let i = 0; i < maxIndex; i++) {
+    const element = [];
+    for (const arr of arrs) {
+      element.push(arr[i]);
     }
     result.push(element);
   }
   return result;
 }
 
-/**
- * Combines multiple arrays into a single array using a custom combiner function.
- * 
- * This function takes multiple arrays and a combiner function, and returns a new array where each element 
- * is the result of applying the combiner function to the corresponding elements of the input arrays.
- *
- * @param {T[]} arr1 - The first array to zip.
- * @param {U[]} [arr2] - The second array to zip (optional).
- * @param {V[]} [arr3] - The third array to zip (optional).
- * @param {W[]} [arr4] - The fourth array to zip (optional).
- * @param {function} combine - The combiner function that takes corresponding elements from each array and returns a single value.
- * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
- *
- * @example
- * // Example usage with two arrays:
- * const arr1 = [1, 2, 3];
- * const arr2 = [4, 5, 6];
- * const result = zipWith(arr1, arr2, (a, b) => a + b);
- * // result will be [5, 7, 9]
- *
- * @example
- * // Example usage with three arrays:
- * const arr1 = [1, 2];
- * const arr2 = [3, 4];
- * const arr3 = [5, 6];
- * const result = zipWith(arr1, arr2, arr3, (a, b, c) => `${a}${b}${c}`);
- * // result will be [`135`, `246`]
- */
-
-function zipWith(arr1) {
-  for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-    rest[_key - 1] = arguments[_key];
-  }
-  var arrs = [arr1].concat(_toConsumableArray(rest.slice(0, -1)));
-  var combine = rest[rest.length - 1];
-  var result = [];
-  var maxIndex = Math.max.apply(Math, _toConsumableArray(arrs.map(function (arr) {
-    return arr.length;
-  })));
-  var _loop = function _loop(i) {
-    var elements = arrs.map(function (arr) {
-      return arr[i];
-    });
-    result.push(combine.apply(void 0, _toConsumableArray(elements)));
-  };
-  for (var i = 0; i < maxIndex; i++) {
-    _loop(i);
+// src/array/zipWith.ts
+function zipWith(arr1, ...rest) {
+  const arrs = [arr1, ...rest.slice(0, -1)];
+  const combine = rest[rest.length - 1];
+  const result = [];
+  const maxIndex = Math.max(...arrs.map((arr) => arr.length));
+  for (let i = 0; i < maxIndex; i++) {
+    const elements = arrs.map((arr) => arr[i]);
+    result.push(combine(...elements));
   }
   return result;
 }
-
-exports.chunk = chunk;
-exports.difference = difference;
-exports.differenceBy = differenceBy;
-exports.differenceWith = differenceWith;
-exports.drop = drop;
-exports.dropRight = dropRight;
-exports.dropRightWhile = dropRightWhile;
-exports.dropWhile = dropWhile;
-exports.groupBy = groupBy;
-exports.intersection = intersection;
-exports.intersectionBy = intersectionBy;
-exports.intersectionWith = intersectionWith;
-exports.partition = partition;
-exports.sample = sample;
-exports.shuffle = shuffle;
-exports.take = take;
-exports.takeRight = takeRight;
-exports.takeRightWhile = takeRightWhile;
-exports.takeWhile = takeWhile;
-exports.union = union;
-exports.unionBy = unionBy;
-exports.unionWith = unionWith;
-exports.uniq = uniq;
-exports.uniqBy = uniqBy;
-exports.uniqWith = uniqWith;
-exports.xor = xor;
-exports.xorBy = xorBy;
-exports.xorWith = xorWith;
-exports.zip = zip;
-exports.zipWith = zipWith;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  chunk,
+  difference,
+  differenceBy,
+  differenceWith,
+  drop,
+  dropRight,
+  dropRightWhile,
+  dropWhile,
+  groupBy,
+  intersection,
+  intersectionBy,
+  intersectionWith,
+  partition,
+  sample,
+  shuffle,
+  take,
+  takeRight,
+  takeRightWhile,
+  takeWhile,
+  union,
+  unionBy,
+  unionWith,
+  uniq,
+  uniqBy,
+  uniqWith,
+  xor,
+  xorBy,
+  xorWith,
+  zip,
+  zipWith
+});
+//# sourceMappingURL=index.js.map