es-toolkit 1.49.0 → 1.50.0-dev.1975

package/dist/compat/string/truncate.mjs

@@ -1,14 +1,7 @@
 import { isObject } from "../predicate/isObject.mjs";
+import { regexMultiByte } from "../_internal/regexMultiByte.mjs";
 //#region src/compat/string/truncate.ts
 /**
-* Used to compose unicode character classes.
-* @link https://github.com/lodash/lodash/blob/4.17.21-es/_hasUnicode.js
-*
-* Used to detect strings with zero-width joiners or code points from the astral planes.
-* @link http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/
-*/
-const regexMultiByte = /[\u200d\ud800-\udfff\u0300-\u036f\ufe20-\ufe2f\u20d0-\u20ff\ufe0e\ufe0f]/;
-/**
 * This regex might more completely detect unicode, but it is slower and this project
 * desires to mimic the behavior of lodash.
 */

package/dist/compat/string/upperCase.js

@@ -1,5 +1,5 @@
-const require_upperCase = require("../../string/upperCase.js");
 const require_deburr = require("./deburr.js");
+const require_words = require("./words.js");
 const require_normalizeForCase = require("../_internal/normalizeForCase.js");
 //#region src/compat/string/upperCase.ts
 /**
@@ -17,7 +17,7 @@ const require_normalizeForCase = require("../_internal/normalizeForCase.js");
 * const convertedStr4 = upperCase('HTTPRequest') // returns 'HTTP REQUEST'
 */
 function upperCase(str) {
-	return require_upperCase.upperCase(require_normalizeForCase.normalizeForCase(require_deburr.deburr(str)));
+	return require_words.words(require_normalizeForCase.normalizeForCase(require_deburr.deburr(str))).map((word) => word.toUpperCase()).join(" ");
 }
 //#endregion
 exports.upperCase = upperCase;

package/dist/compat/string/upperCase.mjs

@@ -1,5 +1,5 @@
-import { upperCase as upperCase$1 } from "../../string/upperCase.mjs";
 import { deburr } from "./deburr.mjs";
+import { words } from "./words.mjs";
 import { normalizeForCase } from "../_internal/normalizeForCase.mjs";
 //#region src/compat/string/upperCase.ts
 /**
@@ -17,7 +17,7 @@ import { normalizeForCase } from "../_internal/normalizeForCase.mjs";
 * const convertedStr4 = upperCase('HTTPRequest') // returns 'HTTP REQUEST'
 */
 function upperCase(str) {
-	return upperCase$1(normalizeForCase(deburr(str)));
+	return words(normalizeForCase(deburr(str))).map((word) => word.toUpperCase()).join(" ");
 }
 //#endregion
 export { upperCase };

package/dist/compat/util/eq.d.mts

@@ -1 +1,17 @@
-import { isEqualsSameValueZero } from "../../_internal/isEqualsSameValueZero.mjs";
+//#region src/compat/util/eq.d.ts
+/**
+ * Performs a `SameValueZero` comparison between two values to determine if they are equivalent.
+ *
+ * @param value The value to compare.
+ * @param other The other value to compare.
+ * @returns Returns `true` if the values are equivalent, else `false`.
+ *
+ * @example
+ * eq(1, 1); // true
+ * eq(0, -0); // true
+ * eq(NaN, NaN); // true
+ * eq('a', Object('a')); // false
+ */
+declare function eq(value: any, other: any): boolean;
+//#endregion
+export { eq };

package/dist/compat/util/eq.d.ts

@@ -1 +1,17 @@
-import { isEqualsSameValueZero } from "../../_internal/isEqualsSameValueZero.js";
+//#region src/compat/util/eq.d.ts
+/**
+ * Performs a `SameValueZero` comparison between two values to determine if they are equivalent.
+ *
+ * @param value The value to compare.
+ * @param other The other value to compare.
+ * @returns Returns `true` if the values are equivalent, else `false`.
+ *
+ * @example
+ * eq(1, 1); // true
+ * eq(0, -0); // true
+ * eq(NaN, NaN); // true
+ * eq('a', Object('a')); // false
+ */
+declare function eq(value: any, other: any): boolean;
+//#endregion
+export { eq };

package/dist/compat/util/eq.js

@@ -1 +1,19 @@
-require("../../_internal/isEqualsSameValueZero.js");
+//#region src/compat/util/eq.ts
+/**
+* Performs a `SameValueZero` comparison between two values to determine if they are equivalent.
+*
+* @param value The value to compare.
+* @param other The other value to compare.
+* @returns Returns `true` if the values are equivalent, else `false`.
+*
+* @example
+* eq(1, 1); // true
+* eq(0, -0); // true
+* eq(NaN, NaN); // true
+* eq('a', Object('a')); // false
+*/
+function eq(value, other) {
+	return value === other || Number.isNaN(value) && Number.isNaN(other);
+}
+//#endregion
+exports.eq = eq;

package/dist/compat/util/eq.mjs

@@ -1 +1,19 @@
-import "../../_internal/isEqualsSameValueZero.mjs";
+//#region src/compat/util/eq.ts
+/**
+* Performs a `SameValueZero` comparison between two values to determine if they are equivalent.
+*
+* @param value The value to compare.
+* @param other The other value to compare.
+* @returns Returns `true` if the values are equivalent, else `false`.
+*
+* @example
+* eq(1, 1); // true
+* eq(0, -0); // true
+* eq(NaN, NaN); // true
+* eq('a', Object('a')); // false
+*/
+function eq(value, other) {
+	return value === other || Number.isNaN(value) && Number.isNaN(other);
+}
+//#endregion
+export { eq };

package/dist/compat/util/toArray.js

@@ -1,5 +1,6 @@
 const require_isArrayLike = require("../predicate/isArrayLike.js");
 const require_isMap = require("../predicate/isMap.js");
+const require_isSet = require("../predicate/isSet.js");
 //#region src/compat/util/toArray.ts
 /**
 * Converts a value to an array.
@@ -15,7 +16,7 @@ const require_isMap = require("../predicate/isMap.js");
 */
 function toArray(value) {
 	if (value == null) return [];
-	if (require_isArrayLike.isArrayLike(value) || require_isMap.isMap(value)) return Array.from(value);
+	if (require_isArrayLike.isArrayLike(value) || require_isMap.isMap(value) || require_isSet.isSet(value)) return Array.from(value);
 	if (typeof value === "object") return Object.values(value);
 	return [];
 }

package/dist/compat/util/toArray.mjs

@@ -1,5 +1,6 @@
 import { isArrayLike } from "../predicate/isArrayLike.mjs";
 import { isMap } from "../predicate/isMap.mjs";
+import { isSet } from "../predicate/isSet.mjs";
 //#region src/compat/util/toArray.ts
 /**
 * Converts a value to an array.
@@ -15,7 +16,7 @@ import { isMap } from "../predicate/isMap.mjs";
 */
 function toArray(value) {
 	if (value == null) return [];
-	if (isArrayLike(value) || isMap(value)) return Array.from(value);
+	if (isArrayLike(value) || isMap(value) || isSet(value)) return Array.from(value);
 	if (typeof value === "object") return Object.values(value);
 	return [];
 }

package/dist/fp/flow.d.mts

@@ -0,0 +1,213 @@
+//#region src/fp/flow.d.ts
+/**
+ * Creates a reusable function from a single function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @returns A function with the same parameters as `fn1` that returns its result.
+ */
+declare function flow<A extends any[], R1>(fn1: (...args: A) => R1): (...args: A) => R1;
+/**
+ * Composes `fn1` and `fn2` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn2`.
+ */
+declare function flow<A extends any[], R1, R2>(fn1: (...args: A) => R1, fn2: (input: R1) => R2): (...args: A) => R2;
+/**
+ * Composes `fn1` through `fn3` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn3`.
+ */
+declare function flow<A extends any[], R1, R2, R3>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3): (...args: A) => R3;
+/**
+ * Composes `fn1` through `fn4` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn4`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4): (...args: A) => R4;
+/**
+ * Composes `fn1` through `fn5` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn5`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5): (...args: A) => R5;
+/**
+ * Composes `fn1` through `fn6` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn6`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6): (...args: A) => R6;
+/**
+ * Composes `fn1` through `fn7` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn7`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7): (...args: A) => R7;
+/**
+ * Composes `fn1` through `fn8` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @param fn8 - Applied to the result of `fn7`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn8`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7, R8>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7, fn8: (input: R7) => R8): (...args: A) => R8;
+/**
+ * Composes `fn1` through `fn9` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @param fn8 - Applied to the result of `fn7`.
+ * @param fn9 - Applied to the result of `fn8`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn9`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7, R8, R9>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7, fn8: (input: R7) => R8, fn9: (input: R8) => R9): (...args: A) => R9;
+/**
+ * Composes `fn1` through `fn10` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @param fn8 - Applied to the result of `fn7`.
+ * @param fn9 - Applied to the result of `fn8`.
+ * @param fn10 - Applied to the result of `fn9`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn10`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7, fn8: (input: R7) => R8, fn9: (input: R8) => R9, fn10: (input: R9) => R10): (...args: A) => R10;
+/**
+ * Composes `fn1` through `fn11` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @param fn8 - Applied to the result of `fn7`.
+ * @param fn9 - Applied to the result of `fn8`.
+ * @param fn10 - Applied to the result of `fn9`.
+ * @param fn11 - Applied to the result of `fn10`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn11`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7, fn8: (input: R7) => R8, fn9: (input: R8) => R9, fn10: (input: R9) => R10, fn11: (input: R10) => R11): (...args: A) => R11;
+/**
+ * Composes `fn1` through `fn12` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @param fn8 - Applied to the result of `fn7`.
+ * @param fn9 - Applied to the result of `fn8`.
+ * @param fn10 - Applied to the result of `fn9`.
+ * @param fn11 - Applied to the result of `fn10`.
+ * @param fn12 - Applied to the result of `fn11`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn12`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7, fn8: (input: R7) => R8, fn9: (input: R8) => R9, fn10: (input: R9) => R10, fn11: (input: R10) => R11, fn12: (input: R11) => R12): (...args: A) => R12;
+/**
+ * Composes `fn1` through `fn13` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @param fn8 - Applied to the result of `fn7`.
+ * @param fn9 - Applied to the result of `fn8`.
+ * @param fn10 - Applied to the result of `fn9`.
+ * @param fn11 - Applied to the result of `fn10`.
+ * @param fn12 - Applied to the result of `fn11`.
+ * @param fn13 - Applied to the result of `fn12`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn13`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7, fn8: (input: R7) => R8, fn9: (input: R8) => R9, fn10: (input: R9) => R10, fn11: (input: R10) => R11, fn12: (input: R11) => R12, fn13: (input: R12) => R13): (...args: A) => R13;
+/**
+ * Composes `fn1` through `fn14` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @param fn8 - Applied to the result of `fn7`.
+ * @param fn9 - Applied to the result of `fn8`.
+ * @param fn10 - Applied to the result of `fn9`.
+ * @param fn11 - Applied to the result of `fn10`.
+ * @param fn12 - Applied to the result of `fn11`.
+ * @param fn13 - Applied to the result of `fn12`.
+ * @param fn14 - Applied to the result of `fn13`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn14`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7, fn8: (input: R7) => R8, fn9: (input: R8) => R9, fn10: (input: R9) => R10, fn11: (input: R10) => R11, fn12: (input: R11) => R12, fn13: (input: R12) => R13, fn14: (input: R13) => R14): (...args: A) => R14;
+/**
+ * Composes `fn1` through `fn15` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @param fn8 - Applied to the result of `fn7`.
+ * @param fn9 - Applied to the result of `fn8`.
+ * @param fn10 - Applied to the result of `fn9`.
+ * @param fn11 - Applied to the result of `fn10`.
+ * @param fn12 - Applied to the result of `fn11`.
+ * @param fn13 - Applied to the result of `fn12`.
+ * @param fn14 - Applied to the result of `fn13`.
+ * @param fn15 - Applied to the result of `fn14`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn15`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7, fn8: (input: R7) => R8, fn9: (input: R8) => R9, fn10: (input: R9) => R10, fn11: (input: R10) => R11, fn12: (input: R11) => R12, fn13: (input: R12) => R13, fn14: (input: R13) => R14, fn15: (input: R14) => R15): (...args: A) => R15;
+//#endregion
+export { flow };

package/dist/fp/flow.d.ts

@@ -0,0 +1,213 @@
+//#region src/fp/flow.d.ts
+/**
+ * Creates a reusable function from a single function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @returns A function with the same parameters as `fn1` that returns its result.
+ */
+declare function flow<A extends any[], R1>(fn1: (...args: A) => R1): (...args: A) => R1;
+/**
+ * Composes `fn1` and `fn2` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn2`.
+ */
+declare function flow<A extends any[], R1, R2>(fn1: (...args: A) => R1, fn2: (input: R1) => R2): (...args: A) => R2;
+/**
+ * Composes `fn1` through `fn3` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn3`.
+ */
+declare function flow<A extends any[], R1, R2, R3>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3): (...args: A) => R3;
+/**
+ * Composes `fn1` through `fn4` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn4`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4): (...args: A) => R4;
+/**
+ * Composes `fn1` through `fn5` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn5`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5): (...args: A) => R5;
+/**
+ * Composes `fn1` through `fn6` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn6`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6): (...args: A) => R6;
+/**
+ * Composes `fn1` through `fn7` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn7`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7): (...args: A) => R7;
+/**
+ * Composes `fn1` through `fn8` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @param fn8 - Applied to the result of `fn7`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn8`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7, R8>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7, fn8: (input: R7) => R8): (...args: A) => R8;
+/**
+ * Composes `fn1` through `fn9` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @param fn8 - Applied to the result of `fn7`.
+ * @param fn9 - Applied to the result of `fn8`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn9`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7, R8, R9>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7, fn8: (input: R7) => R8, fn9: (input: R8) => R9): (...args: A) => R9;
+/**
+ * Composes `fn1` through `fn10` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @param fn8 - Applied to the result of `fn7`.
+ * @param fn9 - Applied to the result of `fn8`.
+ * @param fn10 - Applied to the result of `fn9`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn10`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7, fn8: (input: R7) => R8, fn9: (input: R8) => R9, fn10: (input: R9) => R10): (...args: A) => R10;
+/**
+ * Composes `fn1` through `fn11` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @param fn8 - Applied to the result of `fn7`.
+ * @param fn9 - Applied to the result of `fn8`.
+ * @param fn10 - Applied to the result of `fn9`.
+ * @param fn11 - Applied to the result of `fn10`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn11`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7, fn8: (input: R7) => R8, fn9: (input: R8) => R9, fn10: (input: R9) => R10, fn11: (input: R10) => R11): (...args: A) => R11;
+/**
+ * Composes `fn1` through `fn12` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @param fn8 - Applied to the result of `fn7`.
+ * @param fn9 - Applied to the result of `fn8`.
+ * @param fn10 - Applied to the result of `fn9`.
+ * @param fn11 - Applied to the result of `fn10`.
+ * @param fn12 - Applied to the result of `fn11`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn12`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7, fn8: (input: R7) => R8, fn9: (input: R8) => R9, fn10: (input: R9) => R10, fn11: (input: R10) => R11, fn12: (input: R11) => R12): (...args: A) => R12;
+/**
+ * Composes `fn1` through `fn13` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @param fn8 - Applied to the result of `fn7`.
+ * @param fn9 - Applied to the result of `fn8`.
+ * @param fn10 - Applied to the result of `fn9`.
+ * @param fn11 - Applied to the result of `fn10`.
+ * @param fn12 - Applied to the result of `fn11`.
+ * @param fn13 - Applied to the result of `fn12`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn13`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7, fn8: (input: R7) => R8, fn9: (input: R8) => R9, fn10: (input: R9) => R10, fn11: (input: R10) => R11, fn12: (input: R11) => R12, fn13: (input: R12) => R13): (...args: A) => R13;
+/**
+ * Composes `fn1` through `fn14` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @param fn8 - Applied to the result of `fn7`.
+ * @param fn9 - Applied to the result of `fn8`.
+ * @param fn10 - Applied to the result of `fn9`.
+ * @param fn11 - Applied to the result of `fn10`.
+ * @param fn12 - Applied to the result of `fn11`.
+ * @param fn13 - Applied to the result of `fn12`.
+ * @param fn14 - Applied to the result of `fn13`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn14`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7, fn8: (input: R7) => R8, fn9: (input: R8) => R9, fn10: (input: R9) => R10, fn11: (input: R10) => R11, fn12: (input: R11) => R12, fn13: (input: R12) => R13, fn14: (input: R13) => R14): (...args: A) => R14;
+/**
+ * Composes `fn1` through `fn15` left-to-right into a single reusable function.
+ *
+ * @param fn1 - The first function, which may take any number of arguments.
+ * @param fn2 - Applied to the result of `fn1`.
+ * @param fn3 - Applied to the result of `fn2`.
+ * @param fn4 - Applied to the result of `fn3`.
+ * @param fn5 - Applied to the result of `fn4`.
+ * @param fn6 - Applied to the result of `fn5`.
+ * @param fn7 - Applied to the result of `fn6`.
+ * @param fn8 - Applied to the result of `fn7`.
+ * @param fn9 - Applied to the result of `fn8`.
+ * @param fn10 - Applied to the result of `fn9`.
+ * @param fn11 - Applied to the result of `fn10`.
+ * @param fn12 - Applied to the result of `fn11`.
+ * @param fn13 - Applied to the result of `fn12`.
+ * @param fn14 - Applied to the result of `fn13`.
+ * @param fn15 - Applied to the result of `fn14`.
+ * @returns A function with the same parameters as `fn1` that returns the result of `fn15`.
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15>(fn1: (...args: A) => R1, fn2: (input: R1) => R2, fn3: (input: R2) => R3, fn4: (input: R3) => R4, fn5: (input: R4) => R5, fn6: (input: R5) => R6, fn7: (input: R6) => R7, fn8: (input: R7) => R8, fn9: (input: R8) => R9, fn10: (input: R9) => R10, fn11: (input: R10) => R11, fn12: (input: R11) => R12, fn13: (input: R12) => R13, fn14: (input: R13) => R14, fn15: (input: R14) => R15): (...args: A) => R15;
+//#endregion
+export { flow };

package/dist/fp/flow.js

@@ -0,0 +1,50 @@
+const require_pipe = require("./pipe.js");
+//#region src/fp/flow.ts
+/**
+* Performs left-to-right function composition, returning a **reusable function**
+* instead of running immediately. The first function may take any number of
+* arguments; every later function is unary and receives the previous result.
+*
+* `flow` is the deferred sibling of {@link pipe}: where `pipe(value, ...fns)`
+* threads a concrete value through the functions right away, `flow(...fns)`
+* builds a function you can call later (and reuse) with the data. Internally it
+* delegates to `pipe`, so lazy-capable functions (`map`, `filter`, `take`, …)
+* are fused exactly the same way and benefit from early termination.
+*
+* @param functions - The functions to compose. The first may be variadic; the
+*   rest are unary, each receiving the previous function's output.
+* @returns A function that, when called, applies every function left-to-right.
+*
+* @example
+* import { flow } from 'es-toolkit/fp';
+*
+* const addThenSquare = flow(
+*   (x: number, y: number) => x + y,
+*   n => n * n
+* );
+*
+* addThenSquare(1, 2); // => 9
+*
+* @example
+* import { flow, map, filter, take } from 'es-toolkit/fp';
+*
+* // A reusable lazy pipeline. Only the first two even squares are computed.
+* const firstTwoEvenSquares = flow(
+*   map((x: number) => x * x),
+*   filter(x => x % 2 === 0),
+*   take(2)
+* );
+*
+* firstTwoEvenSquares([1, 2, 3, 4, 5, 6, 7, 8]); // => [4, 16]
+*/
+function flow(...functions) {
+	const run = require_pipe.pipe;
+	return function(...args) {
+		if (functions.length === 0) return args[0];
+		if (args.length <= 1) return run(args[0], ...functions);
+		const [first, ...rest] = functions;
+		return run(first.apply(this, args), ...rest);
+	};
+}
+//#endregion
+exports.flow = flow;