@storm-software/unbuild 0.21.0 → 0.22.0

package/bin/unbuild.js

@@ -23,6 +23,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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"));
 
@@ -510,7 +514,7 @@ var isVerbose = /* @__PURE__ */ __name((label = LogLevelLabel.SILENT) => {
 // ../config-tools/src/logger/console.ts
 var getLogFn = /* @__PURE__ */ __name((logLevel = LogLevel.INFO, config = {}) => {
   const _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 colors3 = !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 (_2) => {
@@ -519,48 +523,48 @@ var getLogFn = /* @__PURE__ */ __name((logLevel = LogLevel.INFO, config = {}) =>
   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))}
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors3.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))}
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors3.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))}
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors3.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))}
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors3.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))}
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors3.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))}
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors3.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))}
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors3.brand ?? "#1fb2a6")(`[${CONSOLE_ICONS[LogLevelLabel.ALL]}  System]`)} ${_chalk.bold.whiteBright(formatLogMessage(message))}
 `);
   };
 }, "getLogFn");
@@ -1382,19 +1386,1449 @@ var import_glob3 = require("glob");
 var import_create_task_graph = require("nx/src/tasks-runner/create-task-graph");
 
 // src/build.ts
-var import_defu3 = __toESM(require("defu"));
-var import_node_fs6 = require("fs");
-var import_promises5 = require("fs/promises");
+var import_defu5 = __toESM(require("defu"));
+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");
-var import_unbuild = require("unbuild");
+
+// ../../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((path3) => {
+  const segments = (0, import_pathe.normalize)(path3).split("/");
+  return segments.map((_2, index) => segments.slice(index).join("/")).filter(Boolean);
+}, "getEntrypointPaths");
+async function ensuredir(path3) {
+  await import_promises4.default.mkdir((0, import_pathe.dirname)(path3), { 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(path3) {
+  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(path3);
+  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(path3) {
+  return path3.includes("*") ? new RegExp(
+    `^${path3.replace(/\./g, String.raw`\.`).replace(/\*/g, ".*")}$`
+  ) : path3;
+}
+__name(pathToRegex, "pathToRegex");
+function withTrailingSlash(path3) {
+  return path3.endsWith("/") ? path3 : `${path3}/`;
+}
+__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 (path3) => {
+          const src = (0, import_pathe.resolve)(ctx.options.rootDir, entry.input, path3);
+          const dist = (0, import_pathe.resolve)(ctx.options.rootDir, distDir, path3);
+          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_promises4 = require("fs/promises");
+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 (0, import_promises4.rm)(directory, {
+  await (0, import_promises6.rm)(directory, {
     recursive: true,
     force: true
   });
@@ -1456,7 +2890,7 @@ var import_compiler_helper_dependency = require("@nx/js/src/utils/compiler-helpe
 // ../../node_modules/.pnpm/rollup-plugin-typescript2@0.36.0_rollup@4.29.1_typescript@5.7.3/node_modules/rollup-plugin-typescript2/dist/rollup-plugin-typescript2.es.js
 var require$$0 = __toESM(require("path"));
 var import_path2 = __toESM(require("path"));
-var import_pluginutils = require("@rollup/pluginutils");
+var import_pluginutils3 = require("@rollup/pluginutils");
 var import_util = __toESM(require("util"));
 var import_os = __toESM(require("os"));
 var import_semver = __toESM(require("semver"));
@@ -1466,12 +2900,12 @@ var import_fs_extra = require("fs-extra");
 var import_crypto = __toESM(require("crypto"));
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve2) {
-      resolve2(value);
+    return value instanceof P ? value : new P(function(resolve3) {
+      resolve3(value);
     });
   }
   __name(adopt, "adopt");
-  return new (P || (P = Promise))(function(resolve2, reject) {
+  return new (P || (P = Promise))(function(resolve3, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -1489,7 +2923,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
     }
     __name(rejected, "rejected");
     function step(result) {
-      result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve3(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     __name(step, "step");
     step((generator = generator.apply(thisArg, _arguments || [])).next());
@@ -1500,7 +2934,7 @@ var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof win
 var safe = {
   exports: {}
 };
-var colors = {
+var colors2 = {
   exports: {}
 };
 var styles = {
@@ -2217,16 +3651,16 @@ function requireAmerica() {
   if (hasRequiredAmerica) return america.exports;
   hasRequiredAmerica = 1;
   (function(module2) {
-    module2["exports"] = function(colors2) {
+    module2["exports"] = function(colors3) {
       return function(letter, i, exploded) {
         if (letter === " ") return letter;
         switch (i % 3) {
           case 0:
-            return colors2.red(letter);
+            return colors3.red(letter);
           case 1:
-            return colors2.white(letter);
+            return colors3.white(letter);
           case 2:
-            return colors2.blue(letter);
+            return colors3.blue(letter);
         }
       };
     };
@@ -2242,9 +3676,9 @@ function requireZebra() {
   if (hasRequiredZebra) return zebra.exports;
   hasRequiredZebra = 1;
   (function(module2) {
-    module2["exports"] = function(colors2) {
+    module2["exports"] = function(colors3) {
       return function(letter, i, exploded) {
-        return i % 2 === 0 ? letter : colors2.inverse(letter);
+        return i % 2 === 0 ? letter : colors3.inverse(letter);
       };
     };
   })(zebra);
@@ -2259,7 +3693,7 @@ function requireRainbow() {
   if (hasRequiredRainbow) return rainbow.exports;
   hasRequiredRainbow = 1;
   (function(module2) {
-    module2["exports"] = function(colors2) {
+    module2["exports"] = function(colors3) {
       var rainbowColors = [
         "red",
         "yellow",
@@ -2271,7 +3705,7 @@ function requireRainbow() {
         if (letter === " ") {
           return letter;
         } else {
-          return colors2[rainbowColors[i++ % rainbowColors.length]](letter);
+          return colors3[rainbowColors[i++ % rainbowColors.length]](letter);
         }
       };
     };
@@ -2287,7 +3721,7 @@ function requireRandom() {
   if (hasRequiredRandom) return random.exports;
   hasRequiredRandom = 1;
   (function(module2) {
-    module2["exports"] = function(colors2) {
+    module2["exports"] = function(colors3) {
       var available = [
         "underline",
         "inverse",
@@ -2308,7 +3742,7 @@ function requireRandom() {
         "brightMagenta"
       ];
       return function(letter, i, exploded) {
-        return letter === " " ? letter : colors2[available[Math.round(Math.random() * (available.length - 2))]](letter);
+        return letter === " " ? letter : colors3[available[Math.round(Math.random() * (available.length - 2))]](letter);
       };
     };
   })(random);
@@ -2316,33 +3750,33 @@ function requireRandom() {
 }
 __name(requireRandom, "requireRandom");
 (function(module2) {
-  var colors2 = {};
-  module2["exports"] = colors2;
-  colors2.themes = {};
+  var colors3 = {};
+  module2["exports"] = colors3;
+  colors3.themes = {};
   var util = import_util.default;
-  var ansiStyles = colors2.styles = styles.exports;
+  var ansiStyles = colors3.styles = styles.exports;
   var defineProps = Object.defineProperties;
   var newLineRegex = new RegExp(/[\r\n]+/g);
-  colors2.supportsColor = supportsColors.supportsColor;
-  if (typeof colors2.enabled === "undefined") {
-    colors2.enabled = colors2.supportsColor() !== false;
+  colors3.supportsColor = supportsColors.supportsColor;
+  if (typeof colors3.enabled === "undefined") {
+    colors3.enabled = colors3.supportsColor() !== false;
   }
-  colors2.enable = function() {
-    colors2.enabled = true;
+  colors3.enable = function() {
+    colors3.enabled = true;
   };
-  colors2.disable = function() {
-    colors2.enabled = false;
+  colors3.disable = function() {
+    colors3.enabled = false;
   };
-  colors2.stripColors = colors2.strip = function(str) {
+  colors3.stripColors = colors3.strip = function(str) {
     return ("" + str).replace(/\x1B\[\d+m/g, "");
   };
-  colors2.stylize = /* @__PURE__ */ __name(function stylize(str, style) {
-    if (!colors2.enabled) {
+  colors3.stylize = /* @__PURE__ */ __name(function stylize(str, style) {
+    if (!colors3.enabled) {
       return str + "";
     }
     var styleMap = ansiStyles[style];
-    if (!styleMap && style in colors2) {
-      return colors2[style](str);
+    if (!styleMap && style in colors3) {
+      return colors3[style](str);
     }
     return styleMap.open + str + styleMap.close;
   }, "stylize");
@@ -2353,7 +3787,7 @@ __name(requireRandom, "requireRandom");
     }
     return str.replace(matchOperatorsRe, "\\$&");
   }, "escapeStringRegexp");
-  function build2(_styles) {
+  function build3(_styles) {
     var builder = /* @__PURE__ */ __name(function builder2() {
       return applyStyle.apply(builder2, arguments);
     }, "builder");
@@ -2361,7 +3795,7 @@ __name(requireRandom, "requireRandom");
     builder.__proto__ = proto;
     return builder;
   }
-  __name(build2, "build");
+  __name(build3, "build");
   var styles$1 = function() {
     var ret = {};
     ansiStyles.grey = ansiStyles.gray;
@@ -2369,13 +3803,13 @@ __name(requireRandom, "requireRandom");
       ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), "g");
       ret[key] = {
         get: /* @__PURE__ */ __name(function() {
-          return build2(this._styles.concat(key));
+          return build3(this._styles.concat(key));
         }, "get")
       };
     });
     return ret;
   }();
-  var proto = defineProps(/* @__PURE__ */ __name(function colors3() {
+  var proto = defineProps(/* @__PURE__ */ __name(function colors4() {
   }, "colors"), styles$1);
   function applyStyle() {
     var args = Array.prototype.slice.call(arguments);
@@ -2386,7 +3820,7 @@ __name(requireRandom, "requireRandom");
         return util.inspect(arg);
       }
     }).join(" ");
-    if (!colors2.enabled || !str) {
+    if (!colors3.enabled || !str) {
       return str;
     }
     var newLinesPresent = str.indexOf("\n") != -1;
@@ -2404,22 +3838,22 @@ __name(requireRandom, "requireRandom");
     return str;
   }
   __name(applyStyle, "applyStyle");
-  colors2.setTheme = function(theme) {
+  colors3.setTheme = function(theme) {
     if (typeof theme === "string") {
       console.log("colors.setTheme now only accepts an object, not a string.  If you are trying to set a theme from a file, it is now your (the caller's) responsibility to require the file.  The old syntax looked like colors.setTheme(__dirname + '/../themes/generic-logging.js'); The new syntax looks like colors.setTheme(require(__dirname + '/../themes/generic-logging.js'));");
       return;
     }
     for (var style in theme) {
       (function(style2) {
-        colors2[style2] = function(str) {
+        colors3[style2] = function(str) {
           if (typeof theme[style2] === "object") {
             var out = str;
             for (var i in theme[style2]) {
-              out = colors2[theme[style2][i]](out);
+              out = colors3[theme[style2][i]](out);
             }
             return out;
           }
-          return colors2[theme[style2]](str);
+          return colors3[theme[style2]](str);
         };
       })(style);
     }
@@ -2429,7 +3863,7 @@ __name(requireRandom, "requireRandom");
     Object.keys(styles$1).forEach(function(name) {
       ret[name] = {
         get: /* @__PURE__ */ __name(function() {
-          return build2([
+          return build3([
             name
           ]);
         }, "get")
@@ -2443,24 +3877,24 @@ __name(requireRandom, "requireRandom");
     exploded = exploded.map(map2);
     return exploded.join("");
   }, "sequencer");
-  colors2.trap = requireTrap();
-  colors2.zalgo = requireZalgo();
-  colors2.maps = {};
-  colors2.maps.america = requireAmerica()(colors2);
-  colors2.maps.zebra = requireZebra()(colors2);
-  colors2.maps.rainbow = requireRainbow()(colors2);
-  colors2.maps.random = requireRandom()(colors2);
-  for (var map in colors2.maps) {
+  colors3.trap = requireTrap();
+  colors3.zalgo = requireZalgo();
+  colors3.maps = {};
+  colors3.maps.america = requireAmerica()(colors3);
+  colors3.maps.zebra = requireZebra()(colors3);
+  colors3.maps.rainbow = requireRainbow()(colors3);
+  colors3.maps.random = requireRandom()(colors3);
+  for (var map in colors3.maps) {
     (function(map2) {
-      colors2[map2] = function(str) {
-        return sequencer(colors2.maps[map2], str);
+      colors3[map2] = function(str) {
+        return sequencer(colors3.maps[map2], str);
       };
     })(map);
   }
-  defineProps(colors2, init());
-})(colors);
+  defineProps(colors3, init());
+})(colors2);
 (function(module2) {
-  var colors$1 = colors.exports;
+  var colors$1 = colors2.exports;
   module2["exports"] = colors$1;
 })(safe);
 var path$4 = import_path2.default;
@@ -2500,8 +3934,8 @@ var pLimit$2 = {
 var pTry$2 = {
   exports: {}
 };
-var pTry$1 = /* @__PURE__ */ __name((fn, ...arguments_) => new Promise((resolve2) => {
-  resolve2(fn(...arguments_));
+var pTry$1 = /* @__PURE__ */ __name((fn, ...arguments_) => new Promise((resolve3) => {
+  resolve3(fn(...arguments_));
 }), "pTry$1");
 pTry$2.exports = pTry$1;
 pTry$2.exports.default = pTry$1;
@@ -2518,20 +3952,20 @@ var pLimit$1 = /* @__PURE__ */ __name((concurrency) => {
       queue.shift()();
     }
   }, "next");
-  const run = /* @__PURE__ */ __name((fn, resolve2, ...args) => {
+  const run = /* @__PURE__ */ __name((fn, resolve3, ...args) => {
     activeCount++;
     const result = pTry(fn, ...args);
-    resolve2(result);
+    resolve3(result);
     result.then(next, next);
   }, "run");
-  const enqueue = /* @__PURE__ */ __name((fn, resolve2, ...args) => {
+  const enqueue = /* @__PURE__ */ __name((fn, resolve3, ...args) => {
     if (activeCount < concurrency) {
-      run(fn, resolve2, ...args);
+      run(fn, resolve3, ...args);
     } else {
-      queue.push(run.bind(null, fn, resolve2, ...args));
+      queue.push(run.bind(null, fn, resolve3, ...args));
     }
   }, "enqueue");
-  const generator = /* @__PURE__ */ __name((fn, ...args) => new Promise((resolve2) => enqueue(fn, resolve2, ...args)), "generator");
+  const generator = /* @__PURE__ */ __name((fn, ...args) => new Promise((resolve3) => enqueue(fn, resolve3, ...args)), "generator");
   Object.defineProperties(generator, {
     activeCount: {
       get: /* @__PURE__ */ __name(() => activeCount, "get")
@@ -2774,12 +4208,12 @@ var checkPath = /* @__PURE__ */ __name((pth) => {
   }
 }, "checkPath");
 var processOptions = /* @__PURE__ */ __name((options) => {
-  const defaults = {
+  const defaults2 = {
     mode: 511 & ~process.umask(),
     fs: fs$1
   };
   return {
-    ...defaults,
+    ...defaults2,
     ...options
   };
 }, "processOptions");
@@ -2794,11 +4228,11 @@ var permissionError = /* @__PURE__ */ __name((pth) => {
 var makeDir$1 = /* @__PURE__ */ __name(async (input, options) => {
   checkPath(input);
   options = processOptions(options);
-  const mkdir = promisify(options.fs.mkdir);
+  const mkdir2 = promisify(options.fs.mkdir);
   const stat = promisify(options.fs.stat);
   if (useNativeRecursiveOption && options.fs.mkdir === fs$1.mkdir) {
     const pth = path$1.resolve(input);
-    await mkdir(pth, {
+    await mkdir2(pth, {
       mode: options.mode,
       recursive: true
     });
@@ -2806,7 +4240,7 @@ var makeDir$1 = /* @__PURE__ */ __name(async (input, options) => {
   }
   const make = /* @__PURE__ */ __name(async (pth) => {
     try {
-      await mkdir(pth, options.mode);
+      await mkdir2(pth, options.mode);
       return pth;
     } catch (error) {
       if (error.code === "EPERM") {
@@ -3008,7 +4442,7 @@ var LanguageServiceHost = class LanguageServiceHost2 {
     this.service = service;
   }
   setSnapshot(fileName, source) {
-    fileName = (0, import_pluginutils.normalizePath)(fileName);
+    fileName = (0, import_pluginutils3.normalizePath)(fileName);
     const snapshot = tsModule.ScriptSnapshot.fromString(source);
     this.snapshots[fileName] = snapshot;
     this.versions[fileName] = (this.versions[fileName] || 0) + 1;
@@ -3016,14 +4450,14 @@ var LanguageServiceHost = class LanguageServiceHost2 {
     return snapshot;
   }
   getScriptSnapshot(fileName) {
-    fileName = (0, import_pluginutils.normalizePath)(fileName);
+    fileName = (0, import_pluginutils3.normalizePath)(fileName);
     if (fileName in this.snapshots) return this.snapshots[fileName];
     const source = tsModule.sys.readFile(fileName);
     if (source) return this.setSnapshot(fileName, source);
     return void 0;
   }
   getScriptVersion(fileName) {
-    fileName = (0, import_pluginutils.normalizePath)(fileName);
+    fileName = (0, import_pluginutils3.normalizePath)(fileName);
     return (this.versions[fileName] || 0).toString();
   }
   getCustomTransformers() {
@@ -3501,11 +4935,11 @@ var lodash$1 = {
       return result;
     }
     __name(arrayFilter, "arrayFilter");
-    function arrayIncludes(array, value) {
+    function arrayIncludes2(array, value) {
       var length = array == null ? 0 : array.length;
       return !!length && baseIndexOf(array, value, 0) > -1;
     }
-    __name(arrayIncludes, "arrayIncludes");
+    __name(arrayIncludes2, "arrayIncludes");
     function arrayIncludesWith(array, value, comparator) {
       var index = -1, length = array == null ? 0 : array.length;
       while (++index < length) {
@@ -3754,9 +5188,9 @@ var lodash$1 = {
       return result;
     }
     __name(mapToArray, "mapToArray");
-    function overArg(func, transform2) {
+    function overArg(func, transform3) {
       return function(arg) {
-        return func(transform2(arg));
+        return func(transform3(arg));
       };
     }
     __name(overArg, "overArg");
@@ -4430,7 +5864,7 @@ var lodash$1 = {
       }
       __name(baseDelay, "baseDelay");
       function baseDifference(array, values2, iteratee2, comparator) {
-        var index = -1, includes2 = arrayIncludes, isCommon = true, length = array.length, result2 = [], valuesLength = values2.length;
+        var index = -1, includes2 = arrayIncludes2, isCommon = true, length = array.length, result2 = [], valuesLength = values2.length;
         if (!length) {
           return result2;
         }
@@ -4585,7 +6019,7 @@ var lodash$1 = {
       }
       __name(baseInRange, "baseInRange");
       function baseIntersection(arrays, iteratee2, comparator) {
-        var includes2 = comparator ? arrayIncludesWith : arrayIncludes, length = arrays[0].length, othLength = arrays.length, othIndex = othLength, caches = Array1(othLength), maxLength = Infinity, result2 = [];
+        var includes2 = comparator ? arrayIncludesWith : arrayIncludes2, length = arrays[0].length, othLength = arrays.length, othIndex = othLength, caches = Array1(othLength), maxLength = Infinity, result2 = [];
         while (othIndex--) {
           var array = arrays[othIndex];
           if (othIndex && iteratee2) {
@@ -5166,7 +6600,7 @@ var lodash$1 = {
       }
       __name(baseToString, "baseToString");
       function baseUniq(array, iteratee2, comparator) {
-        var index = -1, includes2 = arrayIncludes, length = array.length, isCommon = true, result2 = [], seen = result2;
+        var index = -1, includes2 = arrayIncludes2, length = array.length, isCommon = true, result2 = [], seen = result2;
         if (comparator) {
           isCommon = false;
           includes2 = arrayIncludesWith;
@@ -6364,7 +7798,7 @@ var lodash$1 = {
         return nativeObjectToString.call(value);
       }
       __name(objectToString, "objectToString");
-      function overRest(func, start, transform3) {
+      function overRest(func, start, transform4) {
         start = nativeMax(start === undefined$1 ? func.length - 1 : start, 0);
         return function() {
           var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array1(length);
@@ -6376,7 +7810,7 @@ var lodash$1 = {
           while (++index < start) {
             otherArgs[index] = args[index];
           }
-          otherArgs[start] = transform3(array);
+          otherArgs[start] = transform4(array);
           return apply(func, this, otherArgs);
         };
       }
@@ -6477,7 +7911,7 @@ var lodash$1 = {
       function updateWrapDetails(details, bitmask) {
         arrayEach(wrapFlags, function(pair) {
           var value = "_." + pair[0];
-          if (bitmask & pair[1] && !arrayIncludes(details, value)) {
+          if (bitmask & pair[1] && !arrayIncludes2(details, value)) {
             details.push(value);
           }
         });
@@ -6688,10 +8122,10 @@ var lodash$1 = {
         }
         return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, undefined$1, comparator) : [];
       });
-      function join4(array, separator) {
+      function join5(array, separator) {
         return array == null ? "" : nativeJoin.call(array, separator);
       }
-      __name(join4, "join");
+      __name(join5, "join");
       function last(array) {
         var length = array == null ? 0 : array.length;
         return length ? array[length - 1] : undefined$1;
@@ -7796,7 +9230,7 @@ var lodash$1 = {
         return properties == null ? result2 : baseAssign(result2, properties);
       }
       __name(create, "create");
-      var defaults = baseRest(function(object, sources) {
+      var defaults2 = baseRest(function(object, sources) {
         object = Object1(object);
         var index = -1;
         var length = sources.length;
@@ -7991,7 +9425,7 @@ var lodash$1 = {
       __name(setWith, "setWith");
       var toPairs = createToPairs(keys);
       var toPairsIn = createToPairs(keysIn);
-      function transform2(object, iteratee2, accumulator) {
+      function transform3(object, iteratee2, accumulator) {
         var isArr = isArray(object), isArrLike = isArr || isBuffer2(object) || isTypedArray(object);
         iteratee2 = getIteratee(iteratee2, 4);
         if (accumulator == null) {
@@ -8009,7 +9443,7 @@ var lodash$1 = {
         });
         return accumulator;
       }
-      __name(transform2, "transform");
+      __name(transform3, "transform");
       function unset(object, path3) {
         return object == null ? true : baseUnset(object, path3);
       }
@@ -8179,11 +9613,11 @@ var lodash$1 = {
         return baseRepeat(toString(string), n);
       }
       __name(repeat, "repeat");
-      function replace() {
+      function replace2() {
         var args = arguments, string = toString(args[0]);
         return args.length < 3 ? string : string.replace(args[1], args[2]);
       }
-      __name(replace, "replace");
+      __name(replace2, "replace");
       var snakeCase = createCompounder(function(result2, word, index) {
         return result2 + (index ? "_" : "") + word.toLowerCase();
       });
@@ -8636,7 +10070,7 @@ var lodash$1 = {
       lodash2.curry = curry;
       lodash2.curryRight = curryRight;
       lodash2.debounce = debounce;
-      lodash2.defaults = defaults;
+      lodash2.defaults = defaults2;
       lodash2.defaultsDeep = defaultsDeep;
       lodash2.defer = defer;
       lodash2.delay = delay;
@@ -8736,7 +10170,7 @@ var lodash$1 = {
       lodash2.toPairsIn = toPairsIn;
       lodash2.toPath = toPath;
       lodash2.toPlainObject = toPlainObject;
-      lodash2.transform = transform2;
+      lodash2.transform = transform3;
       lodash2.unary = unary;
       lodash2.union = union;
       lodash2.unionBy = unionBy;
@@ -8846,7 +10280,7 @@ var lodash$1 = {
       lodash2.isUndefined = isUndefined;
       lodash2.isWeakMap = isWeakMap;
       lodash2.isWeakSet = isWeakSet;
-      lodash2.join = join4;
+      lodash2.join = join5;
       lodash2.kebabCase = kebabCase;
       lodash2.last = last;
       lodash2.lastIndexOf = lastIndexOf;
@@ -8878,7 +10312,7 @@ var lodash$1 = {
       lodash2.reduce = reduce;
       lodash2.reduceRight = reduceRight;
       lodash2.repeat = repeat;
-      lodash2.replace = replace;
+      lodash2.replace = replace2;
       lodash2.result = result;
       lodash2.round = round;
       lodash2.runInContext = runInContext2;
@@ -10270,9 +11704,9 @@ var hasRequired_overArg;
 function require_overArg() {
   if (hasRequired_overArg) return _overArg;
   hasRequired_overArg = 1;
-  function overArg(func, transform2) {
+  function overArg(func, transform3) {
     return function(arg) {
-      return func(transform2(arg));
+      return func(transform3(arg));
     };
   }
   __name(overArg, "overArg");
@@ -12393,7 +13827,7 @@ function requireTransform() {
   if (hasRequiredTransform) return transform_1;
   hasRequiredTransform = 1;
   var arrayEach = require_arrayEach(), baseCreate = require_baseCreate(), baseForOwn = require_baseForOwn(), baseIteratee = require_baseIteratee(), getPrototype = require_getPrototype(), isArray = requireIsArray(), isBuffer2 = requireIsBuffer(), isFunction = requireIsFunction(), isObject = requireIsObject(), isTypedArray = requireIsTypedArray();
-  function transform2(object, iteratee, accumulator) {
+  function transform3(object, iteratee, accumulator) {
     var isArr = isArray(object), isArrLike = isArr || isBuffer2(object) || isTypedArray(object);
     iteratee = baseIteratee(iteratee, 4);
     if (accumulator == null) {
@@ -12411,8 +13845,8 @@ function requireTransform() {
     });
     return accumulator;
   }
-  __name(transform2, "transform");
-  transform_1 = transform2;
+  __name(transform3, "transform");
+  transform_1 = transform3;
   return transform_1;
 }
 __name(requireTransform, "requireTransform");
@@ -12490,7 +13924,7 @@ function require_overRest() {
   hasRequired_overRest = 1;
   var apply = require_apply();
   var nativeMax = Math.max;
-  function overRest(func, start, transform2) {
+  function overRest(func, start, transform3) {
     start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
     return function() {
       var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length);
@@ -12502,7 +13936,7 @@ function require_overRest() {
       while (++index < start) {
         otherArgs[index] = args[index];
       }
-      otherArgs[start] = transform2(array);
+      otherArgs[start] = transform3(array);
       return apply(func, this, otherArgs);
     };
   }
@@ -12652,12 +14086,12 @@ function require_arrayIncludes() {
   if (hasRequired_arrayIncludes) return _arrayIncludes;
   hasRequired_arrayIncludes = 1;
   var baseIndexOf = require_baseIndexOf();
-  function arrayIncludes(array, value) {
+  function arrayIncludes2(array, value) {
     var length = array == null ? 0 : array.length;
     return !!length && baseIndexOf(array, value, 0) > -1;
   }
-  __name(arrayIncludes, "arrayIncludes");
-  _arrayIncludes = arrayIncludes;
+  __name(arrayIncludes2, "arrayIncludes");
+  _arrayIncludes = arrayIncludes2;
   return _arrayIncludes;
 }
 __name(require_arrayIncludes, "require_arrayIncludes");
@@ -12714,10 +14148,10 @@ var hasRequired_baseUniq;
 function require_baseUniq() {
   if (hasRequired_baseUniq) return _baseUniq;
   hasRequired_baseUniq = 1;
-  var SetCache = require_SetCache(), arrayIncludes = require_arrayIncludes(), arrayIncludesWith = require_arrayIncludesWith(), cacheHas = require_cacheHas(), createSet = require_createSet(), setToArray = require_setToArray();
+  var SetCache = require_SetCache(), arrayIncludes2 = require_arrayIncludes(), arrayIncludesWith = require_arrayIncludesWith(), cacheHas = require_cacheHas(), createSet = require_createSet(), setToArray = require_setToArray();
   var LARGE_ARRAY_SIZE = 200;
   function baseUniq(array, iteratee, comparator) {
-    var index = -1, includes = arrayIncludes, length = array.length, isCommon = true, result = [], seen = result;
+    var index = -1, includes = arrayIncludes2, length = array.length, isCommon = true, result = [], seen = result;
     if (comparator) {
       isCommon = false;
       includes = arrayIncludesWith;
@@ -13052,27 +14486,27 @@ Graph$2.prototype.isLeaf = function(v) {
   return neighbors.length === 0;
 };
 Graph$2.prototype.filterNodes = function(filter) {
-  var copy = new this.constructor({
+  var copy2 = new this.constructor({
     directed: this._isDirected,
     multigraph: this._isMultigraph,
     compound: this._isCompound
   });
-  copy.setGraph(this.graph());
+  copy2.setGraph(this.graph());
   var self1 = this;
   _$b.each(this._nodes, function(value, v) {
     if (filter(v)) {
-      copy.setNode(v, value);
+      copy2.setNode(v, value);
     }
   });
   _$b.each(this._edgeObjs, function(e) {
-    if (copy.hasNode(e.v) && copy.hasNode(e.w)) {
-      copy.setEdge(e, self1.edge(e));
+    if (copy2.hasNode(e.v) && copy2.hasNode(e.w)) {
+      copy2.setEdge(e, self1.edge(e));
     }
   });
   var parents = {};
   function findParent(v) {
     var parent = self1.parent(v);
-    if (parent === void 0 || copy.hasNode(parent)) {
+    if (parent === void 0 || copy2.hasNode(parent)) {
       parents[v] = parent;
       return parent;
     } else if (parent in parents) {
@@ -13083,11 +14517,11 @@ Graph$2.prototype.filterNodes = function(filter) {
   }
   __name(findParent, "findParent");
   if (this._isCompound) {
-    _$b.each(copy.nodes(), function(v) {
-      copy.setParent(v, findParent(v));
+    _$b.each(copy2.nodes(), function(v) {
+      copy2.setParent(v, findParent(v));
     });
   }
-  return copy;
+  return copy2;
 };
 Graph$2.prototype.setDefaultEdgeLabel = function(newDefault) {
   if (!_$b.isFunction(newDefault)) {
@@ -14412,9 +15846,9 @@ var TsCache = class TsCache2 {
     this.syntacticDiagnosticsCache.roll();
     this.typesCache.roll();
   }
-  getCompiled(id, snapshot, transform2) {
+  getCompiled(id, snapshot, transform3) {
     this.context.info(`${safe.exports.blue("transpiling")} '${id}'`);
-    return this.getCached(this.codeCache, id, snapshot, Boolean(!this.options.isolatedModules || this.options.declaration), transform2);
+    return this.getCached(this.codeCache, id, snapshot, Boolean(!this.options.isolatedModules || this.options.declaration), transform3);
   }
   getSyntacticDiagnostics(id, snapshot, check) {
     return this.getDiagnostics("syntax", this.syntacticDiagnosticsCache, id, snapshot, check);
@@ -14497,7 +15931,7 @@ function getOptionsOverrides({ useTsconfigDeclarationDir, cacheRoot }, preParsed
     noEmit: false,
     noEmitOnError: false,
     inlineSourceMap: false,
-    outDir: (0, import_pluginutils.normalizePath)(`${cacheRoot}/placeholder`),
+    outDir: (0, import_pluginutils3.normalizePath)(`${cacheRoot}/placeholder`),
     allowNonTsExtensions: true
   };
   if (!preParsedTsconfig) return overrides;
@@ -14512,13 +15946,13 @@ __name(getOptionsOverrides, "getOptionsOverrides");
 function expandIncludeWithDirs(include, dirs) {
   const newDirs = [];
   dirs.forEach((root) => {
-    if (include instanceof Array) include.forEach((x) => newDirs.push((0, import_pluginutils.normalizePath)(require$$0.join(root, x))));
-    else newDirs.push((0, import_pluginutils.normalizePath)(require$$0.join(root, include)));
+    if (include instanceof Array) include.forEach((x) => newDirs.push((0, import_pluginutils3.normalizePath)(require$$0.join(root, x))));
+    else newDirs.push((0, import_pluginutils3.normalizePath)(require$$0.join(root, include)));
   });
   return newDirs;
 }
 __name(expandIncludeWithDirs, "expandIncludeWithDirs");
-function createFilter(context, pluginOptions, parsedConfig) {
+function createFilter2(context, pluginOptions, parsedConfig) {
   let included = pluginOptions.include;
   let excluded = pluginOptions.exclude;
   if (parsedConfig.options.rootDirs) {
@@ -14533,11 +15967,11 @@ function createFilter(context, pluginOptions, parsedConfig) {
 ${JSON.stringify(included, void 0, 4)}`);
   context.debug(() => `excluded:
 ${JSON.stringify(excluded, void 0, 4)}`);
-  return (0, import_pluginutils.createFilter)(included, excluded, {
+  return (0, import_pluginutils3.createFilter)(included, excluded, {
     resolve: parsedConfig.options.rootDir
   });
 }
-__name(createFilter, "createFilter");
+__name(createFilter2, "createFilter");
 function parseTsConfig(context, pluginOptions) {
   var _a, _b;
   const fileName = tsModule.findConfigFile(pluginOptions.cwd, tsModule.sys.fileExists, pluginOptions.tsconfig);
@@ -14618,7 +16052,7 @@ var typescript = /* @__PURE__ */ __name((options) => {
   }, "getDiagnostics");
   const typecheckFile = /* @__PURE__ */ __name((id, snapshot, tcContext) => {
     if (!snapshot) return;
-    id = (0, import_pluginutils.normalizePath)(id);
+    id = (0, import_pluginutils3.normalizePath)(id);
     checkedFiles.add(id);
     const diagnostics = getDiagnostics(id, snapshot);
     printDiagnostics(tcContext, diagnostics, parsedConfig.options.pretty !== false);
@@ -14626,7 +16060,7 @@ var typescript = /* @__PURE__ */ __name((options) => {
   }, "typecheckFile");
   const addDeclaration = /* @__PURE__ */ __name((id, result) => {
     if (!result.dts) return;
-    const key = (0, import_pluginutils.normalizePath)(id);
+    const key = (0, import_pluginutils3.normalizePath)(id);
     declarations[key] = {
       type: result.dts,
       map: result.dtsmap
@@ -14708,7 +16142,7 @@ ${JSON.stringify(rollupOptions, void 0, 4)}`);
       if (pluginOptions.objectHashIgnoreUnknownHack) context.warn(() => `${safe.exports.yellow("You are using 'objectHashIgnoreUnknownHack' option")}. If you enabled it because of async functions, try disabling it now.`);
       if (pluginOptions.rollupCommonJSResolveHack) context.warn(() => `${safe.exports.yellow("You are using 'rollupCommonJSResolveHack' option")}. This is no longer needed, try disabling it now.`);
       if (watchMode) context.info(`running in watch mode`);
-      filter = createFilter(context, pluginOptions, parsedConfig);
+      filter = createFilter2(context, pluginOptions, parsedConfig);
       servicesHost = new LanguageServiceHost(parsedConfig, pluginOptions.transformers, pluginOptions.cwd);
       service = tsModule.createLanguageService(servicesHost, documentRegistry);
       servicesHost.setLanguageService(service);
@@ -14723,7 +16157,7 @@ ${JSON.stringify(rollupOptions, void 0, 4)}`);
       }
     },
     watchChange(id) {
-      const key = (0, import_pluginutils.normalizePath)(id);
+      const key = (0, import_pluginutils3.normalizePath)(id);
       delete declarations[key];
       checkedFiles.delete(key);
     },
@@ -14731,7 +16165,7 @@ ${JSON.stringify(rollupOptions, void 0, 4)}`);
       var _a;
       if (importee === TSLIB) return TSLIB_VIRTUAL;
       if (!importer) return;
-      importer = (0, import_pluginutils.normalizePath)(importer);
+      importer = (0, import_pluginutils3.normalizePath)(importer);
       const result = tsModule.nodeModuleNameResolver(importee, importer, parsedConfig.options, tsModule.sys);
       const resolved = (_a = result.resolvedModule) === null || _a === void 0 ? void 0 : _a.resolvedFileName;
       if (!resolved) return;
@@ -14817,7 +16251,7 @@ ${JSON.stringify(rollupOptions, void 0, 4)}`);
         });
       }
       parsedConfig.fileNames.forEach((name) => {
-        const key = (0, import_pluginutils.normalizePath)(name);
+        const key = (0, import_pluginutils3.normalizePath)(name);
         if (checkedFiles.has(key) || !filter(key)) return;
         context.debug(() => `type-checking missed '${key}'`);
         const snapshot = servicesHost.getScriptSnapshot(key);
@@ -14830,7 +16264,7 @@ ${JSON.stringify(rollupOptions, void 0, 4)}`);
       generateRound++;
       if (!parsedConfig.options.declaration) return;
       parsedConfig.fileNames.forEach((name) => {
-        const key = (0, import_pluginutils.normalizePath)(name);
+        const key = (0, import_pluginutils3.normalizePath)(name);
         if (key in declarations || !filter(key)) return;
         context.debug(() => `generating missed declarations for '${key}'`);
         const out = convertEmitOutput(service.getEmitOutput(key, true));
@@ -14852,11 +16286,11 @@ ${JSON.stringify(rollupOptions, void 0, 4)}`);
           const parsedText = JSON.parse(entryText);
           parsedText.sources = parsedText.sources.map((source) => {
             const absolutePath = (0, import_path2.resolve)(cachePlaceholder, source);
-            return (0, import_pluginutils.normalizePath)((0, import_path2.relative)(declarationDir, absolutePath));
+            return (0, import_pluginutils3.normalizePath)((0, import_path2.relative)(declarationDir, absolutePath));
           });
           entryText = JSON.stringify(parsedText);
         }
-        const relativePath = (0, import_pluginutils.normalizePath)((0, import_path2.relative)(cachePlaceholder, fileName));
+        const relativePath = (0, import_pluginutils3.normalizePath)((0, import_path2.relative)(cachePlaceholder, fileName));
         context.debug(() => `${safe.exports.blue("emitting declarations")} for '${key}' to '${relativePath}'`);
         this.emitFile({
           type: "asset",
@@ -14975,35 +16409,35 @@ async function resolveOptions(options) {
   if (options.configPath) {
     const configFile = await loadConfig2(options.configPath);
     if (configFile) {
-      options = (0, import_defu3.default)(options, configFile);
+      options = (0, import_defu5.default)(options, configFile);
     }
   }
   const projectGraph = (0, import_devkit6.readCachedProjectGraph)();
   const projectJsonPath = joinPaths(config.workspaceRoot, projectRoot, "project.json");
-  if (!(0, import_node_fs6.existsSync)(projectJsonPath)) {
+  if (!(0, import_node_fs8.existsSync)(projectJsonPath)) {
     throw new Error("Cannot find project.json configuration");
   }
-  const projectJsonContent = await (0, import_promises5.readFile)(projectJsonPath, "utf8");
+  const projectJsonContent = await (0, import_promises7.readFile)(projectJsonPath, "utf8");
   const projectJson = JSON.parse(projectJsonContent);
   const projectName = projectJson.name;
   const packageJsonPath = joinPaths(workspaceRoot.dir, projectRoot, "package.json");
-  if (!(0, import_node_fs6.existsSync)(packageJsonPath)) {
+  if (!(0, import_node_fs8.existsSync)(packageJsonPath)) {
     throw new Error("Cannot find package.json configuration");
   }
-  const packageJsonContent = await (0, import_promises5.readFile)(packageJsonPath, "utf8");
+  const packageJsonContent = await (0, import_promises7.readFile)(packageJsonPath, "utf8");
   const packageJson = JSON.parse(packageJsonContent);
   let tsconfig = options.tsconfig;
   if (!tsconfig) {
     tsconfig = joinPaths(workspaceRoot.dir, projectRoot, "tsconfig.json");
   }
-  if (!(0, import_node_fs6.existsSync)(tsconfig)) {
+  if (!(0, import_node_fs8.existsSync)(tsconfig)) {
     throw new Error("Cannot find tsconfig.json configuration");
   }
   let sourceRoot = projectJson.sourceRoot;
   if (!sourceRoot) {
     sourceRoot = joinPaths(projectRoot, "src");
   }
-  if (!(0, import_node_fs6.existsSync)(sourceRoot)) {
+  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, workspaceRoot.dir, projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
@@ -15105,16 +16539,16 @@ async function resolveOptions(options) {
     resolvedOptions.peerDependencies = Object.keys(packageJson.peerDependencies);
   }
   if (options.rollup) {
-    let rollup = {};
+    let rollup2 = {};
     if (typeof options.rollup === "string") {
       const rollupFile = await loadConfig2(options.rollup);
       if (rollupFile) {
-        rollup = rollupFile;
+        rollup2 = rollupFile;
       }
     } else {
-      rollup = options.rollup;
+      rollup2 = options.rollup;
     }
-    resolvedOptions.rollup = (0, import_defu3.default)(resolvedOptions.rollup ?? {}, rollup);
+    resolvedOptions.rollup = (0, import_defu5.default)(resolvedOptions.rollup ?? {}, rollup2);
   }
   resolvedOptions.hooks = {
     "rollup:options": /* @__PURE__ */ __name(async (ctx, opts) => {
@@ -15126,14 +16560,14 @@ async function resolveOptions(options) {
 }
 __name(resolveOptions, "resolveOptions");
 async function generatePackageJson(options) {
-  if (options.generatePackageJson !== false && (0, import_node_fs6.existsSync)(joinPaths(options.projectRoot, "package.json"))) {
+  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_fs6.existsSync)(packageJsonPath)) {
+    if (!(0, import_node_fs8.existsSync)(packageJsonPath)) {
       throw new Error("Cannot find package.json configuration");
     }
-    let packageJsonContent = await (0, import_promises5.readFile)(joinPaths(options.config.workspaceRoot, options.projectRoot, "package.json"), "utf8");
+    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");
     }
@@ -15150,7 +16584,7 @@ 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 (0, import_unbuild.build)(options.projectRoot, false, {
+    await build(options.projectRoot, false, {
       ...options,
       rootDir: options.projectRoot
     });
@@ -15175,7 +16609,7 @@ async function cleanOutputPath(options) {
   return options;
 }
 __name(cleanOutputPath, "cleanOutputPath");
-async function build(options) {
+async function build2(options) {
   writeDebug(` \u26A1  Executing Storm Unbuild pipeline`);
   const stopwatch = getStopwatch("Unbuild pipeline");
   try {
@@ -15192,7 +16626,7 @@ async function build(options) {
     stopwatch();
   }
 }
-__name(build, "build");
+__name(build2, "build");
 
 // bin/unbuild.ts
 async function createProgram(config) {
@@ -15270,7 +16704,7 @@ async function createProgram(config) {
 __name(createProgram, "createProgram");
 var buildAction = /* @__PURE__ */ __name((config) => async (options) => {
   try {
-    await build({
+    await build2({
       ...options,
       sourcemap: !!options.debug,
       replace: {},