es-toolkit 1.0.3-dev.37 → 1.0.3

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

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

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

@@ -1,22 +1,30 @@
+import { differenceBy } from './differenceBy.mjs';
+import { intersectionBy } from './intersectionBy.mjs';
+import { unionBy } from './unionBy.mjs';
+
 /**
- * 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,
+ * 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 }]
  */
-declare function xorBy<T, U>(arr1: T[], arr2: T[], mapper: (item: T) => U): T[];
+function xorBy(arr1, arr2, mapper) {
+  var union = unionBy(arr1, arr2, mapper);
+  var intersection = intersectionBy(arr1, arr2, mapper);
+  return differenceBy(union, intersection, mapper);
+}
 
 export { xorBy };

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

@@ -1,21 +1,29 @@
+import { differenceWith } from './differenceWith.mjs';
+import { intersectionWith } from './intersectionWith.mjs';
+import { unionWith } from './unionWith.mjs';
+
 /**
- * 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,
+ * 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 }]
  */
-declare function xorWith<T>(arr1: T[], arr2: T[], areElementsEqual: (item1: T, item2: T) => boolean): T[];
+function xorWith(arr1, arr2, areElementsEqual) {
+  var union = unionWith(arr1, arr2, areElementsEqual);
+  var intersection = intersectionWith(arr1, arr2, areElementsEqual);
+  return differenceWith(union, intersection, areElementsEqual);
+}
 
 export { xorWith };

package/esm/array/zip.mjs

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

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

@@ -1,7 +1,9 @@
+import { toConsumableArray as _toConsumableArray } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
 /**
  * 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
+ * 
+ * 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.
@@ -26,9 +28,27 @@
  * const result = zipWith(arr1, arr2, arr3, (a, b, c) => `${a}${b}${c}`);
  * // result will be [`135`, `246`]
  */
-declare function zipWith<T, R>(arr1: T[], combine: (item: T) => R): R[];
-declare function zipWith<T, U, R>(arr1: T[], arr2: U[], combine: (item1: T, item2: U) => R): R[];
-declare function zipWith<T, U, V, R>(arr1: T[], arr2: U[], arr3: V[], combine: (item1: T, item2: U, item3: V) => R): R[];
-declare function zipWith<T, U, V, W, R>(arr1: T[], arr2: U[], arr3: V[], arr4: W[], combine: (item1: T, item2: U, item3: V, item4: W) => R): R[];
+
+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;
+}
 
 export { zipWith };

package/{dist/function/debounce.d.mts → esm/function/debounce.mjs}

@@ -14,13 +14,26 @@
  *
  * // 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();
  */
-declare function debounce(func: () => void, debounceMs: number): {
-    (): void;
-    cancel: () => void;
-};
+function debounce(func, debounceMs) {
+  var timeoutId = null;
+  var debounced = function debounced() {
+    if (timeoutId != null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(function () {
+      func();
+    }, debounceMs);
+  };
+  debounced.cancel = function () {
+    if (timeoutId != null) {
+      clearTimeout(timeoutId);
+    }
+  };
+  return debounced;
+}
 
 export { debounce };

package/{dist/function/once.d.mts → esm/function/once.mjs}

@@ -10,10 +10,22 @@
  *   console.log('Initialized!');
  *   return true;
  * });
- *
+ * 
  * initialize(); // Logs: 'Initialized!' and returns true
  * initialize(); // Returns true without logging
  */
-declare function once<F extends () => any>(func: F): F;
+function once(func) {
+  var called = false;
+  var cache;
+  return function () {
+    if (called) {
+      return cache;
+    }
+    var result = func();
+    called = true;
+    cache = result;
+    return result;
+  };
+}
 
 export { once };

package/{dist/function/throttle.d.mts → esm/function/throttle.mjs}

@@ -14,15 +14,25 @@
  *
  * // 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);
  */
-declare function throttle(func: () => void, throttleMs: number): () => void;
+function throttle(func, throttleMs) {
+  var lastCallTime;
+  var throttledFunction = function throttledFunction() {
+    var now = Date.now();
+    if (lastCallTime == null || now - lastCallTime >= throttleMs) {
+      lastCallTime = now;
+      func();
+    }
+  };
+  return throttledFunction;
+}
 
 export { throttle };

package/esm/math/_virtual/_rollupPluginBabelHelpers.mjs

@@ -0,0 +1,66 @@
+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 _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;
+      }
+    }
+  };
+}
+
+export { _arrayLikeToArray as arrayLikeToArray, _createForOfIteratorHelper as createForOfIteratorHelper, _unsupportedIterableToArray as unsupportedIterableToArray };

package/{dist/math/clamp.d.mts → esm/math/clamp.mjs}

@@ -15,7 +15,12 @@
  * 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
  */
-declare function clamp(value: number, maximum: number): number;
-declare function clamp(value: number, minimum: number, maximum: number): number;
+
+function clamp(value, bound1, bound2) {
+  if (bound2 == null) {
+    return Math.min(value, bound1);
+  }
+  return Math.min(Math.max(value, bound1), bound2);
+}
 
 export { clamp };

package/{dist/math/round.d.mts → esm/math/round.mjs}

@@ -1,7 +1,7 @@
 /**
  * Rounds a number to a specified precision.
- *
- * This function takes a number and an optional precision value, and returns the number rounded
+ * 
+ * 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.
@@ -13,6 +13,10 @@
  * const result2 = round(1.2345, 2); // result2 will be 1.23
  * const result3 = round(1.2345, 3); // result3 will be 1.235
  */
-declare function round(value: number, precision?: number): number;
+function round(value) {
+  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var multiplier = Math.pow(10, precision);
+  return Math.round(value * multiplier) / multiplier;
+}
 
 export { round };

package/esm/math/sum.mjs

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

package/esm/object/_virtual/_rollupPluginBabelHelpers.mjs

@@ -0,0 +1,151 @@
+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 _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+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 _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;
+      }
+    }
+  };
+}
+
+export { _arrayLikeToArray as arrayLikeToArray, _arrayWithHoles as arrayWithHoles, _createForOfIteratorHelper as createForOfIteratorHelper, _defineProperty as defineProperty, _iterableToArrayLimit as iterableToArrayLimit, _nonIterableRest as nonIterableRest, _objectSpread2 as objectSpread2, _slicedToArray as slicedToArray, _toPrimitive as toPrimitive, _toPropertyKey as toPropertyKey, _unsupportedIterableToArray as unsupportedIterableToArray };

package/{dist/object/omit.d.mts → esm/object/omit.mjs}

@@ -1,7 +1,9 @@
+import { objectSpread2 as _objectSpread2, createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
 /**
  * Creates a new object with specified keys omitted.
  *
- * This function takes an object and an array of keys, and returns a new object that
+ * 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.
@@ -13,6 +15,21 @@
  * const result = omit(obj, ['b', 'c']);
  * // result will be { a: 1 }
  */
-declare function omit<T, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+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();
+  }
+  return result;
+}
 
 export { omit };

package/{dist/object/omitBy.d.mts → esm/object/omitBy.mjs}

@@ -1,12 +1,14 @@
+import { slicedToArray as _slicedToArray } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
 /**
  * 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
+ * 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`
+ * @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.
  *
@@ -16,6 +18,18 @@
  * const result = omitBy(obj, shouldOmit);
  * // result will be { a: 1, c: 3 }
  */
-declare function omitBy<T extends Record<string, any>>(obj: T, shouldOmit: (value: T[keyof T], key: string) => boolean): Partial<T>;
+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];
+    if (shouldOmit(value, key)) {
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
 
 export { omitBy };