es-toolkit 0.0.1 → 1.0.0-dev.24

package/esm/array/shuffle.mjs

@@ -1,15 +1,22 @@
 /**
- * @name shuffle
- * @description
- * Randomize the order of an array.
- * @param arr The array to shuffle
+ * Randomizes the order of elements in an array using the Fisher-Yates algorithm.
+ * 
+ * This function takes an array and returns a new array with its elements shuffled in a random order.
+ *
+ * @param {T[]} arr - The array to shuffle.
+ * @returns {T[]} A new array with its elements shuffled in random order.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const shuffledArray = shuffle(array);
+ * // shuffledArray will be a new array with elements of array in random order, e.g., [3, 1, 4, 5, 2]
  */
 function shuffle(arr) {
   /**
    * 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);
+    var j = Math.floor(Math.random() * (i + 1));
     var _ref = [arr[j], arr[i]];
     arr[i] = _ref[0];
     arr[j] = _ref[1];

package/esm/array/takeRight.mjs

@@ -1,8 +1,6 @@
 /**
  * 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.
- *
- * @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.

package/esm/array/union.mjs

@@ -1,19 +1,23 @@
 import { uniq } from './uniq.mjs';
 
 /**
- * `union` function returns the union of the arrays passed as arguments.
+ * 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
- * ```ts
- * union([2], [1, 2]);
- * // [2, 1]
- * ```
+ * const array1 = [1, 2, 3];
+ * const array2 = [3, 4, 5];
+ * const result = union(array1, array2);
+ * // result will be [1, 2, 3, 4, 5]
  */
-function union() {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-    args[_key] = arguments[_key];
-  }
-  return uniq(args.flat());
+function union(arr1, arr2) {
+  return uniq(arr1.concat(arr2));
 }
 
 export { union };

package/esm/array/unionBy.mjs

@@ -2,9 +2,6 @@ import { toConsumableArray as _toConsumableArray } from './_virtual/_rollupPlugi
 
 /**
  * Creates an array of unique values, in order, from all given arrays using a provided mapping function to determine equality.
- *
- * @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.

package/esm/array/unionWith.mjs

@@ -1,21 +1,26 @@
-import { toConsumableArray as _toConsumableArray } from './_virtual/_rollupPluginBabelHelpers.mjs';
 import { uniqWith } from './uniqWith.mjs';
 
 /**
- * `unionWith` function returns the union of multiple arrays passed as arguments. During this process, it removes any duplicated elements.
+ * 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
- * ```ts
- * unionWith(
- *   [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }],
- *   [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }],
- *   (x, y) => x === y
- * );
- * // [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
- * ```
+ * const array1 = [{ id: 1 }, { id: 2 }];
+ * const array2 = [{ id: 2 }, { id: 3 }];
+ * const areItemsEqual = (a, b) => a.id === b.id;
+ * const result = unionWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 1 }, { id: 2 }, { id: 3 }] since { id: 2 } is considered equal in both arrays
  */
 function unionWith(arr1, arr2, areItemsEqual) {
-  return uniqWith([].concat(_toConsumableArray(arr1), _toConsumableArray(arr2)), areItemsEqual);
+  return uniqWith(arr1.concat(arr2), areItemsEqual);
 }
 
 export { unionWith };

package/esm/array/uniq.mjs

@@ -1,18 +1,37 @@
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
 /**
- * @name uniq
- * @description
- * `uniq` removes duplicated elements from the array given as an argument.
+ * 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.
  *
- * It filters out elements with the same value, so duplicates of data types like Objects are not checked.
+ * @param {T[]} arr - The array to process.
+ * @returns {T[]} A new array with only unique values from the original array.
  *
  * @example
- * ```ts
- * uniq([1, 1, 2, 3, 5, 5, 7, 'foo', 'bar', 'bar']);
- * // [1, 2, 3, 5, 7, 'foo', 'bar']
- * ```
+ *  * const array = [1, 2, 2, 3, 4, 4, 5];
+ * const result = uniq(array);
+ * // result will be [1, 2, 3, 4, 5]
  */
 function uniq(arr) {
-  return Array.from(new Set(arr));
+  var result = [];
+  var _iterator = _createForOfIteratorHelper(arr),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      if (result.includes(item)) {
+        continue;
+      }
+      result.push(item);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
 }
 
 export { uniq };

package/esm/array/xor.mjs

@@ -5,8 +5,6 @@ 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.
- *
- * @template T - Type of elements in the input arrays.
  * 
  * @param {T[]} arr1 - The first array.
  * @param {T[]} arr2 - The second array.

package/esm/array/zip.mjs

@@ -1,13 +1,25 @@
 import { toConsumableArray as _toConsumableArray, createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
 
 /**
- * Merges multiple arrays element-wise. Returns an array where each element is an array containing
- * elements from the input arrays at the corresponding index.
+ * Combines multiple arrays into a single array of tuples.
  * 
- * @param {T[]} arr1 - The first array to be zipped.
- * @param {T[]} arr2 - The second array to be zipped.
- * @param {T[]} arr3 - The third array to be zipped.
- * @param {T[]} arr4 - The fourth array to be zipped.
+ * 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() {

package/esm/array/zipWith.mjs

@@ -1,9 +1,32 @@
 import { toConsumableArray as _toConsumableArray } from './_virtual/_rollupPluginBabelHelpers.mjs';
 
 /**
- * Combines multiple arrays element-wise using a provided combining function. 
- * Returns an array where each element is the result of applying the combining function 
- * to the corresponding elements from the input arrays.
+ * 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) {

package/esm/function/debounce.mjs

@@ -1,10 +1,10 @@
 /**
- * Creates a debounced function that delays invoking the provided function until after `waitMs` milliseconds
+ * 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} waitMs - The number of milliseconds to delay.
+ * @param {number} debounceMs - The number of milliseconds to delay.
  * @returns {{ (): void; cancel: () => void }} A new debounced function with a `cancel` method.
  *
  * @example
@@ -18,7 +18,7 @@
  * // Will not log anything as the previous call is canceled
  * debouncedFunction.cancel();
  */
-function debounce(func, waitMs) {
+function debounce(func, debounceMs) {
   var timeoutId = null;
   var debounced = function debounced() {
     if (timeoutId != null) {
@@ -26,7 +26,7 @@ function debounce(func, waitMs) {
     }
     timeoutId = setTimeout(function () {
       func();
-    }, waitMs);
+    }, debounceMs);
   };
   debounced.cancel = function () {
     if (timeoutId != null) {

package/esm/function/once.mjs

@@ -2,7 +2,6 @@
  * 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.
  *
- * @template F - The type of the function to be invoked once.
  * @param {F} func - The function to restrict.
  * @returns {F} A new function that invokes `func` once and caches the result.
  *

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

@@ -1,13 +1,21 @@
 /**
- * @name clamp
- * @description Checks if `value` is within the bounds, if not return the closest bound (bound1: min, bound2: max)
- * function clamp(value: number, bound1: number, bound2?: number): number
+ * 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
- * clamp(3, 1) // 3
- * clamp(3, 1, 5) // 3
- * clamp(3, 5) // 5
- * clamp(7, 3, 5) // 5
+ *  * 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);

package/esm/math/round.mjs

@@ -1,14 +1,17 @@
 /**
- * @name round
- * @description Rounds given number to given precision
- * ```typescript
- * function round(value: number, precision: number = 0): number
- * ```
+ * 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
- * round(1.2) === 1
- * round(3.9) === 4
- * round(8.5) === 9
+ *  * 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;

package/esm/math/sum.mjs

@@ -1,22 +1,33 @@
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
 /**
- * @name sum
- * @description Return the sum of given values.
- * ```typescript
- * function sum(...nums: number[] | number[][]): number;
- * ```
+ * 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
- * sum(1, 2, 3) === 6
- * sum(...[1, 2, 3]) === 6
- * sum([1, 2, 3]) === 6
+ *  * const numbers = [1, 2, 3, 4, 5];
+ * const result = sum(numbers);
+ * // result will be 15
  */
-function sum() {
-  for (var _len = arguments.length, nums = new Array(_len), _key = 0; _key < _len; _key++) {
-    nums[_key] = arguments[_key];
+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 nums.flat().reduce(function (acc, curr) {
-    return acc + curr;
-  }, 0);
+  return result;
 }
 
 export { sum };

package/esm/object/_virtual/_rollupPluginBabelHelpers.mjs

@@ -1,3 +1,30 @@
+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) {
@@ -47,6 +74,12 @@ function _defineProperty(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);
@@ -60,6 +93,9 @@ function _arrayLikeToArray(arr, len) {
   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) {
@@ -112,4 +148,4 @@ function _createForOfIteratorHelper(o, allowArrayLike) {
   };
 }
 
-export { _arrayLikeToArray as arrayLikeToArray, _createForOfIteratorHelper as createForOfIteratorHelper, _defineProperty as defineProperty, _objectSpread2 as objectSpread2, _toPrimitive as toPrimitive, _toPropertyKey as toPropertyKey, _unsupportedIterableToArray as unsupportedIterableToArray };
+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/omit.mjs

@@ -1,10 +1,19 @@
 import { objectSpread2 as _objectSpread2, createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
 
 /**
- * @name omit
- * Omit properties from an object.
- * @param obj The object to omit properties from
- * @param keys The keys to omit from an object
+ * 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);

package/esm/object/omitBy.mjs

@@ -1,5 +1,35 @@
-function omitBy() {
-  throw new Error('Not implemented');
+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 
+ * 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 }
+ */
+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 };

package/esm/object/pick.mjs

@@ -1,10 +1,19 @@
 import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
 
 /**
- * @name pick
- * Pick properties from an given object.
- * @param obj The object to pick properties from
- * @param keys The keys to pick from an object
+ * 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 }
  */
 function pick(obj, keys) {
   var result = {};

package/esm/object/pickBy.mjs

@@ -1,5 +1,35 @@
-function pickBy() {
-  throw new Error('Not implemented');
+import { slicedToArray as _slicedToArray } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
+/**
+ * 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' }
+ */
+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];
+    if (!shouldPick(value, key)) {
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
 }
 
 export { pickBy };