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

package/CHANGELOG.md

@@ -1,5 +1,5 @@
 # es-toolkit Changelog
 
-## Version v1.0.0
+## Version v1.0.2
 
-Initial release. Released on May 31th, 2024.
+Initial release. Released on May 31th, 2024.

package/array.d.ts

@@ -0,0 +1 @@
+export * from './dist/array';

package/dist/array/index.js

@@ -721,7 +721,7 @@ function unionBy(arr1, arr2, mapper) {
  *
  * @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/dist/array/uniqWith.d.ts

@@ -5,7 +5,7 @@
  *
  * @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/dist/index.js

@@ -806,7 +806,7 @@ function unionBy(arr1, arr2, mapper) {
  *
  * @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/chunk.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Splits an array into smaller arrays of a specified length.
+ *
+ * This function takes an input array and divides it into multiple smaller arrays,
+ * each of a specified length. If the input array cannot be evenly divided,
+ * the final sub-array will contain the remaining elements.
+ *
+ * @template T The type of elements in the array.
+ * @param {T[]} arr - The array to be chunked into smaller arrays.
+ * @param {number} size - The size of each smaller array. Must be a positive integer.
+ * @returns {T[][]} A two-dimensional array where each sub-array has a maximum length of `size`.
+ * @throws {Error} Throws an error if `size` is not a positive integer.
+ *
+ * @example
+ * // Splits an array of numbers into sub-arrays of length 2
+ * chunk([1, 2, 3, 4, 5], 2);
+ * // Returns: [[1, 2], [3, 4], [5]]
+ *
+ * @example
+ * // Splits an array of strings into sub-arrays of length 3
+ * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);
+ * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
+ */
+export declare function chunk<T>(arr: T[], size: number): T[][];

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

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

package/esm/array/difference.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Computes the difference between two arrays.
+ *
+ * This function takes two arrays and returns a new array containing the elements
+ * that are present in the first array but not in the second array. It effectively
+ * filters out any elements from the first array that also appear in the second array.
+ *
+ * @template T
+ * @param {T[]} firstArr - The array from which to derive the difference. This is the primary array
+ * from which elements will be compared and filtered.
+ * @param {T[]} secondArr - The array containing elements to be excluded from the first array.
+ * Each element in this array will be checked against the first array, and if a match is found,
+ * that element will be excluded from the result.
+ * @returns {T[]} A new array containing the elements that are present in the first array but not
+ * in the second array.
+ *
+ * @example
+ *  * const array1 = [1, 2, 3, 4, 5];
+ * const array2 = [2, 4];
+ * const result = difference(array1, array2);
+ * // result will be [1, 3, 5] since 2 and 4 are in both arrays and are excluded from the result.
+ */
+export declare function difference<T>(firstArr: T[], secondArr: T[]): T[];

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

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

package/esm/array/differenceBy.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Computes the difference between two arrays after mapping their elements through a provided function.
+ *
+ * This function takes two arrays and a mapper function. It returns a new array containing the elements
+ * that are present in the first array but not in the second array, based on the identity calculated
+ * by the mapper function.
+ *
+ * Essentially, it filters out any elements from the first array that, when
+ * mapped, match an element in the mapped version of the second array.
+ *
+ * @template T, U
+ * @param {T[]} firstArr - The primary array from which to derive the difference.
+ * @param {T[]} secondArr - The array containing elements to be excluded from the first array.
+ * @param {(value: T) => U} mapper - The function to map the elements of both arrays. This function
+ * is applied to each element in both arrays, and the comparison is made based on the mapped values.
+ * @returns {T[]} A new array containing the elements from the first array that do not have a corresponding
+ * mapped identity in the second array.
+ *
+ * @example
+ *  * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [{ id: 2 }, { id: 4 }];
+ * const mapper = item => item.id;
+ * const result = differenceBy(array1, array2, mapper);
+ * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are in both arrays and are excluded from the result.
+ */
+export declare function differenceBy<T, U>(firstArr: T[], secondArr: T[], mapper: (value: T) => U): T[];

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

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

package/esm/array/differenceWith.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Computes the difference between two arrays based on a custom equality function.
+ *
+ * This function takes two arrays and a custom comparison function. It returns a new array containing
+ * the elements that are present in the first array but not in the second array. The comparison to determine
+ * if elements are equal is made using the provided custom function.
+ *
+ * @template T
+ * @param {T[]} firstArr - The array from which to get the difference.
+ * @param {T[]} secondArr - The array containing elements to exclude from the first array.
+ * @param {(x: T, y: T) => boolean} areItemsEqual - A function to determine if two items are equal.
+ * @returns {T[]} A new array containing the elements from the first array that do not match any elements in the second array
+ * according to the custom equality function.
+ *
+ * @example
+ *  * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [{ id: 2 }, { id: 4 }];
+ * const areItemsEqual = (a, b) => a.id === b.id;
+ * const result = differenceWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are considered equal and are excluded from the result.
+ */
+export declare function differenceWith<T>(firstArr: T[], secondArr: T[], areItemsEqual: (x: T, y: T) => boolean): T[];

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

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

package/esm/array/drop.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Removes a specified number of elements from the beginning of an array and returns the rest.
+ *
+ * This function takes an array and a number, and returns a new array with the specified number
+ * of elements removed from the start.
+ *
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {number} itemsCount - The number of elements to drop from the beginning of the array.
+ * @returns {T[]} A new array with the specified number of elements removed from the start.
+ *
+ * @example
+ *  * const array = [1, 2, 3, 4, 5];
+ * const result = drop(array, 2);
+ * // result will be [3, 4, 5] since the first two elements are dropped.
+ */
+export declare function drop<T>(arr: T[], itemsCount: number): T[];

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

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

package/esm/array/dropRight.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Removes a specified number of elements from the end of an array and returns the rest.
+ *
+ * This function takes an array and a number, and returns a new array with the specified number
+ * of elements removed from the end.
+ *
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {number} itemsCount - The number of elements to drop from the end of the array.
+ * @returns {T[]} A new array with the specified number of elements removed from the end.
+ *
+ * @example
+ *  * const array = [1, 2, 3, 4, 5];
+ * const result = dropRight(array, 2);
+ * // result will be [1, 2, 3] since the last two elements are dropped.
+ */
+export declare function dropRight<T>(arr: T[], itemsCount: number): T[];

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

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

package/esm/array/dropRightWhile.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Removes elements from the end of an array until the predicate returns false.
+ *
+ * This function iterates over an array from the end and drops elements until the provided
+ * predicate function returns false. It then returns a new array with the remaining elements.
+ *
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {function(item: T): boolean} canContinueDropping - A predicate function that determines
+ * whether to continue dropping elements. The function is called with each element from the end,
+ * and dropping continues as long as it returns true.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const result = dropRightWhile(array, x => x > 3);
+ * // result will be [1, 2, 3] since elements greater than 3 are dropped from the end.
+ */
+export declare function dropRightWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean): T[];

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

@@ -1,4 +1,4 @@
-import { dropWhile } from './dropWhile.mjs';
+import { dropWhile } from './dropWhile.js';
 
 /**
  * Removes elements from the end of an array until the predicate returns false.

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

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

package/esm/array/dropWhile.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Removes elements from the beginning of an array until the predicate returns false.
+ *
+ * This function iterates over an array and drops elements from the start until the provided
+ * predicate function returns false. It then returns a new array with the remaining elements.
+ *
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {(item: T) => boolean} canContinueDropping - A predicate function that determines
+ * whether to continue dropping elements. The function is called with each element, and dropping
+ * continues as long as it returns true.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const result = dropWhile(array, x => x < 3);
+ * // result will be [3, 4, 5] since elements less than 3 are dropped.
+ */
+export declare function dropWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean): T[];

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

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

package/esm/array/groupBy.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Groups the elements of an array based on a provided key-generating function.
+ *
+ * This function takes an array and a function that generates a key from each element. It returns
+ * an object where the keys are the generated keys and the values are arrays of elements that share
+ * the same key.
+ *
+ * @param {T[]} arr - The array to group.
+ * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.
+ * @returns {Record<K, T[]>} An object where each key is associated with an array of elements that
+ * share that key.
+ *
+ * @example
+ * const array = [
+ *   { category: 'fruit', name: 'apple' },
+ *   { category: 'fruit', name: 'banana' },
+ *   { category: 'vegetable', name: 'carrot' }
+ * ];
+ * const result = groupBy(array, item => item.category);
+ * // result will be:
+ * // {
+ * //   fruit: [
+ * //     { category: 'fruit', name: 'apple' },
+ * //     { category: 'fruit', name: 'banana' }
+ * //   ],
+ * //   vegetable: [
+ * //     { category: 'vegetable', name: 'carrot' }
+ * //   ]
+ * // }
+ */
+export declare function groupBy<T, K extends string>(arr: T[], getKeyFromItem: (item: T) => K): Record<K, T[]>;

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

@@ -1,4 +1,4 @@
-import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.js';
 
 /**
  * Groups the elements of an array based on a provided key-generating function.

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

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

package/esm/array/index.d.ts

@@ -0,0 +1,30 @@
+export { chunk } from './chunk';
+export { difference } from './difference';
+export { differenceBy } from './differenceBy';
+export { differenceWith } from './differenceWith';
+export { drop } from './drop';
+export { dropRight } from './dropRight';
+export { dropRightWhile } from './dropRightWhile';
+export { dropWhile } from './dropWhile';
+export { groupBy } from './groupBy';
+export { intersection } from './intersection';
+export { intersectionBy } from './intersectionBy';
+export { intersectionWith } from './intersectionWith';
+export { partition } from './partition';
+export { sample } from './sample';
+export { shuffle } from './shuffle';
+export { take } from './take';
+export { takeRight } from './takeRight';
+export { takeRightWhile } from './takeRightWhile';
+export { takeWhile } from './takeWhile';
+export { union } from './union';
+export { unionBy } from './unionBy';
+export { unionWith } from './unionWith';
+export { uniq } from './uniq';
+export { uniqBy } from './uniqBy';
+export { uniqWith } from './uniqWith';
+export { xor } from './xor';
+export { xorBy } from './xorBy';
+export { xorWith } from './xorWith';
+export { zip } from './zip';
+export { zipWith } from './zipWith';

package/esm/array/index.js

@@ -0,0 +1,30 @@
+export { chunk } from './chunk.js';
+export { difference } from './difference.js';
+export { differenceBy } from './differenceBy.js';
+export { differenceWith } from './differenceWith.js';
+export { drop } from './drop.js';
+export { dropRight } from './dropRight.js';
+export { dropRightWhile } from './dropRightWhile.js';
+export { dropWhile } from './dropWhile.js';
+export { groupBy } from './groupBy.js';
+export { intersection } from './intersection.js';
+export { intersectionBy } from './intersectionBy.js';
+export { intersectionWith } from './intersectionWith.js';
+export { partition } from './partition.js';
+export { sample } from './sample.js';
+export { shuffle } from './shuffle.js';
+export { take } from './take.js';
+export { takeRight } from './takeRight.js';
+export { takeRightWhile } from './takeRightWhile.js';
+export { takeWhile } from './takeWhile.js';
+export { union } from './union.js';
+export { unionBy } from './unionBy.js';
+export { unionWith } from './unionWith.js';
+export { uniq } from './uniq.js';
+export { uniqBy } from './uniqBy.js';
+export { uniqWith } from './uniqWith.js';
+export { xor } from './xor.js';
+export { xorBy } from './xorBy.js';
+export { xorWith } from './xorWith.js';
+export { zip } from './zip.js';
+export { zipWith } from './zipWith.js';

package/esm/array/intersection.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Returns the intersection of two arrays.
+ *
+ * This function takes two arrays and returns a new array containing the elements that are
+ * present in both arrays. It effectively filters out any elements from the first array that
+ * are not found in the second array.
+ *
+ * @param {T[]} firstArr - The first array to compare.
+ * @param {T[]} secondArr - The second array to compare.
+ * @returns {T[]} A new array containing the elements that are present in both arrays.
+ *
+ * @example
+ * const array1 = [1, 2, 3, 4, 5];
+ * const array2 = [3, 4, 5, 6, 7];
+ * const result = intersection(array1, array2);
+ * // result will be [3, 4, 5] since these elements are in both arrays.
+ */
+export declare function intersection<T>(firstArr: T[], secondArr: T[]): T[];

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

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

package/esm/array/intersectionBy.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Returns the intersection of two arrays based on a mapping function.
+ *
+ * This function takes two arrays and a mapping function. It returns a new array containing
+ * the elements from the first array that, when mapped using the provided function, have matching
+ * mapped elements in the second array. It effectively filters out any elements from the first array
+ * that do not have corresponding mapped values in the second array.
+ *
+ * @param {T[]} firstArr - The first array to compare.
+ * @param {T[]} secondArr - The second array to compare.
+ * @param {(item: T) => U} mapper - A function to map the elements of both arrays for comparison.
+ * @returns {T[]} A new array containing the elements from the first array that have corresponding mapped values in the second array.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [{ id: 2 }, { id: 4 }];
+ * const mapper = item => item.id;
+ * const result = intersectionBy(array1, array2, mapper);
+ * // result will be [{ id: 2 }] since only this element has a matching id in both arrays.
+ */
+export declare function intersectionBy<T, U>(firstArr: T[], secondArr: T[], mapper: (item: T) => U): T[];

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

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

package/esm/array/intersectionWith.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Returns the intersection of two arrays based on a custom equality function.
+ *
+ * This function takes two arrays and a custom equality function. It returns a new array containing
+ * the elements from the first array that have matching elements in the second array, as determined
+ * by the custom equality function. It effectively filters out any elements from the first array that
+ * do not have corresponding matches in the second array according to the equality function.
+ *
+ * @param {T[]} firstArr - The first array to compare.
+ * @param {T[]} secondArr - The second array to compare.
+ * @param {(x: T, y: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal.
+ * This function takes two arguments, one from each array, and returns `true` if the elements are considered equal, and `false` otherwise.
+ * @returns {T[]} A new array containing the elements from the first array that have corresponding matches in the second array according to the custom equality function.
+ *
+ * @example
+ *  * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [{ id: 2 }, { id: 4 }];
+ * const areItemsEqual = (a, b) => a.id === b.id;
+ * const result = intersectionWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 2 }] since this element has a matching id in both arrays.
+ */
+export declare function intersectionWith<T>(firstArr: T[], secondArr: T[], areItemsEqual: (x: T, y: T) => boolean): T[];

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

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

package/esm/array/partition.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Splits an array into two groups based on a predicate function.
+ *
+ * This function takes an array and a predicate function. It returns a tuple of two arrays:
+ * the first array contains elements for which the predicate function returns true, and
+ * the second array contains elements for which the predicate function returns false.
+ *
+ * @param {T[]} arr - The array to partition.
+ * @param {(value: T) => boolean} isInTruthy - A predicate function that determines
+ * whether an element should be placed in the truthy array. The function is called with each
+ * element of the array.
+ * @returns {[T[], T[]]} A tuple containing two arrays: the first array contains elements for
+ * which the predicate returned true, and the second array contains elements for which the
+ * predicate returned false.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const isEven = x => x % 2 === 0;
+ * const [even, odd] = partition(array, isEven);
+ * // even will be [2, 4], and odd will be [1, 3, 5]
+ */
+export declare function partition<T>(arr: T[], isInTruthy: (value: T) => boolean): [truthy: T[], falsy: T[]];

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

@@ -1,4 +1,4 @@
-import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.js';
 
 /**
  * Splits an array into two groups based on a predicate function.

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

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

package/esm/array/sample.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns a random element from an array.
+ *
+ * This function takes an array and returns a single element selected randomly from the array.
+ *
+ * @param {T[]} arr - The array to sample from.
+ * @returns {T} A random element from the array.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const randomElement = sample(array);
+ * // randomElement will be one of the elements from the array, selected randomly.
+ */
+export declare function sample<T>(arr: T[]): T;

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

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

package/esm/array/shuffle.d.ts

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

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

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

package/esm/array/take.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Returns a new array containing the first `count` elements from the input array `arr`.
+ * If `count` is greater than the length of `arr`, the entire array is returned.
+ *
+ * @template T - Type of elements in the input array.
+ *
+ * @param {T[]} arr - The array to take elements from.
+ * @param {number} count - The number of elements to take.
+ * @returns {T[]} A new array containing the first `count` elements from `arr`.
+ *
+ * @example
+ * // Returns [1, 2, 3]
+ * take([1, 2, 3, 4, 5], 3);
+ *
+ * @example
+ * // Returns ['a', 'b']
+ * take(['a', 'b', 'c'], 2);
+ *
+ * @example
+ * // Returns [1, 2, 3]
+ * take([1, 2, 3], 5);
+ */
+export declare function take<T>(arr: T[], count: number): T[];

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

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

package/esm/array/takeRight.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Returns a new array containing the last `count` elements from the input array `arr`.
+ * If `count` is greater than the length of `arr`, the entire array is returned.
+ *
+ * @param {T[]} arr - The array to take elements from.
+ * @param {number} count - The number of elements to take.
+ * @returns {T[]} A new array containing the last `count` elements from `arr`.
+ *
+ * @example
+ * // Returns [4, 5]
+ * takeRight([1, 2, 3, 4, 5], 2);
+ *
+ * @example
+ * // Returns ['b', 'c']
+ * takeRight(['a', 'b', 'c'], 2);
+ *
+ * @example
+ * // Returns [1, 2, 3]
+ * takeRight([1, 2, 3], 5);
+ */
+export declare function takeRight<T>(arr: T[], count: number): T[];

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

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

package/esm/array/takeRightWhile.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Takes elements from the end of the array while the predicate function returns `true`.
+ *
+ * @template T - Type of elements in the input array.
+ *
+ * @param {T[]} arr - The array to take elements from.
+ * @param {function(T): boolean} shouldContinueTaking - The function invoked per element.
+ * @returns {T[]} A new array containing the elements taken from the end while the predicate returns `true`.
+ *
+ * @example
+ * // Returns [3, 2, 1]
+ * takeRightWhile([5, 4, 3, 2, 1], n => n < 4);
+ *
+ * @example
+ * // Returns []
+ * takeRightWhile([1, 2, 3], n => n > 3);
+ */
+export declare function takeRightWhile<T>(arr: T[], shouldContinueTaking: (item: T) => boolean): T[];

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

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

package/esm/array/takeWhile.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Returns a new array containing the leading elements of the provided array
+ * that satisfy the provided predicate function. It stops taking elements as soon
+ * as an element does not satisfy the predicate.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array to process.
+ * @param {(element: T) => boolean} shouldContinueTaking - The predicate function that is called with each element. Elements are included in the result as long as this function returns true.
+ * @returns {T[]} A new array containing the leading elements that satisfy the predicate.
+ *
+ * @example
+ * // Returns [1, 2]
+ * takeWhile([1, 2, 3, 4], x => x < 3);
+ *
+ * @example
+ * // Returns []
+ * takeWhile([1, 2, 3, 4], x => x > 3);
+ */
+export declare function takeWhile<T>(arr: T[], shouldContinueTaking: (element: T) => boolean): T[];

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

@@ -1,4 +1,4 @@
-import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.js';
 
 /**
  * Returns a new array containing the leading elements of the provided array

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

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

package/esm/array/union.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Creates an array of unique values from all given arrays.
+ *
+ * This function takes two arrays, merges them into a single array, and returns a new array
+ * containing only the unique values from the merged array.
+ *
+ * @param {T[]} arr1 - The first array to merge and filter for unique values.
+ * @param {T[]} arr2 - The second array to merge and filter for unique values.
+ * @returns {T[]} A new array of unique values.
+ *
+ * @example
+ * const array1 = [1, 2, 3];
+ * const array2 = [3, 4, 5];
+ * const result = union(array1, array2);
+ * // result will be [1, 2, 3, 4, 5]
+ */
+export declare function union<T>(arr1: T[], arr2: T[]): T[];

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

@@ -1,4 +1,4 @@
-import { uniq } from './uniq.mjs';
+import { uniq } from './uniq.js';
 
 /**
  * Creates an array of unique values from all given arrays.