es-toolkit 1.31.0 → 1.32.0

package/dist/compat/array/find.d.mts

@@ -4,6 +4,7 @@
  * @template T
  * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
  * @param {(item: T, index: number, arr: T[]) => unknown} doesMatch - A function that takes an item, its index, and the array, and returns a truthy value if the item matches the criteria.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that matches the predicate, or `undefined` if no match is found.
  *
  * @example
@@ -12,13 +13,14 @@
  * const result = find(items, (item) => item > 3);
  * console.log(result); // 4
  */
-declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: (item: T, index: number, arr: readonly T[]) => unknown): T | undefined;
+declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: (item: T, index: number, arr: readonly T[]) => unknown, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an array that matches the given partial object.
  *
  * @template T
  * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
  * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that matches the partial object, or `undefined` if no match is found.
  *
  * @example
@@ -27,13 +29,14 @@ declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: (item:
  * const result = find(items, { name: 'Bob' });
  * console.log(result); // { id: 2, name: 'Bob' }
  */
-declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>): T | undefined;
+declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an array that matches a property with a specific value.
  *
  * @template T
  * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
  * @param {[keyof T, unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that has the specified property value, or `undefined` if no match is found.
  *
  * @example
@@ -42,13 +45,14 @@ declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partia
  * const result = find(items, ['name', 'Alice']);
  * console.log(result); // { id: 1, name: 'Alice' }
  */
-declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty: [keyof T, unknown]): T | undefined;
+declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty: [keyof T, unknown], fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an array that has a specific property, where the property name is provided as a PropertyKey.
  *
  * @template T
  * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
  * @param {PropertyKey} propertyToCheck - The property name to check.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that has the specified property, or `undefined` if no match is found.
  *
  * @example
@@ -57,13 +61,14 @@ declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty
  * const result = find(items, 'name');
  * console.log(result); // { id: 1, name: 'Alice' }
  */
-declare function find<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: PropertyKey): T | undefined;
+declare function find<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: PropertyKey, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an object that matches the given predicate function.
  *
  * @template T
  * @param {T | null | undefined} object - The object to search through.
  * @param {(item: T[keyof T], index: number, arr: T) => unknown} doesMatch - A function that takes an item, its key, and the object, and returns a truthy value if the item matches the criteria.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first property value that matches the predicate, or `undefined` if no match is found.
  *
  * @example
@@ -72,13 +77,14 @@ declare function find<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck:
  * const result = find(obj, (item) => item > 2);
  * console.log(result); // 3
  */
-declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (item: T[keyof T], index: keyof T, object: T) => unknown): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (item: T[keyof T], index: keyof T, object: T) => unknown, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an object that matches the given partial value.
  *
  * @template T
  * @param {T | null | undefined} object - The object to search through.
  * @param {Partial<T[keyof T]>} doesMatch - A partial value to match against the values of the object.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first property value that matches the partial value, or `undefined` if no match is found.
  *
  * @example
@@ -87,13 +93,14 @@ declare function find<T extends Record<string, unknown>>(object: T | null | unde
  * const result = find(obj, { name: 'Bob' });
  * console.log(result); // { id: 2, name: 'Bob' }
  */
-declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an object that matches a property with a specific value.
  *
  * @template T
  * @param {T | null | undefined} object - The object to search through.
  * @param {[keyof T[keyof T], unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that has the specified property value, or `undefined` if no match is found.
  *
  * @example
@@ -102,13 +109,14 @@ declare function find<T extends Record<string, unknown>>(object: T | null | unde
  * const result = find(items, ['name', 'Alice']);
  * console.log(result); // { id: 1, name: 'Alice' }
  */
-declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown]): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown], fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an object that has a specific property, where the property name is provided as a PropertyKey.
  *
  * @template T
  * @param {T | null | undefined} object - The object to search through.
  * @param {PropertyKey} propertyToCheck - The property name to check.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first property value that has the specified property, or `undefined` if no match is found.
  *
  * @example
@@ -117,6 +125,6 @@ declare function find<T extends Record<string, unknown>>(object: T | null | unde
  * const result = find(obj, 'name');
  * console.log(result); // { id: 1, name: 'Alice' }
  */
-declare function find<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: PropertyKey): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: PropertyKey, fromIndex?: number): T | undefined;
 
 export { find };

package/dist/compat/array/find.d.ts

@@ -4,6 +4,7 @@
  * @template T
  * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
  * @param {(item: T, index: number, arr: T[]) => unknown} doesMatch - A function that takes an item, its index, and the array, and returns a truthy value if the item matches the criteria.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that matches the predicate, or `undefined` if no match is found.
  *
  * @example
@@ -12,13 +13,14 @@
  * const result = find(items, (item) => item > 3);
  * console.log(result); // 4
  */
-declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: (item: T, index: number, arr: readonly T[]) => unknown): T | undefined;
+declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: (item: T, index: number, arr: readonly T[]) => unknown, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an array that matches the given partial object.
  *
  * @template T
  * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
  * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that matches the partial object, or `undefined` if no match is found.
  *
  * @example
@@ -27,13 +29,14 @@ declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: (item:
  * const result = find(items, { name: 'Bob' });
  * console.log(result); // { id: 2, name: 'Bob' }
  */
-declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>): T | undefined;
+declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an array that matches a property with a specific value.
  *
  * @template T
  * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
  * @param {[keyof T, unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that has the specified property value, or `undefined` if no match is found.
  *
  * @example
@@ -42,13 +45,14 @@ declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partia
  * const result = find(items, ['name', 'Alice']);
  * console.log(result); // { id: 1, name: 'Alice' }
  */
-declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty: [keyof T, unknown]): T | undefined;
+declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty: [keyof T, unknown], fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an array that has a specific property, where the property name is provided as a PropertyKey.
  *
  * @template T
  * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
  * @param {PropertyKey} propertyToCheck - The property name to check.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that has the specified property, or `undefined` if no match is found.
  *
  * @example
@@ -57,13 +61,14 @@ declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty
  * const result = find(items, 'name');
  * console.log(result); // { id: 1, name: 'Alice' }
  */
-declare function find<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: PropertyKey): T | undefined;
+declare function find<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: PropertyKey, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an object that matches the given predicate function.
  *
  * @template T
  * @param {T | null | undefined} object - The object to search through.
  * @param {(item: T[keyof T], index: number, arr: T) => unknown} doesMatch - A function that takes an item, its key, and the object, and returns a truthy value if the item matches the criteria.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first property value that matches the predicate, or `undefined` if no match is found.
  *
  * @example
@@ -72,13 +77,14 @@ declare function find<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck:
  * const result = find(obj, (item) => item > 2);
  * console.log(result); // 3
  */
-declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (item: T[keyof T], index: keyof T, object: T) => unknown): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (item: T[keyof T], index: keyof T, object: T) => unknown, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an object that matches the given partial value.
  *
  * @template T
  * @param {T | null | undefined} object - The object to search through.
  * @param {Partial<T[keyof T]>} doesMatch - A partial value to match against the values of the object.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first property value that matches the partial value, or `undefined` if no match is found.
  *
  * @example
@@ -87,13 +93,14 @@ declare function find<T extends Record<string, unknown>>(object: T | null | unde
  * const result = find(obj, { name: 'Bob' });
  * console.log(result); // { id: 2, name: 'Bob' }
  */
-declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an object that matches a property with a specific value.
  *
  * @template T
  * @param {T | null | undefined} object - The object to search through.
  * @param {[keyof T[keyof T], unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that has the specified property value, or `undefined` if no match is found.
  *
  * @example
@@ -102,13 +109,14 @@ declare function find<T extends Record<string, unknown>>(object: T | null | unde
  * const result = find(items, ['name', 'Alice']);
  * console.log(result); // { id: 1, name: 'Alice' }
  */
-declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown]): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown], fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an object that has a specific property, where the property name is provided as a PropertyKey.
  *
  * @template T
  * @param {T | null | undefined} object - The object to search through.
  * @param {PropertyKey} propertyToCheck - The property name to check.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first property value that has the specified property, or `undefined` if no match is found.
  *
  * @example
@@ -117,6 +125,6 @@ declare function find<T extends Record<string, unknown>>(object: T | null | unde
  * const result = find(obj, 'name');
  * console.log(result); // { id: 1, name: 'Alice' }
  */
-declare function find<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: PropertyKey): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: PropertyKey, fromIndex?: number): T | undefined;
 
 export { find };

package/dist/compat/array/find.mjs

@@ -2,11 +2,14 @@ import { property } from '../object/property.mjs';
 import { matches } from '../predicate/matches.mjs';
 import { matchesProperty } from '../predicate/matchesProperty.mjs';
 
-function find(source, doesMatch) {
+function find(source, doesMatch, fromIndex = 0) {
     if (!source) {
         return undefined;
     }
-    const values = Array.isArray(source) ? source : Object.values(source);
+    if (fromIndex < 0) {
+        fromIndex = Math.max(source.length + fromIndex, 0);
+    }
+    const values = Array.isArray(source) ? source.slice(fromIndex) : Object.values(source).slice(fromIndex);
     switch (typeof doesMatch) {
         case 'function': {
             if (!Array.isArray(source)) {

package/dist/compat/array/sortedIndex.d.mts

@@ -0,0 +1,16 @@
+/**
+ * Uses a binary search to determine the lowest index at which `value`
+ * should be inserted into `array` in order to maintain its sort order.
+ *
+ * @category Array
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to evaluate.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ * sortedIndex([30, 50], 40)
+ * // => 1
+ */
+declare function sortedIndex<T>(array: ArrayLike<T> | null | undefined, value: T): number;
+
+export { sortedIndex };

package/dist/compat/array/sortedIndex.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Uses a binary search to determine the lowest index at which `value`
+ * should be inserted into `array` in order to maintain its sort order.
+ *
+ * @category Array
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to evaluate.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ * sortedIndex([30, 50], 40)
+ * // => 1
+ */
+declare function sortedIndex<T>(array: ArrayLike<T> | null | undefined, value: T): number;
+
+export { sortedIndex };

package/dist/compat/array/sortedIndex.mjs

@@ -0,0 +1,30 @@
+import { sortedIndexBy } from './sortedIndexBy.mjs';
+import { isNil } from '../../predicate/isNil.mjs';
+import { isNull } from '../../predicate/isNull.mjs';
+import { isSymbol } from '../../predicate/isSymbol.mjs';
+import { isNumber } from '../predicate/isNumber.mjs';
+
+const MAX_ARRAY_LENGTH = 4294967295;
+const HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
+function sortedIndex(array, value) {
+    if (isNil(array)) {
+        return 0;
+    }
+    let low = 0, high = isNil(array) ? low : array.length;
+    if (isNumber(value) && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
+        while (low < high) {
+            const mid = (low + high) >>> 1;
+            const compute = array[mid];
+            if (!isNull(compute) && !isSymbol(compute) && compute < value) {
+                low = mid + 1;
+            }
+            else {
+                high = mid;
+            }
+        }
+        return high;
+    }
+    return sortedIndexBy(array, value, value => value);
+}
+
+export { sortedIndex };

package/dist/compat/array/sortedIndexBy.d.mts

@@ -0,0 +1,19 @@
+type Iteratee<T, R> = (value: T) => R;
+/**
+ * This method is like `sortedIndex` except that it accepts `iteratee`
+ * which is invoked for `value` and each element of `array` to compute their
+ * sort ranking. The iteratee is invoked with one argument: (value).
+ *
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to evaluate.
+ * @param {(value: T) => R} iteratee The iteratee invoked per element.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ * const objects = [{ 'n': 4 }, { 'n': 5 }]
+ * sortedIndexBy(objects, { 'n': 4 }, ({ n }) => n)
+ * // => 0
+ */
+declare function sortedIndexBy<T, R>(array: ArrayLike<T> | null | undefined, value: T, iteratee?: Iteratee<T, R>, retHighest?: boolean): number;
+
+export { sortedIndexBy };

package/dist/compat/array/sortedIndexBy.d.ts

@@ -0,0 +1,19 @@
+type Iteratee<T, R> = (value: T) => R;
+/**
+ * This method is like `sortedIndex` except that it accepts `iteratee`
+ * which is invoked for `value` and each element of `array` to compute their
+ * sort ranking. The iteratee is invoked with one argument: (value).
+ *
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to evaluate.
+ * @param {(value: T) => R} iteratee The iteratee invoked per element.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ * const objects = [{ 'n': 4 }, { 'n': 5 }]
+ * sortedIndexBy(objects, { 'n': 4 }, ({ n }) => n)
+ * // => 0
+ */
+declare function sortedIndexBy<T, R>(array: ArrayLike<T> | null | undefined, value: T, iteratee?: Iteratee<T, R>, retHighest?: boolean): number;
+
+export { sortedIndexBy };

package/dist/compat/array/sortedIndexBy.mjs

@@ -0,0 +1,56 @@
+import { isNull } from '../../predicate/isNull.mjs';
+import { isUndefined } from '../../predicate/isUndefined.mjs';
+import { isNaN } from '../predicate/isNaN.mjs';
+import { isNil } from '../predicate/isNil.mjs';
+import { isSymbol } from '../predicate/isSymbol.mjs';
+
+const MAX_ARRAY_LENGTH = 4294967295;
+const MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1;
+function sortedIndexBy(array, value, iteratee, retHighest) {
+    let low = 0;
+    let high = array == null ? 0 : array.length;
+    if (high === 0 || isNil(array)) {
+        return 0;
+    }
+    const transformedValue = iteratee?.(value);
+    const valIsNaN = isNaN(transformedValue);
+    const valIsNull = isNull(transformedValue);
+    const valIsSymbol = isSymbol(transformedValue);
+    const valIsUndefined = isUndefined(transformedValue);
+    while (low < high) {
+        let setLow;
+        const mid = Math.floor((low + high) / 2);
+        const computed = iteratee?.(array[mid]);
+        const othIsDefined = !isUndefined(computed);
+        const othIsNull = isNull(computed);
+        const othIsReflexive = !isNaN(computed);
+        const othIsSymbol = isSymbol(computed);
+        if (valIsNaN) {
+            setLow = retHighest || othIsReflexive;
+        }
+        else if (valIsUndefined) {
+            setLow = othIsReflexive && (retHighest || othIsDefined);
+        }
+        else if (valIsNull) {
+            setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
+        }
+        else if (valIsSymbol) {
+            setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
+        }
+        else if (othIsNull || othIsSymbol) {
+            setLow = false;
+        }
+        else {
+            setLow = retHighest ? computed <= transformedValue : computed < transformedValue;
+        }
+        if (setLow) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return Math.min(high, MAX_ARRAY_INDEX);
+}
+
+export { sortedIndexBy };

package/dist/compat/index.d.mts

@@ -36,6 +36,7 @@ export { noop } from '../function/noop.mjs';
 export { once } from '../function/once.mjs';
 export { partial } from '../function/partial.mjs';
 export { partialRight } from '../function/partialRight.mjs';
+export { retry } from '../function/retry.mjs';
 export { ThrottledFunction } from '../function/throttle.mjs';
 export { unary } from '../function/unary.mjs';
 export { mean } from '../math/mean.mjs';
@@ -58,7 +59,10 @@ export { isLength } from '../predicate/isLength.mjs';
 export { isNotNil } from '../predicate/isNotNil.mjs';
 export { isNull } from '../predicate/isNull.mjs';
 export { isPrimitive } from '../predicate/isPrimitive.mjs';
+export { isPromise } from '../predicate/isPromise.mjs';
 export { isUndefined } from '../predicate/isUndefined.mjs';
+export { Mutex } from '../promise/mutex.mjs';
+export { Semaphore } from '../promise/semaphore.mjs';
 export { timeout } from '../promise/timeout.mjs';
 export { withTimeout } from '../promise/withTimeout.mjs';
 export { capitalize } from '../string/capitalize.mjs';
@@ -106,6 +110,8 @@ export { size } from './array/size.mjs';
 export { slice } from './array/slice.mjs';
 export { some } from './array/some.mjs';
 export { sortBy } from './array/sortBy.mjs';
+export { sortedIndex } from './array/sortedIndex.mjs';
+export { sortedIndexBy } from './array/sortedIndexBy.mjs';
 export { tail } from './array/tail.mjs';
 export { take } from './array/take.mjs';
 export { takeRight } from './array/takeRight.mjs';
@@ -144,6 +150,7 @@ export { floor } from './math/floor.mjs';
 export { inRange } from './math/inRange.mjs';
 export { max } from './math/max.mjs';
 export { min } from './math/min.mjs';
+export { multiply } from './math/multiply.mjs';
 export { parseInt } from './math/parseInt.mjs';
 export { random } from './math/random.mjs';
 export { range } from './math/range.mjs';

package/dist/compat/index.d.ts

@@ -36,6 +36,7 @@ export { noop } from '../function/noop.js';
 export { once } from '../function/once.js';
 export { partial } from '../function/partial.js';
 export { partialRight } from '../function/partialRight.js';
+export { retry } from '../function/retry.js';
 export { ThrottledFunction } from '../function/throttle.js';
 export { unary } from '../function/unary.js';
 export { mean } from '../math/mean.js';
@@ -58,7 +59,10 @@ export { isLength } from '../predicate/isLength.js';
 export { isNotNil } from '../predicate/isNotNil.js';
 export { isNull } from '../predicate/isNull.js';
 export { isPrimitive } from '../predicate/isPrimitive.js';
+export { isPromise } from '../predicate/isPromise.js';
 export { isUndefined } from '../predicate/isUndefined.js';
+export { Mutex } from '../promise/mutex.js';
+export { Semaphore } from '../promise/semaphore.js';
 export { timeout } from '../promise/timeout.js';
 export { withTimeout } from '../promise/withTimeout.js';
 export { capitalize } from '../string/capitalize.js';
@@ -106,6 +110,8 @@ export { size } from './array/size.js';
 export { slice } from './array/slice.js';
 export { some } from './array/some.js';
 export { sortBy } from './array/sortBy.js';
+export { sortedIndex } from './array/sortedIndex.js';
+export { sortedIndexBy } from './array/sortedIndexBy.js';
 export { tail } from './array/tail.js';
 export { take } from './array/take.js';
 export { takeRight } from './array/takeRight.js';
@@ -144,6 +150,7 @@ export { floor } from './math/floor.js';
 export { inRange } from './math/inRange.js';
 export { max } from './math/max.js';
 export { min } from './math/min.js';
+export { multiply } from './math/multiply.js';
 export { parseInt } from './math/parseInt.js';
 export { random } from './math/random.js';
 export { range } from './math/range.js';