@storm-software/tsdown 0.24.10 → 0.24.11

package/README.md

@@ -21,7 +21,7 @@ This package is part of the <b>⚡Storm-Ops</b> monorepo. The Storm-Ops packages
 
 <h3 align="center">💻 Visit <a href="https://stormsoftware.com" target="_blank">stormsoftware.com</a> to stay up to date with this developer</h3><br />
 
-[![Version](https://img.shields.io/badge/version-0.24.9-1fb2a6.svg?style=for-the-badge&color=1fb2a6)](https://prettier.io/)&nbsp;[![Nx](https://img.shields.io/badge/Nx-17.0.2-lightgrey?style=for-the-badge&logo=nx&logoWidth=20&&color=1fb2a6)](http://nx.dev/)&nbsp;[![NextJs](https://img.shields.io/badge/Next.js-14.0.2-lightgrey?style=for-the-badge&logo=nextdotjs&logoWidth=20&color=1fb2a6)](https://nextjs.org/)&nbsp;[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg?style=for-the-badge&logo=commitlint&color=1fb2a6)](http://commitizen.github.io/cz-cli/)&nbsp;![Semantic-Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=for-the-badge&color=1fb2a6)&nbsp;[![documented with Fumadocs](https://img.shields.io/badge/documented_with-fumadocs-success.svg?style=for-the-badge&logo=readthedocs&color=1fb2a6)](https://fumadocs.vercel.app/)&nbsp;![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/storm-software/storm-ops/cr.yml?style=for-the-badge&logo=github-actions&color=1fb2a6)
+[![Version](https://img.shields.io/badge/version-0.24.11-1fb2a6.svg?style=for-the-badge&color=1fb2a6)](https://prettier.io/)&nbsp;[![Nx](https://img.shields.io/badge/Nx-17.0.2-lightgrey?style=for-the-badge&logo=nx&logoWidth=20&&color=1fb2a6)](http://nx.dev/)&nbsp;[![NextJs](https://img.shields.io/badge/Next.js-14.0.2-lightgrey?style=for-the-badge&logo=nextdotjs&logoWidth=20&color=1fb2a6)](https://nextjs.org/)&nbsp;[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg?style=for-the-badge&logo=commitlint&color=1fb2a6)](http://commitizen.github.io/cz-cli/)&nbsp;![Semantic-Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=for-the-badge&color=1fb2a6)&nbsp;[![documented with Fumadocs](https://img.shields.io/badge/documented_with-fumadocs-success.svg?style=for-the-badge&logo=readthedocs&color=1fb2a6)](https://fumadocs.vercel.app/)&nbsp;![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/storm-software/storm-ops/cr.yml?style=for-the-badge&logo=github-actions&color=1fb2a6)
 
 <!-- prettier-ignore-start -->
 <!-- markdownlint-disable -->

package/bin/tsdown.cjs

@@ -0,0 +1,474 @@
+#!/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/tsdown.ts
+var import_get_config2 = require("@storm-software/config-tools/get-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_devkit = require("@nx/devkit");
+var import_build_tools = require("@storm-software/build-tools");
+var import_get_config = require("@storm-software/config-tools/get-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_paths = require("@storm-software/config-tools/utilities/correct-paths");
+
+// ../../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_node_fs = require("fs");
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_find_workspace_root = require("nx/src/utils/find-workspace-root");
+var import_tsdown = require("tsdown");
+
+// src/clean.ts
+var import_console = require("@storm-software/config-tools/logger/console");
+var import_promises = require("fs/promises");
+async function clean(name = "TSDown", directory, config) {
+  (0, import_console.writeDebug)(` \u{1F9F9}  Cleaning ${name} output path: ${directory}`, config);
+  const stopwatch = (0, import_console.getStopwatch)(`${name} output clean`);
+  await cleanDirectories(name, directory, config);
+  stopwatch();
+}
+__name(clean, "clean");
+async function cleanDirectories(name = "TSDown", directory, config) {
+  await (0, import_promises.rm)(directory, {
+    recursive: true,
+    force: true
+  });
+}
+__name(cleanDirectories, "cleanDirectories");
+
+// src/config.ts
+var DEFAULT_BUILD_OPTIONS = {
+  platform: "node",
+  target: "node22",
+  format: [
+    "esm",
+    "cjs"
+  ],
+  tsconfig: "tsconfig.json",
+  envName: "production",
+  globalName: "globalThis",
+  unused: {
+    level: "error"
+  },
+  injectShims: true,
+  watch: false,
+  bundle: true,
+  treeshake: true,
+  clean: true,
+  debug: false
+};
+
+// 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_get_config.getConfig)(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_paths.joinPaths)(workspaceRoot.dir, projectRoot, "project.json");
+  if (!(0, import_node_fs.existsSync)(projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const projectJsonFile = await import_promises2.default.readFile(projectJsonPath, "utf8");
+  const projectJson = JSON.parse(projectJsonFile);
+  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_paths.joinPaths)(workspaceRoot.dir, options.projectRoot, "package.json");
+  if (!(0, import_node_fs.existsSync)(packageJsonPath)) {
+    throw new Error("Cannot find package.json configuration");
+  }
+  const env = (0, import_build_tools.getEnv)("tsdown", options);
+  const result = {
+    ...options,
+    config,
+    ...userOptions,
+    tsconfig: (0, import_correct_paths.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_paths.joinPaths)("dist", projectRoot),
+    plugins: [],
+    name: userOptions.name || projectName,
+    projectConfigurations,
+    projectName,
+    projectGraph,
+    sourceRoot: userOptions.sourceRoot || projectJson.sourceRoot || (0, import_correct_paths.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,
+    dts: userOptions.emitTypes === true ? {
+      transformer: "oxc"
+    } : userOptions.emitTypes,
+    bundleDts: userOptions.emitTypes,
+    assets: userOptions.assets ?? [],
+    shims: userOptions.injectShims !== true,
+    bundle: userOptions.bundle !== false,
+    watch: userOptions.watch === true,
+    define: {
+      STORM_FORMAT: JSON.stringify(options.format || "cjs"),
+      ...options.format === "cjs" && options.injectShims ? {
+        "import.meta.url": "importMetaUrl"
+      } : {},
+      ...Object.keys(env || {}).reduce((res, key) => {
+        const value = JSON.stringify(env[key]);
+        return {
+          ...res,
+          [`process.env.${key}`]: value,
+          [`import.meta.env.${key}`]: value
+        };
+      }, {}),
+      ...options.define
+    }
+  };
+  stopwatch();
+  return result;
+}, "resolveOptions");
+async function generatePackageJson(options) {
+  if (options.generatePackageJson !== false && (0, import_node_fs.existsSync)((0, import_correct_paths.joinPaths)(options.projectRoot, "package.json"))) {
+    (0, import_console2.writeDebug)("  \u270D\uFE0F   Writing package.json file", options.config);
+    const stopwatch = (0, import_console2.getStopwatch)("Write package.json file");
+    const packageJsonPath = (0, import_correct_paths.joinPaths)(options.projectRoot, "project.json");
+    if (!(0, import_node_fs.existsSync)(packageJsonPath)) {
+      throw new Error("Cannot find package.json configuration");
+    }
+    const packageJsonFile = await import_promises2.default.readFile((0, import_correct_paths.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 (0, import_build_tools.addPackageDependencies)(options.config.workspaceRoot, options.projectRoot, options.projectName, packageJson);
+    packageJson = await (0, import_build_tools.addWorkspacePackageJsonFields)(options.config, options.projectRoot, options.sourceRoot, options.projectName, false, packageJson);
+    packageJson.exports ??= {};
+    packageJson.exports["./package.json"] ??= "./package.json";
+    packageJson.exports["."] ??= (0, import_build_tools.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);
+      }
+      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, 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_paths.joinPaths)(options.outdir, "package.json"), packageJson);
+    stopwatch();
+  }
+  return options;
+}
+__name(generatePackageJson, "generatePackageJson");
+async function executeTSDown(options) {
+  (0, import_console2.writeDebug)(`  \u{1F680}  Running ${options.name} build`, options.config);
+  const stopwatch = (0, import_console2.getStopwatch)(`${options.name} build`);
+  await (0, import_tsdown.build)({
+    ...options,
+    entry: options.entryPoints,
+    outDir: options.outdir,
+    config: false
+  });
+  stopwatch();
+  return options;
+}
+__name(executeTSDown, "executeTSDown");
+async function copyBuildAssets(options) {
+  (0, import_console2.writeDebug)(`  \u{1F4CB}  Copying asset files to output directory: ${options.outdir}`, options.config);
+  const stopwatch = (0, import_console2.getStopwatch)(`${options.name} asset copy`);
+  await (0, import_build_tools.copyAssets)(options.config, options.assets ?? [], options.outdir, options.projectRoot, options.sourceRoot, true, false);
+  stopwatch();
+  return options;
+}
+__name(copyBuildAssets, "copyBuildAssets");
+async function reportResults(options) {
+  (0, import_console2.writeSuccess)(`  \u{1F4E6}  The ${options.name} build completed successfully`, options.config);
+}
+__name(reportResults, "reportResults");
+async function cleanOutputPath(options) {
+  if (options.clean !== false && options.outdir) {
+    (0, import_console2.writeDebug)(` \u{1F9F9}  Cleaning ${options.name} output path: ${options.outdir}`, options.config);
+    const stopwatch = (0, import_console2.getStopwatch)(`${options.name} output clean`);
+    await cleanDirectories(options.name, options.outdir, options.config);
+    stopwatch();
+  }
+  return options;
+}
+__name(cleanOutputPath, "cleanOutputPath");
+async function build(options) {
+  (0, import_console2.writeDebug)(`  \u26A1   Executing Storm TSDown pipeline`);
+  const stopwatch = (0, import_console2.getStopwatch)("TSDown pipeline");
+  try {
+    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)));
+    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);
+      }));
+    } else {
+      (0, import_console2.writeWarning)("  \u{1F6A7}   No options were passed to TSBuild. Please check the parameters passed to the `build` function.");
+    }
+    (0, import_console2.writeSuccess)("  \u{1F3C1}  TSDown 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(build, "build");
+
+// bin/tsdown.ts
+async function createProgram(config) {
+  try {
+    (0, import_console3.writeInfo)("\u26A1 Running Storm TSDown 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-tsdown");
+    program.version("1.0.0", "-v --version", "display CLI version");
+    program.description("\u26A1 Run the Storm TSDown 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 TSDown, 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 build({
+      ...options,
+      format: options.format
+    });
+  } catch (e) {
+    (0, import_console3.writeFatal)(`A fatal error occurred while cleaning the TSDown 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 TSDown output directory: ${e.message}`, config);
+    (0, import_process_handler.exitWithError)(config);
+    process.exit(1);
+  }
+}, "cleanAction");
+void (async () => {
+  const config = await (0, import_get_config2.getConfig)();
+  const stopwatch = (0, import_console3.getStopwatch)("Storm TSDown 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 TSDown executable has completed successfully!`, config);
+    (0, import_process_handler.exitWithSuccess)(config);
+  } catch (error) {
+    (0, import_console3.writeFatal)(`A fatal error occurred while running Storm TSDown executable: 
+
+${error.message}`, config);
+    (0, import_process_handler.exitWithError)(config);
+    process.exit(1);
+  } finally {
+    stopwatch();
+  }
+})();

package/dist/build.cjs

@@ -1,11 +1,11 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
 
-var _chunkESRFPDLRcjs = require('./chunk-ESRFPDLR.cjs');
-require('./chunk-IHU462CN.cjs');
+var _chunk75765MSLcjs = require('./chunk-75765MSL.cjs');
+require('./chunk-52NJUFUL.cjs');
 require('./chunk-5KRF6IVW.cjs');
 require('./chunk-USNT2KNT.cjs');
 
 
 
-exports.build = _chunkESRFPDLRcjs.build; exports.cleanOutputPath = _chunkESRFPDLRcjs.cleanOutputPath;
+exports.build = _chunk75765MSLcjs.build; exports.cleanOutputPath = _chunk75765MSLcjs.cleanOutputPath;

package/dist/build.js

@@ -1,8 +1,8 @@
 import {
   build,
   cleanOutputPath
-} from "./chunk-FG4EBMPW.js";
-import "./chunk-TXAM2HUM.js";
+} from "./chunk-UR5MYUPB.js";
+import "./chunk-KB6FL5TT.js";
 import "./chunk-UQLCBJOS.js";
 import "./chunk-SHUYVCID.js";
 export {

package/dist/{chunk-IHU462CN.cjs → chunk-52NJUFUL.cjs}

@@ -203,28 +203,131 @@ var _promises = require('fs/promises');
 var _path = require('path');
 
 // ../config-tools/src/utilities/correct-paths.ts
-
-var removeWindowsDriveLetter = /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, (osSpecificPath) => {
-  return osSpecificPath.replace(/^[A-Z]:/, "");
-}, "removeWindowsDriveLetter");
-var correctPaths = /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, (path) => {
-  if (!path) {
-    return "";
+var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, normalizeWindowsPath, "normalizeWindowsPath");
+var _UNC_REGEX = /^[/\\]{2}/;
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+var _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+var correctPaths = /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, function(path) {
+  if (!path || path.length === 0) {
+    return ".";
   }
-  if (path.includes("\\")) {
-    if (!path.toUpperCase().startsWith("C:")) {
-      path = `C:${path}`;
+  path = normalizeWindowsPath(path);
+  const isUNCPath = path.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path[path.length - 1] === "/";
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
     }
-    return path.replaceAll("/", "\\");
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
   }
-  return removeWindowsDriveLetter(path).split("\\").join("/");
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
 }, "correctPaths");
-var joinPaths = /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, (...paths) => {
-  if (!paths || paths.length === 0) {
-    return "";
+var joinPaths = /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, function(...segments) {
+  let path = "";
+  for (const seg of segments) {
+    if (!seg) {
+      continue;
+    }
+    if (path.length > 0) {
+      const pathTrailing = path[path.length - 1] === "/";
+      const segLeading = seg[0] === "/";
+      const both = pathTrailing && segLeading;
+      if (both) {
+        path += seg.slice(1);
+      } else {
+        path += pathTrailing || segLeading ? seg : `/${seg}`;
+      }
+    } else {
+      path += seg;
+    }
   }
-  return correctPaths(_path.join.call(void 0, ...paths));
+  return correctPaths(path);
 }, "joinPaths");
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) {
+      } else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, normalizeString, "normalizeString");
+var isAbsolute = /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+}, "isAbsolute");
 
 // ../config-tools/src/utilities/find-up.ts