es-toolkit 1.0.3-dev.38 → 1.0.3

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

@@ -1,7 +1,7 @@
 /**
  * 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
+ * 
+ * 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.
@@ -13,6 +13,8 @@
  * const result = dropRight(array, 2);
  * // result will be [1, 2, 3] since the last two elements are dropped.
  */
-declare function dropRight<T>(arr: T[], itemsCount: number): T[];
+function dropRight(arr, itemsCount) {
+  return arr.slice(0, -itemsCount);
+}
 
 export { dropRight };

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

@@ -1,12 +1,14 @@
+import { dropWhile } from './dropWhile.mjs';
+
 /**
  * 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
+ * 
+ * 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,
+ * @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.
  *
@@ -15,6 +17,10 @@
  * const result = dropRightWhile(array, x => x > 3);
  * // result will be [1, 2, 3] since elements greater than 3 are dropped from the end.
  */
-declare function dropRightWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean): T[];
+function dropRightWhile(arr, canContinueDropping) {
+  var reversed = arr.slice().reverse();
+  var dropped = dropWhile(reversed, canContinueDropping);
+  return dropped.slice().reverse();
+}
 
 export { dropRightWhile };

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

@@ -1,12 +1,12 @@
 /**
  * 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
+ * 
+ * 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
+ * @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.
  *
@@ -15,6 +15,11 @@
  * const result = dropWhile(array, x => x < 3);
  * // result will be [3, 4, 5] since elements less than 3 are dropped.
  */
-declare function dropWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean): T[];
+function dropWhile(arr, canContinueDropping) {
+  var dropEndIndex = arr.findIndex(function (item) {
+    return !canContinueDropping(item);
+  });
+  return arr.slice(dropEndIndex);
+}
 
 export { dropWhile };

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

@@ -1,13 +1,15 @@
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
 /**
  * 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
+ * 
+ * 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
+ * @returns {Record<K, T[]>} An object where each key is associated with an array of elements that 
  * share that key.
  *
  * @example
@@ -28,6 +30,25 @@
  * //   ]
  * // }
  */
-declare function groupBy<T, K extends string>(arr: T[], getKeyFromItem: (item: T) => K): Record<K, T[]>;
+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);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+}
 
 export { groupBy };

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

@@ -1,8 +1,8 @@
 /**
  * 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
+ * 
+ * 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.
@@ -15,6 +15,10 @@
  * const result = intersection(array1, array2);
  * // result will be [3, 4, 5] since these elements are in both arrays.
  */
-declare function intersection<T>(firstArr: T[], secondArr: T[]): T[];
+function intersection(firstArr, secondArr) {
+  return firstArr.filter(function (item) {
+    return secondArr.includes(item);
+  });
+}
 
 export { intersection };

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

@@ -1,9 +1,9 @@
 /**
  * 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
+ * 
+ * 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.
@@ -18,6 +18,13 @@
  * const result = intersectionBy(array1, array2, mapper);
  * // result will be [{ id: 2 }] since only this element has a matching id in both arrays.
  */
-declare function intersectionBy<T, U>(firstArr: T[], secondArr: T[], mapper: (item: T) => U): T[];
+function intersectionBy(firstArr, secondArr, mapper) {
+  var mappedSecondArr = secondArr.map(function (x) {
+    return mapper(x);
+  });
+  return firstArr.filter(function (item) {
+    return mappedSecondArr.includes(mapper(item));
+  });
+}
 
 export { intersectionBy };

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

@@ -1,14 +1,14 @@
 /**
  * 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
+ * 
+ * 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.
+ * @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.
  *
@@ -19,6 +19,12 @@
  * const result = intersectionWith(array1, array2, areItemsEqual);
  * // result will be [{ id: 2 }] since this element has a matching id in both arrays.
  */
-declare function intersectionWith<T>(firstArr: T[], secondArr: T[], areItemsEqual: (x: T, y: T) => boolean): T[];
+function intersectionWith(firstArr, secondArr, areItemsEqual) {
+  return firstArr.filter(function (firstItem) {
+    return secondArr.some(function (secondItem) {
+      return areItemsEqual(firstItem, secondItem);
+    });
+  });
+}
 
 export { intersectionWith };

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

@@ -1,16 +1,18 @@
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
 /**
  * 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
+ * 
+ * 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
+ * @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
+ * @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
@@ -19,6 +21,26 @@
  * const [even, odd] = partition(array, isEven);
  * // even will be [2, 4], and odd will be [1, 3, 5]
  */
-declare function partition<T>(arr: T[], isInTruthy: (value: T) => boolean): [truthy: T[], falsy: T[]];
+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);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return [truthy, falsy];
+}
 
 export { partition };

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

@@ -1,6 +1,6 @@
 /**
  * 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.
@@ -11,6 +11,9 @@
  * const randomElement = sample(array);
  * // randomElement will be one of the elements from the array, selected randomly.
  */
-declare function sample<T>(arr: T[]): T;
+function sample(arr) {
+  var randomIndex = Math.floor(Math.random() * arr.length);
+  return arr[randomIndex];
+}
 
 export { sample };

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

@@ -1,6 +1,6 @@
 /**
  * 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.
@@ -11,6 +11,17 @@
  * const shuffledArray = shuffle(array);
  * // shuffledArray will be a new array with elements of array in random order, e.g., [3, 1, 4, 5, 2]
  */
-declare function shuffle<T>(arr: T[]): T[];
+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];
+  }
+  return arr;
+}
 
 export { shuffle };

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

@@ -3,23 +3,25 @@
  * 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);
  */
-declare function take<T>(arr: T[], count: number): T[];
+function take(arr, count) {
+  return arr.slice(0, count);
+}
 
 export { take };

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

@@ -1,23 +1,28 @@
 /**
  * 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);
  */
-declare function takeRight<T>(arr: T[], count: number): T[];
+function takeRight(arr, count) {
+  if (count === 0) {
+    return [];
+  }
+  return arr.slice(-count);
+}
 
 export { takeRight };

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

@@ -1,20 +1,27 @@
 /**
  * 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);
  */
-declare function takeRightWhile<T>(arr: T[], shouldContinueTaking: (item: T) => boolean): T[];
+function takeRightWhile(arr, shouldContinueTaking) {
+  for (var i = arr.length - 1; i >= 0; i--) {
+    if (!shouldContinueTaking(arr[i])) {
+      return arr.slice(i + 1);
+    }
+  }
+  return arr.slice();
+}
 
 export { takeRightWhile };

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

@@ -1,3 +1,5 @@
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
 /**
  * Returns a new array containing the leading elements of the provided array
  * that satisfy the provided predicate function. It stops taking elements as soon
@@ -16,6 +18,24 @@
  * // Returns []
  * takeWhile([1, 2, 3, 4], x => x > 3);
  */
-declare function takeWhile<T>(arr: T[], shouldContinueTaking: (element: T) => boolean): T[];
+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);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+}
 
 export { takeWhile };

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

@@ -1,7 +1,9 @@
+import { uniq } from './uniq.mjs';
+
 /**
  * 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
+ * 
+ * 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.
@@ -14,6 +16,8 @@
  * const result = union(array1, array2);
  * // result will be [1, 2, 3, 4, 5]
  */
-declare function union<T>(arr1: T[], arr2: T[]): T[];
+function union(arr1, arr2) {
+  return uniq(arr1.concat(arr2));
+}
 
 export { union };

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

@@ -1,23 +1,35 @@
+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 }]
  */
-declare function unionBy<T, U>(arr1: T[], arr2: T[], mapper: (item: T) => U): T[];
+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());
+}
 
 export { unionBy };

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

@@ -1,12 +1,14 @@
+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.
  *
@@ -17,6 +19,8 @@
  * const result = unionWith(array1, array2, areItemsEqual);
  * // result will be [{ id: 1 }, { id: 2 }, { id: 3 }] since { id: 2 } is considered equal in both arrays
  */
-declare function unionWith<T>(arr1: T[], arr2: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[];
+function unionWith(arr1, arr2, areItemsEqual) {
+  return uniqWith(arr1.concat(arr2), areItemsEqual);
+}
 
 export { unionWith };

package/esm/array/uniq.mjs

@@ -0,0 +1,37 @@
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
+/**
+ * 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) {
+  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);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+}
+
+export { uniq };

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

@@ -1,3 +1,5 @@
+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.
  *
@@ -9,6 +11,10 @@
  * // [1.2, 2.1, 3.3, 5.7, 7.19]
  * ```
  */
-declare function uniqBy<T, U>(arr: T[], converter: (item: T) => U): T[];
+function uniqBy(arr, converter) {
+  return uniqWith(arr, function (item1, item2) {
+    return converter(item1) === converter(item2);
+  });
+}
 
 export { uniqBy };

package/esm/array/uniqWith.mjs

@@ -0,0 +1,39 @@
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
+/**
+ * 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) {
+  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;
+}
+
+export { uniqWith };