es-toolkit 1.48.1 → 1.49.0

package/dist/fp/array/union.js

@@ -0,0 +1,25 @@
+const require_union = require("../../array/union.js");
+//#region src/fp/array/union.ts
+/**
+* Creates a function that returns unique values from the piped array and secondArray.
+*
+* Values keep their first occurrence order, matching the main {@link union} behavior.
+* Use the returned function with {@link pipe}.
+*
+* @template T - The type of elements in the arrays.
+* @param secondArray - Values to include after the piped array.
+* @returns A function that maps a readonly array to its union with secondArray.
+*
+* @example
+* import { pipe, union } from 'es-toolkit/fp';
+*
+* pipe([1, 2], union([2, 3]));
+* // => [1, 2, 3]
+*/
+function union(secondArray) {
+	return function(array) {
+		return require_union.union(array, secondArray);
+	};
+}
+//#endregion
+exports.union = union;

package/dist/fp/array/union.mjs

@@ -0,0 +1,25 @@
+import { union as union$1 } from "../../array/union.mjs";
+//#region src/fp/array/union.ts
+/**
+* Creates a function that returns unique values from the piped array and secondArray.
+*
+* Values keep their first occurrence order, matching the main {@link union} behavior.
+* Use the returned function with {@link pipe}.
+*
+* @template T - The type of elements in the arrays.
+* @param secondArray - Values to include after the piped array.
+* @returns A function that maps a readonly array to its union with secondArray.
+*
+* @example
+* import { pipe, union } from 'es-toolkit/fp';
+*
+* pipe([1, 2], union([2, 3]));
+* // => [1, 2, 3]
+*/
+function union(secondArray) {
+	return function(array) {
+		return union$1(array, secondArray);
+	};
+}
+//#endregion
+export { union };

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

@@ -0,0 +1,22 @@
+//#region src/fp/array/unionBy.d.ts
+/**
+ * Creates a function that returns unique values by mapped identity.
+ *
+ * Values from the piped array are considered before values from secondArray. The mapper
+ * is used to compare identities, matching the main {@link unionBy} 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 include after 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 union with secondArray.
+ *
+ * @example
+ * import { pipe, unionBy } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }], unionBy([{ id: 1 }, { id: 2 }], item => item.id));
+ * // => [{ id: 1 }, { id: 2 }]
+ */
+declare function unionBy<T, U>(secondArray: readonly T[], mapper: (item: T) => U): (array: readonly T[]) => T[];
+//#endregion
+export { unionBy };

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

@@ -0,0 +1,22 @@
+//#region src/fp/array/unionBy.d.ts
+/**
+ * Creates a function that returns unique values by mapped identity.
+ *
+ * Values from the piped array are considered before values from secondArray. The mapper
+ * is used to compare identities, matching the main {@link unionBy} 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 include after 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 union with secondArray.
+ *
+ * @example
+ * import { pipe, unionBy } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }], unionBy([{ id: 1 }, { id: 2 }], item => item.id));
+ * // => [{ id: 1 }, { id: 2 }]
+ */
+declare function unionBy<T, U>(secondArray: readonly T[], mapper: (item: T) => U): (array: readonly T[]) => T[];
+//#endregion
+export { unionBy };

package/dist/fp/array/unionBy.js

@@ -0,0 +1,27 @@
+const require_unionBy = require("../../array/unionBy.js");
+//#region src/fp/array/unionBy.ts
+/**
+* Creates a function that returns unique values by mapped identity.
+*
+* Values from the piped array are considered before values from secondArray. The mapper
+* is used to compare identities, matching the main {@link unionBy} 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 include after 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 union with secondArray.
+*
+* @example
+* import { pipe, unionBy } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }], unionBy([{ id: 1 }, { id: 2 }], item => item.id));
+* // => [{ id: 1 }, { id: 2 }]
+*/
+function unionBy(secondArray, mapper) {
+	return function(array) {
+		return require_unionBy.unionBy(array, secondArray, mapper);
+	};
+}
+//#endregion
+exports.unionBy = unionBy;

package/dist/fp/array/unionBy.mjs

@@ -0,0 +1,27 @@
+import { unionBy as unionBy$1 } from "../../array/unionBy.mjs";
+//#region src/fp/array/unionBy.ts
+/**
+* Creates a function that returns unique values by mapped identity.
+*
+* Values from the piped array are considered before values from secondArray. The mapper
+* is used to compare identities, matching the main {@link unionBy} 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 include after 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 union with secondArray.
+*
+* @example
+* import { pipe, unionBy } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }], unionBy([{ id: 1 }, { id: 2 }], item => item.id));
+* // => [{ id: 1 }, { id: 2 }]
+*/
+function unionBy(secondArray, mapper) {
+	return function(array) {
+		return unionBy$1(array, secondArray, mapper);
+	};
+}
+//#endregion
+export { unionBy };

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

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

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

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

package/dist/fp/array/unionWith.js

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

package/dist/fp/array/unionWith.mjs

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

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/uniq.d.ts
+/**
+ * Creates a function that removes duplicate values from an array, preserving
+ * the order of first occurrence. Equality follows SameValueZero, matching
+ * Set semantics. Use it with {@link pipe}.
+ *
+ * The returned function is lazy-capable inside {@link pipe}. It keeps a Set of
+ * values already emitted during each pipeline run.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to a duplicate-free array.
+ *
+ * @example
+ * import { pipe, uniq } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 2, 3, 3, 3], uniq());
+ * // => [1, 2, 3]
+ */
+declare function uniq<T>(): (array: readonly T[]) => T[];
+//#endregion
+export { uniq };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/uniq.d.ts
+/**
+ * Creates a function that removes duplicate values from an array, preserving
+ * the order of first occurrence. Equality follows SameValueZero, matching
+ * Set semantics. Use it with {@link pipe}.
+ *
+ * The returned function is lazy-capable inside {@link pipe}. It keeps a Set of
+ * values already emitted during each pipeline run.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to a duplicate-free array.
+ *
+ * @example
+ * import { pipe, uniq } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 2, 3, 3, 3], uniq());
+ * // => [1, 2, 3]
+ */
+declare function uniq<T>(): (array: readonly T[]) => T[];
+//#endregion
+export { uniq };

package/dist/fp/array/uniq.js

@@ -0,0 +1,36 @@
+const require_uniq = require("../../array/uniq.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/uniq.ts
+/**
+* Creates a function that removes duplicate values from an array, preserving
+* the order of first occurrence. Equality follows SameValueZero, matching
+* Set semantics. Use it with {@link pipe}.
+*
+* The returned function is lazy-capable inside {@link pipe}. It keeps a Set of
+* values already emitted during each pipeline run.
+*
+* @template T - The type of elements in the array.
+* @returns A function that maps a readonly array to a duplicate-free array.
+*
+* @example
+* import { pipe, uniq } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 2, 3, 3, 3], uniq());
+* // => [1, 2, 3]
+*/
+function uniq() {
+	function uniqEager(array) {
+		return require_uniq.uniq(array);
+	}
+	const uniqLazy = (emit) => {
+		const seen = /* @__PURE__ */ new Set();
+		return (value) => {
+			if (seen.has(value)) return true;
+			seen.add(value);
+			return emit(value);
+		};
+	};
+	return require_lazy.combineEagerAndLazyFunctions(uniqEager, uniqLazy);
+}
+//#endregion
+exports.uniq = uniq;

package/dist/fp/array/uniq.mjs

@@ -0,0 +1,36 @@
+import { uniq as uniq$1 } from "../../array/uniq.mjs";
+import { combineEagerAndLazyFunctions } from "../_internal/lazy.mjs";
+//#region src/fp/array/uniq.ts
+/**
+* Creates a function that removes duplicate values from an array, preserving
+* the order of first occurrence. Equality follows SameValueZero, matching
+* Set semantics. Use it with {@link pipe}.
+*
+* The returned function is lazy-capable inside {@link pipe}. It keeps a Set of
+* values already emitted during each pipeline run.
+*
+* @template T - The type of elements in the array.
+* @returns A function that maps a readonly array to a duplicate-free array.
+*
+* @example
+* import { pipe, uniq } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 2, 3, 3, 3], uniq());
+* // => [1, 2, 3]
+*/
+function uniq() {
+	function uniqEager(array) {
+		return uniq$1(array);
+	}
+	const uniqLazy = (emit) => {
+		const seen = /* @__PURE__ */ new Set();
+		return (value) => {
+			if (seen.has(value)) return true;
+			seen.add(value);
+			return emit(value);
+		};
+	};
+	return combineEagerAndLazyFunctions(uniqEager, uniqLazy);
+}
+//#endregion
+export { uniq };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/uniqBy.d.ts
+/**
+ * Creates a function that removes duplicate values by mapped identity.
+ *
+ * The first value for each mapped key is preserved. The returned function is
+ * lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @template U - The type of comparison keys returned by the mapper.
+ * @param mapper - Called with each value and index to produce a comparison key.
+ * @returns A function that maps the piped array to unique values.
+ *
+ * @example
+ * import { pipe, uniqBy } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 1 }, { id: 2 }], uniqBy(item => item.id));
+ * // => [{ id: 1 }, { id: 2 }]
+ */
+declare function uniqBy<T, U>(mapper: (item: T, index: number) => U): (array: readonly T[]) => T[];
+//#endregion
+export { uniqBy };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/uniqBy.d.ts
+/**
+ * Creates a function that removes duplicate values by mapped identity.
+ *
+ * The first value for each mapped key is preserved. The returned function is
+ * lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @template U - The type of comparison keys returned by the mapper.
+ * @param mapper - Called with each value and index to produce a comparison key.
+ * @returns A function that maps the piped array to unique values.
+ *
+ * @example
+ * import { pipe, uniqBy } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 1 }, { id: 2 }], uniqBy(item => item.id));
+ * // => [{ id: 1 }, { id: 2 }]
+ */
+declare function uniqBy<T, U>(mapper: (item: T, index: number) => U): (array: readonly T[]) => T[];
+//#endregion
+export { uniqBy };

package/dist/fp/array/uniqBy.js

@@ -0,0 +1,38 @@
+const require_uniqBy = require("../../array/uniqBy.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/uniqBy.ts
+/**
+* Creates a function that removes duplicate values by mapped identity.
+*
+* The first value for each mapped key is preserved. The returned function is
+* lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @template U - The type of comparison keys returned by the mapper.
+* @param mapper - Called with each value and index to produce a comparison key.
+* @returns A function that maps the piped array to unique values.
+*
+* @example
+* import { pipe, uniqBy } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 1 }, { id: 2 }], uniqBy(item => item.id));
+* // => [{ id: 1 }, { id: 2 }]
+*/
+function uniqBy(mapper) {
+	function uniqByEager(array) {
+		return require_uniqBy.uniqBy(array, (item, index) => mapper(item, index));
+	}
+	const uniqByLazy = (emit) => {
+		const seen = /* @__PURE__ */ new Set();
+		let index = 0;
+		return (value) => {
+			const key = mapper(value, index++);
+			if (seen.has(key)) return true;
+			seen.add(key);
+			return emit(value);
+		};
+	};
+	return require_lazy.combineEagerAndLazyFunctions(uniqByEager, uniqByLazy);
+}
+//#endregion
+exports.uniqBy = uniqBy;

package/dist/fp/array/uniqBy.mjs

@@ -0,0 +1,38 @@
+import { uniqBy as uniqBy$1 } from "../../array/uniqBy.mjs";
+import { combineEagerAndLazyFunctions } from "../_internal/lazy.mjs";
+//#region src/fp/array/uniqBy.ts
+/**
+* Creates a function that removes duplicate values by mapped identity.
+*
+* The first value for each mapped key is preserved. The returned function is
+* lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @template U - The type of comparison keys returned by the mapper.
+* @param mapper - Called with each value and index to produce a comparison key.
+* @returns A function that maps the piped array to unique values.
+*
+* @example
+* import { pipe, uniqBy } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 1 }, { id: 2 }], uniqBy(item => item.id));
+* // => [{ id: 1 }, { id: 2 }]
+*/
+function uniqBy(mapper) {
+	function uniqByEager(array) {
+		return uniqBy$1(array, (item, index) => mapper(item, index));
+	}
+	const uniqByLazy = (emit) => {
+		const seen = /* @__PURE__ */ new Set();
+		let index = 0;
+		return (value) => {
+			const key = mapper(value, index++);
+			if (seen.has(key)) return true;
+			seen.add(key);
+			return emit(value);
+		};
+	};
+	return combineEagerAndLazyFunctions(uniqByEager, uniqByLazy);
+}
+//#endregion
+export { uniqBy };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/uniqWith.d.ts
+/**
+ * Creates a function that removes duplicate values using a custom equality function.
+ *
+ * The first value in each equality group is preserved. The returned function is
+ * lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param areItemsEqual - Returns true when two values should be treated as equal.
+ * @returns A function that maps the piped array to unique values.
+ *
+ * @example
+ * import { pipe, uniqWith } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 1 }, { id: 2 }], uniqWith((a, b) => a.id === b.id));
+ * // => [{ id: 1 }, { id: 2 }]
+ */
+declare function uniqWith<T>(areItemsEqual: (item: T, other: T) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { uniqWith };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/uniqWith.d.ts
+/**
+ * Creates a function that removes duplicate values using a custom equality function.
+ *
+ * The first value in each equality group is preserved. The returned function is
+ * lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param areItemsEqual - Returns true when two values should be treated as equal.
+ * @returns A function that maps the piped array to unique values.
+ *
+ * @example
+ * import { pipe, uniqWith } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 1 }, { id: 2 }], uniqWith((a, b) => a.id === b.id));
+ * // => [{ id: 1 }, { id: 2 }]
+ */
+declare function uniqWith<T>(areItemsEqual: (item: T, other: T) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { uniqWith };

package/dist/fp/array/uniqWith.js

@@ -0,0 +1,35 @@
+const require_uniqWith = require("../../array/uniqWith.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/uniqWith.ts
+/**
+* Creates a function that removes duplicate values using a custom equality function.
+*
+* The first value in each equality group is preserved. The returned function is
+* lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param areItemsEqual - Returns true when two values should be treated as equal.
+* @returns A function that maps the piped array to unique values.
+*
+* @example
+* import { pipe, uniqWith } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 1 }, { id: 2 }], uniqWith((a, b) => a.id === b.id));
+* // => [{ id: 1 }, { id: 2 }]
+*/
+function uniqWith(areItemsEqual) {
+	function uniqWithEager(array) {
+		return require_uniqWith.uniqWith(array, areItemsEqual);
+	}
+	const uniqWithLazy = (emit) => {
+		const seen = [];
+		return (value) => {
+			if (seen.some((item) => areItemsEqual(item, value))) return true;
+			seen.push(value);
+			return emit(value);
+		};
+	};
+	return require_lazy.combineEagerAndLazyFunctions(uniqWithEager, uniqWithLazy);
+}
+//#endregion
+exports.uniqWith = uniqWith;

package/dist/fp/array/uniqWith.mjs

@@ -0,0 +1,35 @@
+import { uniqWith as uniqWith$1 } from "../../array/uniqWith.mjs";
+import { combineEagerAndLazyFunctions } from "../_internal/lazy.mjs";
+//#region src/fp/array/uniqWith.ts
+/**
+* Creates a function that removes duplicate values using a custom equality function.
+*
+* The first value in each equality group is preserved. The returned function is
+* lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param areItemsEqual - Returns true when two values should be treated as equal.
+* @returns A function that maps the piped array to unique values.
+*
+* @example
+* import { pipe, uniqWith } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 1 }, { id: 2 }], uniqWith((a, b) => a.id === b.id));
+* // => [{ id: 1 }, { id: 2 }]
+*/
+function uniqWith(areItemsEqual) {
+	function uniqWithEager(array) {
+		return uniqWith$1(array, areItemsEqual);
+	}
+	const uniqWithLazy = (emit) => {
+		const seen = [];
+		return (value) => {
+			if (seen.some((item) => areItemsEqual(item, value))) return true;
+			seen.push(value);
+			return emit(value);
+		};
+	};
+	return combineEagerAndLazyFunctions(uniqWithEager, uniqWithLazy);
+}
+//#endregion
+export { uniqWith };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/unzip.d.ts
+type Unzip<K extends unknown[]> = { [I in keyof K]: Array<K[I]> };
+/**
+ * Creates a function that unzips grouped tuples into arrays by position.
+ *
+ * The returned function is the data-last form of the main {@link unzip} utility.
+ * Use it with {@link pipe}.
+ *
+ * @template T - The tuple type inside the zipped array.
+ * @returns A function that maps zipped tuples to arrays grouped by tuple position.
+ *
+ * @example
+ * import { pipe, unzip } from 'es-toolkit/fp';
+ *
+ * pipe([[1, 'a'], [2, 'b']] as Array<[number, string]>, unzip());
+ * // => [[1, 2], ['a', 'b']]
+ */
+declare function unzip<T extends unknown[]>(): (zipped: ReadonlyArray<[...T]>) => Unzip<T>;
+//#endregion
+export { unzip };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/unzip.d.ts
+type Unzip<K extends unknown[]> = { [I in keyof K]: Array<K[I]> };
+/**
+ * Creates a function that unzips grouped tuples into arrays by position.
+ *
+ * The returned function is the data-last form of the main {@link unzip} utility.
+ * Use it with {@link pipe}.
+ *
+ * @template T - The tuple type inside the zipped array.
+ * @returns A function that maps zipped tuples to arrays grouped by tuple position.
+ *
+ * @example
+ * import { pipe, unzip } from 'es-toolkit/fp';
+ *
+ * pipe([[1, 'a'], [2, 'b']] as Array<[number, string]>, unzip());
+ * // => [[1, 2], ['a', 'b']]
+ */
+declare function unzip<T extends unknown[]>(): (zipped: ReadonlyArray<[...T]>) => Unzip<T>;
+//#endregion
+export { unzip };