es-toolkit 1.32.0 → 1.33.0

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

@@ -0,0 +1,64 @@
+/**
+ * Removes all specified values from an array using an iteratee function.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove values without modifying the original array, use `differenceBy`.
+ *
+ * @template T
+ * @param {T[]} arr - The array to modify.
+ * @param {ArrayLike<T>} valuesToRemove - The values to remove from the array.
+ * @param {(value: T) => unknown} getValue - The iteratee invoked per element.
+ * @returns {T[]} The modified array with the specified values removed.
+ *
+ * @example
+ * const items = [{ value: 1 }, { value: 2 }, { value: 3 }, { value: 1 }];
+ * const result = pullAllBy(items, [{ value: 1 }, { value: 3 }], obj => obj.value);
+ * console.log(result); // [{ value: 2 }]
+ */
+declare function pullAllBy<T>(arr: T[], valuesToRemove: ArrayLike<T>, getValue: (value: T) => unknown): T[];
+/**
+ * Removes all specified values from an array using an iteratee function.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove values without modifying the original array, use `differenceBy`.
+ *
+ * @template T
+ * @param {T[]} arr - The array to modify.
+ * @param {ArrayLike<T>} valuesToRemove - The values to remove from the array.
+ * @param {Partial<T>} getValue - The partial object to match against each element.
+ * @returns {T[]} The modified array with the specified values removed.
+ */
+declare function pullAllBy<T>(arr: T[], valuesToRemove: ArrayLike<T>, getValue: Partial<T>): T[];
+/**
+ * Removes all specified values from an array using an iteratee function.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove values without modifying the original array, use `differenceBy`.
+ *
+ * @template T
+ * @param {T[]} arr - The array to modify.
+ * @param {ArrayLike<T>} valuesToRemove - The values to remove from the array.
+ * @param {[keyof T, unknown]} getValue - The property-value pair to match against each element.
+ * @returns {T[]} The modified array with the specified values removed.
+ */
+declare function pullAllBy<T>(arr: T[], valuesToRemove: ArrayLike<T>, getValue: [keyof T, unknown]): T[];
+/**
+ * Removes all specified values from an array using an iteratee function.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove values without modifying the original array, use `differenceBy`.
+ *
+ * @template T
+ * @param {T[]} arr - The array to modify.
+ * @param {ArrayLike<T>} valuesToRemove - The values to remove from the array.
+ * @param {keyof T} getValue - The key of the property to match against each element.
+ * @returns {T[]} The modified array with the specified values removed.
+ *
+ * @example
+ * const items = [{ value: 1 }, { value: 2 }, { value: 3 }, { value: 1 }];
+ * const result = pullAllBy(items, [{ value: 1 }, { value: 3 }], 'value');
+ * console.log(result); // [{ value: 2 }]
+ */
+declare function pullAllBy<T>(arr: T[], valuesToRemove: ArrayLike<T>, getValue: keyof T): T[];
+
+export { pullAllBy };

package/dist/compat/array/pullAllBy.mjs

@@ -0,0 +1,22 @@
+import { iteratee } from '../util/iteratee.mjs';
+
+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;
+}
+
+export { pullAllBy };

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

@@ -0,0 +1,109 @@
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * The `reduce()` function goes through each element in an array and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduce()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the first element of the array and begins with the second element for the calculation.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: readonly T[]) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = [1, 2, 3];
+ * reduce(arrayLike, (acc, value) => acc && value % 2 === 0, true); // => false
+ */
+declare function reduce<T, U>(collection: readonly T[], iteratee: (accumulator: U, value: T, index: number, collection: readonly T[]) => U, initialValue: U): U;
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * The `reduce()` function goes through each element in an array and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduce()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the first element of the array and begins with the second element for the calculation.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {(accumulator: T, value: T, index: number, collection: readonly T[]) => T} iteratee - The function invoked per iteration.
+ * @returns {T} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = [1, 2, 3];
+ * reduce(arrayLike, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T>(collection: readonly T[], iteratee: (accumulator: T, value: T, index: number, collection: readonly T[]) => T): T;
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * The `reduce()` function goes through each element in an array and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduce()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the first element of the array and begins with the second element for the calculation.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * reduce(arrayLike, (acc, value) => acc + value % 2 === 0, true); // => false
+ */
+declare function reduce<T, U>(collection: ArrayLike<T>, iteratee: (accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U, initialValue: U): U;
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * The `reduce()` function goes through each element in an array and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduce()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the first element of the array and begins with the second element for the calculation.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U} iteratee - The function invoked per iteration.
+ * @returns {T} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * reduce(arrayLike, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T>(collection: ArrayLike<T>, iteratee: (accumulator: T, value: T, index: number, collection: ArrayLike<T>) => T): T;
+/**
+ * Reduces an object to a single value using an iteratee function.
+ *
+ * @param {T} collection - The object to iterate over.
+ * @param {(accumulator: U, value: T[keyof T], key: string, collection: T) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reduce(obj, (acc, value) => acc + value % 2 === 0, true); // => false
+ */
+declare function reduce<T extends object, U>(collection: T, iteratee: (accumulator: U, value: T[keyof T], key: keyof T, collection: T) => U, initialValue: U): U;
+/**
+ * Reduces an object to a single value using an iteratee function.
+ *
+ * @param {T} collection - The object to iterate over.
+ * @param {(accumulator: T[keyof T], value: T[keyof T], key: keyof T, collection: T) => U} iteratee - The function invoked per iteration.
+ * @returns {T[keyof T]} - Returns the accumulated value.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reduce(obj, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T extends object>(collection: T, iteratee: (accumulator: T[keyof T], value: T[keyof T], key: keyof T, collection: T) => T[keyof T]): T[keyof T];
+
+export { reduce };

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

@@ -0,0 +1,109 @@
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * The `reduce()` function goes through each element in an array and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduce()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the first element of the array and begins with the second element for the calculation.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: readonly T[]) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = [1, 2, 3];
+ * reduce(arrayLike, (acc, value) => acc && value % 2 === 0, true); // => false
+ */
+declare function reduce<T, U>(collection: readonly T[], iteratee: (accumulator: U, value: T, index: number, collection: readonly T[]) => U, initialValue: U): U;
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * The `reduce()` function goes through each element in an array and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduce()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the first element of the array and begins with the second element for the calculation.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {(accumulator: T, value: T, index: number, collection: readonly T[]) => T} iteratee - The function invoked per iteration.
+ * @returns {T} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = [1, 2, 3];
+ * reduce(arrayLike, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T>(collection: readonly T[], iteratee: (accumulator: T, value: T, index: number, collection: readonly T[]) => T): T;
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * The `reduce()` function goes through each element in an array and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduce()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the first element of the array and begins with the second element for the calculation.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * reduce(arrayLike, (acc, value) => acc + value % 2 === 0, true); // => false
+ */
+declare function reduce<T, U>(collection: ArrayLike<T>, iteratee: (accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U, initialValue: U): U;
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * The `reduce()` function goes through each element in an array and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduce()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the first element of the array and begins with the second element for the calculation.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U} iteratee - The function invoked per iteration.
+ * @returns {T} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * reduce(arrayLike, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T>(collection: ArrayLike<T>, iteratee: (accumulator: T, value: T, index: number, collection: ArrayLike<T>) => T): T;
+/**
+ * Reduces an object to a single value using an iteratee function.
+ *
+ * @param {T} collection - The object to iterate over.
+ * @param {(accumulator: U, value: T[keyof T], key: string, collection: T) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reduce(obj, (acc, value) => acc + value % 2 === 0, true); // => false
+ */
+declare function reduce<T extends object, U>(collection: T, iteratee: (accumulator: U, value: T[keyof T], key: keyof T, collection: T) => U, initialValue: U): U;
+/**
+ * Reduces an object to a single value using an iteratee function.
+ *
+ * @param {T} collection - The object to iterate over.
+ * @param {(accumulator: T[keyof T], value: T[keyof T], key: keyof T, collection: T) => U} iteratee - The function invoked per iteration.
+ * @returns {T[keyof T]} - Returns the accumulated value.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reduce(obj, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T extends object>(collection: T, iteratee: (accumulator: T[keyof T], value: T[keyof T], key: keyof T, collection: T) => T[keyof T]): T[keyof T];
+
+export { reduce };

package/dist/compat/array/reduce.mjs

@@ -0,0 +1,33 @@
+import { identity } from '../../function/identity.mjs';
+import { range } from '../../math/range.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+
+function reduce(collection, iteratee = identity, accumulator) {
+    if (!collection) {
+        return accumulator;
+    }
+    let keys;
+    let startIndex = 0;
+    if (isArrayLike(collection)) {
+        keys = range(0, collection.length);
+        if (accumulator == null && collection.length > 0) {
+            accumulator = collection[0];
+            startIndex += 1;
+        }
+    }
+    else {
+        keys = Object.keys(collection);
+        if (accumulator == null) {
+            accumulator = collection[keys[0]];
+            startIndex += 1;
+        }
+    }
+    for (let i = startIndex; i < keys.length; i++) {
+        const key = keys[i];
+        const value = collection[key];
+        accumulator = iteratee(accumulator, value, key, collection);
+    }
+    return accumulator;
+}
+
+export { reduce };

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

@@ -0,0 +1,109 @@
+/**
+ * Reduces an array to a single value using an iteratee function, starting from the right.
+ *
+ * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduceRight()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the last element of the array and begins with the second to last element for the calculation.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: readonly T[]) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = [1, 2, 3];
+ * reduceRight(arrayLike, (acc, value) => acc && value % 2 === 0, true); // => false
+ */
+declare function reduceRight<T, U>(collection: readonly T[], iteratee: (accumulator: U, value: T, index: number, collection: readonly T[]) => U, initialValue: U): U;
+/**
+ * Reduces an array to a single value using an iteratee function, starting from the right.
+ *
+ * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduceRight()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the last element of the array and begins with the second to last element for the calculation.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {(accumulator: T, value: T, index: number, collection: readonly T[]) => T} iteratee - The function invoked per iteration.
+ * @returns {T} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = [1, 2, 3];
+ * reduceRight(arrayLike, (acc, value) => acc + value); // => 6
+ */
+declare function reduceRight<T>(collection: readonly T[], iteratee: (accumulator: T, value: T, index: number, collection: readonly T[]) => T): T;
+/**
+ * Reduces an array to a single value using an iteratee function, starting from the right.
+ *
+ * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduceRight()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the last element of the array and begins with the second to last element for the calculation.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * reduceRight(arrayLike, (acc, value) => acc + value % 2 === 0, true); // => false
+ */
+declare function reduceRight<T, U>(collection: ArrayLike<T>, iteratee: (accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U, initialValue: U): U;
+/**
+ * Reduces an array to a single value using an iteratee function, starting from the right.
+ *
+ * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduceRight()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the last element of the array and begins with the second to last element for the calculation.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U} iteratee - The function invoked per iteration.
+ * @returns {T} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * reduceRight(arrayLike, (acc, value) => acc + value); // => 6
+ */
+declare function reduceRight<T>(collection: ArrayLike<T>, iteratee: (accumulator: T, value: T, index: number, collection: ArrayLike<T>) => T): T;
+/**
+ * Reduces an object to a single value using an iteratee function, starting from the right.
+ *
+ * @param {T} collection - The object to iterate over.
+ * @param {(accumulator: U, value: T[keyof T], key: string, collection: T) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reduceRight(obj, (acc, value) => acc + value % 2 === 0, true); // => false
+ */
+declare function reduceRight<T extends object, U>(collection: T, iteratee: (accumulator: U, value: T[keyof T], key: keyof T, collection: T) => U, initialValue: U): U;
+/**
+ * Reduces an object to a single value using an iteratee function, starting from the right.
+ *
+ * @param {T} collection - The object to iterate over.
+ * @param {(accumulator: T[keyof T], value: T[keyof T], key: keyof T, collection: T) => U} iteratee - The function invoked per iteration.
+ * @returns {T[keyof T]} - Returns the accumulated value.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reduceRight(obj, (acc, value) => acc + value); // => 6
+ */
+declare function reduceRight<T extends object>(collection: T, iteratee: (accumulator: T[keyof T], value: T[keyof T], key: keyof T, collection: T) => T[keyof T]): T[keyof T];
+
+export { reduceRight };

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

@@ -0,0 +1,109 @@
+/**
+ * Reduces an array to a single value using an iteratee function, starting from the right.
+ *
+ * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduceRight()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the last element of the array and begins with the second to last element for the calculation.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: readonly T[]) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = [1, 2, 3];
+ * reduceRight(arrayLike, (acc, value) => acc && value % 2 === 0, true); // => false
+ */
+declare function reduceRight<T, U>(collection: readonly T[], iteratee: (accumulator: U, value: T, index: number, collection: readonly T[]) => U, initialValue: U): U;
+/**
+ * Reduces an array to a single value using an iteratee function, starting from the right.
+ *
+ * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduceRight()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the last element of the array and begins with the second to last element for the calculation.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {(accumulator: T, value: T, index: number, collection: readonly T[]) => T} iteratee - The function invoked per iteration.
+ * @returns {T} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = [1, 2, 3];
+ * reduceRight(arrayLike, (acc, value) => acc + value); // => 6
+ */
+declare function reduceRight<T>(collection: readonly T[], iteratee: (accumulator: T, value: T, index: number, collection: readonly T[]) => T): T;
+/**
+ * Reduces an array to a single value using an iteratee function, starting from the right.
+ *
+ * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduceRight()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the last element of the array and begins with the second to last element for the calculation.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * reduceRight(arrayLike, (acc, value) => acc + value % 2 === 0, true); // => false
+ */
+declare function reduceRight<T, U>(collection: ArrayLike<T>, iteratee: (accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U, initialValue: U): U;
+/**
+ * Reduces an array to a single value using an iteratee function, starting from the right.
+ *
+ * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduceRight()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the last element of the array and begins with the second to last element for the calculation.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U} iteratee - The function invoked per iteration.
+ * @returns {T} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * reduceRight(arrayLike, (acc, value) => acc + value); // => 6
+ */
+declare function reduceRight<T>(collection: ArrayLike<T>, iteratee: (accumulator: T, value: T, index: number, collection: ArrayLike<T>) => T): T;
+/**
+ * Reduces an object to a single value using an iteratee function, starting from the right.
+ *
+ * @param {T} collection - The object to iterate over.
+ * @param {(accumulator: U, value: T[keyof T], key: string, collection: T) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reduceRight(obj, (acc, value) => acc + value % 2 === 0, true); // => false
+ */
+declare function reduceRight<T extends object, U>(collection: T, iteratee: (accumulator: U, value: T[keyof T], key: keyof T, collection: T) => U, initialValue: U): U;
+/**
+ * Reduces an object to a single value using an iteratee function, starting from the right.
+ *
+ * @param {T} collection - The object to iterate over.
+ * @param {(accumulator: T[keyof T], value: T[keyof T], key: keyof T, collection: T) => U} iteratee - The function invoked per iteration.
+ * @returns {T[keyof T]} - Returns the accumulated value.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reduceRight(obj, (acc, value) => acc + value); // => 6
+ */
+declare function reduceRight<T extends object>(collection: T, iteratee: (accumulator: T[keyof T], value: T[keyof T], key: keyof T, collection: T) => T[keyof T]): T[keyof T];
+
+export { reduceRight };

package/dist/compat/array/reduceRight.mjs

@@ -0,0 +1,39 @@
+import { identity } from '../../function/identity.mjs';
+import { range } from '../../math/range.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+
+function reduceRight(collection, iteratee = identity, accumulator) {
+    if (!collection) {
+        return accumulator;
+    }
+    let keys;
+    let startIndex;
+    if (isArrayLike(collection)) {
+        keys = range(0, collection.length).reverse();
+        if (accumulator == null && collection.length > 0) {
+            accumulator = collection[collection.length - 1];
+            startIndex = 1;
+        }
+        else {
+            startIndex = 0;
+        }
+    }
+    else {
+        keys = Object.keys(collection).reverse();
+        if (accumulator == null) {
+            accumulator = collection[keys[0]];
+            startIndex = 1;
+        }
+        else {
+            startIndex = 0;
+        }
+    }
+    for (let i = startIndex; i < keys.length; i++) {
+        const key = keys[i];
+        const value = collection[key];
+        accumulator = iteratee(accumulator, value, key, collection);
+    }
+    return accumulator;
+}
+
+export { reduceRight };