@storm-software/tsdown 0.28.22 → 0.28.24

package/dist/{chunk-X56SYHGK.js → chunk-IUBNNUNA.js}

@@ -20,16 +20,17 @@ import {
   writeSuccess,
   writeTrace,
   writeWarning
-} from "./chunk-2WT22RMQ.js";
+} from "./chunk-J4T3BYOA.js";
 import {
   DEFAULT_BUILD_OPTIONS
-} from "./chunk-PR5HLZXS.js";
-import {
-  __name
-} from "./chunk-SHUYVCID.js";
+} from "./chunk-2YE3GBQH.js";
 
 // src/build.ts
-import { createProjectGraphAsync as createProjectGraphAsync2, readProjectsConfigurationFromProjectGraph as readProjectsConfigurationFromProjectGraph2, writeJsonFile } from "@nx/devkit";
+import {
+  createProjectGraphAsync as createProjectGraphAsync2,
+  readProjectsConfigurationFromProjectGraph as readProjectsConfigurationFromProjectGraph2,
+  writeJsonFile
+} from "@nx/devkit";
 
 // ../build-tools/src/config.ts
 var DEFAULT_ENVIRONMENT = "production";
@@ -53,7 +54,7 @@ import { relative } from "path";
 import { CopyAssetsHandler } from "@nx/js/src/utils/assets/copy-assets-handler";
 import { glob } from "glob";
 import { readFile, writeFile } from "node:fs/promises";
-var copyAssets = /* @__PURE__ */ __name(async (config, assets, outputPath, projectRoot, sourceRoot, generatePackageJson2 = true, includeSrc = false, banner, footer) => {
+var copyAssets = async (config, assets, outputPath, projectRoot, sourceRoot, generatePackageJson2 = true, includeSrc = false, banner, footer) => {
   const pendingAssets = Array.from(assets ?? []);
   pendingAssets.push({
     input: projectRoot,
@@ -79,8 +80,11 @@ var copyAssets = /* @__PURE__ */ __name(async (config, assets, outputPath, proje
       output: "src/"
     });
   }
-  writeTrace(`\u{1F4DD}  Copying the following assets to the output directory:
-${pendingAssets.map((pendingAsset) => typeof pendingAsset === "string" ? ` - ${pendingAsset} -> ${outputPath}` : `  - ${pendingAsset.input}/${pendingAsset.glob} -> ${joinPaths(outputPath, pendingAsset.output)}`).join("\n")}`, config);
+  writeTrace(
+    `\u{1F4DD}  Copying the following assets to the output directory:
+${pendingAssets.map((pendingAsset) => typeof pendingAsset === "string" ? ` - ${pendingAsset} -> ${outputPath}` : `  - ${pendingAsset.input}/${pendingAsset.glob} -> ${joinPaths(outputPath, pendingAsset.output)}`).join("\n")}`,
+    config
+  );
   const assetHandler = new CopyAssetsHandler({
     projectDir: projectRoot,
     rootDir: config.workspaceRoot,
@@ -89,28 +93,45 @@ ${pendingAssets.map((pendingAsset) => typeof pendingAsset === "string" ? ` - ${p
   });
   await assetHandler.processAllAssetsOnce();
   if (includeSrc === true) {
-    writeDebug(`\u{1F4DD}  Adding banner and writing source files: ${joinPaths(outputPath, "src")}`, config);
+    writeDebug(
+      `\u{1F4DD}  Adding banner and writing source files: ${joinPaths(
+        outputPath,
+        "src"
+      )}`,
+      config
+    );
     const files = await glob([
       joinPaths(config.workspaceRoot, outputPath, "src/**/*.ts"),
       joinPaths(config.workspaceRoot, outputPath, "src/**/*.tsx"),
       joinPaths(config.workspaceRoot, outputPath, "src/**/*.js"),
       joinPaths(config.workspaceRoot, outputPath, "src/**/*.jsx")
     ]);
-    await Promise.allSettled(files.map(async (file) => writeFile(file, `${banner && typeof banner === "string" ? banner.startsWith("//") ? banner : `// ${banner}` : ""}
+    await Promise.allSettled(
+      files.map(
+        async (file) => writeFile(
+          file,
+          `${banner && typeof banner === "string" ? banner.startsWith("//") ? banner : `// ${banner}` : ""}
 
 ${await readFile(file, "utf8")}
 
-${footer && typeof footer === "string" ? footer.startsWith("//") ? footer : `// ${footer}` : ""}`)));
+${footer && typeof footer === "string" ? footer.startsWith("//") ? footer : `// ${footer}` : ""}`
+        )
+      )
+    );
   }
-}, "copyAssets");
+};
 
 // ../build-tools/src/utilities/generate-package-json.ts
 import { calculateProjectBuildableDependencies } from "@nx/js/src/utils/buildable-libs-utils";
 import { Glob } from "glob";
 import { existsSync, readFileSync } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
-import { createProjectGraphAsync, readCachedProjectGraph, readProjectsConfigurationFromProjectGraph } from "nx/src/project-graph/project-graph";
-var addPackageDependencies = /* @__PURE__ */ __name(async (workspaceRoot, projectRoot, projectName, packageJson) => {
+import {
+  createProjectGraphAsync,
+  readCachedProjectGraph,
+  readProjectsConfigurationFromProjectGraph
+} from "nx/src/project-graph/project-graph";
+var addPackageDependencies = async (workspaceRoot, projectRoot, projectName, packageJson) => {
   let projectGraph;
   try {
     projectGraph = readCachedProjectGraph();
@@ -119,16 +140,35 @@ var addPackageDependencies = /* @__PURE__ */ __name(async (workspaceRoot, projec
     projectGraph = readCachedProjectGraph();
   }
   if (!projectGraph) {
-    throw new Error("The Build process failed because the project graph is not available. Please run the build command again.");
+    throw new Error(
+      "The Build process failed because the project graph is not available. Please run the build command again."
+    );
   }
-  const projectDependencies = calculateProjectBuildableDependencies(void 0, projectGraph, workspaceRoot, projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  const projectDependencies = calculateProjectBuildableDependencies(
+    void 0,
+    projectGraph,
+    workspaceRoot,
+    projectName,
+    process.env.NX_TASK_TARGET_TARGET || "build",
+    process.env.NX_TASK_TARGET_CONFIGURATION || "production",
+    true
+  );
   const localPackages = [];
-  for (const project of projectDependencies.dependencies.filter((dep) => dep.node.type === "lib" && dep.node.data?.root !== projectRoot && dep.node.data?.root !== workspaceRoot)) {
+  for (const project of projectDependencies.dependencies.filter(
+    (dep) => dep.node.type === "lib" && dep.node.data?.root !== projectRoot && dep.node.data?.root !== workspaceRoot
+  )) {
     const projectNode = project.node;
     if (projectNode.data.root) {
-      const projectPackageJsonPath = joinPaths(workspaceRoot, projectNode.data.root, "package.json");
+      const projectPackageJsonPath = joinPaths(
+        workspaceRoot,
+        projectNode.data.root,
+        "package.json"
+      );
       if (existsSync(projectPackageJsonPath)) {
-        const projectPackageJsonContent = await readFile2(projectPackageJsonPath, "utf8");
+        const projectPackageJsonContent = await readFile2(
+          projectPackageJsonPath,
+          "utf8"
+        );
         const projectPackageJson = JSON.parse(projectPackageJsonContent);
         if (projectPackageJson.private !== true) {
           localPackages.push(projectPackageJson);
@@ -137,19 +177,33 @@ var addPackageDependencies = /* @__PURE__ */ __name(async (workspaceRoot, projec
     }
   }
   if (localPackages.length > 0) {
-    writeTrace(`\u{1F4E6}  Adding local packages to package.json: ${localPackages.map((p) => p.name).join(", ")}`);
-    const projectJsonFile = await readFile2(joinPaths(projectRoot, "project.json"), "utf8");
+    writeTrace(
+      `\u{1F4E6}  Adding local packages to package.json: ${localPackages.map((p) => p.name).join(", ")}`
+    );
+    const projectJsonFile = await readFile2(
+      joinPaths(projectRoot, "project.json"),
+      "utf8"
+    );
     const projectJson = JSON.parse(projectJsonFile);
     const projectName2 = projectJson.name;
     const projectConfigurations = readProjectsConfigurationFromProjectGraph(projectGraph);
     if (!projectConfigurations?.projects?.[projectName2]) {
-      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.");
+      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 implicitDependencies = projectConfigurations.projects?.[projectName2].implicitDependencies?.reduce((ret, dep) => {
       if (projectConfigurations.projects?.[dep]) {
-        const depPackageJsonPath = joinPaths(workspaceRoot, projectConfigurations.projects[dep].root, "package.json");
+        const depPackageJsonPath = joinPaths(
+          workspaceRoot,
+          projectConfigurations.projects[dep].root,
+          "package.json"
+        );
         if (existsSync(depPackageJsonPath)) {
-          const depPackageJsonContent = readFileSync(depPackageJsonPath, "utf8");
+          const depPackageJsonContent = readFileSync(
+            depPackageJsonPath,
+            "utf8"
+          );
           const depPackageJson = JSON.parse(depPackageJsonContent);
           if (depPackageJson.private !== true && !ret.includes(depPackageJson.name)) {
             ret.push(depPackageJson.name);
@@ -174,10 +228,13 @@ var addPackageDependencies = /* @__PURE__ */ __name(async (workspaceRoot, projec
     writeTrace("\u{1F4E6}  No local packages dependencies to add to package.json");
   }
   return packageJson;
-}, "addPackageDependencies");
-var addWorkspacePackageJsonFields = /* @__PURE__ */ __name(async (workspaceConfig, projectRoot, sourceRoot, projectName, includeSrc = false, packageJson) => {
+};
+var addWorkspacePackageJsonFields = async (workspaceConfig, projectRoot, sourceRoot, projectName, includeSrc = false, packageJson) => {
   const workspaceRoot = workspaceConfig.workspaceRoot ? workspaceConfig.workspaceRoot : findWorkspaceRoot();
-  const workspacePackageJsonContent = await readFile2(joinPaths(workspaceRoot, "package.json"), "utf8");
+  const workspacePackageJsonContent = await readFile2(
+    joinPaths(workspaceRoot, "package.json"),
+    "utf8"
+  );
   const workspacePackageJson = JSON.parse(workspacePackageJsonContent);
   packageJson.type ??= "module";
   packageJson.sideEffects ??= false;
@@ -188,9 +245,7 @@ var addWorkspacePackageJsonFields = /* @__PURE__ */ __name(async (workspaceConfi
     }
     packageJson.source ??= `${joinPaths(distSrc, "index.ts").replaceAll("\\", "/")}`;
   }
-  packageJson.files ??= [
-    "dist/**/*"
-  ];
+  packageJson.files ??= ["dist/**/*"];
   if (includeSrc === true && !packageJson.files.includes("src")) {
     packageJson.files.push("src/**/*");
   }
@@ -206,21 +261,17 @@ var addWorkspacePackageJsonFields = /* @__PURE__ */ __name(async (workspaceConfi
   packageJson.author ??= workspacePackageJson.author;
   packageJson.maintainers ??= workspacePackageJson.maintainers;
   if (!packageJson.maintainers && packageJson.author) {
-    packageJson.maintainers = [
-      packageJson.author
-    ];
+    packageJson.maintainers = [packageJson.author];
   }
   packageJson.contributors ??= workspacePackageJson.contributors;
   if (!packageJson.contributors && packageJson.author) {
-    packageJson.contributors = [
-      packageJson.author
-    ];
+    packageJson.contributors = [packageJson.author];
   }
   packageJson.repository ??= workspacePackageJson.repository;
   packageJson.repository.directory ??= projectRoot ? projectRoot : joinPaths("packages", projectName);
   return packageJson;
-}, "addWorkspacePackageJsonFields");
-var addPackageJsonExport = /* @__PURE__ */ __name((file, type = "module", sourceRoot) => {
+};
+var addPackageJsonExport = (file, type = "module", sourceRoot) => {
   let entry = file.replaceAll("\\", "/");
   if (sourceRoot) {
     entry = entry.replace(sourceRoot, "");
@@ -239,12 +290,12 @@ var addPackageJsonExport = /* @__PURE__ */ __name((file, type = "module", source
       default: `./dist/${entry}.js`
     }
   };
-}, "addPackageJsonExport");
+};
 
 // ../config-tools/src/config-file/get-config-file.ts
 import { loadConfig } from "c12";
 import defu from "defu";
-var getConfigFileByName = /* @__PURE__ */ __name(async (fileName, filePath, options = {}) => {
+var getConfigFileByName = async (fileName, filePath, options = {}) => {
   const workspacePath = filePath || findWorkspaceRoot(filePath);
   const configs = await Promise.all([
     loadConfig({
@@ -254,7 +305,10 @@ var getConfigFileByName = /* @__PURE__ */ __name(async (fileName, filePath, opti
       envName: fileName?.toUpperCase(),
       jitiOptions: {
         debug: false,
-        fsCache: process.env.STORM_SKIP_CACHE === "true" ? false : joinPaths(process.env.STORM_CACHE_DIR || "node_modules/.cache/storm", "jiti")
+        fsCache: process.env.STORM_SKIP_CACHE === "true" ? false : joinPaths(
+          process.env.STORM_CACHE_DIR || "node_modules/.cache/storm",
+          "jiti"
+        )
       },
       ...options
     }),
@@ -265,32 +319,45 @@ var getConfigFileByName = /* @__PURE__ */ __name(async (fileName, filePath, opti
       envName: fileName?.toUpperCase(),
       jitiOptions: {
         debug: false,
-        fsCache: process.env.STORM_SKIP_CACHE === "true" ? false : joinPaths(process.env.STORM_CACHE_DIR || "node_modules/.cache/storm", "jiti")
+        fsCache: process.env.STORM_SKIP_CACHE === "true" ? false : joinPaths(
+          process.env.STORM_CACHE_DIR || "node_modules/.cache/storm",
+          "jiti"
+        )
       },
       configFile: fileName,
       ...options
     })
   ]);
   return defu(configs[0] ?? {}, configs[1] ?? {});
-}, "getConfigFileByName");
-var getConfigFile = /* @__PURE__ */ __name(async (filePath, additionalFileNames = []) => {
+};
+var getConfigFile = async (filePath, additionalFileNames = []) => {
   const workspacePath = filePath ? filePath : findWorkspaceRoot(filePath);
   const result = await getConfigFileByName("storm-workspace", workspacePath);
   let config = result.config;
   const configFile = result.configFile;
   if (config && configFile && Object.keys(config).length > 0 && !config.skipConfigLogging) {
-    writeTrace(`Found Storm configuration file "${configFile.includes(`${workspacePath}/`) ? configFile.replace(`${workspacePath}/`, "") : configFile}" at "${workspacePath}"`, {
-      logLevel: "all"
-    });
+    writeTrace(
+      `Found Storm configuration file "${configFile.includes(`${workspacePath}/`) ? configFile.replace(`${workspacePath}/`, "") : configFile}" at "${workspacePath}"`,
+      {
+        logLevel: "all"
+      }
+    );
   }
   if (additionalFileNames && additionalFileNames.length > 0) {
-    const results = await Promise.all(additionalFileNames.map((fileName) => getConfigFileByName(fileName, workspacePath)));
+    const results = await Promise.all(
+      additionalFileNames.map(
+        (fileName) => getConfigFileByName(fileName, workspacePath)
+      )
+    );
     for (const result2 of results) {
       if (result2?.config && result2?.configFile && Object.keys(result2.config).length > 0) {
         if (!config.skipConfigLogging && !result2.config.skipConfigLogging) {
-          writeTrace(`Found alternative configuration file "${result2.configFile.includes(`${workspacePath}/`) ? result2.configFile.replace(`${workspacePath}/`, "") : result2.configFile}" at "${workspacePath}"`, {
-            logLevel: "all"
-          });
+          writeTrace(
+            `Found alternative configuration file "${result2.configFile.includes(`${workspacePath}/`) ? result2.configFile.replace(`${workspacePath}/`, "") : result2.configFile}" at "${workspacePath}"`,
+            {
+              logLevel: "all"
+            }
+          );
         }
         config = defu(result2.config ?? {}, config ?? {});
       }
@@ -301,23 +368,25 @@ var getConfigFile = /* @__PURE__ */ __name(async (filePath, additionalFileNames
   }
   config.configFile = configFile;
   return config;
-}, "getConfigFile");
+};
 
 // ../config-tools/src/create-storm-config.ts
 import defu2 from "defu";
 
 // ../config-tools/src/env/get-env.ts
-var getExtensionEnv = /* @__PURE__ */ __name((extensionName) => {
+var getExtensionEnv = (extensionName) => {
   const prefix = `STORM_EXTENSION_${extensionName.toUpperCase()}_`;
   return Object.keys(process.env).filter((key) => key.startsWith(prefix)).reduce((ret, key) => {
-    const name = key.replace(prefix, "").split("_").map((i) => i.length > 0 ? i.trim().charAt(0).toUpperCase() + i.trim().slice(1) : "").join("");
+    const name = key.replace(prefix, "").split("_").map(
+      (i) => i.length > 0 ? i.trim().charAt(0).toUpperCase() + i.trim().slice(1) : ""
+    ).join("");
     if (name) {
       ret[name] = process.env[key];
     }
     return ret;
   }, {});
-}, "getExtensionEnv");
-var getConfigEnv = /* @__PURE__ */ __name(() => {
+};
+var getConfigEnv = () => {
   const prefix = "STORM_";
   let config = {
     extends: process.env[`${prefix}EXTENDS`] || void 0,
@@ -385,14 +454,25 @@ var getConfigEnv = /* @__PURE__ */ __name(() => {
       cyclone: process.env[`${prefix}REGISTRY_CYCLONE`] || void 0,
       container: process.env[`${prefix}REGISTRY_CONTAINER`] || void 0
     },
-    logLevel: process.env[`${prefix}LOG_LEVEL`] !== null && process.env[`${prefix}LOG_LEVEL`] !== void 0 ? process.env[`${prefix}LOG_LEVEL`] && Number.isSafeInteger(Number.parseInt(process.env[`${prefix}LOG_LEVEL`])) ? getLogLevelLabel(Number.parseInt(process.env[`${prefix}LOG_LEVEL`])) : process.env[`${prefix}LOG_LEVEL`] : void 0,
+    logLevel: process.env[`${prefix}LOG_LEVEL`] !== null && process.env[`${prefix}LOG_LEVEL`] !== void 0 ? process.env[`${prefix}LOG_LEVEL`] && Number.isSafeInteger(
+      Number.parseInt(process.env[`${prefix}LOG_LEVEL`])
+    ) ? getLogLevelLabel(
+      Number.parseInt(process.env[`${prefix}LOG_LEVEL`])
+    ) : process.env[`${prefix}LOG_LEVEL`] : void 0,
     skipConfigLogging: process.env[`${prefix}SKIP_CONFIG_LOGGING`] !== void 0 ? Boolean(process.env[`${prefix}SKIP_CONFIG_LOGGING`]) : void 0
   };
-  const themeNames = Object.keys(process.env).filter((envKey) => envKey.startsWith(`${prefix}COLOR_`) && COLOR_KEYS.every((colorKey) => !envKey.startsWith(`${prefix}COLOR_LIGHT_${colorKey}`) && !envKey.startsWith(`${prefix}COLOR_DARK_${colorKey}`)));
-  config.colors = themeNames.length > 0 ? themeNames.reduce((ret, themeName) => {
-    ret[themeName] = getThemeColorConfigEnv(prefix, themeName);
-    return ret;
-  }, {}) : getThemeColorConfigEnv(prefix);
+  const themeNames = Object.keys(process.env).filter(
+    (envKey) => envKey.startsWith(`${prefix}COLOR_`) && COLOR_KEYS.every(
+      (colorKey) => !envKey.startsWith(`${prefix}COLOR_LIGHT_${colorKey}`) && !envKey.startsWith(`${prefix}COLOR_DARK_${colorKey}`)
+    )
+  );
+  config.colors = themeNames.length > 0 ? themeNames.reduce(
+    (ret, themeName) => {
+      ret[themeName] = getThemeColorConfigEnv(prefix, themeName);
+      return ret;
+    },
+    {}
+  ) : getThemeColorConfigEnv(prefix);
   if (config.docs === STORM_DEFAULT_DOCS) {
     if (config.homepage === STORM_DEFAULT_HOMEPAGE) {
       config.docs = `${STORM_DEFAULT_HOMEPAGE}/projects/${config.name}/docs`;
@@ -413,23 +493,17 @@ var getConfigEnv = /* @__PURE__ */ __name(() => {
     config = {
       ...config,
       ...parsed,
-      colors: {
-        ...config.colors,
-        ...parsed.colors
-      },
-      extensions: {
-        ...config.extensions,
-        ...parsed.extensions
-      }
+      colors: { ...config.colors, ...parsed.colors },
+      extensions: { ...config.extensions, ...parsed.extensions }
     };
   }
   return config;
-}, "getConfigEnv");
-var getThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, theme) => {
+};
+var getThemeColorConfigEnv = (prefix, theme) => {
   const themeName = `COLOR_${theme && theme !== "base" ? `${theme}_` : ""}`.toUpperCase();
   return process.env[`${prefix}${themeName}LIGHT_BRAND`] || process.env[`${prefix}${themeName}DARK_BRAND`] ? getMultiThemeColorConfigEnv(prefix + themeName) : getSingleThemeColorConfigEnv(prefix + themeName);
-}, "getThemeColorConfigEnv");
-var getSingleThemeColorConfigEnv = /* @__PURE__ */ __name((prefix) => {
+};
+var getSingleThemeColorConfigEnv = (prefix) => {
   return {
     dark: process.env[`${prefix}DARK`],
     light: process.env[`${prefix}LIGHT`],
@@ -446,14 +520,16 @@ var getSingleThemeColorConfigEnv = /* @__PURE__ */ __name((prefix) => {
     positive: process.env[`${prefix}POSITIVE`],
     negative: process.env[`${prefix}NEGATIVE`]
   };
-}, "getSingleThemeColorConfigEnv");
-var getMultiThemeColorConfigEnv = /* @__PURE__ */ __name((prefix) => {
+};
+var getMultiThemeColorConfigEnv = (prefix) => {
   return {
-    light: getBaseThemeColorConfigEnv(`${prefix}_LIGHT_`),
+    light: getBaseThemeColorConfigEnv(
+      `${prefix}_LIGHT_`
+    ),
     dark: getBaseThemeColorConfigEnv(`${prefix}_DARK_`)
   };
-}, "getMultiThemeColorConfigEnv");
-var getBaseThemeColorConfigEnv = /* @__PURE__ */ __name((prefix) => {
+};
+var getBaseThemeColorConfigEnv = (prefix) => {
   return {
     foreground: process.env[`${prefix}FOREGROUND`],
     background: process.env[`${prefix}BACKGROUND`],
@@ -470,13 +546,16 @@ var getBaseThemeColorConfigEnv = /* @__PURE__ */ __name((prefix) => {
     positive: process.env[`${prefix}POSITIVE`],
     negative: process.env[`${prefix}NEGATIVE`]
   };
-}, "getBaseThemeColorConfigEnv");
+};
 
 // ../config-tools/src/env/set-env.ts
-var setExtensionEnv = /* @__PURE__ */ __name((extensionName, extension) => {
+var setExtensionEnv = (extensionName, extension) => {
   for (const key of Object.keys(extension ?? {})) {
     if (extension[key]) {
-      const result = key?.replace(/([A-Z])+/g, (input) => input ? input[0]?.toUpperCase() + input.slice(1) : "").split(/(?=[A-Z])|[.\-\s_]/).map((x) => x.toLowerCase()) ?? [];
+      const result = key?.replace(
+        /([A-Z])+/g,
+        (input) => input ? input[0]?.toUpperCase() + input.slice(1) : ""
+      ).split(/(?=[A-Z])|[.\-\s_]/).map((x) => x.toLowerCase()) ?? [];
       let extensionKey;
       if (result.length === 0) {
         return;
@@ -491,8 +570,8 @@ var setExtensionEnv = /* @__PURE__ */ __name((extensionName, extension) => {
       process.env[`STORM_EXTENSION_${extensionName.toUpperCase()}_${extensionKey.toUpperCase()}`] = extension[key];
     }
   }
-}, "setExtensionEnv");
-var setConfigEnv = /* @__PURE__ */ __name((config) => {
+};
+var setConfigEnv = (config) => {
   const prefix = "STORM_";
   if (config.extends) {
     process.env[`${prefix}EXTENDS`] = Array.isArray(config.extends) ? JSON.stringify(config.extends) : config.extends;
@@ -581,7 +660,9 @@ var setConfigEnv = /* @__PURE__ */ __name((config) => {
   }
   if (config.directories) {
     if (!config.skipCache && config.directories.cache) {
-      process.env[`${prefix}CACHE_DIR`] = correctPaths(config.directories.cache);
+      process.env[`${prefix}CACHE_DIR`] = correctPaths(
+        config.directories.cache
+      );
       process.env[`${prefix}CACHE_DIRECTORY`] = process.env[`${prefix}CACHE_DIR`];
     }
     if (config.directories.data) {
@@ -589,7 +670,9 @@ var setConfigEnv = /* @__PURE__ */ __name((config) => {
       process.env[`${prefix}DATA_DIRECTORY`] = process.env[`${prefix}DATA_DIR`];
     }
     if (config.directories.config) {
-      process.env[`${prefix}CONFIG_DIR`] = correctPaths(config.directories.config);
+      process.env[`${prefix}CONFIG_DIR`] = correctPaths(
+        config.directories.config
+      );
       process.env[`${prefix}CONFIG_DIRECTORY`] = process.env[`${prefix}CONFIG_DIR`];
     }
     if (config.directories.temp) {
@@ -601,7 +684,9 @@ var setConfigEnv = /* @__PURE__ */ __name((config) => {
       process.env[`${prefix}LOG_DIRECTORY`] = process.env[`${prefix}LOG_DIR`];
     }
     if (config.directories.build) {
-      process.env[`${prefix}BUILD_DIR`] = correctPaths(config.directories.build);
+      process.env[`${prefix}BUILD_DIR`] = correctPaths(
+        config.directories.build
+      );
       process.env[`${prefix}BUILD_DIRECTORY`] = process.env[`${prefix}BUILD_DIR`];
     }
   }
@@ -622,7 +707,10 @@ var setConfigEnv = /* @__PURE__ */ __name((config) => {
       setThemeColorConfigEnv(`${prefix}COLOR_${key}_`, config.colors[key]);
     }
   } else {
-    setThemeColorConfigEnv(`${prefix}COLOR_`, config.colors);
+    setThemeColorConfigEnv(
+      `${prefix}COLOR_`,
+      config.colors
+    );
   }
   if (config.repository) {
     process.env[`${prefix}REPOSITORY`] = config.repository;
@@ -634,7 +722,9 @@ var setConfigEnv = /* @__PURE__ */ __name((config) => {
     process.env[`${prefix}PRE_ID`] = String(config.preid);
   }
   if (config.externalPackagePatterns) {
-    process.env[`${prefix}EXTERNAL_PACKAGE_PATTERNS`] = JSON.stringify(config.externalPackagePatterns);
+    process.env[`${prefix}EXTERNAL_PACKAGE_PATTERNS`] = JSON.stringify(
+      config.externalPackagePatterns
+    );
   }
   if (config.registry) {
     if (config.registry.github) {
@@ -647,20 +737,28 @@ var setConfigEnv = /* @__PURE__ */ __name((config) => {
       process.env[`${prefix}REGISTRY_CARGO`] = String(config.registry.cargo);
     }
     if (config.registry.cyclone) {
-      process.env[`${prefix}REGISTRY_CYCLONE`] = String(config.registry.cyclone);
+      process.env[`${prefix}REGISTRY_CYCLONE`] = String(
+        config.registry.cyclone
+      );
     }
     if (config.registry.container) {
-      process.env[`${prefix}REGISTRY_CONTAINER`] = String(config.registry.container);
+      process.env[`${prefix}REGISTRY_CONTAINER`] = String(
+        config.registry.container
+      );
     }
   }
   if (config.logLevel) {
     process.env[`${prefix}LOG_LEVEL`] = String(config.logLevel);
     process.env.LOG_LEVEL = String(config.logLevel);
-    process.env.NX_VERBOSE_LOGGING = String(getLogLevel(config.logLevel) >= LogLevel.DEBUG ? true : false);
+    process.env.NX_VERBOSE_LOGGING = String(
+      getLogLevel(config.logLevel) >= LogLevel.DEBUG ? true : false
+    );
     process.env.RUST_BACKTRACE = getLogLevel(config.logLevel) >= LogLevel.DEBUG ? "full" : "none";
   }
   if (config.skipConfigLogging !== void 0) {
-    process.env[`${prefix}SKIP_CONFIG_LOGGING`] = String(config.skipConfigLogging);
+    process.env[`${prefix}SKIP_CONFIG_LOGGING`] = String(
+      config.skipConfigLogging
+    );
   }
   process.env[`${prefix}CONFIG`] = JSON.stringify(config);
   for (const key of Object.keys(config.extensions ?? {})) {
@@ -668,11 +766,11 @@ var setConfigEnv = /* @__PURE__ */ __name((config) => {
       setExtensionEnv(key, config.extensions[key]);
     }
   }
-}, "setConfigEnv");
-var setThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, config) => {
+};
+var setThemeColorConfigEnv = (prefix, config) => {
   return config?.light?.brand || config?.dark?.brand ? setMultiThemeColorConfigEnv(prefix, config) : setSingleThemeColorConfigEnv(prefix, config);
-}, "setThemeColorConfigEnv");
-var setSingleThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, config) => {
+};
+var setSingleThemeColorConfigEnv = (prefix, config) => {
   if (config.dark) {
     process.env[`${prefix}DARK`] = config.dark;
   }
@@ -715,14 +813,14 @@ var setSingleThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, config) => {
   if (config.negative) {
     process.env[`${prefix}NEGATIVE`] = config.negative;
   }
-}, "setSingleThemeColorConfigEnv");
-var setMultiThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, config) => {
+};
+var setMultiThemeColorConfigEnv = (prefix, config) => {
   return {
     light: setBaseThemeColorConfigEnv(`${prefix}LIGHT_`, config.light),
     dark: setBaseThemeColorConfigEnv(`${prefix}DARK_`, config.dark)
   };
-}, "setMultiThemeColorConfigEnv");
-var setBaseThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, config) => {
+};
+var setBaseThemeColorConfigEnv = (prefix, config) => {
   if (config.foreground) {
     process.env[`${prefix}FOREGROUND`] = config.foreground;
   }
@@ -765,12 +863,12 @@ var setBaseThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, config) => {
   if (config.negative) {
     process.env[`${prefix}NEGATIVE`] = config.negative;
   }
-}, "setBaseThemeColorConfigEnv");
+};
 
 // ../config-tools/src/create-storm-config.ts
 var _extension_cache = /* @__PURE__ */ new WeakMap();
 var _static_cache = void 0;
-var createStormWorkspaceConfig = /* @__PURE__ */ __name(async (extensionName, schema, workspaceRoot, skipLogs = false, useDefault = true) => {
+var createStormWorkspaceConfig = async (extensionName, schema, workspaceRoot, skipLogs = false, useDefault = true) => {
   let result;
   if (!_static_cache?.data || !_static_cache?.timestamp || _static_cache.timestamp < Date.now() - 8e3) {
     let _workspaceRoot = workspaceRoot;
@@ -781,16 +879,19 @@ var createStormWorkspaceConfig = /* @__PURE__ */ __name(async (extensionName, sc
     const configFile = await getConfigFile(_workspaceRoot);
     if (!configFile) {
       if (!skipLogs) {
-        writeWarning("No Storm Workspace configuration file found in the current repository. Please ensure this is the expected behavior - you can add a `storm-workspace.json` file to the root of your workspace if it is not.\n", {
-          logLevel: "all"
-        });
+        writeWarning(
+          "No Storm Workspace configuration file found in the current repository. Please ensure this is the expected behavior - you can add a `storm-workspace.json` file to the root of your workspace if it is not.\n",
+          { logLevel: "all" }
+        );
       }
       if (useDefault === false) {
         return void 0;
       }
     }
     const defaultConfig = await getDefaultConfig(_workspaceRoot);
-    result = await stormWorkspaceConfigSchema.parseAsync(defu2(configEnv, configFile, defaultConfig));
+    result = await stormWorkspaceConfigSchema.parseAsync(
+      defu2(configEnv, configFile, defaultConfig)
+    );
     result.workspaceRoot ??= _workspaceRoot;
   } else {
     result = _static_cache.data;
@@ -806,11 +907,9 @@ var createStormWorkspaceConfig = /* @__PURE__ */ __name(async (extensionName, sc
     data: result
   };
   return result;
-}, "createStormWorkspaceConfig");
-var createConfigExtension = /* @__PURE__ */ __name((extensionName, schema) => {
-  const extension_cache_key = {
-    extensionName
-  };
+};
+var createConfigExtension = (extensionName, schema) => {
+  const extension_cache_key = { extensionName };
   if (_extension_cache.has(extension_cache_key)) {
     return _extension_cache.get(extension_cache_key);
   }
@@ -820,25 +919,34 @@ var createConfigExtension = /* @__PURE__ */ __name((extensionName, schema) => {
   }
   _extension_cache.set(extension_cache_key, extension);
   return extension;
-}, "createConfigExtension");
-var loadStormWorkspaceConfig = /* @__PURE__ */ __name(async (workspaceRoot, skipLogs = false) => {
-  const config = await createStormWorkspaceConfig(void 0, void 0, workspaceRoot, skipLogs, true);
+};
+var loadStormWorkspaceConfig = async (workspaceRoot, skipLogs = false) => {
+  const config = await createStormWorkspaceConfig(
+    void 0,
+    void 0,
+    workspaceRoot,
+    skipLogs,
+    true
+  );
   setConfigEnv(config);
   if (!skipLogs && !config.skipConfigLogging) {
-    writeTrace(`\u2699\uFE0F  Using Storm Workspace configuration: 
-${formatLogMessage(config)}`, config);
+    writeTrace(
+      `\u2699\uFE0F  Using Storm Workspace configuration: 
+${formatLogMessage(config)}`,
+      config
+    );
   }
   return config;
-}, "loadStormWorkspaceConfig");
+};
 
 // ../config-tools/src/get-config.ts
-var getConfig = /* @__PURE__ */ __name((workspaceRoot, skipLogs = false) => {
+var getConfig = (workspaceRoot, skipLogs = false) => {
   return loadStormWorkspaceConfig(workspaceRoot, skipLogs);
-}, "getConfig");
+};
 
 // ../build-tools/src/utilities/get-entry-points.ts
 import { glob as glob2 } from "glob";
-var getEntryPoints = /* @__PURE__ */ __name(async (config, projectRoot, sourceRoot, entry, emitOnAll = false) => {
+var getEntryPoints = async (config, projectRoot, sourceRoot, entry, emitOnAll = false) => {
   const workspaceRoot = config.workspaceRoot || findWorkspaceRoot();
   const entryPoints = [];
   if (entry) {
@@ -851,35 +959,47 @@ var getEntryPoints = /* @__PURE__ */ __name(async (config, projectRoot, sourceRo
     }
   }
   if (emitOnAll) {
-    entryPoints.push(joinPaths(workspaceRoot, sourceRoot || projectRoot, "**/*.{ts,tsx}"));
-  }
-  const results = await Promise.all(entryPoints.map(async (entryPoint) => {
-    const paths = [];
-    if (entryPoint.includes("*")) {
-      const files = await glob2(entryPoint, {
-        withFileTypes: true,
-        ignore: [
-          "**/node_modules/**"
-        ]
-      });
-      paths.push(...files.reduce((ret, filePath) => {
-        const result = correctPaths(joinPaths(filePath.path, filePath.name).replaceAll(correctPaths(workspaceRoot), "").replaceAll(correctPaths(projectRoot), ""));
-        if (result) {
-          writeDebug(`Trying to add entry point ${result} at "${joinPaths(filePath.path, filePath.name)}"`, config);
-          if (!paths.includes(result)) {
-            paths.push(result);
-          }
+    entryPoints.push(
+      joinPaths(workspaceRoot, sourceRoot || projectRoot, "**/*.{ts,tsx}")
+    );
+  }
+  const results = await Promise.all(
+    entryPoints.map(async (entryPoint) => {
+      const paths = [];
+      if (entryPoint.includes("*")) {
+        const files = await glob2(entryPoint, {
+          withFileTypes: true,
+          ignore: ["**/node_modules/**"]
+        });
+        paths.push(
+          ...files.reduce((ret, filePath) => {
+            const result = correctPaths(
+              joinPaths(filePath.path, filePath.name).replaceAll(correctPaths(workspaceRoot), "").replaceAll(correctPaths(projectRoot), "")
+            );
+            if (result) {
+              writeDebug(
+                `Trying to add entry point ${result} at "${joinPaths(
+                  filePath.path,
+                  filePath.name
+                )}"`,
+                config
+              );
+              if (!paths.includes(result)) {
+                paths.push(result);
+              }
+            }
+            return ret;
+          }, [])
+        );
+      } else {
+        writeDebug(`Trying to add entry point ${entryPoint}"`, config);
+        if (!paths.includes(entryPoint)) {
+          paths.push(entryPoint);
         }
-        return ret;
-      }, []));
-    } else {
-      writeDebug(`Trying to add entry point ${entryPoint}"`, config);
-      if (!paths.includes(entryPoint)) {
-        paths.push(entryPoint);
       }
-    }
-    return paths;
-  }));
+      return paths;
+    })
+  );
   return results.filter(Boolean).reduce((ret, result) => {
     result.forEach((res) => {
       if (res && !ret.includes(res)) {
@@ -888,10 +1008,10 @@ var getEntryPoints = /* @__PURE__ */ __name(async (config, projectRoot, sourceRo
     });
     return ret;
   }, []);
-}, "getEntryPoints");
+};
 
 // ../build-tools/src/utilities/get-env.ts
-var getEnv = /* @__PURE__ */ __name((builder, options) => {
+var getEnv = (builder, options) => {
   return {
     STORM_BUILD: builder,
     STORM_ORG: options.orgName || DEFAULT_ORGANIZATION,
@@ -902,14 +1022,17 @@ var getEnv = /* @__PURE__ */ __name((builder, options) => {
     STORM_TARGET: JSON.stringify(options.target),
     ...options.env
   };
-}, "getEnv");
+};
 
 // ../build-tools/src/utilities/read-nx-config.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { readFile as readFile3 } from "node:fs/promises";
 
 // ../build-tools/src/utilities/task-graph.ts
-import { createTaskGraph, mapTargetDefaultsToDependencies } from "nx/src/tasks-runner/create-task-graph";
+import {
+  createTaskGraph,
+  mapTargetDefaultsToDependencies
+} from "nx/src/tasks-runner/create-task-graph";
 
 // src/build.ts
 import defu3 from "defu";
@@ -917,7 +1040,7 @@ import { existsSync as existsSync3 } from "node:fs";
 import hf from "node:fs/promises";
 import { findWorkspaceRoot as findWorkspaceRoot2 } from "nx/src/utils/find-workspace-root";
 import { build as tsdown } from "tsdown";
-var resolveOptions = /* @__PURE__ */ __name(async (userOptions) => {
+var resolveOptions = async (userOptions) => {
   const projectRoot = userOptions.projectRoot;
   const workspaceRoot = findWorkspaceRoot2(projectRoot);
   if (!workspaceRoot) {
@@ -929,7 +1052,11 @@ var resolveOptions = /* @__PURE__ */ __name(async (userOptions) => {
   const projectGraph = await createProjectGraphAsync2({
     exitOnError: true
   });
-  const projectJsonPath = joinPaths(workspaceRoot.dir, projectRoot, "project.json");
+  const projectJsonPath = joinPaths(
+    workspaceRoot.dir,
+    projectRoot,
+    "project.json"
+  );
   if (!existsSync3(projectJsonPath)) {
     throw new Error("Cannot find project.json configuration");
   }
@@ -938,12 +1065,18 @@ var resolveOptions = /* @__PURE__ */ __name(async (userOptions) => {
   const projectName = projectJson.name;
   const projectConfigurations = readProjectsConfigurationFromProjectGraph2(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.");
+    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 = defu3(userOptions, DEFAULT_BUILD_OPTIONS);
   options.name ??= `${projectName}-${options.format}`;
   options.target ??= DEFAULT_TARGET;
-  const packageJsonPath = joinPaths(workspaceRoot.dir, options.projectRoot, "package.json");
+  const packageJsonPath = joinPaths(
+    workspaceRoot.dir,
+    options.projectRoot,
+    "package.json"
+  );
   if (!existsSync3(packageJsonPath)) {
     throw new Error("Cannot find package.json configuration");
   }
@@ -952,11 +1085,18 @@ var resolveOptions = /* @__PURE__ */ __name(async (userOptions) => {
     ...options,
     config,
     ...userOptions,
-    tsconfig: joinPaths(projectRoot, userOptions.tsconfig ? userOptions.tsconfig.replace(projectRoot, "") : "tsconfig.json"),
+    tsconfig: joinPaths(
+      projectRoot,
+      userOptions.tsconfig ? userOptions.tsconfig.replace(projectRoot, "") : "tsconfig.json"
+    ),
     format: options.format || "cjs",
-    entryPoints: await getEntryPoints(config, projectRoot, projectJson.sourceRoot, userOptions.entry || [
-      "./src/index.ts"
-    ], userOptions.emitOnAll),
+    entryPoints: await getEntryPoints(
+      config,
+      projectRoot,
+      projectJson.sourceRoot,
+      userOptions.entry || ["./src/index.ts"],
+      userOptions.emitOnAll
+    ),
     outdir: userOptions.outputPath || joinPaths("dist", projectRoot),
     plugins: [],
     name: userOptions.name || projectName,
@@ -971,9 +1111,7 @@ var resolveOptions = /* @__PURE__ */ __name(async (userOptions) => {
     generatePackageJson: userOptions.generatePackageJson !== false,
     clean: userOptions.clean !== false,
     emitOnAll: userOptions.emitOnAll === true,
-    dts: userOptions.dts === true ? {
-      transformer: "oxc"
-    } : userOptions.dts,
+    dts: userOptions.dts === true ? { transformer: "oxc" } : userOptions.dts,
     bundleDts: userOptions.dts,
     assets: userOptions.assets ?? [],
     shims: userOptions.injectShims !== true,
@@ -997,7 +1135,7 @@ var resolveOptions = /* @__PURE__ */ __name(async (userOptions) => {
   };
   stopwatch();
   return result;
-}, "resolveOptions");
+};
 async function generatePackageJson(options) {
   if (options.generatePackageJson !== false && existsSync3(joinPaths(options.projectRoot, "package.json"))) {
     writeDebug("  \u270D\uFE0F   Writing package.json file", options.config);
@@ -1006,51 +1144,74 @@ async function generatePackageJson(options) {
     if (!existsSync3(packageJsonPath)) {
       throw new Error("Cannot find package.json configuration");
     }
-    const packageJsonFile = await hf.readFile(joinPaths(options.config.workspaceRoot, options.projectRoot, "package.json"), "utf8");
+    const packageJsonFile = await hf.readFile(
+      joinPaths(
+        options.config.workspaceRoot,
+        options.projectRoot,
+        "package.json"
+      ),
+      "utf8"
+    );
     if (!packageJsonFile) {
       throw new Error("Cannot find package.json configuration file");
     }
     let packageJson = JSON.parse(packageJsonFile);
-    packageJson = await addPackageDependencies(options.config.workspaceRoot, options.projectRoot, options.projectName, packageJson);
-    packageJson = await addWorkspacePackageJsonFields(options.config, options.projectRoot, options.sourceRoot, options.projectName, false, packageJson);
+    packageJson = await addPackageDependencies(
+      options.config.workspaceRoot,
+      options.projectRoot,
+      options.projectName,
+      packageJson
+    );
+    packageJson = await addWorkspacePackageJsonFields(
+      options.config,
+      options.projectRoot,
+      options.sourceRoot,
+      options.projectName,
+      false,
+      packageJson
+    );
     packageJson.exports ??= {};
     packageJson.exports["./package.json"] ??= "./package.json";
-    packageJson.exports["."] ??= addPackageJsonExport("index", packageJson.type, options.sourceRoot);
-    let entryPoints = [
-      {
-        in: "./src/index.ts",
-        out: "./src/index.ts"
-      }
-    ];
+    packageJson.exports["."] ??= addPackageJsonExport(
+      "index",
+      packageJson.type,
+      options.sourceRoot
+    );
+    let entryPoints = [{ in: "./src/index.ts", out: "./src/index.ts" }];
     if (options.entryPoints) {
       if (Array.isArray(options.entryPoints)) {
-        entryPoints = options.entryPoints.map((entryPoint) => typeof entryPoint === "string" ? {
-          in: entryPoint,
-          out: entryPoint
-        } : entryPoint);
+        entryPoints = 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}`] ??= addPackageJsonExport(entry, packageJson.type, options.sourceRoot);
+        packageJson.exports[`./${entry}`] ??= addPackageJsonExport(
+          entry,
+          packageJson.type,
+          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);
+    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 writeJsonFile(joinPaths(options.outdir, "package.json"), packageJson);
     stopwatch();
   }
   return options;
 }
-__name(generatePackageJson, "generatePackageJson");
 async function executeTSDown(options) {
   writeDebug(`  \u{1F680}  Running ${options.name} build`, options.config);
   const stopwatch = getStopwatch(`${options.name} build`);
@@ -1063,60 +1224,78 @@ async function executeTSDown(options) {
   stopwatch();
   return options;
 }
-__name(executeTSDown, "executeTSDown");
 async function copyBuildAssets(options) {
-  writeDebug(`  \u{1F4CB}  Copying asset files to output directory: ${options.outdir}`, options.config);
+  writeDebug(
+    `  \u{1F4CB}  Copying asset files to output directory: ${options.outdir}`,
+    options.config
+  );
   const stopwatch = getStopwatch(`${options.name} asset copy`);
-  await copyAssets(options.config, options.assets ?? [], options.outdir, options.projectRoot, options.sourceRoot, true, false);
+  await copyAssets(
+    options.config,
+    options.assets ?? [],
+    options.outdir,
+    options.projectRoot,
+    options.sourceRoot,
+    true,
+    false
+  );
   stopwatch();
   return options;
 }
-__name(copyBuildAssets, "copyBuildAssets");
 async function reportResults(options) {
-  writeSuccess(`  \u{1F4E6}  The ${options.name} build completed successfully`, options.config);
+  writeSuccess(
+    `  \u{1F4E6}  The ${options.name} build completed successfully`,
+    options.config
+  );
 }
-__name(reportResults, "reportResults");
 async function cleanOutputPath(options) {
   if (options.clean !== false && options.outdir) {
-    writeDebug(` \u{1F9F9}  Cleaning ${options.name} output path: ${options.outdir}`, options.config);
+    writeDebug(
+      ` \u{1F9F9}  Cleaning ${options.name} output path: ${options.outdir}`,
+      options.config
+    );
     const stopwatch = getStopwatch(`${options.name} output clean`);
     await cleanDirectories(options.name, options.outdir, options.config);
     stopwatch();
   }
   return options;
 }
-__name(cleanOutputPath, "cleanOutputPath");
 async function build(options) {
   writeDebug(`  \u26A1   Executing Storm TSDown pipeline`);
   const stopwatch = getStopwatch("TSDown pipeline");
   try {
-    const opts = Array.isArray(options) ? options : [
-      options
-    ];
+    const opts = Array.isArray(options) ? options : [options];
     if (opts.length === 0) {
       throw new Error("No build options were provided");
     }
-    const resolved = await Promise.all(opts.map(async (opt) => await resolveOptions(opt)));
+    const resolved = await Promise.all(
+      opts.map(async (opt) => await resolveOptions(opt))
+    );
     if (resolved.length > 0) {
       await cleanOutputPath(resolved[0]);
       await generatePackageJson(resolved[0]);
-      await Promise.all(resolved.map(async (opt) => {
-        await executeTSDown(opt);
-        await copyBuildAssets(opt);
-        await reportResults(opt);
-      }));
+      await Promise.all(
+        resolved.map(async (opt) => {
+          await executeTSDown(opt);
+          await copyBuildAssets(opt);
+          await reportResults(opt);
+        })
+      );
     } else {
-      writeWarning("  \u{1F6A7}   No options were passed to TSBuild. Please check the parameters passed to the `build` function.");
+      writeWarning(
+        "  \u{1F6A7}   No options were passed to TSBuild. Please check the parameters passed to the `build` function."
+      );
     }
     writeSuccess("  \u{1F3C1}  TSDown pipeline build completed successfully");
   } catch (error) {
-    writeFatal("Fatal errors that the build process could not recover from have occured. The build process has been terminated.");
+    writeFatal(
+      "Fatal errors that the build process could not recover from have occured. The build process has been terminated."
+    );
     throw error;
   } finally {
     stopwatch();
   }
 }
-__name(build, "build");
 
 export {
   cleanOutputPath,