es-toolkit 1.37.0 → 1.37.1-dev.1244

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

@@ -0,0 +1,16 @@
+/**
+ * Returns a new array containing all elements except the last one from the input array.
+ * If the input array is empty or has only one element, the function returns an empty array.
+ *
+ * @template T The type of elements in the array.
+ * @param {ArrayLike<T> | null | undefined} arr - The input array.
+ * @returns {T[]} A new array containing all but the last element of the input array.
+ *
+ * @example
+ * const arr = [1, 2, 3, 4];
+ * const result = initial(arr);
+ * // result will be [1, 2, 3]
+ */
+declare function initial<T>(arr: ArrayLike<T> | null | undefined): T[];
+
+export { initial };

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

@@ -0,0 +1,16 @@
+/**
+ * Returns a new array containing all elements except the last one from the input array.
+ * If the input array is empty or has only one element, the function returns an empty array.
+ *
+ * @template T The type of elements in the array.
+ * @param {ArrayLike<T> | null | undefined} arr - The input array.
+ * @returns {T[]} A new array containing all but the last element of the input array.
+ *
+ * @example
+ * const arr = [1, 2, 3, 4];
+ * const result = initial(arr);
+ * // result will be [1, 2, 3]
+ */
+declare function initial<T>(arr: ArrayLike<T> | null | undefined): T[];
+
+export { initial };

package/dist/compat/array/initial.mjs

@@ -0,0 +1,11 @@
+import { initial as initial$1 } from '../../array/initial.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+
+function initial(arr) {
+    if (!isArrayLike(arr)) {
+        return [];
+    }
+    return initial$1(Array.from(arr));
+}
+
+export { initial };

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

@@ -0,0 +1,48 @@
+/**
+ * Maps each element of an array based on a provided key-generating function.
+ *
+ * This function takes an array and a function that generates a key from each element. It returns
+ * an object where the keys are the generated keys and the values are the corresponding elements.
+ * If there are multiple elements generating the same key, the last element among them is used
+ * as the value.
+ *
+ * @param {ArrayLike<T> | null | undefined} collection - The collection to iterate over.
+ * @param {Function | PropertyKey | Array | Object} [iteratee] - The iteratee to transform keys.
+ *   - If a function is provided, it's invoked for each element in the collection.
+ *   - If a property name (string) is provided, that property of each element is used as the key.
+ *   - If a property-value pair (array) is provided, elements with matching property values are used.
+ *   - If a partial object is provided, elements with matching properties are used.
+ *   - If omitted, the identity function is used.
+ * @returns {Object} Returns the composed aggregate object.
+ *
+ * @example
+ * // Using an array of objects
+ * keyBy([{ id: 'a' }, { id: 'b' }], 'id');
+ * // => { a: { id: 'a' }, b: { id: 'b' } }
+ *
+ * @example
+ * // Using a function iteratee
+ * keyBy(['a', 'b', 'c'], val => val.toUpperCase());
+ * // => { A: 'a', B: 'b', C: 'c' }
+ */
+declare function keyBy<T>(collection: ArrayLike<T> | null | undefined, iteratee?: ((value: T) => unknown) | PropertyKey | [keyof T, unknown] | Partial<T> | null): Record<string, T>;
+/**
+ * Maps each value of an object based on a provided key-generating function.
+ *
+ * This function takes an object and a function that generates a key from each value. It returns
+ * an object where the keys are the generated keys and the values are the corresponding values.
+ * If there are multiple values generating the same key, the last value among them is used
+ * as the value.
+ *
+ * @example
+ * // Using an object
+ * keyBy({ a: { id: 1 }, b: { id: 2 } }, 'id');
+ * // => { '1': { id: 1 }, '2': { id: 2 } }
+ *
+ * @param collection - The object to iterate over.
+ * @param iteratee - The function or shorthand to generate the key.
+ * @returns An object composed of keys generated from the iteratee.
+ */
+declare function keyBy<T extends object>(collection: T | null | undefined, iteratee?: ((value: T[keyof T]) => unknown) | PropertyKey | [keyof T[keyof T], unknown] | Partial<T[keyof T]> | null): Record<string, T[keyof T]>;
+
+export { keyBy };

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

@@ -0,0 +1,48 @@
+/**
+ * Maps each element of an array based on a provided key-generating function.
+ *
+ * This function takes an array and a function that generates a key from each element. It returns
+ * an object where the keys are the generated keys and the values are the corresponding elements.
+ * If there are multiple elements generating the same key, the last element among them is used
+ * as the value.
+ *
+ * @param {ArrayLike<T> | null | undefined} collection - The collection to iterate over.
+ * @param {Function | PropertyKey | Array | Object} [iteratee] - The iteratee to transform keys.
+ *   - If a function is provided, it's invoked for each element in the collection.
+ *   - If a property name (string) is provided, that property of each element is used as the key.
+ *   - If a property-value pair (array) is provided, elements with matching property values are used.
+ *   - If a partial object is provided, elements with matching properties are used.
+ *   - If omitted, the identity function is used.
+ * @returns {Object} Returns the composed aggregate object.
+ *
+ * @example
+ * // Using an array of objects
+ * keyBy([{ id: 'a' }, { id: 'b' }], 'id');
+ * // => { a: { id: 'a' }, b: { id: 'b' } }
+ *
+ * @example
+ * // Using a function iteratee
+ * keyBy(['a', 'b', 'c'], val => val.toUpperCase());
+ * // => { A: 'a', B: 'b', C: 'c' }
+ */
+declare function keyBy<T>(collection: ArrayLike<T> | null | undefined, iteratee?: ((value: T) => unknown) | PropertyKey | [keyof T, unknown] | Partial<T> | null): Record<string, T>;
+/**
+ * Maps each value of an object based on a provided key-generating function.
+ *
+ * This function takes an object and a function that generates a key from each value. It returns
+ * an object where the keys are the generated keys and the values are the corresponding values.
+ * If there are multiple values generating the same key, the last value among them is used
+ * as the value.
+ *
+ * @example
+ * // Using an object
+ * keyBy({ a: { id: 1 }, b: { id: 2 } }, 'id');
+ * // => { '1': { id: 1 }, '2': { id: 2 } }
+ *
+ * @param collection - The object to iterate over.
+ * @param iteratee - The function or shorthand to generate the key.
+ * @returns An object composed of keys generated from the iteratee.
+ */
+declare function keyBy<T extends object>(collection: T | null | undefined, iteratee?: ((value: T[keyof T]) => unknown) | PropertyKey | [keyof T[keyof T], unknown] | Partial<T[keyof T]> | null): Record<string, T[keyof T]>;
+
+export { keyBy };

package/dist/compat/array/keyBy.mjs

@@ -0,0 +1,21 @@
+import { reduce } from './reduce.mjs';
+import { identity } from '../../function/identity.mjs';
+import '../../function/partial.mjs';
+import '../../function/partialRight.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+import { isObjectLike } from '../predicate/isObjectLike.mjs';
+import { iteratee } from '../util/iteratee.mjs';
+
+function keyBy(collection, iteratee$1) {
+    if (!isArrayLike(collection) && !isObjectLike(collection)) {
+        return {};
+    }
+    const keyFn = iteratee(iteratee$1 ?? identity);
+    return reduce(collection, (result, value) => {
+        const key = keyFn(value);
+        result[key] = value;
+        return result;
+    }, {});
+}
+
+export { keyBy };

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

@@ -0,0 +1,22 @@
+/**
+ * Randomizes the order of elements in an `array` using the Fisher-Yates algorithm.
+ *
+ * This function takes an `array` and returns a new `array` with its elements shuffled in a random order.
+ *
+ * @template T - The type of elements in the `array`.
+ * @param {T[]} array - The `array` to shuffle.
+ * @returns {T[]} A new `array` with its elements shuffled in random order.
+ */
+declare function shuffle<T>(array: ArrayLike<T> | null | undefined): T[];
+/**
+ * Randomizes the order of elements in an `object` using the Fisher-Yates algorithm.
+ *
+ * This function takes an `object` and returns a new `object` with its values shuffled in a random order.
+ *
+ * @template T - The type of elements in the `object`.
+ * @param {T} object - The `object` to shuffle.
+ * @returns {T[]} A new `Array` with the values of the `object` shuffled in a random order.
+ */
+declare function shuffle<T extends object>(object: T | null | undefined): Array<T[keyof T]>;
+
+export { shuffle };

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

@@ -0,0 +1,22 @@
+/**
+ * Randomizes the order of elements in an `array` using the Fisher-Yates algorithm.
+ *
+ * This function takes an `array` and returns a new `array` with its elements shuffled in a random order.
+ *
+ * @template T - The type of elements in the `array`.
+ * @param {T[]} array - The `array` to shuffle.
+ * @returns {T[]} A new `array` with its elements shuffled in random order.
+ */
+declare function shuffle<T>(array: ArrayLike<T> | null | undefined): T[];
+/**
+ * Randomizes the order of elements in an `object` using the Fisher-Yates algorithm.
+ *
+ * This function takes an `object` and returns a new `object` with its values shuffled in a random order.
+ *
+ * @template T - The type of elements in the `object`.
+ * @param {T} object - The `object` to shuffle.
+ * @returns {T[]} A new `Array` with the values of the `object` shuffled in a random order.
+ */
+declare function shuffle<T extends object>(object: T | null | undefined): Array<T[keyof T]>;
+
+export { shuffle };

package/dist/compat/array/shuffle.mjs

@@ -0,0 +1,24 @@
+import { shuffle as shuffle$1 } from '../../array/shuffle.mjs';
+import { values } from '../object/values.mjs';
+import { isArray } from '../predicate/isArray.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+import { isNil } from '../predicate/isNil.mjs';
+import { isObjectLike } from '../predicate/isObjectLike.mjs';
+
+function shuffle(collection) {
+    if (isNil(collection)) {
+        return [];
+    }
+    if (isArray(collection)) {
+        return shuffle$1(collection);
+    }
+    if (isArrayLike(collection)) {
+        return shuffle$1(Array.from(collection));
+    }
+    if (isObjectLike(collection)) {
+        return shuffle$1(values(collection));
+    }
+    return [];
+}
+
+export { shuffle };

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

@@ -0,0 +1,108 @@
+/**
+ * Creates an array of unique values that is the symmetric difference of the given arrays after applying the iteratee function to each element.
+ *
+ * This function takes multiple arrays and an iteratee function (or property key) to
+ * compare the elements after transforming them. It returns a new array containing elements that are present
+ * in exactly one of the arrays after applying the iteratee to each element.
+ *
+ * @template T1, T2
+ * @param {ArrayLike<T1> | null | undefined} array - The first array to compare.
+ * @param {ArrayLike<T2>} values - The second array to compare.
+ * @param {(value: T1 | T2) => unknown | string} iteratee - The iteratee invoked on each element
+ *  for comparison. It can also be a property key to compare based on that property.
+ * @returns {Array<T1 | T2>} A new array containing elements that are present in exactly one of the arrays
+ *  after applying the iteratee.
+ *
+ * @example
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }, { x: 4 }];
+ * const result = xorBy(array1, array2, 'x');
+ * // result will be [{ x: 1 }, { x: 4 }] since these elements are unique to their respective arrays.
+ *
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }, { x: 4 }];
+ * const result = xorBy(array1, array2, value => value.x);
+ * // result will be [{ x: 1 }, { x: 4 }] since these elements are unique to their respective arrays.
+ */
+declare function xorBy<T1, T2>(array: ArrayLike<T1> | null | undefined, values: ArrayLike<T2>, iteratee: ((value: T1 | T2) => unknown) | string): Array<T1 | T2>;
+/**
+ * Creates an array of unique values that is the symmetric difference of the given arrays after applying the iteratee function to each element.
+ *
+ * This function takes multiple arrays and an iteratee function (or property key) to
+ * compare the elements after transforming them. It returns a new array containing elements that are present
+ * in exactly one of the arrays after applying the iteratee to each element.
+ *
+ * @template T1, T2, T3
+ * @param {ArrayLike<T1> | null | undefined} array - The first array to compare.
+ * @param {ArrayLike<T2>} values1 - The second array to compare.
+ * @param {ArrayLike<T3>} values2 - The third array to compare.
+ * @param {(value: T1 | T2 | T3) => unknown | string} iteratee - The iteratee invoked on each element
+ *  for comparison. It can also be a property key to compare based on that property.
+ * @returns {Array<T1 | T2 | T3>} A new array containing elements that are present in exactly one of the arrays
+ *  after applying the iteratee.
+ *
+ * @example
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }, { x: 4 }];
+ * const result = xorBy(array1, array2, array3, 'x');
+ * // result will be [{ x: 1 }, { x: 4 }] since these elements are unique to their respective arrays.
+ *
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }, { x: 4 }];
+ * const result = xorBy(array1, array2, array3, value => value.x);
+ * // result will be [{ x: 1 }, { x: 4 }] since these elements are unique to their respective arrays.
+ */
+declare function xorBy<T1, T2, T3>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, iteratee: ((value: T1 | T2 | T3) => unknown) | string): Array<T1 | T2 | T3>;
+/**
+ * Creates an array of unique values that is the symmetric difference of the given arrays after applying the iteratee function to each element.
+ *
+ * This function takes multiple arrays and an iteratee function (or property key) to
+ * compare the elements after transforming them. It returns a new array containing elements that are present
+ * in exactly one of the arrays after applying the iteratee to each element.
+ *
+ * @template T1, T2, T3, T4
+ * @param {ArrayLike<T1> | null | undefined} array - The first array to compare.
+ * @param {ArrayLike<T2>} values1 - The second array to compare.
+ * @param {ArrayLike<T3>} values2 - The third array to compare.
+ * @param {...(ArrayLike<T4> | ((value: T1 | T2 | T3 | T4) => unknown) | string)} values - Additional arrays to compare, or the iteratee function.
+ * @returns {Array<T1 | T2 | T3 | T4>} A new array containing elements that are present in exactly one of the arrays
+ *  after applying the iteratee.
+ *
+ * @example
+ * const array1 = [{ x: 1 }, { x: 2 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }, { x: 4 }];
+ * const array4 = [{ x: 4 }, { x: 5 }];
+ * const result = xorBy(array1, array2, array3, array4, 'x');
+ * // result will be [{ x: 1 }, { x: 5 }] since these elements are unique to their respective arrays.
+ *
+ * const array1 = [{ x: 1 }, { x: 2 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }, { x: 4 }];
+ * const array4 = [{ x: 4 }, { x: 5 }];
+ * const result = xorBy(array1, array2, array3, array4, value => value.x);
+ * // result will be [{ x: 1 }, { x: 5 }] since these elements are unique to their respective arrays.
+ */
+declare function xorBy<T1, T2, T3, T4>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, ...values: Array<ArrayLike<T4> | ((value: T1 | T2 | T3 | T4) => unknown) | string>): Array<T1 | T2 | T3 | T4>;
+/**
+ * Computes the symmetric difference between two arrays using a custom mapping function.
+ * The symmetric difference is the set of elements which are in either of the arrays,
+ * but not in their intersection, determined by the result of the mapping function.
+ *
+ * @template T - Type of elements in the input arrays.
+ * @template U - Type of the values returned by the mapping function.
+ *
+ * @param {...(ArrayLike<T> | null | undefined | PropertyKey | Partial<T> | ((value: T) => unknown))} values - The arrays to inspect, or the function to map array elements to comparison values.
+ * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the values returned by the mapping function.
+ *
+ * @example
+ * // Custom mapping function for objects with an 'id' property
+ * const idMapper = obj => obj.id;
+ * xorBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);
+ * // Returns [{ id: 1 }, { id: 3 }]
+ */
+declare function xorBy<T>(...values: Array<ArrayLike<T> | null | undefined | PropertyKey | Partial<T> | ((value: T) => unknown)>): T[];
+
+export { xorBy };

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

@@ -0,0 +1,108 @@
+/**
+ * Creates an array of unique values that is the symmetric difference of the given arrays after applying the iteratee function to each element.
+ *
+ * This function takes multiple arrays and an iteratee function (or property key) to
+ * compare the elements after transforming them. It returns a new array containing elements that are present
+ * in exactly one of the arrays after applying the iteratee to each element.
+ *
+ * @template T1, T2
+ * @param {ArrayLike<T1> | null | undefined} array - The first array to compare.
+ * @param {ArrayLike<T2>} values - The second array to compare.
+ * @param {(value: T1 | T2) => unknown | string} iteratee - The iteratee invoked on each element
+ *  for comparison. It can also be a property key to compare based on that property.
+ * @returns {Array<T1 | T2>} A new array containing elements that are present in exactly one of the arrays
+ *  after applying the iteratee.
+ *
+ * @example
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }, { x: 4 }];
+ * const result = xorBy(array1, array2, 'x');
+ * // result will be [{ x: 1 }, { x: 4 }] since these elements are unique to their respective arrays.
+ *
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }, { x: 4 }];
+ * const result = xorBy(array1, array2, value => value.x);
+ * // result will be [{ x: 1 }, { x: 4 }] since these elements are unique to their respective arrays.
+ */
+declare function xorBy<T1, T2>(array: ArrayLike<T1> | null | undefined, values: ArrayLike<T2>, iteratee: ((value: T1 | T2) => unknown) | string): Array<T1 | T2>;
+/**
+ * Creates an array of unique values that is the symmetric difference of the given arrays after applying the iteratee function to each element.
+ *
+ * This function takes multiple arrays and an iteratee function (or property key) to
+ * compare the elements after transforming them. It returns a new array containing elements that are present
+ * in exactly one of the arrays after applying the iteratee to each element.
+ *
+ * @template T1, T2, T3
+ * @param {ArrayLike<T1> | null | undefined} array - The first array to compare.
+ * @param {ArrayLike<T2>} values1 - The second array to compare.
+ * @param {ArrayLike<T3>} values2 - The third array to compare.
+ * @param {(value: T1 | T2 | T3) => unknown | string} iteratee - The iteratee invoked on each element
+ *  for comparison. It can also be a property key to compare based on that property.
+ * @returns {Array<T1 | T2 | T3>} A new array containing elements that are present in exactly one of the arrays
+ *  after applying the iteratee.
+ *
+ * @example
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }, { x: 4 }];
+ * const result = xorBy(array1, array2, array3, 'x');
+ * // result will be [{ x: 1 }, { x: 4 }] since these elements are unique to their respective arrays.
+ *
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }, { x: 4 }];
+ * const result = xorBy(array1, array2, array3, value => value.x);
+ * // result will be [{ x: 1 }, { x: 4 }] since these elements are unique to their respective arrays.
+ */
+declare function xorBy<T1, T2, T3>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, iteratee: ((value: T1 | T2 | T3) => unknown) | string): Array<T1 | T2 | T3>;
+/**
+ * Creates an array of unique values that is the symmetric difference of the given arrays after applying the iteratee function to each element.
+ *
+ * This function takes multiple arrays and an iteratee function (or property key) to
+ * compare the elements after transforming them. It returns a new array containing elements that are present
+ * in exactly one of the arrays after applying the iteratee to each element.
+ *
+ * @template T1, T2, T3, T4
+ * @param {ArrayLike<T1> | null | undefined} array - The first array to compare.
+ * @param {ArrayLike<T2>} values1 - The second array to compare.
+ * @param {ArrayLike<T3>} values2 - The third array to compare.
+ * @param {...(ArrayLike<T4> | ((value: T1 | T2 | T3 | T4) => unknown) | string)} values - Additional arrays to compare, or the iteratee function.
+ * @returns {Array<T1 | T2 | T3 | T4>} A new array containing elements that are present in exactly one of the arrays
+ *  after applying the iteratee.
+ *
+ * @example
+ * const array1 = [{ x: 1 }, { x: 2 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }, { x: 4 }];
+ * const array4 = [{ x: 4 }, { x: 5 }];
+ * const result = xorBy(array1, array2, array3, array4, 'x');
+ * // result will be [{ x: 1 }, { x: 5 }] since these elements are unique to their respective arrays.
+ *
+ * const array1 = [{ x: 1 }, { x: 2 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }, { x: 4 }];
+ * const array4 = [{ x: 4 }, { x: 5 }];
+ * const result = xorBy(array1, array2, array3, array4, value => value.x);
+ * // result will be [{ x: 1 }, { x: 5 }] since these elements are unique to their respective arrays.
+ */
+declare function xorBy<T1, T2, T3, T4>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, ...values: Array<ArrayLike<T4> | ((value: T1 | T2 | T3 | T4) => unknown) | string>): Array<T1 | T2 | T3 | T4>;
+/**
+ * Computes the symmetric difference between two arrays using a custom mapping function.
+ * The symmetric difference is the set of elements which are in either of the arrays,
+ * but not in their intersection, determined by the result of the mapping function.
+ *
+ * @template T - Type of elements in the input arrays.
+ * @template U - Type of the values returned by the mapping function.
+ *
+ * @param {...(ArrayLike<T> | null | undefined | PropertyKey | Partial<T> | ((value: T) => unknown))} values - The arrays to inspect, or the function to map array elements to comparison values.
+ * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the values returned by the mapping function.
+ *
+ * @example
+ * // Custom mapping function for objects with an 'id' property
+ * const idMapper = obj => obj.id;
+ * xorBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);
+ * // Returns [{ id: 1 }, { id: 3 }]
+ */
+declare function xorBy<T>(...values: Array<ArrayLike<T> | null | undefined | PropertyKey | Partial<T> | ((value: T) => unknown)>): T[];
+
+export { xorBy };

package/dist/compat/array/xorBy.mjs

@@ -0,0 +1,23 @@
+import { differenceBy } from './differenceBy.mjs';
+import { intersectionBy } from './intersectionBy.mjs';
+import { last } from './last.mjs';
+import { unionBy } from './unionBy.mjs';
+import { windowed } from '../../array/windowed.mjs';
+import { identity } from '../../function/identity.mjs';
+import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs';
+import { iteratee } from '../util/iteratee.mjs';
+
+function xorBy(...values) {
+    const lastValue = last(values);
+    let mapper = identity;
+    if (!isArrayLikeObject(lastValue) && lastValue != null) {
+        mapper = iteratee(lastValue);
+        values = values.slice(0, -1);
+    }
+    const arrays = values.filter(isArrayLikeObject);
+    const union = unionBy(...arrays, mapper);
+    const intersections = windowed(arrays, 2).map(([arr1, arr2]) => intersectionBy(arr1, arr2, mapper));
+    return differenceBy(union, unionBy(...intersections, mapper), mapper);
+}
+
+export { xorBy };

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

@@ -0,0 +1,89 @@
+/**
+ * Creates an array of unique values that is the symmetric difference of the given arrays using a custom comparator function.
+ *
+ * This function takes multiple arrays and a comparator function to determine equality between elements.
+ * It returns a new array containing elements that are present in exactly one of the arrays
+ * as determined by the comparator function.
+ *
+ * @template T1, T2
+ * @param {ArrayLike<T1> | null | undefined} array - The first array to compare.
+ * @param {ArrayLike<T2>} values - The second array to compare.
+ * @param {(a: T1 | T2, b: T1 | T2) => boolean} comparator - The comparator invoked per element to determine equality.
+ * @returns {Array<T1 | T2>} A new array containing elements that are present in exactly one of the arrays
+ *  as determined by the comparator.
+ *
+ * @example
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }, { x: 4 }];
+ * const result = xorWith(array1, array2, (a, b) => a.x === b.x);
+ * // result will be [{ x: 1 }, { x: 4 }] since these elements are unique to their respective arrays.
+ */
+declare function xorWith<T1, T2>(array: ArrayLike<T1> | null | undefined, values: ArrayLike<T2>, comparator: (a: T1 | T2, b: T1 | T2) => boolean): Array<T1 | T2>;
+/**
+ * Creates an array of unique values that is the symmetric difference of the given arrays using a custom comparator function.
+ *
+ * This function takes multiple arrays and a comparator function to determine equality between elements.
+ * It returns a new array containing elements that are present in exactly one of the arrays
+ * as determined by the comparator function.
+ *
+ * @template T1, T2, T3
+ * @param {ArrayLike<T1> | null | undefined} array - The first array to compare.
+ * @param {ArrayLike<T2>} values1 - The second array to compare.
+ * @param {ArrayLike<T3>} values2 - The third array to compare.
+ * @param {(a: T1 | T2 | T3, b: T1 | T2 | T3) => boolean} comparator - The comparator invoked per element to determine equality.
+ * @returns {Array<T1 | T2 | T3>} A new array containing elements that are present in exactly one of the arrays
+ *  as determined by the comparator.
+ *
+ * @example
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }, { x: 4 }];
+ * const result = xorWith(array1, array2, array3, (a, b) => a.x === b.x);
+ * // result will be [{ x: 1 }, { x: 4 }] since these elements are unique to their respective arrays.
+ */
+declare function xorWith<T1, T2, T3>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, comparator: (a: T1 | T2 | T3, b: T1 | T2 | T3) => boolean): Array<T1 | T2 | T3>;
+/**
+ * Creates an array of unique values that is the symmetric difference of the given arrays using a custom comparator function.
+ *
+ * This function takes multiple arrays and a comparator function to determine equality between elements.
+ * It returns a new array containing elements that are present in exactly one of the arrays
+ * as determined by the comparator function.
+ *
+ * @template T1, T2, T3, T4
+ * @param {ArrayLike<T1> | null | undefined} array - The first array to compare.
+ * @param {ArrayLike<T2>} values1 - The second array to compare.
+ * @param {ArrayLike<T3>} values2 - The third array to compare.
+ * @param {...(ArrayLike<T4> | ((a: T1 | T2 | T3 | T4, b: T1 | T2 | T3 | T4) => boolean))} values - Additional arrays to compare, or the comparator function.
+ * @returns {Array<T1 | T2 | T3 | T4>} A new array containing elements that are present in exactly one of the arrays
+ *  as determined by the comparator.
+ *
+ * @example
+ * const array1 = [{ x: 1 }, { x: 2 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }, { x: 4 }];
+ * const array4 = [{ x: 4 }, { x: 5 }];
+ * const result = xorWith(array1, array2, array3, array4, (a, b) => a.x === b.x);
+ * // result will be [{ x: 1 }, { x: 5 }] since these elements are unique to their respective arrays.
+ */
+declare function xorWith<T1, T2, T3, T4>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, ...values: Array<ArrayLike<T4> | ((a: T1 | T2 | T3 | T4, b: T1 | T2 | T3 | T4) => boolean)>): Array<T1 | T2 | T3 | T4>;
+/**
+ * Creates an array of unique values that is the symmetric difference of the given arrays using a custom comparator function.
+ *
+ * The symmetric difference is the set of elements which are in either of the arrays,
+ * but not in their intersection, determined by the comparator function.
+ *
+ * @template T - Type of elements in the input arrays.
+ *
+ * @param {...(ArrayLike<T> | null | undefined | ((a: T, b: T) => boolean))} values - The arrays to inspect, or the comparator function.
+ * @returns {T[]} An array containing the elements that are present in exactly one of the arrays
+ *  as determined by the comparator.
+ *
+ * @example
+ * // Custom comparator function for objects with an 'id' property
+ * const idComparator = (a, b) => a.id === b.id;
+ * xorWith([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idComparator);
+ * // Returns [{ id: 1 }, { id: 3 }]
+ */
+declare function xorWith<T>(...values: Array<ArrayLike<T> | null | undefined | ((a: T, b: T) => boolean)>): T[];
+
+export { xorWith };