es-toolkit 1.0.0-dev.24 → 1.0.2-canary.0

package/esm/array/union.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/array/unionBy.d.ts

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

package/esm/array/{unionBy.mjs → unionBy.js}

@@ -1,4 +1,4 @@
-import { toConsumableArray as _toConsumableArray } from './_virtual/_rollupPluginBabelHelpers.mjs';
+import { toConsumableArray as _toConsumableArray } from './_virtual/_rollupPluginBabelHelpers.js';
 
 /**
  * Creates an array of unique values, in order, from all given arrays using a provided mapping function to determine equality.

package/esm/array/unionBy.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/array/unionWith.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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
+ */
+export declare function unionWith<T>(arr1: T[], arr2: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[];

package/esm/array/{unionWith.mjs → unionWith.js}

@@ -1,4 +1,4 @@
-import { uniqWith } from './uniqWith.mjs';
+import { uniqWith } from './uniqWith.js';
 
 /**
  * Creates an array of unique values from two given arrays based on a custom equality function.

package/esm/array/unionWith.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/array/uniq.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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]
+ */
+export declare function uniq<T>(arr: T[]): T[];

package/esm/array/{uniq.mjs → uniq.js}

@@ -1,4 +1,4 @@
-import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.js';
 
 /**
  * Creates a duplicate-free version of an array.

package/esm/array/uniq.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/array/uniqBy.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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]
+ * ```
+ */
+export declare function uniqBy<T, U>(arr: T[], converter: (item: T) => U): T[];

package/esm/array/{uniqBy.mjs → uniqBy.js}

@@ -1,4 +1,4 @@
-import { uniqWith } from './uniqWith.mjs';
+import { uniqWith } from './uniqWith.js';
 
 /**
  * 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.

package/esm/array/uniqBy.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/array/uniqWith.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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]
+ * ```
+ */
+export declare function uniqWith<T>(arr: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[];

package/esm/array/{uniqWith.mjs → uniqWith.js}

@@ -1,4 +1,4 @@
-import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.js';
 
 /**
  * The `uniqWith` function takes an array as its first argument and a 'comparator' function as the second.
@@ -7,7 +7,7 @@ import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virt
  *
  * @example
  * ```ts
- * uniqWith([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], (a, b) => );
+ * 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]
  * ```
  */

package/esm/array/uniqWith.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/array/xor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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']);
+ */
+export declare function xor<T>(arr1: T[], arr2: T[]): T[];

package/esm/array/{xor.mjs → xor.js}

@@ -1,6 +1,6 @@
-import { difference } from './difference.mjs';
-import { intersection } from './intersection.mjs';
-import { union } from './union.mjs';
+import { difference } from './difference.js';
+import { intersection } from './intersection.js';
+import { union } from './union.js';
 
 /**
  * Computes the symmetric difference between two arrays. The symmetric difference is the set of elements

package/esm/array/xor.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/array/xorBy.d.ts

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

package/esm/array/{xorBy.mjs → xorBy.js}

@@ -1,6 +1,6 @@
-import { differenceBy } from './differenceBy.mjs';
-import { intersectionBy } from './intersectionBy.mjs';
-import { unionBy } from './unionBy.mjs';
+import { differenceBy } from './differenceBy.js';
+import { intersectionBy } from './intersectionBy.js';
+import { unionBy } from './unionBy.js';
 
 /**
  * Computes the symmetric difference between two arrays using a custom mapping function. 

package/esm/array/xorBy.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/array/xorWith.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 }]
+ */
+export declare function xorWith<T>(arr1: T[], arr2: T[], areElementsEqual: (item1: T, item2: T) => boolean): T[];

package/esm/array/{xorWith.mjs → xorWith.js}

@@ -1,6 +1,6 @@
-import { differenceWith } from './differenceWith.mjs';
-import { intersectionWith } from './intersectionWith.mjs';
-import { unionWith } from './unionWith.mjs';
+import { differenceWith } from './differenceWith.js';
+import { intersectionWith } from './intersectionWith.js';
+import { unionWith } from './unionWith.js';
 
 /**
  * Computes the symmetric difference between two arrays using a custom equality function. 

package/esm/array/xorWith.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/array/zip.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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]]
+ */
+export declare function zip<T>(arr1: T[]): [T][];
+export declare function zip<T, U>(arr1: T[], arr2: U[]): [T, U][];
+export declare function zip<T, U, V>(arr1: T[], arr2: U[], arr3: V[]): [T, U, V][];
+export declare function zip<T, U, V, W>(arr1: T[], arr2: U[], arr3: V[], arr4: W[]): [T, U, V, W][];

package/esm/array/{zip.mjs → zip.js}

@@ -1,4 +1,4 @@
-import { toConsumableArray as _toConsumableArray, createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+import { toConsumableArray as _toConsumableArray, createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.js';
 
 /**
  * Combines multiple arrays into a single array of tuples.

package/esm/array/zip.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/array/zipWith.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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`]
+ */
+export declare function zipWith<T, R>(arr1: T[], combine: (item: T) => R): R[];
+export declare function zipWith<T, U, R>(arr1: T[], arr2: U[], combine: (item1: T, item2: U) => R): R[];
+export declare function zipWith<T, U, V, R>(arr1: T[], arr2: U[], arr3: V[], combine: (item1: T, item2: U, item3: V) => R): R[];
+export 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[];

package/esm/array/{zipWith.mjs → zipWith.js}

@@ -1,4 +1,4 @@
-import { toConsumableArray as _toConsumableArray } from './_virtual/_rollupPluginBabelHelpers.mjs';
+import { toConsumableArray as _toConsumableArray } from './_virtual/_rollupPluginBabelHelpers.js';
 
 /**
  * Combines multiple arrays into a single array using a custom combiner function.

package/esm/array/zipWith.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/function/debounce.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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();
+ */
+export declare function debounce(func: () => void, debounceMs: number): {
+    (): void;
+    cancel: () => void;
+};

package/esm/function/debounce.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/function/index.d.ts

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

package/esm/function/index.js

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

package/esm/function/once.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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
+ */
+export declare function once<F extends () => any>(func: F): F;

package/esm/function/once.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/function/throttle.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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);
+ */
+export declare function throttle(func: () => void, throttleMs: number): () => void;

package/esm/function/throttle.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/index.d.ts

@@ -0,0 +1,6 @@
+export * from './array';
+export * from './function';
+export * from './math';
+export * from './object';
+export * from './predicate';
+export * from './promise';

package/esm/index.js

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

package/esm/math/clamp.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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
+ */
+export declare function clamp(value: number, maximum: number): number;
+export declare function clamp(value: number, minimum: number, maximum: number): number;

package/esm/math/clamp.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/math/index.d.ts

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

package/esm/math/index.js

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

package/esm/math/round.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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
+ */
+export declare function round(value: number, precision?: number): number;

package/esm/math/round.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/math/sum.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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
+ */
+export declare function sum(nums: number[]): number;

package/esm/math/{sum.mjs → sum.js}

@@ -1,4 +1,4 @@
-import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.js';
 
 /**
  * Calculates the sum of an array of numbers.

package/esm/math/sum.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/object/index.d.ts

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

package/esm/object/index.js

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

package/esm/object/omit.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 }
+ */
+export declare function omit<T, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;

package/esm/object/{omit.mjs → omit.js}

@@ -1,4 +1,4 @@
-import { objectSpread2 as _objectSpread2, createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+import { objectSpread2 as _objectSpread2, createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.js';
 
 /**
  * Creates a new object with specified keys omitted.

package/esm/object/omit.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/object/omitBy.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 }
+ */
+export declare function omitBy<T extends Record<string, any>>(obj: T, shouldOmit: (value: T[keyof T], key: string) => boolean): Partial<T>;