@quantiya/codevibe-claude-plugin 2.0.12 → 2.0.14

package/node_modules/node-abi/abi_registry.json

@@ -449,12 +449,5 @@
     "lts": false,
     "runtime": "electron",
     "target": "44.0.0-alpha.1"
-  },
-  {
-    "abi": "150",
-    "future": true,
-    "lts": false,
-    "runtime": "electron",
-    "target": "45.0.0-alpha.1"
   }
 ]

package/node_modules/node-abi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-abi",
-  "version": "3.96.0",
+  "version": "3.95.0",
   "description": "Get the Node ABI for a given target and runtime, and vice versa.",
   "main": "index.js",
   "scripts": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-claude-plugin",
-  "version": "2.0.12",
+  "version": "2.0.14",
   "description": "Control Claude Code from your iPhone and Android — real-time sync, approve file edits, send prompts by voice. Part of CodeVibe.",
   "main": "dist/server.js",
   "codevibe": {
@@ -47,7 +47,7 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@quantiya/codevibe-core": "2.0.11",
+    "@quantiya/codevibe-core": "2.0.12",
     "@quantiya/quorum-core": "^1.0.1",
     "dotenv": "^16.6.1",
     "express": "^5.1.0",

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

@@ -1,213 +0,0 @@
-//#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.d.ts

@@ -1,213 +0,0 @@
-//#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

@@ -1,37 +0,0 @@
-//#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

@@ -1,37 +0,0 @@
-//#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/iterator/cartesianProduct.d.mts

@@ -1,23 +0,0 @@
-//#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

@@ -1,23 +0,0 @@
-//#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

@@ -1,28 +0,0 @@
-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;