es-toolkit 1.26.1 → 1.27.0-dev.876

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

@@ -0,0 +1,30 @@
+/**
+ * This function takes multiple arrays and returns a new array containing only the unique values
+ * from all input arrays, preserving the order of their first occurrence.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param {Array<ArrayLike<T> | null | undefined>} arrays - The arrays to inspect.
+ * @returns {T[]} Returns the new array of combined unique values.
+ *
+ * @example
+ * // Returns [2, 1]
+ * union([2], [1, 2]);
+ *
+ * @example
+ * // Returns [2, 1, 3]
+ * union([2], [1, 2], [2, 3]);
+ *
+ * @example
+ * // Returns [1, 3, 2, [5], [4]] (does not deeply flatten nested arrays)
+ * union([1, 3, 2], [1, [5]], [2, [4]]);
+ *
+ * @example
+ * // Returns [0, 2, 1] (ignores non-array values like 3 and { '0': 1 })
+ * union([0], 3, { '0': 1 }, null, [2, 1]);
+ * @example
+ * // Returns [0, 'a', 2, 1] (treats array-like object { 0: 'a', length: 1 } as a valid array)
+ * union([0], { 0: 'a', length: 1 }, [2, 1]);
+ */
+declare function union<T>(...arrays: Array<ArrayLike<T> | null | undefined>): T[];
+
+export { union };

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

@@ -0,0 +1,30 @@
+/**
+ * This function takes multiple arrays and returns a new array containing only the unique values
+ * from all input arrays, preserving the order of their first occurrence.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param {Array<ArrayLike<T> | null | undefined>} arrays - The arrays to inspect.
+ * @returns {T[]} Returns the new array of combined unique values.
+ *
+ * @example
+ * // Returns [2, 1]
+ * union([2], [1, 2]);
+ *
+ * @example
+ * // Returns [2, 1, 3]
+ * union([2], [1, 2], [2, 3]);
+ *
+ * @example
+ * // Returns [1, 3, 2, [5], [4]] (does not deeply flatten nested arrays)
+ * union([1, 3, 2], [1, [5]], [2, [4]]);
+ *
+ * @example
+ * // Returns [0, 2, 1] (ignores non-array values like 3 and { '0': 1 })
+ * union([0], 3, { '0': 1 }, null, [2, 1]);
+ * @example
+ * // Returns [0, 'a', 2, 1] (treats array-like object { 0: 'a', length: 1 } as a valid array)
+ * union([0], { 0: 'a', length: 1 }, [2, 1]);
+ */
+declare function union<T>(...arrays: Array<ArrayLike<T> | null | undefined>): T[];
+
+export { union };

package/dist/compat/array/union.mjs

@@ -0,0 +1,11 @@
+import { flatten } from './flatten.mjs';
+import { uniq } from '../../array/uniq.mjs';
+import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs';
+
+function union(...arrays) {
+    const validArrays = arrays.filter(isArrayLikeObject);
+    const flattened = flatten(validArrays, 1);
+    return uniq(flattened);
+}
+
+export { union };

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

@@ -0,0 +1,60 @@
+/**
+ * Creates a duplicate-free version of an array using a transform function for comparison.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array to inspect.
+ * @param {(value: T) => unknown} iteratee - The transform function.
+ * @returns {T[]} Returns the new duplicate-free array.
+ *
+ * @example
+ * uniqBy([2.1, 1.2, 2.3], Math.floor);
+ * // => [2.1, 1.2]
+ */
+declare function uniqBy<T>(array: ArrayLike<T>, iteratee: (value: T) => unknown): T[];
+/**
+ * Creates a duplicate-free version of an array using a property name for comparison.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array to inspect.
+ * @param {string} path - The property path to get values from.
+ * @returns {T[]} Returns the new duplicate-free array.
+ *
+ * @example
+ * const users = [
+ *   { 'user': 'barney', 'age': 36 },
+ *   { 'user': 'fred',   'age': 40 },
+ *   { 'user': 'barney', 'age': 37 }
+ * ];
+ * uniqBy(users, 'user');
+ * // => [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }]
+ */
+declare function uniqBy<T>(array: ArrayLike<T>, path: string): T[];
+/**
+ * Creates a duplicate-free version of an array using a property index for comparison.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array to inspect.
+ * @param {number} index - The index to get values from.
+ * @returns {T[]} Returns the new duplicate-free array.
+ *
+ * @example
+ * const arrays = [[2], [3], [1], [2], [3], [1]];
+ * uniqBy(arrays, 0);
+ * // => [[2], [3], [1]]
+ */
+declare function uniqBy<T>(array: ArrayLike<T>, index: number): T[];
+/**
+ * Creates a duplicate-free version of an array, combining multiple arrays and using an optional transform function.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array to inspect.
+ * @param {...Array<ArrayLike<T> | ((value: T) => unknown) | string>} values - Additional arrays and/or iteratee.
+ * @returns {T[]} Returns the new duplicate-free array.
+ *
+ * @example
+ * uniqBy([1, 2], [2, 3], [3, 4], Math.floor);
+ * // => [1, 2, 3, 4]
+ */
+declare function uniqBy<T>(array: ArrayLike<T> | null | undefined, ...values: Array<ArrayLike<T> | ((value: T) => unknown) | string>): T[];
+
+export { uniqBy };

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

@@ -0,0 +1,60 @@
+/**
+ * Creates a duplicate-free version of an array using a transform function for comparison.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array to inspect.
+ * @param {(value: T) => unknown} iteratee - The transform function.
+ * @returns {T[]} Returns the new duplicate-free array.
+ *
+ * @example
+ * uniqBy([2.1, 1.2, 2.3], Math.floor);
+ * // => [2.1, 1.2]
+ */
+declare function uniqBy<T>(array: ArrayLike<T>, iteratee: (value: T) => unknown): T[];
+/**
+ * Creates a duplicate-free version of an array using a property name for comparison.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array to inspect.
+ * @param {string} path - The property path to get values from.
+ * @returns {T[]} Returns the new duplicate-free array.
+ *
+ * @example
+ * const users = [
+ *   { 'user': 'barney', 'age': 36 },
+ *   { 'user': 'fred',   'age': 40 },
+ *   { 'user': 'barney', 'age': 37 }
+ * ];
+ * uniqBy(users, 'user');
+ * // => [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }]
+ */
+declare function uniqBy<T>(array: ArrayLike<T>, path: string): T[];
+/**
+ * Creates a duplicate-free version of an array using a property index for comparison.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array to inspect.
+ * @param {number} index - The index to get values from.
+ * @returns {T[]} Returns the new duplicate-free array.
+ *
+ * @example
+ * const arrays = [[2], [3], [1], [2], [3], [1]];
+ * uniqBy(arrays, 0);
+ * // => [[2], [3], [1]]
+ */
+declare function uniqBy<T>(array: ArrayLike<T>, index: number): T[];
+/**
+ * Creates a duplicate-free version of an array, combining multiple arrays and using an optional transform function.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array to inspect.
+ * @param {...Array<ArrayLike<T> | ((value: T) => unknown) | string>} values - Additional arrays and/or iteratee.
+ * @returns {T[]} Returns the new duplicate-free array.
+ *
+ * @example
+ * uniqBy([1, 2], [2, 3], [3, 4], Math.floor);
+ * // => [1, 2, 3, 4]
+ */
+declare function uniqBy<T>(array: ArrayLike<T> | null | undefined, ...values: Array<ArrayLike<T> | ((value: T) => unknown) | string>): T[];
+
+export { uniqBy };

package/dist/compat/array/uniqBy.mjs

@@ -0,0 +1,25 @@
+import { flatten } from './flatten.mjs';
+import { last } from './last.mjs';
+import { uniq } from '../../array/uniq.mjs';
+import { uniqBy as uniqBy$1 } from '../../array/uniqBy.mjs';
+import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs';
+import { iteratee } from '../util/iteratee.mjs';
+
+function uniqBy(arr, ...values) {
+    if (!isArrayLikeObject(arr)) {
+        return [];
+    }
+    const iteratee$1 = last(values);
+    if (iteratee$1 === undefined) {
+        return Array.from(arr);
+    }
+    const validArrays = values.slice(0, -1).filter(isArrayLikeObject);
+    const flattenedArrays = flatten(validArrays);
+    const allValues = [...Array.from(arr), ...flattenedArrays];
+    if (isArrayLikeObject(iteratee$1)) {
+        return uniq(allValues);
+    }
+    return uniqBy$1(allValues, iteratee(iteratee$1));
+}
+
+export { uniqBy };

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

@@ -0,0 +1,16 @@
+/**
+ * Gathers elements in the same position in an internal array
+ * from a grouped array of elements and returns them as a new array.
+ *
+ * @template T - The type of elements in the nested array.
+ * @param {T[][] | ArrayLike<ArrayLike<T>> | null | undefined} array - The nested array to unzip.
+ * @returns {T[][]} A new array of unzipped elements.
+ *
+ * @example
+ * const zipped = [['a', true, 1],['b', false, 2]];
+ * const result = unzip(zipped);
+ * // result will be [['a', 'b'], [true, false], [1, 2]]
+ */
+declare function unzip<T>(array: T[][] | ArrayLike<ArrayLike<T>> | null | undefined): T[][];
+
+export { unzip };

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

@@ -0,0 +1,16 @@
+/**
+ * Gathers elements in the same position in an internal array
+ * from a grouped array of elements and returns them as a new array.
+ *
+ * @template T - The type of elements in the nested array.
+ * @param {T[][] | ArrayLike<ArrayLike<T>> | null | undefined} array - The nested array to unzip.
+ * @returns {T[][]} A new array of unzipped elements.
+ *
+ * @example
+ * const zipped = [['a', true, 1],['b', false, 2]];
+ * const result = unzip(zipped);
+ * // result will be [['a', 'b'], [true, false], [1, 2]]
+ */
+declare function unzip<T>(array: T[][] | ArrayLike<ArrayLike<T>> | null | undefined): T[][];
+
+export { unzip };

package/dist/compat/array/unzip.mjs

@@ -0,0 +1,14 @@
+import { unzip as unzip$1 } from '../../array/unzip.mjs';
+import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs';
+
+function unzip(array) {
+    if (!isArrayLikeObject(array) || !array.length) {
+        return [];
+    }
+    if (Array.isArray(array)) {
+        return unzip$1(array);
+    }
+    return unzip$1(Array.from(array, value => Array.from(value)));
+}
+
+export { unzip };

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

@@ -0,0 +1,134 @@
+/**
+ * Combines multiple arrays into a single array of tuples.
+ *
+ * This function takes multiple arrays and returns a new array where each element is a tuple
+ * containing the corresponding elements from the input arrays. If the input arrays are of
+ * different lengths, the resulting array will have the length of the longest input array,
+ * with undefined values for missing elements.
+ *
+ * @template T
+ * @param {ArrayLike<T>} arr1 - The first array to zip.
+ * @returns {Array<[T | undefined]>} A new array of tuples containing the corresponding elements from the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const result = zip(arr1);
+ * // result will be [[1], [2], [3]]
+ */
+declare function zip<T>(arr1: ArrayLike<T>): Array<[T | undefined]>;
+/**
+ * Combines multiple arrays into a single array of tuples.
+ *
+ * This function takes multiple arrays and returns a new array where each element is a tuple
+ * containing the corresponding elements from the input arrays. If the input arrays are of
+ * different lengths, the resulting array will have the length of the longest input array,
+ * with undefined values for missing elements.
+ *
+ * @template T, U
+ * @param {ArrayLike<T>} arr1 - The first array to zip.
+ * @param {ArrayLike<U>} arr2 - The second array to zip.
+ * @returns {Array<[T | undefined, U | undefined]>} A new array of tuples containing the corresponding elements from the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const arr2 = ['a', 'b', 'c'];
+ * const result = zip(arr1, arr2);
+ * // result will be [[1, 'a'], [2, 'b'], [3, 'c']]
+ */
+declare function zip<T, U>(arr1: ArrayLike<T>, arr2: ArrayLike<U>): Array<[T | undefined, U | undefined]>;
+/**
+ * Combines multiple arrays into a single array of tuples.
+ *
+ * This function takes multiple arrays and returns a new array where each element is a tuple
+ * containing the corresponding elements from the input arrays. If the input arrays are of
+ * different lengths, the resulting array will have the length of the longest input array,
+ * with undefined values for missing elements.
+ *
+ * @template T, U, V
+ * @param {ArrayLike<T>} arr1 - The first array to zip.
+ * @param {ArrayLike<U>} arr2 - The second array to zip.
+ * @param {ArrayLike<V>} arr3 - The third array to zip.
+ * @returns {Array<[T | undefined, U | undefined, V | undefined]>} A new array of tuples containing the corresponding elements from the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const arr2 = ['a', 'b', 'c'];
+ * const arr3 = [true, false];
+ * const result = zip(arr1, arr2, arr3);
+ * // result will be [[1, 'a', true], [2, 'b', false], [3, 'c', undefined]]
+ */
+declare function zip<T, U, V>(arr1: ArrayLike<T>, arr2: ArrayLike<U>, arr3: ArrayLike<V>): Array<[T | undefined, U | undefined, V | undefined]>;
+/**
+ * Combines multiple arrays into a single array of tuples.
+ *
+ * This function takes multiple arrays and returns a new array where each element is a tuple
+ * containing the corresponding elements from the input arrays. If the input arrays are of
+ * different lengths, the resulting array will have the length of the longest input array,
+ * with undefined values for missing elements.
+ *
+ * @template T, U, V, W
+ * @param {ArrayLike<T>} arr1 - The first array to zip.
+ * @param {ArrayLike<U>} arr2 - The second array to zip.
+ * @param {ArrayLike<V>} arr3 - The third array to zip.
+ * @param {ArrayLike<W>} arr4 - The fourth array to zip.
+ * @returns {Array<[T | undefined, U | undefined, V | undefined, W | undefined]>} A new array of tuples containing the corresponding elements from the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const arr2 = ['a', 'b', 'c'];
+ * const arr3 = [true, false];
+ * const arr4 = [null, null, null];
+ * const result = zip(arr1, arr2, arr3, arr4);
+ * // result will be [[1, 'a', true, null], [2, 'b', false, null], [3, 'c', undefined, null]]
+ */
+declare function zip<T, U, V, W>(arr1: ArrayLike<T>, arr2: ArrayLike<U>, arr3: ArrayLike<V>, arr4: ArrayLike<W>): Array<[T | undefined, U | undefined, V | undefined, W | undefined]>;
+/**
+ * Combines multiple arrays into a single array of tuples.
+ *
+ * This function takes multiple arrays and returns a new array where each element is a tuple
+ * containing the corresponding elements from the input arrays. If the input arrays are of
+ * different lengths, the resulting array will have the length of the longest input array,
+ * with undefined values for missing elements.
+ *
+ * @template T, U, V, W
+ * @param {ArrayLike<T>} arr1 - The first array to zip.
+ * @param {ArrayLike<U>} arr2 - The second array to zip.
+ * @param {ArrayLike<V>} arr3 - The third array to zip.
+ * @param {ArrayLike<W>} arr4 - The fourth array to zip.
+ * @param {ArrayLike<X>} arr5 - The fifth array to zip.
+ * @returns {Array<[T | undefined, U | undefined, V | undefined, W | undefined, X | undefined]>} A new array of tuples containing the corresponding elements from the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const arr2 = ['a', 'b', 'c'];
+ * const arr3 = [true, false];
+ * const arr4 = [null, null, null];
+ * const arr5 = [undefined, undefined, undefined];
+ * const result = zip(arr1, arr2, arr3, arr4, arr5);
+ * // result will be [[1, 'a', true, null, undefined], [2, 'b', false, null, undefined], [3, 'c', undefined, null, undefined]]
+ */
+declare function zip<T, U, V, W, X>(arr1: ArrayLike<T>, arr2: ArrayLike<U>, arr3: ArrayLike<V>, arr4: ArrayLike<W>, arr5: ArrayLike<X>): Array<[T | undefined, U | undefined, V | undefined, W | undefined, X | undefined]>;
+/**
+ * Combines multiple arrays into a single array of tuples.
+ *
+ * This function takes multiple arrays and returns a new array where each element is a tuple
+ * containing the corresponding elements from the input arrays. If the input arrays are of
+ * different lengths, the resulting array will have the length of the longest input array,
+ * with undefined values for missing elements.
+ *
+ * @template T
+ * @param {Array<ArrayLike<any> | null | undefined>} arrays - The arrays to zip.
+ * @returns {Array<Array<T | undefined>>} A new array of tuples containing the corresponding elements from the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const arr2 = ['a', 'b', 'c'];
+ * const arr3 = [true, false];
+ * const arr4 = [null, null, null];
+ * const arr5 = [undefined, undefined, undefined];
+ * const result = zip(arr1, arr2, arr3, arr4, arr5);
+ * // result will be [[1, 'a', true, null, undefined], [2, 'b', false, null, undefined], [3, 'c', undefined, null, undefined]]
+ */
+declare function zip<T>(...arrays: Array<ArrayLike<any> | null | undefined>): Array<Array<T | undefined>>;
+
+export { zip };

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

@@ -0,0 +1,134 @@
+/**
+ * Combines multiple arrays into a single array of tuples.
+ *
+ * This function takes multiple arrays and returns a new array where each element is a tuple
+ * containing the corresponding elements from the input arrays. If the input arrays are of
+ * different lengths, the resulting array will have the length of the longest input array,
+ * with undefined values for missing elements.
+ *
+ * @template T
+ * @param {ArrayLike<T>} arr1 - The first array to zip.
+ * @returns {Array<[T | undefined]>} A new array of tuples containing the corresponding elements from the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const result = zip(arr1);
+ * // result will be [[1], [2], [3]]
+ */
+declare function zip<T>(arr1: ArrayLike<T>): Array<[T | undefined]>;
+/**
+ * Combines multiple arrays into a single array of tuples.
+ *
+ * This function takes multiple arrays and returns a new array where each element is a tuple
+ * containing the corresponding elements from the input arrays. If the input arrays are of
+ * different lengths, the resulting array will have the length of the longest input array,
+ * with undefined values for missing elements.
+ *
+ * @template T, U
+ * @param {ArrayLike<T>} arr1 - The first array to zip.
+ * @param {ArrayLike<U>} arr2 - The second array to zip.
+ * @returns {Array<[T | undefined, U | undefined]>} A new array of tuples containing the corresponding elements from the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const arr2 = ['a', 'b', 'c'];
+ * const result = zip(arr1, arr2);
+ * // result will be [[1, 'a'], [2, 'b'], [3, 'c']]
+ */
+declare function zip<T, U>(arr1: ArrayLike<T>, arr2: ArrayLike<U>): Array<[T | undefined, U | undefined]>;
+/**
+ * Combines multiple arrays into a single array of tuples.
+ *
+ * This function takes multiple arrays and returns a new array where each element is a tuple
+ * containing the corresponding elements from the input arrays. If the input arrays are of
+ * different lengths, the resulting array will have the length of the longest input array,
+ * with undefined values for missing elements.
+ *
+ * @template T, U, V
+ * @param {ArrayLike<T>} arr1 - The first array to zip.
+ * @param {ArrayLike<U>} arr2 - The second array to zip.
+ * @param {ArrayLike<V>} arr3 - The third array to zip.
+ * @returns {Array<[T | undefined, U | undefined, V | undefined]>} A new array of tuples containing the corresponding elements from the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const arr2 = ['a', 'b', 'c'];
+ * const arr3 = [true, false];
+ * const result = zip(arr1, arr2, arr3);
+ * // result will be [[1, 'a', true], [2, 'b', false], [3, 'c', undefined]]
+ */
+declare function zip<T, U, V>(arr1: ArrayLike<T>, arr2: ArrayLike<U>, arr3: ArrayLike<V>): Array<[T | undefined, U | undefined, V | undefined]>;
+/**
+ * Combines multiple arrays into a single array of tuples.
+ *
+ * This function takes multiple arrays and returns a new array where each element is a tuple
+ * containing the corresponding elements from the input arrays. If the input arrays are of
+ * different lengths, the resulting array will have the length of the longest input array,
+ * with undefined values for missing elements.
+ *
+ * @template T, U, V, W
+ * @param {ArrayLike<T>} arr1 - The first array to zip.
+ * @param {ArrayLike<U>} arr2 - The second array to zip.
+ * @param {ArrayLike<V>} arr3 - The third array to zip.
+ * @param {ArrayLike<W>} arr4 - The fourth array to zip.
+ * @returns {Array<[T | undefined, U | undefined, V | undefined, W | undefined]>} A new array of tuples containing the corresponding elements from the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const arr2 = ['a', 'b', 'c'];
+ * const arr3 = [true, false];
+ * const arr4 = [null, null, null];
+ * const result = zip(arr1, arr2, arr3, arr4);
+ * // result will be [[1, 'a', true, null], [2, 'b', false, null], [3, 'c', undefined, null]]
+ */
+declare function zip<T, U, V, W>(arr1: ArrayLike<T>, arr2: ArrayLike<U>, arr3: ArrayLike<V>, arr4: ArrayLike<W>): Array<[T | undefined, U | undefined, V | undefined, W | undefined]>;
+/**
+ * Combines multiple arrays into a single array of tuples.
+ *
+ * This function takes multiple arrays and returns a new array where each element is a tuple
+ * containing the corresponding elements from the input arrays. If the input arrays are of
+ * different lengths, the resulting array will have the length of the longest input array,
+ * with undefined values for missing elements.
+ *
+ * @template T, U, V, W
+ * @param {ArrayLike<T>} arr1 - The first array to zip.
+ * @param {ArrayLike<U>} arr2 - The second array to zip.
+ * @param {ArrayLike<V>} arr3 - The third array to zip.
+ * @param {ArrayLike<W>} arr4 - The fourth array to zip.
+ * @param {ArrayLike<X>} arr5 - The fifth array to zip.
+ * @returns {Array<[T | undefined, U | undefined, V | undefined, W | undefined, X | undefined]>} A new array of tuples containing the corresponding elements from the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const arr2 = ['a', 'b', 'c'];
+ * const arr3 = [true, false];
+ * const arr4 = [null, null, null];
+ * const arr5 = [undefined, undefined, undefined];
+ * const result = zip(arr1, arr2, arr3, arr4, arr5);
+ * // result will be [[1, 'a', true, null, undefined], [2, 'b', false, null, undefined], [3, 'c', undefined, null, undefined]]
+ */
+declare function zip<T, U, V, W, X>(arr1: ArrayLike<T>, arr2: ArrayLike<U>, arr3: ArrayLike<V>, arr4: ArrayLike<W>, arr5: ArrayLike<X>): Array<[T | undefined, U | undefined, V | undefined, W | undefined, X | undefined]>;
+/**
+ * Combines multiple arrays into a single array of tuples.
+ *
+ * This function takes multiple arrays and returns a new array where each element is a tuple
+ * containing the corresponding elements from the input arrays. If the input arrays are of
+ * different lengths, the resulting array will have the length of the longest input array,
+ * with undefined values for missing elements.
+ *
+ * @template T
+ * @param {Array<ArrayLike<any> | null | undefined>} arrays - The arrays to zip.
+ * @returns {Array<Array<T | undefined>>} A new array of tuples containing the corresponding elements from the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const arr2 = ['a', 'b', 'c'];
+ * const arr3 = [true, false];
+ * const arr4 = [null, null, null];
+ * const arr5 = [undefined, undefined, undefined];
+ * const result = zip(arr1, arr2, arr3, arr4, arr5);
+ * // result will be [[1, 'a', true, null, undefined], [2, 'b', false, null, undefined], [3, 'c', undefined, null, undefined]]
+ */
+declare function zip<T>(...arrays: Array<ArrayLike<any> | null | undefined>): Array<Array<T | undefined>>;
+
+export { zip };

package/dist/compat/array/zip.mjs

@@ -0,0 +1,11 @@
+import { zip as zip$1 } from '../../array/zip.mjs';
+import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs';
+
+function zip(...arrays) {
+    if (!arrays.length) {
+        return [];
+    }
+    return zip$1(...arrays.filter(group => isArrayLikeObject(group)));
+}
+
+export { zip };