es-toolkit 1.0.3 → 1.0.4-dev.39

package/dist/index.js

@@ -1,647 +1,221 @@
-'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 __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  chunk: () => chunk,
+  clamp: () => clamp,
+  debounce: () => debounce,
+  delay: () => delay,
+  difference: () => difference,
+  differenceBy: () => differenceBy,
+  differenceWith: () => differenceWith,
+  drop: () => drop,
+  dropRight: () => dropRight,
+  dropRightWhile: () => dropRightWhile,
+  dropWhile: () => dropWhile,
+  groupBy: () => groupBy,
+  intersection: () => intersection,
+  intersectionBy: () => intersectionBy,
+  intersectionWith: () => intersectionWith,
+  isNil: () => isNil,
+  isNotNil: () => isNotNil,
+  isNull: () => isNull,
+  isUndefined: () => isUndefined,
+  omit: () => omit,
+  omitBy: () => omitBy,
+  once: () => once,
+  partition: () => partition,
+  pick: () => pick,
+  pickBy: () => pickBy,
+  round: () => round,
+  sample: () => sample,
+  shuffle: () => shuffle,
+  sum: () => sum,
+  take: () => take,
+  takeRight: () => takeRight,
+  takeRightWhile: () => takeRightWhile,
+  takeWhile: () => takeWhile,
+  throttle: () => throttle,
+  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(src_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 _iterableToArrayLimit(r, l) {
-  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
-  if (null != t) {
-    var e,
-      n,
-      i,
-      u,
-      a = [],
-      f = !0,
-      o = !1;
-    try {
-      if (i = (t = t.call(r)).next, 0 === l) {
-        if (Object(t) !== t) return;
-        f = !1;
-      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
-    } catch (r) {
-      o = !0, n = r;
-    } finally {
-      try {
-        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
-      } finally {
-        if (o) throw n;
-      }
-    }
-    return a;
-  }
-}
-function ownKeys(e, r) {
-  var t = Object.keys(e);
-  if (Object.getOwnPropertySymbols) {
-    var o = Object.getOwnPropertySymbols(e);
-    r && (o = o.filter(function (r) {
-      return Object.getOwnPropertyDescriptor(e, r).enumerable;
-    })), t.push.apply(t, o);
-  }
-  return t;
-}
-function _objectSpread2(e) {
-  for (var r = 1; r < arguments.length; r++) {
-    var t = null != arguments[r] ? arguments[r] : {};
-    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
-      _defineProperty(e, r, t[r]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
-      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
-    });
-  }
-  return e;
-}
-function _toPrimitive(t, r) {
-  if ("object" != typeof t || !t) return t;
-  var e = t[Symbol.toPrimitive];
-  if (void 0 !== e) {
-    var i = e.call(t, r || "default");
-    if ("object" != typeof i) return i;
-    throw new TypeError("@@toPrimitive must return a primitive value.");
-  }
-  return ("string" === r ? String : Number)(t);
-}
-function _toPropertyKey(t) {
-  var i = _toPrimitive(t, "string");
-  return "symbol" == typeof i ? i : i + "";
-}
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-function _slicedToArray(arr, i) {
-  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-}
-function _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-}
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-}
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return 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 _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure 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 [];
@@ -649,25 +223,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);
     }
@@ -675,406 +233,127 @@ 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;
 }
 
-/**
- * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds
- * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
- * method to cancel any pending execution.
- *
- * @param {() => void} func - The function to debounce.
- * @param {number} debounceMs - The number of milliseconds to delay.
- * @returns {{ (): void; cancel: () => void }} A new debounced function with a `cancel` method.
- *
- * @example
- * const debouncedFunction = debounce(() => {
- *   console.log('Function executed');
- * }, 1000);
- *
- * // Will log 'Function executed' after 1 second if not called again in that time
- * debouncedFunction();
- * 
- * // Will not log anything as the previous call is canceled
- * debouncedFunction.cancel();
- */
+// src/function/debounce.ts
 function debounce(func, debounceMs) {
-  var timeoutId = null;
-  var debounced = function debounced() {
+  let timeoutId = null;
+  const debounced = function() {
     if (timeoutId != null) {
       clearTimeout(timeoutId);
     }
-    timeoutId = setTimeout(function () {
+    timeoutId = setTimeout(() => {
       func();
     }, debounceMs);
   };
-  debounced.cancel = function () {
+  debounced.cancel = function() {
     if (timeoutId != null) {
       clearTimeout(timeoutId);
     }
@@ -1082,65 +361,26 @@ function debounce(func, debounceMs) {
   return debounced;
 }
 
-/**
- * Creates a function that is restricted to invoking the provided function `func` once.
- * Repeated calls to the function will return the value from the first invocation.
- *
- * @param {F} func - The function to restrict.
- * @returns {F} A new function that invokes `func` once and caches the result.
- *
- * @example
- * const initialize = once(() => {
- *   console.log('Initialized!');
- *   return true;
- * });
- * 
- * initialize(); // Logs: 'Initialized!' and returns true
- * initialize(); // Returns true without logging
- */
+// src/function/once.ts
 function once(func) {
-  var called = false;
-  var cache;
-  return function () {
+  let called = false;
+  let cache;
+  return function() {
     if (called) {
       return cache;
     }
-    var result = func();
+    const result = func();
     called = true;
     cache = result;
     return result;
   };
 }
 
-/**
- * Creates a throttled function that only invokes the provided function at most once
- * per every `throttleMs` milliseconds. Subsequent calls to the throttled function
- * within the wait time will not trigger the execution of the original function.
- *
- * @param {() => void} func - The function to throttle.
- * @param {number} throttleMs - The number of milliseconds to throttle executions to.
- * @returns {() => void} A new throttled function.
- *
- * @example
- * const throttledFunction = throttle(() => {
- *   console.log('Function executed');
- * }, 1000);
- *
- * // Will log 'Function executed' immediately
- * throttledFunction();
- * 
- * // Will not log anything as it is within the throttle time
- * throttledFunction();
- * 
- * // After 1 second
- * setTimeout(() => {
- *   throttledFunction(); // Will log 'Function executed'
- * }, 1000);
- */
+// src/function/throttle.ts
 function throttle(func, throttleMs) {
-  var lastCallTime;
-  var throttledFunction = function throttledFunction() {
-    var now = Date.now();
+  let lastCallTime;
+  const throttledFunction = function() {
+    const now = Date.now();
     if (lastCallTime == null || now - lastCallTime >= throttleMs) {
       lastCallTime = now;
       func();
@@ -1149,24 +389,7 @@ function throttle(func, throttleMs) {
   return throttledFunction;
 }
 
-/**
- * Clamps a number within the inclusive lower and upper bounds.
- *
- * This function takes a number and two bounds, and returns the number clamped within the specified bounds.
- * If only one bound is provided, it returns the minimum of the value and the bound.
- *
- * @param {number} value - The number to clamp.
- * @param {number} minimum - The minimum bound to clamp the number.
- * @param {number} maximum - The maximum bound to clamp the number.
- * @returns {number} The clamped number within the specified bounds.
- *
- * @example
- *  * const result1 = clamp(10, 5); // result1 will be 5, as 10 is clamped to the bound 5
- * const result2 = clamp(10, 5, 15); // result2 will be 10, as it is within the bounds 5 and 15
- * const result3 = clamp(2, 5, 15); // result3 will be 5, as 2 is clamped to the lower bound 5
- * const result4 = clamp(20, 5, 15); // result4 will be 15, as 20 is clamped to the upper bound 15
- */
-
+// src/math/clamp.ts
 function clamp(value, bound1, bound2) {
   if (bound2 == null) {
     return Math.min(value, bound1);
@@ -1174,113 +397,34 @@ function clamp(value, bound1, bound2) {
   return Math.min(Math.max(value, bound1), bound2);
 }
 
-/**
- * Rounds a number to a specified precision.
- * 
- * This function takes a number and an optional precision value, and returns the number rounded 
- * to the specified number of decimal places.
- *
- * @param {number} value - The number to round.
- * @param {number} [precision=0] - The number of decimal places to round to. Defaults to 0.
- * @returns {number} The rounded number.
- *
- * @example
- *  * const result1 = round(1.2345); // result1 will be 1
- * const result2 = round(1.2345, 2); // result2 will be 1.23
- * const result3 = round(1.2345, 3); // result3 will be 1.235
- */
-function round(value) {
-  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  var multiplier = Math.pow(10, precision);
+// src/math/round.ts
+function round(value, precision = 0) {
+  const multiplier = Math.pow(10, precision);
   return Math.round(value * multiplier) / multiplier;
 }
 
-/**
- * Calculates the sum of an array of numbers.
- * 
- * This function takes an array of numbers and returns the sum of all the elements in the array.
- *
- * @param {number[]} nums - An array of numbers to be summed.
- * @returns {number} The sum of all the numbers in the array.
- *
- * @example
- *  * const numbers = [1, 2, 3, 4, 5];
- * const result = sum(numbers);
- * // result will be 15
- */
+// src/math/sum.ts
 function sum(nums) {
-  var result = 0;
-  var _iterator = _createForOfIteratorHelper(nums),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var num = _step.value;
-      result += num;
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+  let result = 0;
+  for (const num of nums) {
+    result += num;
   }
   return result;
 }
 
-/**
- * Creates a new object with specified keys omitted.
- *
- * This function takes an object and an array of keys, and returns a new object that 
- * excludes the properties corresponding to the specified keys.
- *
- * @param {T} obj - The object to omit keys from.
- * @param {K[]} keys - An array of keys to be omitted from the object.
- * @returns {Omit<T, K>} A new object with the specified keys omitted.
- *
- * @example
- *  * const obj = { a: 1, b: 2, c: 3 };
- * const result = omit(obj, ['b', 'c']);
- * // result will be { a: 1 }
- */
+// src/object/omit.ts
 function omit(obj, keys) {
-  var result = _objectSpread2({}, obj);
-  var _iterator = _createForOfIteratorHelper(keys),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var key = _step.value;
-      delete result[key];
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+  const result = __spreadValues({}, obj);
+  for (const key of keys) {
+    delete result[key];
   }
   return result;
 }
 
-/**
- * Creates a new object composed of the properties that do not satisfy the predicate function.
- *
- * This function takes an object and a predicate function, and returns a new object that 
- * includes only the properties for which the predicate function returns false.
- *
- * @param {T} obj - The object to omit properties from.
- * @param {(value: T[string], key: string) => boolean} shouldOmit - A predicate function that determines 
- * whether a property should be omitted. It takes the property's key and value as arguments and returns `true` 
- * if the property should be omitted, and `false` otherwise.
- * @returns {Partial<T>} A new object with the properties that do not satisfy the predicate function.
- *
- * @example
- * const obj = { a: 1, b: 'omit', c: 3 };
- * const shouldOmit = (key, value) => typeof value === 'string';
- * const result = omitBy(obj, shouldOmit);
- * // result will be { a: 1, c: 3 }
- */
+// src/object/omitBy.ts
 function omitBy(obj, shouldOmit) {
-  var result = {};
-  for (var _i = 0, _Object$entries = Object.entries(obj); _i < _Object$entries.length; _i++) {
-    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-      key = _Object$entries$_i[0],
-      value = _Object$entries$_i[1];
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
     if (shouldOmit(value, key)) {
       continue;
     }
@@ -1289,62 +433,19 @@ function omitBy(obj, shouldOmit) {
   return result;
 }
 
-/**
- * Creates a new object composed of the picked object properties.
- *
- * This function takes an object and an array of keys, and returns a new object that 
- * includes only the properties corresponding to the specified keys.
- *
- * @param {T} obj - The object to pick keys from.
- * @param {K[]} keys - An array of keys to be picked from the object.
- * @returns {Pick<T, K>} A new object with the specified keys picked.
- *
- * @example
- *  * const obj = { a: 1, b: 2, c: 3 };
- * const result = pick(obj, ['a', 'c']);
- * // result will be { a: 1, c: 3 }
- */
+// src/object/pick.ts
 function pick(obj, keys) {
-  var result = {};
-  var _iterator = _createForOfIteratorHelper(keys),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var key = _step.value;
-      result[key] = obj[key];
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+  const result = {};
+  for (const key of keys) {
+    result[key] = obj[key];
   }
   return result;
 }
 
-/**
- * Creates a new object composed of the properties that satisfy the predicate function.
- *
- * This function takes an object and a predicate function, and returns a new object that 
- * includes only the properties for which the predicate function returns true.
- *
- * @param {T} obj - The object to pick properties from.
- * @param {(value: T[keyof T], key: string) => boolean} shouldPick - A predicate function that determines 
- * whether a property should be picked. It takes the property's key and value as arguments and returns `true` 
- * if the property should be picked, and `false` otherwise.
- * @returns {Partial<T>} A new object with the properties that satisfy the predicate function.
- *
- * @example
- * const obj = { a: 1, b: 'pick', c: 3 };
- * const shouldPick = (value) => typeof value === 'string';
- * const result = pickBy(obj, shouldPick);
- * // result will be { b: 'pick' }
- */
+// src/object/pickBy.ts
 function pickBy(obj, shouldPick) {
-  var result = {};
-  for (var _i = 0, _Object$entries = Object.entries(obj); _i < _Object$entries.length; _i++) {
-    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-      key = _Object$entries$_i[0],
-      value = _Object$entries$_i[1];
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
     if (!shouldPick(value, key)) {
       continue;
     }
@@ -1353,162 +454,78 @@ function pickBy(obj, shouldPick) {
   return result;
 }
 
-/**
- * Checks if a given value is null or undefined.
- * 
- * This function tests whether the provided value is either `null` or `undefined`. 
- * It returns `true` if the value is `null` or `undefined`, and `false` otherwise.
- * 
- * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null` or `undefined`.
- *
- * @param {unknown} x - The value to test for null or undefined.
- * @returns {boolean} `true` if the value is null or undefined, `false` otherwise.
- *
- * @example
- *  * const value1 = null;
- * const value2 = undefined;
- * const value3 = 42;
- * const result1 = isNil(value1); // true
- * const result2 = isNil(value2); // true
- * const result3 = isNil(value3); // false
- */
+// src/predicate/isNil.ts
 function isNil(x) {
-  return x == null || x == undefined;
+  return x === null || x === void 0;
 }
 
-/**
- * Checks if the given value is not null nor undefined.
- * 
- * The main use of this function is to be used with TypeScript as a type predicate.
- *
- * @param {T | null | undefined} x - The value to test if it is not null nor undefined.
- * @returns {x is T} True if the value is not null nor undefined, false otherwise.
- *
- * @example
- * // Here the type of `arr` is (number | undefined)[]
- * const arr = [1, undefined, 3];
- * // Here the type of `result` is number[]
- * const result = arr.filter(isNotNil);
- * // result will be [1, 3]
- */
+// src/predicate/isNotNil.ts
 function isNotNil(x) {
-  return x != null && x != undefined;
+  return x !== null && x !== void 0;
 }
 
-/**
- * Checks if the given value is null.
- *
- * This function tests whether the provided value is strictly equal to `null`. 
- * It returns `true` if the value is `null`, and `false` otherwise.
- *
- * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null`.
- * 
- * @param {unknown} x - The value to test if it is null.
- * @returns {x is null} True if the value is null, false otherwise.
- *
- * @example
- *  * const value1 = null;
- * const value2 = undefined;
- * const value3 = 42;
- * 
- * console.log(isNull(value1)); // true
- * console.log(isNull(value2)); // false
- * console.log(isNull(value3)); // false
- */
+// src/predicate/isNull.ts
 function isNull(x) {
   return x === null;
 }
 
-/**
- * Checks if the given value is undefined.
- *
- * This function tests whether the provided value is strictly equal to `undefined`. 
- * It returns `true` if the value is `undefined`, and `false` otherwise.
- * 
- * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `undefined`.
- *
- * @param {unknown} x - The value to test if it is undefined.
- * @returns {x is undefined} true if the value is undefined, false otherwise.
- *
- * @example
- *  * const value1 = undefined;
- * const value2 = null;
- * const value3 = 42;
- * 
- * console.log(isUndefined(value1)); // true
- * console.log(isUndefined(value2)); // false
- * console.log(isUndefined(value3)); // false
- */
+// src/predicate/isUndefined.ts
 function isUndefined(x) {
-  return x === undefined;
+  return x === void 0;
 }
 
-/**
- * Delays the execution of code for a specified number of milliseconds.
- * 
- * This function returns a Promise that resolves after the specified delay, allowing you to use it 
- * with async/await to pause execution.
- *
- * @param {number} ms - The number of milliseconds to delay.
- * @returns {Promise<void>} A Promise that resolves after the specified delay.
- *
- * @example
- * async function foo() {
- *   console.log('Start');
- *   await delay(1000); // Delays execution for 1 second
- *   console.log('End');
- * }
- * 
- * foo();
- */
+// src/promise/delay.ts
 function delay(ms) {
-  return new Promise(function (resolve) {
+  return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
 }
-
-exports.chunk = chunk;
-exports.clamp = clamp;
-exports.debounce = debounce;
-exports.delay = delay;
-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.isNil = isNil;
-exports.isNotNil = isNotNil;
-exports.isNull = isNull;
-exports.isUndefined = isUndefined;
-exports.omit = omit;
-exports.omitBy = omitBy;
-exports.once = once;
-exports.partition = partition;
-exports.pick = pick;
-exports.pickBy = pickBy;
-exports.round = round;
-exports.sample = sample;
-exports.shuffle = shuffle;
-exports.sum = sum;
-exports.take = take;
-exports.takeRight = takeRight;
-exports.takeRightWhile = takeRightWhile;
-exports.takeWhile = takeWhile;
-exports.throttle = throttle;
-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,
+  clamp,
+  debounce,
+  delay,
+  difference,
+  differenceBy,
+  differenceWith,
+  drop,
+  dropRight,
+  dropRightWhile,
+  dropWhile,
+  groupBy,
+  intersection,
+  intersectionBy,
+  intersectionWith,
+  isNil,
+  isNotNil,
+  isNull,
+  isUndefined,
+  omit,
+  omitBy,
+  once,
+  partition,
+  pick,
+  pickBy,
+  round,
+  sample,
+  shuffle,
+  sum,
+  take,
+  takeRight,
+  takeRightWhile,
+  takeWhile,
+  throttle,
+  union,
+  unionBy,
+  unionWith,
+  uniq,
+  uniqBy,
+  uniqWith,
+  xor,
+  xorBy,
+  xorWith,
+  zip,
+  zipWith
+});
+//# sourceMappingURL=index.js.map