es-toolkit 1.48.1-dev.1889 → 1.48.1-dev.1894

package/dist/fp/array/xor.d.ts

@@ -0,0 +1,20 @@
+//#region src/fp/array/xor.d.ts
+/**
+ * Creates a function that returns the symmetric difference with secondArray.
+ *
+ * The result contains values that appear in exactly one of the arrays, matching the main
+ * {@link xor} behavior.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param secondArray - Values to compare with the piped array.
+ * @returns A function that maps a readonly array to its symmetric difference.
+ *
+ * @example
+ * import { pipe, xor } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], xor([2, 3]));
+ * // => [1, 3]
+ */
+declare function xor<T>(secondArray: readonly T[]): (array: readonly T[]) => T[];
+//#endregion
+export { xor };

package/dist/fp/array/xor.js

@@ -0,0 +1,25 @@
+const require_xor = require("../../array/xor.js");
+//#region src/fp/array/xor.ts
+/**
+* Creates a function that returns the symmetric difference with secondArray.
+*
+* The result contains values that appear in exactly one of the arrays, matching the main
+* {@link xor} behavior.
+*
+* @template T - The type of elements in the arrays.
+* @param secondArray - Values to compare with the piped array.
+* @returns A function that maps a readonly array to its symmetric difference.
+*
+* @example
+* import { pipe, xor } from 'es-toolkit/fp';
+*
+* pipe([1, 2], xor([2, 3]));
+* // => [1, 3]
+*/
+function xor(secondArray) {
+	return function(array) {
+		return require_xor.xor(array, secondArray);
+	};
+}
+//#endregion
+exports.xor = xor;

package/dist/fp/array/xor.mjs

@@ -0,0 +1,25 @@
+import { xor as xor$1 } from "../../array/xor.mjs";
+//#region src/fp/array/xor.ts
+/**
+* Creates a function that returns the symmetric difference with secondArray.
+*
+* The result contains values that appear in exactly one of the arrays, matching the main
+* {@link xor} behavior.
+*
+* @template T - The type of elements in the arrays.
+* @param secondArray - Values to compare with the piped array.
+* @returns A function that maps a readonly array to its symmetric difference.
+*
+* @example
+* import { pipe, xor } from 'es-toolkit/fp';
+*
+* pipe([1, 2], xor([2, 3]));
+* // => [1, 3]
+*/
+function xor(secondArray) {
+	return function(array) {
+		return xor$1(array, secondArray);
+	};
+}
+//#endregion
+export { xor };

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

@@ -0,0 +1,22 @@
+//#region src/fp/array/xorBy.d.ts
+/**
+ * Creates a function that returns the symmetric difference by mapped identity.
+ *
+ * The mapper is used to decide which values appear in exactly one array, matching the main
+ * {@link xorBy} behavior.
+ *
+ * @template T - The type of elements in the arrays.
+ * @template U - The type of comparison keys returned by the mapper.
+ * @param secondArray - Values to compare with the piped array.
+ * @param mapper - Called for values from both arrays to produce comparison keys.
+ * @returns A function that maps a readonly array to its symmetric difference.
+ *
+ * @example
+ * import { pipe, xorBy } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], xorBy([{ id: 2 }, { id: 3 }], item => item.id));
+ * // => [{ id: 1 }, { id: 3 }]
+ */
+declare function xorBy<T, U>(secondArray: readonly T[], mapper: (item: T) => U): (array: readonly T[]) => T[];
+//#endregion
+export { xorBy };

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

@@ -0,0 +1,22 @@
+//#region src/fp/array/xorBy.d.ts
+/**
+ * Creates a function that returns the symmetric difference by mapped identity.
+ *
+ * The mapper is used to decide which values appear in exactly one array, matching the main
+ * {@link xorBy} behavior.
+ *
+ * @template T - The type of elements in the arrays.
+ * @template U - The type of comparison keys returned by the mapper.
+ * @param secondArray - Values to compare with the piped array.
+ * @param mapper - Called for values from both arrays to produce comparison keys.
+ * @returns A function that maps a readonly array to its symmetric difference.
+ *
+ * @example
+ * import { pipe, xorBy } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], xorBy([{ id: 2 }, { id: 3 }], item => item.id));
+ * // => [{ id: 1 }, { id: 3 }]
+ */
+declare function xorBy<T, U>(secondArray: readonly T[], mapper: (item: T) => U): (array: readonly T[]) => T[];
+//#endregion
+export { xorBy };

package/dist/fp/array/xorBy.js

@@ -0,0 +1,27 @@
+const require_xorBy = require("../../array/xorBy.js");
+//#region src/fp/array/xorBy.ts
+/**
+* Creates a function that returns the symmetric difference by mapped identity.
+*
+* The mapper is used to decide which values appear in exactly one array, matching the main
+* {@link xorBy} behavior.
+*
+* @template T - The type of elements in the arrays.
+* @template U - The type of comparison keys returned by the mapper.
+* @param secondArray - Values to compare with the piped array.
+* @param mapper - Called for values from both arrays to produce comparison keys.
+* @returns A function that maps a readonly array to its symmetric difference.
+*
+* @example
+* import { pipe, xorBy } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], xorBy([{ id: 2 }, { id: 3 }], item => item.id));
+* // => [{ id: 1 }, { id: 3 }]
+*/
+function xorBy(secondArray, mapper) {
+	return function(array) {
+		return require_xorBy.xorBy(array, secondArray, mapper);
+	};
+}
+//#endregion
+exports.xorBy = xorBy;

package/dist/fp/array/xorBy.mjs

@@ -0,0 +1,27 @@
+import { xorBy as xorBy$1 } from "../../array/xorBy.mjs";
+//#region src/fp/array/xorBy.ts
+/**
+* Creates a function that returns the symmetric difference by mapped identity.
+*
+* The mapper is used to decide which values appear in exactly one array, matching the main
+* {@link xorBy} behavior.
+*
+* @template T - The type of elements in the arrays.
+* @template U - The type of comparison keys returned by the mapper.
+* @param secondArray - Values to compare with the piped array.
+* @param mapper - Called for values from both arrays to produce comparison keys.
+* @returns A function that maps a readonly array to its symmetric difference.
+*
+* @example
+* import { pipe, xorBy } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], xorBy([{ id: 2 }, { id: 3 }], item => item.id));
+* // => [{ id: 1 }, { id: 3 }]
+*/
+function xorBy(secondArray, mapper) {
+	return function(array) {
+		return xorBy$1(array, secondArray, mapper);
+	};
+}
+//#endregion
+export { xorBy };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/xorWith.d.ts
+/**
+ * Creates a function that returns the symmetric difference using a custom equality function.
+ *
+ * The equality function decides whether two values represent the same item, matching the
+ * main {@link xorWith} behavior.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param secondArray - Values to compare with the piped array.
+ * @param areItemsEqual - Returns true when two values are equal.
+ * @returns A function that maps a readonly array to its symmetric difference.
+ *
+ * @example
+ * import { pipe, xorWith } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], xorWith([{ id: 2 }, { id: 3 }], (a, b) => a.id === b.id));
+ * // => [{ id: 1 }, { id: 3 }]
+ */
+declare function xorWith<T>(secondArray: readonly T[], areItemsEqual: (item: T, other: T) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { xorWith };

package/dist/fp/array/xorWith.d.ts

@@ -0,0 +1,21 @@
+//#region src/fp/array/xorWith.d.ts
+/**
+ * Creates a function that returns the symmetric difference using a custom equality function.
+ *
+ * The equality function decides whether two values represent the same item, matching the
+ * main {@link xorWith} behavior.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param secondArray - Values to compare with the piped array.
+ * @param areItemsEqual - Returns true when two values are equal.
+ * @returns A function that maps a readonly array to its symmetric difference.
+ *
+ * @example
+ * import { pipe, xorWith } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], xorWith([{ id: 2 }, { id: 3 }], (a, b) => a.id === b.id));
+ * // => [{ id: 1 }, { id: 3 }]
+ */
+declare function xorWith<T>(secondArray: readonly T[], areItemsEqual: (item: T, other: T) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { xorWith };

package/dist/fp/array/xorWith.js

@@ -0,0 +1,26 @@
+const require_xorWith = require("../../array/xorWith.js");
+//#region src/fp/array/xorWith.ts
+/**
+* Creates a function that returns the symmetric difference using a custom equality function.
+*
+* The equality function decides whether two values represent the same item, matching the
+* main {@link xorWith} behavior.
+*
+* @template T - The type of elements in the arrays.
+* @param secondArray - Values to compare with the piped array.
+* @param areItemsEqual - Returns true when two values are equal.
+* @returns A function that maps a readonly array to its symmetric difference.
+*
+* @example
+* import { pipe, xorWith } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], xorWith([{ id: 2 }, { id: 3 }], (a, b) => a.id === b.id));
+* // => [{ id: 1 }, { id: 3 }]
+*/
+function xorWith(secondArray, areItemsEqual) {
+	return function(array) {
+		return require_xorWith.xorWith(array, secondArray, areItemsEqual);
+	};
+}
+//#endregion
+exports.xorWith = xorWith;

package/dist/fp/array/xorWith.mjs

@@ -0,0 +1,26 @@
+import { xorWith as xorWith$1 } from "../../array/xorWith.mjs";
+//#region src/fp/array/xorWith.ts
+/**
+* Creates a function that returns the symmetric difference using a custom equality function.
+*
+* The equality function decides whether two values represent the same item, matching the
+* main {@link xorWith} behavior.
+*
+* @template T - The type of elements in the arrays.
+* @param secondArray - Values to compare with the piped array.
+* @param areItemsEqual - Returns true when two values are equal.
+* @returns A function that maps a readonly array to its symmetric difference.
+*
+* @example
+* import { pipe, xorWith } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], xorWith([{ id: 2 }, { id: 3 }], (a, b) => a.id === b.id));
+* // => [{ id: 1 }, { id: 3 }]
+*/
+function xorWith(secondArray, areItemsEqual) {
+	return function(array) {
+		return xorWith$1(array, secondArray, areItemsEqual);
+	};
+}
+//#endregion
+export { xorWith };

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

@@ -0,0 +1,61 @@
+//#region src/fp/array/zip.d.ts
+/**
+ * Creates a function that wraps each element of the piped array in a one-item tuple.
+ *
+ * @template T - The type of elements in the piped array.
+ * @returns A function that maps the piped array to one-item tuples.
+ *
+ * @example
+ * import { pipe, zip } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], zip());
+ * // => [[1], [2]]
+ */
+declare function zip<T>(): (array: readonly T[]) => Array<[T]>;
+/**
+ * Creates a function that zips the piped array with one configured array.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the configured array.
+ * @param arr2 - The second array to zip.
+ * @returns A function that maps the piped array to two-item tuples.
+ *
+ * @example
+ * pipe([1, 2], zip(['a', 'b']));
+ * // => [[1, 'a'], [2, 'b']]
+ */
+declare function zip<T, U>(arr2: readonly U[]): (array: readonly T[]) => Array<[T, U]>;
+/**
+ * Creates a function that zips the piped array with two configured arrays.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the second array.
+ * @template V - The type of elements in the third array.
+ * @param arr2 - The second array to zip.
+ * @param arr3 - The third array to zip.
+ * @returns A function that maps the piped array to three-item tuples.
+ */
+declare function zip<T, U, V>(arr2: readonly U[], arr3: readonly V[]): (array: readonly T[]) => Array<[T, U, V]>;
+/**
+ * Creates a function that zips the piped array with three configured arrays.
+ *
+ * @template T - The type of elements in the piped 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 arr2 - The second array to zip.
+ * @param arr3 - The third array to zip.
+ * @param arr4 - The fourth array to zip.
+ * @returns A function that maps the piped array to four-item tuples.
+ */
+declare function zip<T, U, V, W>(arr2: readonly U[], arr3: readonly V[], arr4: readonly W[]): (array: readonly T[]) => Array<[T, U, V, W]>;
+/**
+ * Creates a function that zips the piped array with any number of configured arrays.
+ *
+ * @template T - The shared element type of the arrays.
+ * @param arrs - Additional arrays to zip.
+ * @returns A function that maps the piped array to grouped rows.
+ */
+declare function zip<T>(...arrs: Array<readonly T[]>): (array: readonly T[]) => T[][];
+//#endregion
+export { zip };

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

@@ -0,0 +1,61 @@
+//#region src/fp/array/zip.d.ts
+/**
+ * Creates a function that wraps each element of the piped array in a one-item tuple.
+ *
+ * @template T - The type of elements in the piped array.
+ * @returns A function that maps the piped array to one-item tuples.
+ *
+ * @example
+ * import { pipe, zip } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], zip());
+ * // => [[1], [2]]
+ */
+declare function zip<T>(): (array: readonly T[]) => Array<[T]>;
+/**
+ * Creates a function that zips the piped array with one configured array.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the configured array.
+ * @param arr2 - The second array to zip.
+ * @returns A function that maps the piped array to two-item tuples.
+ *
+ * @example
+ * pipe([1, 2], zip(['a', 'b']));
+ * // => [[1, 'a'], [2, 'b']]
+ */
+declare function zip<T, U>(arr2: readonly U[]): (array: readonly T[]) => Array<[T, U]>;
+/**
+ * Creates a function that zips the piped array with two configured arrays.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the second array.
+ * @template V - The type of elements in the third array.
+ * @param arr2 - The second array to zip.
+ * @param arr3 - The third array to zip.
+ * @returns A function that maps the piped array to three-item tuples.
+ */
+declare function zip<T, U, V>(arr2: readonly U[], arr3: readonly V[]): (array: readonly T[]) => Array<[T, U, V]>;
+/**
+ * Creates a function that zips the piped array with three configured arrays.
+ *
+ * @template T - The type of elements in the piped 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 arr2 - The second array to zip.
+ * @param arr3 - The third array to zip.
+ * @param arr4 - The fourth array to zip.
+ * @returns A function that maps the piped array to four-item tuples.
+ */
+declare function zip<T, U, V, W>(arr2: readonly U[], arr3: readonly V[], arr4: readonly W[]): (array: readonly T[]) => Array<[T, U, V, W]>;
+/**
+ * Creates a function that zips the piped array with any number of configured arrays.
+ *
+ * @template T - The shared element type of the arrays.
+ * @param arrs - Additional arrays to zip.
+ * @returns A function that maps the piped array to grouped rows.
+ */
+declare function zip<T>(...arrs: Array<readonly T[]>): (array: readonly T[]) => T[][];
+//#endregion
+export { zip };

package/dist/fp/array/zip.js

@@ -0,0 +1,9 @@
+const require_zip = require("../../array/zip.js");
+//#region src/fp/array/zip.ts
+function zip(...arrs) {
+	return function(array) {
+		return require_zip.zip(array, ...arrs);
+	};
+}
+//#endregion
+exports.zip = zip;

package/dist/fp/array/zip.mjs

@@ -0,0 +1,9 @@
+import { zip as zip$1 } from "../../array/zip.mjs";
+//#region src/fp/array/zip.ts
+function zip(...arrs) {
+	return function(array) {
+		return zip$1(array, ...arrs);
+	};
+}
+//#endregion
+export { zip };

package/dist/fp/array/zipObject.d.mts

@@ -0,0 +1,21 @@
+//#region src/fp/array/zipObject.d.ts
+/**
+ * Creates a function that builds an object from the piped keys and configured values.
+ *
+ * Keys are read from the piped array and paired with values by index, matching the main
+ * {@link zipObject} behavior.
+ *
+ * @template P - The property-key type from the piped keys.
+ * @template V - The type of configured values.
+ * @param values - Values assigned to the piped keys by index.
+ * @returns A function that maps keys to an object.
+ *
+ * @example
+ * import { pipe, zipObject } from 'es-toolkit/fp';
+ *
+ * pipe(['a', 'b'] as const, zipObject([1, 2]));
+ * // => { a: 1, b: 2 }
+ */
+declare function zipObject<P extends PropertyKey, V>(values: readonly V[]): (keys: readonly P[]) => Record<P, V>;
+//#endregion
+export { zipObject };

package/dist/fp/array/zipObject.d.ts

@@ -0,0 +1,21 @@
+//#region src/fp/array/zipObject.d.ts
+/**
+ * Creates a function that builds an object from the piped keys and configured values.
+ *
+ * Keys are read from the piped array and paired with values by index, matching the main
+ * {@link zipObject} behavior.
+ *
+ * @template P - The property-key type from the piped keys.
+ * @template V - The type of configured values.
+ * @param values - Values assigned to the piped keys by index.
+ * @returns A function that maps keys to an object.
+ *
+ * @example
+ * import { pipe, zipObject } from 'es-toolkit/fp';
+ *
+ * pipe(['a', 'b'] as const, zipObject([1, 2]));
+ * // => { a: 1, b: 2 }
+ */
+declare function zipObject<P extends PropertyKey, V>(values: readonly V[]): (keys: readonly P[]) => Record<P, V>;
+//#endregion
+export { zipObject };

package/dist/fp/array/zipObject.js

@@ -0,0 +1,26 @@
+const require_zipObject = require("../../array/zipObject.js");
+//#region src/fp/array/zipObject.ts
+/**
+* Creates a function that builds an object from the piped keys and configured values.
+*
+* Keys are read from the piped array and paired with values by index, matching the main
+* {@link zipObject} behavior.
+*
+* @template P - The property-key type from the piped keys.
+* @template V - The type of configured values.
+* @param values - Values assigned to the piped keys by index.
+* @returns A function that maps keys to an object.
+*
+* @example
+* import { pipe, zipObject } from 'es-toolkit/fp';
+*
+* pipe(['a', 'b'] as const, zipObject([1, 2]));
+* // => { a: 1, b: 2 }
+*/
+function zipObject(values) {
+	return function(keys) {
+		return require_zipObject.zipObject(keys, values);
+	};
+}
+//#endregion
+exports.zipObject = zipObject;

package/dist/fp/array/zipObject.mjs

@@ -0,0 +1,26 @@
+import { zipObject as zipObject$1 } from "../../array/zipObject.mjs";
+//#region src/fp/array/zipObject.ts
+/**
+* Creates a function that builds an object from the piped keys and configured values.
+*
+* Keys are read from the piped array and paired with values by index, matching the main
+* {@link zipObject} behavior.
+*
+* @template P - The property-key type from the piped keys.
+* @template V - The type of configured values.
+* @param values - Values assigned to the piped keys by index.
+* @returns A function that maps keys to an object.
+*
+* @example
+* import { pipe, zipObject } from 'es-toolkit/fp';
+*
+* pipe(['a', 'b'] as const, zipObject([1, 2]));
+* // => { a: 1, b: 2 }
+*/
+function zipObject(values) {
+	return function(keys) {
+		return zipObject$1(keys, values);
+	};
+}
+//#endregion
+export { zipObject };

package/dist/fp/array/zipWith.d.mts

@@ -0,0 +1,57 @@
+//#region src/fp/array/zipWith.d.ts
+/**
+ * Creates a function that maps each value in the piped array with its index.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template R - The type returned by the combiner.
+ * @param combine - Called with each value and index.
+ * @returns A function that maps the piped array to combined values.
+ *
+ * @example
+ * import { pipe, zipWith } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], zipWith((value, index) => value + index));
+ * // => [1, 3]
+ */
+declare function zipWith<T, R>(combine: (item: T, index: number) => R): (array: readonly T[]) => R[];
+/**
+ * Creates a function that zips the piped array with one configured array and combines each group.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the configured array.
+ * @template R - The type returned by the combiner.
+ * @param arr2 - The second array to zip.
+ * @param combine - Called with a value from each array and the index.
+ * @returns A function that maps the piped array to combined values.
+ */
+declare function zipWith<T, U, R>(arr2: readonly U[], combine: (item1: T, item2: U, index: number) => R): (array: readonly T[]) => R[];
+/**
+ * Creates a function that zips the piped array with two configured arrays and combines each group.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the second array.
+ * @template V - The type of elements in the third array.
+ * @template R - The type returned by the combiner.
+ * @param arr2 - The second array to zip.
+ * @param arr3 - The third array to zip.
+ * @param combine - Called with a value from each array and the index.
+ * @returns A function that maps the piped array to combined values.
+ */
+declare function zipWith<T, U, V, R>(arr2: readonly U[], arr3: readonly V[], combine: (item1: T, item2: U, item3: V, index: number) => R): (array: readonly T[]) => R[];
+/**
+ * Creates a function that zips the piped array with three configured arrays and combines each group.
+ *
+ * @template T - The type of elements in the piped 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.
+ * @template R - The type returned by the combiner.
+ * @param arr2 - The second array to zip.
+ * @param arr3 - The third array to zip.
+ * @param arr4 - The fourth array to zip.
+ * @param combine - Called with a value from each array and the index.
+ * @returns A function that maps the piped array to combined values.
+ */
+declare function zipWith<T, U, V, W, R>(arr2: readonly U[], arr3: readonly V[], arr4: readonly W[], combine: (item1: T, item2: U, item3: V, item4: W, index: number) => R): (array: readonly T[]) => R[];
+//#endregion
+export { zipWith };

package/dist/fp/array/zipWith.d.ts

@@ -0,0 +1,57 @@
+//#region src/fp/array/zipWith.d.ts
+/**
+ * Creates a function that maps each value in the piped array with its index.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template R - The type returned by the combiner.
+ * @param combine - Called with each value and index.
+ * @returns A function that maps the piped array to combined values.
+ *
+ * @example
+ * import { pipe, zipWith } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], zipWith((value, index) => value + index));
+ * // => [1, 3]
+ */
+declare function zipWith<T, R>(combine: (item: T, index: number) => R): (array: readonly T[]) => R[];
+/**
+ * Creates a function that zips the piped array with one configured array and combines each group.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the configured array.
+ * @template R - The type returned by the combiner.
+ * @param arr2 - The second array to zip.
+ * @param combine - Called with a value from each array and the index.
+ * @returns A function that maps the piped array to combined values.
+ */
+declare function zipWith<T, U, R>(arr2: readonly U[], combine: (item1: T, item2: U, index: number) => R): (array: readonly T[]) => R[];
+/**
+ * Creates a function that zips the piped array with two configured arrays and combines each group.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the second array.
+ * @template V - The type of elements in the third array.
+ * @template R - The type returned by the combiner.
+ * @param arr2 - The second array to zip.
+ * @param arr3 - The third array to zip.
+ * @param combine - Called with a value from each array and the index.
+ * @returns A function that maps the piped array to combined values.
+ */
+declare function zipWith<T, U, V, R>(arr2: readonly U[], arr3: readonly V[], combine: (item1: T, item2: U, item3: V, index: number) => R): (array: readonly T[]) => R[];
+/**
+ * Creates a function that zips the piped array with three configured arrays and combines each group.
+ *
+ * @template T - The type of elements in the piped 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.
+ * @template R - The type returned by the combiner.
+ * @param arr2 - The second array to zip.
+ * @param arr3 - The third array to zip.
+ * @param arr4 - The fourth array to zip.
+ * @param combine - Called with a value from each array and the index.
+ * @returns A function that maps the piped array to combined values.
+ */
+declare function zipWith<T, U, V, W, R>(arr2: readonly U[], arr3: readonly V[], arr4: readonly W[], combine: (item1: T, item2: U, item3: V, item4: W, index: number) => R): (array: readonly T[]) => R[];
+//#endregion
+export { zipWith };

package/dist/fp/array/zipWith.js

@@ -0,0 +1,9 @@
+const require_zipWith = require("../../array/zipWith.js");
+//#region src/fp/array/zipWith.ts
+function zipWith(...rest) {
+	return function(array) {
+		return require_zipWith.zipWith(array, ...rest);
+	};
+}
+//#endregion
+exports.zipWith = zipWith;

package/dist/fp/array/zipWith.mjs

@@ -0,0 +1,9 @@
+import { zipWith as zipWith$1 } from "../../array/zipWith.mjs";
+//#region src/fp/array/zipWith.ts
+function zipWith(...rest) {
+	return function(array) {
+		return zipWith$1(array, ...rest);
+	};
+}
+//#endregion
+export { zipWith };