@storm-software/unbuild 0.25.2 → 0.26.0

package/bin/unbuild.cjs

@@ -0,0 +1,3366 @@
+#!/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
+));
+
+// ../../node_modules/.pnpm/tsup@8.3.5_@microsoft+api-extractor@7.49.1_@types+node@22.10.7__@swc+core@1.7.26_@swc+helpers_ekim6y52mwpq6ssxiprcp44dam/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = /* @__PURE__ */ __name(() => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href, "getImportMetaUrl");
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// ../config/src/schema.ts
+var import_zod = __toESM(require("zod"));
+
+// ../config/src/constants.ts
+var STORM_DEFAULT_DOCS = "https://docs.stormsoftware.com";
+var STORM_DEFAULT_HOMEPAGE = "https://stormsoftware.com";
+var STORM_DEFAULT_LICENSING = "https://license.stormsoftware.com";
+var STORM_DEFAULT_LICENSE = "Apache-2.0";
+
+// ../config/src/schema.ts
+var DarkColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#1d1e22").describe("The dark background color of the workspace");
+var LightColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#f4f4f5").describe("The light background color of the workspace");
+var BrandColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#1fb2a6").describe("The primary brand specific color of the workspace");
+var AlternateColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).optional().describe("The alternate brand specific color of the workspace");
+var AccentColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).optional().describe("The secondary brand specific color of the workspace");
+var LinkColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).optional().describe("The color used to display hyperlink text");
+var HelpColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#8256D0").describe("The second brand specific color of the workspace");
+var SuccessColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#12B66A").describe("The success color of the workspace");
+var InfoColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#0070E0").describe("The informational color of the workspace");
+var WarningColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#fcc419").describe("The warning color of the workspace");
+var DangerColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#D8314A").describe("The danger color of the workspace");
+var FatalColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).optional().describe("The fatal color of the workspace");
+var PositiveColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#4ade80").describe("The positive number color of the workspace");
+var NegativeColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#ef4444").describe("The negative number color of the workspace");
+var DarkThemeColorConfigSchema = import_zod.default.object({
+  foreground: LightColorSchema,
+  background: DarkColorSchema,
+  brand: BrandColorSchema,
+  alternate: AlternateColorSchema,
+  accent: AccentColorSchema,
+  link: LinkColorSchema,
+  help: HelpColorSchema,
+  success: SuccessColorSchema,
+  info: InfoColorSchema,
+  warning: WarningColorSchema,
+  danger: DangerColorSchema,
+  fatal: FatalColorSchema,
+  positive: PositiveColorSchema,
+  negative: NegativeColorSchema
+});
+var LightThemeColorConfigSchema = import_zod.default.object({
+  foreground: DarkColorSchema,
+  background: LightColorSchema,
+  brand: BrandColorSchema,
+  alternate: AlternateColorSchema,
+  accent: AccentColorSchema,
+  link: LinkColorSchema,
+  help: HelpColorSchema,
+  success: SuccessColorSchema,
+  info: InfoColorSchema,
+  warning: WarningColorSchema,
+  danger: DangerColorSchema,
+  fatal: FatalColorSchema,
+  positive: PositiveColorSchema,
+  negative: NegativeColorSchema
+});
+var MultiThemeColorConfigSchema = import_zod.default.object({
+  dark: DarkThemeColorConfigSchema,
+  light: LightThemeColorConfigSchema
+});
+var SingleThemeColorConfigSchema = import_zod.default.object({
+  dark: DarkColorSchema,
+  light: LightColorSchema,
+  brand: BrandColorSchema,
+  alternate: AlternateColorSchema,
+  accent: AccentColorSchema,
+  link: LinkColorSchema,
+  help: HelpColorSchema,
+  success: SuccessColorSchema,
+  info: InfoColorSchema,
+  warning: WarningColorSchema,
+  danger: DangerColorSchema,
+  fatal: FatalColorSchema,
+  positive: PositiveColorSchema,
+  negative: NegativeColorSchema
+});
+var RegistryUrlConfigSchema = import_zod.default.string().trim().toLowerCase().url().optional().describe("A remote registry URL used to publish distributable packages");
+var RegistryConfigSchema = import_zod.default.object({
+  github: RegistryUrlConfigSchema,
+  npm: RegistryUrlConfigSchema,
+  cargo: RegistryUrlConfigSchema,
+  cyclone: RegistryUrlConfigSchema,
+  container: RegistryUrlConfigSchema
+}).default({}).describe("A list of remote registry URLs used by Storm Software");
+var ColorConfigSchema = SingleThemeColorConfigSchema.or(MultiThemeColorConfigSchema).describe("Colors used for various workspace elements");
+var ColorConfigMapSchema = import_zod.default.union([
+  import_zod.default.object({
+    "base": ColorConfigSchema
+  }),
+  import_zod.default.record(import_zod.default.string(), ColorConfigSchema)
+]);
+var WorkspaceBotConfigSchema = import_zod.default.object({
+  name: import_zod.default.string().trim().default("Stormie-Bot").describe("The workspace bot user's name (this is the bot that will be used to perform various tasks)"),
+  email: import_zod.default.string().trim().email().default("bot@stormsoftware.com").describe("The email of the workspace bot")
+}).describe("The workspace's bot user's config used to automated various operations tasks");
+var WorkspaceDirectoryConfigSchema = import_zod.default.object({
+  cache: import_zod.default.string().trim().optional().describe("The directory used to store the environment's cached file data"),
+  data: import_zod.default.string().trim().optional().describe("The directory used to store the environment's data files"),
+  config: import_zod.default.string().trim().optional().describe("The directory used to store the environment's configuration files"),
+  temp: import_zod.default.string().trim().optional().describe("The directory used to store the environment's temp files"),
+  log: import_zod.default.string().trim().optional().describe("The directory used to store the environment's temp files"),
+  build: import_zod.default.string().trim().default("dist").describe("The directory used to store the workspace's distributable files after a build (relative to the workspace root)")
+}).describe("Various directories used by the workspace to store data, cache, and configuration files");
+var StormConfigSchema = import_zod.default.object({
+  $schema: import_zod.default.string().trim().default("https://cdn.jsdelivr.net/npm/@storm-software/config/schemas/storm.schema.json").optional().nullish().describe("The URL to the JSON schema file that describes the Storm configuration file"),
+  extends: import_zod.default.string().trim().optional().describe("The path to a base JSON file to use as a configuration preset file"),
+  name: import_zod.default.string().trim().toLowerCase().optional().describe("The name of the service/package/scope using this configuration"),
+  namespace: import_zod.default.string().trim().toLowerCase().optional().describe("The namespace of the package"),
+  organization: import_zod.default.string().trim().default("storm-software").describe("The organization of the workspace"),
+  repository: import_zod.default.string().trim().url().optional().describe("The repo URL of the workspace (i.e. GitHub)"),
+  license: import_zod.default.string().trim().default("Apache-2.0").describe("The license type of the package"),
+  homepage: import_zod.default.string().trim().url().default(STORM_DEFAULT_HOMEPAGE).describe("The homepage of the workspace"),
+  docs: import_zod.default.string().trim().url().default(STORM_DEFAULT_DOCS).describe("The base documentation site for the workspace"),
+  licensing: import_zod.default.string().trim().url().default(STORM_DEFAULT_LICENSING).describe("The base licensing site for the workspace"),
+  branch: import_zod.default.string().trim().default("main").describe("The branch of the workspace"),
+  preid: import_zod.default.string().optional().describe("A tag specifying the version pre-release identifier"),
+  owner: import_zod.default.string().trim().default("@storm-software/admin").describe("The owner of the package"),
+  bot: WorkspaceBotConfigSchema,
+  env: import_zod.default.enum([
+    "development",
+    "staging",
+    "production"
+  ]).default("production").describe("The current runtime environment name for the package"),
+  workspaceRoot: import_zod.default.string().trim().default("").describe("The root directory of the workspace"),
+  externalPackagePatterns: import_zod.default.array(import_zod.default.string()).default([]).describe("The build will use these package patterns to determine if they should be external to the bundle"),
+  skipCache: import_zod.default.boolean().default(false).describe("Should all known types of workspace caching be skipped?"),
+  directories: WorkspaceDirectoryConfigSchema,
+  packageManager: import_zod.default.enum([
+    "npm",
+    "yarn",
+    "pnpm",
+    "bun"
+  ]).default("npm").describe("The JavaScript/TypeScript package manager used by the repository"),
+  timezone: import_zod.default.string().trim().default("America/New_York").describe("The default timezone of the workspace"),
+  locale: import_zod.default.string().trim().default("en-US").describe("The default locale of the workspace"),
+  logLevel: import_zod.default.enum([
+    "silent",
+    "fatal",
+    "error",
+    "warn",
+    "success",
+    "info",
+    "debug",
+    "trace",
+    "all"
+  ]).default("info").describe("The log level used to filter out lower priority log messages. If not provided, this is defaulted using the `environment` config value (if `environment` is set to `production` then `level` is `error`, else `level` is `debug`)."),
+  registry: RegistryConfigSchema,
+  configFile: import_zod.default.string().trim().nullable().default(null).describe("The filepath of the Storm config. When this field is null, no config file was found in the current workspace."),
+  colors: ColorConfigSchema.or(ColorConfigMapSchema).describe("Storm theme config values used for styling various package elements"),
+  extensions: import_zod.default.record(import_zod.default.any()).optional().default({}).describe("Configuration of each used extension")
+}).describe("Storm Workspace config values used during various dev-ops processes. This type is a combination of the StormPackageConfig and StormProject types. It represents the config of the entire monorepo.");
+
+// ../config-tools/src/create-storm-config.ts
+var import_defu2 = __toESM(require("defu"), 1);
+
+// ../config-tools/src/config-file/get-config-file.ts
+var import_c12 = require("c12");
+var import_defu = __toESM(require("defu"), 1);
+
+// ../config-tools/src/types.ts
+var LogLevel = {
+  SILENT: 0,
+  FATAL: 10,
+  ERROR: 20,
+  WARN: 30,
+  SUCCESS: 35,
+  INFO: 40,
+  DEBUG: 60,
+  TRACE: 70,
+  ALL: 100
+};
+var LogLevelLabel = {
+  SILENT: "silent",
+  FATAL: "fatal",
+  ERROR: "error",
+  WARN: "warn",
+  SUCCESS: "success",
+  INFO: "info",
+  DEBUG: "debug",
+  TRACE: "trace",
+  ALL: "all"
+};
+
+// ../config/src/types.ts
+var COLOR_KEYS = [
+  "dark",
+  "light",
+  "base",
+  "brand",
+  "alternate",
+  "accent",
+  "link",
+  "success",
+  "help",
+  "info",
+  "warning",
+  "danger",
+  "fatal",
+  "positive",
+  "negative"
+];
+
+// ../config-tools/src/utilities/get-default-config.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+
+// ../config-tools/src/utilities/correct-paths.ts
+var import_devkit = require("@nx/devkit");
+var correctPaths = /* @__PURE__ */ __name((path2) => {
+  if (!path2) {
+    return "";
+  }
+  if (!path2.toUpperCase().startsWith("C:") && path2.includes("\\")) {
+    path2 = `C:${path2}`;
+  }
+  return path2.replaceAll("\\", "/");
+}, "correctPaths");
+var joinPaths = /* @__PURE__ */ __name((...paths) => {
+  if (!paths || paths.length === 0) {
+    return "";
+  }
+  return correctPaths((0, import_devkit.joinPathFragments)(...paths.map((path2) => correctPaths(path2))));
+}, "joinPaths");
+
+// ../config-tools/src/utilities/find-up.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var MAX_PATH_SEARCH_DEPTH = 30;
+var depth = 0;
+function findFolderUp(startPath, endFileNames) {
+  const _startPath = startPath ?? process.cwd();
+  if (endFileNames.some((endFileName) => (0, import_node_fs.existsSync)((0, import_node_path.join)(_startPath, endFileName)))) {
+    return _startPath;
+  }
+  if (_startPath !== "/" && depth++ < MAX_PATH_SEARCH_DEPTH) {
+    const parent = (0, import_node_path.join)(_startPath, "..");
+    return findFolderUp(parent, endFileNames);
+  }
+  return void 0;
+}
+__name(findFolderUp, "findFolderUp");
+
+// ../config-tools/src/utilities/find-workspace-root.ts
+var rootFiles = [
+  "storm.json",
+  "storm.json",
+  "storm.yaml",
+  "storm.yml",
+  "storm.js",
+  "storm.ts",
+  ".storm.json",
+  ".storm.yaml",
+  ".storm.yml",
+  ".storm.js",
+  ".storm.ts",
+  "lerna.json",
+  "nx.json",
+  "turbo.json",
+  "npm-workspace.json",
+  "yarn-workspace.json",
+  "pnpm-workspace.json",
+  "npm-workspace.yaml",
+  "yarn-workspace.yaml",
+  "pnpm-workspace.yaml",
+  "npm-workspace.yml",
+  "yarn-workspace.yml",
+  "pnpm-workspace.yml",
+  "npm-lock.json",
+  "yarn-lock.json",
+  "pnpm-lock.json",
+  "npm-lock.yaml",
+  "yarn-lock.yaml",
+  "pnpm-lock.yaml",
+  "npm-lock.yml",
+  "yarn-lock.yml",
+  "pnpm-lock.yml",
+  "bun.lockb"
+];
+function findWorkspaceRootSafe(pathInsideMonorepo) {
+  if (process.env.STORM_WORKSPACE_ROOT || process.env.NX_WORKSPACE_ROOT_PATH) {
+    return correctPaths(process.env.STORM_WORKSPACE_ROOT ?? process.env.NX_WORKSPACE_ROOT_PATH);
+  }
+  return correctPaths(findFolderUp(pathInsideMonorepo ?? process.cwd(), rootFiles));
+}
+__name(findWorkspaceRootSafe, "findWorkspaceRootSafe");
+function findWorkspaceRoot(pathInsideMonorepo) {
+  const result = findWorkspaceRootSafe(pathInsideMonorepo);
+  if (!result) {
+    throw new Error(`Cannot find workspace root upwards from known path. Files search list includes: 
+${rootFiles.join("\n")}
+Path: ${pathInsideMonorepo ? pathInsideMonorepo : process.cwd()}`);
+  }
+  return result;
+}
+__name(findWorkspaceRoot, "findWorkspaceRoot");
+
+// ../config-tools/src/utilities/get-default-config.ts
+var DEFAULT_COLOR_CONFIG = {
+  "light": {
+    "background": "#fafafa",
+    "foreground": "#1d1e22",
+    "brand": "#1fb2a6",
+    "alternate": "#db2777",
+    "help": "#5C4EE5",
+    "success": "#087f5b",
+    "info": "#0550ae",
+    "warning": "#e3b341",
+    "danger": "#D8314A",
+    "positive": "#22c55e",
+    "negative": "#dc2626"
+  },
+  "dark": {
+    "background": "#1d1e22",
+    "foreground": "#cbd5e1",
+    "brand": "#2dd4bf",
+    "alternate": "#db2777",
+    "help": "#818cf8",
+    "success": "#10b981",
+    "info": "#58a6ff",
+    "warning": "#f3d371",
+    "danger": "#D8314A",
+    "positive": "#22c55e",
+    "negative": "#dc2626"
+  }
+};
+var getDefaultConfig = /* @__PURE__ */ __name((root) => {
+  let license = STORM_DEFAULT_LICENSE;
+  let homepage = STORM_DEFAULT_HOMEPAGE;
+  let name;
+  let namespace;
+  let repository;
+  const workspaceRoot = findWorkspaceRoot(root);
+  if ((0, import_node_fs2.existsSync)((0, import_node_path2.join)(workspaceRoot, "package.json"))) {
+    const file = (0, import_node_fs2.readFileSync)((0, import_node_path2.join)(workspaceRoot, "package.json"), {
+      encoding: "utf8"
+    });
+    if (file) {
+      const packageJson = JSON.parse(file);
+      if (packageJson.name) {
+        name = packageJson.name;
+      }
+      if (packageJson.namespace) {
+        namespace = packageJson.namespace;
+      }
+      if (packageJson.repository?.url) {
+        repository = packageJson.repository?.url;
+      }
+      if (packageJson.license) {
+        license = packageJson.license;
+      }
+      if (packageJson.homepage) {
+        homepage = packageJson.homepage;
+      }
+    }
+  }
+  return {
+    workspaceRoot,
+    name,
+    namespace,
+    repository,
+    license,
+    homepage,
+    docs: `${homepage || STORM_DEFAULT_HOMEPAGE}/docs`,
+    licensing: `${homepage || STORM_DEFAULT_HOMEPAGE}/license`
+  };
+}, "getDefaultConfig");
+
+// ../config-tools/src/logger/chalk.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var chalkDefault = {
+  hex: /* @__PURE__ */ __name((_) => (message) => message, "hex"),
+  bgHex: /* @__PURE__ */ __name((_) => ({
+    whiteBright: /* @__PURE__ */ __name((message) => message, "whiteBright")
+  }), "bgHex"),
+  whiteBright: /* @__PURE__ */ __name((message) => message, "whiteBright"),
+  gray: /* @__PURE__ */ __name((message) => message, "gray"),
+  bold: {
+    hex: /* @__PURE__ */ __name((_) => (message) => message, "hex"),
+    bgHex: /* @__PURE__ */ __name((_) => ({
+      whiteBright: /* @__PURE__ */ __name((message) => message, "whiteBright")
+    }), "bgHex"),
+    whiteBright: /* @__PURE__ */ __name((message) => message, "whiteBright")
+  },
+  dim: {
+    hex: /* @__PURE__ */ __name((_) => (message) => message, "hex"),
+    gray: /* @__PURE__ */ __name((message) => message, "gray")
+  }
+};
+var getChalk = /* @__PURE__ */ __name(() => {
+  let _chalk = import_chalk.default;
+  if (!_chalk?.hex || !_chalk?.bold?.hex || !_chalk?.bgHex || !_chalk?.whiteBright) {
+    _chalk = chalkDefault;
+  }
+  return _chalk;
+}, "getChalk");
+
+// ../config-tools/src/logger/is-unicode-supported.ts
+var import_node_process = __toESM(require("process"), 1);
+function isUnicodeSupported() {
+  const { env } = import_node_process.default;
+  const { TERM, TERM_PROGRAM } = env;
+  if (import_node_process.default.platform !== "win32") {
+    return TERM !== "linux";
+  }
+  return Boolean(env.WT_SESSION) || // Windows Terminal
+  Boolean(env.TERMINUS_SUBLIME) || // Terminus (<0.2.27)
+  env.ConEmuTask === "{cmd::Cmder}" || // ConEmu and cmder
+  TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+__name(isUnicodeSupported, "isUnicodeSupported");
+
+// ../config-tools/src/logger/console-icons.ts
+var useIcon = /* @__PURE__ */ __name((c, fallback) => isUnicodeSupported() ? c : fallback, "useIcon");
+var CONSOLE_ICONS = {
+  [LogLevelLabel.ERROR]: useIcon("\u2718", "\xD7"),
+  [LogLevelLabel.FATAL]: useIcon("\u{1F480}", "\xD7"),
+  [LogLevelLabel.WARN]: useIcon("\u26A0", "\u203C"),
+  [LogLevelLabel.INFO]: useIcon("\u2139", "i"),
+  [LogLevelLabel.SUCCESS]: useIcon("\u2714", "\u221A"),
+  [LogLevelLabel.DEBUG]: useIcon("\u{1F6E0}", "D"),
+  [LogLevelLabel.TRACE]: useIcon("\u{1F6E0}", "T"),
+  [LogLevelLabel.ALL]: useIcon("\u2709", "\u2192")
+};
+
+// ../config-tools/src/logger/format-timestamp.ts
+var formatTimestamp = /* @__PURE__ */ __name((date = /* @__PURE__ */ new Date()) => {
+  return `${date.toLocaleDateString()} ${date.toLocaleTimeString()}`;
+}, "formatTimestamp");
+
+// ../config-tools/src/logger/get-log-level.ts
+var getLogLevel = /* @__PURE__ */ __name((label) => {
+  switch (label) {
+    case "all":
+      return LogLevel.ALL;
+    case "trace":
+      return LogLevel.TRACE;
+    case "debug":
+      return LogLevel.DEBUG;
+    case "info":
+      return LogLevel.INFO;
+    case "warn":
+      return LogLevel.WARN;
+    case "error":
+      return LogLevel.ERROR;
+    case "fatal":
+      return LogLevel.FATAL;
+    case "silent":
+      return LogLevel.SILENT;
+    default:
+      return LogLevel.INFO;
+  }
+}, "getLogLevel");
+var getLogLevelLabel = /* @__PURE__ */ __name((logLevel = LogLevel.INFO) => {
+  if (logLevel >= LogLevel.ALL) {
+    return LogLevelLabel.ALL;
+  }
+  if (logLevel >= LogLevel.TRACE) {
+    return LogLevelLabel.TRACE;
+  }
+  if (logLevel >= LogLevel.DEBUG) {
+    return LogLevelLabel.DEBUG;
+  }
+  if (logLevel >= LogLevel.INFO) {
+    return LogLevelLabel.INFO;
+  }
+  if (logLevel >= LogLevel.WARN) {
+    return LogLevelLabel.WARN;
+  }
+  if (logLevel >= LogLevel.ERROR) {
+    return LogLevelLabel.ERROR;
+  }
+  if (logLevel >= LogLevel.FATAL) {
+    return LogLevelLabel.FATAL;
+  }
+  if (logLevel <= LogLevel.SILENT) {
+    return LogLevelLabel.SILENT;
+  }
+  return LogLevelLabel.INFO;
+}, "getLogLevelLabel");
+var isVerbose = /* @__PURE__ */ __name((label = LogLevelLabel.SILENT) => {
+  const logLevel = typeof label === "string" ? getLogLevel(label) : label;
+  return logLevel >= LogLevel.DEBUG;
+}, "isVerbose");
+
+// ../config-tools/src/logger/console.ts
+var getLogFn = /* @__PURE__ */ __name((logLevel = LogLevel.INFO, config = {}, _chalk = getChalk()) => {
+  const colors2 = !config.colors?.dark && !config.colors?.["base"] && !config.colors?.["base"]?.dark ? DEFAULT_COLOR_CONFIG : config.colors?.dark && typeof config.colors.dark === "string" ? config.colors : config.colors?.["base"]?.dark && typeof config.colors["base"].dark === "string" ? config.colors["base"].dark : config.colors?.["base"] ? config.colors?.["base"] : DEFAULT_COLOR_CONFIG;
+  const configLogLevel = config.logLevel || process.env.STORM_LOG_LEVEL || LogLevelLabel.INFO;
+  if (typeof logLevel === "number" && (logLevel >= getLogLevel(configLogLevel) || logLevel <= LogLevel.SILENT) || typeof logLevel === "string" && getLogLevel(logLevel) >= getLogLevel(configLogLevel)) {
+    return (_) => {
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.FATAL >= logLevel || typeof logLevel === "string" && LogLevel.FATAL >= getLogLevel(logLevel)) {
+    return (message) => {
+      console.error(`
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors2.fatal ?? "#7d1a1a")(`[${CONSOLE_ICONS[LogLevelLabel.FATAL]} Fatal]`)} ${_chalk.bold.whiteBright(formatLogMessage(message))}
+`);
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.ERROR >= logLevel || typeof logLevel === "string" && LogLevel.ERROR >= getLogLevel(logLevel)) {
+    return (message) => {
+      console.error(`
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors2.danger ?? "#f85149")(`[${CONSOLE_ICONS[LogLevelLabel.ERROR]} Error]`)} ${_chalk.bold.whiteBright(formatLogMessage(message))}
+`);
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.WARN >= logLevel || typeof logLevel === "string" && LogLevel.WARN >= getLogLevel(logLevel)) {
+    return (message) => {
+      console.warn(`
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors2.warning ?? "#e3b341")(`[${CONSOLE_ICONS[LogLevelLabel.WARN]} Warn]`)} ${_chalk.bold.whiteBright(formatLogMessage(message))}
+`);
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.SUCCESS >= logLevel || typeof logLevel === "string" && LogLevel.SUCCESS >= getLogLevel(logLevel)) {
+    return (message) => {
+      console.info(`
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors2.success ?? "#56d364")(`[${CONSOLE_ICONS[LogLevelLabel.SUCCESS]} Success]`)} ${_chalk.bold.whiteBright(formatLogMessage(message))}
+`);
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.INFO >= logLevel || typeof logLevel === "string" && LogLevel.INFO >= getLogLevel(logLevel)) {
+    return (message) => {
+      console.info(`
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors2.info ?? "#58a6ff")(`[${CONSOLE_ICONS[LogLevelLabel.INFO]} Info]`)} ${_chalk.bold.whiteBright(formatLogMessage(message))}
+`);
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.TRACE >= logLevel || typeof logLevel === "string" && LogLevel.TRACE >= getLogLevel(logLevel)) {
+    return (message) => {
+      console.debug(`
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors2.brand ?? "#1fb2a6")(`[${CONSOLE_ICONS[LogLevelLabel.DEBUG]} Debug]`)} ${_chalk.bold.whiteBright(formatLogMessage(message))}
+`);
+    };
+  }
+  return (message) => {
+    console.log(`
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors2.brand ?? "#1fb2a6")(`[${CONSOLE_ICONS[LogLevelLabel.ALL]}  System]`)} ${_chalk.bold.whiteBright(formatLogMessage(message))}
+`);
+  };
+}, "getLogFn");
+var writeFatal = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.FATAL, config)(message), "writeFatal");
+var writeError = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.ERROR, config)(message), "writeError");
+var writeWarning = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.WARN, config)(message), "writeWarning");
+var writeInfo = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.INFO, config)(message), "writeInfo");
+var writeSuccess = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.SUCCESS, config)(message), "writeSuccess");
+var writeDebug = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.DEBUG, config)(message), "writeDebug");
+var writeTrace = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.TRACE, config)(message), "writeTrace");
+var writeSystem = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.ALL, config)(message), "writeSystem");
+var getStopwatch = /* @__PURE__ */ __name((name) => {
+  const start = process.hrtime();
+  return () => {
+    const end = process.hrtime(start);
+    console.info(`
+>  \u23F1\uFE0F  The${name ? ` ${name}` : ""} process took ${Math.round(end[0] * 1e3 + end[1] / 1e6)}ms to complete
+
+`);
+  };
+}, "getStopwatch");
+var MAX_DEPTH = 4;
+var formatLogMessage = /* @__PURE__ */ __name((message, options = {}, depth2 = 0) => {
+  if (depth2 > MAX_DEPTH) {
+    return "<max depth>";
+  }
+  const prefix = options.prefix ?? "-";
+  const skip = options.skip ?? [];
+  return typeof message === "undefined" || message === null || !message && typeof message !== "boolean" ? "<none>" : typeof message === "string" ? message : Array.isArray(message) ? `
+${message.map((item, index) => ` ${prefix}> #${index} = ${formatLogMessage(item, {
+    prefix: `${prefix}-`,
+    skip
+  }, depth2 + 1)}`).join("\n")}` : typeof message === "object" ? `
+${Object.keys(message).filter((key) => !skip.includes(key)).map((key) => ` ${prefix}> ${key} = ${_isFunction(message[key]) ? "<function>" : typeof message[key] === "object" ? formatLogMessage(message[key], {
+    prefix: `${prefix}-`,
+    skip
+  }, depth2 + 1) : message[key]}`).join("\n")}` : message;
+}, "formatLogMessage");
+var _isFunction = /* @__PURE__ */ __name((value) => {
+  try {
+    return value instanceof Function || typeof value === "function" || !!(value?.constructor && value?.call && value?.apply);
+  } catch (e) {
+    return false;
+  }
+}, "_isFunction");
+
+// ../config-tools/src/utilities/process-handler.ts
+var exitWithError = /* @__PURE__ */ __name((config) => {
+  writeFatal("Exiting script with an error status...", config);
+  process.exit(1);
+}, "exitWithError");
+var exitWithSuccess = /* @__PURE__ */ __name((config) => {
+  writeSuccess("Script completed successfully. Exiting...", config);
+  process.exit(0);
+}, "exitWithSuccess");
+var handleProcess = /* @__PURE__ */ __name((config) => {
+  writeTrace(`Using the following arguments to process the script: ${process.argv.join(", ")}`, config);
+  process.on("unhandledRejection", (error) => {
+    writeError(`An Unhandled Rejection occurred while running the program: ${error}`, config);
+    exitWithError(config);
+  });
+  process.on("uncaughtException", (error) => {
+    writeError(`An Uncaught Exception occurred while running the program: ${error.message} 
+Stacktrace: ${error.stack}`, config);
+    exitWithError(config);
+  });
+  process.on("SIGTERM", (signal) => {
+    writeError(`The program terminated with signal code: ${signal}`, config);
+    exitWithError(config);
+  });
+  process.on("SIGINT", (signal) => {
+    writeError(`The program terminated with signal code: ${signal}`, config);
+    exitWithError(config);
+  });
+  process.on("SIGHUP", (signal) => {
+    writeError(`The program terminated with signal code: ${signal}`, config);
+    exitWithError(config);
+  });
+}, "handleProcess");
+
+// ../config-tools/src/config-file/get-config-file.ts
+var getConfigFileByName = /* @__PURE__ */ __name(async (fileName, filePath, options = {}) => {
+  const workspacePath = filePath || findWorkspaceRoot(filePath);
+  let config = await (0, import_c12.loadConfig)({
+    cwd: workspacePath,
+    packageJson: true,
+    name: fileName,
+    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")
+    },
+    ...options
+  });
+  if (!config || Object.keys(config).length === 0) {
+    config = await (0, import_c12.loadConfig)({
+      cwd: workspacePath,
+      packageJson: true,
+      name: fileName,
+      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")
+      },
+      configFile: fileName,
+      ...options
+    });
+  }
+  return config;
+}, "getConfigFileByName");
+var getConfigFile = /* @__PURE__ */ __name(async (filePath, additionalFileNames = []) => {
+  const workspacePath = filePath ? filePath : findWorkspaceRoot(filePath);
+  const result = await getConfigFileByName("storm", workspacePath);
+  let config = result.config;
+  const configFile = result.configFile;
+  if (config && configFile && Object.keys(config).length > 0) {
+    writeSystem(`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)));
+    for (const result2 of results) {
+      if (result2?.config && result2?.configFile && Object.keys(result2.config).length > 0) {
+        writeSystem(`Found alternative configuration file "${result2.configFile.includes(`${workspacePath}/`) ? result2.configFile.replace(`${workspacePath}/`, "") : result2.configFile}" at "${workspacePath}"`, {
+          logLevel: "all"
+        });
+        config = (0, import_defu.default)(result2.config ?? {}, config ?? {});
+      }
+    }
+  }
+  if (!config) {
+    return void 0;
+  }
+  config.configFile = configFile;
+  return config;
+}, "getConfigFile");
+
+// ../config-tools/src/env/get-env.ts
+var getConfigEnv = /* @__PURE__ */ __name(() => {
+  const prefix = "STORM_";
+  let config = {
+    extends: process.env[`${prefix}EXTENDS`] || void 0,
+    name: process.env[`${prefix}NAME`] || void 0,
+    namespace: process.env[`${prefix}NAMESPACE`] || void 0,
+    owner: process.env[`${prefix}OWNER`] || void 0,
+    bot: {
+      name: process.env[`${prefix}BOT_NAME`] || void 0,
+      email: process.env[`${prefix}BOT_EMAIL`] || void 0
+    },
+    organization: process.env[`${prefix}ORGANIZATION`] || void 0,
+    packageManager: process.env[`${prefix}PACKAGE_MANAGER`] || void 0,
+    license: process.env[`${prefix}LICENSE`] || void 0,
+    homepage: process.env[`${prefix}HOMEPAGE`] || void 0,
+    docs: process.env[`${prefix}DOCS`] || void 0,
+    licensing: process.env[`${prefix}LICENSING`] || void 0,
+    timezone: process.env[`${prefix}TIMEZONE`] || process.env.TZ || void 0,
+    locale: process.env[`${prefix}LOCALE`] || process.env.LOCALE || void 0,
+    configFile: process.env[`${prefix}CONFIG_FILE`] ? correctPaths(process.env[`${prefix}CONFIG_FILE`]) : void 0,
+    workspaceRoot: process.env[`${prefix}WORKSPACE_ROOT`] ? correctPaths(process.env[`${prefix}WORKSPACE_ROOT`]) : void 0,
+    directories: {
+      cache: process.env[`${prefix}CACHE_DIR`] ? correctPaths(process.env[`${prefix}CACHE_DIR`]) : void 0,
+      data: process.env[`${prefix}DATA_DIR`] ? correctPaths(process.env[`${prefix}DATA_DIR`]) : void 0,
+      config: process.env[`${prefix}CONFIG_DIR`] ? correctPaths(process.env[`${prefix}CONFIG_DIR`]) : void 0,
+      temp: process.env[`${prefix}TEMP_DIR`] ? correctPaths(process.env[`${prefix}TEMP_DIR`]) : void 0,
+      log: process.env[`${prefix}LOG_DIR`] ? correctPaths(process.env[`${prefix}LOG_DIR`]) : void 0,
+      build: process.env[`${prefix}BUILD_DIR`] ? correctPaths(process.env[`${prefix}BUILD_DIR`]) : void 0
+    },
+    skipCache: process.env[`${prefix}SKIP_CACHE`] !== void 0 ? Boolean(process.env[`${prefix}SKIP_CACHE`]) : void 0,
+    env: (process.env[`${prefix}ENV`] ?? process.env.NODE_ENV ?? process.env.ENVIRONMENT) || void 0,
+    // ci:
+    //   process.env[`${prefix}CI`] !== undefined
+    //     ? Boolean(
+    //         process.env[`${prefix}CI`] ??
+    //           process.env.CI ??
+    //           process.env.CONTINUOUS_INTEGRATION
+    //       )
+    //     : undefined,
+    repository: process.env[`${prefix}REPOSITORY`] || void 0,
+    branch: process.env[`${prefix}BRANCH`] || void 0,
+    preid: process.env[`${prefix}PRE_ID`] || void 0,
+    externalPackagePatterns: process.env[`${prefix}EXTERNAL_PACKAGE_PATTERNS`] ? JSON.parse(process.env[`${prefix}EXTERNAL_PACKAGE_PATTERNS`]) : [],
+    registry: {
+      github: process.env[`${prefix}REGISTRY_GITHUB`] || void 0,
+      npm: process.env[`${prefix}REGISTRY_NPM`] || void 0,
+      cargo: process.env[`${prefix}REGISTRY_CARGO`] || void 0,
+      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
+  };
+  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`;
+    } else {
+      config.docs = `${config.homepage}/docs`;
+    }
+  }
+  if (config.licensing === STORM_DEFAULT_LICENSING) {
+    if (config.homepage === STORM_DEFAULT_HOMEPAGE) {
+      config.licensing = `${STORM_DEFAULT_HOMEPAGE}/projects/${config.name}/licensing`;
+    } else {
+      config.licensing = `${config.homepage}/docs`;
+    }
+  }
+  const serializedConfig = process.env[`${prefix}CONFIG`];
+  if (serializedConfig) {
+    const parsed = JSON.parse(serializedConfig);
+    config = {
+      ...config,
+      ...parsed,
+      colors: {
+        ...config.colors,
+        ...parsed.colors
+      },
+      extensions: {
+        ...config.extensions,
+        ...parsed.extensions
+      }
+    };
+  }
+  return config;
+}, "getConfigEnv");
+var getThemeColorConfigEnv = /* @__PURE__ */ __name((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) => {
+  return {
+    dark: process.env[`${prefix}DARK`],
+    light: process.env[`${prefix}LIGHT`],
+    brand: process.env[`${prefix}BRAND`],
+    alternate: process.env[`${prefix}ALTERNATE`],
+    accent: process.env[`${prefix}ACCENT`],
+    link: process.env[`${prefix}LINK`],
+    help: process.env[`${prefix}HELP`],
+    success: process.env[`${prefix}SUCCESS`],
+    info: process.env[`${prefix}INFO`],
+    warning: process.env[`${prefix}WARNING`],
+    danger: process.env[`${prefix}DANGER`],
+    fatal: process.env[`${prefix}FATAL`],
+    positive: process.env[`${prefix}POSITIVE`],
+    negative: process.env[`${prefix}NEGATIVE`]
+  };
+}, "getSingleThemeColorConfigEnv");
+var getMultiThemeColorConfigEnv = /* @__PURE__ */ __name((prefix) => {
+  return {
+    light: getBaseThemeColorConfigEnv(`${prefix}_LIGHT_`),
+    dark: getBaseThemeColorConfigEnv(`${prefix}_DARK_`)
+  };
+}, "getMultiThemeColorConfigEnv");
+var getBaseThemeColorConfigEnv = /* @__PURE__ */ __name((prefix) => {
+  return {
+    foreground: process.env[`${prefix}FOREGROUND`],
+    background: process.env[`${prefix}BACKGROUND`],
+    brand: process.env[`${prefix}BRAND`],
+    alternate: process.env[`${prefix}ALTERNATE`],
+    accent: process.env[`${prefix}ACCENT`],
+    link: process.env[`${prefix}LINK`],
+    help: process.env[`${prefix}HELP`],
+    success: process.env[`${prefix}SUCCESS`],
+    info: process.env[`${prefix}INFO`],
+    warning: process.env[`${prefix}WARNING`],
+    danger: process.env[`${prefix}DANGER`],
+    fatal: process.env[`${prefix}FATAL`],
+    positive: process.env[`${prefix}POSITIVE`],
+    negative: process.env[`${prefix}NEGATIVE`]
+  };
+}, "getBaseThemeColorConfigEnv");
+
+// ../config-tools/src/env/set-env.ts
+var setExtensionEnv = /* @__PURE__ */ __name((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()) ?? [];
+      let extensionKey;
+      if (result.length === 0) {
+        return;
+      }
+      if (result.length === 1) {
+        extensionKey = result[0]?.toUpperCase() ?? "";
+      } else {
+        extensionKey = result.reduce((ret, part) => {
+          return `${ret}_${part.toLowerCase()}`;
+        });
+      }
+      process.env[`STORM_EXTENSION_${extensionName.toUpperCase()}_${extensionKey.toUpperCase()}`] = extension[key];
+    }
+  }
+}, "setExtensionEnv");
+var setConfigEnv = /* @__PURE__ */ __name((config) => {
+  const prefix = "STORM_";
+  if (config.extends) {
+    process.env[`${prefix}EXTENDS`] = config.extends;
+  }
+  if (config.name) {
+    process.env[`${prefix}NAME`] = config.name;
+  }
+  if (config.namespace) {
+    process.env[`${prefix}NAMESPACE`] = config.namespace;
+  }
+  if (config.owner) {
+    process.env[`${prefix}OWNER`] = config.owner;
+  }
+  if (config.bot) {
+    process.env[`${prefix}BOT_NAME`] = config.bot.name;
+    process.env[`${prefix}BOT_EMAIL`] = config.bot.email;
+  }
+  if (config.organization) {
+    process.env[`${prefix}ORGANIZATION`] = config.organization;
+  }
+  if (config.packageManager) {
+    process.env[`${prefix}PACKAGE_MANAGER`] = config.packageManager;
+  }
+  if (config.license) {
+    process.env[`${prefix}LICENSE`] = config.license;
+  }
+  if (config.homepage) {
+    process.env[`${prefix}HOMEPAGE`] = config.homepage;
+  }
+  if (config.docs) {
+    process.env[`${prefix}DOCS`] = config.docs;
+  }
+  if (config.licensing) {
+    process.env[`${prefix}LICENSING`] = config.licensing;
+  }
+  if (config.timezone) {
+    process.env[`${prefix}TIMEZONE`] = config.timezone;
+    process.env.TZ = config.timezone;
+    process.env.DEFAULT_TIMEZONE = config.timezone;
+  }
+  if (config.locale) {
+    process.env[`${prefix}LOCALE`] = config.locale;
+    process.env.LOCALE = config.locale;
+    process.env.DEFAULT_LOCALE = config.locale;
+    process.env.LANG = config.locale ? `${config.locale.replaceAll("-", "_")}.UTF-8` : "en_US.UTF-8";
+  }
+  if (config.configFile) {
+    process.env[`${prefix}CONFIG_FILE`] = correctPaths(config.configFile);
+  }
+  if (config.workspaceRoot) {
+    process.env[`${prefix}WORKSPACE_ROOT`] = correctPaths(config.workspaceRoot);
+    process.env.NX_WORKSPACE_ROOT = correctPaths(config.workspaceRoot);
+    process.env.NX_WORKSPACE_ROOT_PATH = correctPaths(config.workspaceRoot);
+  }
+  if (config.directories) {
+    if (!config.skipCache && config.directories.cache) {
+      process.env[`${prefix}CACHE_DIR`] = correctPaths(config.directories.cache);
+    }
+    if (config.directories.data) {
+      process.env[`${prefix}DATA_DIR`] = correctPaths(config.directories.data);
+    }
+    if (config.directories.config) {
+      process.env[`${prefix}CONFIG_DIR`] = correctPaths(config.directories.config);
+    }
+    if (config.directories.temp) {
+      process.env[`${prefix}TEMP_DIR`] = correctPaths(config.directories.temp);
+    }
+    if (config.directories.log) {
+      process.env[`${prefix}LOG_DIR`] = correctPaths(config.directories.log);
+    }
+    if (config.directories.build) {
+      process.env[`${prefix}BUILD_DIR`] = correctPaths(config.directories.build);
+    }
+  }
+  if (config.skipCache !== void 0) {
+    process.env[`${prefix}SKIP_CACHE`] = String(config.skipCache);
+    if (config.skipCache) {
+      process.env.NX_SKIP_NX_CACHE ??= String(config.skipCache);
+      process.env.NX_CACHE_PROJECT_GRAPH ??= String(config.skipCache);
+    }
+  }
+  if (config.env) {
+    process.env[`${prefix}ENV`] = config.env;
+    process.env.NODE_ENV = config.env;
+    process.env.ENVIRONMENT = config.env;
+  }
+  if (config.colors?.base?.light || config.colors?.base?.dark) {
+    for (const key of Object.keys(config.colors)) {
+      setThemeColorConfigEnv(`${prefix}COLOR_${key}_`, config.colors[key]);
+    }
+  } else {
+    setThemeColorConfigEnv(`${prefix}COLOR_`, config.colors);
+  }
+  if (config.repository) {
+    process.env[`${prefix}REPOSITORY`] = config.repository;
+  }
+  if (config.branch) {
+    process.env[`${prefix}BRANCH`] = config.branch;
+  }
+  if (config.preid) {
+    process.env[`${prefix}PRE_ID`] = String(config.preid);
+  }
+  if (config.externalPackagePatterns) {
+    process.env[`${prefix}EXTERNAL_PACKAGE_PATTERNS`] = JSON.stringify(config.externalPackagePatterns);
+  }
+  if (config.registry) {
+    if (config.registry.github) {
+      process.env[`${prefix}REGISTRY_GITHUB`] = String(config.registry.github);
+    }
+    if (config.registry.npm) {
+      process.env[`${prefix}REGISTRY_NPM`] = String(config.registry.npm);
+    }
+    if (config.registry.cargo) {
+      process.env[`${prefix}REGISTRY_CARGO`] = String(config.registry.cargo);
+    }
+    if (config.registry.cyclone) {
+      process.env[`${prefix}REGISTRY_CYCLONE`] = String(config.registry.cyclone);
+    }
+    if (config.registry.container) {
+      process.env[`${prefix}REGISTRY_CONTAINER`] = String(config.registry.cyclone);
+    }
+  }
+  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.RUST_BACKTRACE = getLogLevel(config.logLevel) >= LogLevel.DEBUG ? "full" : "none";
+  }
+  process.env[`${prefix}CONFIG`] = JSON.stringify(config);
+  for (const key of Object.keys(config.extensions ?? {})) {
+    config.extensions[key] && Object.keys(config.extensions[key]) && setExtensionEnv(key, config.extensions[key]);
+  }
+}, "setConfigEnv");
+var setThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, config) => {
+  return config?.light?.brand || config?.dark?.brand ? setMultiThemeColorConfigEnv(prefix, config) : setSingleThemeColorConfigEnv(prefix, config);
+}, "setThemeColorConfigEnv");
+var setSingleThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, config) => {
+  if (config.dark) {
+    process.env[`${prefix}DARK`] = config.dark;
+  }
+  if (config.light) {
+    process.env[`${prefix}LIGHT`] = config.light;
+  }
+  if (config.brand) {
+    process.env[`${prefix}BRAND`] = config.brand;
+  }
+  if (config.alternate) {
+    process.env[`${prefix}ALTERNATE`] = config.alternate;
+  }
+  if (config.accent) {
+    process.env[`${prefix}ACCENT`] = config.accent;
+  }
+  if (config.link) {
+    process.env[`${prefix}LINK`] = config.link;
+  }
+  if (config.help) {
+    process.env[`${prefix}HELP`] = config.help;
+  }
+  if (config.success) {
+    process.env[`${prefix}SUCCESS`] = config.success;
+  }
+  if (config.info) {
+    process.env[`${prefix}INFO`] = config.info;
+  }
+  if (config.warning) {
+    process.env[`${prefix}WARNING`] = config.warning;
+  }
+  if (config.danger) {
+    process.env[`${prefix}DANGER`] = config.danger;
+  }
+  if (config.fatal) {
+    process.env[`${prefix}FATAL`] = config.fatal;
+  }
+  if (config.positive) {
+    process.env[`${prefix}POSITIVE`] = config.positive;
+  }
+  if (config.negative) {
+    process.env[`${prefix}NEGATIVE`] = config.negative;
+  }
+}, "setSingleThemeColorConfigEnv");
+var setMultiThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, config) => {
+  return {
+    light: setBaseThemeColorConfigEnv(`${prefix}LIGHT_`, config.light),
+    dark: setBaseThemeColorConfigEnv(`${prefix}DARK_`, config.dark)
+  };
+}, "setMultiThemeColorConfigEnv");
+var setBaseThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, config) => {
+  if (config.foreground) {
+    process.env[`${prefix}FOREGROUND`] = config.foreground;
+  }
+  if (config.background) {
+    process.env[`${prefix}BACKGROUND`] = config.background;
+  }
+  if (config.brand) {
+    process.env[`${prefix}BRAND`] = config.brand;
+  }
+  if (config.alternate) {
+    process.env[`${prefix}ALTERNATE`] = config.alternate;
+  }
+  if (config.accent) {
+    process.env[`${prefix}ACCENT`] = config.accent;
+  }
+  if (config.link) {
+    process.env[`${prefix}LINK`] = config.link;
+  }
+  if (config.help) {
+    process.env[`${prefix}HELP`] = config.help;
+  }
+  if (config.success) {
+    process.env[`${prefix}SUCCESS`] = config.success;
+  }
+  if (config.info) {
+    process.env[`${prefix}INFO`] = config.info;
+  }
+  if (config.warning) {
+    process.env[`${prefix}WARNING`] = config.warning;
+  }
+  if (config.danger) {
+    process.env[`${prefix}DANGER`] = config.danger;
+  }
+  if (config.fatal) {
+    process.env[`${prefix}FATAL`] = config.fatal;
+  }
+  if (config.positive) {
+    process.env[`${prefix}POSITIVE`] = config.positive;
+  }
+  if (config.negative) {
+    process.env[`${prefix}NEGATIVE`] = config.negative;
+  }
+}, "setBaseThemeColorConfigEnv");
+
+// ../config-tools/src/create-storm-config.ts
+var _static_cache = void 0;
+var loadStormConfig = /* @__PURE__ */ __name(async (workspaceRoot) => {
+  let config = {};
+  if (_static_cache?.data && _static_cache?.timestamp && _static_cache.timestamp >= Date.now() + 3e4) {
+    writeTrace(`Configuration cache hit - ${_static_cache.timestamp}`, _static_cache.data);
+    return _static_cache.data;
+  }
+  let _workspaceRoot = workspaceRoot;
+  if (!_workspaceRoot) {
+    _workspaceRoot = findWorkspaceRoot();
+  }
+  const configFile = await getConfigFile(_workspaceRoot);
+  if (!configFile) {
+    writeWarning("No Storm config file found in the current workspace. Please ensure this is the expected behavior - you can add a `storm.json` file to the root of your workspace if it is not.\n", {
+      logLevel: "all"
+    });
+  }
+  config = (0, import_defu2.default)(getConfigEnv(), configFile, getDefaultConfig(_workspaceRoot));
+  setConfigEnv(config);
+  writeTrace(`\u2699\uFE0F  Using Storm configuration: 
+${formatLogMessage(config)}`, config);
+  return config;
+}, "loadStormConfig");
+
+// bin/unbuild.ts
+var import_commander = require("commander");
+
+// src/build.ts
+var import_devkit6 = require("@nx/devkit");
+var import_js2 = require("@nx/js");
+var import_buildable_libs_utils4 = require("@nx/js/src/utils/buildable-libs-utils");
+
+// ../build-tools/src/plugins/swc.ts
+var import_core = require("@swc/core");
+
+// ../build-tools/src/plugins/ts-resolve.ts
+var import_node_fs3 = __toESM(require("fs"));
+var import_node_module = require("module");
+var import_node_path3 = __toESM(require("path"));
+var import_resolve = __toESM(require("resolve"));
+
+// ../build-tools/src/plugins/type-definitions.ts
+var import_devkit2 = require("@nx/devkit");
+var import_path = require("path");
+
+// ../build-tools/src/utilities/copy-assets.ts
+var import_devkit3 = require("@nx/devkit");
+var import_js = require("@nx/js");
+var import_glob = require("glob");
+var import_promises2 = require("fs/promises");
+
+// ../build-tools/src/utilities/read-nx-config.ts
+var import_node_fs4 = require("fs");
+var import_promises = require("fs/promises");
+var readNxConfig = /* @__PURE__ */ __name(async (workspaceRoot) => {
+  let rootDir = workspaceRoot;
+  if (!rootDir) {
+    const config = await loadStormConfig();
+    rootDir = config.workspaceRoot;
+  }
+  const nxJsonPath = joinPaths(rootDir, "nx.json");
+  if (!(0, import_node_fs4.existsSync)(nxJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const configContent = await (0, import_promises.readFile)(nxJsonPath, "utf8");
+  return JSON.parse(configContent);
+}, "readNxConfig");
+
+// ../build-tools/src/utilities/copy-assets.ts
+var copyAssets = /* @__PURE__ */ __name(async (config, assets, outputPath, projectRoot, projectName, sourceRoot, generatePackageJson2 = true, includeSrc = false, banner, footer) => {
+  const pendingAssets = Array.from(assets ?? []);
+  if (!pendingAssets?.some((asset) => asset?.glob === "*.md")) {
+    pendingAssets.push({
+      input: projectRoot,
+      glob: "*.md",
+      output: "/"
+    });
+  }
+  if (generatePackageJson2 === false) {
+    pendingAssets.push({
+      input: sourceRoot,
+      glob: "package.json",
+      output: "."
+    });
+  }
+  if (!pendingAssets?.some((asset) => asset?.glob === "LICENSE")) {
+    pendingAssets.push({
+      input: "",
+      glob: "LICENSE",
+      output: "."
+    });
+  }
+  if (includeSrc === true) {
+    pendingAssets.push({
+      input: sourceRoot,
+      glob: "**/{*.ts,*.tsx,*.js,*.jsx}",
+      output: "src/"
+    });
+  }
+  const nxJson = readNxConfig(config.workspaceRoot);
+  const projectGraph = (0, import_devkit3.readCachedProjectGraph)();
+  const projectsConfigurations = (0, import_devkit3.readProjectsConfigurationFromProjectGraph)(projectGraph);
+  if (!projectsConfigurations?.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 buildTarget = projectsConfigurations.projects[projectName].targets?.build;
+  if (!buildTarget) {
+    throw new Error(`The Build process failed because the project does not have a valid build target in the project.json file. Check if the file exists in the root of the project at ${joinPaths(projectRoot, "project.json")}`);
+  }
+  const result = await (0, import_js.copyAssets)({
+    assets,
+    watch: false,
+    outputPath
+  }, {
+    root: config.workspaceRoot,
+    targetName: "build",
+    target: buildTarget,
+    projectName,
+    projectGraph,
+    projectsConfigurations,
+    nxJsonConfiguration: nxJson,
+    cwd: config.workspaceRoot,
+    isVerbose: isVerbose(config.logLevel)
+  });
+  if (!result.success) {
+    throw new Error("The Build process failed trying to copy assets");
+  }
+  if (includeSrc === true) {
+    writeDebug(`\u{1F4DD}  Adding banner and writing source files: ${joinPaths(outputPath, "src")}`, config);
+    const files = await (0, import_glob.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) => (0, import_promises2.writeFile)(file, `${banner && typeof banner === "string" ? banner.startsWith("//") ? banner : `// ${banner}` : ""}
+
+${await (0, import_promises2.readFile)(file, "utf8")}
+
+${footer && typeof footer === "string" ? footer.startsWith("//") ? footer : `// ${footer}` : ""}`)));
+  }
+}, "copyAssets");
+
+// ../build-tools/src/utilities/generate-package-json.ts
+var import_buildable_libs_utils = require("@nx/js/src/utils/buildable-libs-utils");
+var import_glob2 = require("glob");
+var import_node_fs5 = require("fs");
+var import_promises3 = require("fs/promises");
+var import_project_graph = require("nx/src/project-graph/project-graph");
+var addPackageDependencies = /* @__PURE__ */ __name(async (workspaceRoot, projectRoot, projectName, packageJson) => {
+  const projectDependencies = (0, import_buildable_libs_utils.calculateProjectBuildableDependencies)(void 0, (0, import_project_graph.readCachedProjectGraph)(), 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)) {
+    const projectNode = project.node;
+    if (projectNode.data.root) {
+      const projectPackageJsonPath = joinPaths(workspaceRoot, projectNode.data.root, "package.json");
+      if ((0, import_node_fs5.existsSync)(projectPackageJsonPath)) {
+        const projectPackageJsonContent = await (0, import_promises3.readFile)(projectPackageJsonPath, "utf8");
+        const projectPackageJson = JSON.parse(projectPackageJsonContent);
+        if (projectPackageJson.private !== false) {
+          localPackages.push(projectPackageJson);
+        }
+      }
+    }
+  }
+  if (localPackages.length > 0) {
+    writeTrace(`\u{1F4E6}  Adding local packages to package.json: ${localPackages.map((p) => p.name).join(", ")}`);
+    packageJson.peerDependencies = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = `>=${localPackage.version || "0.0.1"}`;
+      }
+      return ret;
+    }, packageJson.peerDependencies ?? {});
+    packageJson.peerDependenciesMeta = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = {
+          optional: false
+        };
+      }
+      return ret;
+    }, packageJson.peerDependenciesMeta ?? {});
+    packageJson.devDependencies = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = localPackage.version || "0.0.1";
+      }
+      return ret;
+    }, packageJson.peerDependencies ?? {});
+  } else {
+    writeTrace("\u{1F4E6}  No local packages dependencies to add to package.json");
+  }
+  return packageJson;
+}, "addPackageDependencies");
+var addWorkspacePackageJsonFields = /* @__PURE__ */ __name(async (config, projectRoot, sourceRoot, projectName, includeSrc = false, packageJson) => {
+  const workspaceRoot = config.workspaceRoot ? config.workspaceRoot : findWorkspaceRoot();
+  const workspacePackageJsonContent = await (0, import_promises3.readFile)(joinPaths(workspaceRoot, "package.json"), "utf8");
+  const workspacePackageJson = JSON.parse(workspacePackageJsonContent);
+  packageJson.type ??= "module";
+  packageJson.sideEffects ??= false;
+  if (includeSrc === true) {
+    let distSrc = sourceRoot.replace(projectRoot, "");
+    if (distSrc.startsWith("/")) {
+      distSrc = distSrc.substring(1);
+    }
+    packageJson.source ??= `${joinPaths(distSrc, "index.ts").replaceAll("\\", "/")}`;
+  }
+  packageJson.files ??= [
+    "dist/**/*"
+  ];
+  if (includeSrc === true && !packageJson.files.includes("src")) {
+    packageJson.files.push("src/**/*");
+  }
+  packageJson.publishConfig ??= {
+    access: "public"
+  };
+  packageJson.description ??= workspacePackageJson.description;
+  packageJson.homepage ??= workspacePackageJson.homepage;
+  packageJson.bugs ??= workspacePackageJson.bugs;
+  packageJson.license ??= workspacePackageJson.license;
+  packageJson.keywords ??= workspacePackageJson.keywords;
+  packageJson.funding ??= workspacePackageJson.funding;
+  packageJson.author ??= workspacePackageJson.author;
+  packageJson.maintainers ??= workspacePackageJson.maintainers;
+  if (!packageJson.maintainers && packageJson.author) {
+    packageJson.maintainers = [
+      packageJson.author
+    ];
+  }
+  packageJson.contributors ??= workspacePackageJson.contributors;
+  if (!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) => {
+  let entry = file.replaceAll("\\", "/");
+  if (sourceRoot) {
+    entry = entry.replace(sourceRoot, "");
+  }
+  return {
+    "import": {
+      "types": `./dist/${entry}.d.${type === "module" ? "ts" : "mts"}`,
+      "default": `./dist/${entry}.${type === "module" ? "js" : "mjs"}`
+    },
+    "require": {
+      "types": `./dist/${entry}.d.${type === "commonjs" ? "ts" : "cts"}`,
+      "default": `./dist/${entry}.${type === "commonjs" ? "js" : "cjs"}`
+    },
+    "default": {
+      "types": `./dist/${entry}.d.ts`,
+      "default": `./dist/${entry}.js`
+    }
+  };
+}, "addPackageJsonExport");
+var addPackageJsonExports = /* @__PURE__ */ __name(async (sourceRoot, packageJson) => {
+  packageJson.exports ??= {};
+  const files = await new import_glob2.Glob("**/*.{ts,tsx}", {
+    absolute: false,
+    cwd: sourceRoot,
+    root: sourceRoot
+  }).walk();
+  files.forEach((file) => {
+    addPackageJsonExport(file, packageJson.type, sourceRoot);
+    const split = file.split(".");
+    split.pop();
+    const entry = split.join(".").replaceAll("\\", "/");
+    packageJson.exports[`./${entry}`] ??= addPackageJsonExport(entry, packageJson.type, 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 ??= {};
+  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["./package.json"] ??= "./package.json";
+  packageJson.exports["."] = packageJson.exports["."] ?? addPackageJsonExport("index", packageJson.type, sourceRoot);
+  return packageJson;
+}, "addPackageJsonExports");
+
+// ../build-tools/src/utilities/get-entry-points.ts
+var import_glob3 = require("glob");
+
+// ../build-tools/src/utilities/task-graph.ts
+var import_create_task_graph = require("nx/src/tasks-runner/create-task-graph");
+
+// src/build.ts
+var import_defu5 = __toESM(require("defu"), 1);
+var import_node_fs8 = require("fs");
+var import_promises7 = require("fs/promises");
+var import_node_path6 = require("path");
+var import_find_workspace_root5 = require("nx/src/utils/find-workspace-root");
+
+// ../../node_modules/.pnpm/unbuild@3.3.1_sass@1.83.4_typescript@5.7.3/node_modules/unbuild/dist/shared/unbuild.B2_7OVir.mjs
+var import_node_module2 = __toESM(require("module"), 1);
+var import_node_fs6 = require("fs");
+var import_pathe = require("pathe");
+var import_utils = require("consola/utils");
+var import_consola = __toESM(require("consola"), 1);
+var import_defu3 = require("defu");
+var import_hookable = require("hookable");
+var import_pretty_bytes = __toESM(require("pretty-bytes"), 1);
+var import_tinyglobby = require("tinyglobby");
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_jiti = require("jiti");
+var import_rollup = require("rollup");
+var import_rollup_plugin_dts = __toESM(require("rollup-plugin-dts"), 1);
+var import_plugin_commonjs = __toESM(require("@rollup/plugin-commonjs"), 1);
+var import_plugin_node_resolve = require("@rollup/plugin-node-resolve");
+var import_plugin_alias = __toESM(require("@rollup/plugin-alias"), 1);
+var import_plugin_replace = __toESM(require("@rollup/plugin-replace"), 1);
+var import_utils2 = require("pathe/utils");
+var import_mlly = require("mlly");
+var import_esbuild = require("esbuild");
+var import_pluginutils = require("@rollup/pluginutils");
+var import_plugin_json = __toESM(require("@rollup/plugin-json"), 1);
+var import_magic_string = __toESM(require("magic-string"), 1);
+var import_untyped = require("untyped");
+var import_babel_plugin = __toESM(require("untyped/babel-plugin"), 1);
+var import_scule = require("scule");
+var import_mkdist = require("mkdist");
+function definePreset(preset) {
+  return preset;
+}
+__name(definePreset, "definePreset");
+var autoPreset = definePreset(() => {
+  return {
+    hooks: {
+      "build:prepare"(ctx) {
+        if (!ctx.pkg || ctx.options.entries.length > 0) {
+          return;
+        }
+        const sourceFiles = listRecursively((0, import_pathe.join)(ctx.options.rootDir, "src"));
+        const res = inferEntries(ctx.pkg, sourceFiles, ctx.options.rootDir);
+        for (const message of res.warnings) {
+          warn(ctx, message);
+        }
+        ctx.options.entries.push(...res.entries);
+        if (res.cjs) {
+          ctx.options.rollup.emitCJS = true;
+        }
+        if (ctx.options.declaration === void 0) {
+          ctx.options.declaration = res.dts ? "compatible" : false;
+        }
+        import_consola.consola.info(
+          "Automatically detected entries:",
+          import_utils.colors.cyan(
+            ctx.options.entries.map(
+              (e) => import_utils.colors.bold(
+                e.input.replace(ctx.options.rootDir + "/", "").replace(/\/$/, "/*")
+              )
+            ).join(", ")
+          ),
+          import_utils.colors.gray(
+            ["esm", res.cjs && "cjs", res.dts && "dts"].filter(Boolean).map((tag) => `[${tag}]`).join(" ")
+          )
+        );
+      }
+    }
+  };
+});
+function inferEntries(pkg, sourceFiles, rootDir) {
+  const warnings = [];
+  sourceFiles.sort((a, b) => a.split("/").length - b.split("/").length);
+  const outputs = extractExportFilenames(pkg.exports);
+  if (pkg.bin) {
+    const binaries = typeof pkg.bin === "string" ? [pkg.bin] : Object.values(pkg.bin);
+    for (const file of binaries) {
+      outputs.push({ file });
+    }
+  }
+  if (pkg.main) {
+    outputs.push({ file: pkg.main });
+  }
+  if (pkg.module) {
+    outputs.push({ type: "esm", file: pkg.module });
+  }
+  if (pkg.types || pkg.typings) {
+    outputs.push({ file: pkg.types || pkg.typings });
+  }
+  const isESMPkg = pkg.type === "module";
+  for (const output of outputs.filter((o) => !o.type)) {
+    const isJS = output.file.endsWith(".js");
+    if (isESMPkg && isJS || output.file.endsWith(".mjs")) {
+      output.type = "esm";
+    } else if (!isESMPkg && isJS || output.file.endsWith(".cjs")) {
+      output.type = "cjs";
+    }
+  }
+  let cjs = false;
+  let dts2 = false;
+  const entries = [];
+  for (const output of outputs) {
+    const outputSlug = output.file.replace(
+      /(\*[^/\\]*|\.d\.(m|c)?ts|\.\w+)$/,
+      ""
+    );
+    const isDir = outputSlug.endsWith("/");
+    if (isDir && ["./", "/"].includes(outputSlug)) {
+      continue;
+    }
+    const possiblePaths = getEntrypointPaths(outputSlug);
+    const input = possiblePaths.reduce((source, d) => {
+      if (source) {
+        return source;
+      }
+      const SOURCE_RE = new RegExp(
+        `(?<=/|$)${d}${isDir ? "" : String.raw`\.\w+`}$`
+      );
+      return sourceFiles.find((i) => SOURCE_RE.test(i))?.replace(/(\.d\.(m|c)?ts|\.\w+)$/, "");
+    }, void 0);
+    if (!input) {
+      if (!(0, import_node_fs6.existsSync)((0, import_pathe.resolve)(rootDir || ".", output.file))) {
+        warnings.push(`Could not find entrypoint for \`${output.file}\``);
+      }
+      continue;
+    }
+    if (output.type === "cjs") {
+      cjs = true;
+    }
+    const entry = entries.find((i) => i.input === input) || entries[entries.push({ input }) - 1];
+    if (/\.d\.(m|c)?ts$/.test(output.file)) {
+      dts2 = true;
+    }
+    if (isDir) {
+      entry.outDir = outputSlug;
+      entry.format = output.type;
+    }
+  }
+  return { entries, cjs, dts: dts2, warnings };
+}
+__name(inferEntries, "inferEntries");
+var getEntrypointPaths = /* @__PURE__ */ __name((path2) => {
+  const segments = (0, import_pathe.normalize)(path2).split("/");
+  return segments.map((_, index) => segments.slice(index).join("/")).filter(Boolean);
+}, "getEntrypointPaths");
+async function ensuredir(path2) {
+  await import_promises4.default.mkdir((0, import_pathe.dirname)(path2), { recursive: true });
+}
+__name(ensuredir, "ensuredir");
+function warn(ctx, message) {
+  if (ctx.warnings.has(message)) {
+    return;
+  }
+  import_consola.consola.debug("[unbuild] [warn]", message);
+  ctx.warnings.add(message);
+}
+__name(warn, "warn");
+async function symlink(from, to, force = true) {
+  await ensuredir(to);
+  if (force) {
+    await import_promises4.default.unlink(to).catch(() => {
+    });
+  }
+  await import_promises4.default.symlink(from, to, "junction");
+}
+__name(symlink, "symlink");
+function dumpObject(obj) {
+  return "{ " + Object.keys(obj).map((key) => `${key}: ${JSON.stringify(obj[key])}`).join(", ") + " }";
+}
+__name(dumpObject, "dumpObject");
+function getpkg(id = "") {
+  const s = id.split("/");
+  return s[0][0] === "@" ? `${s[0]}/${s[1]}` : s[0];
+}
+__name(getpkg, "getpkg");
+async function rmdir(dir) {
+  await import_promises4.default.unlink(dir).catch(() => {
+  });
+  await import_promises4.default.rm(dir, { recursive: true, force: true }).catch(() => {
+  });
+}
+__name(rmdir, "rmdir");
+function listRecursively(path2) {
+  const filenames = /* @__PURE__ */ new Set();
+  const walk = /* @__PURE__ */ __name((path22) => {
+    const files = (0, import_node_fs6.readdirSync)(path22);
+    for (const file of files) {
+      const fullPath = (0, import_pathe.resolve)(path22, file);
+      if ((0, import_node_fs6.statSync)(fullPath).isDirectory()) {
+        filenames.add(fullPath + "/");
+        walk(fullPath);
+      } else {
+        filenames.add(fullPath);
+      }
+    }
+  }, "walk");
+  walk(path2);
+  return [...filenames];
+}
+__name(listRecursively, "listRecursively");
+async function resolvePreset(preset, rootDir) {
+  if (preset === "auto") {
+    preset = autoPreset;
+  } else if (typeof preset === "string") {
+    preset = await (0, import_jiti.createJiti)(rootDir, { interopDefault: true }).import(preset, {
+      default: true
+    }) || {};
+  }
+  if (typeof preset === "function") {
+    preset = preset();
+  }
+  return preset;
+}
+__name(resolvePreset, "resolvePreset");
+function inferExportType(condition, previousConditions = [], filename = "") {
+  if (filename) {
+    if (filename.endsWith(".d.ts")) {
+      return "esm";
+    }
+    if (filename.endsWith(".mjs")) {
+      return "esm";
+    }
+    if (filename.endsWith(".cjs")) {
+      return "cjs";
+    }
+  }
+  switch (condition) {
+    case "import": {
+      return "esm";
+    }
+    case "require": {
+      return "cjs";
+    }
+    default: {
+      if (previousConditions.length === 0) {
+        return "esm";
+      }
+      const [newCondition, ...rest] = previousConditions;
+      return inferExportType(newCondition, rest, filename);
+    }
+  }
+}
+__name(inferExportType, "inferExportType");
+function extractExportFilenames(exports2, conditions = []) {
+  if (!exports2) {
+    return [];
+  }
+  if (typeof exports2 === "string") {
+    return [{ file: exports2, type: "esm" }];
+  }
+  return Object.entries(exports2).filter(([subpath]) => !subpath.endsWith(".json")).flatMap(
+    ([condition, exports22]) => typeof exports22 === "string" ? {
+      file: exports22,
+      type: inferExportType(condition, conditions, exports22)
+    } : extractExportFilenames(exports22, [...conditions, condition])
+  );
+}
+__name(extractExportFilenames, "extractExportFilenames");
+function arrayIncludes(arr, searchElement) {
+  return arr.some(
+    (entry) => entry instanceof RegExp ? entry.test(searchElement) : entry === searchElement
+  );
+}
+__name(arrayIncludes, "arrayIncludes");
+function removeExtension(filename) {
+  return filename.replace(/\.(js|mjs|cjs|ts|mts|cts|json|jsx|tsx)$/, "");
+}
+__name(removeExtension, "removeExtension");
+function inferPkgExternals(pkg) {
+  const externals = [
+    ...Object.keys(pkg.dependencies || {}),
+    ...Object.keys(pkg.peerDependencies || {}),
+    ...Object.keys(pkg.devDependencies || {}).filter(
+      (dep) => dep.startsWith("@types/")
+    ),
+    ...Object.keys(pkg.optionalDependencies || {})
+  ];
+  if (pkg.name) {
+    externals.push(pkg.name);
+    if (pkg.exports) {
+      for (const subpath of Object.keys(pkg.exports)) {
+        if (subpath.startsWith("./")) {
+          externals.push(pathToRegex(`${pkg.name}/${subpath.slice(2)}`));
+        }
+      }
+    }
+  }
+  if (pkg.imports) {
+    for (const importName of Object.keys(pkg.imports)) {
+      if (importName.startsWith("#")) {
+        externals.push(pathToRegex(importName));
+      }
+    }
+  }
+  return [...new Set(externals)];
+}
+__name(inferPkgExternals, "inferPkgExternals");
+function pathToRegex(path2) {
+  return path2.includes("*") ? new RegExp(
+    `^${path2.replace(/\./g, String.raw`\.`).replace(/\*/g, ".*")}$`
+  ) : path2;
+}
+__name(pathToRegex, "pathToRegex");
+function withTrailingSlash(path2) {
+  return path2.endsWith("/") ? path2 : `${path2}/`;
+}
+__name(withTrailingSlash, "withTrailingSlash");
+function validateDependencies(ctx) {
+  const usedDependencies = /* @__PURE__ */ new Set();
+  const unusedDependencies = new Set(
+    Object.keys(ctx.pkg.dependencies || {})
+  );
+  const implicitDependencies = /* @__PURE__ */ new Set();
+  for (const id of ctx.usedImports) {
+    unusedDependencies.delete(id);
+    usedDependencies.add(id);
+  }
+  if (Array.isArray(ctx.options.dependencies)) {
+    for (const id of ctx.options.dependencies) {
+      unusedDependencies.delete(id);
+    }
+  }
+  for (const id of usedDependencies) {
+    if (!arrayIncludes(ctx.options.externals, id) && !id.startsWith("chunks/") && !ctx.options.dependencies.includes(getpkg(id)) && !ctx.options.peerDependencies.includes(getpkg(id))) {
+      implicitDependencies.add(id);
+    }
+  }
+  if (unusedDependencies.size > 0) {
+    warn(
+      ctx,
+      "Potential unused dependencies found: " + [...unusedDependencies].map((id) => import_utils.colors.cyan(id)).join(", ")
+    );
+  }
+  if (implicitDependencies.size > 0 && !ctx.options.rollup.inlineDependencies) {
+    warn(
+      ctx,
+      "Potential implicit dependencies found: " + [...implicitDependencies].map((id) => import_utils.colors.cyan(id)).join(", ")
+    );
+  }
+}
+__name(validateDependencies, "validateDependencies");
+function validatePackage(pkg, rootDir, ctx) {
+  if (!pkg) {
+    return;
+  }
+  const filenames = new Set(
+    [
+      ...typeof pkg.bin === "string" ? [pkg.bin] : Object.values(pkg.bin || {}),
+      pkg.main,
+      pkg.module,
+      pkg.types,
+      pkg.typings,
+      ...extractExportFilenames(pkg.exports).map((i) => i.file)
+    ].map((i) => i && (0, import_pathe.resolve)(rootDir, i.replace(/\/[^/]*\*.*$/, "")))
+  );
+  const missingOutputs = [];
+  for (const filename of filenames) {
+    if (filename && !filename.includes("*") && !(0, import_node_fs6.existsSync)(filename)) {
+      missingOutputs.push(filename.replace(rootDir + "/", ""));
+    }
+  }
+  if (missingOutputs.length > 0) {
+    warn(
+      ctx,
+      `Potential missing package.json files: ${missingOutputs.map((o) => import_utils.colors.cyan(o)).join(", ")}`
+    );
+  }
+}
+__name(validatePackage, "validatePackage");
+var SHEBANG_RE = /^#![^\n]*/;
+function shebangPlugin() {
+  return {
+    name: "unbuild-shebang",
+    async writeBundle(options, bundle) {
+      for (const [fileName, output] of Object.entries(bundle)) {
+        if (output.type !== "chunk") {
+          continue;
+        }
+        if (output.code?.match(SHEBANG_RE)) {
+          const outFile = (0, import_pathe.resolve)(options.dir, fileName);
+          await makeExecutable(outFile);
+        }
+      }
+    }
+  };
+}
+__name(shebangPlugin, "shebangPlugin");
+function removeShebangPlugin() {
+  return {
+    name: "unbuild-remove-shebang",
+    renderChunk(code) {
+      return code.replace(SHEBANG_RE, "");
+    }
+  };
+}
+__name(removeShebangPlugin, "removeShebangPlugin");
+async function makeExecutable(filePath) {
+  await import_node_fs6.promises.chmod(
+    filePath,
+    493
+    /* rwx r-x r-x */
+  ).catch(() => {
+  });
+}
+__name(makeExecutable, "makeExecutable");
+function getShebang(code, append = "\n") {
+  const m = code.match(SHEBANG_RE);
+  return m ? m + append : "";
+}
+__name(getShebang, "getShebang");
+var DefaultLoaders = {
+  ".js": "js",
+  ".mjs": "js",
+  ".cjs": "js",
+  ".ts": "ts",
+  ".mts": "ts",
+  ".cts": "ts",
+  ".tsx": "tsx",
+  ".jsx": "jsx"
+};
+function esbuild(options) {
+  const {
+    include = new RegExp(Object.keys(DefaultLoaders).join("|")),
+    exclude = /node_modules/,
+    loaders: loaderOptions,
+    ...esbuildOptions
+  } = options;
+  const loaders = { ...DefaultLoaders };
+  if (loaderOptions) {
+    for (const [key, value] of Object.entries(loaderOptions)) {
+      if (typeof value === "string") {
+        loaders[key] = value;
+      } else if (value === false) {
+        delete loaders[key];
+      }
+    }
+  }
+  const getLoader = /* @__PURE__ */ __name((id = "") => {
+    return loaders[(0, import_pathe.extname)(id)];
+  }, "getLoader");
+  const filter = (0, import_pluginutils.createFilter)(include, exclude);
+  return {
+    name: "esbuild",
+    async transform(code, id) {
+      if (!filter(id)) {
+        return null;
+      }
+      const loader = getLoader(id);
+      if (!loader) {
+        return null;
+      }
+      const result = await (0, import_esbuild.transform)(code, {
+        ...esbuildOptions,
+        loader,
+        sourcefile: id
+      });
+      printWarnings(id, result, this);
+      return {
+        code: result.code || "",
+        map: result.map || null
+      };
+    },
+    async renderChunk(code, { fileName }) {
+      if (!options.minify) {
+        return null;
+      }
+      if (/\.d\.(c|m)?tsx?$/.test(fileName)) {
+        return null;
+      }
+      const loader = getLoader(fileName);
+      if (!loader) {
+        return null;
+      }
+      const result = await (0, import_esbuild.transform)(code, {
+        ...esbuildOptions,
+        loader,
+        sourcefile: fileName,
+        minify: true
+      });
+      return {
+        code: result.code || "",
+        map: result.map || null
+      };
+    }
+  };
+}
+__name(esbuild, "esbuild");
+function printWarnings(id, result, plugin) {
+  if (result.warnings) {
+    for (const warning of result.warnings) {
+      let message = "[esbuild]";
+      if (warning.location) {
+        message += ` (${(0, import_pathe.relative)(process.cwd(), id)}:${warning.location.line}:${warning.location.column})`;
+      }
+      message += ` ${warning.text}`;
+      plugin.warn(message);
+    }
+  }
+}
+__name(printWarnings, "printWarnings");
+var EXPORT_DEFAULT = "export default ";
+function JSONPlugin(options) {
+  const plugin = (0, import_plugin_json.default)(options);
+  return {
+    ...plugin,
+    name: "unbuild-json",
+    transform(code, id) {
+      const res = plugin.transform.call(this, code, id);
+      if (res && typeof res !== "string" && "code" in res && res.code && res.code.startsWith(EXPORT_DEFAULT)) {
+        res.code = res.code.replace(EXPORT_DEFAULT, "module.exports = ");
+      }
+      return res;
+    }
+  };
+}
+__name(JSONPlugin, "JSONPlugin");
+var defaults = {
+  include: [/\.(md|txt|css|htm|html)$/],
+  exclude: []
+};
+function rawPlugin(opts = {}) {
+  opts = { ...opts, ...defaults };
+  const filter = (0, import_pluginutils.createFilter)(opts.include, opts.exclude);
+  return {
+    name: "unbuild-raw",
+    transform(code, id) {
+      if (filter(id)) {
+        return {
+          code: `export default ${JSON.stringify(code)}`,
+          map: null
+        };
+      }
+    }
+  };
+}
+__name(rawPlugin, "rawPlugin");
+function cjsPlugin(_opts) {
+  return {
+    name: "unbuild-cjs",
+    renderChunk(code, _chunk, opts) {
+      if (opts.format === "es") {
+        return CJSToESM(code);
+      }
+      return null;
+    }
+  };
+}
+__name(cjsPlugin, "cjsPlugin");
+function fixCJSExportTypePlugin() {
+  return {
+    name: "unbuild-fix-cjs-export-type",
+    renderChunk(code, info, opts) {
+      if (info.type !== "chunk" || !info.fileName.endsWith(".d.cts") || !info.isEntry || info.exports?.length !== 1 || info.exports[0] !== "default") {
+        return;
+      }
+      return code.replace(
+        /(?<=(?<=[;}]|^)\s*export\s*){\s*([\w$]+)\s*as\s+default\s*}/,
+        `= $1`
+      );
+    }
+  };
+}
+__name(fixCJSExportTypePlugin, "fixCJSExportTypePlugin");
+var CJSyntaxRe = /__filename|__dirname|require\(|require\.resolve\(/;
+var CJSShim = `
+
+// -- Unbuild CommonJS Shims --
+import __cjs_url__ from 'url';
+import __cjs_path__ from 'path';
+import __cjs_mod__ from 'module';
+const __filename = __cjs_url__.fileURLToPath(import.meta.url);
+const __dirname = __cjs_path__.dirname(__filename);
+const require = __cjs_mod__.createRequire(import.meta.url);
+`;
+function CJSToESM(code) {
+  if (code.includes(CJSShim) || !CJSyntaxRe.test(code)) {
+    return null;
+  }
+  const lastESMImport = (0, import_mlly.findStaticImports)(code).pop();
+  const indexToAppend = lastESMImport ? lastESMImport.end : 0;
+  const s = new import_magic_string.default(code);
+  s.appendRight(indexToAppend, CJSShim);
+  return {
+    code: s.toString(),
+    map: s.generateMap()
+  };
+}
+__name(CJSToESM, "CJSToESM");
+var DEFAULT_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".mjs",
+  ".cjs",
+  ".js",
+  ".jsx",
+  ".json"
+];
+function resolveAliases(ctx) {
+  const aliases = {
+    [ctx.pkg.name]: ctx.options.rootDir,
+    ...ctx.options.alias
+  };
+  if (ctx.options.rollup.alias) {
+    if (Array.isArray(ctx.options.rollup.alias.entries)) {
+      Object.assign(
+        aliases,
+        Object.fromEntries(
+          ctx.options.rollup.alias.entries.map((entry) => {
+            return [entry.find, entry.replacement];
+          })
+        )
+      );
+    } else {
+      Object.assign(
+        aliases,
+        ctx.options.rollup.alias.entries || ctx.options.rollup.alias
+      );
+    }
+  }
+  return aliases;
+}
+__name(resolveAliases, "resolveAliases");
+function getChunkFilename(ctx, chunk, ext) {
+  if (chunk.isDynamicEntry) {
+    return `chunks/[name].${ext}`;
+  }
+  return `shared/${ctx.options.name}.[hash].${ext}`;
+}
+__name(getChunkFilename, "getChunkFilename");
+function getRollupOptions(ctx) {
+  const _aliases = resolveAliases(ctx);
+  return {
+    input: Object.fromEntries(
+      ctx.options.entries.filter((entry) => entry.builder === "rollup").map((entry) => [
+        entry.name,
+        (0, import_pathe.resolve)(ctx.options.rootDir, entry.input)
+      ])
+    ),
+    output: [
+      ctx.options.rollup.emitCJS && {
+        dir: (0, import_pathe.resolve)(ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].cjs",
+        chunkFileNames: /* @__PURE__ */ __name((chunk) => getChunkFilename(ctx, chunk, "cjs"), "chunkFileNames"),
+        format: "cjs",
+        exports: "auto",
+        interop: "compat",
+        generatedCode: { constBindings: true },
+        externalLiveBindings: false,
+        freeze: false,
+        sourcemap: ctx.options.sourcemap,
+        ...ctx.options.rollup.output
+      },
+      {
+        dir: (0, import_pathe.resolve)(ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].mjs",
+        chunkFileNames: /* @__PURE__ */ __name((chunk) => getChunkFilename(ctx, chunk, "mjs"), "chunkFileNames"),
+        format: "esm",
+        exports: "auto",
+        generatedCode: { constBindings: true },
+        externalLiveBindings: false,
+        freeze: false,
+        sourcemap: ctx.options.sourcemap,
+        ...ctx.options.rollup.output
+      }
+    ].filter(Boolean),
+    external(originalId) {
+      const resolvedId = (0, import_utils2.resolveAlias)(originalId, _aliases);
+      const pkgName = (0, import_mlly.parseNodeModulePath)(resolvedId)?.name || (0, import_mlly.parseNodeModulePath)(originalId)?.name || getpkg(originalId);
+      if (arrayIncludes(ctx.options.externals, pkgName) || arrayIncludes(ctx.options.externals, originalId) || arrayIncludes(ctx.options.externals, resolvedId)) {
+        return true;
+      }
+      for (const id of [originalId, resolvedId]) {
+        if (id[0] === "." || (0, import_pathe.isAbsolute)(id) || /src[/\\]/.test(id) || id.startsWith(ctx.pkg.name)) {
+          return false;
+        }
+      }
+      if (ctx.options.rollup.inlineDependencies === true || Array.isArray(ctx.options.rollup.inlineDependencies) && (arrayIncludes(ctx.options.rollup.inlineDependencies, pkgName) || arrayIncludes(ctx.options.rollup.inlineDependencies, originalId) || arrayIncludes(ctx.options.rollup.inlineDependencies, resolvedId))) {
+        return false;
+      }
+      warn(ctx, `Implicitly bundling "${originalId}"`);
+      return false;
+    },
+    onwarn(warning, rollupWarn) {
+      if (!warning.code || !["CIRCULAR_DEPENDENCY"].includes(warning.code)) {
+        rollupWarn(warning);
+      }
+    },
+    plugins: [
+      ctx.options.rollup.replace && (0, import_plugin_replace.default)({
+        ...ctx.options.rollup.replace,
+        values: {
+          ...ctx.options.replace,
+          ...ctx.options.rollup.replace.values
+        }
+      }),
+      ctx.options.rollup.alias && (0, import_plugin_alias.default)({
+        ...ctx.options.rollup.alias,
+        entries: _aliases
+      }),
+      ctx.options.rollup.resolve && (0, import_plugin_node_resolve.nodeResolve)({
+        extensions: DEFAULT_EXTENSIONS,
+        exportConditions: ["production"],
+        ...ctx.options.rollup.resolve
+      }),
+      ctx.options.rollup.json && JSONPlugin({
+        ...ctx.options.rollup.json
+      }),
+      shebangPlugin(),
+      ctx.options.rollup.esbuild && esbuild({
+        sourcemap: ctx.options.sourcemap,
+        ...ctx.options.rollup.esbuild
+      }),
+      ctx.options.rollup.commonjs && (0, import_plugin_commonjs.default)({
+        extensions: DEFAULT_EXTENSIONS,
+        ...ctx.options.rollup.commonjs
+      }),
+      ctx.options.rollup.preserveDynamicImports && {
+        renderDynamicImport() {
+          return { left: "import(", right: ")" };
+        }
+      },
+      ctx.options.rollup.cjsBridge && cjsPlugin(),
+      rawPlugin()
+    ].filter(Boolean)
+  };
+}
+__name(getRollupOptions, "getRollupOptions");
+async function rollupStub(ctx) {
+  const babelPlugins = ctx.options.stubOptions.jiti.transformOptions?.babel?.plugins;
+  const importedBabelPlugins = [];
+  const serializedJitiOptions = JSON.stringify(
+    {
+      ...ctx.options.stubOptions.jiti,
+      alias: {
+        ...resolveAliases(ctx),
+        ...ctx.options.stubOptions.jiti.alias
+      },
+      transformOptions: {
+        ...ctx.options.stubOptions.jiti.transformOptions,
+        babel: {
+          ...ctx.options.stubOptions.jiti.transformOptions?.babel,
+          plugins: "__$BABEL_PLUGINS"
+        }
+      }
+    },
+    null,
+    2
+  ).replace(
+    '"__$BABEL_PLUGINS"',
+    Array.isArray(babelPlugins) ? "[" + babelPlugins.map((plugin, i) => {
+      if (Array.isArray(plugin)) {
+        const [name, ...args] = plugin;
+        importedBabelPlugins.push(name);
+        return `[` + [
+          `plugin${i}`,
+          ...args.map((val) => JSON.stringify(val))
+        ].join(", ") + "]";
+      } else {
+        importedBabelPlugins.push(plugin);
+        return `plugin${i}`;
+      }
+    }).join(",") + "]" : "[]"
+  );
+  for (const entry of ctx.options.entries.filter(
+    (entry2) => entry2.builder === "rollup"
+  )) {
+    const output = (0, import_pathe.resolve)(
+      ctx.options.rootDir,
+      ctx.options.outDir,
+      entry.name
+    );
+    const isESM = ctx.pkg.type === "module";
+    const resolvedEntry = (0, import_mlly.fileURLToPath)(ctx.jiti.esmResolve(entry.input));
+    const resolvedEntryWithoutExt = resolvedEntry.slice(
+      0,
+      Math.max(0, resolvedEntry.length - (0, import_pathe.extname)(resolvedEntry).length)
+    );
+    const resolvedEntryForTypeImport = isESM ? `${resolvedEntry.replace(/(\.m?)(ts)$/, "$1js")}` : resolvedEntryWithoutExt;
+    const code = await import_node_fs6.promises.readFile(resolvedEntry, "utf8");
+    const shebang = getShebang(code);
+    await (0, import_promises4.mkdir)((0, import_pathe.dirname)(output), { recursive: true });
+    if (ctx.options.rollup.emitCJS) {
+      const jitiCJSPath = (0, import_pathe.relative)(
+        (0, import_pathe.dirname)(output),
+        await (0, import_mlly.resolvePath)("jiti", {
+          url: importMetaUrl,
+          conditions: ["node", "require"]
+        })
+      );
+      await (0, import_promises4.writeFile)(
+        output + ".cjs",
+        shebang + [
+          `const { createJiti } = require(${JSON.stringify(jitiCJSPath)})`,
+          ...importedBabelPlugins.map(
+            (plugin, i) => `const plugin${i} = require(${JSON.stringify(plugin)})`
+          ),
+          "",
+          `const jiti = createJiti(__filename, ${serializedJitiOptions})`,
+          "",
+          `/** @type {import(${JSON.stringify(
+            resolvedEntryForTypeImport
+          )})} */`,
+          `module.exports = jiti(${JSON.stringify(resolvedEntry)})`
+        ].join("\n")
+      );
+    }
+    const namedExports = await (0, import_mlly.resolveModuleExportNames)(
+      resolvedEntry,
+      {
+        extensions: DEFAULT_EXTENSIONS
+      }
+    ).catch((error) => {
+      warn(ctx, `Cannot analyze ${resolvedEntry} for exports:` + error);
+      return [];
+    });
+    const hasDefaultExport = namedExports.includes("default") || namedExports.length === 0;
+    const jitiESMPath = (0, import_pathe.relative)(
+      (0, import_pathe.dirname)(output),
+      await (0, import_mlly.resolvePath)("jiti", {
+        url: importMetaUrl,
+        conditions: ["node", "import"]
+      })
+    );
+    await (0, import_promises4.writeFile)(
+      output + ".mjs",
+      shebang + [
+        `import { createJiti } from ${JSON.stringify(jitiESMPath)};`,
+        ...importedBabelPlugins.map(
+          (plugin, i) => `import plugin${i} from ${JSON.stringify(plugin)}`
+        ),
+        "",
+        `const jiti = createJiti(import.meta.url, ${serializedJitiOptions})`,
+        "",
+        `/** @type {import(${JSON.stringify(resolvedEntryForTypeImport)})} */`,
+        `const _module = await jiti.import(${JSON.stringify(
+          resolvedEntry
+        )});`,
+        hasDefaultExport ? "\nexport default _module?.default ?? _module;" : "",
+        ...namedExports.filter((name) => name !== "default").map((name) => `export const ${name} = _module.${name};`)
+      ].join("\n")
+    );
+    if (ctx.options.declaration) {
+      const dtsContent = [
+        `export * from ${JSON.stringify(resolvedEntryForTypeImport)};`,
+        hasDefaultExport ? `export { default } from ${JSON.stringify(resolvedEntryForTypeImport)};` : ""
+      ].join("\n");
+      await (0, import_promises4.writeFile)(output + ".d.cts", dtsContent);
+      await (0, import_promises4.writeFile)(output + ".d.mts", dtsContent);
+      if (ctx.options.declaration === "compatible" || ctx.options.declaration === true) {
+        await (0, import_promises4.writeFile)(output + ".d.ts", dtsContent);
+      }
+    }
+    if (shebang) {
+      await makeExecutable(output + ".cjs");
+      await makeExecutable(output + ".mjs");
+    }
+  }
+}
+__name(rollupStub, "rollupStub");
+function rollupWatch(rollupOptions) {
+  const watcher = (0, import_rollup.watch)(rollupOptions);
+  let inputs;
+  if (Array.isArray(rollupOptions.input)) {
+    inputs = rollupOptions.input;
+  } else if (typeof rollupOptions.input === "string") {
+    inputs = [rollupOptions.input];
+  } else {
+    inputs = Object.keys(rollupOptions.input || {});
+  }
+  import_consola.default.info(
+    `[unbuild] [rollup] Starting watchers for entries: ${inputs.map((input) => "./" + (0, import_pathe.relative)(process.cwd(), input)).join(", ")}`
+  );
+  import_consola.default.warn(
+    "[unbuild] [rollup] Watch mode is experimental and may be unstable"
+  );
+  watcher.on("change", (id, { event }) => {
+    import_consola.default.info(`${import_utils.colors.cyan((0, import_pathe.relative)(".", id))} was ${event}d`);
+  });
+  watcher.on("restart", () => {
+    import_consola.default.info(import_utils.colors.gray("[unbuild] [rollup] Rebuilding bundle"));
+  });
+  watcher.on("event", (event) => {
+    if (event.code === "END") {
+      import_consola.default.success(import_utils.colors.green("[unbuild] [rollup] Rebuild finished\n"));
+    }
+  });
+}
+__name(rollupWatch, "rollupWatch");
+async function rollupBuild(ctx) {
+  if (ctx.options.stub) {
+    await rollupStub(ctx);
+    await ctx.hooks.callHook("rollup:done", ctx);
+    return;
+  }
+  const rollupOptions = getRollupOptions(ctx);
+  await ctx.hooks.callHook("rollup:options", ctx, rollupOptions);
+  if (Object.keys(rollupOptions.input).length === 0) {
+    await ctx.hooks.callHook("rollup:done", ctx);
+    return;
+  }
+  const buildResult = await (0, import_rollup.rollup)(rollupOptions);
+  await ctx.hooks.callHook("rollup:build", ctx, buildResult);
+  const allOutputOptions = rollupOptions.output;
+  for (const outputOptions of allOutputOptions) {
+    const { output } = await buildResult.write(outputOptions);
+    const chunkFileNames = /* @__PURE__ */ new Set();
+    const outputChunks = output.filter(
+      (e) => e.type === "chunk"
+    );
+    for (const entry of outputChunks) {
+      chunkFileNames.add(entry.fileName);
+      for (const id of entry.imports) {
+        ctx.usedImports.add(id);
+      }
+      if (entry.isEntry) {
+        ctx.buildEntries.push({
+          chunks: entry.imports.filter(
+            (i) => outputChunks.find((c) => c.fileName === i)
+          ),
+          modules: Object.entries(entry.modules).map(([id, mod]) => ({
+            id,
+            bytes: mod.renderedLength
+          })),
+          path: entry.fileName,
+          bytes: Buffer.byteLength(entry.code, "utf8"),
+          exports: entry.exports
+        });
+      }
+    }
+    for (const chunkFileName of chunkFileNames) {
+      ctx.usedImports.delete(chunkFileName);
+    }
+  }
+  if (ctx.options.watch) {
+    rollupWatch(rollupOptions);
+    if (ctx.options.declaration && ctx.options.watch) {
+      import_consola.default.warn("`rollup` DTS builder does not support watch mode yet.");
+    }
+    return;
+  }
+  if (ctx.options.declaration) {
+    rollupOptions.plugins = [
+      ...rollupOptions.plugins,
+      (0, import_rollup_plugin_dts.default)(ctx.options.rollup.dts),
+      removeShebangPlugin(),
+      ctx.options.rollup.emitCJS && fixCJSExportTypePlugin()
+    ].filter(Boolean);
+    await ctx.hooks.callHook("rollup:dts:options", ctx, rollupOptions);
+    const typesBuild2 = await (0, import_rollup.rollup)(rollupOptions);
+    await ctx.hooks.callHook("rollup:dts:build", ctx, typesBuild2);
+    if (ctx.options.rollup.emitCJS) {
+      await typesBuild2.write({
+        dir: (0, import_pathe.resolve)(ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].d.cts",
+        chunkFileNames: /* @__PURE__ */ __name((chunk) => getChunkFilename(ctx, chunk, "d.cts"), "chunkFileNames")
+      });
+    }
+    await typesBuild2.write({
+      dir: (0, import_pathe.resolve)(ctx.options.rootDir, ctx.options.outDir),
+      entryFileNames: "[name].d.mts",
+      chunkFileNames: /* @__PURE__ */ __name((chunk) => getChunkFilename(ctx, chunk, "d.mts"), "chunkFileNames")
+    });
+    if (ctx.options.declaration === true || ctx.options.declaration === "compatible") {
+      await typesBuild2.write({
+        dir: (0, import_pathe.resolve)(ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].d.ts",
+        chunkFileNames: /* @__PURE__ */ __name((chunk) => getChunkFilename(ctx, chunk, "d.ts"), "chunkFileNames")
+      });
+    }
+  }
+  await ctx.hooks.callHook("rollup:done", ctx);
+}
+__name(rollupBuild, "rollupBuild");
+async function typesBuild(ctx) {
+  const entries = ctx.options.entries.filter(
+    (entry) => entry.builder === "untyped"
+  );
+  await ctx.hooks.callHook("untyped:entries", ctx, entries);
+  for (const entry of entries) {
+    const options = {
+      jiti: {
+        interopDefault: true,
+        transformOptions: {
+          babel: {
+            plugins: [import_babel_plugin.default]
+          }
+        }
+      }
+    };
+    await ctx.hooks.callHook("untyped:entry:options", ctx, entry, options);
+    const untypedJiti = (0, import_jiti.createJiti)(ctx.options.rootDir, options.jiti);
+    const distDir = entry.outDir;
+    let rawSchema = await untypedJiti.import((0, import_pathe.resolve)(ctx.options.rootDir, entry.input), {
+      try: true
+    }) || {};
+    const rawSchemaKeys = Object.keys(rawSchema);
+    if (rawSchemaKeys.length === 1 && rawSchemaKeys[0] === "default") {
+      rawSchema = rawSchema.default;
+    }
+    const defaults2 = entry.defaults || {};
+    const schema = await (0, import_untyped.resolveSchema)(rawSchema, defaults2);
+    await ctx.hooks.callHook("untyped:entry:schema", ctx, entry, schema);
+    const outputs = {
+      markdown: {
+        fileName: (0, import_pathe.resolve)(distDir, `${entry.name}.md`),
+        contents: (0, import_untyped.generateMarkdown)(schema)
+      },
+      schema: {
+        fileName: `${entry.name}.schema.json`,
+        contents: JSON.stringify(schema, null, 2)
+      },
+      defaults: {
+        fileName: `${entry.name}.defaults.json`,
+        contents: JSON.stringify(defaults2, null, 2)
+      },
+      declaration: entry.declaration ? {
+        fileName: `${entry.name}.d.ts`,
+        contents: (0, import_untyped.generateTypes)(schema, {
+          interfaceName: (0, import_scule.pascalCase)(entry.name + "-schema")
+        })
+      } : void 0
+    };
+    await ctx.hooks.callHook("untyped:entry:outputs", ctx, entry, outputs);
+    for (const output of Object.values(outputs)) {
+      if (!output) continue;
+      await (0, import_promises4.writeFile)(
+        (0, import_pathe.resolve)(distDir, output.fileName),
+        output.contents,
+        "utf8"
+      );
+    }
+  }
+  await ctx.hooks.callHook("untyped:done", ctx);
+  if (entries.length > 0 && ctx.options.watch) {
+    import_consola.default.warn("`untyped` builder does not support watch mode yet.");
+  }
+}
+__name(typesBuild, "typesBuild");
+async function mkdistBuild(ctx) {
+  const entries = ctx.options.entries.filter(
+    (e) => e.builder === "mkdist"
+  );
+  await ctx.hooks.callHook("mkdist:entries", ctx, entries);
+  for (const entry of entries) {
+    const distDir = entry.outDir;
+    if (ctx.options.stub) {
+      await rmdir(distDir);
+      await symlink(entry.input, distDir);
+    } else {
+      const mkdistOptions = {
+        rootDir: ctx.options.rootDir,
+        srcDir: entry.input,
+        distDir,
+        cleanDist: false,
+        ...entry
+      };
+      await ctx.hooks.callHook(
+        "mkdist:entry:options",
+        ctx,
+        entry,
+        mkdistOptions
+      );
+      const output = await (0, import_mkdist.mkdist)(mkdistOptions);
+      ctx.buildEntries.push({
+        path: distDir,
+        chunks: output.writtenFiles.map((p) => (0, import_pathe.relative)(ctx.options.outDir, p))
+      });
+      await ctx.hooks.callHook("mkdist:entry:build", ctx, entry, output);
+      if (output.errors) {
+        for (const error of output.errors) {
+          warn(
+            ctx,
+            `mkdist build failed for \`${(0, import_pathe.relative)(ctx.options.rootDir, error.filename)}\`:
+${error.errors.map((e) => `  - ${e}`).join("\n")}`
+          );
+        }
+      }
+    }
+  }
+  await ctx.hooks.callHook("mkdist:done", ctx);
+  if (entries.length > 0 && ctx.options.watch) {
+    import_consola.default.warn("`mkdist` builder does not support watch mode yet.");
+  }
+}
+__name(mkdistBuild, "mkdistBuild");
+var copy = import_node_fs6.promises.cp || import_node_fs6.promises.copyFile;
+async function copyBuild(ctx) {
+  const entries = ctx.options.entries.filter(
+    (e) => e.builder === "copy"
+  );
+  await ctx.hooks.callHook("copy:entries", ctx, entries);
+  for (const entry of entries) {
+    const distDir = entry.outDir;
+    if (ctx.options.stub) {
+      await rmdir(distDir);
+      await symlink(entry.input, distDir);
+    } else {
+      const patterns = Array.isArray(entry.pattern) ? entry.pattern : [entry.pattern || "**"];
+      const paths = await (0, import_tinyglobby.glob)(patterns, {
+        cwd: (0, import_pathe.resolve)(ctx.options.rootDir, entry.input),
+        absolute: false
+      });
+      const outputList = await Promise.allSettled(
+        paths.map(async (path2) => {
+          const src = (0, import_pathe.resolve)(ctx.options.rootDir, entry.input, path2);
+          const dist = (0, import_pathe.resolve)(ctx.options.rootDir, distDir, path2);
+          await copy(src, dist);
+          return dist;
+        })
+      );
+      for (const output of outputList) {
+        if (output.status === "rejected") {
+          warn(ctx, output.reason);
+        }
+      }
+      ctx.buildEntries.push({
+        path: distDir,
+        chunks: outputList.filter(({ status }) => status === "fulfilled").map(
+          (p) => (0, import_pathe.relative)(
+            ctx.options.outDir,
+            p.value
+          )
+        )
+      });
+    }
+  }
+  await ctx.hooks.callHook("copy:done", ctx);
+  if (entries.length > 0 && ctx.options.watch) {
+    import_consola.default.warn("`untyped` builder does not support watch mode yet.");
+  }
+}
+__name(copyBuild, "copyBuild");
+async function build(rootDir, stub, inputConfig = {}) {
+  rootDir = (0, import_pathe.resolve)(process.cwd(), rootDir || ".");
+  const jiti = (0, import_jiti.createJiti)(rootDir);
+  const _buildConfig = await jiti.import(inputConfig?.config || "./build.config", {
+    try: !inputConfig.config,
+    default: true
+  }) || {};
+  const buildConfigs = (Array.isArray(_buildConfig) ? _buildConfig : [_buildConfig]).filter(Boolean);
+  const pkg = await jiti.import("./package.json", {
+    try: true,
+    default: true
+  }) || {};
+  const cleanedDirs = [];
+  const _watchMode = inputConfig.watch === true;
+  const _stubMode = !_watchMode && (stub || inputConfig.stub === true);
+  for (const buildConfig of buildConfigs) {
+    await _build(
+      rootDir,
+      inputConfig,
+      buildConfig,
+      pkg,
+      cleanedDirs,
+      _stubMode,
+      _watchMode
+    );
+  }
+}
+__name(build, "build");
+async function _build(rootDir, inputConfig = {}, buildConfig, pkg, cleanedDirs, _stubMode, _watchMode) {
+  const preset = await resolvePreset(
+    buildConfig.preset || pkg.unbuild?.preset || pkg.build?.preset || inputConfig.preset || "auto",
+    rootDir
+  );
+  const options = (0, import_defu3.defu)(
+    buildConfig,
+    pkg.unbuild || pkg.build,
+    inputConfig,
+    preset,
+    {
+      name: (pkg?.name || "").split("/").pop() || "default",
+      rootDir,
+      entries: [],
+      clean: true,
+      declaration: void 0,
+      outDir: "dist",
+      stub: _stubMode,
+      stubOptions: {
+        /**
+         * See https://github.com/unjs/jiti#%EF%B8%8F-options
+         */
+        jiti: {
+          interopDefault: true,
+          alias: {}
+        }
+      },
+      watch: _watchMode,
+      watchOptions: _watchMode ? {
+        exclude: "node_modules/**",
+        include: "src/**"
+      } : void 0,
+      externals: [
+        ...import_node_module2.default.builtinModules,
+        ...import_node_module2.default.builtinModules.map((m) => "node:" + m)
+      ],
+      dependencies: [],
+      devDependencies: [],
+      peerDependencies: [],
+      alias: {},
+      replace: {},
+      failOnWarn: true,
+      sourcemap: false,
+      rollup: {
+        emitCJS: false,
+        watch: false,
+        cjsBridge: false,
+        inlineDependencies: false,
+        preserveDynamicImports: true,
+        output: {
+          // https://v8.dev/features/import-attributes
+          importAttributesKey: "with"
+        },
+        // Plugins
+        replace: {
+          preventAssignment: true
+        },
+        alias: {},
+        resolve: {
+          preferBuiltins: true
+        },
+        json: {
+          preferConst: true
+        },
+        commonjs: {
+          ignoreTryCatch: true
+        },
+        esbuild: { target: "esnext" },
+        dts: {
+          // https://github.com/Swatinem/rollup-plugin-dts/issues/143
+          compilerOptions: { preserveSymlinks: false },
+          respectExternal: true
+        }
+      },
+      parallel: false
+    }
+  );
+  options.outDir = (0, import_pathe.resolve)(options.rootDir, options.outDir);
+  const jiti = (0, import_jiti.createJiti)(options.rootDir, { interopDefault: true });
+  const ctx = {
+    options,
+    jiti,
+    warnings: /* @__PURE__ */ new Set(),
+    pkg,
+    buildEntries: [],
+    usedImports: /* @__PURE__ */ new Set(),
+    hooks: (0, import_hookable.createHooks)()
+  };
+  if (preset.hooks) {
+    ctx.hooks.addHooks(preset.hooks);
+  }
+  if (inputConfig.hooks) {
+    ctx.hooks.addHooks(inputConfig.hooks);
+  }
+  if (buildConfig.hooks) {
+    ctx.hooks.addHooks(buildConfig.hooks);
+  }
+  await ctx.hooks.callHook("build:prepare", ctx);
+  options.entries = options.entries.map(
+    (entry) => typeof entry === "string" ? { input: entry } : entry
+  );
+  for (const entry of options.entries) {
+    if (typeof entry.name !== "string") {
+      let relativeInput = (0, import_pathe.isAbsolute)(entry.input) ? (0, import_pathe.relative)(rootDir, entry.input) : (0, import_pathe.normalize)(entry.input);
+      if (relativeInput.startsWith("./")) {
+        relativeInput = relativeInput.slice(2);
+      }
+      entry.name = removeExtension(relativeInput.replace(/^src\//, ""));
+    }
+    if (!entry.input) {
+      throw new Error("Missing entry input: " + dumpObject(entry));
+    }
+    if (!entry.builder) {
+      entry.builder = entry.input.endsWith("/") ? "mkdist" : "rollup";
+    }
+    if (options.declaration !== void 0 && entry.declaration === void 0) {
+      entry.declaration = options.declaration;
+    }
+    entry.input = (0, import_pathe.resolve)(options.rootDir, entry.input);
+    entry.outDir = (0, import_pathe.resolve)(options.rootDir, entry.outDir || options.outDir);
+  }
+  options.dependencies = Object.keys(pkg.dependencies || {});
+  options.peerDependencies = Object.keys(pkg.peerDependencies || {});
+  options.devDependencies = Object.keys(pkg.devDependencies || {});
+  options.externals.push(...inferPkgExternals(pkg));
+  options.externals = [...new Set(options.externals)];
+  await ctx.hooks.callHook("build:before", ctx);
+  import_consola.consola.info(
+    import_utils.colors.cyan(`${options.stub ? "Stubbing" : "Building"} ${options.name}`)
+  );
+  if (process.env.DEBUG) {
+    import_consola.consola.info(`${import_utils.colors.bold("Root dir:")} ${options.rootDir}
+  ${import_utils.colors.bold("Entries:")}
+  ${options.entries.map((entry) => "  " + dumpObject(entry)).join("\n  ")}
+`);
+  }
+  if (options.clean) {
+    for (const dir of new Set(
+      options.entries.map((e) => e.outDir).filter(Boolean).sort()
+    )) {
+      if (dir === options.rootDir || options.rootDir.startsWith(withTrailingSlash(dir)) || cleanedDirs.some((c) => dir.startsWith(c))) {
+        continue;
+      }
+      cleanedDirs.push(dir);
+      import_consola.consola.info(
+        `Cleaning dist directory: \`./${(0, import_pathe.relative)(process.cwd(), dir)}\``
+      );
+      await rmdir(dir);
+      await import_node_fs6.promises.mkdir(dir, { recursive: true });
+    }
+  }
+  const buildTasks = [
+    typesBuild,
+    // untyped
+    mkdistBuild,
+    // mkdist
+    rollupBuild,
+    // rollup
+    copyBuild
+    // copy
+  ];
+  if (options.parallel) {
+    await Promise.all(buildTasks.map((task) => task(ctx)));
+  } else {
+    for (const task of buildTasks) {
+      await task(ctx);
+    }
+  }
+  if (options.stub || options.watch) {
+    await ctx.hooks.callHook("build:done", ctx);
+    return;
+  }
+  import_consola.consola.success(import_utils.colors.green("Build succeeded for " + options.name));
+  const outFiles = await (0, import_tinyglobby.glob)(["**"], { cwd: options.outDir });
+  for (const file of outFiles) {
+    let entry = ctx.buildEntries.find((e) => e.path === file);
+    if (!entry) {
+      entry = {
+        path: file,
+        chunk: true
+      };
+      ctx.buildEntries.push(entry);
+    }
+    if (!entry.bytes) {
+      const stat = await import_node_fs6.promises.stat((0, import_pathe.resolve)(options.outDir, file));
+      entry.bytes = stat.size;
+    }
+  }
+  const rPath = /* @__PURE__ */ __name((p) => (0, import_pathe.relative)(process.cwd(), (0, import_pathe.resolve)(options.outDir, p)), "rPath");
+  for (const entry of ctx.buildEntries.filter((e) => !e.chunk)) {
+    let totalBytes = entry.bytes || 0;
+    for (const chunk of entry.chunks || []) {
+      totalBytes += ctx.buildEntries.find((e) => e.path === chunk)?.bytes || 0;
+    }
+    let line = `  ${import_utils.colors.bold(rPath(entry.path))} (` + [
+      totalBytes && `total size: ${import_utils.colors.cyan((0, import_pretty_bytes.default)(totalBytes))}`,
+      entry.bytes && `chunk size: ${import_utils.colors.cyan((0, import_pretty_bytes.default)(entry.bytes))}`,
+      entry.exports?.length && `exports: ${import_utils.colors.gray(entry.exports.join(", "))}`
+    ].filter(Boolean).join(", ") + ")";
+    if (entry.chunks?.length) {
+      line += "\n" + entry.chunks.map((p) => {
+        const chunk = ctx.buildEntries.find((e) => e.path === p) || {};
+        return import_utils.colors.gray(
+          "  \u2514\u2500 " + rPath(p) + import_utils.colors.bold(
+            chunk.bytes ? ` (${(0, import_pretty_bytes.default)(chunk?.bytes)})` : ""
+          )
+        );
+      }).join("\n");
+    }
+    if (entry.modules?.length) {
+      line += "\n" + entry.modules.filter((m) => m.id.includes("node_modules")).sort((a, b) => (b.bytes || 0) - (a.bytes || 0)).map((m) => {
+        return import_utils.colors.gray(
+          "  \u{1F4E6} " + rPath(m.id) + import_utils.colors.bold(m.bytes ? ` (${(0, import_pretty_bytes.default)(m.bytes)})` : "")
+        );
+      }).join("\n");
+    }
+    import_consola.consola.log(entry.chunk ? import_utils.colors.gray(line) : line);
+  }
+  console.log(
+    "\u03A3 Total dist size (byte size):",
+    import_utils.colors.cyan(
+      (0, import_pretty_bytes.default)(ctx.buildEntries.reduce((a, e) => a + (e.bytes || 0), 0))
+    )
+  );
+  validateDependencies(ctx);
+  validatePackage(pkg, rootDir, ctx);
+  await ctx.hooks.callHook("build:done", ctx);
+  import_consola.consola.log("");
+  if (ctx.warnings.size > 0) {
+    import_consola.consola.warn(
+      "Build is done with some warnings:\n\n" + [...ctx.warnings].map((msg) => "- " + msg).join("\n")
+    );
+    if (ctx.options.failOnWarn) {
+      import_consola.consola.error(
+        "Exiting with code (1). You can change this behavior by setting `failOnWarn: false` ."
+      );
+      process.exit(1);
+    }
+  }
+}
+__name(_build, "_build");
+
+// ../../node_modules/.pnpm/unbuild@3.3.1_sass@1.83.4_typescript@5.7.3/node_modules/unbuild/dist/index.mjs
+var import_node_module3 = require("module");
+var import_node_fs7 = require("fs");
+var import_pathe2 = require("pathe");
+var import_utils3 = require("consola/utils");
+var import_consola2 = require("consola");
+var import_defu4 = require("defu");
+var import_hookable2 = require("hookable");
+var import_pretty_bytes2 = require("pretty-bytes");
+var import_tinyglobby2 = require("tinyglobby");
+var import_promises5 = require("fs/promises");
+var import_jiti2 = require("jiti");
+var import_rollup2 = require("rollup");
+var import_rollup_plugin_dts2 = require("rollup-plugin-dts");
+var import_plugin_commonjs2 = require("@rollup/plugin-commonjs");
+var import_plugin_node_resolve2 = require("@rollup/plugin-node-resolve");
+var import_plugin_alias2 = require("@rollup/plugin-alias");
+var import_plugin_replace2 = require("@rollup/plugin-replace");
+var import_utils4 = require("pathe/utils");
+var import_mlly2 = require("mlly");
+var import_esbuild2 = require("esbuild");
+var import_pluginutils2 = require("@rollup/pluginutils");
+var import_plugin_json2 = require("@rollup/plugin-json");
+var import_magic_string2 = require("magic-string");
+var import_untyped2 = require("untyped");
+var import_babel_plugin2 = require("untyped/babel-plugin");
+var import_scule2 = require("scule");
+var import_mkdist2 = require("mkdist");
+
+// src/clean.ts
+var import_promises6 = require("fs/promises");
+async function clean(name = "Unbuild", directory, config) {
+  writeDebug(` \u{1F9F9}  Cleaning ${name} output path: ${directory}`, config);
+  const stopwatch = getStopwatch(`${name} output clean`);
+  await cleanDirectories(name, directory, config);
+  stopwatch();
+}
+__name(clean, "clean");
+async function cleanDirectories(name = "Unbuild", directory, config) {
+  await (0, import_promises6.rm)(directory, {
+    recursive: true,
+    force: true
+  });
+}
+__name(cleanDirectories, "cleanDirectories");
+
+// src/plugins/analyze.ts
+var formatBytes = /* @__PURE__ */ __name((bytes) => {
+  if (bytes === 0) return "0 Byte";
+  const k = 1e3;
+  const dm = 3;
+  const sizes = [
+    "Bytes",
+    "KB",
+    "MB",
+    "GB"
+  ];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
+}, "formatBytes");
+var analyzePlugin = /* @__PURE__ */ __name((options, resolvedOptions) => {
+  return {
+    name: "storm:analyzer",
+    renderChunk(source, chunk) {
+      const sourceBytes = formatBytes(source.length);
+      const fileName = chunk.fileName;
+      writeInfo(` - ${fileName} ${sourceBytes}`, resolvedOptions.config);
+    }
+  };
+}, "analyzePlugin");
+
+// src/plugins/on-error.ts
+var onErrorPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => ({
+  name: "storm:on-error",
+  buildEnd(error) {
+    if (error) {
+      writeError(`The following errors occurred during the build:
+${error ? error.message : "Unknown build error"}
+
+    `, resolvedOptions.config);
+      throw new Error("Storm unbuild process failed with errors.");
+    }
+  },
+  renderError(error) {
+    writeError(`The following errors occurred during the build:
+${error ? error.message : "Unknown build error"}
+
+  `, resolvedOptions.config);
+    throw new Error("Storm unbuild process failed with errors.");
+  }
+}), "onErrorPlugin");
+
+// src/plugins/tsc.ts
+var import_devkit5 = require("@nx/devkit");
+var import_buildable_libs_utils3 = require("@nx/js/src/utils/buildable-libs-utils");
+var import_compiler_helper_dependency = require("@nx/js/src/utils/compiler-helper-dependency");
+var import_rollup_plugin_typescript2 = __toESM(require("rollup-plugin-typescript2"), 1);
+
+// src/utilities/helpers.ts
+var import_devkit4 = require("@nx/devkit");
+var import_buildable_libs_utils2 = require("@nx/js/src/utils/buildable-libs-utils");
+var import_node_path4 = require("path");
+var import_node_url = require("url");
+var import_typescript = __toESM(require("typescript"), 1);
+async function loadConfig2(configPath) {
+  if (!/\.(js|mjs)$/.test((0, import_node_path4.extname)(configPath))) {
+    throw new Error("Unsupported config file format");
+  }
+  return import((0, import_node_url.pathToFileURL)(configPath).toString()).then((config) => config.default);
+}
+__name(loadConfig2, "loadConfig");
+async function createTsCompilerOptions(config, tsConfigPath, projectRoot, dependencies) {
+  const tsConfigFile = import_typescript.default.readConfigFile((0, import_devkit4.joinPathFragments)(config.workspaceRoot, projectRoot, tsConfigPath), import_typescript.default.sys.readFile);
+  const tsConfig = import_typescript.default.parseJsonConfigFileContent(tsConfigFile.config, import_typescript.default.sys, (0, import_node_path4.dirname)((0, import_devkit4.joinPathFragments)(config.workspaceRoot, projectRoot, tsConfigPath)));
+  const compilerOptions = {
+    rootDir: projectRoot,
+    declaration: true,
+    paths: (0, import_buildable_libs_utils2.computeCompilerOptionsPaths)(tsConfig, dependencies ?? [])
+  };
+  writeTrace(compilerOptions, config);
+  return compilerOptions;
+}
+__name(createTsCompilerOptions, "createTsCompilerOptions");
+
+// src/plugins/tsc.ts
+var tscPlugin = /* @__PURE__ */ __name(async (options, resolvedOptions) => {
+  const projectGraph = (0, import_devkit5.readCachedProjectGraph)();
+  const result = (0, import_buildable_libs_utils3.calculateProjectBuildableDependencies)(void 0, projectGraph, resolvedOptions.config.workspaceRoot, resolvedOptions.projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  let dependencies = result.dependencies;
+  const tsLibDependency = (0, import_compiler_helper_dependency.getHelperDependency)(import_compiler_helper_dependency.HelperDependency.tsc, resolvedOptions.tsconfig, dependencies, projectGraph, true);
+  if (tsLibDependency) {
+    dependencies = dependencies.filter((deps) => deps.name !== tsLibDependency.name);
+    dependencies.push(tsLibDependency);
+  }
+  return (0, import_rollup_plugin_typescript2.default)({
+    check: options.emitTypes !== false,
+    tsconfig: resolvedOptions.tsconfig,
+    tsconfigOverride: {
+      compilerOptions: await createTsCompilerOptions(resolvedOptions.config, resolvedOptions.tsconfig, resolvedOptions.projectRoot, dependencies)
+    }
+  });
+}, "tscPlugin");
+
+// src/plugins/type-definitions.ts
+var import_node_path5 = require("path");
+function typeDefinitions(projectRoot) {
+  return {
+    name: "storm:dts-bundle",
+    async generateBundle(_opts, bundle) {
+      for (const file of Object.values(bundle)) {
+        if (file.type === "asset" || !file.isEntry || file.facadeModuleId == null) {
+          continue;
+        }
+        const hasDefaultExport = file.exports.includes("default");
+        const entrySourceFileName = (0, import_node_path5.relative)(projectRoot, file.facadeModuleId);
+        const entrySourceDtsName = entrySourceFileName.replace(/\.[cm]?[jt]sx?$/, "");
+        const dtsFileName = file.fileName.replace(/\.[cm]?js$/, ".d.ts");
+        const relativeSourceDtsName = JSON.stringify("./" + entrySourceDtsName);
+        const dtsFileSource = hasDefaultExport ? `
+export * from ${relativeSourceDtsName};
+export { default } from ${relativeSourceDtsName};
+            ` : `export * from ${relativeSourceDtsName};
+`;
+        this.emitFile({
+          type: "asset",
+          fileName: dtsFileName,
+          source: dtsFileSource
+        });
+      }
+    }
+  };
+}
+__name(typeDefinitions, "typeDefinitions");
+
+// src/config.ts
+var getDefaultBuildPlugins = /* @__PURE__ */ __name(async (options, resolvedOptions) => Promise.all([
+  analyzePlugin(options, resolvedOptions),
+  typeDefinitions(resolvedOptions.projectRoot),
+  tscPlugin(options, resolvedOptions),
+  onErrorPlugin(options, resolvedOptions)
+].map((plugin) => Promise.resolve(plugin))), "getDefaultBuildPlugins");
+
+// src/build.ts
+async function resolveOptions(options, config) {
+  writeDebug("  \u2699\uFE0F   Resolving build options", config);
+  const stopwatch = getStopwatch("Build options resolution");
+  if (options.configPath) {
+    const configFile = await loadConfig2(options.configPath);
+    if (configFile) {
+      options = (0, import_defu5.default)(options, configFile);
+    }
+  }
+  const outputPath = options.outputPath || joinPaths("dist", options.projectRoot);
+  const projectGraph = (0, import_devkit6.readCachedProjectGraph)();
+  const projectJsonPath = joinPaths(config.workspaceRoot, options.projectRoot, "project.json");
+  if (!(0, import_node_fs8.existsSync)(projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const projectJsonContent = await (0, import_promises7.readFile)(projectJsonPath, "utf8");
+  const projectJson = JSON.parse(projectJsonContent);
+  const projectName = projectJson.name;
+  const packageJsonPath = joinPaths(config.workspaceRoot, options.projectRoot, "package.json");
+  if (!(0, import_node_fs8.existsSync)(packageJsonPath)) {
+    throw new Error("Cannot find package.json configuration");
+  }
+  const packageJsonContent = await (0, import_promises7.readFile)(packageJsonPath, "utf8");
+  const packageJson = JSON.parse(packageJsonContent);
+  let tsconfig = options.tsconfig;
+  if (!tsconfig) {
+    tsconfig = joinPaths(config.workspaceRoot, options.projectRoot, "tsconfig.json");
+  }
+  if (!(0, import_node_fs8.existsSync)(tsconfig)) {
+    throw new Error("Cannot find tsconfig.json configuration");
+  }
+  let sourceRoot = projectJson.sourceRoot;
+  if (!sourceRoot) {
+    sourceRoot = joinPaths(options.projectRoot, "src");
+  }
+  if (!(0, import_node_fs8.existsSync)(sourceRoot)) {
+    throw new Error("Cannot find sourceRoot directory");
+  }
+  const result = (0, import_buildable_libs_utils4.calculateProjectBuildableDependencies)(void 0, projectGraph, config.workspaceRoot, projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  let dependencies = result.dependencies;
+  const tsLibDependency = (0, import_js2.getHelperDependency)(import_js2.HelperDependency.tsc, tsconfig, dependencies, projectGraph, true);
+  if (tsLibDependency) {
+    dependencies = dependencies.filter((deps) => deps.name !== tsLibDependency.name);
+    dependencies.push(tsLibDependency);
+  }
+  const resolvedOptions = {
+    name: projectName,
+    config,
+    projectRoot: options.projectRoot,
+    sourceRoot,
+    projectName,
+    tsconfig,
+    clean: false,
+    entries: [
+      {
+        builder: "mkdist",
+        input: `.${sourceRoot.replace(options.projectRoot, "")}`,
+        outDir: joinPaths((0, import_node_path6.relative)(joinPaths(config.workspaceRoot, options.projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
+        declaration: options.emitTypes !== false,
+        format: "esm"
+      },
+      {
+        builder: "mkdist",
+        input: `.${sourceRoot.replace(options.projectRoot, "")}`,
+        outDir: joinPaths((0, import_node_path6.relative)(joinPaths(config.workspaceRoot, options.projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
+        declaration: options.emitTypes !== false,
+        format: "cjs",
+        ext: "cjs"
+      }
+    ],
+    declaration: options.emitTypes !== false ? "compatible" : false,
+    failOnWarn: false,
+    sourcemap: options.sourcemap ?? !!options.debug,
+    outDir: outputPath,
+    parallel: true,
+    stub: false,
+    stubOptions: {
+      jiti: {}
+    },
+    externals: options.external ?? [],
+    dependencies: [],
+    peerDependencies: [],
+    devDependencies: [],
+    hooks: {},
+    alias: {},
+    replace: {},
+    rollup: {
+      replace: {},
+      alias: {},
+      json: {},
+      commonjs: {
+        sourceMap: options.sourcemap ?? true
+      },
+      emitCJS: true,
+      cjsBridge: true,
+      dts: {
+        respectExternal: true,
+        tsconfig
+      },
+      output: {
+        banner: options.banner || `
+//      \u26A1 Built by Storm Software
+  `,
+        footer: options.footer
+      },
+      resolve: {
+        preferBuiltins: true,
+        extensions: [
+          ".cjs",
+          ".mjs",
+          ".js",
+          ".jsx",
+          ".ts",
+          ".tsx",
+          ".json"
+        ]
+      },
+      esbuild: {
+        minify: options.minify !== false,
+        splitting: options.splitting !== false,
+        treeShaking: options.treeShaking !== false,
+        color: true,
+        logLevel: config.logLevel === LogLevelLabel.FATAL ? LogLevelLabel.ERROR : isVerbose() ? "verbose" : config.logLevel
+      }
+    }
+  };
+  dependencies = dependencies.filter((dep) => dep.node.type === "npm" || dep.node.type === "lib" || dep.node.type === "app");
+  if (dependencies.length > 0) {
+    resolvedOptions.dependencies = dependencies.map((dep) => dep.name);
+  }
+  if (packageJson.devDependencies) {
+    resolvedOptions.devDependencies = Object.keys(packageJson.devDependencies);
+  }
+  if (packageJson.peerDependencies) {
+    resolvedOptions.peerDependencies = Object.keys(packageJson.peerDependencies);
+  }
+  if (options.rollup) {
+    let rollup2 = {};
+    if (typeof options.rollup === "string") {
+      const rollupFile = await loadConfig2(options.rollup);
+      if (rollupFile) {
+        rollup2 = rollupFile;
+      }
+    } else {
+      rollup2 = options.rollup;
+    }
+    resolvedOptions.rollup = (0, import_defu5.default)(resolvedOptions.rollup ?? {}, rollup2);
+  }
+  resolvedOptions.hooks = {
+    "rollup:options": /* @__PURE__ */ __name(async (ctx, opts) => {
+      opts.plugins = options.plugins ?? await getDefaultBuildPlugins(options, resolvedOptions);
+    }, "rollup:options")
+  };
+  stopwatch();
+  return resolvedOptions;
+}
+__name(resolveOptions, "resolveOptions");
+async function generatePackageJson(options) {
+  if (options.generatePackageJson !== false && (0, import_node_fs8.existsSync)(joinPaths(options.projectRoot, "package.json"))) {
+    writeDebug("  \u270D\uFE0F   Writing package.json file", options.config);
+    const stopwatch = getStopwatch("Write package.json file");
+    const packageJsonPath = joinPaths(options.projectRoot, "project.json");
+    if (!(0, import_node_fs8.existsSync)(packageJsonPath)) {
+      throw new Error("Cannot find package.json configuration");
+    }
+    let packageJsonContent = await (0, import_promises7.readFile)(joinPaths(options.config.workspaceRoot, options.projectRoot, "package.json"), "utf8");
+    if (!packageJsonContent) {
+      throw new Error("Cannot find package.json configuration file");
+    }
+    let packageJson = JSON.parse(packageJsonContent);
+    packageJson = await addPackageDependencies(options.config.workspaceRoot, options.projectRoot, options.projectName, packageJson);
+    packageJson = await addWorkspacePackageJsonFields(options.config, options.projectRoot, options.sourceRoot, options.projectName, false, packageJson);
+    await (0, import_devkit6.writeJsonFile)(joinPaths(options.outDir, "package.json"), await addPackageJsonExports(options.sourceRoot, packageJson));
+    stopwatch();
+  }
+  return options;
+}
+__name(generatePackageJson, "generatePackageJson");
+async function executeUnbuild(options) {
+  writeDebug(`  \u{1F680}  Running ${options.name} (${options.projectRoot}) build`, options.config);
+  const stopwatch = getStopwatch(`${options.name} (${options.projectRoot}) build`);
+  try {
+    await build(options.projectRoot, false, {
+      ...options,
+      rootDir: options.projectRoot
+    });
+  } finally {
+    stopwatch();
+  }
+  return options;
+}
+__name(executeUnbuild, "executeUnbuild");
+async function copyBuildAssets(options) {
+  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.projectName, options.sourceRoot, options.generatePackageJson, options.includeSrc);
+  stopwatch();
+  return options;
+}
+__name(copyBuildAssets, "copyBuildAssets");
+async function cleanOutputPath(options) {
+  if (options.clean !== false && options.outDir) {
+    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 build2(options) {
+  const projectRoot = options.projectRoot;
+  if (!projectRoot) {
+    throw new Error("Cannot find project root");
+  }
+  const workspaceRoot = (0, import_find_workspace_root5.findWorkspaceRoot)(projectRoot);
+  if (!workspaceRoot) {
+    throw new Error("Cannot find workspace root");
+  }
+  const config = await loadStormConfig(workspaceRoot.dir);
+  writeDebug(` \u26A1  Executing Storm Unbuild pipeline`, config);
+  const stopwatch = getStopwatch("Unbuild pipeline");
+  try {
+    options.projectRoot = projectRoot;
+    const resolvedOptions = await resolveOptions(options, config);
+    await cleanOutputPath(resolvedOptions);
+    await generatePackageJson(resolvedOptions);
+    await executeUnbuild(resolvedOptions);
+    await copyBuildAssets(resolvedOptions);
+    writeSuccess(`  \u{1F3C1}  The ${resolvedOptions.name} build completed successfully`, config);
+  } catch (error) {
+    writeFatal("  \u274C  Fatal errors occurred during the build that could not be recovered from. The build process has been terminated.", config);
+    throw error;
+  } finally {
+    stopwatch();
+  }
+}
+__name(build2, "build");
+
+// bin/unbuild.ts
+async function createProgram(config) {
+  try {
+    writeInfo("\u26A1 Running Storm Unbuild pipeline", config);
+    const root = 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-unbuild");
+    program.version("1.0.0", "-v --version", "display CLI version");
+    program.description("\u26A1 Run the Storm Unbuild 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 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 Unbuild.").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(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) {
+    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 build2({
+      ...options,
+      sourcemap: !!options.debug,
+      replace: {},
+      alias: {},
+      stub: false,
+      watchOptions: {
+        buildDelay: 5e3,
+        chokidar: {},
+        clearScreen: true,
+        skipWrite: true
+      },
+      stubOptions: {
+        jiti: {}
+      },
+      dependencies: [],
+      peerDependencies: [],
+      devDependencies: [],
+      rollup: {
+        emitCJS: false,
+        watch: false,
+        cjsBridge: false,
+        dts: {
+          respectExternal: true
+        },
+        replace: {},
+        alias: {},
+        resolve: {},
+        json: {},
+        commonjs: {},
+        esbuild: {
+          target: options.target,
+          format: "esm",
+          platform: options.platform,
+          minify: options.minify,
+          treeShaking: options.treeShaking
+        }
+      }
+    });
+  } catch (e) {
+    writeFatal(`A fatal error occurred while cleaning the Unbuild output directory: ${e.message}`, config);
+    exitWithError(config);
+    process.exit(1);
+  }
+}, "buildAction");
+var cleanAction = /* @__PURE__ */ __name((config) => async (options) => {
+  try {
+    await clean(options.name, options.output, config);
+  } catch (e) {
+    writeFatal(`A fatal error occurred while cleaning the ESBuild output directory: ${e.message}`, config);
+    exitWithError(config);
+    process.exit(1);
+  }
+}, "cleanAction");
+void (async () => {
+  const config = await loadStormConfig();
+  const stopwatch = getStopwatch("Storm ESBuild executable");
+  try {
+    handleProcess(config);
+    const program = await createProgram(config);
+    await program.parseAsync(process.argv);
+    writeSuccess(`\u{1F389}  Storm ESBuild executable has completed successfully!`, config);
+    exitWithSuccess(config);
+  } catch (error) {
+    writeFatal(`A fatal error occurred while running Storm ESBuild executable: 
+
+${error.message}`, config);
+    exitWithError(config);
+    process.exit(1);
+  } finally {
+    stopwatch();
+  }
+})();