@quantiya/codevibe-claude-plugin 2.0.26 → 2.0.27

package/node_modules/es-toolkit/dist/fp/flowAsync.d.ts

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

package/node_modules/es-toolkit/dist/fp/flowAsync.js

@@ -0,0 +1,37 @@
+//#region src/fp/flowAsync.ts
+/**
+* Performs left-to-right async function composition, returning a **reusable
+* async function** instead of running immediately. The first function may take
+* any number of arguments; every later function is unary and receives the
+* awaited result of the previous one.
+*
+* `flowAsync` is the promise-aware sibling of {@link flow}: where `flow` passes
+* each raw return value straight to the next function (so a returned `Promise`
+* arrives unresolved), `flowAsync` awaits every step, letting synchronous and
+* asynchronous functions mix freely in one chain. The composed function always
+* returns a `Promise`.
+*
+* @param functions - The functions to compose. The first may be variadic; the
+*   rest are unary, each receiving the awaited output of the previous function.
+* @returns An async function that, when called, applies every function
+*   left-to-right, awaiting each result.
+*
+* @example
+* import { flowAsync } from 'es-toolkit/fp';
+*
+* const fetchUser = async (id: number) => ({ id, name: 'Alice' });
+* const getName = (user: { name: string }) => user.name;
+*
+* const getUserName = flowAsync(fetchUser, getName);
+* await getUserName(1); // => 'Alice'
+*/
+function flowAsync(...functions) {
+	return async function(...args) {
+		if (functions.length === 0) return args[0];
+		let result = await functions[0].apply(this, args);
+		for (let i = 1; i < functions.length; i++) result = await functions[i].call(this, result);
+		return result;
+	};
+}
+//#endregion
+exports.flowAsync = flowAsync;

package/node_modules/es-toolkit/dist/fp/flowAsync.mjs

@@ -0,0 +1,37 @@
+//#region src/fp/flowAsync.ts
+/**
+* Performs left-to-right async function composition, returning a **reusable
+* async function** instead of running immediately. The first function may take
+* any number of arguments; every later function is unary and receives the
+* awaited result of the previous one.
+*
+* `flowAsync` is the promise-aware sibling of {@link flow}: where `flow` passes
+* each raw return value straight to the next function (so a returned `Promise`
+* arrives unresolved), `flowAsync` awaits every step, letting synchronous and
+* asynchronous functions mix freely in one chain. The composed function always
+* returns a `Promise`.
+*
+* @param functions - The functions to compose. The first may be variadic; the
+*   rest are unary, each receiving the awaited output of the previous function.
+* @returns An async function that, when called, applies every function
+*   left-to-right, awaiting each result.
+*
+* @example
+* import { flowAsync } from 'es-toolkit/fp';
+*
+* const fetchUser = async (id: number) => ({ id, name: 'Alice' });
+* const getName = (user: { name: string }) => user.name;
+*
+* const getUserName = flowAsync(fetchUser, getName);
+* await getUserName(1); // => 'Alice'
+*/
+function flowAsync(...functions) {
+	return async function(...args) {
+		if (functions.length === 0) return args[0];
+		let result = await functions[0].apply(this, args);
+		for (let i = 1; i < functions.length; i++) result = await functions[i].call(this, result);
+		return result;
+	};
+}
+//#endregion
+export { flowAsync };

package/node_modules/es-toolkit/dist/fp/index.d.mts

@@ -68,9 +68,10 @@ import { zip } from "./array/zip.mjs";
 import { zipObject } from "./array/zipObject.mjs";
 import { zipWith } from "./array/zipWith.mjs";
 import { flow } from "./flow.mjs";
+import { flowAsync } from "./flowAsync.mjs";
 import { add } from "./math/add.mjs";
 import { multiply } from "./math/multiply.mjs";
 import { omit } from "./object/omit.mjs";
 import { pick } from "./object/pick.mjs";
 import { pipe } from "./pipe.mjs";
-export { WindowedOptions, add, at, cartesianProduct, chunk, chunkBy, combinations, compact, countBy, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, filter, find, findIndex, findLast, findLastIndex, flatMap, flatMapDeep, flatten, flattenDeep, flow, forEach, groupBy, head, initial, intersection, intersectionBy, intersectionWith, isSubset, isSubsetWith, join, keyBy, last, length, map, maxBy, minBy, multiply, omit, orderBy, partition, pick, pipe, reverse, sample, sampleSize, shuffle, sortBy, tail, take, takeRight, takeRightWhile, takeWhile, toFilled, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, windowed, without, xor, xorBy, xorWith, zip, zipObject, zipWith };
+export { WindowedOptions, add, at, cartesianProduct, chunk, chunkBy, combinations, compact, countBy, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, filter, find, findIndex, findLast, findLastIndex, flatMap, flatMapDeep, flatten, flattenDeep, flow, flowAsync, forEach, groupBy, head, initial, intersection, intersectionBy, intersectionWith, isSubset, isSubsetWith, join, keyBy, last, length, map, maxBy, minBy, multiply, omit, orderBy, partition, pick, pipe, reverse, sample, sampleSize, shuffle, sortBy, tail, take, takeRight, takeRightWhile, takeWhile, toFilled, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, windowed, without, xor, xorBy, xorWith, zip, zipObject, zipWith };

package/node_modules/es-toolkit/dist/fp/index.d.ts

@@ -68,9 +68,10 @@ import { zip } from "./array/zip.js";
 import { zipObject } from "./array/zipObject.js";
 import { zipWith } from "./array/zipWith.js";
 import { flow } from "./flow.js";
+import { flowAsync } from "./flowAsync.js";
 import { add } from "./math/add.js";
 import { multiply } from "./math/multiply.js";
 import { omit } from "./object/omit.js";
 import { pick } from "./object/pick.js";
 import { pipe } from "./pipe.js";
-export { WindowedOptions, add, at, cartesianProduct, chunk, chunkBy, combinations, compact, countBy, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, filter, find, findIndex, findLast, findLastIndex, flatMap, flatMapDeep, flatten, flattenDeep, flow, forEach, groupBy, head, initial, intersection, intersectionBy, intersectionWith, isSubset, isSubsetWith, join, keyBy, last, length, map, maxBy, minBy, multiply, omit, orderBy, partition, pick, pipe, reverse, sample, sampleSize, shuffle, sortBy, tail, take, takeRight, takeRightWhile, takeWhile, toFilled, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, windowed, without, xor, xorBy, xorWith, zip, zipObject, zipWith };
+export { WindowedOptions, add, at, cartesianProduct, chunk, chunkBy, combinations, compact, countBy, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, filter, find, findIndex, findLast, findLastIndex, flatMap, flatMapDeep, flatten, flattenDeep, flow, flowAsync, forEach, groupBy, head, initial, intersection, intersectionBy, intersectionWith, isSubset, isSubsetWith, join, keyBy, last, length, map, maxBy, minBy, multiply, omit, orderBy, partition, pick, pipe, reverse, sample, sampleSize, shuffle, sortBy, tail, take, takeRight, takeRightWhile, takeWhile, toFilled, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, windowed, without, xor, xorBy, xorWith, zip, zipObject, zipWith };

package/node_modules/es-toolkit/dist/fp/index.js

@@ -70,6 +70,7 @@ const require_zipWith = require("./array/zipWith.js");
 require("./array/index.js");
 const require_pipe = require("./pipe.js");
 const require_flow = require("./flow.js");
+const require_flowAsync = require("./flowAsync.js");
 const require_add = require("./math/add.js");
 const require_multiply = require("./math/multiply.js");
 require("./math/index.js");
@@ -101,6 +102,7 @@ exports.flatMapDeep = require_flatMapDeep.flatMapDeep;
 exports.flatten = require_flatten.flatten;
 exports.flattenDeep = require_flattenDeep.flattenDeep;
 exports.flow = require_flow.flow;
+exports.flowAsync = require_flowAsync.flowAsync;
 exports.forEach = require_forEach.forEach;
 exports.groupBy = require_groupBy.groupBy;
 exports.head = require_head.head;

package/node_modules/es-toolkit/dist/fp/index.mjs

@@ -69,10 +69,11 @@ import { zipWith } from "./array/zipWith.mjs";
 import "./array/index.mjs";
 import { pipe } from "./pipe.mjs";
 import { flow } from "./flow.mjs";
+import { flowAsync } from "./flowAsync.mjs";
 import { add } from "./math/add.mjs";
 import { multiply } from "./math/multiply.mjs";
 import "./math/index.mjs";
 import { omit } from "./object/omit.mjs";
 import { pick } from "./object/pick.mjs";
 import "./object/index.mjs";
-export { add, at, cartesianProduct, chunk, chunkBy, combinations, compact, countBy, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, filter, find, findIndex, findLast, findLastIndex, flatMap, flatMapDeep, flatten, flattenDeep, flow, forEach, groupBy, head, initial, intersection, intersectionBy, intersectionWith, isSubset, isSubsetWith, join, keyBy, last, length, map, maxBy, minBy, multiply, omit, orderBy, partition, pick, pipe, reverse, sample, sampleSize, shuffle, sortBy, tail, take, takeRight, takeRightWhile, takeWhile, toFilled, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, windowed, without, xor, xorBy, xorWith, zip, zipObject, zipWith };
+export { add, at, cartesianProduct, chunk, chunkBy, combinations, compact, countBy, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, filter, find, findIndex, findLast, findLastIndex, flatMap, flatMapDeep, flatten, flattenDeep, flow, flowAsync, forEach, groupBy, head, initial, intersection, intersectionBy, intersectionWith, isSubset, isSubsetWith, join, keyBy, last, length, map, maxBy, minBy, multiply, omit, orderBy, partition, pick, pipe, reverse, sample, sampleSize, shuffle, sortBy, tail, take, takeRight, takeRightWhile, takeWhile, toFilled, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, windowed, without, xor, xorBy, xorWith, zip, zipObject, zipWith };

package/node_modules/es-toolkit/dist/fp/iterator/cartesianProduct.d.mts

@@ -0,0 +1,23 @@
+//#region src/fp/iterator/cartesianProduct.d.ts
+/**
+ * Creates a function that lazily takes the Cartesian product of the piped
+ * iterator and `other`, for use with {@link pipe}. Every element of the piped
+ * iterator is paired with every element of `other`, with `other` advancing
+ * fastest. `other` is buffered into an array when iteration starts, while the
+ * piped iterator is consumed lazily, so it may be infinite.
+ *
+ * @template T - The type of elements produced by the piped iterator.
+ * @template U - The type of elements produced by `other`.
+ * @param other - The iterator to take the product with.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<[T, U]>`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { cartesianProduct, toArray } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2].values(), cartesianProduct(['a', 'b'].values()), toArray());
+ * // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+ */
+declare function cartesianProduct<T, U>(other: Iterator<U>): (source: Iterator<T>) => IteratorObject<[T, U], undefined>;
+//#endregion
+export { cartesianProduct };

package/node_modules/es-toolkit/dist/fp/iterator/cartesianProduct.d.ts

@@ -0,0 +1,23 @@
+//#region src/fp/iterator/cartesianProduct.d.ts
+/**
+ * Creates a function that lazily takes the Cartesian product of the piped
+ * iterator and `other`, for use with {@link pipe}. Every element of the piped
+ * iterator is paired with every element of `other`, with `other` advancing
+ * fastest. `other` is buffered into an array when iteration starts, while the
+ * piped iterator is consumed lazily, so it may be infinite.
+ *
+ * @template T - The type of elements produced by the piped iterator.
+ * @template U - The type of elements produced by `other`.
+ * @param other - The iterator to take the product with.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<[T, U]>`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { cartesianProduct, toArray } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2].values(), cartesianProduct(['a', 'b'].values()), toArray());
+ * // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+ */
+declare function cartesianProduct<T, U>(other: Iterator<U>): (source: Iterator<T>) => IteratorObject<[T, U], undefined>;
+//#endregion
+export { cartesianProduct };

package/node_modules/es-toolkit/dist/fp/iterator/cartesianProduct.js

@@ -0,0 +1,28 @@
+const require_cartesianProduct = require("../../iterator/cartesianProduct.js");
+//#region src/fp/iterator/cartesianProduct.ts
+/**
+* Creates a function that lazily takes the Cartesian product of the piped
+* iterator and `other`, for use with {@link pipe}. Every element of the piped
+* iterator is paired with every element of `other`, with `other` advancing
+* fastest. `other` is buffered into an array when iteration starts, while the
+* piped iterator is consumed lazily, so it may be infinite.
+*
+* @template T - The type of elements produced by the piped iterator.
+* @template U - The type of elements produced by `other`.
+* @param other - The iterator to take the product with.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<[T, U]>`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { cartesianProduct, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2].values(), cartesianProduct(['a', 'b'].values()), toArray());
+* // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+*/
+function cartesianProduct(other) {
+	return function cartesianProductInIterator(source) {
+		return require_cartesianProduct.cartesianProduct(source, other);
+	};
+}
+//#endregion
+exports.cartesianProduct = cartesianProduct;

package/node_modules/es-toolkit/dist/fp/iterator/cartesianProduct.mjs

@@ -0,0 +1,28 @@
+import { cartesianProduct as cartesianProduct$1 } from "../../iterator/cartesianProduct.mjs";
+//#region src/fp/iterator/cartesianProduct.ts
+/**
+* Creates a function that lazily takes the Cartesian product of the piped
+* iterator and `other`, for use with {@link pipe}. Every element of the piped
+* iterator is paired with every element of `other`, with `other` advancing
+* fastest. `other` is buffered into an array when iteration starts, while the
+* piped iterator is consumed lazily, so it may be infinite.
+*
+* @template T - The type of elements produced by the piped iterator.
+* @template U - The type of elements produced by `other`.
+* @param other - The iterator to take the product with.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<[T, U]>`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { cartesianProduct, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2].values(), cartesianProduct(['a', 'b'].values()), toArray());
+* // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+*/
+function cartesianProduct(other) {
+	return function cartesianProductInIterator(source) {
+		return cartesianProduct$1(source, other);
+	};
+}
+//#endregion
+export { cartesianProduct };

package/node_modules/es-toolkit/dist/fp/iterator/chunk.d.mts

@@ -0,0 +1,19 @@
+//#region src/fp/iterator/chunk.d.ts
+/**
+ * Creates a function that lazily groups the elements of an iterator into arrays
+ * of length `size`, for use with {@link pipe}. The final chunk may be shorter.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @param size - The length of each chunk; must be an integer greater than zero.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T[]>`.
+ * @throws {Error} Throws an error if `size` is not an integer greater than zero.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { chunk, toArray } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4, 5].values(), chunk(2), toArray()); // => [[1, 2], [3, 4], [5]]
+ */
+declare function chunk<T>(size: number): (source: Iterator<T>) => IteratorObject<T[], undefined>;
+//#endregion
+export { chunk };

package/node_modules/es-toolkit/dist/fp/iterator/chunk.d.ts

@@ -0,0 +1,19 @@
+//#region src/fp/iterator/chunk.d.ts
+/**
+ * Creates a function that lazily groups the elements of an iterator into arrays
+ * of length `size`, for use with {@link pipe}. The final chunk may be shorter.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @param size - The length of each chunk; must be an integer greater than zero.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T[]>`.
+ * @throws {Error} Throws an error if `size` is not an integer greater than zero.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { chunk, toArray } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4, 5].values(), chunk(2), toArray()); // => [[1, 2], [3, 4], [5]]
+ */
+declare function chunk<T>(size: number): (source: Iterator<T>) => IteratorObject<T[], undefined>;
+//#endregion
+export { chunk };

package/node_modules/es-toolkit/dist/fp/iterator/chunk.js

@@ -0,0 +1,24 @@
+const require_chunk = require("../../iterator/chunk.js");
+//#region src/fp/iterator/chunk.ts
+/**
+* Creates a function that lazily groups the elements of an iterator into arrays
+* of length `size`, for use with {@link pipe}. The final chunk may be shorter.
+*
+* @template T - The type of elements produced by the source iterator.
+* @param size - The length of each chunk; must be an integer greater than zero.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T[]>`.
+* @throws {Error} Throws an error if `size` is not an integer greater than zero.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { chunk, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3, 4, 5].values(), chunk(2), toArray()); // => [[1, 2], [3, 4], [5]]
+*/
+function chunk(size) {
+	return function chunkInIterator(source) {
+		return require_chunk.chunk(source, size);
+	};
+}
+//#endregion
+exports.chunk = chunk;

package/node_modules/es-toolkit/dist/fp/iterator/chunk.mjs

@@ -0,0 +1,24 @@
+import { chunk as chunk$1 } from "../../iterator/chunk.mjs";
+//#region src/fp/iterator/chunk.ts
+/**
+* Creates a function that lazily groups the elements of an iterator into arrays
+* of length `size`, for use with {@link pipe}. The final chunk may be shorter.
+*
+* @template T - The type of elements produced by the source iterator.
+* @param size - The length of each chunk; must be an integer greater than zero.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T[]>`.
+* @throws {Error} Throws an error if `size` is not an integer greater than zero.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { chunk, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3, 4, 5].values(), chunk(2), toArray()); // => [[1, 2], [3, 4], [5]]
+*/
+function chunk(size) {
+	return function chunkInIterator(source) {
+		return chunk$1(source, size);
+	};
+}
+//#endregion
+export { chunk };

package/node_modules/es-toolkit/dist/fp/iterator/count.d.mts

@@ -0,0 +1,20 @@
+//#region src/fp/iterator/count.d.ts
+/**
+ * Creates a function that consumes an iterator and returns the number of
+ * elements it produces, for use as the terminal step of a {@link pipe}.
+ *
+ * This is a terminal operation: it pulls every element, so it must not be used
+ * on an infinite iterator.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @returns A function mapping an `Iterator<T>` to its element count.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { filter, count } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4].values(), filter(x => x % 2 === 0), count()); // => 2
+ */
+declare function count<T>(): (source: Iterator<T>) => number;
+//#endregion
+export { count };

package/node_modules/es-toolkit/dist/fp/iterator/count.d.ts

@@ -0,0 +1,20 @@
+//#region src/fp/iterator/count.d.ts
+/**
+ * Creates a function that consumes an iterator and returns the number of
+ * elements it produces, for use as the terminal step of a {@link pipe}.
+ *
+ * This is a terminal operation: it pulls every element, so it must not be used
+ * on an infinite iterator.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @returns A function mapping an `Iterator<T>` to its element count.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { filter, count } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4].values(), filter(x => x % 2 === 0), count()); // => 2
+ */
+declare function count<T>(): (source: Iterator<T>) => number;
+//#endregion
+export { count };

package/node_modules/es-toolkit/dist/fp/iterator/count.js

@@ -0,0 +1,25 @@
+const require_count = require("../../iterator/count.js");
+//#region src/fp/iterator/count.ts
+/**
+* Creates a function that consumes an iterator and returns the number of
+* elements it produces, for use as the terminal step of a {@link pipe}.
+*
+* This is a terminal operation: it pulls every element, so it must not be used
+* on an infinite iterator.
+*
+* @template T - The type of elements produced by the source iterator.
+* @returns A function mapping an `Iterator<T>` to its element count.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { filter, count } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3, 4].values(), filter(x => x % 2 === 0), count()); // => 2
+*/
+function count() {
+	return function countInIterator(source) {
+		return require_count.count(source);
+	};
+}
+//#endregion
+exports.count = count;