@storm-software/esbuild 0.4.1 → 0.14.2

package/dist/esbuild.cjs

@@ -0,0 +1,1185 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// bin/esbuild.ts
+var import_create_storm_config2 = require("@storm-software/config-tools/create-storm-config");
+var import_console3 = require("@storm-software/config-tools/logger/console");
+var import_find_workspace_root2 = require("@storm-software/config-tools/utilities/find-workspace-root");
+var import_process_handler = require("@storm-software/config-tools/utilities/process-handler");
+var import_commander = require("commander");
+
+// src/build.ts
+var import_node3 = require("@humanfs/node");
+var import_devkit = require("@nx/devkit");
+var import_build_tools = require("@storm-software/build-tools");
+var import_create_storm_config = require("@storm-software/config-tools/create-storm-config");
+var import_console2 = require("@storm-software/config-tools/logger/console");
+var import_get_log_level = require("@storm-software/config-tools/logger/get-log-level");
+var import_correct_paths2 = require("@storm-software/config-tools/utilities/correct-paths");
+var import_chokidar = require("chokidar");
+
+// ../../node_modules/.pnpm/defu@6.1.4/node_modules/defu/dist/defu.mjs
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+__name(isPlainObject, "isPlainObject");
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isPlainObject(value) && isPlainObject(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+__name(_defu, "_defu");
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
+  );
+}
+__name(createDefu, "createDefu");
+var defu = createDefu();
+var defuFn = createDefu((object, key, currentValue) => {
+  if (object[key] !== void 0 && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+var defuArrayFn = createDefu((object, key, currentValue) => {
+  if (Array.isArray(object[key]) && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+
+// src/build.ts
+var import_es_toolkit = require("es-toolkit");
+var import_compat = require("es-toolkit/compat");
+var esbuild2 = __toESM(require("esbuild"), 1);
+var import_globby = require("globby");
+var import_find_workspace_root = require("nx/src/utils/find-workspace-root");
+
+// src/base/renderer-engine.ts
+var import_node_path2 = __toESM(require("path"), 1);
+var import_source_map = require("source-map");
+
+// src/utilities/output-file.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var outputFile = /* @__PURE__ */ __name(async (filepath, data, options) => {
+  await import_node_fs.default.promises.mkdir(import_node_path.default.dirname(filepath), {
+    recursive: true
+  });
+  await import_node_fs.default.promises.writeFile(filepath, data, options);
+}, "outputFile");
+
+// src/base/renderer-engine.ts
+var parseSourceMap = /* @__PURE__ */ __name((map2) => {
+  return typeof map2 === "string" ? JSON.parse(map2) : map2;
+}, "parseSourceMap");
+var isJS = /* @__PURE__ */ __name((path5) => /\.(js|mjs|cjs)$/.test(path5), "isJS");
+var isCSS = /* @__PURE__ */ __name((path5) => /\.css$/.test(path5), "isCSS");
+var getSourcemapComment = /* @__PURE__ */ __name((inline, map2, filepath, isCssFile) => {
+  if (!map2) return "";
+  const prefix = isCssFile ? "/*" : "//";
+  const suffix = isCssFile ? " */" : "";
+  const url = inline ? `data:application/json;base64,${Buffer.from(typeof map2 === "string" ? map2 : JSON.stringify(map2)).toString("base64")}` : `${import_node_path2.default.basename(filepath)}.map`;
+  return `${prefix}# sourceMappingURL=${url}${suffix}`;
+}, "getSourcemapComment");
+var RendererEngine = class {
+  static {
+    __name(this, "RendererEngine");
+  }
+  #renderers;
+  #options;
+  constructor(renderers) {
+    this.#renderers = renderers;
+  }
+  setOptions(options) {
+    this.#options = options;
+  }
+  getOptions() {
+    if (!this.#options) {
+      throw new Error(`Renderer options is not set`);
+    }
+    return this.#options;
+  }
+  modifyEsbuildOptions(options) {
+    for (const renderer of this.#renderers) {
+      if (renderer.esbuildOptions) {
+        renderer.esbuildOptions.call(this.getOptions(), options);
+      }
+    }
+  }
+  async buildStarted() {
+    for (const renderer of this.#renderers) {
+      if (renderer.buildStart) {
+        await renderer.buildStart.call(this.getOptions());
+      }
+    }
+  }
+  async buildFinished({ outputFiles, metafile }) {
+    const files = outputFiles.filter((file) => !file.path.endsWith(".map")).map((file) => {
+      if (isJS(file.path) || isCSS(file.path)) {
+        let relativePath = import_node_path2.default.relative(this.getOptions().config.workspaceRoot, file.path);
+        if (!relativePath.startsWith("\\\\?\\")) {
+          relativePath = relativePath.replace(/\\/g, "/");
+        }
+        const meta = metafile?.outputs[relativePath];
+        return {
+          type: "chunk",
+          path: file.path,
+          code: file.text,
+          map: outputFiles.find((f) => f.path === `${file.path}.map`)?.text,
+          entryPoint: meta?.entryPoint,
+          exports: meta?.exports,
+          imports: meta?.imports
+        };
+      } else {
+        return {
+          type: "asset",
+          path: file.path,
+          contents: file.contents
+        };
+      }
+    });
+    const writtenFiles = [];
+    await Promise.all(files.map(async (info) => {
+      for (const renderer of this.#renderers) {
+        if (info.type === "chunk" && renderer.renderChunk) {
+          const result = await renderer.renderChunk.call(this.getOptions(), info.code, info);
+          if (result) {
+            info.code = result.code;
+            if (result.map) {
+              const originalConsumer = await new import_source_map.SourceMapConsumer(parseSourceMap(info.map));
+              const newConsumer = await new import_source_map.SourceMapConsumer(parseSourceMap(result.map));
+              const generator = import_source_map.SourceMapGenerator.fromSourceMap(newConsumer);
+              generator.applySourceMap(originalConsumer, info.path);
+              info.map = generator.toJSON();
+              originalConsumer.destroy();
+              newConsumer.destroy();
+            }
+          }
+        }
+      }
+      const inlineSourceMap = this.#options.sourcemap === "inline";
+      const contents = info.type === "chunk" ? info.code + getSourcemapComment(inlineSourceMap, info.map, info.path, isCSS(info.path)) : info.contents;
+      await outputFile(info.path, contents, {
+        mode: info.type === "chunk" ? info.mode : void 0
+      });
+      writtenFiles.push({
+        get name() {
+          return import_node_path2.default.relative(process.cwd(), info.path);
+        },
+        get size() {
+          return contents.length;
+        }
+      });
+      if (info.type === "chunk" && info.map && !inlineSourceMap) {
+        const map2 = typeof info.map === "string" ? JSON.parse(info.map) : info.map;
+        const outPath = `${info.path}.map`;
+        const contents2 = JSON.stringify(map2);
+        await outputFile(outPath, contents2);
+        writtenFiles.push({
+          get name() {
+            return import_node_path2.default.relative(process.cwd(), outPath);
+          },
+          get size() {
+            return contents2.length;
+          }
+        });
+      }
+    }));
+    for (const renderer of this.#renderers) {
+      if (renderer.buildEnd) {
+        await renderer.buildEnd.call(this.getOptions(), {
+          writtenFiles
+        });
+      }
+    }
+  }
+};
+
+// src/clean.ts
+var import_node = require("@humanfs/node");
+var import_console = require("@storm-software/config-tools/logger/console");
+async function clean(name = "ESBuild", directory, config) {
+  (0, import_console.writeDebug)(` \u{1F9F9}  Cleaning ${name} output path: ${directory}`, config);
+  const stopwatch = (0, import_console.getStopwatch)(`${name} output clean`);
+  await import_node.hfs.deleteAll(directory);
+  stopwatch();
+}
+__name(clean, "clean");
+
+// src/config.ts
+var import_get_out_extension = require("@storm-software/build-tools/utilities/get-out-extension");
+
+// src/plugins/esm-split-code-to-cjs.ts
+var esbuild = __toESM(require("esbuild"), 1);
+var esmSplitCodeToCjsPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => ({
+  name: "storm:esm-split-code-to-cjs",
+  setup(build4) {
+    build4.onEnd(async (result) => {
+      const outFiles = Object.keys(result.metafile?.outputs ?? {});
+      const jsFiles = outFiles.filter((f) => f.endsWith("js"));
+      await esbuild.build({
+        outdir: resolvedOptions.outdir,
+        entryPoints: jsFiles,
+        allowOverwrite: true,
+        format: "cjs",
+        logLevel: "error",
+        packages: "external"
+      });
+    });
+  }
+}), "esmSplitCodeToCjsPlugin");
+
+// src/plugins/fix-imports.ts
+var fixImportsPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => ({
+  name: "storm:fix-imports",
+  setup(build4) {
+    build4.onResolve({
+      filter: /^spdx-exceptions/
+    }, () => {
+      return {
+        path: require.resolve("spdx-exceptions")
+      };
+    });
+    build4.onResolve({
+      filter: /^spdx-license-ids/
+    }, () => {
+      return {
+        path: require.resolve("spdx-license-ids")
+      };
+    });
+  }
+}), "fixImportsPlugin");
+
+// src/plugins/native-node-module.ts
+var import_node_path3 = require("path");
+var nativeNodeModulesPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => {
+  return {
+    name: "native-node-modules",
+    setup(build4) {
+      build4.onResolve({
+        filter: /\.node$/,
+        namespace: "file"
+      }, (args) => {
+        const resolvedId = require.resolve(args.path, {
+          paths: [
+            args.resolveDir
+          ]
+        });
+        if (resolvedId.endsWith(".node")) {
+          return {
+            path: resolvedId,
+            namespace: "node-file"
+          };
+        }
+        return {
+          path: resolvedId
+        };
+      });
+      build4.onLoad({
+        filter: /.*/,
+        namespace: "node-file"
+      }, (args) => {
+        return {
+          contents: `
+            import path from ${JSON.stringify(args.path)}
+            try { module.exports = require(path) }
+            catch {}
+          `,
+          resolveDir: (0, import_node_path3.dirname)(args.path)
+        };
+      });
+      build4.onResolve({
+        filter: /\.node$/,
+        namespace: "node-file"
+      }, (args) => ({
+        path: args.path,
+        namespace: "file"
+      }));
+      const opts = build4.initialOptions;
+      opts.loader = opts.loader || {};
+      opts.loader[".node"] = "file";
+    }
+  };
+}, "nativeNodeModulesPlugin");
+
+// src/plugins/node-protocol.ts
+var nodeProtocolPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => {
+  const nodeProtocol = "node:";
+  return {
+    name: "node-protocol-plugin",
+    setup({ onResolve }) {
+      onResolve({
+        filter: /^node:/
+      }, ({ path: path5 }) => ({
+        path: path5.slice(nodeProtocol.length),
+        external: true
+      }));
+    }
+  };
+}, "nodeProtocolPlugin");
+
+// src/plugins/on-error.ts
+var import_config_tools = require("@storm-software/config-tools");
+var onErrorPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => ({
+  name: "storm:on-error",
+  setup(build4) {
+    build4.onEnd((result) => {
+      if (result.errors.length > 0 && process.env.WATCH !== "true") {
+        (0, import_config_tools.writeError)(`The following errors occurred during the build:
+${result.errors.map((error) => error.text).join("\n")}
+
+`, resolvedOptions.config);
+        throw new Error("Storm esbuild process failed with errors.");
+      }
+    });
+  }
+}), "onErrorPlugin");
+
+// src/plugins/resolve-paths.ts
+var import_correct_paths = require("@storm-software/config-tools/utilities/correct-paths");
+var import_node_path4 = __toESM(require("path"), 1);
+function resolvePathsConfig(options, cwd) {
+  if (options?.compilerOptions?.paths) {
+    const paths = Object.entries(options.compilerOptions.paths);
+    const resolvedPaths = paths.map(([key, paths2]) => {
+      return [
+        key,
+        paths2.map((v) => import_node_path4.default.resolve(cwd, v))
+      ];
+    });
+    return Object.fromEntries(resolvedPaths);
+  }
+  if (options.extends) {
+    const extendsPath = import_node_path4.default.resolve(cwd, options.extends);
+    const extendsDir = import_node_path4.default.dirname(extendsPath);
+    const extendsConfig = require(extendsPath);
+    return resolvePathsConfig(extendsConfig, extendsDir);
+  }
+  return [];
+}
+__name(resolvePathsConfig, "resolvePathsConfig");
+var resolvePathsPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => ({
+  name: "storm:resolve-paths",
+  setup(build4) {
+    const parentTsConfig = build4.initialOptions.tsconfig ? require((0, import_correct_paths.joinPaths)(resolvedOptions.config.workspaceRoot, build4.initialOptions.tsconfig)) : require((0, import_correct_paths.joinPaths)(resolvedOptions.config.workspaceRoot, "tsconfig.json"));
+    const resolvedTsPaths = resolvePathsConfig(parentTsConfig, options.projectRoot);
+    const packagesRegex = new RegExp(`^(${Object.keys(resolvedTsPaths).join("|")})$`);
+    build4.onResolve({
+      filter: packagesRegex
+    }, (args) => {
+      if (build4.initialOptions.external?.includes(args.path)) {
+        return {
+          path: args.path,
+          external: true
+        };
+      }
+      return {
+        path: `${resolvedTsPaths[args.path][0]}/index.ts`
+      };
+    });
+  }
+}), "resolvePathsPlugin");
+
+// src/plugins/tsc.ts
+var import_node2 = require("@humanfs/node");
+var import_api_extractor = require("@microsoft/api-extractor");
+var import_config_tools2 = require("@storm-software/config-tools");
+function bundleTypeDefinitions(filename, outfile, externals, options) {
+  const { dependencies, peerDependencies, devDependencies } = require((0, import_config_tools2.joinPaths)(options.projectRoot, "package.json"));
+  const dependenciesKeys = Object.keys(dependencies ?? {}).flatMap((p) => [
+    p,
+    getTypeDependencyPackageName(p)
+  ]);
+  const peerDependenciesKeys = Object.keys(peerDependencies ?? {}).flatMap((p) => [
+    p,
+    getTypeDependencyPackageName(p)
+  ]);
+  const devDependenciesKeys = Object.keys(devDependencies ?? {}).flatMap((p) => [
+    p,
+    getTypeDependencyPackageName(p)
+  ]);
+  const includeDeps = devDependenciesKeys;
+  const excludeDeps = /* @__PURE__ */ new Set([
+    ...dependenciesKeys,
+    ...peerDependenciesKeys,
+    ...externals
+  ]);
+  const bundledPackages = includeDeps.filter((dep) => !excludeDeps.has(dep));
+  const extractorConfig = import_api_extractor.ExtractorConfig.prepare({
+    configObject: {
+      projectFolder: options.projectRoot,
+      mainEntryPointFilePath: filename,
+      bundledPackages,
+      compiler: {
+        tsconfigFilePath: options.tsconfig,
+        overrideTsconfig: {
+          compilerOptions: {
+            paths: {}
+            // bug with api extract + paths
+          }
+        }
+      },
+      dtsRollup: {
+        enabled: true,
+        untrimmedFilePath: (0, import_config_tools2.joinPaths)(options.outdir, `${outfile}.d.ts`)
+      },
+      tsdocMetadata: {
+        enabled: false
+      }
+    },
+    packageJsonFullPath: (0, import_config_tools2.joinPaths)(options.projectRoot, "package.json"),
+    configObjectFullPath: void 0
+  });
+  const extractorResult = import_api_extractor.Extractor.invoke(extractorConfig, {
+    showVerboseMessages: true,
+    localBuild: true
+  });
+  if (extractorResult.succeeded === false) {
+    (0, import_config_tools2.writeError)(`API Extractor completed with ${extractorResult.errorCount} ${extractorResult.errorCount === 1 ? "error" : "errors"}`);
+    throw new Error("API Extractor completed with errors");
+  }
+}
+__name(bundleTypeDefinitions, "bundleTypeDefinitions");
+var tscPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => ({
+  name: "storm:tsc",
+  setup(build4) {
+    if (options.emitTypes === false) {
+      return;
+    }
+    build4.onStart(async () => {
+      if (process.env.WATCH !== "true" && process.env.DEV !== "true") {
+        await (0, import_config_tools2.run)(resolvedOptions.config, `pnpm exec tsc --project ${resolvedOptions.tsconfig}`, resolvedOptions.config.workspaceRoot);
+      }
+      if (resolvedOptions.bundle && resolvedOptions.entryPoints && resolvedOptions.entryPoints.length > 0 && resolvedOptions.entryPoints[0] && resolvedOptions.entryPoints[0].endsWith(".ts")) {
+        const sourceRoot = resolvedOptions.sourceRoot.replaceAll(resolvedOptions.projectRoot, "");
+        const typeOutDir = resolvedOptions.outdir;
+        const entryPoint = resolvedOptions.entryPoints[0].replace(sourceRoot, "").replace(/\.ts$/, "");
+        const bundlePath = (0, import_config_tools2.joinPaths)(resolvedOptions.outdir, entryPoint);
+        let dtsPath;
+        if (await import_node2.hfs.isFile((0, import_config_tools2.joinPaths)(resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint}.d.ts`))) {
+          dtsPath = (0, import_config_tools2.joinPaths)(resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint}.d.ts`);
+        } else if (await import_node2.hfs.isFile((0, import_config_tools2.joinPaths)(resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint.replace(/^src\//, "")}.d.ts`))) {
+          dtsPath = (0, import_config_tools2.joinPaths)(resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint.replace(/^src\//, "")}.d.ts`);
+        }
+        const ext = resolvedOptions.outExtension.dts || resolvedOptions.format === "esm" ? "d.mts" : "d.ts";
+        if (process.env.WATCH !== "true" && process.env.DEV !== "true") {
+          bundleTypeDefinitions(dtsPath, bundlePath, resolvedOptions.external ?? [], resolvedOptions);
+          const dtsContents = await import_node2.hfs.text(`${bundlePath}.d.ts`);
+          await import_node2.hfs.write(`${bundlePath}.${ext}`, dtsContents);
+        } else {
+          await import_node2.hfs.write(`${bundlePath}.${ext}`, `export * from './${entryPoint}'`);
+        }
+      }
+    });
+  }
+}), "tscPlugin");
+function getTypeDependencyPackageName(npmPackage) {
+  if (npmPackage.startsWith("@")) {
+    const [scope, name] = npmPackage.split("/");
+    return `@types/${scope?.slice(1)}__${name}`;
+  }
+  return `@types/${npmPackage}`;
+}
+__name(getTypeDependencyPackageName, "getTypeDependencyPackageName");
+
+// src/config.ts
+var getOutputExtensionMap = /* @__PURE__ */ __name((options, pkgType) => {
+  return options.outExtension ? options.outExtension(options.format, pkgType) : (0, import_get_out_extension.getOutExtension)(options.format, pkgType);
+}, "getOutputExtensionMap");
+var getDefaultBuildPlugins = /* @__PURE__ */ __name((options, resolvedOptions) => [
+  nodeProtocolPlugin(options, resolvedOptions),
+  resolvePathsPlugin(options, resolvedOptions),
+  fixImportsPlugin(options, resolvedOptions),
+  nativeNodeModulesPlugin(options, resolvedOptions),
+  esmSplitCodeToCjsPlugin(options, resolvedOptions),
+  tscPlugin(options, resolvedOptions),
+  onErrorPlugin(options, resolvedOptions)
+], "getDefaultBuildPlugins");
+var DEFAULT_BUILD_OPTIONS = {
+  platform: "node",
+  target: "node22",
+  format: "cjs",
+  external: [],
+  logLevel: "error",
+  tsconfig: "tsconfig.json",
+  environment: "production",
+  keepNames: true,
+  metafile: true,
+  injectShims: true,
+  color: true,
+  watch: false,
+  bundle: true,
+  clean: true,
+  debug: false,
+  loader: {
+    ".aac": "file",
+    ".css": "file",
+    ".eot": "file",
+    ".flac": "file",
+    ".gif": "file",
+    ".jpeg": "file",
+    ".jpg": "file",
+    ".mp3": "file",
+    ".mp4": "file",
+    ".ogg": "file",
+    ".otf": "file",
+    ".png": "file",
+    ".svg": "file",
+    ".ttf": "file",
+    ".wav": "file",
+    ".webm": "file",
+    ".webp": "file",
+    ".woff": "file",
+    ".woff2": "file"
+  },
+  banner: import_get_out_extension.DEFAULT_COMPILED_BANNER
+};
+
+// src/plugins/deps-check.ts
+var import_config_tools3 = require("@storm-software/config-tools");
+var import_node_module = require("module");
+var import_node_path5 = __toESM(require("path"), 1);
+var unusedIgnore = [
+  // these are our dev dependencies
+  /@types\/.*?/,
+  /@typescript-eslint.*?/,
+  /eslint.*?/,
+  "esbuild",
+  "husky",
+  "is-ci",
+  "lint-staged",
+  "prettier",
+  "typescript",
+  "ts-node",
+  "ts-jest",
+  "@swc/core",
+  "@swc/jest",
+  "jest",
+  // these are missing 3rd party deps
+  "spdx-exceptions",
+  "spdx-license-ids",
+  // type-only, so it is not detected
+  "ts-toolbelt",
+  // these are indirectly used by build
+  "buffer"
+];
+var missingIgnore = [
+  ".prisma",
+  "@prisma/client",
+  "ts-toolbelt"
+];
+var depsCheckPlugin = /* @__PURE__ */ __name((bundle) => ({
+  name: "storm:deps-check",
+  setup(build4) {
+    const pkgJsonPath = import_node_path5.default.join(process.cwd(), "package.json");
+    const pkgContents = require(pkgJsonPath);
+    const regDependencies = Object.keys(pkgContents["dependencies"] ?? {});
+    const devDependencies = Object.keys(pkgContents["devDependencies"] ?? {});
+    const peerDependencies = Object.keys(pkgContents["peerDependencies"] ?? {});
+    const dependencies = [
+      ...regDependencies,
+      ...bundle ? devDependencies : []
+    ];
+    const collectedDependencies = /* @__PURE__ */ new Set();
+    const onlyPackages = /^[^./](?!:)|^\.[^./]|^\.\.[^/]/;
+    build4.onResolve({
+      filter: onlyPackages
+    }, (args) => {
+      if (args.importer.includes(process.cwd())) {
+        if (args.path[0] === "@") {
+          const [org, pkg] = args.path.split("/");
+          collectedDependencies.add(`${org}/${pkg}`);
+        } else {
+          const [pkg] = args.path.split("/");
+          collectedDependencies.add(pkg);
+        }
+      }
+      return {
+        external: true
+      };
+    });
+    build4.onEnd(() => {
+      const unusedDependencies = [
+        ...dependencies
+      ].filter((dep) => {
+        return !collectedDependencies.has(dep) || import_node_module.builtinModules.includes(dep);
+      });
+      const missingDependencies = [
+        ...collectedDependencies
+      ].filter((dep) => {
+        return !dependencies.includes(dep) && !import_node_module.builtinModules.includes(dep);
+      });
+      const filteredUnusedDeps = unusedDependencies.filter((dep) => {
+        return !unusedIgnore.some((pattern) => dep.match(pattern));
+      });
+      const filteredMissingDeps = missingDependencies.filter((dep) => {
+        return !missingIgnore.some((pattern) => dep.match(pattern)) && !peerDependencies.includes(dep);
+      });
+      (0, import_config_tools3.writeWarning)(`Unused Dependencies: ${JSON.stringify(filteredUnusedDeps)}`);
+      (0, import_config_tools3.writeError)(`Missing Dependencies: ${JSON.stringify(filteredMissingDeps)}`);
+      if (filteredMissingDeps.length > 0) {
+        throw new Error(`Missing dependencies detected - please install them:
+${JSON.stringify(filteredMissingDeps)}
+`);
+      }
+    });
+  }
+}), "depsCheckPlugin");
+
+// src/renderers/shebang.ts
+var shebangRenderer = {
+  name: "shebang",
+  renderChunk(_, __, info) {
+    if (info.type === "chunk" && /\.(cjs|js|mjs)$/.test(info.path) && info.code.startsWith("#!")) {
+      info.mode = 493;
+    }
+  }
+};
+
+// 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 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 (userOptions) => {
+  const projectRoot = userOptions.projectRoot;
+  const workspaceRoot = (0, import_find_workspace_root.findWorkspaceRoot)(projectRoot);
+  if (!workspaceRoot) {
+    throw new Error("Cannot find Nx workspace root");
+  }
+  const config = await (0, import_create_storm_config.loadStormConfig)(workspaceRoot.dir);
+  (0, import_console2.writeDebug)("  \u2699\uFE0F   Resolving build options", config);
+  const stopwatch = (0, import_console2.getStopwatch)("Build options resolution");
+  const projectGraph = await (0, import_devkit.createProjectGraphAsync)({
+    exitOnError: true
+  });
+  const projectJsonPath = (0, import_correct_paths2.joinPaths)(workspaceRoot.dir, projectRoot, "project.json");
+  if (!await import_node3.hfs.isFile(projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const projectJson = await import_node3.hfs.json(projectJsonPath);
+  const projectName = projectJson.name;
+  const projectConfigurations = (0, import_devkit.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.");
+  }
+  const options = defu(userOptions, DEFAULT_BUILD_OPTIONS);
+  options.name ??= `${projectName}-${options.format}`;
+  options.target ??= import_build_tools.DEFAULT_TARGET;
+  const packageJsonPath = (0, import_correct_paths2.joinPaths)(workspaceRoot.dir, options.projectRoot, "package.json");
+  if (!await import_node3.hfs.isFile(packageJsonPath)) {
+    throw new Error("Cannot find package.json configuration");
+  }
+  const packageJson = await import_node3.hfs.json(packageJsonPath);
+  const outExtension = getOutputExtensionMap(options, packageJson.type);
+  const env = (0, import_build_tools.getEnv)("esbuild", options);
+  const result = {
+    ...options,
+    config,
+    mainFields: options.platform === "node" ? [
+      "module",
+      "main"
+    ] : [
+      "browser",
+      "module",
+      "main"
+    ],
+    resolveExtensions: [
+      ".ts",
+      ".js",
+      ".node"
+    ],
+    ...userOptions,
+    tsconfig: (0, import_correct_paths2.joinPaths)(projectRoot, userOptions.tsconfig ? userOptions.tsconfig.replace(projectRoot, "") : "tsconfig.json"),
+    format: options.format || "cjs",
+    entryPoints: await (0, import_build_tools.getEntryPoints)(config, projectRoot, projectJson.sourceRoot, userOptions.entry || [
+      "./src/index.ts"
+    ], userOptions.emitOnAll),
+    outdir: userOptions.outputPath || (0, import_correct_paths2.joinPaths)("dist", projectRoot),
+    plugins: [],
+    name: userOptions.name || projectName,
+    projectConfigurations,
+    projectName,
+    projectGraph,
+    sourceRoot: userOptions.sourceRoot || projectJson.sourceRoot || (0, import_correct_paths2.joinPaths)(projectRoot, "src"),
+    minify: userOptions.minify || !userOptions.debug,
+    verbose: userOptions.verbose || (0, import_get_log_level.isVerbose)() || userOptions.debug === true,
+    includeSrc: userOptions.includeSrc === true,
+    metafile: userOptions.metafile !== false,
+    generatePackageJson: userOptions.generatePackageJson !== false,
+    clean: userOptions.clean !== false,
+    emitOnAll: userOptions.emitOnAll === true,
+    assets: userOptions.assets ?? [],
+    injectShims: userOptions.injectShims !== true,
+    bundle: userOptions.bundle !== false,
+    keepNames: true,
+    watch: userOptions.watch === true,
+    outExtension,
+    footer: userOptions.footer,
+    banner: {
+      js: options.banner || import_build_tools.DEFAULT_COMPILED_BANNER,
+      css: options.banner || import_build_tools.DEFAULT_COMPILED_BANNER
+    },
+    splitting: options.format === "iife" ? false : typeof options.splitting === "boolean" ? options.splitting : options.format === "esm",
+    treeShaking: options.format === "esm",
+    env,
+    define: {
+      STORM_FORMAT: JSON.stringify(options.format || "cjs"),
+      ...options.format === "cjs" && options.injectShims ? {
+        "import.meta.url": "importMetaUrl"
+      } : {},
+      ...options.define,
+      ...Object.keys(env || {}).reduce((res, key) => {
+        const value = JSON.stringify(env[key]);
+        return {
+          ...res,
+          [`process.env.${key}`]: value,
+          [`import.meta.env.${key}`]: value
+        };
+      }, {})
+    },
+    inject: [
+      options.format === "cjs" && options.injectShims ? (0, import_correct_paths2.joinPaths)(__dirname, "../assets/cjs_shims.js") : "",
+      options.format === "esm" && options.injectShims && options.platform === "node" ? (0, import_correct_paths2.joinPaths)(__dirname, "../assets/esm_shims.js") : "",
+      ...options.inject ?? []
+    ].filter(Boolean)
+  };
+  result.plugins = userOptions.plugins ?? getDefaultBuildPlugins(userOptions, result);
+  stopwatch();
+  return result;
+}, "resolveOptions");
+async function generatePackageJson(context2) {
+  if (context2.options.generatePackageJson !== false && await import_node3.hfs.isFile((0, import_correct_paths2.joinPaths)(context2.options.projectRoot, "package.json"))) {
+    (0, import_console2.writeDebug)("  \u270D\uFE0F   Writing package.json file", context2.options.config);
+    const stopwatch = (0, import_console2.getStopwatch)("Write package.json file");
+    const packageJsonPath = (0, import_correct_paths2.joinPaths)(context2.options.projectRoot, "project.json");
+    if (!await import_node3.hfs.isFile(packageJsonPath)) {
+      throw new Error("Cannot find package.json configuration");
+    }
+    let packageJson = await import_node3.hfs.json((0, import_correct_paths2.joinPaths)(context2.options.config.workspaceRoot, context2.options.projectRoot, "package.json"));
+    if (!packageJson) {
+      throw new Error("Cannot find package.json configuration file");
+    }
+    packageJson = await (0, import_build_tools.addPackageDependencies)(context2.options.config.workspaceRoot, context2.options.projectRoot, context2.options.projectName, packageJson);
+    packageJson = await (0, import_build_tools.addWorkspacePackageJsonFields)(context2.options.config, context2.options.projectRoot, context2.options.sourceRoot, context2.options.projectName, false, packageJson);
+    packageJson.exports ??= {};
+    packageJson.exports["./package.json"] ??= "./package.json";
+    packageJson.exports["."] ??= (0, import_build_tools.addPackageJsonExport)("index", packageJson.type, context2.options.sourceRoot);
+    let entryPoints = [
+      {
+        in: "./src/index.ts",
+        out: "./src/index.ts"
+      }
+    ];
+    if (context2.options.entryPoints) {
+      if (Array.isArray(context2.options.entryPoints)) {
+        entryPoints = context2.options.entryPoints.map((entryPoint) => typeof entryPoint === "string" ? {
+          in: entryPoint,
+          out: entryPoint
+        } : entryPoint);
+      }
+      for (const entryPoint of entryPoints) {
+        const split = entryPoint.out.split(".");
+        split.pop();
+        const entry = split.join(".").replaceAll("\\", "/");
+        packageJson.exports[`./${entry}`] ??= (0, import_build_tools.addPackageJsonExport)(entry, packageJson.type, context2.options.sourceRoot);
+      }
+    }
+    packageJson.main = packageJson.type === "commonjs" ? "./dist/index.js" : "./dist/index.cjs";
+    packageJson.module = packageJson.type === "module" ? "./dist/index.js" : "./dist/index.mjs";
+    packageJson.types = "./dist/index.d.ts";
+    packageJson.exports = Object.keys(packageJson.exports).reduce((ret, key) => {
+      if (key.endsWith("/index") && !ret[key.replace("/index", "")]) {
+        ret[key.replace("/index", "")] = packageJson.exports[key];
+      }
+      return ret;
+    }, packageJson.exports);
+    await (0, import_devkit.writeJsonFile)((0, import_correct_paths2.joinPaths)(context2.options.outdir, "package.json"), packageJson);
+    stopwatch();
+  }
+  return context2;
+}
+__name(generatePackageJson, "generatePackageJson");
+async function createOptions(options) {
+  return (0, import_es_toolkit.flatten)(await Promise.all((0, import_compat.map)(options, (opt) => [
+    // we defer it so that we don't trigger glob immediately
+    () => resolveOptions(opt)
+  ])));
+}
+__name(createOptions, "createOptions");
+async function generateContext(getOptions) {
+  const options = await getOptions();
+  const rendererEngine = new RendererEngine([
+    shebangRenderer,
+    ...options.renderers || []
+  ]);
+  return {
+    options,
+    rendererEngine
+  };
+}
+__name(generateContext, "generateContext");
+async function executeEsBuild(context2) {
+  (0, import_console2.writeDebug)(`  \u{1F680}  Running ${context2.options.name} build`, context2.options.config);
+  const stopwatch = (0, import_console2.getStopwatch)(`${context2.options.name} build`);
+  if (process.env.WATCH === "true") {
+    const ctx = await esbuild2.context(context2.options);
+    watch(ctx, context2.options);
+  }
+  const result = await esbuild2.build(context2.options);
+  if (result.metafile) {
+    const metafilePath = `${context2.options.outdir}/${context2.options.name}.meta.json`;
+    await import_node3.hfs.write(metafilePath, JSON.stringify(result.metafile));
+  }
+  stopwatch();
+  return context2;
+}
+__name(executeEsBuild, "executeEsBuild");
+async function copyBuildAssets(context2) {
+  if (context2.result?.errors.length === 0) {
+    (0, import_console2.writeDebug)(`  \u{1F4CB}  Copying asset files to output directory: ${context2.options.outdir}`, context2.options.config);
+    const stopwatch = (0, import_console2.getStopwatch)(`${context2.options.name} asset copy`);
+    await (0, import_build_tools.copyAssets)(context2.options.config, context2.options.assets ?? [], context2.options.outdir, context2.options.projectRoot, context2.options.projectName, context2.options.sourceRoot, true, false);
+    stopwatch();
+  }
+  return context2;
+}
+__name(copyBuildAssets, "copyBuildAssets");
+async function reportResults(context2) {
+  if (context2.result?.errors.length === 0) {
+    if (context2.result.warnings.length > 0) {
+      (0, import_console2.writeWarning)(`  \u{1F6A7}  The following warnings occurred during the build: ${context2.result.warnings.map((warning) => warning.text).join("\n")}`, context2.options.config);
+    }
+    (0, import_console2.writeSuccess)(`  \u{1F4E6}  The ${context2.options.name} build completed successfully`, context2.options.config);
+  }
+}
+__name(reportResults, "reportResults");
+async function dependencyCheck(options) {
+  if (process.env.DEV === "true") {
+    return void 0;
+  }
+  if (process.env.CI && !process.env.BUILDKITE) {
+    return void 0;
+  }
+  const buildPromise = esbuild2.build({
+    entryPoints: (0, import_globby.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 cleanOutputPath(context2) {
+  if (context2.options.clean !== false && context2.options.outdir) {
+    await clean(context2.options.name, context2.options.outdir, context2.options.config);
+  }
+  return context2;
+}
+__name(cleanOutputPath, "cleanOutputPath");
+async function build3(options) {
+  (0, import_console2.writeDebug)(`  \u26A1   Executing Storm ESBuild pipeline`);
+  const stopwatch = (0, import_console2.getStopwatch)("ESBuild pipeline");
+  try {
+    const opts = Array.isArray(options) ? options : [
+      options
+    ];
+    if (opts.length === 0) {
+      throw new Error("No build options were provided");
+    }
+    void transduce.async(opts, dependencyCheck);
+    await transduce.async(await createOptions(opts), pipe.async(generateContext, cleanOutputPath, generatePackageJson, executeEsBuild, copyBuildAssets, reportResults));
+    (0, import_console2.writeSuccess)("  \u{1F3C1}  ESBuild pipeline build completed successfully");
+  } catch (error) {
+    (0, import_console2.writeFatal)("  \u274C  Fatal errors occurred during the build that could not be recovered from. The build process has been terminated.");
+    throw error;
+  } finally {
+    stopwatch();
+  }
+}
+__name(build3, "build");
+var watch = /* @__PURE__ */ __name((context2, options) => {
+  if (!options.watch) {
+    return context2;
+  }
+  const config = {
+    ignoreInitial: true,
+    useFsEvents: true,
+    ignored: [
+      "./src/__tests__/**/*",
+      "./package.json"
+    ]
+  };
+  const changeWatcher = (0, import_chokidar.watch)([
+    "./src/**/*"
+  ], config);
+  const fastRebuild = (0, import_es_toolkit.debounce)(async () => {
+    const timeBefore = Date.now();
+    const rebuildResult = await handle.async(() => {
+      return context2.rebuild();
+    });
+    if (rebuildResult instanceof Error) {
+      (0, import_console2.writeError)(rebuildResult.message);
+    }
+    (0, import_console2.writeTrace)(`${Date.now() - timeBefore}ms [${options.name ?? ""}]`);
+  }, 10);
+  changeWatcher.on("change", fastRebuild);
+  return void 0;
+}, "watch");
+
+// bin/esbuild.ts
+async function createProgram(config) {
+  try {
+    (0, import_console3.writeInfo)("\u26A1 Running Storm ESBuild pipeline", config);
+    const root = (0, import_find_workspace_root2.findWorkspaceRootSafe)();
+    process.env.STORM_WORKSPACE_ROOT ??= root;
+    process.env.NX_WORKSPACE_ROOT_PATH ??= root;
+    root && process.chdir(root);
+    const program = new import_commander.Command("storm-esbuild");
+    program.version("1.0.0", "-v --version", "display CLI version");
+    program.description("\u26A1 Run the Storm ESBuild pipeline").showHelpAfterError().showSuggestionAfterError();
+    const projectRootOption = new import_commander.Option("-p --project-root <path>", "The path to the root of the project to build. This path is defined relative to the workspace root.").makeOptionMandatory(true);
+    const sourceRootOption = new import_commander.Option("-s --source-root <path>", "The path of the project's source folder to build");
+    const nameOption = new import_commander.Option("-n --name <value>", "The name of the project to build");
+    const outputPathOption = new import_commander.Option("-o --output-path <path>", "The path of the project's source folder to build").default("dist/{projectRoot}");
+    const platformOption = new import_commander.Option("-p --platform <value>", "The platform to build the distribution for").choices([
+      "node",
+      "neutral",
+      "browser"
+    ]).default("node");
+    const formatOption = new import_commander.Option("-f, --format <value...>", "The format to build the distribution in").choices([
+      "esm",
+      "cjs",
+      "iife"
+    ]).argParser((value, previous) => {
+      if (previous === void 0) {
+        return [
+          value
+        ];
+      } else if (!previous.includes(value)) {
+        previous.push(value);
+      }
+      return previous;
+    }).default("esm");
+    const cleanOption = new import_commander.Option("-c --clean", "Should the output directory be cleaned before building").default(true);
+    const noCleanOption = new import_commander.Option("--no-clean", "Should the output directory be cleaned before building").default(false);
+    const bundleOption = new import_commander.Option("-b --bundle", "Should the output be bundled").default(true);
+    const noBundleOption = new import_commander.Option("--no-bundle", "Should the output be bundled").default(false);
+    const targetOption = new import_commander.Option("-t --target <value>", "The target to build the distribution for").choices([
+      "ESNext",
+      "ES2015",
+      "ES2016",
+      "ES2017",
+      "ES2018",
+      "ES2019",
+      "ES2020",
+      "ES2021",
+      "ES2022",
+      "ES2023"
+    ]).default("ESNext");
+    const watchOption = new import_commander.Option("-w --watch", "Should the build process watch for changes").default(false);
+    const debugOption = new import_commander.Option("-d --debug", "Should the build process run in debug mode").default(false);
+    const bannerOption = new import_commander.Option("--banner <value>", "The banner to prepend to the output");
+    const footerOption = new import_commander.Option("--footer <value>", "The footer to prepend to the output");
+    const splittingOption = new import_commander.Option("--splitting", "Should the output be split into multiple files").default(true);
+    const treeShakingOption = new import_commander.Option("--tree-shaking", "Should tree shaking be enabled").default(true);
+    const generatePackageJsonOption = new import_commander.Option("--generate-package-json", "Should a package.json be generated for the output").default(true);
+    const emitOnAllOption = new import_commander.Option("--emit-on-all", "Should the output be emitted on all platforms").default(false);
+    const metafileOption = new import_commander.Option("--metafile", "Should a metafile be generated for the output").default(true);
+    const minifyOption = new import_commander.Option("--minify", "Should the output be minified").default(true);
+    const includeSrcOption = new import_commander.Option("--include-src", "Should the source files be included in the output").default(false);
+    const verboseOption = new import_commander.Option("--verbose", "Should the build process be verbose").default(false);
+    const injectShimsOption = new import_commander.Option("--inject-shims", "Should shims be injected into the output").default(true);
+    const emitTypesOption = new import_commander.Option("--emit-types", "Should types be emitted for the output").default(true);
+    program.command("build", {
+      isDefault: true
+    }).alias("bundle").description("Run a TypeScript build using ESBuild, API-Extractor, and TSC (for type generation).").addOption(nameOption).addOption(projectRootOption).addOption(sourceRootOption).addOption(outputPathOption).addOption(platformOption).addOption(formatOption).addOption(targetOption).addOption(bundleOption).addOption(noBundleOption).addOption(cleanOption).addOption(noCleanOption).addOption(watchOption).addOption(debugOption).addOption(bannerOption).addOption(footerOption).addOption(splittingOption).addOption(treeShakingOption).addOption(generatePackageJsonOption).addOption(emitOnAllOption).addOption(metafileOption).addOption(minifyOption).addOption(includeSrcOption).addOption(verboseOption).addOption(injectShimsOption).addOption(emitTypesOption).action(buildAction(config));
+    program.command("clean").alias("clear").description("Clean the output directory of the project. This command will remove the 'dist' folder.").addOption(nameOption).action(cleanAction(config));
+    return program;
+  } catch (e) {
+    (0, import_console3.writeFatal)(`A fatal error occurred while running the program: ${e.message}`, config);
+    process.exit(1);
+  }
+}
+__name(createProgram, "createProgram");
+var buildAction = /* @__PURE__ */ __name((config) => async (options) => {
+  try {
+    await build3({
+      ...options,
+      format: options.format
+    });
+  } catch (e) {
+    (0, import_console3.writeFatal)(`A fatal error occurred while cleaning the ESBuild output directory: ${e.message}`, config);
+    (0, import_process_handler.exitWithError)(config);
+    process.exit(1);
+  }
+}, "buildAction");
+var cleanAction = /* @__PURE__ */ __name((config) => async (options) => {
+  try {
+    await clean(options.name, options.output, config);
+  } catch (e) {
+    (0, import_console3.writeFatal)(`A fatal error occurred while cleaning the ESBuild output directory: ${e.message}`, config);
+    (0, import_process_handler.exitWithError)(config);
+    process.exit(1);
+  }
+}, "cleanAction");
+void (async () => {
+  const config = await (0, import_create_storm_config2.loadStormConfig)();
+  const stopwatch = (0, import_console3.getStopwatch)("Storm ESBuild executable");
+  try {
+    (0, import_process_handler.handleProcess)(config);
+    const program = await createProgram(config);
+    await program.parseAsync(process.argv);
+    (0, import_console3.writeSuccess)(`\u{1F389}  Storm ESBuild executable has completed successfully!`, config);
+    (0, import_process_handler.exitWithSuccess)(config);
+  } catch (error) {
+    (0, import_console3.writeFatal)(`A fatal error occurred while running Storm ESBuild executable: 
+
+${error.message}`, config);
+    (0, import_process_handler.exitWithError)(config);
+    process.exit(1);
+  } finally {
+    stopwatch();
+  }
+})();