es-toolkit 1.31.0 → 1.32.0-dev.1005

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';
@@ -99,6 +103,7 @@ export { nth } from './array/nth.js';
 export { orderBy } from './array/orderBy.js';
 export { pull } from './array/pull.js';
 export { pullAll } from './array/pullAll.js';
+export { pullAllBy } from './array/pullAllBy.js';
 export { remove } from './array/remove.js';
 export { reverse } from './array/reverse.js';
 export { sample } from './array/sample.js';
@@ -106,6 +111,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 +151,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';

package/dist/compat/index.js

@@ -3,14 +3,16 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const zipWith = require('../_chunk/zipWith-Bdyzuy.js');
-const promise_index = require('../_chunk/index-BGZDR9.js');
-const unary = require('../_chunk/unary-B6qG7C.js');
+const AbortError = require('../_chunk/AbortError-Cg4ZQ1.js');
+const error_index = require('../error/index.js');
+const unary = require('../_chunk/unary-c1NFA5.js');
 const noop = require('../_chunk/noop-2IwLUk.js');
 const range$1 = require('../_chunk/range-HnEIT7.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
-const toMerged = require('../_chunk/toMerged-DGFrN7.js');
-const isPlainObject$1 = require('../_chunk/isPlainObject-octpoD.js');
-const isWeakSet$1 = require('../_chunk/isWeakSet-CvIdTA.js');
+const toMerged = require('../_chunk/toMerged-BQTfB8.js');
+const isPlainObject$1 = require('../_chunk/isPlainObject-Xaozpc.js');
+const isWeakSet$1 = require('../_chunk/isWeakSet-DoHqUM.js');
+const promise_index = require('../promise/index.js');
 const upperFirst$1 = require('../_chunk/upperFirst-CorAVn.js');
 const util_index = require('../util/index.js');
 
@@ -361,14 +363,14 @@ function cloneDeepWith(obj, cloneValue) {
             return undefined;
         }
         switch (Object.prototype.toString.call(obj)) {
-            case isWeakSet$1.numberTag:
-            case isWeakSet$1.stringTag:
-            case isWeakSet$1.booleanTag: {
+            case isPlainObject$1.numberTag:
+            case isPlainObject$1.stringTag:
+            case isPlainObject$1.booleanTag: {
                 const result = new obj.constructor(obj?.valueOf());
                 toMerged.copyProperties(result, obj);
                 return result;
             }
-            case isWeakSet$1.argumentsTag: {
+            case isPlainObject$1.argumentsTag: {
                 const result = {};
                 toMerged.copyProperties(result, obj);
                 result.length = obj.length;
@@ -402,7 +404,7 @@ function isIndex(value, length = Number.MAX_SAFE_INTEGER) {
 }
 
 function isArguments(value) {
-    return value !== null && typeof value === 'object' && isWeakSet$1.getTag(value) === '[object Arguments]';
+    return value !== null && typeof value === 'object' && isPlainObject$1.getTag(value) === '[object Arguments]';
 }
 
 function has(object, path) {
@@ -726,11 +728,14 @@ function filter(source, predicate) {
     }
 }
 
-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)) {
@@ -1172,6 +1177,25 @@ function pullAll(arr, valuesToRemove = []) {
     return zipWith.pull(arr, Array.from(valuesToRemove));
 }
 
+function pullAllBy(arr, valuesToRemove, _getValue) {
+    const getValue = iteratee(_getValue);
+    const valuesSet = new Set(Array.from(valuesToRemove).map(x => getValue(x)));
+    let resultIndex = 0;
+    for (let i = 0; i < arr.length; i++) {
+        const value = getValue(arr[i]);
+        if (valuesSet.has(value)) {
+            continue;
+        }
+        if (!Object.hasOwn(arr, i)) {
+            delete arr[resultIndex++];
+            continue;
+        }
+        arr[resultIndex++] = arr[i];
+    }
+    arr.length = resultIndex;
+    return arr;
+}
+
 function remove(arr, shouldRemoveElement) {
     return zipWith.remove(arr, iteratee(shouldRemoveElement));
 }
@@ -1292,6 +1316,90 @@ function sortBy(collection, ...criteria) {
     return orderBy(collection, zipWith.flatten(criteria), ['asc']);
 }
 
+function isNaN(value) {
+    return Number.isNaN(value);
+}
+
+function isNil(x) {
+    return x == null;
+}
+
+const MAX_ARRAY_LENGTH$2 = 4294967295;
+const MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH$2 - 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 = isWeakSet$1.isNull(transformedValue);
+    const valIsSymbol = isSymbol(transformedValue);
+    const valIsUndefined = isWeakSet$1.isUndefined(transformedValue);
+    while (low < high) {
+        let setLow;
+        const mid = Math.floor((low + high) / 2);
+        const computed = iteratee?.(array[mid]);
+        const othIsDefined = !isWeakSet$1.isUndefined(computed);
+        const othIsNull = isWeakSet$1.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);
+}
+
+function isNumber(value) {
+    return typeof value === 'number' || value instanceof Number;
+}
+
+const MAX_ARRAY_LENGTH$1 = 4294967295;
+const HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH$1 >>> 1;
+function sortedIndex(array, value) {
+    if (isWeakSet$1.isNil(array)) {
+        return 0;
+    }
+    let low = 0, high = isWeakSet$1.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 (!isWeakSet$1.isNull(compute) && !isWeakSet$1.isSymbol(compute) && compute < value) {
+                low = mid + 1;
+            }
+            else {
+                high = mid;
+            }
+        }
+        return high;
+    }
+    return sortedIndexBy(array, value, value => value);
+}
+
 function tail(arr) {
     if (!isArrayLike(arr)) {
         return [];
@@ -1855,6 +1963,38 @@ function min(items = []) {
     return minElement;
 }
 
+function toString(value) {
+    if (value == null) {
+        return '';
+    }
+    if (Array.isArray(value)) {
+        return value.map(toString).join(',');
+    }
+    const result = String(value);
+    if (result === '0' && Object.is(Number(value), -0)) {
+        return '-0';
+    }
+    return result;
+}
+
+function multiply(value, other) {
+    if (value === undefined && other === undefined) {
+        return 1;
+    }
+    if (value === undefined || other === undefined) {
+        return value || other;
+    }
+    if (typeof value === 'string' || typeof other === 'string') {
+        value = toString(value);
+        other = toString(other);
+    }
+    else {
+        value = Number(value);
+        other = Number(other);
+    }
+    return value * other;
+}
+
 function parseInt(string, radix = 0, guard) {
     if (guard) {
         radix = 0;
@@ -2415,10 +2555,6 @@ function omit(obj, ...keysArr) {
     return result;
 }
 
-function isNil(x) {
-    return x == null;
-}
-
 function pick(obj, ...keysArr) {
     if (isNil(obj)) {
         return {};
@@ -2559,7 +2695,7 @@ function isEqualWith(a, b, areValuesEqual = noop.noop) {
 }
 
 function isError(value) {
-    return isWeakSet$1.getTag(value) === '[object Error]';
+    return isPlainObject$1.getTag(value) === '[object Error]';
 }
 
 function isFinite(value) {
@@ -2574,14 +2710,6 @@ function isMap(value) {
     return isWeakSet$1.isMap(value);
 }
 
-function isNaN(value) {
-    return Number.isNaN(value);
-}
-
-function isNumber(value) {
-    return typeof value === 'number' || value instanceof Number;
-}
-
 function isRegExp(value) {
     return isWeakSet$1.isRegExp(value);
 }
@@ -2602,20 +2730,6 @@ function isWeakSet(value) {
     return isWeakSet$1.isWeakSet(value);
 }
 
-function toString(value) {
-    if (value == null) {
-        return '';
-    }
-    if (Array.isArray(value)) {
-        return value.map(toString).join(',');
-    }
-    const result = String(value);
-    if (result === '0' && Object.is(Number(value), -0)) {
-        return '-0';
-    }
-    return result;
-}
-
 function normalizeForCase(str) {
     if (typeof str !== 'string') {
         str = toString(str);
@@ -3081,16 +3195,15 @@ exports.xorBy = zipWith.xorBy;
 exports.xorWith = zipWith.xorWith;
 exports.zipObject = zipWith.zipObject;
 exports.zipWith = zipWith.zipWith;
-exports.AbortError = promise_index.AbortError;
-exports.TimeoutError = promise_index.TimeoutError;
-exports.timeout = promise_index.timeout;
-exports.withTimeout = promise_index.withTimeout;
+exports.AbortError = AbortError.AbortError;
+exports.TimeoutError = error_index.TimeoutError;
 exports.asyncNoop = unary.asyncNoop;
 exports.identity = unary.identity;
 exports.memoize = unary.memoize;
 exports.once = unary.once;
 exports.partial = unary.partial;
 exports.partialRight = unary.partialRight;
+exports.retry = unary.retry;
 exports.unary = unary.unary;
 exports.noop = noop.noop;
 exports.mean = range$1.mean;
@@ -3117,7 +3230,12 @@ exports.isJSONValue = isWeakSet$1.isJSONValue;
 exports.isLength = isWeakSet$1.isLength;
 exports.isNotNil = isWeakSet$1.isNotNil;
 exports.isNull = isWeakSet$1.isNull;
+exports.isPromise = isWeakSet$1.isPromise;
 exports.isUndefined = isWeakSet$1.isUndefined;
+exports.Mutex = promise_index.Mutex;
+exports.Semaphore = promise_index.Semaphore;
+exports.timeout = promise_index.timeout;
+exports.withTimeout = promise_index.withTimeout;
 exports.capitalize = upperFirst$1.capitalize;
 exports.constantCase = upperFirst$1.constantCase;
 exports.pascalCase = upperFirst$1.pascalCase;
@@ -3242,6 +3360,7 @@ exports.mergeWith = mergeWith;
 exports.method = method;
 exports.methodOf = methodOf;
 exports.min = min;
+exports.multiply = multiply;
 exports.negate = negate;
 exports.now = now;
 exports.nth = nth;
@@ -3257,6 +3376,7 @@ exports.property = property;
 exports.propertyOf = propertyOf;
 exports.pull = pull;
 exports.pullAll = pullAll;
+exports.pullAllBy = pullAllBy;
 exports.random = random;
 exports.range = range;
 exports.rangeRight = rangeRight;
@@ -3274,6 +3394,8 @@ exports.slice = slice;
 exports.snakeCase = snakeCase;
 exports.some = some;
 exports.sortBy = sortBy;
+exports.sortedIndex = sortedIndex;
+exports.sortedIndexBy = sortedIndexBy;
 exports.spread = spread;
 exports.startCase = startCase;
 exports.startsWith = startsWith;

package/dist/compat/index.mjs

@@ -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 { unary } from '../function/unary.mjs';
 export { mean } from '../math/mean.mjs';
 export { meanBy } from '../math/meanBy.mjs';
@@ -59,7 +60,10 @@ export { isJSONArray, isJSONObject, isJSONValue } from '../predicate/isJSONValue
 export { isLength } from '../predicate/isLength.mjs';
 export { isNotNil } from '../predicate/isNotNil.mjs';
 export { isNull } from '../predicate/isNull.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';
@@ -101,6 +105,7 @@ export { nth } from './array/nth.mjs';
 export { orderBy } from './array/orderBy.mjs';
 export { pull } from './array/pull.mjs';
 export { pullAll } from './array/pullAll.mjs';
+export { pullAllBy } from './array/pullAllBy.mjs';
 export { remove } from './array/remove.mjs';
 export { reverse } from './array/reverse.mjs';
 export { sample } from './array/sample.mjs';
@@ -108,6 +113,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';
@@ -146,6 +153,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/math/multiply.d.mts

@@ -0,0 +1,18 @@
+/**
+ * Multiply two numbers.
+ *
+ * If either of the numbers is `NaN`, the function returns `NaN`.
+ *
+ * @param {number} value The first number in a multiplication
+ * @param {number} other The second number in a multiplication
+ * @returns {number} The product of value and other
+ *
+ * @example
+ * multiply(2, 3); // => 6
+ * multiply(2, NaN); // => NaN
+ * multiply(NaN, 3); // => NaN
+ * multiply(NaN, NaN); // => NaN
+ */
+declare function multiply(value: number, other: number): number;
+
+export { multiply };

package/dist/compat/math/multiply.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Multiply two numbers.
+ *
+ * If either of the numbers is `NaN`, the function returns `NaN`.
+ *
+ * @param {number} value The first number in a multiplication
+ * @param {number} other The second number in a multiplication
+ * @returns {number} The product of value and other
+ *
+ * @example
+ * multiply(2, 3); // => 6
+ * multiply(2, NaN); // => NaN
+ * multiply(NaN, 3); // => NaN
+ * multiply(NaN, NaN); // => NaN
+ */
+declare function multiply(value: number, other: number): number;
+
+export { multiply };

package/dist/compat/math/multiply.mjs

@@ -0,0 +1,21 @@
+import { toString } from '../util/toString.mjs';
+
+function multiply(value, other) {
+    if (value === undefined && other === undefined) {
+        return 1;
+    }
+    if (value === undefined || other === undefined) {
+        return value || other;
+    }
+    if (typeof value === 'string' || typeof other === 'string') {
+        value = toString(value);
+        other = toString(other);
+    }
+    else {
+        value = Number(value);
+        other = Number(other);
+    }
+    return value * other;
+}
+
+export { multiply };

package/dist/error/index.d.mts

@@ -0,0 +1,2 @@
+export { AbortError } from './AbortError.mjs';
+export { TimeoutError } from './TimeoutError.mjs';

package/dist/error/index.d.ts

@@ -0,0 +1,2 @@
+export { AbortError } from './AbortError.js';
+export { TimeoutError } from './TimeoutError.js';

package/dist/error/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const AbortError = require('../_chunk/AbortError-Cg4ZQ1.js');
+
+class TimeoutError extends Error {
+    constructor(message = 'The operation was timed out') {
+        super(message);
+        this.name = 'TimeoutError';
+    }
+}
+
+exports.AbortError = AbortError.AbortError;
+exports.TimeoutError = TimeoutError;

package/dist/error/index.mjs

@@ -0,0 +1,2 @@
+export { AbortError } from './AbortError.mjs';
+export { TimeoutError } from './TimeoutError.mjs';

package/dist/function/index.d.mts

@@ -15,6 +15,7 @@ export { once } from './once.mjs';
 export { partial } from './partial.mjs';
 export { partialRight } from './partialRight.mjs';
 export { rest } from './rest.mjs';
+export { retry } from './retry.mjs';
 export { spread } from './spread.mjs';
 export { ThrottledFunction, throttle } from './throttle.mjs';
 export { unary } from './unary.mjs';

package/dist/function/index.d.ts

@@ -15,6 +15,7 @@ export { once } from './once.js';
 export { partial } from './partial.js';
 export { partialRight } from './partialRight.js';
 export { rest } from './rest.js';
+export { retry } from './retry.js';
 export { spread } from './spread.js';
 export { ThrottledFunction, throttle } from './throttle.js';
 export { unary } from './unary.js';

package/dist/function/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const unary = require('../_chunk/unary-B6qG7C.js');
+const unary = require('../_chunk/unary-c1NFA5.js');
 const noop = require('../_chunk/noop-2IwLUk.js');
 
 function before(n, func) {
@@ -98,6 +98,7 @@ exports.once = unary.once;
 exports.partial = unary.partial;
 exports.partialRight = unary.partialRight;
 exports.rest = unary.rest;
+exports.retry = unary.retry;
 exports.unary = unary.unary;
 exports.noop = noop.noop;
 exports.before = before;

package/dist/function/index.mjs

@@ -15,6 +15,7 @@ export { once } from './once.mjs';
 export { partial } from './partial.mjs';
 export { partialRight } from './partialRight.mjs';
 export { rest } from './rest.mjs';
+export { retry } from './retry.mjs';
 export { spread } from './spread.mjs';
 export { throttle } from './throttle.mjs';
 export { unary } from './unary.mjs';

package/dist/function/retry.d.mts

@@ -0,0 +1,59 @@
+interface RetryOptions {
+    /**
+     * The number of milliseconds to interval delay.
+     * @default 0
+     */
+    delay?: number;
+    /**
+     * The number of retries to attempt.
+     * @default Number.POSITIVE_INFINITY
+     */
+    retries?: number;
+    /**
+     * An AbortSignal to cancel the retry operation.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Retries a function that returns a promise until it resolves successfully.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Basic usage with default retry options
+ * retry(() => fetchData()).then(data => console.log(data));
+ */
+declare function retry<T>(func: () => Promise<T>): Promise<T>;
+/**
+ * Retries a function that returns a promise a specified number of times.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry. It should return a promise.
+ * @param {number} retries - The number of retries to attempt. Default is Infinity.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Retry a function up to 3 times
+ * retry(() => fetchData(), 3).then(data => console.log(data));
+ */
+declare function retry<T>(func: () => Promise<T>, retries: number): Promise<T>;
+/**
+ * Retries a function that returns a promise with specified options.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry. It should return a promise.
+ * @param {RetryOptions} options - Options to configure the retry behavior.
+ * @param {number} [options.delay=0] - The number of milliseconds to wait between retries.
+ * @param {number} [options.retries=Infinity] - The number of retries to attempt.
+ * @param {AbortSignal} [options.signal] - An AbortSignal to cancel the retry operation.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Retry a function with a delay of 1000ms between attempts
+ * retry(() => fetchData(), { delay: 1000, times: 5 }).then(data => console.log(data));
+ */
+declare function retry<T>(func: () => Promise<T>, options: RetryOptions): Promise<T>;
+
+export { retry };

package/dist/function/retry.d.ts

@@ -0,0 +1,59 @@
+interface RetryOptions {
+    /**
+     * The number of milliseconds to interval delay.
+     * @default 0
+     */
+    delay?: number;
+    /**
+     * The number of retries to attempt.
+     * @default Number.POSITIVE_INFINITY
+     */
+    retries?: number;
+    /**
+     * An AbortSignal to cancel the retry operation.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Retries a function that returns a promise until it resolves successfully.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Basic usage with default retry options
+ * retry(() => fetchData()).then(data => console.log(data));
+ */
+declare function retry<T>(func: () => Promise<T>): Promise<T>;
+/**
+ * Retries a function that returns a promise a specified number of times.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry. It should return a promise.
+ * @param {number} retries - The number of retries to attempt. Default is Infinity.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Retry a function up to 3 times
+ * retry(() => fetchData(), 3).then(data => console.log(data));
+ */
+declare function retry<T>(func: () => Promise<T>, retries: number): Promise<T>;
+/**
+ * Retries a function that returns a promise with specified options.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry. It should return a promise.
+ * @param {RetryOptions} options - Options to configure the retry behavior.
+ * @param {number} [options.delay=0] - The number of milliseconds to wait between retries.
+ * @param {number} [options.retries=Infinity] - The number of retries to attempt.
+ * @param {AbortSignal} [options.signal] - An AbortSignal to cancel the retry operation.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Retry a function with a delay of 1000ms between attempts
+ * retry(() => fetchData(), { delay: 1000, times: 5 }).then(data => console.log(data));
+ */
+declare function retry<T>(func: () => Promise<T>, options: RetryOptions): Promise<T>;
+
+export { retry };