es-toolkit 0.0.1-dev.20

package/esm/array/xorBy.mjs

@@ -0,0 +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, 
+ * but not in their intersection, determined by the result of the mapping function.
+ *
+ * @template T - Type of elements in the input arrays.
+ * @template U - Type of the values returned by the mapping function.
+ * 
+ * @param {T[]} arr1 - The first array.
+ * @param {T[]} arr2 - The second array.
+ * @param {function(item: T): U} mapper - The function to map array elements to comparison values.
+ * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the values returned by the mapping function.
+ * 
+ * @example
+ * // Custom mapping function for objects with an 'id' property
+ * const idMapper = obj => obj.id;
+ * xorBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);
+ * // Returns [{ id: 1 }, { id: 3 }]
+ */
+function xorBy(arr1, arr2, mapper) {
+  var union = unionBy(arr1, arr2, mapper);
+  var intersection = intersectionBy(arr1, arr2, mapper);
+  return differenceBy(union, intersection, mapper);
+}
+
+export { xorBy };

package/esm/array/xorWith.mjs

@@ -0,0 +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, 
+ * but not in their intersection.
+ *
+ * @template T - Type of elements in the input arrays.
+ * 
+ * @param {T[]} arr1 - The first array.
+ * @param {T[]} arr2 - The second array.
+ * @param {(item1: T, item2: T) => boolean} areElementsEqual - The custom equality function to compare elements.
+ * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the custom equality function.
+ * 
+ * @example
+ * // Custom equality function for objects with an 'id' property
+ * const areObjectsEqual = (a, b) => a.id === b.id;
+ * xorWith([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], areObjectsEqual);
+ * // Returns [{ id: 1 }, { id: 3 }]
+ */
+function xorWith(arr1, arr2, areElementsEqual) {
+  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/esm/array/zipWith.mjs

@@ -0,0 +1,54 @@
+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 
+ * is the result of applying the combiner function to the corresponding elements of the input arrays.
+ *
+ * @param {T[]} arr1 - The first array to zip.
+ * @param {U[]} [arr2] - The second array to zip (optional).
+ * @param {V[]} [arr3] - The third array to zip (optional).
+ * @param {W[]} [arr4] - The fourth array to zip (optional).
+ * @param {function} combine - The combiner function that takes corresponding elements from each array and returns a single value.
+ * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
+ *
+ * @example
+ * // Example usage with two arrays:
+ * const arr1 = [1, 2, 3];
+ * const arr2 = [4, 5, 6];
+ * const result = zipWith(arr1, arr2, (a, b) => a + b);
+ * // result will be [5, 7, 9]
+ *
+ * @example
+ * // Example usage with three arrays:
+ * const arr1 = [1, 2];
+ * const arr2 = [3, 4];
+ * const arr3 = [5, 6];
+ * const result = zipWith(arr1, arr2, arr3, (a, b, c) => `${a}${b}${c}`);
+ * // result will be [`135`, `246`]
+ */
+
+function zipWith(arr1) {
+  for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    rest[_key - 1] = arguments[_key];
+  }
+  var arrs = [arr1].concat(_toConsumableArray(rest.slice(0, -1)));
+  var combine = rest[rest.length - 1];
+  var result = [];
+  var maxIndex = Math.max.apply(Math, _toConsumableArray(arrs.map(function (arr) {
+    return arr.length;
+  })));
+  var _loop = function _loop(i) {
+    var elements = arrs.map(function (arr) {
+      return arr[i];
+    });
+    result.push(combine.apply(void 0, _toConsumableArray(elements)));
+  };
+  for (var i = 0; i < maxIndex; i++) {
+    _loop(i);
+  }
+  return result;
+}
+
+export { zipWith };

package/esm/function/debounce.mjs

@@ -0,0 +1,39 @@
+/**
+ * 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();
+ */
+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/esm/function/index.mjs

@@ -0,0 +1,3 @@
+export { debounce } from './debounce.mjs';
+export { once } from './once.mjs';
+export { throttle } from './throttle.mjs';

package/esm/function/once.mjs

@@ -0,0 +1,31 @@
+/**
+ * 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
+ */
+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/esm/function/throttle.mjs

@@ -0,0 +1,38 @@
+/**
+ * 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);
+ */
+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/index.mjs

@@ -0,0 +1,45 @@
+export { chunk } from './array/chunk.mjs';
+export { difference } from './array/difference.mjs';
+export { differenceBy } from './array/differenceBy.mjs';
+export { differenceWith } from './array/differenceWith.mjs';
+export { drop } from './array/drop.mjs';
+export { dropRight } from './array/dropRight.mjs';
+export { dropRightWhile } from './array/dropRightWhile.mjs';
+export { dropWhile } from './array/dropWhile.mjs';
+export { groupBy } from './array/groupBy.mjs';
+export { intersection } from './array/intersection.mjs';
+export { intersectionBy } from './array/intersectionBy.mjs';
+export { intersectionWith } from './array/intersectionWith.mjs';
+export { partition } from './array/partition.mjs';
+export { sample } from './array/sample.mjs';
+export { shuffle } from './array/shuffle.mjs';
+export { take } from './array/take.mjs';
+export { takeRight } from './array/takeRight.mjs';
+export { takeRightWhile } from './array/takeRightWhile.mjs';
+export { takeWhile } from './array/takeWhile.mjs';
+export { union } from './array/union.mjs';
+export { unionBy } from './array/unionBy.mjs';
+export { unionWith } from './array/unionWith.mjs';
+export { uniq } from './array/uniq.mjs';
+export { uniqBy } from './array/uniqBy.mjs';
+export { uniqWith } from './array/uniqWith.mjs';
+export { xor } from './array/xor.mjs';
+export { xorBy } from './array/xorBy.mjs';
+export { xorWith } from './array/xorWith.mjs';
+export { zip } from './array/zip.mjs';
+export { zipWith } from './array/zipWith.mjs';
+export { debounce } from './function/debounce.mjs';
+export { once } from './function/once.mjs';
+export { throttle } from './function/throttle.mjs';
+export { clamp } from './math/clamp.mjs';
+export { round } from './math/round.mjs';
+export { sum } from './math/sum.mjs';
+export { omit } from './object/omit.mjs';
+export { omitBy } from './object/omitBy.mjs';
+export { pick } from './object/pick.mjs';
+export { pickBy } from './object/pickBy.mjs';
+export { isNil } from './predicate/isNil.mjs';
+export { isNotNil } from './predicate/isNotNil.mjs';
+export { isNull } from './predicate/isNull.mjs';
+export { isUndefined } from './predicate/isUndefined.mjs';
+export { delay } from './promise/delay.mjs';

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/esm/math/clamp.mjs

@@ -0,0 +1,26 @@
+/**
+ * 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
+ */
+
+function clamp(value, bound1, bound2) {
+  if (bound2 == null) {
+    return Math.min(value, bound1);
+  }
+  return Math.min(Math.max(value, bound1), bound2);
+}
+
+export { clamp };

package/esm/math/index.mjs

@@ -0,0 +1,3 @@
+export { clamp } from './clamp.mjs';
+export { round } from './round.mjs';
+export { sum } from './sum.mjs';

package/esm/math/round.mjs

@@ -0,0 +1,22 @@
+/**
+ * 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);
+  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/esm/object/index.mjs

@@ -0,0 +1,4 @@
+export { omit } from './omit.mjs';
+export { omitBy } from './omitBy.mjs';
+export { pick } from './pick.mjs';
+export { pickBy } from './pickBy.mjs';

package/esm/object/omit.mjs

@@ -0,0 +1,35 @@
+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 
+ * 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 }
+ */
+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 };