@storm-software/esbuild 0.0.1 → 0.1.0

package/dist/chunk-YGD5JBOH.js

@@ -0,0 +1,337 @@
+import {
+  onErrorPlugin
+} from "./chunk-RKSGVSXZ.js";
+import {
+  resolvePathsPlugin
+} from "./chunk-4TW4ZA3I.js";
+import {
+  tscPlugin
+} from "./chunk-5JHKW6MG.js";
+import {
+  DEFAULT_BUILD_OPTIONS
+} from "./chunk-ELGZJRET.js";
+import {
+  depsCheckPlugin
+} from "./chunk-PCGRI6Z6.js";
+import {
+  writeLog
+} from "./chunk-YIAZ64WG.js";
+import {
+  fixImportsPlugin
+} from "./chunk-LVDPGHWK.js";
+import {
+  __name
+} from "./chunk-3GQAWCBQ.js";
+
+// src/build.ts
+import { hfs } from "@humanfs/node";
+import { createProjectGraphAsync, joinPathFragments, readJsonFile, readProjectsConfigurationFromProjectGraph, writeJsonFile } from "@nx/devkit";
+import { calculateProjectBuildableDependencies } from "@nx/js/src/utils/buildable-libs-utils";
+import { watch as createWatcher } from "chokidar";
+import { debounce, flatten, omit } from "es-toolkit";
+import { map } from "es-toolkit/compat";
+import * as esbuild from "esbuild";
+import { globbySync } from "globby";
+import { existsSync } from "node:fs";
+import { findWorkspaceRoot } from "nx/src/utils/find-workspace-root";
+
+// src/utilities/helpers.ts
+function handleSync(fn) {
+  try {
+    return fn();
+  } catch (error_) {
+    return error_;
+  }
+}
+__name(handleSync, "handleSync");
+async function handleAsync(fn) {
+  try {
+    return await fn();
+  } catch (error_) {
+    return error_;
+  }
+}
+__name(handleAsync, "handleAsync");
+var handle = handleSync;
+handle.async = handleAsync;
+var skip = Symbol("skip");
+function transduceSync(list, transformer) {
+  const transduced = [];
+  for (const [i, element_] of list.entries()) {
+    const transformed = transformer(element_, i);
+    if (transformed !== skip) {
+      transduced[transduced.length] = transformed;
+    }
+  }
+  return transduced;
+}
+__name(transduceSync, "transduceSync");
+async function transduceAsync(list, transformer) {
+  const transduced = [];
+  await Promise.all(list.entries().map(async ([i, element_]) => {
+    const transformed = await transformer(element_, i);
+    if (transformed !== skip) {
+      transduced[transduced.length] = transformed;
+    }
+  }));
+  return transduced;
+}
+__name(transduceAsync, "transduceAsync");
+var Filter = /* @__PURE__ */ __name((filter) => (item) => {
+  return filter(item) ? item : skip;
+}, "Filter");
+var Mapper = /* @__PURE__ */ __name((mapper) => (item) => {
+  return mapper(item);
+}, "Mapper");
+var transduce = transduceSync;
+transduce.async = transduceAsync;
+function pipeSync(fn, ...fns) {
+  return (...args) => {
+    let result = fn(...args);
+    for (let i = 0; result !== skip && i < fns.length; ++i) {
+      result = fns[i]?.(result);
+    }
+    return result;
+  };
+}
+__name(pipeSync, "pipeSync");
+function pipeAsync(fn, ...fns) {
+  return async (...args) => {
+    let result = await fn(...args);
+    for (let i = 0; result !== skip && i < fns.length; ++i) {
+      result = await fns[i]?.(result);
+    }
+    return result;
+  };
+}
+__name(pipeAsync, "pipeAsync");
+var pipe = pipeSync;
+pipe.async = pipeAsync;
+
+// src/build.ts
+var resolveOptions = /* @__PURE__ */ __name(async (options) => {
+  const projectRoot = options.projectRoot;
+  const workspaceRoot = findWorkspaceRoot(projectRoot);
+  if (!workspaceRoot) {
+    throw new Error("Cannot find Nx workspace root");
+  }
+  const nxJsonPath = joinPathFragments(workspaceRoot.dir, "nx.json");
+  if (!await hfs.isFile(nxJsonPath)) {
+    throw new Error("Cannot find Nx workspace configuration");
+  }
+  const projectGraph = await createProjectGraphAsync({
+    exitOnError: true
+  });
+  const projectJsonPath = joinPathFragments(workspaceRoot.dir, projectRoot, "project.json");
+  if (!await hfs.isFile(projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const projectJson = await hfs.json(projectJsonPath);
+  const projectName = projectJson.name;
+  const projectConfigurations = readProjectsConfigurationFromProjectGraph(projectGraph);
+  if (!projectConfigurations?.projects?.[projectName]) {
+    throw new Error("The Build process failed because the project does not have a valid configuration in the project.json file. Check if the file exists in the root of the project.");
+  }
+  return {
+    ...DEFAULT_BUILD_OPTIONS,
+    format: "cjs",
+    outExtension: {
+      ".js": ".js"
+    },
+    resolveExtensions: [
+      ".ts",
+      ".js",
+      ".node"
+    ],
+    entryPoints: globbySync("./src/**/*.{j,t}s", {
+      ignore: [
+        "./src/__tests__/**/*"
+      ]
+    }),
+    mainFields: [
+      "module",
+      "main"
+    ],
+    ...options,
+    outdir: options.outdir || joinPathFragments(workspaceRoot.dir, "dist", projectRoot),
+    plugins: [
+      ...options.plugins ?? [],
+      resolvePathsPlugin,
+      fixImportsPlugin,
+      tscPlugin(options.emitTypes),
+      onErrorPlugin
+    ],
+    external: [
+      ...options.external ?? []
+    ],
+    name: `${options.name || projectName}-${options.format || "cjs"}`,
+    projectConfigurations,
+    projectName,
+    projectGraph,
+    workspaceRoot
+  };
+}, "resolveOptions");
+var generatePackageJson = /* @__PURE__ */ __name(async (options) => {
+  const nxJsonPath = joinPathFragments(options.workspaceRoot.dir, "nx.json");
+  if (!await hfs.isFile(nxJsonPath)) {
+    throw new Error("Cannot find Nx workspace configuration");
+  }
+  const projectJsonPath = joinPathFragments(options.workspaceRoot.dir, options.projectRoot, "project.json");
+  if (!await hfs.isFile(projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  if (!options.projectConfigurations?.projects?.[options.projectName]) {
+    throw new Error("The Build process failed because the project does not have a valid configuration in the project.json file. Check if the file exists in the root of the project.");
+  }
+  const packageJsonPath = joinPathFragments(options.projectRoot, "project.json");
+  if (!await hfs.isFile(packageJsonPath)) {
+    throw new Error("Cannot find package.json configuration");
+  }
+  const packageJson = await hfs.json(joinPathFragments(options.workspaceRoot.dir, options.projectRoot, "package.json"));
+  const projectDependencies = calculateProjectBuildableDependencies(void 0, options.projectGraph, options.workspaceRoot.dir, options.projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  const localPackages = projectDependencies.dependencies.filter((dep) => dep.node.type === "lib" && dep.node.data.root !== options.projectRoot && dep.node.data.root !== options.workspaceRoot.dir).reduce((ret, project) => {
+    const projectNode = project.node;
+    if (projectNode.data.root) {
+      const projectPackageJsonPath = joinPathFragments(options.workspaceRoot.dir, projectNode.data.root, "package.json");
+      if (existsSync(projectPackageJsonPath)) {
+        const projectPackageJson = readJsonFile(projectPackageJsonPath);
+        if (projectPackageJson.private !== false) {
+          ret.push(projectPackageJson);
+        }
+      }
+    }
+    return ret;
+  }, []);
+  if (localPackages.length > 0) {
+    writeLog("trace", `\u{1F4E6}  Adding local packages to package.json: ${localPackages.map((p) => p.name).join(", ")}`);
+    packageJson.peerDependencies = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = `>=${localPackage.version || "0.0.1"}`;
+      }
+      return ret;
+    }, packageJson.peerDependencies ?? {});
+    packageJson.peerDependenciesMeta = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = {
+          optional: false
+        };
+      }
+      return ret;
+    }, packageJson.peerDependenciesMeta ?? {});
+    packageJson.devDependencies = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = localPackage.version || "0.0.1";
+      }
+      return ret;
+    }, packageJson.peerDependencies ?? {});
+  } else {
+    writeLog("trace", "\u{1F4E6}  No local packages dependencies to add to package.json");
+  }
+  packageJson.main = "./dist/index.cjs";
+  packageJson.module = "./dist/index.mjs";
+  packageJson.types = "./dist/index.d.ts";
+  await writeJsonFile(joinPathFragments(options.outdir, "package.json"), packageJson);
+  return options;
+}, "generatePackageJson");
+async function createOptions(options) {
+  return flatten(await Promise.all(map(options, (options2) => [
+    // we defer it so that we don't trigger glob immediately
+    () => resolveOptions(options2)
+  ])));
+}
+__name(createOptions, "createOptions");
+async function computeOptions(options) {
+  return options();
+}
+__name(computeOptions, "computeOptions");
+async function executeEsBuild(options) {
+  if (process.env.WATCH === "true") {
+    const context2 = await esbuild.context(omit(options, [
+      "name",
+      "emitTypes",
+      "emitMetafile"
+    ]));
+    watch(context2, options);
+  }
+  const build3 = await esbuild.build(omit(options, [
+    "name",
+    "emitTypes",
+    "emitMetafile"
+  ]));
+  if (build3.metafile && options.emitMetafile) {
+    const metafilePath = `${options.outdir}/${options.name}.meta.json`;
+    await hfs.write(metafilePath, JSON.stringify(build3.metafile));
+  }
+  return [
+    options,
+    build3
+  ];
+}
+__name(executeEsBuild, "executeEsBuild");
+async function dependencyCheck(options) {
+  if (process.env.DEV === "true") return void 0;
+  if (process.env.CI && !process.env.BUILDKITE) return void 0;
+  const buildPromise = esbuild.build({
+    entryPoints: globbySync("**/*.{j,t}s", {
+      // We don't check dependencies in ecosystem tests because tests are isolated from the build.
+      ignore: [
+        "./src/__tests__/**/*",
+        "./tests/e2e/**/*",
+        "./dist/**/*"
+      ],
+      gitignore: true
+    }),
+    logLevel: "silent",
+    bundle: true,
+    write: false,
+    outdir: "out",
+    plugins: [
+      depsCheckPlugin(options.bundle)
+    ]
+  });
+  await buildPromise.catch(() => {
+  });
+  return void 0;
+}
+__name(dependencyCheck, "dependencyCheck");
+async function build2(options) {
+  void transduce.async(options, dependencyCheck);
+  return transduce.async(await createOptions(options), pipe.async(computeOptions, generatePackageJson, executeEsBuild));
+}
+__name(build2, "build");
+var watch = /* @__PURE__ */ __name((context2, options) => {
+  if (process.env.WATCH !== "true") return context2;
+  const config = {
+    ignoreInitial: true,
+    useFsEvents: true,
+    ignored: [
+      "./src/__tests__/**/*",
+      "./package.json"
+    ]
+  };
+  const changeWatcher = createWatcher([
+    "./src/**/*"
+  ], config);
+  const fastRebuild = debounce(async () => {
+    const timeBefore = Date.now();
+    const rebuildResult = await handle.async(() => {
+      return context2.rebuild();
+    });
+    if (rebuildResult instanceof Error) {
+      writeLog("error", rebuildResult.message);
+    }
+    writeLog("log", `${Date.now() - timeBefore}ms [${options.name ?? ""}]`);
+  }, 10);
+  changeWatcher.on("change", fastRebuild);
+  return void 0;
+}, "watch");
+
+export {
+  handle,
+  skip,
+  Filter,
+  Mapper,
+  transduce,
+  pipe,
+  build2 as build
+};

package/dist/chunk-YIAZ64WG.js

@@ -0,0 +1,14 @@
+import {
+  __name
+} from "./chunk-3GQAWCBQ.js";
+
+// src/utilities/log.ts
+import { consola } from "consola";
+function writeLog(type, ...args) {
+  consola[type]("[Storm]", ...args);
+}
+__name(writeLog, "writeLog");
+
+export {
+  writeLog
+};

package/dist/config.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkNVGEXPTGcjs = require('./chunk-NVGEXPTG.cjs');
+require('./chunk-BGYQAVKQ.cjs');
+
+
+
+exports.DEFAULT_BUILD_OPTIONS = _chunkNVGEXPTGcjs.DEFAULT_BUILD_OPTIONS; exports.adapterConfig = _chunkNVGEXPTGcjs.adapterConfig;

package/dist/config.d.cts

@@ -0,0 +1,15 @@
+import { ESBuildOptions } from './types.cjs';
+import '@nx/devkit';
+import 'esbuild';
+import 'nx/src/utils/find-workspace-root';
+
+declare const DEFAULT_BUILD_OPTIONS: {
+    readonly platform: "node";
+    readonly target: "ES2021";
+    readonly logLevel: "error";
+    readonly tsconfig: "tsconfig.json";
+    readonly metafile: true;
+};
+declare const adapterConfig: Omit<ESBuildOptions, "projectRoot">[];
+
+export { DEFAULT_BUILD_OPTIONS, adapterConfig };

package/dist/config.d.ts

@@ -0,0 +1,15 @@
+import { ESBuildOptions } from './types.js';
+import '@nx/devkit';
+import 'esbuild';
+import 'nx/src/utils/find-workspace-root';
+
+declare const DEFAULT_BUILD_OPTIONS: {
+    readonly platform: "node";
+    readonly target: "ES2021";
+    readonly logLevel: "error";
+    readonly tsconfig: "tsconfig.json";
+    readonly metafile: true;
+};
+declare const adapterConfig: Omit<ESBuildOptions, "projectRoot">[];
+
+export { DEFAULT_BUILD_OPTIONS, adapterConfig };

package/dist/config.js

@@ -0,0 +1,9 @@
+import {
+  DEFAULT_BUILD_OPTIONS,
+  adapterConfig
+} from "./chunk-ELGZJRET.js";
+import "./chunk-3GQAWCBQ.js";
+export {
+  DEFAULT_BUILD_OPTIONS,
+  adapterConfig
+};

package/dist/index.cjs

@@ -0,0 +1,38 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+var _chunk5S2XTAF2cjs = require('./chunk-5S2XTAF2.cjs');
+require('./chunk-DCWECOOS.cjs');
+require('./chunk-WLHWKRZB.cjs');
+
+
+var _chunkA6CGWMV7cjs = require('./chunk-A6CGWMV7.cjs');
+
+
+
+var _chunkNVGEXPTGcjs = require('./chunk-NVGEXPTG.cjs');
+require('./chunk-SFZRYJZ2.cjs');
+require('./chunk-MTKAAECG.cjs');
+
+
+var _chunkRJQ3LCGJcjs = require('./chunk-RJQ3LCGJ.cjs');
+require('./chunk-3C3PXJUM.cjs');
+require('./chunk-BGYQAVKQ.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_BUILD_OPTIONS = _chunkNVGEXPTGcjs.DEFAULT_BUILD_OPTIONS; exports.Filter = _chunk5S2XTAF2cjs.Filter; exports.Mapper = _chunk5S2XTAF2cjs.Mapper; exports.adapterConfig = _chunkNVGEXPTGcjs.adapterConfig; exports.build = _chunk5S2XTAF2cjs.build; exports.handle = _chunk5S2XTAF2cjs.handle; exports.pipe = _chunk5S2XTAF2cjs.pipe; exports.run = _chunkA6CGWMV7cjs.run; exports.skip = _chunk5S2XTAF2cjs.skip; exports.transduce = _chunk5S2XTAF2cjs.transduce; exports.writeLog = _chunkRJQ3LCGJcjs.writeLog;

package/dist/index.d.cts

@@ -0,0 +1,230 @@
+export { build } from './build.cjs';
+export { DEFAULT_BUILD_OPTIONS, adapterConfig } from './config.cjs';
+export { ESBuildOptions, ESBuildResolvedOptions, ESBuildResult } from './types.cjs';
+import { LogType } from 'consola';
+import * as execa from 'execa';
+import 'esbuild';
+import '@nx/devkit';
+import 'nx/src/utils/find-workspace-root';
+
+declare function handleSync<R, E = Error>(fn: () => R): R | E;
+declare function handleAsync<R, E = Error>(fn: () => Promise<R> | R): Promise<R | E>;
+/**
+ * Executes a function, catches exceptions, and returns any outcome.
+ * @param fn - to be executed
+ */
+declare const handle: typeof handleSync & {
+    async: typeof handleAsync;
+};
+
+declare const skip: unique symbol;
+type SyncTransformer<I, R> = (item: I, key: number) => R | typeof skip;
+type ASyncTransformer<I, R> = (item: I, key: number) => Promise<R | typeof skip>;
+declare function transduceSync<I, R>(list: Array<I>, transformer: SyncTransformer<I, R>): R[];
+declare function transduceAsync<I, R>(list: Array<I>, transformer: ASyncTransformer<I, R>): Promise<R[]>;
+declare const Filter: <I>(filter: (item: I) => boolean) => (item: I) => I;
+declare const Mapper: <I, R>(mapper: (item: I) => R) => (item: I) => R;
+/**
+ * Transducers enable efficient data processing. They allow the composition of
+ * mappers and filters to be applied on a list. And this is applied in a single
+ * pass, that's the efficient pipeline processing.
+ *
+ * (does not reduce at the same time)
+ *
+ * @see https://medium.com/javascript-scene/7985330fe73d
+ *
+ * @param list - to transform
+ * @param transformer - to apply
+
+ * @example
+ * ```ts
+ * const filterEven = Filter(<U>(unit: U) =>
+ *   typeof unit === 'number' ? !(unit % 2) : true,
+ * )
+ * const mapTimes2 = Mapper(<U>(unit: U) =>
+ *   typeof unit === 'number' ? unit * 2 : unit,
+ * )
+ * const mapString = Mapper(<U>(unit: U) => `${unit}`)
+ *
+ * const test0 = transduce(
+ *   [1, 2, 3, 4, 5, 6, 7, 'a'],
+ *   pipe(filterEven, mapTimes2, mapTimes2, mapString, filterEven),
+ * )
+ * ```
+ */
+declare const transduce: typeof transduceSync & {
+    async: typeof transduceAsync;
+};
+
+type FunctionLike<P extends Array<any> = any, R = any> = (...args: P) => R;
+type Await<P> = P extends Promise<infer A> ? A : P;
+/**
+ * Pipe the input and output of functions.
+ *
+ * @param fn - parameter-taking function
+ * @param fns - subsequent piped functions
+ * @returns
+ */
+declare const pipe: PipeMultiSync & {
+    async: PipeMultiAsync;
+};
+declare type PipeMultiSync = {
+    <R0, P extends any[]>(...fns: [FunctionLike<P, R0>]): FunctionLike<P, R0>;
+    <R0, R1, P extends any[]>(...fns: [FunctionLike<P, R0>, FunctionLike<[R0], R1>]): FunctionLike<P, R1>;
+    <R0, R1, R2, P extends any[]>(...fns: [
+        FunctionLike<P, R0>,
+        FunctionLike<[R0], R1>,
+        FunctionLike<[R1], R2>
+    ]): FunctionLike<P, R2>;
+    <R0, R1, R2, R3, P extends any[]>(...fns: [
+        FunctionLike<P, R0>,
+        FunctionLike<[R0], R1>,
+        FunctionLike<[R1], R2>,
+        FunctionLike<[R2], R3>
+    ]): FunctionLike<P, R3>;
+    <R0, R1, R2, R3, R4, P extends any[]>(...fns: [
+        FunctionLike<P, R0>,
+        FunctionLike<[R0], R1>,
+        FunctionLike<[R1], R2>,
+        FunctionLike<[R2], R3>,
+        FunctionLike<[R3], R4>
+    ]): FunctionLike<P, R4>;
+    <R0, R1, R2, R3, R4, R5, P extends any[]>(...fns: [
+        FunctionLike<P, R0>,
+        FunctionLike<[R0], R1>,
+        FunctionLike<[R1], R2>,
+        FunctionLike<[R2], R3>,
+        FunctionLike<[R3], R4>,
+        FunctionLike<[R4], R5>
+    ]): FunctionLike<P, R5>;
+    <R0, R1, R2, R3, R4, R5, R6, P extends any[]>(...fns: [
+        FunctionLike<P, R0>,
+        FunctionLike<[R0], R1>,
+        FunctionLike<[R1], R2>,
+        FunctionLike<[R2], R3>,
+        FunctionLike<[R3], R4>,
+        FunctionLike<[R4], R5>,
+        FunctionLike<[R5], R6>
+    ]): FunctionLike<P, R6>;
+    <R0, R1, R2, R3, R4, R5, R6, R7, P extends any[]>(...fns: [
+        FunctionLike<P, R0>,
+        FunctionLike<[R0], R1>,
+        FunctionLike<[R1], R2>,
+        FunctionLike<[R2], R3>,
+        FunctionLike<[R3], R4>,
+        FunctionLike<[R4], R5>,
+        FunctionLike<[R5], R6>,
+        FunctionLike<[R6], R7>
+    ]): FunctionLike<P, R7>;
+    <R0, R1, R2, R3, R4, R5, R6, R7, R8, P extends any[]>(...fns: [
+        FunctionLike<P, R0>,
+        FunctionLike<[R0], R1>,
+        FunctionLike<[R1], R2>,
+        FunctionLike<[R2], R3>,
+        FunctionLike<[R3], R4>,
+        FunctionLike<[R4], R5>,
+        FunctionLike<[R5], R6>,
+        FunctionLike<[R6], R7>,
+        FunctionLike<[R7], R8>
+    ]): FunctionLike<P, R8>;
+    <R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, P extends any[]>(...fns: [
+        FunctionLike<P, R0>,
+        FunctionLike<[R0], R1>,
+        FunctionLike<[R1], R2>,
+        FunctionLike<[R2], R3>,
+        FunctionLike<[R3], R4>,
+        FunctionLike<[R4], R5>,
+        FunctionLike<[R5], R6>,
+        FunctionLike<[R6], R7>,
+        FunctionLike<[R7], R8>,
+        FunctionLike<[R8], R9>
+    ]): FunctionLike<P, R9>;
+};
+declare type PipeMultiAsync = {
+    <R0, P extends any[]>(...fns: [FunctionLike<P, R0>]): FunctionLike<P, Promise<Await<R0>>>;
+    <R0, R1, P extends any[]>(...fns: [FunctionLike<P, R0>, FunctionLike<[Await<R0>], R1>]): FunctionLike<P, Promise<Await<R1>>>;
+    <R0, R1, R2, P extends any[]>(...fns: [
+        FunctionLike<P, R0>,
+        FunctionLike<[Await<R0>], R1>,
+        FunctionLike<[Await<R1>], R2>
+    ]): FunctionLike<P, Promise<Await<R2>>>;
+    <R0, R1, R2, R3, P extends any[]>(...fns: [
+        FunctionLike<P, R0>,
+        FunctionLike<[Await<R0>], R1>,
+        FunctionLike<[Await<R1>], R2>,
+        FunctionLike<[Await<R2>], R3>
+    ]): FunctionLike<P, Promise<Await<R3>>>;
+    <R0, R1, R2, R3, R4, P extends any[]>(...fns: [
+        FunctionLike<P, R0>,
+        FunctionLike<[Await<R0>], R1>,
+        FunctionLike<[Await<R1>], R2>,
+        FunctionLike<[Await<R2>], R3>,
+        FunctionLike<[Await<R3>], R4>
+    ]): FunctionLike<P, Promise<Await<R4>>>;
+    <R0, R1, R2, R3, R4, R5, P extends any[]>(...fns: [
+        FunctionLike<P, R0>,
+        FunctionLike<[Await<R0>], R1>,
+        FunctionLike<[Await<R1>], R2>,
+        FunctionLike<[Await<R2>], R3>,
+        FunctionLike<[Await<R3>], R4>,
+        FunctionLike<[Await<R4>], R5>
+    ]): FunctionLike<P, Promise<Await<R5>>>;
+    <R0, R1, R2, R3, R4, R5, R6, P extends any[]>(...fns: [
+        FunctionLike<P, R0>,
+        FunctionLike<[Await<R0>], R1>,
+        FunctionLike<[Await<R1>], R2>,
+        FunctionLike<[Await<R2>], R3>,
+        FunctionLike<[Await<R3>], R4>,
+        FunctionLike<[Await<R4>], R5>,
+        FunctionLike<[Await<R5>], R6>
+    ]): FunctionLike<P, Promise<Await<R6>>>;
+    <R0, R1, R2, R3, R4, R5, R6, R7, P extends any[]>(...fns: [
+        FunctionLike<P, R0>,
+        FunctionLike<[Await<R0>], R1>,
+        FunctionLike<[Await<R1>], R2>,
+        FunctionLike<[Await<R2>], R3>,
+        FunctionLike<[Await<R3>], R4>,
+        FunctionLike<[Await<R4>], R5>,
+        FunctionLike<[Await<R5>], R6>,
+        FunctionLike<[Await<R6>], R7>
+    ]): FunctionLike<P, Promise<Await<R7>>>;
+    <R0, R1, R2, R3, R4, R5, R6, R7, R8, P extends any[]>(...fns: [
+        FunctionLike<P, R0>,
+        FunctionLike<[Await<R0>], R1>,
+        FunctionLike<[Await<R1>], R2>,
+        FunctionLike<[Await<R2>], R3>,
+        FunctionLike<[Await<R3>], R4>,
+        FunctionLike<[Await<R4>], R5>,
+        FunctionLike<[Await<R5>], R6>,
+        FunctionLike<[Await<R6>], R7>,
+        FunctionLike<[Await<R7>], R8>
+    ]): FunctionLike<P, Promise<Await<R8>>>;
+    <R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, P extends any[]>(...fns: [
+        FunctionLike<P, R0>,
+        FunctionLike<[Await<R0>], R1>,
+        FunctionLike<[Await<R1>], R2>,
+        FunctionLike<[Await<R2>], R3>,
+        FunctionLike<[Await<R3>], R4>,
+        FunctionLike<[Await<R4>], R5>,
+        FunctionLike<[Await<R5>], R6>,
+        FunctionLike<[Await<R6>], R7>,
+        FunctionLike<[Await<R7>], R8>,
+        FunctionLike<[Await<R8>], R9>
+    ]): FunctionLike<P, Promise<Await<R9>>>;
+};
+
+/**
+ * Writes a log message to the console.
+ *
+ * @param type - The type of log message.
+ * @param args - The arguments to log.
+ */
+declare function writeLog(type: LogType, ...args: string[]): void;
+
+declare function run(command: string): execa.ResultPromise<{
+    preferLocal: true;
+    shell: true;
+    stdio: "inherit";
+}>;
+
+export { Filter, Mapper, type PipeMultiAsync, type PipeMultiSync, handle, pipe, run, skip, transduce, writeLog };