es-toolkit 1.26.1-dev.847 → 1.26.1-dev.850

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 };

package/dist/compat/index.d.mts

@@ -27,7 +27,6 @@ export { unzipWith } from '../array/unzipWith.mjs';
 export { xor } from '../array/xor.mjs';
 export { xorBy } from '../array/xorBy.mjs';
 export { xorWith } from '../array/xorWith.mjs';
-export { zip } from '../array/zip.mjs';
 export { zipObject } from '../array/zipObject.mjs';
 export { zipWith } from '../array/zipWith.mjs';
 export { AbortError } from '../error/AbortError.mjs';
@@ -116,6 +115,7 @@ export { takeRight } from './array/takeRight.mjs';
 export { uniq } from './array/uniq.mjs';
 export { unzip } from './array/unzip.mjs';
 export { without } from './array/without.mjs';
+export { zip } from './array/zip.mjs';
 export { zipObjectDeep } from './array/zipObjectDeep.mjs';
 export { ary } from './function/ary.mjs';
 export { attempt } from './function/attempt.mjs';

package/dist/compat/index.d.ts

@@ -27,7 +27,6 @@ export { unzipWith } from '../array/unzipWith.js';
 export { xor } from '../array/xor.js';
 export { xorBy } from '../array/xorBy.js';
 export { xorWith } from '../array/xorWith.js';
-export { zip } from '../array/zip.js';
 export { zipObject } from '../array/zipObject.js';
 export { zipWith } from '../array/zipWith.js';
 export { AbortError } from '../error/AbortError.js';
@@ -116,6 +115,7 @@ export { takeRight } from './array/takeRight.js';
 export { uniq } from './array/uniq.js';
 export { unzip } from './array/unzip.js';
 export { without } from './array/without.js';
+export { zip } from './array/zip.js';
 export { zipObjectDeep } from './array/zipObjectDeep.js';
 export { ary } from './function/ary.js';
 export { attempt } from './function/attempt.js';

package/dist/compat/index.js

@@ -2,11 +2,11 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const zipWith = require('../_chunk/zipWith-Dkv3D1.js');
+const zipWith = require('../_chunk/zipWith-Dx_q4f.js');
 const promise_index = require('../_chunk/index-BGZDR9.js');
 const unary = require('../_chunk/unary-CcTNuC.js');
 const noop = require('../_chunk/noop-2IwLUk.js');
-const sumBy = require('../_chunk/sumBy-CRE6-A.js');
+const sumBy = require('../_chunk/sumBy-wtGD37.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
 const toMerged = require('../_chunk/toMerged-wNz52b.js');
 const isPlainObject$1 = require('../_chunk/isPlainObject-octpoD.js');
@@ -1174,6 +1174,13 @@ function without(array, ...values) {
     return zipWith.without(Array.from(array), ...values);
 }
 
+function zip(...arrays) {
+    if (!arrays.length) {
+        return [];
+    }
+    return zipWith.zip(...arrays.filter(group => isArrayLikeObject(group)));
+}
+
 function set(obj, path, value) {
     const resolvedPath = Array.isArray(path) ? path : typeof path === 'string' ? toPath(path) : [path];
     let current = obj;
@@ -2475,7 +2482,6 @@ exports.unzipWith = zipWith.unzipWith;
 exports.xor = zipWith.xor;
 exports.xorBy = zipWith.xorBy;
 exports.xorWith = zipWith.xorWith;
-exports.zip = zipWith.zip;
 exports.zipObject = zipWith.zipObject;
 exports.zipWith = zipWith.zipWith;
 exports.AbortError = promise_index.AbortError;
@@ -2672,4 +2678,5 @@ exports.unset = unset;
 exports.unzip = unzip;
 exports.upperCase = upperCase;
 exports.without = without;
+exports.zip = zip;
 exports.zipObjectDeep = zipObjectDeep;

package/dist/compat/index.mjs

@@ -27,7 +27,6 @@ export { unzipWith } from '../array/unzipWith.mjs';
 export { xor } from '../array/xor.mjs';
 export { xorBy } from '../array/xorBy.mjs';
 export { xorWith } from '../array/xorWith.mjs';
-export { zip } from '../array/zip.mjs';
 export { zipObject } from '../array/zipObject.mjs';
 export { zipWith } from '../array/zipWith.mjs';
 export { AbortError } from '../error/AbortError.mjs';
@@ -118,6 +117,7 @@ export { takeRight } from './array/takeRight.mjs';
 export { uniq } from './array/uniq.mjs';
 export { unzip } from './array/unzip.mjs';
 export { without } from './array/without.mjs';
+export { zip } from './array/zip.mjs';
 export { zipObjectDeep } from './array/zipObjectDeep.mjs';
 export { ary } from './function/ary.mjs';
 export { attempt } from './function/attempt.mjs';

package/dist/index.js

@@ -2,13 +2,13 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const zipWith = require('./_chunk/zipWith-Dkv3D1.js');
+const zipWith = require('./_chunk/zipWith-Dx_q4f.js');
 const array_index = require('./array/index.js');
 const promise_index = require('./_chunk/index-BGZDR9.js');
 const unary = require('./_chunk/unary-CcTNuC.js');
 const function_index = require('./function/index.js');
 const noop = require('./_chunk/noop-2IwLUk.js');
-const sumBy = require('./_chunk/sumBy-CRE6-A.js');
+const sumBy = require('./_chunk/sumBy-wtGD37.js');
 const randomInt = require('./_chunk/randomInt-CF7bZK.js');
 const math_index = require('./math/index.js');
 const toMerged = require('./_chunk/toMerged-wNz52b.js');

package/dist/math/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const sumBy = require('../_chunk/sumBy-CRE6-A.js');
+const sumBy = require('../_chunk/sumBy-wtGD37.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
 
 function round(value, precision = 0) {

package/dist/math/range.mjs

@@ -1,11 +1,8 @@
-function range(start, end, step) {
+function range(start, end, step = 1) {
     if (end == null) {
         end = start;
         start = 0;
     }
-    if (step == null) {
-        step = 1;
-    }
     if (!Number.isInteger(step) || step === 0) {
         throw new Error(`The step value must be a non-zero integer.`);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "es-toolkit",
   "description": "A state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.",
-  "version": "1.26.1-dev.847+5b9e9656",
+  "version": "1.26.1-dev.850+7dbf58a9",
   "homepage": "https://es-toolkit.slash.page",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {