es-toolkit 1.23.0 → 1.24.0

package/dist/compat/_internal/MAX_ARRAY_LENGTH.mjs

@@ -0,0 +1,3 @@
+const MAX_ARRAY_LENGTH = 4_294_967_295;
+
+export { MAX_ARRAY_LENGTH };

package/dist/compat/_internal/isIterateeCall.mjs

@@ -0,0 +1,17 @@
+import { isIndex } from './isIndex.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+import { isObject } from '../predicate/isObject.mjs';
+import { eq } from '../util/eq.mjs';
+
+function isIterateeCall(value, index, object) {
+    if (!isObject(object)) {
+        return false;
+    }
+    if ((typeof index === 'number' && isArrayLike(object) && isIndex(index) && index < object.length) ||
+        (typeof index === 'string' && index in object)) {
+        return eq(object[index], value);
+    }
+    return false;
+}
+
+export { isIterateeCall };

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

@@ -2,9 +2,9 @@
  * Computes the difference between an array and multiple arrays.
  *
  * @template T
- * @param {T[]} arr - The primary array from which to derive the difference. This is the main array
+ * @param {ArrayLike<T> | undefined | null} arr - The primary array from which to derive the difference. This is the main array
  * from which elements will be compared and filtered.
- * @param {...T[]} values - Multiple arrays containing elements to be excluded from the primary array.
+ * @param {Array<ArrayLike<T>>} values - Multiple arrays containing elements to be excluded from the primary array.
  * These arrays will be flattened into a single array, and each element in this array will be checked against the primary array.
  * 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 primary array but not
@@ -16,7 +16,13 @@
  * const array3 = [5, 6];
  * const result = difference(array1, array2, array3);
  * // result will be [1, 3] since 2, 4, and 5 are in the other arrays and are excluded from the result.
+ *
+ * @example
+ * const arrayLike1 = { 0: 1, 1: 2, 2: 3, length: 3 };
+ * const arrayLike2 = { 0: 2, 1: 4, length: 2 };
+ * const result = difference(arrayLike1, arrayLike2);
+ * // result will be [1, 3] since 2 is in both array-like objects and is excluded from the result.
  */
-declare function difference<T>(arr: readonly T[], ...values: Array<readonly T[]>): T[];
+declare function difference<T>(arr: ArrayLike<T> | undefined | null, ...values: Array<ArrayLike<T>>): T[];
 
 export { difference };

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

@@ -2,9 +2,9 @@
  * Computes the difference between an array and multiple arrays.
  *
  * @template T
- * @param {T[]} arr - The primary array from which to derive the difference. This is the main array
+ * @param {ArrayLike<T> | undefined | null} arr - The primary array from which to derive the difference. This is the main array
  * from which elements will be compared and filtered.
- * @param {...T[]} values - Multiple arrays containing elements to be excluded from the primary array.
+ * @param {Array<ArrayLike<T>>} values - Multiple arrays containing elements to be excluded from the primary array.
  * These arrays will be flattened into a single array, and each element in this array will be checked against the primary array.
  * 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 primary array but not
@@ -16,7 +16,13 @@
  * const array3 = [5, 6];
  * const result = difference(array1, array2, array3);
  * // result will be [1, 3] since 2, 4, and 5 are in the other arrays and are excluded from the result.
+ *
+ * @example
+ * const arrayLike1 = { 0: 1, 1: 2, 2: 3, length: 3 };
+ * const arrayLike2 = { 0: 2, 1: 4, length: 2 };
+ * const result = difference(arrayLike1, arrayLike2);
+ * // result will be [1, 3] since 2 is in both array-like objects and is excluded from the result.
  */
-declare function difference<T>(arr: readonly T[], ...values: Array<readonly T[]>): T[];
+declare function difference<T>(arr: ArrayLike<T> | undefined | null, ...values: Array<ArrayLike<T>>): T[];
 
 export { difference };

package/dist/compat/array/difference.mjs

@@ -1,9 +1,18 @@
 import { difference as difference$1 } from '../../array/difference.mjs';
-import { flatten } from '../../array/flatten.mjs';
+import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs';
 
 function difference(arr, ...values) {
-    const arr1 = arr;
-    const arr2 = flatten(values);
+    if (!isArrayLikeObject(arr)) {
+        return [];
+    }
+    const arr1 = Array.from(arr);
+    const arr2 = [];
+    for (let i = 0; i < values.length; i++) {
+        const value = values[i];
+        if (isArrayLikeObject(value)) {
+            arr2.push(...Array.from(value));
+        }
+    }
     return difference$1(arr1, arr2);
 }
 

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

@@ -0,0 +1,60 @@
+/**
+ * Drops elements from the end of an array while the predicate function returns truthy.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {(item: T, index: number, arr: T[]) => unknown} canContinueDropping - A predicate function that determines
+ * whether to continue dropping elements. The function is called with each element, index, and array, 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 = [5, 4, 3, 2, 1];
+ * const result = dropRightWhile(array, x => x < 3);
+ * result will be [5, 4, 3] since elements less than 3 are dropped.
+ */
+declare function dropRightWhile<T>(arr: readonly T[], canContinueDropping: (item: T, index: number, arr: readonly T[]) => unknown): T[];
+/**
+ * Drops elements from the end of an array while the specified object properties match.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {Partial<T>} objectToDrop - An object specifying the properties to match for dropping elements.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ *
+ * @example
+ * const array = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * const result = dropRightWhile(array, { a: 3 });
+ * result will be [{ a: 1 }, { a: 2 }] since the last object matches the properties of the provided object.
+ */
+declare function dropRightWhile<T>(arr: readonly T[], objectToDrop: Partial<T>): T[];
+/**
+ * Drops elements from the end of an array while the specified property matches a given value.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {[keyof T, unknown]} propertyToDrop - A tuple containing the property key and the value to match for dropping elements.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ *
+ * @example
+ * const array = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const result = dropRightWhile(array, ['id', 3]);
+ * result will be [{ id: 1 }, { id: 2 }] since the last object has the id property matching the value 3.
+ */
+declare function dropRightWhile<T>(arr: readonly T[], propertyToDrop: [keyof T, unknown]): T[];
+/**
+ * Drops elements from the end of an array while the specified property name matches.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {string} propertyToDrop - The name of the property to match for dropping elements.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ *
+ * @example
+ * const array = [{ isActive: false }, { isActive: true }, { isActive: true }];
+ * const result = dropRightWhile(array, 'isActive');
+ * result will be [{ isActive: false }] since it drops elements until it finds one with a falsy isActive property.
+ */
+declare function dropRightWhile<T>(arr: readonly T[], propertyToDrop: string): T[];
+
+export { dropRightWhile };

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

@@ -0,0 +1,60 @@
+/**
+ * Drops elements from the end of an array while the predicate function returns truthy.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {(item: T, index: number, arr: T[]) => unknown} canContinueDropping - A predicate function that determines
+ * whether to continue dropping elements. The function is called with each element, index, and array, 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 = [5, 4, 3, 2, 1];
+ * const result = dropRightWhile(array, x => x < 3);
+ * result will be [5, 4, 3] since elements less than 3 are dropped.
+ */
+declare function dropRightWhile<T>(arr: readonly T[], canContinueDropping: (item: T, index: number, arr: readonly T[]) => unknown): T[];
+/**
+ * Drops elements from the end of an array while the specified object properties match.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {Partial<T>} objectToDrop - An object specifying the properties to match for dropping elements.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ *
+ * @example
+ * const array = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * const result = dropRightWhile(array, { a: 3 });
+ * result will be [{ a: 1 }, { a: 2 }] since the last object matches the properties of the provided object.
+ */
+declare function dropRightWhile<T>(arr: readonly T[], objectToDrop: Partial<T>): T[];
+/**
+ * Drops elements from the end of an array while the specified property matches a given value.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {[keyof T, unknown]} propertyToDrop - A tuple containing the property key and the value to match for dropping elements.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ *
+ * @example
+ * const array = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const result = dropRightWhile(array, ['id', 3]);
+ * result will be [{ id: 1 }, { id: 2 }] since the last object has the id property matching the value 3.
+ */
+declare function dropRightWhile<T>(arr: readonly T[], propertyToDrop: [keyof T, unknown]): T[];
+/**
+ * Drops elements from the end of an array while the specified property name matches.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {string} propertyToDrop - The name of the property to match for dropping elements.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ *
+ * @example
+ * const array = [{ isActive: false }, { isActive: true }, { isActive: true }];
+ * const result = dropRightWhile(array, 'isActive');
+ * result will be [{ isActive: false }] since it drops elements until it finds one with a falsy isActive property.
+ */
+declare function dropRightWhile<T>(arr: readonly T[], propertyToDrop: string): T[];
+
+export { dropRightWhile };

package/dist/compat/array/dropRightWhile.mjs

@@ -0,0 +1,27 @@
+import { dropRightWhile as dropRightWhile$1 } from '../../array/dropRightWhile.mjs';
+import { property } from '../object/property.mjs';
+import { matches } from '../predicate/matches.mjs';
+import { matchesProperty } from '../predicate/matchesProperty.mjs';
+
+function dropRightWhile(arr, predicate) {
+    switch (typeof predicate) {
+        case 'function': {
+            return dropRightWhile$1(arr, (item, index, arr) => Boolean(predicate(item, index, arr)));
+        }
+        case 'object': {
+            if (Array.isArray(predicate) && predicate.length === 2) {
+                const key = predicate[0];
+                const value = predicate[1];
+                return dropRightWhile$1(arr, matchesProperty(key, value));
+            }
+            else {
+                return dropRightWhile$1(arr, matches(predicate));
+            }
+        }
+        case 'string': {
+            return dropRightWhile$1(arr, property(predicate));
+        }
+    }
+}
+
+export { dropRightWhile };

package/dist/compat/array/every.mjs

@@ -17,11 +17,10 @@ function every(source, doesMatch) {
     switch (typeof doesMatch) {
         case 'function': {
             if (!Array.isArray(source)) {
-                const entries = Object.entries(source);
-                for (let i = 0; i < entries.length; i++) {
-                    const entry = entries[i];
-                    const key = entry[0];
-                    const value = entry[1];
+                const keys = Object.keys(source);
+                for (let i = 0; i < keys.length; i++) {
+                    const key = keys[i];
+                    const value = source[key];
                     if (!doesMatch(value, key, source)) {
                         return false;
                     }

package/dist/compat/array/filter.mjs

@@ -13,11 +13,10 @@ function filter(source, predicate) {
         case 'function': {
             if (!Array.isArray(source)) {
                 const result = [];
-                const entries = Object.entries(source);
-                for (let i = 0; i < entries.length; i++) {
-                    const entry = entries[i];
-                    const key = entry[0];
-                    const value = entry[1];
+                const keys = Object.keys(source);
+                for (let i = 0; i < keys.length; i++) {
+                    const key = keys[i];
+                    const value = source[key];
                     if (predicate(value, key, source)) {
                         result.push(value);
                     }

package/dist/compat/array/find.mjs

@@ -10,11 +10,10 @@ function find(source, doesMatch) {
     switch (typeof doesMatch) {
         case 'function': {
             if (!Array.isArray(source)) {
-                const entries = Object.entries(source);
-                for (let i = 0; i < entries.length; i++) {
-                    const entry = entries[i];
-                    const key = entry[0];
-                    const value = entry[1];
+                const keys = Object.keys(source);
+                for (let i = 0; i < keys.length; i++) {
+                    const key = keys[i];
+                    const value = source[key];
                     if (doesMatch(value, key, source)) {
                         return value;
                     }

package/dist/compat/array/includes.mjs

@@ -1,4 +1,5 @@
 import { isString } from '../predicate/isString.mjs';
+import { eq } from '../util/eq.mjs';
 import { toInteger } from '../util/toInteger.mjs';
 
 function includes(source, target, fromIndex, guard) {
@@ -29,7 +30,7 @@ function includes(source, target, fromIndex, guard) {
     }
     for (let i = fromIndex; i < keys.length; i++) {
         const value = Reflect.get(source, keys[i]);
-        if (value === target || (Number.isNaN(value) && Number.isNaN(target))) {
+        if (eq(value, target)) {
             return true;
         }
     }

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

@@ -0,0 +1,18 @@
+/**
+ * Create a slice of `array` from `start` up to, but not including, `end`.
+ *
+ * It does not return a dense array for sparse arrays unlike the native `Array.prototype.slice`.
+ *
+ * @template T - The type of the array elements.
+ * @param {T[]} array - The array to slice.
+ * @param {number} [start=0] - The start position.
+ * @param {number} [end=array.length] - The end position.
+ * @returns {T[]} - Returns the slice of `array`.
+ *
+ * @example
+ * slice([1, 2, 3], 1, 2); // => [2]
+ * slice(new Array(3)); // => [undefined, undefined, undefined]
+ */
+declare function slice<T>(array: readonly T[], start?: number, end?: number): T[];
+
+export { slice };

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

@@ -0,0 +1,18 @@
+/**
+ * Create a slice of `array` from `start` up to, but not including, `end`.
+ *
+ * It does not return a dense array for sparse arrays unlike the native `Array.prototype.slice`.
+ *
+ * @template T - The type of the array elements.
+ * @param {T[]} array - The array to slice.
+ * @param {number} [start=0] - The start position.
+ * @param {number} [end=array.length] - The end position.
+ * @returns {T[]} - Returns the slice of `array`.
+ *
+ * @example
+ * slice([1, 2, 3], 1, 2); // => [2]
+ * slice(new Array(3)); // => [undefined, undefined, undefined]
+ */
+declare function slice<T>(array: readonly T[], start?: number, end?: number): T[];
+
+export { slice };

package/dist/compat/array/slice.mjs

@@ -0,0 +1,38 @@
+import { isIterateeCall } from '../_internal/isIterateeCall.mjs';
+import { toInteger } from '../util/toInteger.mjs';
+
+function slice(array, start, end) {
+    if (array == null) {
+        return [];
+    }
+    const length = array.length;
+    if (end === undefined) {
+        end = length;
+    }
+    else if (typeof end !== 'number' && isIterateeCall(array, start, end)) {
+        start = 0;
+        end = length;
+    }
+    start = toInteger(start);
+    end = toInteger(end);
+    if (start < 0) {
+        start = Math.max(length + start, 0);
+    }
+    else {
+        start = Math.min(start, length);
+    }
+    if (end < 0) {
+        end = Math.max(length + end, 0);
+    }
+    else {
+        end = Math.min(end, length);
+    }
+    const resultLength = Math.max(end - start, 0);
+    const result = new Array(resultLength);
+    for (let i = 0; i < resultLength; ++i) {
+        result[i] = array[start + i];
+    }
+    return result;
+}
+
+export { slice };

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

@@ -0,0 +1,25 @@
+/**
+ * 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);
+ */
+declare function take<T>(arr: readonly T[], count: number): T[];
+
+export { take };

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

@@ -0,0 +1,25 @@
+/**
+ * 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);
+ */
+declare function take<T>(arr: readonly T[], count: number): T[];
+
+export { take };

package/dist/compat/array/take.mjs

@@ -0,0 +1,10 @@
+import { take as take$1 } from '../../array/take.mjs';
+
+function take(arr, count) {
+    if (count < 1) {
+        return [];
+    }
+    return take$1(arr, count);
+}
+
+export { take };

package/dist/compat/function/before.d.mts

@@ -0,0 +1,26 @@
+/**
+ * Creates a function that invokes `func`, with the `this` binding and arguments
+ * of the created function, while it's called less than `n` times. Subsequent
+ * calls to the created function return the result of the last `func` invocation.
+ *
+ * @template F - The type of the function to be invoked.
+ * @param {number} n - The number of times the returned function is allowed to call `func` before stopping.
+ * - If `n` is 0, `func` will never be called.
+ * - If `n` is a positive integer, `func` will be called up to `n-1` times.
+ * @param {F} func - The function to be called with the limit applied.
+ * @returns {(...args: Parameters<F>) => ReturnType<F> } - A new function that:
+ * - Tracks the number of calls.
+ * - Invokes `func` until the `n-1`-th call.
+ * - Returns last result of `func`, if `n` is reached.
+ * @throws {TypeError} - If `func` is not a function.
+ * @example
+ * let count = 0;
+ * const before3 = before(3, () => ++count);
+ *
+ * before3(); // => 1
+ * before3(); // => 2
+ * before3(); // => 2
+ */
+declare function before<F extends (...args: any[]) => any>(n: number, func: F): (...args: Parameters<F>) => ReturnType<F>;
+
+export { before };

package/dist/compat/function/before.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Creates a function that invokes `func`, with the `this` binding and arguments
+ * of the created function, while it's called less than `n` times. Subsequent
+ * calls to the created function return the result of the last `func` invocation.
+ *
+ * @template F - The type of the function to be invoked.
+ * @param {number} n - The number of times the returned function is allowed to call `func` before stopping.
+ * - If `n` is 0, `func` will never be called.
+ * - If `n` is a positive integer, `func` will be called up to `n-1` times.
+ * @param {F} func - The function to be called with the limit applied.
+ * @returns {(...args: Parameters<F>) => ReturnType<F> } - A new function that:
+ * - Tracks the number of calls.
+ * - Invokes `func` until the `n-1`-th call.
+ * - Returns last result of `func`, if `n` is reached.
+ * @throws {TypeError} - If `func` is not a function.
+ * @example
+ * let count = 0;
+ * const before3 = before(3, () => ++count);
+ *
+ * before3(); // => 1
+ * before3(); // => 2
+ * before3(); // => 2
+ */
+declare function before<F extends (...args: any[]) => any>(n: number, func: F): (...args: Parameters<F>) => ReturnType<F>;
+
+export { before };

package/dist/compat/function/before.mjs

@@ -0,0 +1,20 @@
+import { toInteger } from '../util/toInteger.mjs';
+
+function before(n, func) {
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
+    }
+    let result;
+    n = toInteger(n);
+    return function (...args) {
+        if (--n > 0) {
+            result = func.apply(this, args);
+        }
+        if (n <= 1 && func) {
+            func = undefined;
+        }
+        return result;
+    };
+}
+
+export { before };

package/dist/compat/function/curryRight.d.mts

@@ -0,0 +1,50 @@
+/**
+ * Creates a function that accepts arguments of `func` and either invokes `func` returning its result, if at least `arity` number of arguments have been provided, or returns a function that accepts the remaining `func` arguments, and so on.
+ * The arity of `func` may be specified if `func.length` is not sufficient.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * The `curryRight.placeholder` value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments.
+ *
+ * Note: This method doesn't set the `length` property of curried functions.
+ *
+ * @param {(...args: any[]) => any} func - The function to curry.
+ * @param {number=func.length} arity - The arity of func.
+ * @param {unknown} guard - Enables use as an iteratee for methods like `Array#map`.
+ * @returns {((...args: any[]) => any) & { placeholder: typeof curryRight.placeholder }} - Returns the new curried function.
+ *
+ * @example
+ * const abc = function(a, b, c) {
+ *   return Array.from(arguments);
+ * };
+ *
+ * let curried = curryRight(abc);
+ *
+ * curried(3)(2)(1);
+ * // => [1, 2, 3]
+ *
+ * curried(2, 3)(1);
+ * // => [1, 2, 3]
+ *
+ * curried(1, 2, 3);
+ * // => [1, 2, 3]
+ *
+ * // Curried with placeholders.
+ * curried(3)(curryRight.placeholder, 2)(1);
+ * // => [1, 2, 3]
+ *
+ * // Curried with arity.
+ * curried = curryRight(abc, 2);
+ *
+ * curried(2)(1);
+ * // => [1, 2]
+ */
+declare function curryRight(func: (...args: any[]) => any, arity?: number, guard?: unknown): ((...args: any[]) => any) & {
+    placeholder: typeof curryRight.placeholder;
+};
+declare namespace curryRight {
+    var placeholder: typeof curryRightPlaceholder;
+}
+declare const curryRightPlaceholder: unique symbol;
+
+export { curryRight };

package/dist/compat/function/curryRight.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Creates a function that accepts arguments of `func` and either invokes `func` returning its result, if at least `arity` number of arguments have been provided, or returns a function that accepts the remaining `func` arguments, and so on.
+ * The arity of `func` may be specified if `func.length` is not sufficient.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * The `curryRight.placeholder` value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments.
+ *
+ * Note: This method doesn't set the `length` property of curried functions.
+ *
+ * @param {(...args: any[]) => any} func - The function to curry.
+ * @param {number=func.length} arity - The arity of func.
+ * @param {unknown} guard - Enables use as an iteratee for methods like `Array#map`.
+ * @returns {((...args: any[]) => any) & { placeholder: typeof curryRight.placeholder }} - Returns the new curried function.
+ *
+ * @example
+ * const abc = function(a, b, c) {
+ *   return Array.from(arguments);
+ * };
+ *
+ * let curried = curryRight(abc);
+ *
+ * curried(3)(2)(1);
+ * // => [1, 2, 3]
+ *
+ * curried(2, 3)(1);
+ * // => [1, 2, 3]
+ *
+ * curried(1, 2, 3);
+ * // => [1, 2, 3]
+ *
+ * // Curried with placeholders.
+ * curried(3)(curryRight.placeholder, 2)(1);
+ * // => [1, 2, 3]
+ *
+ * // Curried with arity.
+ * curried = curryRight(abc, 2);
+ *
+ * curried(2)(1);
+ * // => [1, 2]
+ */
+declare function curryRight(func: (...args: any[]) => any, arity?: number, guard?: unknown): ((...args: any[]) => any) & {
+    placeholder: typeof curryRight.placeholder;
+};
+declare namespace curryRight {
+    var placeholder: typeof curryRightPlaceholder;
+}
+declare const curryRightPlaceholder: unique symbol;
+
+export { curryRight };