@storm-software/unbuild 0.25.2 → 0.25.3

package/dist/chunk-HYDGJLPG.cjs

@@ -0,0 +1,2495 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkKUMAH6IZcjs = require('./chunk-KUMAH6IZ.cjs');
+
+
+var _chunkADWBQYE6cjs = require('./chunk-ADWBQYE6.cjs');
+
+
+var _chunkLUXNRUAPcjs = require('./chunk-LUXNRUAP.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk36OA7HRFcjs = require('./chunk-36OA7HRF.cjs');
+
+
+
+var _chunkYDYGZTJKcjs = require('./chunk-YDYGZTJK.cjs');
+
+// src/build.ts
+var _devkit = require('@nx/devkit');
+var _js = require('@nx/js');
+var _buildablelibsutils = require('@nx/js/src/utils/buildable-libs-utils');
+
+// ../build-tools/src/plugins/swc.ts
+var _core = require('@swc/core');
+
+// ../build-tools/src/plugins/ts-resolve.ts
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+var _module = require('module'); var _module2 = _interopRequireDefault(_module);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _resolve2 = require('resolve'); var _resolve3 = _interopRequireDefault(_resolve2);
+
+// ../build-tools/src/plugins/type-definitions.ts
+
+
+
+// ../build-tools/src/utilities/copy-assets.ts
+
+
+
+// ../config-tools/src/logger/create-logger.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+async function createLogger(config) {
+  const workspaceRoot = _chunk36OA7HRFcjs.findWorkspaceRoot.call(void 0, );
+  if (!workspaceRoot) {
+    throw new Error("Cannot find workspace root");
+  }
+  const writeFatal = _chunk36OA7HRFcjs.getLogFn.call(void 0, _chunk36OA7HRFcjs.LogLevel.FATAL, config, _chalk2.default);
+  const writeError = _chunk36OA7HRFcjs.getLogFn.call(void 0, _chunk36OA7HRFcjs.LogLevel.ERROR, config, _chalk2.default);
+  const writeWarning2 = _chunk36OA7HRFcjs.getLogFn.call(void 0, _chunk36OA7HRFcjs.LogLevel.WARN, config, _chalk2.default);
+  const writeInfo = _chunk36OA7HRFcjs.getLogFn.call(void 0, _chunk36OA7HRFcjs.LogLevel.INFO, config, _chalk2.default);
+  const writeSuccess = _chunk36OA7HRFcjs.getLogFn.call(void 0, _chunk36OA7HRFcjs.LogLevel.SUCCESS, config, _chalk2.default);
+  const writeDebug2 = _chunk36OA7HRFcjs.getLogFn.call(void 0, _chunk36OA7HRFcjs.LogLevel.DEBUG, config, _chalk2.default);
+  const writeTrace2 = _chunk36OA7HRFcjs.getLogFn.call(void 0, _chunk36OA7HRFcjs.LogLevel.DEBUG, config, _chalk2.default);
+  return {
+    fatal: writeFatal,
+    error: writeError,
+    warning: writeWarning2,
+    info: writeInfo,
+    success: writeSuccess,
+    debug: writeDebug2,
+    trace: writeTrace2,
+    getStopwatch: _chunk36OA7HRFcjs.getStopwatch
+  };
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, createLogger, "createLogger");
+
+// ../build-tools/src/utilities/copy-assets.ts
+var _glob = require('glob');
+var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
+
+// ../config-tools/src/config-file/get-config-file.ts
+var _c12 = require('c12');
+var _defu = require('defu'); var _defu2 = _interopRequireDefault(_defu);
+var getConfigFileByName = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, async (fileName, filePath, options = {}) => {
+  const workspacePath = filePath || _chunk36OA7HRFcjs.findWorkspaceRoot.call(void 0, filePath);
+  let config = await _c12.loadConfig.call(void 0, {
+    cwd: workspacePath,
+    packageJson: true,
+    name: fileName,
+    envName: _optionalChain([fileName, 'optionalAccess', _2 => _2.toUpperCase, 'call', _3 => _3()]),
+    jitiOptions: {
+      debug: false,
+      fsCache: process.env.STORM_SKIP_CACHE === "true" ? false : _chunk36OA7HRFcjs.joinPaths.call(void 0, process.env.STORM_CACHE_DIR || "node_modules/.cache/storm", "jiti")
+    },
+    ...options
+  });
+  if (!config || Object.keys(config).length === 0) {
+    config = await _c12.loadConfig.call(void 0, {
+      cwd: workspacePath,
+      packageJson: true,
+      name: fileName,
+      envName: _optionalChain([fileName, 'optionalAccess', _4 => _4.toUpperCase, 'call', _5 => _5()]),
+      jitiOptions: {
+        debug: false,
+        fsCache: process.env.STORM_SKIP_CACHE === "true" ? false : _chunk36OA7HRFcjs.joinPaths.call(void 0, process.env.STORM_CACHE_DIR || "node_modules/.cache/storm", "jiti")
+      },
+      configFile: fileName,
+      ...options
+    });
+  }
+  return config;
+}, "getConfigFileByName");
+var getConfigFile = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, async (filePath, additionalFileNames = []) => {
+  const workspacePath = filePath ? filePath : _chunk36OA7HRFcjs.findWorkspaceRoot.call(void 0, filePath);
+  const result = await getConfigFileByName("storm", workspacePath);
+  let config = result.config;
+  const configFile = result.configFile;
+  if (config && configFile && Object.keys(config).length > 0) {
+    _chunk36OA7HRFcjs.writeSystem.call(void 0, `Found Storm configuration file "${configFile.includes(`${workspacePath}/`) ? configFile.replace(`${workspacePath}/`, "") : configFile}" at "${workspacePath}"`, {
+      logLevel: "all"
+    });
+  }
+  if (additionalFileNames && additionalFileNames.length > 0) {
+    const results = await Promise.all(additionalFileNames.map((fileName) => getConfigFileByName(fileName, workspacePath)));
+    for (const result2 of results) {
+      if (_optionalChain([result2, 'optionalAccess', _6 => _6.config]) && _optionalChain([result2, 'optionalAccess', _7 => _7.configFile]) && Object.keys(result2.config).length > 0) {
+        _chunk36OA7HRFcjs.writeSystem.call(void 0, `Found alternative configuration file "${result2.configFile.includes(`${workspacePath}/`) ? result2.configFile.replace(`${workspacePath}/`, "") : result2.configFile}" at "${workspacePath}"`, {
+          logLevel: "all"
+        });
+        config = _defu2.default.call(void 0, _nullishCoalesce(result2.config, () => ( {})), _nullishCoalesce(config, () => ( {})));
+      }
+    }
+  }
+  if (!config) {
+    return void 0;
+  }
+  config.configFile = configFile;
+  return config;
+}, "getConfigFile");
+
+// ../config-tools/src/create-storm-config.ts
+
+
+// ../config-tools/src/env/get-env.ts
+var getConfigEnv = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, () => {
+  const prefix = "STORM_";
+  let config = {
+    extends: process.env[`${prefix}EXTENDS`] || void 0,
+    name: process.env[`${prefix}NAME`] || void 0,
+    namespace: process.env[`${prefix}NAMESPACE`] || void 0,
+    owner: process.env[`${prefix}OWNER`] || void 0,
+    bot: {
+      name: process.env[`${prefix}BOT_NAME`] || void 0,
+      email: process.env[`${prefix}BOT_EMAIL`] || void 0
+    },
+    organization: process.env[`${prefix}ORGANIZATION`] || void 0,
+    packageManager: process.env[`${prefix}PACKAGE_MANAGER`] || void 0,
+    license: process.env[`${prefix}LICENSE`] || void 0,
+    homepage: process.env[`${prefix}HOMEPAGE`] || void 0,
+    docs: process.env[`${prefix}DOCS`] || void 0,
+    licensing: process.env[`${prefix}LICENSING`] || void 0,
+    timezone: process.env[`${prefix}TIMEZONE`] || process.env.TZ || void 0,
+    locale: process.env[`${prefix}LOCALE`] || process.env.LOCALE || void 0,
+    configFile: process.env[`${prefix}CONFIG_FILE`] ? _chunk36OA7HRFcjs.correctPaths.call(void 0, process.env[`${prefix}CONFIG_FILE`]) : void 0,
+    workspaceRoot: process.env[`${prefix}WORKSPACE_ROOT`] ? _chunk36OA7HRFcjs.correctPaths.call(void 0, process.env[`${prefix}WORKSPACE_ROOT`]) : void 0,
+    directories: {
+      cache: process.env[`${prefix}CACHE_DIR`] ? _chunk36OA7HRFcjs.correctPaths.call(void 0, process.env[`${prefix}CACHE_DIR`]) : void 0,
+      data: process.env[`${prefix}DATA_DIR`] ? _chunk36OA7HRFcjs.correctPaths.call(void 0, process.env[`${prefix}DATA_DIR`]) : void 0,
+      config: process.env[`${prefix}CONFIG_DIR`] ? _chunk36OA7HRFcjs.correctPaths.call(void 0, process.env[`${prefix}CONFIG_DIR`]) : void 0,
+      temp: process.env[`${prefix}TEMP_DIR`] ? _chunk36OA7HRFcjs.correctPaths.call(void 0, process.env[`${prefix}TEMP_DIR`]) : void 0,
+      log: process.env[`${prefix}LOG_DIR`] ? _chunk36OA7HRFcjs.correctPaths.call(void 0, process.env[`${prefix}LOG_DIR`]) : void 0,
+      build: process.env[`${prefix}BUILD_DIR`] ? _chunk36OA7HRFcjs.correctPaths.call(void 0, process.env[`${prefix}BUILD_DIR`]) : void 0
+    },
+    skipCache: process.env[`${prefix}SKIP_CACHE`] !== void 0 ? Boolean(process.env[`${prefix}SKIP_CACHE`]) : void 0,
+    env: (_nullishCoalesce(_nullishCoalesce(process.env[`${prefix}ENV`], () => ( process.env.NODE_ENV)), () => ( process.env.ENVIRONMENT))) || void 0,
+    // ci:
+    //   process.env[`${prefix}CI`] !== undefined
+    //     ? Boolean(
+    //         process.env[`${prefix}CI`] ??
+    //           process.env.CI ??
+    //           process.env.CONTINUOUS_INTEGRATION
+    //       )
+    //     : undefined,
+    repository: process.env[`${prefix}REPOSITORY`] || void 0,
+    branch: process.env[`${prefix}BRANCH`] || void 0,
+    preid: process.env[`${prefix}PRE_ID`] || void 0,
+    externalPackagePatterns: process.env[`${prefix}EXTERNAL_PACKAGE_PATTERNS`] ? JSON.parse(process.env[`${prefix}EXTERNAL_PACKAGE_PATTERNS`]) : [],
+    registry: {
+      github: process.env[`${prefix}REGISTRY_GITHUB`] || void 0,
+      npm: process.env[`${prefix}REGISTRY_NPM`] || void 0,
+      cargo: process.env[`${prefix}REGISTRY_CARGO`] || void 0,
+      cyclone: process.env[`${prefix}REGISTRY_CYCLONE`] || void 0,
+      container: process.env[`${prefix}REGISTRY_CONTAINER`] || void 0
+    },
+    logLevel: process.env[`${prefix}LOG_LEVEL`] !== null && process.env[`${prefix}LOG_LEVEL`] !== void 0 ? process.env[`${prefix}LOG_LEVEL`] && Number.isSafeInteger(Number.parseInt(process.env[`${prefix}LOG_LEVEL`])) ? _chunk36OA7HRFcjs.getLogLevelLabel.call(void 0, Number.parseInt(process.env[`${prefix}LOG_LEVEL`])) : process.env[`${prefix}LOG_LEVEL`] : void 0
+  };
+  const themeNames = Object.keys(process.env).filter((envKey) => envKey.startsWith(`${prefix}COLOR_`) && _chunk36OA7HRFcjs.COLOR_KEYS.every((colorKey) => !envKey.startsWith(`${prefix}COLOR_LIGHT_${colorKey}`) && !envKey.startsWith(`${prefix}COLOR_DARK_${colorKey}`)));
+  config.colors = themeNames.length > 0 ? themeNames.reduce((ret, themeName) => {
+    ret[themeName] = getThemeColorConfigEnv(prefix, themeName);
+    return ret;
+  }, {}) : getThemeColorConfigEnv(prefix);
+  if (config.docs === _chunk36OA7HRFcjs.STORM_DEFAULT_DOCS) {
+    if (config.homepage === _chunk36OA7HRFcjs.STORM_DEFAULT_HOMEPAGE) {
+      config.docs = `${_chunk36OA7HRFcjs.STORM_DEFAULT_HOMEPAGE}/projects/${config.name}/docs`;
+    } else {
+      config.docs = `${config.homepage}/docs`;
+    }
+  }
+  if (config.licensing === _chunk36OA7HRFcjs.STORM_DEFAULT_LICENSING) {
+    if (config.homepage === _chunk36OA7HRFcjs.STORM_DEFAULT_HOMEPAGE) {
+      config.licensing = `${_chunk36OA7HRFcjs.STORM_DEFAULT_HOMEPAGE}/projects/${config.name}/licensing`;
+    } else {
+      config.licensing = `${config.homepage}/docs`;
+    }
+  }
+  const serializedConfig = process.env[`${prefix}CONFIG`];
+  if (serializedConfig) {
+    const parsed = JSON.parse(serializedConfig);
+    config = {
+      ...config,
+      ...parsed,
+      colors: {
+        ...config.colors,
+        ...parsed.colors
+      },
+      extensions: {
+        ...config.extensions,
+        ...parsed.extensions
+      }
+    };
+  }
+  return config;
+}, "getConfigEnv");
+var getThemeColorConfigEnv = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (prefix, theme) => {
+  const themeName = `COLOR_${theme && theme !== "base" ? `${theme}_` : ""}`.toUpperCase();
+  return process.env[`${prefix}${themeName}LIGHT_BRAND`] || process.env[`${prefix}${themeName}DARK_BRAND`] ? getMultiThemeColorConfigEnv(prefix + themeName) : getSingleThemeColorConfigEnv(prefix + themeName);
+}, "getThemeColorConfigEnv");
+var getSingleThemeColorConfigEnv = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (prefix) => {
+  return {
+    dark: process.env[`${prefix}DARK`],
+    light: process.env[`${prefix}LIGHT`],
+    brand: process.env[`${prefix}BRAND`],
+    alternate: process.env[`${prefix}ALTERNATE`],
+    accent: process.env[`${prefix}ACCENT`],
+    link: process.env[`${prefix}LINK`],
+    help: process.env[`${prefix}HELP`],
+    success: process.env[`${prefix}SUCCESS`],
+    info: process.env[`${prefix}INFO`],
+    warning: process.env[`${prefix}WARNING`],
+    danger: process.env[`${prefix}DANGER`],
+    fatal: process.env[`${prefix}FATAL`],
+    positive: process.env[`${prefix}POSITIVE`],
+    negative: process.env[`${prefix}NEGATIVE`]
+  };
+}, "getSingleThemeColorConfigEnv");
+var getMultiThemeColorConfigEnv = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (prefix) => {
+  return {
+    light: getBaseThemeColorConfigEnv(`${prefix}_LIGHT_`),
+    dark: getBaseThemeColorConfigEnv(`${prefix}_DARK_`)
+  };
+}, "getMultiThemeColorConfigEnv");
+var getBaseThemeColorConfigEnv = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (prefix) => {
+  return {
+    foreground: process.env[`${prefix}FOREGROUND`],
+    background: process.env[`${prefix}BACKGROUND`],
+    brand: process.env[`${prefix}BRAND`],
+    alternate: process.env[`${prefix}ALTERNATE`],
+    accent: process.env[`${prefix}ACCENT`],
+    link: process.env[`${prefix}LINK`],
+    help: process.env[`${prefix}HELP`],
+    success: process.env[`${prefix}SUCCESS`],
+    info: process.env[`${prefix}INFO`],
+    warning: process.env[`${prefix}WARNING`],
+    danger: process.env[`${prefix}DANGER`],
+    fatal: process.env[`${prefix}FATAL`],
+    positive: process.env[`${prefix}POSITIVE`],
+    negative: process.env[`${prefix}NEGATIVE`]
+  };
+}, "getBaseThemeColorConfigEnv");
+
+// ../config-tools/src/env/set-env.ts
+var setExtensionEnv = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (extensionName, extension) => {
+  for (const key of Object.keys(_nullishCoalesce(extension, () => ( {})))) {
+    if (extension[key]) {
+      const result = _nullishCoalesce(_optionalChain([key, 'optionalAccess', _8 => _8.replace, 'call', _9 => _9(/([A-Z])+/g, (input) => input ? _optionalChain([input, 'access', _10 => _10[0], 'optionalAccess', _11 => _11.toUpperCase, 'call', _12 => _12()]) + input.slice(1) : ""), 'access', _13 => _13.split, 'call', _14 => _14(/(?=[A-Z])|[.\-\s_]/), 'access', _15 => _15.map, 'call', _16 => _16((x) => x.toLowerCase())]), () => ( []));
+      let extensionKey;
+      if (result.length === 0) {
+        return;
+      }
+      if (result.length === 1) {
+        extensionKey = _nullishCoalesce(_optionalChain([result, 'access', _17 => _17[0], 'optionalAccess', _18 => _18.toUpperCase, 'call', _19 => _19()]), () => ( ""));
+      } else {
+        extensionKey = result.reduce((ret, part) => {
+          return `${ret}_${part.toLowerCase()}`;
+        });
+      }
+      process.env[`STORM_EXTENSION_${extensionName.toUpperCase()}_${extensionKey.toUpperCase()}`] = extension[key];
+    }
+  }
+}, "setExtensionEnv");
+var setConfigEnv = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (config) => {
+  const prefix = "STORM_";
+  if (config.extends) {
+    process.env[`${prefix}EXTENDS`] = config.extends;
+  }
+  if (config.name) {
+    process.env[`${prefix}NAME`] = config.name;
+  }
+  if (config.namespace) {
+    process.env[`${prefix}NAMESPACE`] = config.namespace;
+  }
+  if (config.owner) {
+    process.env[`${prefix}OWNER`] = config.owner;
+  }
+  if (config.bot) {
+    process.env[`${prefix}BOT_NAME`] = config.bot.name;
+    process.env[`${prefix}BOT_EMAIL`] = config.bot.email;
+  }
+  if (config.organization) {
+    process.env[`${prefix}ORGANIZATION`] = config.organization;
+  }
+  if (config.packageManager) {
+    process.env[`${prefix}PACKAGE_MANAGER`] = config.packageManager;
+  }
+  if (config.license) {
+    process.env[`${prefix}LICENSE`] = config.license;
+  }
+  if (config.homepage) {
+    process.env[`${prefix}HOMEPAGE`] = config.homepage;
+  }
+  if (config.docs) {
+    process.env[`${prefix}DOCS`] = config.docs;
+  }
+  if (config.licensing) {
+    process.env[`${prefix}LICENSING`] = config.licensing;
+  }
+  if (config.timezone) {
+    process.env[`${prefix}TIMEZONE`] = config.timezone;
+    process.env.TZ = config.timezone;
+    process.env.DEFAULT_TIMEZONE = config.timezone;
+  }
+  if (config.locale) {
+    process.env[`${prefix}LOCALE`] = config.locale;
+    process.env.LOCALE = config.locale;
+    process.env.DEFAULT_LOCALE = config.locale;
+    process.env.LANG = config.locale ? `${config.locale.replaceAll("-", "_")}.UTF-8` : "en_US.UTF-8";
+  }
+  if (config.configFile) {
+    process.env[`${prefix}CONFIG_FILE`] = _chunk36OA7HRFcjs.correctPaths.call(void 0, config.configFile);
+  }
+  if (config.workspaceRoot) {
+    process.env[`${prefix}WORKSPACE_ROOT`] = _chunk36OA7HRFcjs.correctPaths.call(void 0, config.workspaceRoot);
+    process.env.NX_WORKSPACE_ROOT = _chunk36OA7HRFcjs.correctPaths.call(void 0, config.workspaceRoot);
+    process.env.NX_WORKSPACE_ROOT_PATH = _chunk36OA7HRFcjs.correctPaths.call(void 0, config.workspaceRoot);
+  }
+  if (config.directories) {
+    if (!config.skipCache && config.directories.cache) {
+      process.env[`${prefix}CACHE_DIR`] = _chunk36OA7HRFcjs.correctPaths.call(void 0, config.directories.cache);
+    }
+    if (config.directories.data) {
+      process.env[`${prefix}DATA_DIR`] = _chunk36OA7HRFcjs.correctPaths.call(void 0, config.directories.data);
+    }
+    if (config.directories.config) {
+      process.env[`${prefix}CONFIG_DIR`] = _chunk36OA7HRFcjs.correctPaths.call(void 0, config.directories.config);
+    }
+    if (config.directories.temp) {
+      process.env[`${prefix}TEMP_DIR`] = _chunk36OA7HRFcjs.correctPaths.call(void 0, config.directories.temp);
+    }
+    if (config.directories.log) {
+      process.env[`${prefix}LOG_DIR`] = _chunk36OA7HRFcjs.correctPaths.call(void 0, config.directories.log);
+    }
+    if (config.directories.build) {
+      process.env[`${prefix}BUILD_DIR`] = _chunk36OA7HRFcjs.correctPaths.call(void 0, config.directories.build);
+    }
+  }
+  if (config.skipCache !== void 0) {
+    process.env[`${prefix}SKIP_CACHE`] = String(config.skipCache);
+    if (config.skipCache) {
+      process.env.NX_SKIP_NX_CACHE ??= String(config.skipCache);
+      process.env.NX_CACHE_PROJECT_GRAPH ??= String(config.skipCache);
+    }
+  }
+  if (config.env) {
+    process.env[`${prefix}ENV`] = config.env;
+    process.env.NODE_ENV = config.env;
+    process.env.ENVIRONMENT = config.env;
+  }
+  if (_optionalChain([config, 'access', _20 => _20.colors, 'optionalAccess', _21 => _21.base, 'optionalAccess', _22 => _22.light]) || _optionalChain([config, 'access', _23 => _23.colors, 'optionalAccess', _24 => _24.base, 'optionalAccess', _25 => _25.dark])) {
+    for (const key of Object.keys(config.colors)) {
+      setThemeColorConfigEnv(`${prefix}COLOR_${key}_`, config.colors[key]);
+    }
+  } else {
+    setThemeColorConfigEnv(`${prefix}COLOR_`, config.colors);
+  }
+  if (config.repository) {
+    process.env[`${prefix}REPOSITORY`] = config.repository;
+  }
+  if (config.branch) {
+    process.env[`${prefix}BRANCH`] = config.branch;
+  }
+  if (config.preid) {
+    process.env[`${prefix}PRE_ID`] = String(config.preid);
+  }
+  if (config.externalPackagePatterns) {
+    process.env[`${prefix}EXTERNAL_PACKAGE_PATTERNS`] = JSON.stringify(config.externalPackagePatterns);
+  }
+  if (config.registry) {
+    if (config.registry.github) {
+      process.env[`${prefix}REGISTRY_GITHUB`] = String(config.registry.github);
+    }
+    if (config.registry.npm) {
+      process.env[`${prefix}REGISTRY_NPM`] = String(config.registry.npm);
+    }
+    if (config.registry.cargo) {
+      process.env[`${prefix}REGISTRY_CARGO`] = String(config.registry.cargo);
+    }
+    if (config.registry.cyclone) {
+      process.env[`${prefix}REGISTRY_CYCLONE`] = String(config.registry.cyclone);
+    }
+    if (config.registry.container) {
+      process.env[`${prefix}REGISTRY_CONTAINER`] = String(config.registry.cyclone);
+    }
+  }
+  if (config.logLevel) {
+    process.env[`${prefix}LOG_LEVEL`] = String(config.logLevel);
+    process.env.LOG_LEVEL = String(config.logLevel);
+    process.env.NX_VERBOSE_LOGGING = String(_chunk36OA7HRFcjs.getLogLevel.call(void 0, config.logLevel) >= _chunk36OA7HRFcjs.LogLevel.DEBUG ? true : false);
+    process.env.RUST_BACKTRACE = _chunk36OA7HRFcjs.getLogLevel.call(void 0, config.logLevel) >= _chunk36OA7HRFcjs.LogLevel.DEBUG ? "full" : "none";
+  }
+  process.env[`${prefix}CONFIG`] = JSON.stringify(config);
+  for (const key of Object.keys(_nullishCoalesce(config.extensions, () => ( {})))) {
+    config.extensions[key] && Object.keys(config.extensions[key]) && setExtensionEnv(key, config.extensions[key]);
+  }
+}, "setConfigEnv");
+var setThemeColorConfigEnv = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (prefix, config) => {
+  return _optionalChain([config, 'optionalAccess', _26 => _26.light, 'optionalAccess', _27 => _27.brand]) || _optionalChain([config, 'optionalAccess', _28 => _28.dark, 'optionalAccess', _29 => _29.brand]) ? setMultiThemeColorConfigEnv(prefix, config) : setSingleThemeColorConfigEnv(prefix, config);
+}, "setThemeColorConfigEnv");
+var setSingleThemeColorConfigEnv = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (prefix, config) => {
+  if (config.dark) {
+    process.env[`${prefix}DARK`] = config.dark;
+  }
+  if (config.light) {
+    process.env[`${prefix}LIGHT`] = config.light;
+  }
+  if (config.brand) {
+    process.env[`${prefix}BRAND`] = config.brand;
+  }
+  if (config.alternate) {
+    process.env[`${prefix}ALTERNATE`] = config.alternate;
+  }
+  if (config.accent) {
+    process.env[`${prefix}ACCENT`] = config.accent;
+  }
+  if (config.link) {
+    process.env[`${prefix}LINK`] = config.link;
+  }
+  if (config.help) {
+    process.env[`${prefix}HELP`] = config.help;
+  }
+  if (config.success) {
+    process.env[`${prefix}SUCCESS`] = config.success;
+  }
+  if (config.info) {
+    process.env[`${prefix}INFO`] = config.info;
+  }
+  if (config.warning) {
+    process.env[`${prefix}WARNING`] = config.warning;
+  }
+  if (config.danger) {
+    process.env[`${prefix}DANGER`] = config.danger;
+  }
+  if (config.fatal) {
+    process.env[`${prefix}FATAL`] = config.fatal;
+  }
+  if (config.positive) {
+    process.env[`${prefix}POSITIVE`] = config.positive;
+  }
+  if (config.negative) {
+    process.env[`${prefix}NEGATIVE`] = config.negative;
+  }
+}, "setSingleThemeColorConfigEnv");
+var setMultiThemeColorConfigEnv = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (prefix, config) => {
+  return {
+    light: setBaseThemeColorConfigEnv(`${prefix}LIGHT_`, config.light),
+    dark: setBaseThemeColorConfigEnv(`${prefix}DARK_`, config.dark)
+  };
+}, "setMultiThemeColorConfigEnv");
+var setBaseThemeColorConfigEnv = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (prefix, config) => {
+  if (config.foreground) {
+    process.env[`${prefix}FOREGROUND`] = config.foreground;
+  }
+  if (config.background) {
+    process.env[`${prefix}BACKGROUND`] = config.background;
+  }
+  if (config.brand) {
+    process.env[`${prefix}BRAND`] = config.brand;
+  }
+  if (config.alternate) {
+    process.env[`${prefix}ALTERNATE`] = config.alternate;
+  }
+  if (config.accent) {
+    process.env[`${prefix}ACCENT`] = config.accent;
+  }
+  if (config.link) {
+    process.env[`${prefix}LINK`] = config.link;
+  }
+  if (config.help) {
+    process.env[`${prefix}HELP`] = config.help;
+  }
+  if (config.success) {
+    process.env[`${prefix}SUCCESS`] = config.success;
+  }
+  if (config.info) {
+    process.env[`${prefix}INFO`] = config.info;
+  }
+  if (config.warning) {
+    process.env[`${prefix}WARNING`] = config.warning;
+  }
+  if (config.danger) {
+    process.env[`${prefix}DANGER`] = config.danger;
+  }
+  if (config.fatal) {
+    process.env[`${prefix}FATAL`] = config.fatal;
+  }
+  if (config.positive) {
+    process.env[`${prefix}POSITIVE`] = config.positive;
+  }
+  if (config.negative) {
+    process.env[`${prefix}NEGATIVE`] = config.negative;
+  }
+}, "setBaseThemeColorConfigEnv");
+
+// ../config-tools/src/create-storm-config.ts
+var _static_cache = void 0;
+var loadStormConfig = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, async (workspaceRoot) => {
+  let config = {};
+  if (_optionalChain([_static_cache, 'optionalAccess', _30 => _30.data]) && _optionalChain([_static_cache, 'optionalAccess', _31 => _31.timestamp]) && _static_cache.timestamp >= Date.now() + 3e4) {
+    _chunk36OA7HRFcjs.writeTrace.call(void 0, `Configuration cache hit - ${_static_cache.timestamp}`, _static_cache.data);
+    return _static_cache.data;
+  }
+  let _workspaceRoot = workspaceRoot;
+  if (!_workspaceRoot) {
+    _workspaceRoot = _chunk36OA7HRFcjs.findWorkspaceRoot.call(void 0, );
+  }
+  const configFile = await getConfigFile(_workspaceRoot);
+  if (!configFile) {
+    _chunk36OA7HRFcjs.writeWarning.call(void 0, "No Storm config file found in the current workspace. Please ensure this is the expected behavior - you can add a `storm.json` file to the root of your workspace if it is not.\n", {
+      logLevel: "all"
+    });
+  }
+  config = _defu2.default.call(void 0, getConfigEnv(), configFile, _chunk36OA7HRFcjs.getDefaultConfig.call(void 0, _workspaceRoot));
+  setConfigEnv(config);
+  _chunk36OA7HRFcjs.writeTrace.call(void 0, `\u2699\uFE0F  Using Storm configuration: 
+${_chunk36OA7HRFcjs.formatLogMessage.call(void 0, config)}`, config);
+  return config;
+}, "loadStormConfig");
+
+// ../build-tools/src/utilities/read-nx-config.ts
+
+
+var readNxConfig = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, async (workspaceRoot) => {
+  let rootDir = workspaceRoot;
+  if (!rootDir) {
+    const config = await loadStormConfig();
+    rootDir = config.workspaceRoot;
+  }
+  const nxJsonPath = _chunk36OA7HRFcjs.joinPaths.call(void 0, rootDir, "nx.json");
+  if (!_fs.existsSync.call(void 0, nxJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const configContent = await _promises.readFile.call(void 0, nxJsonPath, "utf8");
+  return JSON.parse(configContent);
+}, "readNxConfig");
+
+// ../build-tools/src/utilities/copy-assets.ts
+var copyAssets = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, async (config, assets, outputPath, projectRoot, projectName, sourceRoot, generatePackageJson2 = true, includeSrc = false, banner, footer) => {
+  const pendingAssets = Array.from(_nullishCoalesce(assets, () => ( [])));
+  if (!_optionalChain([pendingAssets, 'optionalAccess', _32 => _32.some, 'call', _33 => _33((asset) => _optionalChain([asset, 'optionalAccess', _34 => _34.glob]) === "*.md")])) {
+    pendingAssets.push({
+      input: projectRoot,
+      glob: "*.md",
+      output: "/"
+    });
+  }
+  if (generatePackageJson2 === false) {
+    pendingAssets.push({
+      input: sourceRoot,
+      glob: "package.json",
+      output: "."
+    });
+  }
+  if (!_optionalChain([pendingAssets, 'optionalAccess', _35 => _35.some, 'call', _36 => _36((asset) => _optionalChain([asset, 'optionalAccess', _37 => _37.glob]) === "LICENSE")])) {
+    pendingAssets.push({
+      input: "",
+      glob: "LICENSE",
+      output: "."
+    });
+  }
+  if (includeSrc === true) {
+    pendingAssets.push({
+      input: sourceRoot,
+      glob: "**/{*.ts,*.tsx,*.js,*.jsx}",
+      output: "src/"
+    });
+  }
+  const nxJson = readNxConfig(config.workspaceRoot);
+  const projectGraph = _devkit.readCachedProjectGraph.call(void 0, );
+  const projectsConfigurations = _devkit.readProjectsConfigurationFromProjectGraph.call(void 0, projectGraph);
+  if (!_optionalChain([projectsConfigurations, 'optionalAccess', _38 => _38.projects, 'optionalAccess', _39 => _39[projectName]])) {
+    throw new Error("The Build process failed because the project does not have a valid configuration in the project.json file. Check if the file exists in the root of the project.");
+  }
+  const buildTarget = _optionalChain([projectsConfigurations, 'access', _40 => _40.projects, 'access', _41 => _41[projectName], 'access', _42 => _42.targets, 'optionalAccess', _43 => _43.build]);
+  if (!buildTarget) {
+    throw new Error(`The Build process failed because the project does not have a valid build target in the project.json file. Check if the file exists in the root of the project at ${_chunk36OA7HRFcjs.joinPaths.call(void 0, projectRoot, "project.json")}`);
+  }
+  const result = await _js.copyAssets.call(void 0, {
+    assets,
+    watch: false,
+    outputPath
+  }, {
+    root: config.workspaceRoot,
+    targetName: "build",
+    target: buildTarget,
+    projectName,
+    projectGraph,
+    projectsConfigurations,
+    nxJsonConfiguration: nxJson,
+    cwd: config.workspaceRoot,
+    isVerbose: _chunk36OA7HRFcjs.isVerbose.call(void 0, config.logLevel)
+  });
+  if (!result.success) {
+    throw new Error("The Build process failed trying to copy assets");
+  }
+  if (includeSrc === true) {
+    _chunk36OA7HRFcjs.writeDebug.call(void 0, `\u{1F4DD}  Adding banner and writing source files: ${_chunk36OA7HRFcjs.joinPaths.call(void 0, outputPath, "src")}`, config);
+    const files = await _glob.glob.call(void 0, [
+      _chunk36OA7HRFcjs.joinPaths.call(void 0, config.workspaceRoot, outputPath, "src/**/*.ts"),
+      _chunk36OA7HRFcjs.joinPaths.call(void 0, config.workspaceRoot, outputPath, "src/**/*.tsx"),
+      _chunk36OA7HRFcjs.joinPaths.call(void 0, config.workspaceRoot, outputPath, "src/**/*.js"),
+      _chunk36OA7HRFcjs.joinPaths.call(void 0, config.workspaceRoot, outputPath, "src/**/*.jsx")
+    ]);
+    await Promise.allSettled(files.map(async (file) => _promises.writeFile.call(void 0, file, `${banner && typeof banner === "string" ? banner.startsWith("//") ? banner : `// ${banner}` : ""}
+
+${await _promises.readFile.call(void 0, file, "utf8")}
+
+${footer && typeof footer === "string" ? footer.startsWith("//") ? footer : `// ${footer}` : ""}`)));
+  }
+}, "copyAssets");
+
+// ../build-tools/src/utilities/generate-package-json.ts
+
+
+
+
+var _projectgraph = require('nx/src/project-graph/project-graph');
+var addPackageDependencies = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, async (workspaceRoot, projectRoot, projectName, packageJson) => {
+  const projectDependencies = _buildablelibsutils.calculateProjectBuildableDependencies.call(void 0, void 0, _projectgraph.readCachedProjectGraph.call(void 0, ), workspaceRoot, projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  const localPackages = [];
+  for (const project of projectDependencies.dependencies.filter((dep) => dep.node.type === "lib" && dep.node.data.root !== projectRoot && dep.node.data.root !== workspaceRoot)) {
+    const projectNode = project.node;
+    if (projectNode.data.root) {
+      const projectPackageJsonPath = _chunk36OA7HRFcjs.joinPaths.call(void 0, workspaceRoot, projectNode.data.root, "package.json");
+      if (_fs.existsSync.call(void 0, projectPackageJsonPath)) {
+        const projectPackageJsonContent = await _promises.readFile.call(void 0, projectPackageJsonPath, "utf8");
+        const projectPackageJson = JSON.parse(projectPackageJsonContent);
+        if (projectPackageJson.private !== false) {
+          localPackages.push(projectPackageJson);
+        }
+      }
+    }
+  }
+  if (localPackages.length > 0) {
+    _chunk36OA7HRFcjs.writeTrace.call(void 0, `\u{1F4E6}  Adding local packages to package.json: ${localPackages.map((p) => p.name).join(", ")}`);
+    packageJson.peerDependencies = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = `>=${localPackage.version || "0.0.1"}`;
+      }
+      return ret;
+    }, _nullishCoalesce(packageJson.peerDependencies, () => ( {})));
+    packageJson.peerDependenciesMeta = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = {
+          optional: false
+        };
+      }
+      return ret;
+    }, _nullishCoalesce(packageJson.peerDependenciesMeta, () => ( {})));
+    packageJson.devDependencies = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = localPackage.version || "0.0.1";
+      }
+      return ret;
+    }, _nullishCoalesce(packageJson.peerDependencies, () => ( {})));
+  } else {
+    _chunk36OA7HRFcjs.writeTrace.call(void 0, "\u{1F4E6}  No local packages dependencies to add to package.json");
+  }
+  return packageJson;
+}, "addPackageDependencies");
+var addWorkspacePackageJsonFields = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, async (config, projectRoot, sourceRoot, projectName, includeSrc = false, packageJson) => {
+  const workspaceRoot = config.workspaceRoot ? config.workspaceRoot : _chunk36OA7HRFcjs.findWorkspaceRoot.call(void 0, );
+  const workspacePackageJsonContent = await _promises.readFile.call(void 0, _chunk36OA7HRFcjs.joinPaths.call(void 0, workspaceRoot, "package.json"), "utf8");
+  const workspacePackageJson = JSON.parse(workspacePackageJsonContent);
+  packageJson.type ??= "module";
+  packageJson.sideEffects ??= false;
+  if (includeSrc === true) {
+    let distSrc = sourceRoot.replace(projectRoot, "");
+    if (distSrc.startsWith("/")) {
+      distSrc = distSrc.substring(1);
+    }
+    packageJson.source ??= `${_chunk36OA7HRFcjs.joinPaths.call(void 0, distSrc, "index.ts").replaceAll("\\", "/")}`;
+  }
+  packageJson.files ??= [
+    "dist/**/*"
+  ];
+  if (includeSrc === true && !packageJson.files.includes("src")) {
+    packageJson.files.push("src/**/*");
+  }
+  packageJson.publishConfig ??= {
+    access: "public"
+  };
+  packageJson.description ??= workspacePackageJson.description;
+  packageJson.homepage ??= workspacePackageJson.homepage;
+  packageJson.bugs ??= workspacePackageJson.bugs;
+  packageJson.license ??= workspacePackageJson.license;
+  packageJson.keywords ??= workspacePackageJson.keywords;
+  packageJson.funding ??= workspacePackageJson.funding;
+  packageJson.author ??= workspacePackageJson.author;
+  packageJson.maintainers ??= workspacePackageJson.maintainers;
+  if (!packageJson.maintainers && packageJson.author) {
+    packageJson.maintainers = [
+      packageJson.author
+    ];
+  }
+  packageJson.contributors ??= workspacePackageJson.contributors;
+  if (!packageJson.contributors && packageJson.author) {
+    packageJson.contributors = [
+      packageJson.author
+    ];
+  }
+  packageJson.repository ??= workspacePackageJson.repository;
+  packageJson.repository.directory ??= projectRoot ? projectRoot : _chunk36OA7HRFcjs.joinPaths.call(void 0, "packages", projectName);
+  return packageJson;
+}, "addWorkspacePackageJsonFields");
+var addPackageJsonExport = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (file, type = "module", sourceRoot) => {
+  let entry = file.replaceAll("\\", "/");
+  if (sourceRoot) {
+    entry = entry.replace(sourceRoot, "");
+  }
+  return {
+    "import": {
+      "types": `./dist/${entry}.d.${type === "module" ? "ts" : "mts"}`,
+      "default": `./dist/${entry}.${type === "module" ? "js" : "mjs"}`
+    },
+    "require": {
+      "types": `./dist/${entry}.d.${type === "commonjs" ? "ts" : "cts"}`,
+      "default": `./dist/${entry}.${type === "commonjs" ? "js" : "cjs"}`
+    },
+    "default": {
+      "types": `./dist/${entry}.d.ts`,
+      "default": `./dist/${entry}.js`
+    }
+  };
+}, "addPackageJsonExport");
+var addPackageJsonExports = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, async (sourceRoot, packageJson) => {
+  packageJson.exports ??= {};
+  const files = await new (0, _glob.Glob)("**/*.{ts,tsx}", {
+    absolute: false,
+    cwd: sourceRoot,
+    root: sourceRoot
+  }).walk();
+  files.forEach((file) => {
+    addPackageJsonExport(file, packageJson.type, sourceRoot);
+    const split = file.split(".");
+    split.pop();
+    const entry = split.join(".").replaceAll("\\", "/");
+    packageJson.exports[`./${entry}`] ??= addPackageJsonExport(entry, packageJson.type, sourceRoot);
+  });
+  packageJson.main = packageJson.type === "commonjs" ? "./dist/index.js" : "./dist/index.cjs";
+  packageJson.module = packageJson.type === "module" ? "./dist/index.js" : "./dist/index.mjs";
+  packageJson.types = "./dist/index.d.ts";
+  packageJson.exports ??= {};
+  packageJson.exports = Object.keys(packageJson.exports).reduce((ret, key) => {
+    if (key.endsWith("/index") && !ret[key.replace("/index", "")]) {
+      ret[key.replace("/index", "")] = packageJson.exports[key];
+    }
+    return ret;
+  }, packageJson.exports);
+  packageJson.exports["./package.json"] ??= "./package.json";
+  packageJson.exports["."] = _nullishCoalesce(packageJson.exports["."], () => ( addPackageJsonExport("index", packageJson.type, sourceRoot)));
+  return packageJson;
+}, "addPackageJsonExports");
+
+// ../build-tools/src/utilities/get-entry-points.ts
+
+
+// ../build-tools/src/utilities/task-graph.ts
+var _createtaskgraph = require('nx/src/tasks-runner/create-task-graph');
+
+// src/build.ts
+
+var _jiti = require('jiti');
+
+
+
+var _findworkspaceroot = require('nx/src/utils/find-workspace-root');
+
+// ../../node_modules/.pnpm/unbuild@3.3.1_sass@1.83.4_typescript@5.7.3/node_modules/unbuild/dist/shared/unbuild.B2_7OVir.mjs
+
+
+var _pathe = require('pathe');
+var _utils = require('consola/utils');
+var _consola = require('consola'); var _consola2 = _interopRequireDefault(_consola);
+
+var _hookable = require('hookable');
+var _prettybytes = require('pretty-bytes'); var _prettybytes2 = _interopRequireDefault(_prettybytes);
+var _tinyglobby = require('tinyglobby');
+
+
+var _rollup = require('rollup');
+var _rollupplugindts = require('rollup-plugin-dts'); var _rollupplugindts2 = _interopRequireDefault(_rollupplugindts);
+var _plugincommonjs = require('@rollup/plugin-commonjs'); var _plugincommonjs2 = _interopRequireDefault(_plugincommonjs);
+var _pluginnoderesolve = require('@rollup/plugin-node-resolve');
+var _pluginalias = require('@rollup/plugin-alias'); var _pluginalias2 = _interopRequireDefault(_pluginalias);
+var _pluginreplace = require('@rollup/plugin-replace'); var _pluginreplace2 = _interopRequireDefault(_pluginreplace);
+var _utils3 = require('pathe/utils');
+var _mlly = require('mlly');
+var _esbuild = require('esbuild');
+var _pluginutils = require('@rollup/pluginutils');
+var _pluginjson = require('@rollup/plugin-json'); var _pluginjson2 = _interopRequireDefault(_pluginjson);
+var _magicstring = require('magic-string'); var _magicstring2 = _interopRequireDefault(_magicstring);
+var _untyped = require('untyped');
+var _babelplugin = require('untyped/babel-plugin'); var _babelplugin2 = _interopRequireDefault(_babelplugin);
+var _scule = require('scule');
+var _mkdist = require('mkdist');
+function definePreset(preset) {
+  return preset;
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, definePreset, "definePreset");
+var autoPreset = definePreset(() => {
+  return {
+    hooks: {
+      "build:prepare"(ctx) {
+        if (!ctx.pkg || ctx.options.entries.length > 0) {
+          return;
+        }
+        const sourceFiles = listRecursively(_pathe.join.call(void 0, 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;
+        }
+        _consola.consola.info(
+          "Automatically detected entries:",
+          _utils.colors.cyan(
+            ctx.options.entries.map(
+              (e) => _utils.colors.bold(
+                e.input.replace(ctx.options.rootDir + "/", "").replace(/\/$/, "/*")
+              )
+            ).join(", ")
+          ),
+          _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 _optionalChain([sourceFiles, 'access', _44 => _44.find, 'call', _45 => _45((i) => SOURCE_RE.test(i)), 'optionalAccess', _46 => _46.replace, 'call', _47 => _47(/(\.d\.(m|c)?ts|\.\w+)$/, "")]);
+    }, void 0);
+    if (!input) {
+      if (!_fs.existsSync.call(void 0, _pathe.resolve.call(void 0, 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 };
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, inferEntries, "inferEntries");
+var getEntrypointPaths = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (path2) => {
+  const segments = _pathe.normalize.call(void 0, path2).split("/");
+  return segments.map((_, index) => segments.slice(index).join("/")).filter(Boolean);
+}, "getEntrypointPaths");
+async function ensuredir(path2) {
+  await _promises2.default.mkdir(_pathe.dirname.call(void 0, path2), { recursive: true });
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, ensuredir, "ensuredir");
+function warn(ctx, message) {
+  if (ctx.warnings.has(message)) {
+    return;
+  }
+  _consola.consola.debug("[unbuild] [warn]", message);
+  ctx.warnings.add(message);
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, warn, "warn");
+async function symlink(from, to, force = true) {
+  await ensuredir(to);
+  if (force) {
+    await _promises2.default.unlink(to).catch(() => {
+    });
+  }
+  await _promises2.default.symlink(from, to, "junction");
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, symlink, "symlink");
+function dumpObject(obj) {
+  return "{ " + Object.keys(obj).map((key) => `${key}: ${JSON.stringify(obj[key])}`).join(", ") + " }";
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, dumpObject, "dumpObject");
+function getpkg(id = "") {
+  const s = id.split("/");
+  return s[0][0] === "@" ? `${s[0]}/${s[1]}` : s[0];
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, getpkg, "getpkg");
+async function rmdir(dir) {
+  await _promises2.default.unlink(dir).catch(() => {
+  });
+  await _promises2.default.rm(dir, { recursive: true, force: true }).catch(() => {
+  });
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, rmdir, "rmdir");
+function listRecursively(path2) {
+  const filenames = /* @__PURE__ */ new Set();
+  const walk = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (path22) => {
+    const files = _fs.readdirSync.call(void 0, path22);
+    for (const file of files) {
+      const fullPath = _pathe.resolve.call(void 0, path22, file);
+      if (_fs.statSync.call(void 0, fullPath).isDirectory()) {
+        filenames.add(fullPath + "/");
+        walk(fullPath);
+      } else {
+        filenames.add(fullPath);
+      }
+    }
+  }, "walk");
+  walk(path2);
+  return [...filenames];
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, listRecursively, "listRecursively");
+async function resolvePreset(preset, rootDir) {
+  if (preset === "auto") {
+    preset = autoPreset;
+  } else if (typeof preset === "string") {
+    preset = await _jiti.createJiti.call(void 0, rootDir, { interopDefault: true }).import(preset, {
+      default: true
+    }) || {};
+  }
+  if (typeof preset === "function") {
+    preset = preset();
+  }
+  return preset;
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, 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);
+    }
+  }
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, inferExportType, "inferExportType");
+function extractExportFilenames(exports, conditions = []) {
+  if (!exports) {
+    return [];
+  }
+  if (typeof exports === "string") {
+    return [{ file: exports, type: "esm" }];
+  }
+  return Object.entries(exports).filter(([subpath]) => !subpath.endsWith(".json")).flatMap(
+    ([condition, exports2]) => typeof exports2 === "string" ? {
+      file: exports2,
+      type: inferExportType(condition, conditions, exports2)
+    } : extractExportFilenames(exports2, [...conditions, condition])
+  );
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, extractExportFilenames, "extractExportFilenames");
+function arrayIncludes(arr, searchElement) {
+  return arr.some(
+    (entry) => entry instanceof RegExp ? entry.test(searchElement) : entry === searchElement
+  );
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, arrayIncludes, "arrayIncludes");
+function removeExtension(filename) {
+  return filename.replace(/\.(js|mjs|cjs|ts|mts|cts|json|jsx|tsx)$/, "");
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, 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)];
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, inferPkgExternals, "inferPkgExternals");
+function pathToRegex(path2) {
+  return path2.includes("*") ? new RegExp(
+    `^${path2.replace(/\./g, String.raw`\.`).replace(/\*/g, ".*")}$`
+  ) : path2;
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, pathToRegex, "pathToRegex");
+function withTrailingSlash(path2) {
+  return path2.endsWith("/") ? path2 : `${path2}/`;
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, 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) => _utils.colors.cyan(id)).join(", ")
+    );
+  }
+  if (implicitDependencies.size > 0 && !ctx.options.rollup.inlineDependencies) {
+    warn(
+      ctx,
+      "Potential implicit dependencies found: " + [...implicitDependencies].map((id) => _utils.colors.cyan(id)).join(", ")
+    );
+  }
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, 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 && _pathe.resolve.call(void 0, rootDir, i.replace(/\/[^/]*\*.*$/, "")))
+  );
+  const missingOutputs = [];
+  for (const filename of filenames) {
+    if (filename && !filename.includes("*") && !_fs.existsSync.call(void 0, filename)) {
+      missingOutputs.push(filename.replace(rootDir + "/", ""));
+    }
+  }
+  if (missingOutputs.length > 0) {
+    warn(
+      ctx,
+      `Potential missing package.json files: ${missingOutputs.map((o) => _utils.colors.cyan(o)).join(", ")}`
+    );
+  }
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, 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 (_optionalChain([output, 'access', _48 => _48.code, 'optionalAccess', _49 => _49.match, 'call', _50 => _50(SHEBANG_RE)])) {
+          const outFile = _pathe.resolve.call(void 0, options.dir, fileName);
+          await makeExecutable(outFile);
+        }
+      }
+    }
+  };
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, shebangPlugin, "shebangPlugin");
+function removeShebangPlugin() {
+  return {
+    name: "unbuild-remove-shebang",
+    renderChunk(code) {
+      return code.replace(SHEBANG_RE, "");
+    }
+  };
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, removeShebangPlugin, "removeShebangPlugin");
+async function makeExecutable(filePath) {
+  await _fs.promises.chmod(
+    filePath,
+    493
+    /* rwx r-x r-x */
+  ).catch(() => {
+  });
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, makeExecutable, "makeExecutable");
+function getShebang(code, append = "\n") {
+  const m = code.match(SHEBANG_RE);
+  return m ? m + append : "";
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, 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__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (id = "") => {
+    return loaders[_pathe.extname.call(void 0, id)];
+  }, "getLoader");
+  const filter = _pluginutils.createFilter.call(void 0, 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 _esbuild.transform.call(void 0, 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 _esbuild.transform.call(void 0, code, {
+        ...esbuildOptions,
+        loader,
+        sourcefile: fileName,
+        minify: true
+      });
+      return {
+        code: result.code || "",
+        map: result.map || null
+      };
+    }
+  };
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, esbuild, "esbuild");
+function printWarnings(id, result, plugin) {
+  if (result.warnings) {
+    for (const warning of result.warnings) {
+      let message = "[esbuild]";
+      if (warning.location) {
+        message += ` (${_pathe.relative.call(void 0, process.cwd(), id)}:${warning.location.line}:${warning.location.column})`;
+      }
+      message += ` ${warning.text}`;
+      plugin.warn(message);
+    }
+  }
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, printWarnings, "printWarnings");
+var EXPORT_DEFAULT = "export default ";
+function JSONPlugin(options) {
+  const plugin = _pluginjson2.default.call(void 0, 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;
+    }
+  };
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, JSONPlugin, "JSONPlugin");
+var defaults = {
+  include: [/\.(md|txt|css|htm|html)$/],
+  exclude: []
+};
+function rawPlugin(opts = {}) {
+  opts = { ...opts, ...defaults };
+  const filter = _pluginutils.createFilter.call(void 0, opts.include, opts.exclude);
+  return {
+    name: "unbuild-raw",
+    transform(code, id) {
+      if (filter(id)) {
+        return {
+          code: `export default ${JSON.stringify(code)}`,
+          map: null
+        };
+      }
+    }
+  };
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, rawPlugin, "rawPlugin");
+function cjsPlugin(_opts) {
+  return {
+    name: "unbuild-cjs",
+    renderChunk(code, _chunk, opts) {
+      if (opts.format === "es") {
+        return CJSToESM(code);
+      }
+      return null;
+    }
+  };
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, 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 || _optionalChain([info, 'access', _51 => _51.exports, 'optionalAccess', _52 => _52.length]) !== 1 || info.exports[0] !== "default") {
+        return;
+      }
+      return code.replace(
+        /(?<=(?<=[;}]|^)\s*export\s*){\s*([\w$]+)\s*as\s+default\s*}/,
+        `= $1`
+      );
+    }
+  };
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, 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 = _mlly.findStaticImports.call(void 0, code).pop();
+  const indexToAppend = lastESMImport ? lastESMImport.end : 0;
+  const s = new (0, _magicstring2.default)(code);
+  s.appendRight(indexToAppend, CJSShim);
+  return {
+    code: s.toString(),
+    map: s.generateMap()
+  };
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, 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;
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, resolveAliases, "resolveAliases");
+function getChunkFilename(ctx, chunk, ext) {
+  if (chunk.isDynamicEntry) {
+    return `chunks/[name].${ext}`;
+  }
+  return `shared/${ctx.options.name}.[hash].${ext}`;
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, 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,
+        _pathe.resolve.call(void 0, ctx.options.rootDir, entry.input)
+      ])
+    ),
+    output: [
+      ctx.options.rollup.emitCJS && {
+        dir: _pathe.resolve.call(void 0, ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].cjs",
+        chunkFileNames: /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (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: _pathe.resolve.call(void 0, ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].mjs",
+        chunkFileNames: /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (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 = _utils3.resolveAlias.call(void 0, originalId, _aliases);
+      const pkgName = _optionalChain([_mlly.parseNodeModulePath.call(void 0, resolvedId), 'optionalAccess', _53 => _53.name]) || _optionalChain([_mlly.parseNodeModulePath.call(void 0, originalId), 'optionalAccess', _54 => _54.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] === "." || _pathe.isAbsolute.call(void 0, 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 && _pluginreplace2.default.call(void 0, {
+        ...ctx.options.rollup.replace,
+        values: {
+          ...ctx.options.replace,
+          ...ctx.options.rollup.replace.values
+        }
+      }),
+      ctx.options.rollup.alias && _pluginalias2.default.call(void 0, {
+        ...ctx.options.rollup.alias,
+        entries: _aliases
+      }),
+      ctx.options.rollup.resolve && _pluginnoderesolve.nodeResolve.call(void 0, {
+        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 && _plugincommonjs2.default.call(void 0, {
+        extensions: DEFAULT_EXTENSIONS,
+        ...ctx.options.rollup.commonjs
+      }),
+      ctx.options.rollup.preserveDynamicImports && {
+        renderDynamicImport() {
+          return { left: "import(", right: ")" };
+        }
+      },
+      ctx.options.rollup.cjsBridge && cjsPlugin(),
+      rawPlugin()
+    ].filter(Boolean)
+  };
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, getRollupOptions, "getRollupOptions");
+async function rollupStub(ctx) {
+  const babelPlugins = _optionalChain([ctx, 'access', _55 => _55.options, 'access', _56 => _56.stubOptions, 'access', _57 => _57.jiti, 'access', _58 => _58.transformOptions, 'optionalAccess', _59 => _59.babel, 'optionalAccess', _60 => _60.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: {
+          ..._optionalChain([ctx, 'access', _61 => _61.options, 'access', _62 => _62.stubOptions, 'access', _63 => _63.jiti, 'access', _64 => _64.transformOptions, 'optionalAccess', _65 => _65.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 = _pathe.resolve.call(void 0, 
+      ctx.options.rootDir,
+      ctx.options.outDir,
+      entry.name
+    );
+    const isESM = ctx.pkg.type === "module";
+    const resolvedEntry = _mlly.fileURLToPath.call(void 0, ctx.jiti.esmResolve(entry.input));
+    const resolvedEntryWithoutExt = resolvedEntry.slice(
+      0,
+      Math.max(0, resolvedEntry.length - _pathe.extname.call(void 0, resolvedEntry).length)
+    );
+    const resolvedEntryForTypeImport = isESM ? `${resolvedEntry.replace(/(\.m?)(ts)$/, "$1js")}` : resolvedEntryWithoutExt;
+    const code = await _fs.promises.readFile(resolvedEntry, "utf8");
+    const shebang = getShebang(code);
+    await _promises.mkdir.call(void 0, _pathe.dirname.call(void 0, output), { recursive: true });
+    if (ctx.options.rollup.emitCJS) {
+      const jitiCJSPath = _pathe.relative.call(void 0, 
+        _pathe.dirname.call(void 0, output),
+        await _mlly.resolvePath.call(void 0, "jiti", {
+          url: _chunkYDYGZTJKcjs.importMetaUrl,
+          conditions: ["node", "require"]
+        })
+      );
+      await _promises.writeFile.call(void 0, 
+        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 _mlly.resolveModuleExportNames.call(void 0, 
+      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 = _pathe.relative.call(void 0, 
+      _pathe.dirname.call(void 0, output),
+      await _mlly.resolvePath.call(void 0, "jiti", {
+        url: _chunkYDYGZTJKcjs.importMetaUrl,
+        conditions: ["node", "import"]
+      })
+    );
+    await _promises.writeFile.call(void 0, 
+      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 _promises.writeFile.call(void 0, output + ".d.cts", dtsContent);
+      await _promises.writeFile.call(void 0, output + ".d.mts", dtsContent);
+      if (ctx.options.declaration === "compatible" || ctx.options.declaration === true) {
+        await _promises.writeFile.call(void 0, output + ".d.ts", dtsContent);
+      }
+    }
+    if (shebang) {
+      await makeExecutable(output + ".cjs");
+      await makeExecutable(output + ".mjs");
+    }
+  }
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, rollupStub, "rollupStub");
+function rollupWatch(rollupOptions) {
+  const watcher = _rollup.watch.call(void 0, 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 || {});
+  }
+  _consola2.default.info(
+    `[unbuild] [rollup] Starting watchers for entries: ${inputs.map((input) => "./" + _pathe.relative.call(void 0, process.cwd(), input)).join(", ")}`
+  );
+  _consola2.default.warn(
+    "[unbuild] [rollup] Watch mode is experimental and may be unstable"
+  );
+  watcher.on("change", (id, { event }) => {
+    _consola2.default.info(`${_utils.colors.cyan(_pathe.relative.call(void 0, ".", id))} was ${event}d`);
+  });
+  watcher.on("restart", () => {
+    _consola2.default.info(_utils.colors.gray("[unbuild] [rollup] Rebuilding bundle"));
+  });
+  watcher.on("event", (event) => {
+    if (event.code === "END") {
+      _consola2.default.success(_utils.colors.green("[unbuild] [rollup] Rebuild finished\n"));
+    }
+  });
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, 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 _rollup.rollup.call(void 0, 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) {
+      _consola2.default.warn("`rollup` DTS builder does not support watch mode yet.");
+    }
+    return;
+  }
+  if (ctx.options.declaration) {
+    rollupOptions.plugins = [
+      ...rollupOptions.plugins,
+      _rollupplugindts2.default.call(void 0, ctx.options.rollup.dts),
+      removeShebangPlugin(),
+      ctx.options.rollup.emitCJS && fixCJSExportTypePlugin()
+    ].filter(Boolean);
+    await ctx.hooks.callHook("rollup:dts:options", ctx, rollupOptions);
+    const typesBuild2 = await _rollup.rollup.call(void 0, rollupOptions);
+    await ctx.hooks.callHook("rollup:dts:build", ctx, typesBuild2);
+    if (ctx.options.rollup.emitCJS) {
+      await typesBuild2.write({
+        dir: _pathe.resolve.call(void 0, ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].d.cts",
+        chunkFileNames: /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (chunk) => getChunkFilename(ctx, chunk, "d.cts"), "chunkFileNames")
+      });
+    }
+    await typesBuild2.write({
+      dir: _pathe.resolve.call(void 0, ctx.options.rootDir, ctx.options.outDir),
+      entryFileNames: "[name].d.mts",
+      chunkFileNames: /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (chunk) => getChunkFilename(ctx, chunk, "d.mts"), "chunkFileNames")
+    });
+    if (ctx.options.declaration === true || ctx.options.declaration === "compatible") {
+      await typesBuild2.write({
+        dir: _pathe.resolve.call(void 0, ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].d.ts",
+        chunkFileNames: /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (chunk) => getChunkFilename(ctx, chunk, "d.ts"), "chunkFileNames")
+      });
+    }
+  }
+  await ctx.hooks.callHook("rollup:done", ctx);
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, 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: [_babelplugin2.default]
+          }
+        }
+      }
+    };
+    await ctx.hooks.callHook("untyped:entry:options", ctx, entry, options);
+    const untypedJiti = _jiti.createJiti.call(void 0, ctx.options.rootDir, options.jiti);
+    const distDir = entry.outDir;
+    let rawSchema = await untypedJiti.import(_pathe.resolve.call(void 0, 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 _untyped.resolveSchema.call(void 0, rawSchema, defaults2);
+    await ctx.hooks.callHook("untyped:entry:schema", ctx, entry, schema);
+    const outputs = {
+      markdown: {
+        fileName: _pathe.resolve.call(void 0, distDir, `${entry.name}.md`),
+        contents: _untyped.generateMarkdown.call(void 0, 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: _untyped.generateTypes.call(void 0, schema, {
+          interfaceName: _scule.pascalCase.call(void 0, 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 _promises.writeFile.call(void 0, 
+        _pathe.resolve.call(void 0, distDir, output.fileName),
+        output.contents,
+        "utf8"
+      );
+    }
+  }
+  await ctx.hooks.callHook("untyped:done", ctx);
+  if (entries.length > 0 && ctx.options.watch) {
+    _consola2.default.warn("`untyped` builder does not support watch mode yet.");
+  }
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, 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 _mkdist.mkdist.call(void 0, mkdistOptions);
+      ctx.buildEntries.push({
+        path: distDir,
+        chunks: output.writtenFiles.map((p) => _pathe.relative.call(void 0, 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 \`${_pathe.relative.call(void 0, 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) {
+    _consola2.default.warn("`mkdist` builder does not support watch mode yet.");
+  }
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, mkdistBuild, "mkdistBuild");
+var copy = _fs.promises.cp || _fs.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 _tinyglobby.glob.call(void 0, patterns, {
+        cwd: _pathe.resolve.call(void 0, ctx.options.rootDir, entry.input),
+        absolute: false
+      });
+      const outputList = await Promise.allSettled(
+        paths.map(async (path2) => {
+          const src = _pathe.resolve.call(void 0, ctx.options.rootDir, entry.input, path2);
+          const dist = _pathe.resolve.call(void 0, ctx.options.rootDir, distDir, path2);
+          await copy(src, dist);
+          return dist;
+        })
+      );
+      for (const output of outputList) {
+        if (output.status === "rejected") {
+          warn(ctx, output.reason);
+        }
+      }
+      ctx.buildEntries.push({
+        path: distDir,
+        chunks: outputList.filter(({ status }) => status === "fulfilled").map(
+          (p) => _pathe.relative.call(void 0, 
+            ctx.options.outDir,
+            p.value
+          )
+        )
+      });
+    }
+  }
+  await ctx.hooks.callHook("copy:done", ctx);
+  if (entries.length > 0 && ctx.options.watch) {
+    _consola2.default.warn("`untyped` builder does not support watch mode yet.");
+  }
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, copyBuild, "copyBuild");
+async function build(rootDir, stub, inputConfig = {}) {
+  rootDir = _pathe.resolve.call(void 0, process.cwd(), rootDir || ".");
+  const jiti = _jiti.createJiti.call(void 0, rootDir);
+  const _buildConfig = await jiti.import(_optionalChain([inputConfig, 'optionalAccess', _66 => _66.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
+    );
+  }
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, build, "build");
+async function _build(rootDir, inputConfig = {}, buildConfig, pkg, cleanedDirs, _stubMode, _watchMode) {
+  const preset = await resolvePreset(
+    buildConfig.preset || _optionalChain([pkg, 'access', _67 => _67.unbuild, 'optionalAccess', _68 => _68.preset]) || _optionalChain([pkg, 'access', _69 => _69.build, 'optionalAccess', _70 => _70.preset]) || inputConfig.preset || "auto",
+    rootDir
+  );
+  const options = _defu.defu.call(void 0, 
+    buildConfig,
+    pkg.unbuild || pkg.build,
+    inputConfig,
+    preset,
+    {
+      name: (_optionalChain([pkg, 'optionalAccess', _71 => _71.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: [
+        ..._module2.default.builtinModules,
+        ..._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 = _pathe.resolve.call(void 0, options.rootDir, options.outDir);
+  const jiti = _jiti.createJiti.call(void 0, options.rootDir, { interopDefault: true });
+  const ctx = {
+    options,
+    jiti,
+    warnings: /* @__PURE__ */ new Set(),
+    pkg,
+    buildEntries: [],
+    usedImports: /* @__PURE__ */ new Set(),
+    hooks: _hookable.createHooks.call(void 0, )
+  };
+  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 = _pathe.isAbsolute.call(void 0, entry.input) ? _pathe.relative.call(void 0, rootDir, entry.input) : _pathe.normalize.call(void 0, 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 = _pathe.resolve.call(void 0, options.rootDir, entry.input);
+    entry.outDir = _pathe.resolve.call(void 0, 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);
+  _consola.consola.info(
+    _utils.colors.cyan(`${options.stub ? "Stubbing" : "Building"} ${options.name}`)
+  );
+  if (process.env.DEBUG) {
+    _consola.consola.info(`${_utils.colors.bold("Root dir:")} ${options.rootDir}
+  ${_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);
+      _consola.consola.info(
+        `Cleaning dist directory: \`./${_pathe.relative.call(void 0, process.cwd(), dir)}\``
+      );
+      await rmdir(dir);
+      await _fs.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;
+  }
+  _consola.consola.success(_utils.colors.green("Build succeeded for " + options.name));
+  const outFiles = await _tinyglobby.glob.call(void 0, ["**"], { 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 _fs.promises.stat(_pathe.resolve.call(void 0, options.outDir, file));
+      entry.bytes = stat.size;
+    }
+  }
+  const rPath = /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, (p) => _pathe.relative.call(void 0, process.cwd(), _pathe.resolve.call(void 0, 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 += _optionalChain([ctx, 'access', _72 => _72.buildEntries, 'access', _73 => _73.find, 'call', _74 => _74((e) => e.path === chunk), 'optionalAccess', _75 => _75.bytes]) || 0;
+    }
+    let line = `  ${_utils.colors.bold(rPath(entry.path))} (` + [
+      totalBytes && `total size: ${_utils.colors.cyan(_prettybytes2.default.call(void 0, totalBytes))}`,
+      entry.bytes && `chunk size: ${_utils.colors.cyan(_prettybytes2.default.call(void 0, entry.bytes))}`,
+      _optionalChain([entry, 'access', _76 => _76.exports, 'optionalAccess', _77 => _77.length]) && `exports: ${_utils.colors.gray(entry.exports.join(", "))}`
+    ].filter(Boolean).join(", ") + ")";
+    if (_optionalChain([entry, 'access', _78 => _78.chunks, 'optionalAccess', _79 => _79.length])) {
+      line += "\n" + entry.chunks.map((p) => {
+        const chunk = ctx.buildEntries.find((e) => e.path === p) || {};
+        return _utils.colors.gray(
+          "  \u2514\u2500 " + rPath(p) + _utils.colors.bold(
+            chunk.bytes ? ` (${_prettybytes2.default.call(void 0, _optionalChain([chunk, 'optionalAccess', _80 => _80.bytes]))})` : ""
+          )
+        );
+      }).join("\n");
+    }
+    if (_optionalChain([entry, 'access', _81 => _81.modules, 'optionalAccess', _82 => _82.length])) {
+      line += "\n" + entry.modules.filter((m) => m.id.includes("node_modules")).sort((a, b) => (b.bytes || 0) - (a.bytes || 0)).map((m) => {
+        return _utils.colors.gray(
+          "  \u{1F4E6} " + rPath(m.id) + _utils.colors.bold(m.bytes ? ` (${_prettybytes2.default.call(void 0, m.bytes)})` : "")
+        );
+      }).join("\n");
+    }
+    _consola.consola.log(entry.chunk ? _utils.colors.gray(line) : line);
+  }
+  console.log(
+    "\u03A3 Total dist size (byte size):",
+    _utils.colors.cyan(
+      _prettybytes2.default.call(void 0, ctx.buildEntries.reduce((a, e) => a + (e.bytes || 0), 0))
+    )
+  );
+  validateDependencies(ctx);
+  validatePackage(pkg, rootDir, ctx);
+  await ctx.hooks.callHook("build:done", ctx);
+  _consola.consola.log("");
+  if (ctx.warnings.size > 0) {
+    _consola.consola.warn(
+      "Build is done with some warnings:\n\n" + [...ctx.warnings].map((msg) => "- " + msg).join("\n")
+    );
+    if (ctx.options.failOnWarn) {
+      _consola.consola.error(
+        "Exiting with code (1). You can change this behavior by setting `failOnWarn: false` ."
+      );
+      process.exit(1);
+    }
+  }
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, _build, "_build");
+
+// ../../node_modules/.pnpm/unbuild@3.3.1_sass@1.83.4_typescript@5.7.3/node_modules/unbuild/dist/index.mjs
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// src/build.ts
+async function resolveOptions(options) {
+  const projectRoot = options.projectRoot;
+  if (!projectRoot) {
+    throw new Error("Cannot find project root");
+  }
+  const outputPath = options.outputPath || _chunk36OA7HRFcjs.joinPaths.call(void 0, "dist", projectRoot);
+  const workspaceRoot = _findworkspaceroot.findWorkspaceRoot.call(void 0, projectRoot);
+  if (!workspaceRoot) {
+    throw new Error("Cannot find workspace root");
+  }
+  const config = await loadStormConfig(workspaceRoot.dir);
+  const logger = await createLogger(config);
+  logger.debug("  \u2699\uFE0F   Resolving build options");
+  const stopwatch = logger.getStopwatch("Build options resolution");
+  if (options.configPath) {
+    const configFile = await _chunkLUXNRUAPcjs.loadConfig.call(void 0, options.configPath);
+    if (configFile) {
+      options = _defu2.default.call(void 0, options, configFile);
+    }
+  }
+  const projectGraph = _devkit.readCachedProjectGraph.call(void 0, );
+  const projectJsonPath = _chunk36OA7HRFcjs.joinPaths.call(void 0, config.workspaceRoot, projectRoot, "project.json");
+  if (!_fs.existsSync.call(void 0, projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const projectJsonContent = await _promises.readFile.call(void 0, projectJsonPath, "utf8");
+  const projectJson = JSON.parse(projectJsonContent);
+  const projectName = projectJson.name;
+  const packageJsonPath = _chunk36OA7HRFcjs.joinPaths.call(void 0, workspaceRoot.dir, projectRoot, "package.json");
+  if (!_fs.existsSync.call(void 0, packageJsonPath)) {
+    throw new Error("Cannot find package.json configuration");
+  }
+  const packageJsonContent = await _promises.readFile.call(void 0, packageJsonPath, "utf8");
+  const packageJson = JSON.parse(packageJsonContent);
+  let tsconfig = options.tsconfig;
+  if (!tsconfig) {
+    tsconfig = _chunk36OA7HRFcjs.joinPaths.call(void 0, workspaceRoot.dir, projectRoot, "tsconfig.json");
+  }
+  if (!_fs.existsSync.call(void 0, tsconfig)) {
+    throw new Error("Cannot find tsconfig.json configuration");
+  }
+  let sourceRoot = projectJson.sourceRoot;
+  if (!sourceRoot) {
+    sourceRoot = _chunk36OA7HRFcjs.joinPaths.call(void 0, projectRoot, "src");
+  }
+  if (!_fs.existsSync.call(void 0, sourceRoot)) {
+    throw new Error("Cannot find sourceRoot directory");
+  }
+  const result = _buildablelibsutils.calculateProjectBuildableDependencies.call(void 0, void 0, projectGraph, workspaceRoot.dir, projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  let dependencies = result.dependencies;
+  const tsLibDependency = _js.getHelperDependency.call(void 0, _js.HelperDependency.tsc, tsconfig, dependencies, projectGraph, true);
+  if (tsLibDependency) {
+    dependencies = dependencies.filter((deps) => deps.name !== tsLibDependency.name);
+    dependencies.push(tsLibDependency);
+  }
+  const jiti = _jiti.createJiti.call(void 0, config.workspaceRoot, {
+    fsCache: config.skipCache ? false : _chunk36OA7HRFcjs.joinPaths.call(void 0, config.directories.cache || "node_modules/.cache/storm", "jiti"),
+    interopDefault: true
+  });
+  const resolvedOptions = {
+    name: projectName,
+    config,
+    projectRoot,
+    sourceRoot,
+    projectName,
+    tsconfig,
+    jiti,
+    logger,
+    clean: false,
+    entries: [
+      {
+        builder: "mkdist",
+        input: `.${sourceRoot.replace(projectRoot, "")}`,
+        outDir: _chunk36OA7HRFcjs.joinPaths.call(void 0, _path.relative.call(void 0, _chunk36OA7HRFcjs.joinPaths.call(void 0, config.workspaceRoot, projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
+        declaration: options.emitTypes !== false,
+        format: "esm"
+      },
+      {
+        builder: "mkdist",
+        input: `.${sourceRoot.replace(projectRoot, "")}`,
+        outDir: _chunk36OA7HRFcjs.joinPaths.call(void 0, _path.relative.call(void 0, _chunk36OA7HRFcjs.joinPaths.call(void 0, config.workspaceRoot, projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
+        declaration: options.emitTypes !== false,
+        format: "cjs",
+        ext: "cjs"
+      }
+    ],
+    declaration: options.emitTypes !== false ? "compatible" : false,
+    failOnWarn: false,
+    sourcemap: _nullishCoalesce(options.sourcemap, () => ( !!options.debug)),
+    outDir: outputPath,
+    parallel: true,
+    stub: false,
+    stubOptions: {
+      jiti: {}
+    },
+    externals: _nullishCoalesce(options.external, () => ( [])),
+    dependencies: [],
+    peerDependencies: [],
+    devDependencies: [],
+    hooks: {},
+    alias: {},
+    replace: {},
+    rollup: {
+      replace: {},
+      alias: {},
+      json: {},
+      commonjs: {
+        sourceMap: _nullishCoalesce(options.sourcemap, () => ( true))
+      },
+      emitCJS: true,
+      cjsBridge: true,
+      dts: {
+        respectExternal: true,
+        tsconfig
+      },
+      output: {
+        banner: options.banner || `
+//      \u26A1 Built by Storm Software
+  `,
+        footer: options.footer
+      },
+      resolve: {
+        preferBuiltins: true,
+        extensions: [
+          ".cjs",
+          ".mjs",
+          ".js",
+          ".jsx",
+          ".ts",
+          ".tsx",
+          ".json"
+        ]
+      },
+      esbuild: {
+        minify: options.minify !== false,
+        splitting: options.splitting !== false,
+        treeShaking: options.treeShaking !== false,
+        color: true,
+        logLevel: config.logLevel === _chunk36OA7HRFcjs.LogLevelLabel.FATAL ? _chunk36OA7HRFcjs.LogLevelLabel.ERROR : _chunk36OA7HRFcjs.isVerbose.call(void 0, ) ? "verbose" : config.logLevel
+      }
+    }
+  };
+  dependencies = dependencies.filter((dep) => dep.node.type === "npm" || dep.node.type === "lib" || dep.node.type === "app");
+  if (dependencies.length > 0) {
+    resolvedOptions.dependencies = dependencies.map((dep) => dep.name);
+  }
+  if (packageJson.devDependencies) {
+    resolvedOptions.devDependencies = Object.keys(packageJson.devDependencies);
+  }
+  if (packageJson.peerDependencies) {
+    resolvedOptions.peerDependencies = Object.keys(packageJson.peerDependencies);
+  }
+  if (options.rollup) {
+    let rollup2 = {};
+    if (typeof options.rollup === "string") {
+      const rollupFile = await _chunkLUXNRUAPcjs.loadConfig.call(void 0, options.rollup);
+      if (rollupFile) {
+        rollup2 = rollupFile;
+      }
+    } else {
+      rollup2 = options.rollup;
+    }
+    resolvedOptions.rollup = _defu2.default.call(void 0, _nullishCoalesce(resolvedOptions.rollup, () => ( {})), rollup2);
+  }
+  resolvedOptions.hooks = {
+    "rollup:options": /* @__PURE__ */ _chunkYDYGZTJKcjs.__name.call(void 0, async (ctx, opts) => {
+      opts.plugins = await _asyncNullishCoalesce(options.plugins, async () => ( await _chunkADWBQYE6cjs.getDefaultBuildPlugins.call(void 0, options, resolvedOptions)));
+    }, "rollup:options")
+  };
+  stopwatch();
+  return resolvedOptions;
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, resolveOptions, "resolveOptions");
+async function generatePackageJson(options) {
+  if (options.generatePackageJson !== false && _fs.existsSync.call(void 0, _chunk36OA7HRFcjs.joinPaths.call(void 0, options.projectRoot, "package.json"))) {
+    options.logger.debug("  \u270D\uFE0F   Writing package.json file");
+    const stopwatch = options.logger.getStopwatch("Write package.json file");
+    const packageJsonPath = _chunk36OA7HRFcjs.joinPaths.call(void 0, options.projectRoot, "project.json");
+    if (!_fs.existsSync.call(void 0, packageJsonPath)) {
+      throw new Error("Cannot find package.json configuration");
+    }
+    let packageJsonContent = await _promises.readFile.call(void 0, _chunk36OA7HRFcjs.joinPaths.call(void 0, options.config.workspaceRoot, options.projectRoot, "package.json"), "utf8");
+    if (!packageJsonContent) {
+      throw new Error("Cannot find package.json configuration file");
+    }
+    let packageJson = JSON.parse(packageJsonContent);
+    packageJson = await addPackageDependencies(options.config.workspaceRoot, options.projectRoot, options.projectName, packageJson);
+    packageJson = await addWorkspacePackageJsonFields(options.config, options.projectRoot, options.sourceRoot, options.projectName, false, packageJson);
+    await _devkit.writeJsonFile.call(void 0, _chunk36OA7HRFcjs.joinPaths.call(void 0, options.outDir, "package.json"), await addPackageJsonExports(options.sourceRoot, packageJson));
+    stopwatch();
+  }
+  return options;
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, generatePackageJson, "generatePackageJson");
+async function executeUnbuild(options) {
+  options.logger.debug(`  \u{1F680}  Running ${options.name} (${options.projectRoot}) build`);
+  const stopwatch = options.logger.getStopwatch(`${options.name} (${options.projectRoot}) build`);
+  try {
+    await build(options.projectRoot, false, {
+      ...options,
+      rootDir: options.projectRoot
+    });
+  } finally {
+    stopwatch();
+  }
+  return options;
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, executeUnbuild, "executeUnbuild");
+async function copyBuildAssets(options) {
+  options.logger.debug(`  \u{1F4CB}  Copying asset files to output directory: ${options.outDir}`);
+  const stopwatch = options.logger.getStopwatch(`${options.name} asset copy`);
+  await copyAssets(options.config, _nullishCoalesce(options.assets, () => ( [])), options.outDir, options.projectRoot, options.projectName, options.sourceRoot, options.generatePackageJson, options.includeSrc);
+  stopwatch();
+  return options;
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, copyBuildAssets, "copyBuildAssets");
+async function cleanOutputPath(options) {
+  if (options.clean !== false && options.outDir) {
+    options.logger.debug(` \u{1F9F9}  Cleaning ${options.name} output path: ${options.outDir}`);
+    const stopwatch = options.logger.getStopwatch(`${options.name} output clean`);
+    await _chunkKUMAH6IZcjs.cleanDirectories.call(void 0, options.name, options.outDir, options.config);
+    stopwatch();
+  }
+  return options;
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, cleanOutputPath, "cleanOutputPath");
+async function build2(options) {
+  const resolvedOptions = await resolveOptions(options);
+  resolvedOptions.logger.debug(` \u26A1  Executing Storm Unbuild pipeline`);
+  const stopwatch = resolvedOptions.logger.getStopwatch("Unbuild pipeline");
+  try {
+    await cleanOutputPath(resolvedOptions);
+    await generatePackageJson(resolvedOptions);
+    await executeUnbuild(resolvedOptions);
+    await copyBuildAssets(resolvedOptions);
+    resolvedOptions.logger.success(`  \u{1F3C1}  The ${resolvedOptions.name} build completed successfully`);
+  } catch (error) {
+    resolvedOptions.logger.fatal("  \u274C  Fatal errors occurred during the build that could not be recovered from. The build process has been terminated.");
+    throw error;
+  } finally {
+    stopwatch();
+  }
+}
+_chunkYDYGZTJKcjs.__name.call(void 0, build2, "build");
+
+
+
+exports.build = build2;