es-toolkit 1.32.0-dev.1005 → 1.32.0-dev.1007

package/dist/compat/array/find.mjs

@@ -1,46 +1,26 @@
-import { property } from '../object/property.mjs';
-import { matches } from '../predicate/matches.mjs';
-import { matchesProperty } from '../predicate/matchesProperty.mjs';
+import { iteratee } from '../util/iteratee.mjs';
 
-function find(source, doesMatch, fromIndex = 0) {
+function find(source, _doesMatch, fromIndex = 0) {
     if (!source) {
         return undefined;
     }
     if (fromIndex < 0) {
         fromIndex = Math.max(source.length + fromIndex, 0);
     }
+    const doesMatch = iteratee(_doesMatch);
     const values = Array.isArray(source) ? source.slice(fromIndex) : Object.values(source).slice(fromIndex);
-    switch (typeof doesMatch) {
-        case 'function': {
-            if (!Array.isArray(source)) {
-                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;
-                    }
-                }
-                return undefined;
+    if (typeof doesMatch === 'function' && !Array.isArray(source)) {
+        const keys = Object.keys(source).slice(fromIndex);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const value = source[key];
+            if (doesMatch(value, key, source)) {
+                return value;
             }
-            return values.find(doesMatch);
-        }
-        case 'object': {
-            if (Array.isArray(doesMatch) && doesMatch.length === 2) {
-                const key = doesMatch[0];
-                const value = doesMatch[1];
-                return values.find(matchesProperty(key, value));
-            }
-            else {
-                return values.find(matches(doesMatch));
-            }
-        }
-        case 'symbol':
-        case 'number':
-        case 'string': {
-            return values.find(property(doesMatch));
         }
+        return undefined;
     }
+    return values.find(doesMatch);
 }
 
 export { find };

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

@@ -0,0 +1,130 @@
+/**
+ * Finds the last item in an array that matches the given predicate function.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
+ * @param {(item: T, index: number, arr: T[]) => unknown} doesMatch - A function that takes an item, its index, and the array, and returns a truthy value if the item matches the criteria.
+ * @param {number} [fromIndex=arr.length-1] - The index to start the search from, defaults to arr.length-1.
+ * @returns {T | undefined} - The last item that matches the predicate, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a predicate function
+ * const items = [1, 2, 3, 4, 5];
+ * const result = findLast(items, (item) => item > 3);
+ * console.log(result); // 5
+ */
+declare function findLast<T>(arr: ArrayLike<T> | null | undefined, doesMatch: (item: T, index: number, arr: readonly T[]) => unknown, fromIndex?: number): T | undefined;
+/**
+ * Finds the last item in an array that matches the given partial object.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
+ * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @param {number} [fromIndex=arr.length-1] - The index to start the search from, defaults to arr.length-1.
+ * @returns {T | undefined} - The last item that matches the partial object, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a partial object
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Bob' }];
+ * const result = findLast(items, { name: 'Bob' });
+ * console.log(result); // { id: 3, name: 'Bob' }
+ */
+declare function findLast<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>, fromIndex?: number): T | undefined;
+/**
+ * Finds the last item in an array that matches a property with a specific value.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
+ * @param {[keyof T, unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @param {number} [fromIndex=arr.length-1] - The index to start the search from, defaults to arr.length-1.
+ * @returns {T | undefined} - The last item that has the specified property value, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property-value pair
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Alice' }];
+ * const result = findLast(items, ['name', 'Alice']);
+ * console.log(result); // { id: 3, name: 'Alice' }
+ */
+declare function findLast<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty: [keyof T, unknown], fromIndex?: number): T | undefined;
+/**
+ * Finds the last item in an array that has a specific property, where the property name is provided as a PropertyKey.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
+ * @param {PropertyKey} propertyToCheck - The property name to check.
+ * @param {number} [fromIndex=arr.length-1] - The index to start the search from, defaults to arr.length-1.
+ * @returns {T | undefined} - The last item that has the specified property, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property name
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2 }, { id: 3, name: 'Bob' }];
+ * const result = findLast(items, 'name');
+ * console.log(result); // { id: 3, name: 'Bob' }
+ */
+declare function findLast<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: PropertyKey, fromIndex?: number): T | undefined;
+/**
+ * Finds the last item in an object that matches the given predicate function.
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to search through.
+ * @param {(item: T[keyof T], index: number, arr: T) => unknown} doesMatch - A function that takes an item, its key, and the object, and returns a truthy value if the item matches the criteria.
+ * @param {number} [fromIndex=Object.keys(object).length-1] - The index to start the search from, defaults to Object.keys(object).length-1.
+ * @returns {T | undefined} - The last property value that matches the predicate, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a predicate function
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const result = findLast(obj, (item) => item > 1);
+ * console.log(result); // 3
+ */
+declare function findLast<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (item: T[keyof T], index: keyof T, object: T) => unknown, fromIndex?: number): T | undefined;
+/**
+ * Finds the last item in an object that matches the given partial value.
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to search through.
+ * @param {Partial<T[keyof T]>} doesMatch - A partial value to match against the values of the object.
+ * @param {number} [fromIndex=Object.keys(object).length-1] - The index to start the search from, defaults to Object.keys(object).length-1.
+ * @returns {T | undefined} - The last property value that matches the partial value, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a partial value
+ * const obj = { a: { id: 1, name: 'Bob' }, b: { id: 2, name: 'Alice' }, c: { id: 3, name: 'Bob' } };
+ * const result = findLast(obj, { name: 'Bob' });
+ * console.log(result); // { id: 3, name: 'Bob' }
+ */
+declare function findLast<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>, fromIndex?: number): T | undefined;
+/**
+ * Finds the last item in an object that matches a property with a specific value.
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to search through.
+ * @param {[keyof T[keyof T], unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @param {number} [fromIndex=Object.keys(object).length-1] - The index to start the search from, defaults to Object.keys(object).length-1.
+ * @returns {T | undefined} - The last item that has the specified property value, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property-value pair
+ * const items = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' }, c: { id: 3, name: 'Alice' } };
+ * const result = findLast(items, ['name', 'Alice']);
+ * console.log(result); // { id: 3, name: 'Alice' }
+ */
+declare function findLast<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown], fromIndex?: number): T | undefined;
+/**
+ * Finds the last item in an object that has a specific property, where the property name is provided as a PropertyKey.
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to search through.
+ * @param {PropertyKey} propertyToCheck - The property name to check.
+ * @param {number} [fromIndex=Object.keys(object).length-1] - The index to start the search from, defaults to Object.keys(object).length-1.
+ * @returns {T | undefined} - The last property value that has the specified property, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property name
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2 }, c: { id: 3, name: 'Bob' } };
+ * const result = findLast(obj, 'name');
+ * console.log(result); // { id: 3, name: 'Bob' }
+ */
+declare function findLast<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: PropertyKey, fromIndex?: number): T | undefined;
+
+export { findLast };

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

@@ -0,0 +1,130 @@
+/**
+ * Finds the last item in an array that matches the given predicate function.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
+ * @param {(item: T, index: number, arr: T[]) => unknown} doesMatch - A function that takes an item, its index, and the array, and returns a truthy value if the item matches the criteria.
+ * @param {number} [fromIndex=arr.length-1] - The index to start the search from, defaults to arr.length-1.
+ * @returns {T | undefined} - The last item that matches the predicate, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a predicate function
+ * const items = [1, 2, 3, 4, 5];
+ * const result = findLast(items, (item) => item > 3);
+ * console.log(result); // 5
+ */
+declare function findLast<T>(arr: ArrayLike<T> | null | undefined, doesMatch: (item: T, index: number, arr: readonly T[]) => unknown, fromIndex?: number): T | undefined;
+/**
+ * Finds the last item in an array that matches the given partial object.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
+ * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @param {number} [fromIndex=arr.length-1] - The index to start the search from, defaults to arr.length-1.
+ * @returns {T | undefined} - The last item that matches the partial object, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a partial object
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Bob' }];
+ * const result = findLast(items, { name: 'Bob' });
+ * console.log(result); // { id: 3, name: 'Bob' }
+ */
+declare function findLast<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>, fromIndex?: number): T | undefined;
+/**
+ * Finds the last item in an array that matches a property with a specific value.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
+ * @param {[keyof T, unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @param {number} [fromIndex=arr.length-1] - The index to start the search from, defaults to arr.length-1.
+ * @returns {T | undefined} - The last item that has the specified property value, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property-value pair
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Alice' }];
+ * const result = findLast(items, ['name', 'Alice']);
+ * console.log(result); // { id: 3, name: 'Alice' }
+ */
+declare function findLast<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty: [keyof T, unknown], fromIndex?: number): T | undefined;
+/**
+ * Finds the last item in an array that has a specific property, where the property name is provided as a PropertyKey.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
+ * @param {PropertyKey} propertyToCheck - The property name to check.
+ * @param {number} [fromIndex=arr.length-1] - The index to start the search from, defaults to arr.length-1.
+ * @returns {T | undefined} - The last item that has the specified property, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property name
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2 }, { id: 3, name: 'Bob' }];
+ * const result = findLast(items, 'name');
+ * console.log(result); // { id: 3, name: 'Bob' }
+ */
+declare function findLast<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: PropertyKey, fromIndex?: number): T | undefined;
+/**
+ * Finds the last item in an object that matches the given predicate function.
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to search through.
+ * @param {(item: T[keyof T], index: number, arr: T) => unknown} doesMatch - A function that takes an item, its key, and the object, and returns a truthy value if the item matches the criteria.
+ * @param {number} [fromIndex=Object.keys(object).length-1] - The index to start the search from, defaults to Object.keys(object).length-1.
+ * @returns {T | undefined} - The last property value that matches the predicate, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a predicate function
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const result = findLast(obj, (item) => item > 1);
+ * console.log(result); // 3
+ */
+declare function findLast<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (item: T[keyof T], index: keyof T, object: T) => unknown, fromIndex?: number): T | undefined;
+/**
+ * Finds the last item in an object that matches the given partial value.
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to search through.
+ * @param {Partial<T[keyof T]>} doesMatch - A partial value to match against the values of the object.
+ * @param {number} [fromIndex=Object.keys(object).length-1] - The index to start the search from, defaults to Object.keys(object).length-1.
+ * @returns {T | undefined} - The last property value that matches the partial value, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a partial value
+ * const obj = { a: { id: 1, name: 'Bob' }, b: { id: 2, name: 'Alice' }, c: { id: 3, name: 'Bob' } };
+ * const result = findLast(obj, { name: 'Bob' });
+ * console.log(result); // { id: 3, name: 'Bob' }
+ */
+declare function findLast<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>, fromIndex?: number): T | undefined;
+/**
+ * Finds the last item in an object that matches a property with a specific value.
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to search through.
+ * @param {[keyof T[keyof T], unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @param {number} [fromIndex=Object.keys(object).length-1] - The index to start the search from, defaults to Object.keys(object).length-1.
+ * @returns {T | undefined} - The last item that has the specified property value, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property-value pair
+ * const items = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' }, c: { id: 3, name: 'Alice' } };
+ * const result = findLast(items, ['name', 'Alice']);
+ * console.log(result); // { id: 3, name: 'Alice' }
+ */
+declare function findLast<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown], fromIndex?: number): T | undefined;
+/**
+ * Finds the last item in an object that has a specific property, where the property name is provided as a PropertyKey.
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to search through.
+ * @param {PropertyKey} propertyToCheck - The property name to check.
+ * @param {number} [fromIndex=Object.keys(object).length-1] - The index to start the search from, defaults to Object.keys(object).length-1.
+ * @returns {T | undefined} - The last property value that has the specified property, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property name
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2 }, c: { id: 3, name: 'Bob' } };
+ * const result = findLast(obj, 'name');
+ * console.log(result); // { id: 3, name: 'Bob' }
+ */
+declare function findLast<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: PropertyKey, fromIndex?: number): T | undefined;
+
+export { findLast };

package/dist/compat/array/findLast.mjs

@@ -0,0 +1,32 @@
+import { iteratee } from '../util/iteratee.mjs';
+import { toInteger } from '../util/toInteger.mjs';
+
+function findLast(source, _doesMatch, fromIndex) {
+    if (!source) {
+        return undefined;
+    }
+    const length = Array.isArray(source) ? source.length : Object.keys(source).length;
+    fromIndex = toInteger(fromIndex ?? length - 1);
+    if (fromIndex < 0) {
+        fromIndex = Math.max(length + fromIndex, 0);
+    }
+    else {
+        fromIndex = Math.min(fromIndex, length - 1);
+    }
+    const doesMatch = iteratee(_doesMatch);
+    const values = Array.isArray(source) ? source.slice(0, fromIndex + 1) : Object.values(source).slice(0, fromIndex + 1);
+    if (typeof doesMatch === 'function' && !Array.isArray(source)) {
+        const keys = Object.keys(source).slice(0, fromIndex + 1);
+        for (let i = fromIndex; i >= 0; i--) {
+            const key = keys[i];
+            const value = source[key];
+            if (doesMatch(value, key, source)) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    return values.findLast(doesMatch);
+}
+
+export { findLast };

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

@@ -0,0 +1,96 @@
+/**
+ * Returns the intersection of two arrays based on a custom equality function.
+ *
+ * This function takes two arrays and a custom equality function. It returns a new array containing
+ * the elements from the first array that have matching elements in the second array, as determined
+ * by the custom equality function. It effectively filters out any elements from the first array that
+ * do not have corresponding matches in the second array according to the equality function.
+ *
+ * @template T - The type of elements in the first array.
+ * @template U - The type of elements in the second array.
+ * @param {T[]} firstArr - The first array to compare.
+ * @param {U[]} secondArr - The second array to compare.
+ * @param {(x: T, y: U) => boolean} areItemsEqual - A custom function to determine if two elements are equal.
+ * This function takes two arguments, one from each array, and returns `true` if the elements are considered equal, and `false` otherwise.
+ * @returns {T[]} A new array containing the elements from the first array that have corresponding matches in the second array according to the custom equality function.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [{ id: 2 }, { id: 4 }];
+ * const areItemsEqual = (a, b) => a.id === b.id;
+ * const result = intersectionWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 2 }] since this element has a matching id in both arrays.
+ *
+ * @example
+ * const array1 = [
+ *   { id: 1, name: 'jane' },
+ *   { id: 2, name: 'amy' },
+ *   { id: 3, name: 'michael' },
+ * ];
+ * const array2 = [2, 4];
+ * const areItemsEqual = (a, b) => a.id === b;
+ * const result = intersectionWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 2, name: 'amy' }] since this element has a matching id that is equal to seconds array's element.
+ */
+declare function intersectionWith<T, U>(firstArr: ArrayLike<T> | null | undefined, secondArr: ArrayLike<U> | null | undefined, areItemsEqual: (x: T, y: U) => boolean): T[];
+/**
+ * Returns the intersection of three arrays based on a custom equality function.
+ *
+ * @template T - The type of elements in the first array
+ * @template U - The type of elements in the second array
+ * @template V - The type of elements in the third array
+ * @param {ArrayLike<T> | null | undefined} firstArr - The first array to compare
+ * @param {ArrayLike<U> | null | undefined} secondArr - The second array to compare
+ * @param {ArrayLike<V> | null | undefined} thirdArr - The third array to compare
+ * @param {(x: T, y: U | V) => boolean} areItemsEqual - Custom equality function
+ * @returns {T[]} Elements from first array that match in all arrays
+ *
+ * @example
+ * const arr1 = [{id: 1}, {id: 2}];
+ * const arr2 = [{id: 2}, {id: 3}];
+ * const arr3 = [{id: 2}, {id: 4}];
+ * const result = intersectionWith(arr1, arr2, arr3, (a, b) => a.id === b.id);
+ * // result is [{id: 2}]
+ */
+declare function intersectionWith<T, U, V>(firstArr: ArrayLike<T> | null | undefined, secondArr: ArrayLike<U> | null | undefined, thirdArr: ArrayLike<V> | null | undefined, areItemsEqual: (x: T, y: U | V) => boolean): T[];
+/**
+ * Returns the intersection of four arrays based on a custom equality function.
+ *
+ * @template T - The type of elements in the first array
+ * @template U - The type of elements in the second array
+ * @template V - The type of elements in the third array
+ * @template W - The type of elements in the fourth array
+ * @param {ArrayLike<T> | null | undefined} firstArr - The first array to compare
+ * @param {ArrayLike<U> | null | undefined} secondArr - The second array to compare
+ * @param {ArrayLike<V> | null | undefined} thirdArr - The third array to compare
+ * @param {ArrayLike<V> | null | undefined} fourthArr - The fourth array to compare
+ * @param {(x: T, y: U | V | W) => boolean} areItemsEqual - Custom equality function
+ * @returns {T[]} Elements from first array that match in all arrays
+ *
+ * @example
+ * const arr1 = [{id: 1}, {id: 2}];
+ * const arr2 = [{id: 2}, {id: 3}];
+ * const arr3 = [{id: 2}, {id: 4}];
+ * const arr4 = [{id: 2}, {id: 5}];
+ * const result = intersectionWith(arr1, arr2, arr3, arr4, (a, b) => a.id === b.id);
+ * // result is [{id: 2}]
+ */
+declare function intersectionWith<T, U, V, W>(firstArr: ArrayLike<T> | null | undefined, secondArr: ArrayLike<U> | null | undefined, thirdArr: ArrayLike<V> | null | undefined, fourthArr: ArrayLike<V> | null | undefined, areItemsEqual: (x: T, y: U | V | W) => boolean): T[];
+/**
+ * Returns the intersection of multiple arrays based on a custom equality function.
+ *
+ * @template T - The type of elements in the arrays
+ * @param {ArrayLike<T> | null | undefined} firstArr - The first array to compare
+ * @param {...(ArrayLike<T> | null | undefined | ((x: T, y: T) => boolean))} otherArrs - Additional arrays and optional equality function
+ * @returns {T[]} Elements from first array that match in all arrays
+ *
+ * @example
+ * const arr1 = [{id: 1}, {id: 2}];
+ * const arr2 = [{id: 2}, {id: 3}];
+ * const arr3 = [{id: 2}, {id: 4}];
+ * const result = intersectionWith(arr1, arr2, arr3, (a, b) => a.id === b.id);
+ * // result is [{id: 2}]
+ */
+declare function intersectionWith<T>(firstArr: ArrayLike<T> | null | undefined, ...otherArrs: Array<ArrayLike<T> | null | undefined | ((x: T, y: T) => boolean)>): T[];
+
+export { intersectionWith };

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

@@ -0,0 +1,96 @@
+/**
+ * Returns the intersection of two arrays based on a custom equality function.
+ *
+ * This function takes two arrays and a custom equality function. It returns a new array containing
+ * the elements from the first array that have matching elements in the second array, as determined
+ * by the custom equality function. It effectively filters out any elements from the first array that
+ * do not have corresponding matches in the second array according to the equality function.
+ *
+ * @template T - The type of elements in the first array.
+ * @template U - The type of elements in the second array.
+ * @param {T[]} firstArr - The first array to compare.
+ * @param {U[]} secondArr - The second array to compare.
+ * @param {(x: T, y: U) => boolean} areItemsEqual - A custom function to determine if two elements are equal.
+ * This function takes two arguments, one from each array, and returns `true` if the elements are considered equal, and `false` otherwise.
+ * @returns {T[]} A new array containing the elements from the first array that have corresponding matches in the second array according to the custom equality function.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [{ id: 2 }, { id: 4 }];
+ * const areItemsEqual = (a, b) => a.id === b.id;
+ * const result = intersectionWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 2 }] since this element has a matching id in both arrays.
+ *
+ * @example
+ * const array1 = [
+ *   { id: 1, name: 'jane' },
+ *   { id: 2, name: 'amy' },
+ *   { id: 3, name: 'michael' },
+ * ];
+ * const array2 = [2, 4];
+ * const areItemsEqual = (a, b) => a.id === b;
+ * const result = intersectionWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 2, name: 'amy' }] since this element has a matching id that is equal to seconds array's element.
+ */
+declare function intersectionWith<T, U>(firstArr: ArrayLike<T> | null | undefined, secondArr: ArrayLike<U> | null | undefined, areItemsEqual: (x: T, y: U) => boolean): T[];
+/**
+ * Returns the intersection of three arrays based on a custom equality function.
+ *
+ * @template T - The type of elements in the first array
+ * @template U - The type of elements in the second array
+ * @template V - The type of elements in the third array
+ * @param {ArrayLike<T> | null | undefined} firstArr - The first array to compare
+ * @param {ArrayLike<U> | null | undefined} secondArr - The second array to compare
+ * @param {ArrayLike<V> | null | undefined} thirdArr - The third array to compare
+ * @param {(x: T, y: U | V) => boolean} areItemsEqual - Custom equality function
+ * @returns {T[]} Elements from first array that match in all arrays
+ *
+ * @example
+ * const arr1 = [{id: 1}, {id: 2}];
+ * const arr2 = [{id: 2}, {id: 3}];
+ * const arr3 = [{id: 2}, {id: 4}];
+ * const result = intersectionWith(arr1, arr2, arr3, (a, b) => a.id === b.id);
+ * // result is [{id: 2}]
+ */
+declare function intersectionWith<T, U, V>(firstArr: ArrayLike<T> | null | undefined, secondArr: ArrayLike<U> | null | undefined, thirdArr: ArrayLike<V> | null | undefined, areItemsEqual: (x: T, y: U | V) => boolean): T[];
+/**
+ * Returns the intersection of four arrays based on a custom equality function.
+ *
+ * @template T - The type of elements in the first array
+ * @template U - The type of elements in the second array
+ * @template V - The type of elements in the third array
+ * @template W - The type of elements in the fourth array
+ * @param {ArrayLike<T> | null | undefined} firstArr - The first array to compare
+ * @param {ArrayLike<U> | null | undefined} secondArr - The second array to compare
+ * @param {ArrayLike<V> | null | undefined} thirdArr - The third array to compare
+ * @param {ArrayLike<V> | null | undefined} fourthArr - The fourth array to compare
+ * @param {(x: T, y: U | V | W) => boolean} areItemsEqual - Custom equality function
+ * @returns {T[]} Elements from first array that match in all arrays
+ *
+ * @example
+ * const arr1 = [{id: 1}, {id: 2}];
+ * const arr2 = [{id: 2}, {id: 3}];
+ * const arr3 = [{id: 2}, {id: 4}];
+ * const arr4 = [{id: 2}, {id: 5}];
+ * const result = intersectionWith(arr1, arr2, arr3, arr4, (a, b) => a.id === b.id);
+ * // result is [{id: 2}]
+ */
+declare function intersectionWith<T, U, V, W>(firstArr: ArrayLike<T> | null | undefined, secondArr: ArrayLike<U> | null | undefined, thirdArr: ArrayLike<V> | null | undefined, fourthArr: ArrayLike<V> | null | undefined, areItemsEqual: (x: T, y: U | V | W) => boolean): T[];
+/**
+ * Returns the intersection of multiple arrays based on a custom equality function.
+ *
+ * @template T - The type of elements in the arrays
+ * @param {ArrayLike<T> | null | undefined} firstArr - The first array to compare
+ * @param {...(ArrayLike<T> | null | undefined | ((x: T, y: T) => boolean))} otherArrs - Additional arrays and optional equality function
+ * @returns {T[]} Elements from first array that match in all arrays
+ *
+ * @example
+ * const arr1 = [{id: 1}, {id: 2}];
+ * const arr2 = [{id: 2}, {id: 3}];
+ * const arr3 = [{id: 2}, {id: 4}];
+ * const result = intersectionWith(arr1, arr2, arr3, (a, b) => a.id === b.id);
+ * // result is [{id: 2}]
+ */
+declare function intersectionWith<T>(firstArr: ArrayLike<T> | null | undefined, ...otherArrs: Array<ArrayLike<T> | null | undefined | ((x: T, y: T) => boolean)>): T[];
+
+export { intersectionWith };

package/dist/compat/array/intersectionWith.mjs

@@ -0,0 +1,43 @@
+import { last } from './last.mjs';
+import { intersectionWith as intersectionWith$1 } from '../../array/intersectionWith.mjs';
+import { uniq } from './uniq.mjs';
+import { eq } from '../util/eq.mjs';
+
+function intersectionWith(firstArr, ...otherArrs) {
+    console.log(firstArr);
+    if (firstArr == null) {
+        return [];
+    }
+    const _comparator = last(otherArrs);
+    let comparator = eq;
+    let uniq$1 = uniq;
+    if (typeof _comparator === 'function') {
+        comparator = _comparator;
+        uniq$1 = uniqPreserve0;
+        otherArrs.pop();
+    }
+    let result = uniq$1(Array.from(firstArr));
+    for (let i = 0; i < otherArrs.length; ++i) {
+        const otherArr = otherArrs[i];
+        if (otherArr == null) {
+            return [];
+        }
+        result = intersectionWith$1(result, Array.from(otherArr), comparator);
+    }
+    return result;
+}
+function uniqPreserve0(arr) {
+    const result = [];
+    const added = new Set();
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        if (added.has(item)) {
+            continue;
+        }
+        result.push(item);
+        added.add(item);
+    }
+    return result;
+}
+
+export { intersectionWith };

package/dist/compat/index.d.mts

@@ -5,7 +5,6 @@ export { flatMapDeep } from '../array/flatMapDeep.mjs';
 export { forEachRight } from '../array/forEachRight.mjs';
 export { groupBy } from '../array/groupBy.mjs';
 export { initial } from '../array/initial.mjs';
-export { intersectionWith } from '../array/intersectionWith.mjs';
 export { isSubset } from '../array/isSubset.mjs';
 export { isSubsetWith } from '../array/isSubsetWith.mjs';
 export { keyBy } from '../array/keyBy.mjs';
@@ -85,6 +84,7 @@ export { fill } from './array/fill.mjs';
 export { filter } from './array/filter.mjs';
 export { find } from './array/find.mjs';
 export { findIndex } from './array/findIndex.mjs';
+export { findLast } from './array/findLast.mjs';
 export { findLastIndex } from './array/findLastIndex.mjs';
 export { flatten } from './array/flatten.mjs';
 export { flattenDeep } from './array/flattenDeep.mjs';
@@ -95,6 +95,7 @@ export { includes } from './array/includes.mjs';
 export { indexOf } from './array/indexOf.mjs';
 export { intersection } from './array/intersection.mjs';
 export { intersectionBy } from './array/intersectionBy.mjs';
+export { intersectionWith } from './array/intersectionWith.mjs';
 export { join } from './array/join.mjs';
 export { last } from './array/last.mjs';
 export { lastIndexOf } from './array/lastIndexOf.mjs';

package/dist/compat/index.d.ts

@@ -5,7 +5,6 @@ export { flatMapDeep } from '../array/flatMapDeep.js';
 export { forEachRight } from '../array/forEachRight.js';
 export { groupBy } from '../array/groupBy.js';
 export { initial } from '../array/initial.js';
-export { intersectionWith } from '../array/intersectionWith.js';
 export { isSubset } from '../array/isSubset.js';
 export { isSubsetWith } from '../array/isSubsetWith.js';
 export { keyBy } from '../array/keyBy.js';
@@ -85,6 +84,7 @@ export { fill } from './array/fill.js';
 export { filter } from './array/filter.js';
 export { find } from './array/find.js';
 export { findIndex } from './array/findIndex.js';
+export { findLast } from './array/findLast.js';
 export { findLastIndex } from './array/findLastIndex.js';
 export { flatten } from './array/flatten.js';
 export { flattenDeep } from './array/flattenDeep.js';
@@ -95,6 +95,7 @@ export { includes } from './array/includes.js';
 export { indexOf } from './array/indexOf.js';
 export { intersection } from './array/intersection.js';
 export { intersectionBy } from './array/intersectionBy.js';
+export { intersectionWith } from './array/intersectionWith.js';
 export { join } from './array/join.js';
 export { last } from './array/last.js';
 export { lastIndexOf } from './array/lastIndexOf.js';