es-toolkit 1.43.0 → 1.44.0-dev.1722

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # es-toolkit Changelog
 
+## Version v1.44.0
+
+Released on January 16th, 2026.
+
+- Added `shouldRetry` option to `retry` function. ([#1585])
+- Added `isEmptyObject` predicate function. ([#1584])
+- Added `isNumber` predicate function.
+- Enhanced error cloning to support `AggregateError`. ([#1563])
+- Implemented collection methods for Maps and Sets.
+- Added bundle size analysis and visualization components to docs. ([#1564])
+- Fixed `flattenObject` to retain empty objects and arrays.
+- Enhanced type safety for `clone` function.
+- Fixed `clone` error when cloning object with null prototype. ([#1570])
+- Fixed array function callbacks to include index and array parameters. ([#1561])
+- Fixed `compat/cloneDeep` and `cloneDeepWith` to clone null-prototype objects as regular objects. ([#1562])
+- Fixed `compat/clamp` to ensure consistency with lodash. ([#1555])
+- Simplified `intersection` filter callback for consistency. ([#1582])
+- Fixed incorrect function names and output in `cloneDeep` JSDoc examples. ([#1583])
+
+We sincerely thank @raon0211, @dayongkr, @eunwoo-levi, @matt-oakes, @T3sT3ro, and @D-Sketon for their contributions. We appreciate your great efforts!
+
 ## Version v1.43.0
 
 Released on December 12th, 2025.

package/dist/{compat/util/eq.d.mts → _internal/isEqualsSameValueZero.d.mts}

@@ -11,6 +11,6 @@
  * eq(NaN, NaN); // true
  * eq('a', Object('a')); // false
  */
-declare function eq(value: any, other: any): boolean;
+declare function isEqualsSameValueZero(value: any, other: any): boolean;
 
-export { eq };
+export { isEqualsSameValueZero };

package/dist/{compat/util/eq.d.ts → _internal/isEqualsSameValueZero.d.ts}

@@ -11,6 +11,6 @@
  * eq(NaN, NaN); // true
  * eq('a', Object('a')); // false
  */
-declare function eq(value: any, other: any): boolean;
+declare function isEqualsSameValueZero(value: any, other: any): boolean;
 
-export { eq };
+export { isEqualsSameValueZero };

package/dist/{compat/util/eq.js → _internal/isEqualsSameValueZero.js}

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-function eq(value, other) {
+function isEqualsSameValueZero(value, other) {
     return value === other || (Number.isNaN(value) && Number.isNaN(other));
 }
 
-exports.eq = eq;
+exports.isEqualsSameValueZero = isEqualsSameValueZero;

package/dist/_internal/isEqualsSameValueZero.mjs

@@ -0,0 +1,5 @@
+function isEqualsSameValueZero(value, other) {
+    return value === other || (Number.isNaN(value) && Number.isNaN(other));
+}
+
+export { isEqualsSameValueZero };

package/dist/array/countBy.d.mts

@@ -11,7 +11,7 @@
  * @template T - The type of the items in the input array.
  * @template K - The type of keys.
  * @param {T[]} arr - The input array to count occurrences.
- * @param {(item: T) => K} mapper - The transformation function that maps each item to a key.
+ * @param {(item: T, index: number, array: readonly T[]) => K} mapper - The transformation function that maps each item, its index, and the array to a key.
  * @returns {Record<K, number>} An object containing the transformed items as keys and the
  * counts as values.
  *
@@ -24,7 +24,13 @@
  * const array = [1, 2, 3, 4, 5];
  * const result = countBy(array, item => item % 2 === 0 ? 'even' : 'odd');
  * // result will be { odd: 3, even: 2 }
+ *
+ * @example
+ * // Using index parameter
+ * const array = ['a', 'b', 'c', 'd'];
+ * const result = countBy(array, (item, index) => index < 2 ? 'first' : 'rest');
+ * // result will be { first: 2, rest: 2 }
  */
-declare function countBy<T, K extends PropertyKey>(arr: readonly T[], mapper: (item: T) => K): Record<K, number>;
+declare function countBy<T, K extends PropertyKey>(arr: readonly T[], mapper: (item: T, index: number, array: readonly T[]) => K): Record<K, number>;
 
 export { countBy };

package/dist/array/countBy.d.ts

@@ -11,7 +11,7 @@
  * @template T - The type of the items in the input array.
  * @template K - The type of keys.
  * @param {T[]} arr - The input array to count occurrences.
- * @param {(item: T) => K} mapper - The transformation function that maps each item to a key.
+ * @param {(item: T, index: number, array: readonly T[]) => K} mapper - The transformation function that maps each item, its index, and the array to a key.
  * @returns {Record<K, number>} An object containing the transformed items as keys and the
  * counts as values.
  *
@@ -24,7 +24,13 @@
  * const array = [1, 2, 3, 4, 5];
  * const result = countBy(array, item => item % 2 === 0 ? 'even' : 'odd');
  * // result will be { odd: 3, even: 2 }
+ *
+ * @example
+ * // Using index parameter
+ * const array = ['a', 'b', 'c', 'd'];
+ * const result = countBy(array, (item, index) => index < 2 ? 'first' : 'rest');
+ * // result will be { first: 2, rest: 2 }
  */
-declare function countBy<T, K extends PropertyKey>(arr: readonly T[], mapper: (item: T) => K): Record<K, number>;
+declare function countBy<T, K extends PropertyKey>(arr: readonly T[], mapper: (item: T, index: number, array: readonly T[]) => K): Record<K, number>;
 
 export { countBy };

package/dist/array/countBy.js

@@ -6,7 +6,7 @@ function countBy(arr, mapper) {
     const result = {};
     for (let i = 0; i < arr.length; i++) {
         const item = arr[i];
-        const key = mapper(item);
+        const key = mapper(item, i, arr);
         result[key] = (result[key] ?? 0) + 1;
     }
     return result;

package/dist/array/countBy.mjs

@@ -2,7 +2,7 @@ function countBy(arr, mapper) {
     const result = {};
     for (let i = 0; i < arr.length; i++) {
         const item = arr[i];
-        const key = mapper(item);
+        const key = mapper(item, i, arr);
         result[key] = (result[key] ?? 0) + 1;
     }
     return result;

package/dist/array/flatMap.d.mts

@@ -5,7 +5,7 @@
  * @template U - The type of elements within the returned array from the iteratee function.
  * @template D - The depth to which the array should be flattened.
  * @param {T[]} arr - The array to flatten.
- * @param {(item: T) => U} iteratee - The function that produces the new array elements.
+ * @param {(item: T, index: number, array: readonly T[]) => U} iteratee - The function that produces the new array elements. It receives the element, its index, and the array.
  * @param {D} depth - The depth level specifying how deep a nested array structure should be flattened. Defaults to 1.
  * @returns {Array<FlatArray<U[], D>>} The new array with the mapped and flattened elements.
  *
@@ -18,6 +18,6 @@
  * flatMap(arr, (item: number) => [[item, item]], 2);
  * // [1, 1, 2, 2, 3, 3]
  */
-declare function flatMap<T, U, D extends number = 1>(arr: readonly T[], iteratee: (item: T) => U, depth?: D): Array<FlatArray<U[], D>>;
+declare function flatMap<T, U, D extends number = 1>(arr: readonly T[], iteratee: (item: T, index: number, array: readonly T[]) => U, depth?: D): Array<FlatArray<U[], D>>;
 
 export { flatMap };

package/dist/array/flatMap.d.ts

@@ -5,7 +5,7 @@
  * @template U - The type of elements within the returned array from the iteratee function.
  * @template D - The depth to which the array should be flattened.
  * @param {T[]} arr - The array to flatten.
- * @param {(item: T) => U} iteratee - The function that produces the new array elements.
+ * @param {(item: T, index: number, array: readonly T[]) => U} iteratee - The function that produces the new array elements. It receives the element, its index, and the array.
  * @param {D} depth - The depth level specifying how deep a nested array structure should be flattened. Defaults to 1.
  * @returns {Array<FlatArray<U[], D>>} The new array with the mapped and flattened elements.
  *
@@ -18,6 +18,6 @@
  * flatMap(arr, (item: number) => [[item, item]], 2);
  * // [1, 1, 2, 2, 3, 3]
  */
-declare function flatMap<T, U, D extends number = 1>(arr: readonly T[], iteratee: (item: T) => U, depth?: D): Array<FlatArray<U[], D>>;
+declare function flatMap<T, U, D extends number = 1>(arr: readonly T[], iteratee: (item: T, index: number, array: readonly T[]) => U, depth?: D): Array<FlatArray<U[], D>>;
 
 export { flatMap };

package/dist/array/flatMap.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const flatten = require('./flatten.js');
 
 function flatMap(arr, iteratee, depth = 1) {
-    return flatten.flatten(arr.map(item => iteratee(item)), depth);
+    return flatten.flatten(arr.map((item, index) => iteratee(item, index, arr)), depth);
 }
 
 exports.flatMap = flatMap;

package/dist/array/flatMap.mjs

@@ -1,7 +1,7 @@
 import { flatten } from './flatten.mjs';
 
 function flatMap(arr, iteratee, depth = 1) {
-    return flatten(arr.map(item => iteratee(item)), depth);
+    return flatten(arr.map((item, index) => iteratee(item, index, arr)), depth);
 }
 
 export { flatMap };

package/dist/array/flatMapDeep.d.mts

@@ -6,13 +6,13 @@ import { ExtractNestedArrayType } from './flattenDeep.mjs';
  * @template T - The type of elements within the array.
  * @template U - The type of elements within the returned array from the iteratee function.
  * @param {T[]} arr - The array to flatten.
- * @param {(item: T) => U} iteratee - The function that produces the new array elements.
+ * @param {(item: T, index: number, array: readonly T[]) => U} iteratee - The function that produces the new array elements. It receives the element, its index, and the array.
  * @returns {Array<ExtractNestedArrayType<U>>} A new array that has been flattened.
  *
  * @example
  * const result = flatMapDeep([1, 2, 3], n => [[n, n]]);
  * // [1, 1, 2, 2, 3, 3]
  */
-declare function flatMapDeep<T, U>(arr: readonly T[], iteratee: (item: T) => U): Array<ExtractNestedArrayType<U>>;
+declare function flatMapDeep<T, U>(arr: readonly T[], iteratee: (item: T, index: number, array: readonly T[]) => U): Array<ExtractNestedArrayType<U>>;
 
 export { flatMapDeep };

package/dist/array/flatMapDeep.d.ts

@@ -6,13 +6,13 @@ import { ExtractNestedArrayType } from './flattenDeep.js';
  * @template T - The type of elements within the array.
  * @template U - The type of elements within the returned array from the iteratee function.
  * @param {T[]} arr - The array to flatten.
- * @param {(item: T) => U} iteratee - The function that produces the new array elements.
+ * @param {(item: T, index: number, array: readonly T[]) => U} iteratee - The function that produces the new array elements. It receives the element, its index, and the array.
  * @returns {Array<ExtractNestedArrayType<U>>} A new array that has been flattened.
  *
  * @example
  * const result = flatMapDeep([1, 2, 3], n => [[n, n]]);
  * // [1, 1, 2, 2, 3, 3]
  */
-declare function flatMapDeep<T, U>(arr: readonly T[], iteratee: (item: T) => U): Array<ExtractNestedArrayType<U>>;
+declare function flatMapDeep<T, U>(arr: readonly T[], iteratee: (item: T, index: number, array: readonly T[]) => U): Array<ExtractNestedArrayType<U>>;
 
 export { flatMapDeep };

package/dist/array/flatMapDeep.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const flattenDeep = require('./flattenDeep.js');
 
 function flatMapDeep(arr, iteratee) {
-    return flattenDeep.flattenDeep(arr.map((item) => iteratee(item)));
+    return flattenDeep.flattenDeep(arr.map((item, index) => iteratee(item, index, arr)));
 }
 
 exports.flatMapDeep = flatMapDeep;

package/dist/array/flatMapDeep.mjs

@@ -1,7 +1,7 @@
 import { flattenDeep } from './flattenDeep.mjs';
 
 function flatMapDeep(arr, iteratee) {
-    return flattenDeep(arr.map((item) => iteratee(item)));
+    return flattenDeep(arr.map((item, index) => iteratee(item, index, arr)));
 }
 
 export { flatMapDeep };

package/dist/array/groupBy.d.mts

@@ -8,7 +8,7 @@
  * @template T - The type of elements in the array.
  * @template K - The type of keys.
  * @param {T[]} arr - The array to group.
- * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.
+ * @param {(item: T, index: number, array: readonly T[]) => K} getKeyFromItem - A function that generates a key from an element, its index, and the array.
  * @returns {Record<K, T[]>} An object where each key is associated with an array of elements that
  * share that key.
  *
@@ -29,7 +29,13 @@
  * //     { category: 'vegetable', name: 'carrot' }
  * //   ]
  * // }
+ *
+ * @example
+ * // Using index parameter
+ * const items = ['a', 'b', 'c', 'd'];
+ * const result = groupBy(items, (item, index) => index % 2 === 0 ? 'even' : 'odd');
+ * // result will be: { even: ['a', 'c'], odd: ['b', 'd'] }
  */
-declare function groupBy<T, K extends PropertyKey>(arr: readonly T[], getKeyFromItem: (item: T) => K): Record<K, T[]>;
+declare function groupBy<T, K extends PropertyKey>(arr: readonly T[], getKeyFromItem: (item: T, index: number, array: readonly T[]) => K): Record<K, T[]>;
 
 export { groupBy };

package/dist/array/groupBy.d.ts

@@ -8,7 +8,7 @@
  * @template T - The type of elements in the array.
  * @template K - The type of keys.
  * @param {T[]} arr - The array to group.
- * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.
+ * @param {(item: T, index: number, array: readonly T[]) => K} getKeyFromItem - A function that generates a key from an element, its index, and the array.
  * @returns {Record<K, T[]>} An object where each key is associated with an array of elements that
  * share that key.
  *
@@ -29,7 +29,13 @@
  * //     { category: 'vegetable', name: 'carrot' }
  * //   ]
  * // }
+ *
+ * @example
+ * // Using index parameter
+ * const items = ['a', 'b', 'c', 'd'];
+ * const result = groupBy(items, (item, index) => index % 2 === 0 ? 'even' : 'odd');
+ * // result will be: { even: ['a', 'c'], odd: ['b', 'd'] }
  */
-declare function groupBy<T, K extends PropertyKey>(arr: readonly T[], getKeyFromItem: (item: T) => K): Record<K, T[]>;
+declare function groupBy<T, K extends PropertyKey>(arr: readonly T[], getKeyFromItem: (item: T, index: number, array: readonly T[]) => K): Record<K, T[]>;
 
 export { groupBy };

package/dist/array/groupBy.js

@@ -6,7 +6,7 @@ function groupBy(arr, getKeyFromItem) {
     const result = {};
     for (let i = 0; i < arr.length; i++) {
         const item = arr[i];
-        const key = getKeyFromItem(item);
+        const key = getKeyFromItem(item, i, arr);
         if (!Object.hasOwn(result, key)) {
             result[key] = [];
         }

package/dist/array/groupBy.mjs

@@ -2,7 +2,7 @@ function groupBy(arr, getKeyFromItem) {
     const result = {};
     for (let i = 0; i < arr.length; i++) {
         const item = arr[i];
-        const key = getKeyFromItem(item);
+        const key = getKeyFromItem(item, i, arr);
         if (!Object.hasOwn(result, key)) {
             result[key] = [];
         }

package/dist/array/intersection.js

@@ -4,9 +4,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 function intersection(firstArr, secondArr) {
     const secondSet = new Set(secondArr);
-    return firstArr.filter(item => {
-        return secondSet.has(item);
-    });
+    return firstArr.filter(item => secondSet.has(item));
 }
 
 exports.intersection = intersection;

package/dist/array/intersection.mjs

@@ -1,8 +1,6 @@
 function intersection(firstArr, secondArr) {
     const secondSet = new Set(secondArr);
-    return firstArr.filter(item => {
-        return secondSet.has(item);
-    });
+    return firstArr.filter(item => secondSet.has(item));
 }
 
 export { intersection };

package/dist/array/keyBy.d.mts

@@ -9,7 +9,7 @@
  * @template T - The type of elements in the array.
  * @template K - The type of keys.
  * @param {T[]} arr - The array of elements to be mapped.
- * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.
+ * @param {(item: T, index: number, array: readonly T[]) => K} getKeyFromItem - A function that generates a key from an element, its index, and the array.
  * @returns {Record<K, T>} An object where keys are mapped to each element of an array.
  *
  * @example
@@ -24,7 +24,13 @@
  * //   fruit: { category: 'fruit', name: 'banana' },
  * //   vegetable: { category: 'vegetable', name: 'carrot' }
  * // }
+ *
+ * @example
+ * // Using index parameter
+ * const items = ['a', 'b', 'c'];
+ * const result = keyBy(items, (item, index) => index);
+ * // result will be: { 0: 'a', 1: 'b', 2: 'c' }
  */
-declare function keyBy<T, K extends PropertyKey>(arr: readonly T[], getKeyFromItem: (item: T) => K): Record<K, T>;
+declare function keyBy<T, K extends PropertyKey>(arr: readonly T[], getKeyFromItem: (item: T, index: number, array: readonly T[]) => K): Record<K, T>;
 
 export { keyBy };

package/dist/array/keyBy.d.ts

@@ -9,7 +9,7 @@
  * @template T - The type of elements in the array.
  * @template K - The type of keys.
  * @param {T[]} arr - The array of elements to be mapped.
- * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.
+ * @param {(item: T, index: number, array: readonly T[]) => K} getKeyFromItem - A function that generates a key from an element, its index, and the array.
  * @returns {Record<K, T>} An object where keys are mapped to each element of an array.
  *
  * @example
@@ -24,7 +24,13 @@
  * //   fruit: { category: 'fruit', name: 'banana' },
  * //   vegetable: { category: 'vegetable', name: 'carrot' }
  * // }
+ *
+ * @example
+ * // Using index parameter
+ * const items = ['a', 'b', 'c'];
+ * const result = keyBy(items, (item, index) => index);
+ * // result will be: { 0: 'a', 1: 'b', 2: 'c' }
  */
-declare function keyBy<T, K extends PropertyKey>(arr: readonly T[], getKeyFromItem: (item: T) => K): Record<K, T>;
+declare function keyBy<T, K extends PropertyKey>(arr: readonly T[], getKeyFromItem: (item: T, index: number, array: readonly T[]) => K): Record<K, T>;
 
 export { keyBy };

package/dist/array/keyBy.js

@@ -6,7 +6,7 @@ function keyBy(arr, getKeyFromItem) {
     const result = {};
     for (let i = 0; i < arr.length; i++) {
         const item = arr[i];
-        const key = getKeyFromItem(item);
+        const key = getKeyFromItem(item, i, arr);
         result[key] = item;
     }
     return result;

package/dist/array/keyBy.mjs

@@ -2,7 +2,7 @@ function keyBy(arr, getKeyFromItem) {
     const result = {};
     for (let i = 0; i < arr.length; i++) {
         const item = arr[i];
-        const key = getKeyFromItem(item);
+        const key = getKeyFromItem(item, i, arr);
         result[key] = item;
     }
     return result;

package/dist/array/maxBy.d.mts

@@ -18,14 +18,14 @@
  *   x => x.age
  * ); // Returns: { name: 'john', age: 30 }
  */
-declare function maxBy<T>(items: readonly [T, ...T[]], getValue: (element: T) => number): T;
+declare function maxBy<T>(items: readonly [T, ...T[]], getValue: (element: T, index: number, array: readonly T[]) => number): T;
 /**
  * Finds the element in an array that has the maximum value when applying
  * the `getValue` function to each element.
  *
  * @template T - The type of elements in the array.
  * @param {T[]} items The array of elements to search.
- * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @param {(element: T, index: number, array: readonly T[]) => number} getValue A function that selects a numeric value from each element.
  * @returns {T | undefined} The element with the maximum value as determined by the `getValue` function,
  * or `undefined` if the array is empty.
  * @example
@@ -40,6 +40,6 @@ declare function maxBy<T>(items: readonly [T, ...T[]], getValue: (element: T) =>
  *   x => x.age
  * ); // Returns: { name: 'john', age: 30 }
  */
-declare function maxBy<T>(items: readonly T[], getValue: (element: T) => number): T | undefined;
+declare function maxBy<T>(items: readonly T[], getValue: (element: T, index: number, array: readonly T[]) => number): T | undefined;
 
 export { maxBy };

package/dist/array/maxBy.d.ts

@@ -18,14 +18,14 @@
  *   x => x.age
  * ); // Returns: { name: 'john', age: 30 }
  */
-declare function maxBy<T>(items: readonly [T, ...T[]], getValue: (element: T) => number): T;
+declare function maxBy<T>(items: readonly [T, ...T[]], getValue: (element: T, index: number, array: readonly T[]) => number): T;
 /**
  * Finds the element in an array that has the maximum value when applying
  * the `getValue` function to each element.
  *
  * @template T - The type of elements in the array.
  * @param {T[]} items The array of elements to search.
- * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @param {(element: T, index: number, array: readonly T[]) => number} getValue A function that selects a numeric value from each element.
  * @returns {T | undefined} The element with the maximum value as determined by the `getValue` function,
  * or `undefined` if the array is empty.
  * @example
@@ -40,6 +40,6 @@ declare function maxBy<T>(items: readonly [T, ...T[]], getValue: (element: T) =>
  *   x => x.age
  * ); // Returns: { name: 'john', age: 30 }
  */
-declare function maxBy<T>(items: readonly T[], getValue: (element: T) => number): T | undefined;
+declare function maxBy<T>(items: readonly T[], getValue: (element: T, index: number, array: readonly T[]) => number): T | undefined;
 
 export { maxBy };

package/dist/array/maxBy.js

@@ -7,10 +7,10 @@ function maxBy(items, getValue) {
         return undefined;
     }
     let maxElement = items[0];
-    let max = getValue(maxElement);
+    let max = getValue(maxElement, 0, items);
     for (let i = 1; i < items.length; i++) {
         const element = items[i];
-        const value = getValue(element);
+        const value = getValue(element, i, items);
         if (value > max) {
             max = value;
             maxElement = element;

package/dist/array/maxBy.mjs

@@ -3,10 +3,10 @@ function maxBy(items, getValue) {
         return undefined;
     }
     let maxElement = items[0];
-    let max = getValue(maxElement);
+    let max = getValue(maxElement, 0, items);
     for (let i = 1; i < items.length; i++) {
         const element = items[i];
-        const value = getValue(element);
+        const value = getValue(element, i, items);
         if (value > max) {
             max = value;
             maxElement = element;

package/dist/array/minBy.d.mts

@@ -18,14 +18,14 @@
  *   x => x.age
  * ); // Returns: { name: 'joe', age: 26 }
  */
-declare function minBy<T>(items: readonly [T, ...T[]], getValue: (element: T) => number): T;
+declare function minBy<T>(items: readonly [T, ...T[]], getValue: (element: T, index: number, array: readonly T[]) => number): T;
 /**
  * Finds the element in an array that has the minimum value when applying
  * the `getValue` function to each element.
  *
  * @template T - The type of elements in the array.
  * @param {T[]} items The array of elements to search.
- * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @param {(element: T, index: number, array: readonly T[]) => number} getValue A function that selects a numeric value from each element.
  * @returns {T | undefined} The element with the minimum value as determined by the `getValue` function,
  * or `undefined` if the array is empty.
  * @example
@@ -40,6 +40,6 @@ declare function minBy<T>(items: readonly [T, ...T[]], getValue: (element: T) =>
  *   x => x.age
  * ); // Returns: { name: 'joe', age: 26 }
  */
-declare function minBy<T>(items: readonly T[], getValue: (element: T) => number): T | undefined;
+declare function minBy<T>(items: readonly T[], getValue: (element: T, index: number, array: readonly T[]) => number): T | undefined;
 
 export { minBy };

package/dist/array/minBy.d.ts

@@ -18,14 +18,14 @@
  *   x => x.age
  * ); // Returns: { name: 'joe', age: 26 }
  */
-declare function minBy<T>(items: readonly [T, ...T[]], getValue: (element: T) => number): T;
+declare function minBy<T>(items: readonly [T, ...T[]], getValue: (element: T, index: number, array: readonly T[]) => number): T;
 /**
  * Finds the element in an array that has the minimum value when applying
  * the `getValue` function to each element.
  *
  * @template T - The type of elements in the array.
  * @param {T[]} items The array of elements to search.
- * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @param {(element: T, index: number, array: readonly T[]) => number} getValue A function that selects a numeric value from each element.
  * @returns {T | undefined} The element with the minimum value as determined by the `getValue` function,
  * or `undefined` if the array is empty.
  * @example
@@ -40,6 +40,6 @@ declare function minBy<T>(items: readonly [T, ...T[]], getValue: (element: T) =>
  *   x => x.age
  * ); // Returns: { name: 'joe', age: 26 }
  */
-declare function minBy<T>(items: readonly T[], getValue: (element: T) => number): T | undefined;
+declare function minBy<T>(items: readonly T[], getValue: (element: T, index: number, array: readonly T[]) => number): T | undefined;
 
 export { minBy };

package/dist/array/minBy.js

@@ -7,10 +7,10 @@ function minBy(items, getValue) {
         return undefined;
     }
     let minElement = items[0];
-    let min = getValue(minElement);
+    let min = getValue(minElement, 0, items);
     for (let i = 1; i < items.length; i++) {
         const element = items[i];
-        const value = getValue(element);
+        const value = getValue(element, i, items);
         if (value < min) {
             min = value;
             minElement = element;

package/dist/array/minBy.mjs

@@ -3,10 +3,10 @@ function minBy(items, getValue) {
         return undefined;
     }
     let minElement = items[0];
-    let min = getValue(minElement);
+    let min = getValue(minElement, 0, items);
     for (let i = 1; i < items.length; i++) {
         const element = items[i];
-        const value = getValue(element);
+        const value = getValue(element, i, items);
         if (value < min) {
             min = value;
             minElement = element;

package/dist/array/partition.d.mts

@@ -8,9 +8,9 @@
  * @template T - The type of elements in the array.
  * @template {T} U - The type being filtered for.
  * @param {T[]} arr - The array to partition.
- * @param {(value: T) => value is U} isInTruthy - A type guard that determines whether an
+ * @param {(value: T, index: number, array: readonly T[]) => value is U} isInTruthy - A type guard that determines whether an
  * element should be placed in the truthy array. The function is called with each element
- * of the array.
+ * of the array and its index.
  * @returns {[U[], Exclude<T, U>[]]} A tuple containing two arrays: the first array contains elements for
  * which the predicate returned true, and the second array contains elements for which the
  * predicate returned false.
@@ -21,7 +21,7 @@
  * const [even, odd]: [(2 | 4)[], (2 | 4)[]] = partition(array, isEven);
  * // even will be [2, 4], and odd will be [1, 3]
  */
-declare function partition<T, U extends T>(arr: readonly T[], isInTruthy: (value: T) => value is U): [truthy: U[], falsy: Array<Exclude<T, U>>];
+declare function partition<T, U extends T>(arr: readonly T[], isInTruthy: (value: T, index: number, array: readonly T[]) => value is U): [truthy: U[], falsy: Array<Exclude<T, U>>];
 /**
  * Splits an array into two groups based on a predicate function.
  *
@@ -31,9 +31,9 @@ declare function partition<T, U extends T>(arr: readonly T[], isInTruthy: (value
  *
  * @template T - The type of elements in the array.
  * @param {T[]} arr - The array to partition.
- * @param {(value: T) => boolean} isInTruthy - A predicate function that determines
+ * @param {(value: T, index: number) => boolean} isInTruthy - A predicate function that determines
  * whether an element should be placed in the truthy array. The function is called with each
- * element of the array.
+ * element of the array and its index.
  * @returns {[T[], T[]]} A tuple containing two arrays: the first array contains elements for
  * which the predicate returned true, and the second array contains elements for which the
  * predicate returned false.
@@ -44,6 +44,6 @@ declare function partition<T, U extends T>(arr: readonly T[], isInTruthy: (value
  * const [even, odd] = partition(array, isEven);
  * // even will be [2, 4], and odd will be [1, 3, 5]
  */
-declare function partition<T>(arr: readonly T[], isInTruthy: (value: T) => boolean): [truthy: T[], falsy: T[]];
+declare function partition<T>(arr: readonly T[], isInTruthy: (value: T, index: number, array: readonly T[]) => boolean): [truthy: T[], falsy: T[]];
 
 export { partition };