es-toolkit 1.0.3-dev.38 → 1.0.3

package/dist/array/index.js

@@ -1,192 +1,562 @@
-"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
+'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']]
+ */
 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.');
   }
-  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;
+  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;
     result[index] = arr.slice(start, end);
   }
   return result;
 }
 
-// src/array/difference.ts
+/**
+ * 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.
+ */
 function difference(firstArr, secondArr) {
-  return firstArr.filter((item) => {
+  return firstArr.filter(function (item) {
     return !secondArr.includes(item);
   });
 }
 
-// src/array/differenceBy.ts
+/**
+ * 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.
+ */
 function differenceBy(firstArr, secondArr, mapper) {
-  const mappedSecondArr = secondArr.map((item) => mapper(item));
-  return firstArr.filter((item) => {
+  var mappedSecondArr = secondArr.map(function (item) {
+    return mapper(item);
+  });
+  return firstArr.filter(function (item) {
     return !mappedSecondArr.includes(mapper(item));
   });
 }
 
-// src/array/differenceWith.ts
+/**
+ * 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.
+ */
 function differenceWith(firstArr, secondArr, areItemsEqual) {
-  return firstArr.filter((firstItem) => {
-    return secondArr.every((secondItem) => {
+  return firstArr.filter(function (firstItem) {
+    return secondArr.every(function (secondItem) {
       return !areItemsEqual(firstItem, secondItem);
     });
   });
 }
 
-// src/array/drop.ts
+/**
+ * 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.
+ */
 function drop(arr, itemsCount) {
   return arr.slice(itemsCount);
 }
 
-// src/array/dropRight.ts
+/**
+ * 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.
+ */
 function dropRight(arr, itemsCount) {
   return arr.slice(0, -itemsCount);
 }
 
-// src/array/dropWhile.ts
+/**
+ * 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.
+ */
 function dropWhile(arr, canContinueDropping) {
-  const dropEndIndex = arr.findIndex((item) => !canContinueDropping(item));
+  var dropEndIndex = arr.findIndex(function (item) {
+    return !canContinueDropping(item);
+  });
   return arr.slice(dropEndIndex);
 }
 
-// src/array/dropRightWhile.ts
+/**
+ * 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.
+ */
 function dropRightWhile(arr, canContinueDropping) {
-  const reversed = arr.slice().reverse();
-  const dropped = dropWhile(reversed, canContinueDropping);
+  var reversed = arr.slice().reverse();
+  var dropped = dropWhile(reversed, canContinueDropping);
   return dropped.slice().reverse();
 }
 
-// src/array/groupBy.ts
+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' }
+ * //   ]
+ * // }
+ */
 function groupBy(arr, getKeyFromItem) {
-  const result = {};
-  for (const item of arr) {
-    const key = getKeyFromItem(item);
-    if (result[key] == null) {
-      result[key] = [];
+  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);
     }
-    result[key].push(item);
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
   }
   return result;
 }
 
-// src/array/intersection.ts
+/**
+ * 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.
+ */
 function intersection(firstArr, secondArr) {
-  return firstArr.filter((item) => {
+  return firstArr.filter(function (item) {
     return secondArr.includes(item);
   });
 }
 
-// src/array/intersectionBy.ts
+/**
+ * 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.
+ */
 function intersectionBy(firstArr, secondArr, mapper) {
-  const mappedSecondArr = secondArr.map((x) => mapper(x));
-  return firstArr.filter((item) => {
+  var mappedSecondArr = secondArr.map(function (x) {
+    return mapper(x);
+  });
+  return firstArr.filter(function (item) {
     return mappedSecondArr.includes(mapper(item));
   });
 }
 
-// src/array/intersectionWith.ts
+/**
+ * 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.
+ */
 function intersectionWith(firstArr, secondArr, areItemsEqual) {
-  return firstArr.filter((firstItem) => {
-    return secondArr.some((secondItem) => {
+  return firstArr.filter(function (firstItem) {
+    return secondArr.some(function (secondItem) {
       return areItemsEqual(firstItem, secondItem);
     });
   });
 }
 
-// src/array/partition.ts
+/**
+ * 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]
+ */
 function partition(arr, isInTruthy) {
-  const truthy = [];
-  const falsy = [];
-  for (const item of arr) {
-    if (isInTruthy(item)) {
-      truthy.push(item);
-    } else {
-      falsy.push(item);
+  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);
+      }
     }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
   }
   return [truthy, falsy];
 }
 
-// src/array/sample.ts
+/**
+ * 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.
+ */
 function sample(arr) {
-  const randomIndex = Math.floor(Math.random() * arr.length);
+  var randomIndex = Math.floor(Math.random() * arr.length);
   return arr[randomIndex];
 }
 
-// src/array/shuffle.ts
+/**
+ * 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]
+ */
 function shuffle(arr) {
-  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]];
+  /**
+   * 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];
   }
   return arr;
 }
 
-// src/array/take.ts
+/**
+ * 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);
+ */
 function take(arr, count) {
   return arr.slice(0, count);
 }
 
-// src/array/takeRight.ts
+/**
+ * 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);
+ */
 function takeRight(arr, count) {
   if (count === 0) {
     return [];
@@ -194,9 +564,25 @@ function takeRight(arr, count) {
   return arr.slice(-count);
 }
 
-// src/array/takeRightWhile.ts
+/**
+ * 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);
+ */
 function takeRightWhile(arr, shouldContinueTaking) {
-  for (let i = arr.length - 1; i >= 0; i--) {
+  for (var i = arr.length - 1; i >= 0; i--) {
     if (!shouldContinueTaking(arr[i])) {
       return arr.slice(i + 1);
     }
@@ -204,145 +590,402 @@ function takeRightWhile(arr, shouldContinueTaking) {
   return arr.slice();
 }
 
-// src/array/takeWhile.ts
+/**
+ * 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);
+ */
 function takeWhile(arr, shouldContinueTaking) {
-  const result = [];
-  for (const item of arr) {
-    if (!shouldContinueTaking(item)) {
-      break;
+  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);
     }
-    result.push(item);
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
   }
   return result;
 }
 
-// src/array/uniq.ts
+/**
+ * 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]
+ */
 function uniq(arr) {
-  const result = [];
-  for (const item of arr) {
-    if (result.includes(item)) {
-      continue;
+  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);
     }
-    result.push(item);
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
   }
   return result;
 }
 
-// src/array/union.ts
+/**
+ * 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]
+ */
 function union(arr1, arr2) {
   return uniq(arr1.concat(arr2));
 }
 
-// src/array/unionBy.ts
+/**
+ * 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) {
-  const map = /* @__PURE__ */ new Map();
-  for (const item of [...arr1, ...arr2]) {
-    const key = mapper(item);
+  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 [...map.values()];
+  return _toConsumableArray(map.values());
 }
 
-// src/array/uniqWith.ts
+/**
+ * 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]
+ * ```
+ */
 function uniqWith(arr, areItemsEqual) {
-  const result = [];
-  for (const item of arr) {
-    const isUniq = result.every((v) => !areItemsEqual(v, item));
-    if (isUniq) {
-      result.push(item);
+  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();
     }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
   }
   return result;
 }
 
-// src/array/unionWith.ts
+/**
+ * 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
+ */
 function unionWith(arr1, arr2, areItemsEqual) {
   return uniqWith(arr1.concat(arr2), areItemsEqual);
 }
 
-// src/array/uniqBy.ts
+/**
+ * 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]
+ * ```
+ */
 function uniqBy(arr, converter) {
-  return uniqWith(arr, (item1, item2) => converter(item1) === converter(item2));
+  return uniqWith(arr, function (item1, item2) {
+    return converter(item1) === converter(item2);
+  });
 }
 
-// src/array/xor.ts
+/**
+ * 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));
 }
 
-// src/array/xorBy.ts
+/**
+ * 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 }]
+ */
 function xorBy(arr1, arr2, mapper) {
-  const union2 = unionBy(arr1, arr2, mapper);
-  const intersection2 = intersectionBy(arr1, arr2, mapper);
-  return differenceBy(union2, intersection2, mapper);
+  var union = unionBy(arr1, arr2, mapper);
+  var intersection = intersectionBy(arr1, arr2, mapper);
+  return differenceBy(union, intersection, mapper);
 }
 
-// src/array/xorWith.ts
+/**
+ * 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 }]
+ */
 function xorWith(arr1, arr2, areElementsEqual) {
-  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]);
+  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();
     }
     result.push(element);
   }
   return result;
 }
 
-// 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));
+/**
+ * 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);
   }
   return result;
 }
-// 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
+
+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;