@nasti-toolchain/nasti 2.5.0 → 2.5.1

package/dist/cli.cjs

@@ -5,16 +5,25 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __glob = (map) => (path19) => {
-  var fn = map[path19];
+var __glob = (map) => (path21) => {
+  var fn = map[path21];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path19);
+  throw new Error("Module not found in bundle: " + path21);
 };
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -62,7 +71,7 @@ function createLogger(level = "info", options = {}) {
   const canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI;
   const clear = canClearScreen ? clearScreen : () => {
   };
-  function format(type, msg, options2 = {}) {
+  function format2(type, msg, options2 = {}) {
     if (options2.timestamp) {
       const tag = type === "info" ? import_picocolors.default.cyan(import_picocolors.default.bold(prefix)) : type === "warn" ? import_picocolors.default.yellow(import_picocolors.default.bold(prefix)) : import_picocolors.default.red(import_picocolors.default.bold(prefix));
       return `${import_picocolors.default.dim(timeFormatter.format(/* @__PURE__ */ new Date()))} ${tag} ${msg}`;
@@ -79,16 +88,16 @@ function createLogger(level = "info", options = {}) {
       if (type === lastType && msg === lastMsg) {
         sameCount++;
         clear();
-        console_[method](format(type, msg, options2), import_picocolors.default.yellow(`(x${sameCount + 1})`));
+        console_[method](format2(type, msg, options2), import_picocolors.default.yellow(`(x${sameCount + 1})`));
       } else {
         sameCount = 0;
         lastMsg = msg;
         lastType = type;
         if (options2.clear) clear();
-        console_[method](format(type, msg, options2));
+        console_[method](format2(type, msg, options2));
       }
     } else {
-      console_[method](format(type, msg, options2));
+      console_[method](format2(type, msg, options2));
     }
   }
   const warnedMessages = /* @__PURE__ */ new Set();
@@ -2322,8 +2331,8 @@ function rewriteExternalRequires(code, baseDir, root) {
 }
 async function injectCjsNamedExports(code, entryFile) {
   try {
-    const { createRequire: createRequire7 } = await import("module");
-    const req = createRequire7(entryFile);
+    const { createRequire: createRequire6 } = await import("module");
+    const req = createRequire6(entryFile);
     const cjsExports = req(entryFile);
     if (!cjsExports || typeof cjsExports !== "object" && typeof cjsExports !== "function" || Array.isArray(cjsExports)) return code;
     const namedKeys = Object.keys(cjsExports).filter(
@@ -3323,27 +3332,27 @@ var require_process = __commonJS({
 var require_filesystem = __commonJS({
   "node_modules/detect-libc/lib/filesystem.js"(exports2, module2) {
     "use strict";
-    var fs14 = require("fs");
+    var fs15 = require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync = (path19) => {
-      const fd = fs14.openSync(path19, "r");
+    var readFileSync = (path21) => {
+      const fd = fs15.openSync(path21, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs14.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs14.close(fd, () => {
+      const bytesRead = fs15.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs15.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
-    var readFile = (path19) => new Promise((resolve, reject) => {
-      fs14.open(path19, "r", (err, fd) => {
+    var readFile = (path21) => new Promise((resolve, reject) => {
+      fs15.open(path21, "r", (err, fd) => {
         if (err) {
           reject(err);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
-          fs14.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+          fs15.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
             resolve(buffer.subarray(0, bytesRead));
-            fs14.close(fd, () => {
+            fs15.close(fd, () => {
             });
           });
         }
@@ -3455,11 +3464,11 @@ var require_detect_libc = __commonJS({
       }
       return null;
     };
-    var familyFromInterpreterPath = (path19) => {
-      if (path19) {
-        if (path19.includes("/ld-musl-")) {
+    var familyFromInterpreterPath = (path21) => {
+      if (path21) {
+        if (path21.includes("/ld-musl-")) {
           return MUSL;
-        } else if (path19.includes("/ld-linux-")) {
+        } else if (path21.includes("/ld-linux-")) {
           return GLIBC;
         }
       }
@@ -3506,8 +3515,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = await readFile(SELF_PATH);
-        const path19 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path19);
+        const path21 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path21);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -3519,8 +3528,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = readFileSync(SELF_PATH);
-        const path19 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path19);
+        const path21 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path21);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -4542,8 +4551,8 @@ function vuePlugin(config, environmentName = "client") {
       let cached2 = descriptorCache.get(filePath);
       if (!cached2) {
         try {
-          const fs14 = await import("fs");
-          const rawSource = fs14.readFileSync(filePath, "utf-8");
+          const fs15 = await import("fs");
+          const rawSource = fs15.readFileSync(filePath, "utf-8");
           const transformedSfc = await applySourceTransform(
             vueOptions.transformSfc,
             rawSource,
@@ -4967,6 +4976,1310 @@ var init_builtins = __esm({
   }
 });
 
+// node_modules/import-meta-resolve/lib/errors.js
+function formatList(array, type = "and") {
+  return array.length < 3 ? array.join(` ${type} `) : `${array.slice(0, -1).join(", ")}, ${type} ${array[array.length - 1]}`;
+}
+function createError(sym, value, constructor) {
+  messages.set(sym, value);
+  return makeNodeErrorWithCode(constructor, sym);
+}
+function makeNodeErrorWithCode(Base, key) {
+  return NodeError;
+  function NodeError(...parameters) {
+    const limit = Error.stackTraceLimit;
+    if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;
+    const error = new Base();
+    if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = limit;
+    const message = getMessage(key, parameters, error);
+    Object.defineProperties(error, {
+      // Note: no need to implement `kIsNodeError` symbol, would be hard,
+      // probably.
+      message: {
+        value: message,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      },
+      toString: {
+        /** @this {Error} */
+        value() {
+          return `${this.name} [${key}]: ${this.message}`;
+        },
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    captureLargerStackTrace(error);
+    error.code = key;
+    return error;
+  }
+}
+function isErrorStackTraceLimitWritable() {
+  try {
+    if (import_node_v8.default.startupSnapshot.isBuildingSnapshot()) {
+      return false;
+    }
+  } catch {
+  }
+  const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+  if (desc === void 0) {
+    return Object.isExtensible(Error);
+  }
+  return own.call(desc, "writable") && desc.writable !== void 0 ? desc.writable : desc.set !== void 0;
+}
+function hideStackFrames(wrappedFunction) {
+  const hidden = nodeInternalPrefix + wrappedFunction.name;
+  Object.defineProperty(wrappedFunction, "name", { value: hidden });
+  return wrappedFunction;
+}
+function getMessage(key, parameters, self) {
+  const message = messages.get(key);
+  import_node_assert.default.ok(message !== void 0, "expected `message` to be found");
+  if (typeof message === "function") {
+    import_node_assert.default.ok(
+      message.length <= parameters.length,
+      // Default options do not count.
+      `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${message.length}).`
+    );
+    return Reflect.apply(message, self, parameters);
+  }
+  const regex = /%[dfijoOs]/g;
+  let expectedLength = 0;
+  while (regex.exec(message) !== null) expectedLength++;
+  import_node_assert.default.ok(
+    expectedLength === parameters.length,
+    `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${expectedLength}).`
+  );
+  if (parameters.length === 0) return message;
+  parameters.unshift(message);
+  return Reflect.apply(import_node_util.format, null, parameters);
+}
+function determineSpecificType(value) {
+  if (value === null || value === void 0) {
+    return String(value);
+  }
+  if (typeof value === "function" && value.name) {
+    return `function ${value.name}`;
+  }
+  if (typeof value === "object") {
+    if (value.constructor && value.constructor.name) {
+      return `an instance of ${value.constructor.name}`;
+    }
+    return `${(0, import_node_util.inspect)(value, { depth: -1 })}`;
+  }
+  let inspected = (0, import_node_util.inspect)(value, { colors: false });
+  if (inspected.length > 28) {
+    inspected = `${inspected.slice(0, 25)}...`;
+  }
+  return `type ${typeof value} (${inspected})`;
+}
+var import_node_v8, import_node_assert, import_node_util, own, classRegExp, kTypes, codes, messages, nodeInternalPrefix, userStackTraceLimit, captureLargerStackTrace;
+var init_errors = __esm({
+  "node_modules/import-meta-resolve/lib/errors.js"() {
+    "use strict";
+    import_node_v8 = __toESM(require("v8"), 1);
+    import_node_assert = __toESM(require("assert"), 1);
+    import_node_util = require("util");
+    own = {}.hasOwnProperty;
+    classRegExp = /^([A-Z][a-z\d]*)+$/;
+    kTypes = /* @__PURE__ */ new Set([
+      "string",
+      "function",
+      "number",
+      "object",
+      // Accept 'Function' and 'Object' as alternative to the lower cased version.
+      "Function",
+      "Object",
+      "boolean",
+      "bigint",
+      "symbol"
+    ]);
+    codes = {};
+    messages = /* @__PURE__ */ new Map();
+    nodeInternalPrefix = "__node_internal_";
+    codes.ERR_INVALID_ARG_TYPE = createError(
+      "ERR_INVALID_ARG_TYPE",
+      /**
+       * @param {string} name
+       * @param {Array<string> | string} expected
+       * @param {unknown} actual
+       */
+      (name, expected, actual) => {
+        import_node_assert.default.ok(typeof name === "string", "'name' must be a string");
+        if (!Array.isArray(expected)) {
+          expected = [expected];
+        }
+        let message = "The ";
+        if (name.endsWith(" argument")) {
+          message += `${name} `;
+        } else {
+          const type = name.includes(".") ? "property" : "argument";
+          message += `"${name}" ${type} `;
+        }
+        message += "must be ";
+        const types = [];
+        const instances = [];
+        const other = [];
+        for (const value of expected) {
+          import_node_assert.default.ok(
+            typeof value === "string",
+            "All expected entries have to be of type string"
+          );
+          if (kTypes.has(value)) {
+            types.push(value.toLowerCase());
+          } else if (classRegExp.exec(value) === null) {
+            import_node_assert.default.ok(
+              value !== "object",
+              'The value "object" should be written as "Object"'
+            );
+            other.push(value);
+          } else {
+            instances.push(value);
+          }
+        }
+        if (instances.length > 0) {
+          const pos = types.indexOf("object");
+          if (pos !== -1) {
+            types.slice(pos, 1);
+            instances.push("Object");
+          }
+        }
+        if (types.length > 0) {
+          message += `${types.length > 1 ? "one of type" : "of type"} ${formatList(
+            types,
+            "or"
+          )}`;
+          if (instances.length > 0 || other.length > 0) message += " or ";
+        }
+        if (instances.length > 0) {
+          message += `an instance of ${formatList(instances, "or")}`;
+          if (other.length > 0) message += " or ";
+        }
+        if (other.length > 0) {
+          if (other.length > 1) {
+            message += `one of ${formatList(other, "or")}`;
+          } else {
+            if (other[0].toLowerCase() !== other[0]) message += "an ";
+            message += `${other[0]}`;
+          }
+        }
+        message += `. Received ${determineSpecificType(actual)}`;
+        return message;
+      },
+      TypeError
+    );
+    codes.ERR_INVALID_MODULE_SPECIFIER = createError(
+      "ERR_INVALID_MODULE_SPECIFIER",
+      /**
+       * @param {string} request
+       * @param {string} reason
+       * @param {string} [base]
+       */
+      (request, reason, base = void 0) => {
+        return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
+      },
+      TypeError
+    );
+    codes.ERR_INVALID_PACKAGE_CONFIG = createError(
+      "ERR_INVALID_PACKAGE_CONFIG",
+      /**
+       * @param {string} path
+       * @param {string} [base]
+       * @param {string} [message]
+       */
+      (path21, base, message) => {
+        return `Invalid package config ${path21}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+      },
+      Error
+    );
+    codes.ERR_INVALID_PACKAGE_TARGET = createError(
+      "ERR_INVALID_PACKAGE_TARGET",
+      /**
+       * @param {string} packagePath
+       * @param {string} key
+       * @param {unknown} target
+       * @param {boolean} [isImport=false]
+       * @param {string} [base]
+       */
+      (packagePath, key, target, isImport = false, base = void 0) => {
+        const relatedError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
+        if (key === ".") {
+          import_node_assert.default.ok(isImport === false);
+          return `Invalid "exports" main target ${JSON.stringify(target)} defined in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? '; targets must start with "./"' : ""}`;
+        }
+        return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(
+          target
+        )} defined for '${key}' in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? '; targets must start with "./"' : ""}`;
+      },
+      Error
+    );
+    codes.ERR_MODULE_NOT_FOUND = createError(
+      "ERR_MODULE_NOT_FOUND",
+      /**
+       * @param {string} path
+       * @param {string} base
+       * @param {boolean} [exactUrl]
+       */
+      (path21, base, exactUrl = false) => {
+        return `Cannot find ${exactUrl ? "module" : "package"} '${path21}' imported from ${base}`;
+      },
+      Error
+    );
+    codes.ERR_NETWORK_IMPORT_DISALLOWED = createError(
+      "ERR_NETWORK_IMPORT_DISALLOWED",
+      "import of '%s' by %s is not supported: %s",
+      Error
+    );
+    codes.ERR_PACKAGE_IMPORT_NOT_DEFINED = createError(
+      "ERR_PACKAGE_IMPORT_NOT_DEFINED",
+      /**
+       * @param {string} specifier
+       * @param {string} packagePath
+       * @param {string} base
+       */
+      (specifier, packagePath, base) => {
+        return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath}package.json` : ""} imported from ${base}`;
+      },
+      TypeError
+    );
+    codes.ERR_PACKAGE_PATH_NOT_EXPORTED = createError(
+      "ERR_PACKAGE_PATH_NOT_EXPORTED",
+      /**
+       * @param {string} packagePath
+       * @param {string} subpath
+       * @param {string} [base]
+       */
+      (packagePath, subpath, base = void 0) => {
+        if (subpath === ".")
+          return `No "exports" main defined in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
+        return `Package subpath '${subpath}' is not defined by "exports" in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
+      },
+      Error
+    );
+    codes.ERR_UNSUPPORTED_DIR_IMPORT = createError(
+      "ERR_UNSUPPORTED_DIR_IMPORT",
+      "Directory import '%s' is not supported resolving ES modules imported from %s",
+      Error
+    );
+    codes.ERR_UNSUPPORTED_RESOLVE_REQUEST = createError(
+      "ERR_UNSUPPORTED_RESOLVE_REQUEST",
+      'Failed to resolve module specifier "%s" from "%s": Invalid relative URL or base scheme is not hierarchical.',
+      TypeError
+    );
+    codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
+      "ERR_UNKNOWN_FILE_EXTENSION",
+      /**
+       * @param {string} extension
+       * @param {string} path
+       */
+      (extension, path21) => {
+        return `Unknown file extension "${extension}" for ${path21}`;
+      },
+      TypeError
+    );
+    codes.ERR_INVALID_ARG_VALUE = createError(
+      "ERR_INVALID_ARG_VALUE",
+      /**
+       * @param {string} name
+       * @param {unknown} value
+       * @param {string} [reason='is invalid']
+       */
+      (name, value, reason = "is invalid") => {
+        let inspected = (0, import_node_util.inspect)(value);
+        if (inspected.length > 128) {
+          inspected = `${inspected.slice(0, 128)}...`;
+        }
+        const type = name.includes(".") ? "property" : "argument";
+        return `The ${type} '${name}' ${reason}. Received ${inspected}`;
+      },
+      TypeError
+      // Note: extra classes have been shaken out.
+      // , RangeError
+    );
+    captureLargerStackTrace = hideStackFrames(
+      /**
+       * @param {Error} error
+       * @returns {Error}
+       */
+      // @ts-expect-error: fine
+      function(error) {
+        const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
+        if (stackTraceLimitIsWritable) {
+          userStackTraceLimit = Error.stackTraceLimit;
+          Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+        }
+        Error.captureStackTrace(error);
+        if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;
+        return error;
+      }
+    );
+  }
+});
+
+// node_modules/import-meta-resolve/lib/package-json-reader.js
+function read(jsonPath, { base, specifier }) {
+  const existing = cache.get(jsonPath);
+  if (existing) {
+    return existing;
+  }
+  let string;
+  try {
+    string = import_node_fs9.default.readFileSync(import_node_path11.default.toNamespacedPath(jsonPath), "utf8");
+  } catch (error) {
+    const exception = (
+      /** @type {ErrnoException} */
+      error
+    );
+    if (exception.code !== "ENOENT") {
+      throw exception;
+    }
+  }
+  const result = {
+    exists: false,
+    pjsonPath: jsonPath,
+    main: void 0,
+    name: void 0,
+    type: "none",
+    // Ignore unknown types for forwards compatibility
+    exports: void 0,
+    imports: void 0
+  };
+  if (string !== void 0) {
+    let parsed;
+    try {
+      parsed = JSON.parse(string);
+    } catch (error_) {
+      const cause = (
+        /** @type {ErrnoException} */
+        error_
+      );
+      const error = new ERR_INVALID_PACKAGE_CONFIG(
+        jsonPath,
+        (base ? `"${specifier}" from ` : "") + (0, import_node_url4.fileURLToPath)(base || specifier),
+        cause.message
+      );
+      error.cause = cause;
+      throw error;
+    }
+    result.exists = true;
+    if (hasOwnProperty.call(parsed, "name") && typeof parsed.name === "string") {
+      result.name = parsed.name;
+    }
+    if (hasOwnProperty.call(parsed, "main") && typeof parsed.main === "string") {
+      result.main = parsed.main;
+    }
+    if (hasOwnProperty.call(parsed, "exports")) {
+      result.exports = parsed.exports;
+    }
+    if (hasOwnProperty.call(parsed, "imports")) {
+      result.imports = parsed.imports;
+    }
+    if (hasOwnProperty.call(parsed, "type") && (parsed.type === "commonjs" || parsed.type === "module")) {
+      result.type = parsed.type;
+    }
+  }
+  cache.set(jsonPath, result);
+  return result;
+}
+function getPackageScopeConfig(resolved) {
+  let packageJSONUrl = new URL("package.json", resolved);
+  while (true) {
+    const packageJSONPath2 = packageJSONUrl.pathname;
+    if (packageJSONPath2.endsWith("node_modules/package.json")) {
+      break;
+    }
+    const packageConfig = read((0, import_node_url4.fileURLToPath)(packageJSONUrl), {
+      specifier: resolved
+    });
+    if (packageConfig.exists) {
+      return packageConfig;
+    }
+    const lastPackageJSONUrl = packageJSONUrl;
+    packageJSONUrl = new URL("../package.json", packageJSONUrl);
+    if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) {
+      break;
+    }
+  }
+  const packageJSONPath = (0, import_node_url4.fileURLToPath)(packageJSONUrl);
+  return {
+    pjsonPath: packageJSONPath,
+    exists: false,
+    type: "none"
+  };
+}
+function getPackageType(url) {
+  return getPackageScopeConfig(url).type;
+}
+var import_node_fs9, import_node_path11, import_node_url4, hasOwnProperty, ERR_INVALID_PACKAGE_CONFIG, cache;
+var init_package_json_reader = __esm({
+  "node_modules/import-meta-resolve/lib/package-json-reader.js"() {
+    "use strict";
+    import_node_fs9 = __toESM(require("fs"), 1);
+    import_node_path11 = __toESM(require("path"), 1);
+    import_node_url4 = require("url");
+    init_errors();
+    hasOwnProperty = {}.hasOwnProperty;
+    ({ ERR_INVALID_PACKAGE_CONFIG } = codes);
+    cache = /* @__PURE__ */ new Map();
+  }
+});
+
+// node_modules/import-meta-resolve/lib/get-format.js
+function mimeToFormat(mime) {
+  if (mime && /\s*(text|application)\/javascript\s*(;\s*charset=utf-?8\s*)?/i.test(mime))
+    return "module";
+  if (mime === "application/json") return "json";
+  return null;
+}
+function getDataProtocolModuleFormat(parsed) {
+  const { 1: mime } = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(
+    parsed.pathname
+  ) || [null, null, null];
+  return mimeToFormat(mime);
+}
+function extname(url) {
+  const pathname = url.pathname;
+  let index2 = pathname.length;
+  while (index2--) {
+    const code = pathname.codePointAt(index2);
+    if (code === 47) {
+      return "";
+    }
+    if (code === 46) {
+      return pathname.codePointAt(index2 - 1) === 47 ? "" : pathname.slice(index2);
+    }
+  }
+  return "";
+}
+function getFileProtocolModuleFormat(url, _context, ignoreErrors) {
+  const value = extname(url);
+  if (value === ".js") {
+    const packageType = getPackageType(url);
+    if (packageType !== "none") {
+      return packageType;
+    }
+    return "commonjs";
+  }
+  if (value === "") {
+    const packageType = getPackageType(url);
+    if (packageType === "none" || packageType === "commonjs") {
+      return "commonjs";
+    }
+    return "module";
+  }
+  const format2 = extensionFormatMap[value];
+  if (format2) return format2;
+  if (ignoreErrors) {
+    return void 0;
+  }
+  const filepath = (0, import_node_url5.fileURLToPath)(url);
+  throw new ERR_UNKNOWN_FILE_EXTENSION(value, filepath);
+}
+function getHttpProtocolModuleFormat() {
+}
+function defaultGetFormatWithoutErrors(url, context) {
+  const protocol = url.protocol;
+  if (!hasOwnProperty2.call(protocolHandlers, protocol)) {
+    return null;
+  }
+  return protocolHandlers[protocol](url, context, true) || null;
+}
+var import_node_url5, ERR_UNKNOWN_FILE_EXTENSION, hasOwnProperty2, extensionFormatMap, protocolHandlers;
+var init_get_format = __esm({
+  "node_modules/import-meta-resolve/lib/get-format.js"() {
+    "use strict";
+    import_node_url5 = require("url");
+    init_package_json_reader();
+    init_errors();
+    ({ ERR_UNKNOWN_FILE_EXTENSION } = codes);
+    hasOwnProperty2 = {}.hasOwnProperty;
+    extensionFormatMap = {
+      // @ts-expect-error: hush.
+      __proto__: null,
+      ".cjs": "commonjs",
+      ".js": "module",
+      ".json": "json",
+      ".mjs": "module"
+    };
+    protocolHandlers = {
+      // @ts-expect-error: hush.
+      __proto__: null,
+      "data:": getDataProtocolModuleFormat,
+      "file:": getFileProtocolModuleFormat,
+      "http:": getHttpProtocolModuleFormat,
+      "https:": getHttpProtocolModuleFormat,
+      "node:"() {
+        return "builtin";
+      }
+    };
+  }
+});
+
+// node_modules/import-meta-resolve/lib/utils.js
+function getDefaultConditions() {
+  return DEFAULT_CONDITIONS;
+}
+function getDefaultConditionsSet() {
+  return DEFAULT_CONDITIONS_SET;
+}
+function getConditionsSet(conditions) {
+  if (conditions !== void 0 && conditions !== getDefaultConditions()) {
+    if (!Array.isArray(conditions)) {
+      throw new ERR_INVALID_ARG_VALUE(
+        "conditions",
+        conditions,
+        "expected an array"
+      );
+    }
+    return new Set(conditions);
+  }
+  return getDefaultConditionsSet();
+}
+var ERR_INVALID_ARG_VALUE, DEFAULT_CONDITIONS, DEFAULT_CONDITIONS_SET;
+var init_utils = __esm({
+  "node_modules/import-meta-resolve/lib/utils.js"() {
+    "use strict";
+    init_errors();
+    ({ ERR_INVALID_ARG_VALUE } = codes);
+    DEFAULT_CONDITIONS = Object.freeze(["node", "import"]);
+    DEFAULT_CONDITIONS_SET = new Set(DEFAULT_CONDITIONS);
+  }
+});
+
+// node_modules/import-meta-resolve/lib/resolve.js
+function emitInvalidSegmentDeprecation(target, request, match, packageJsonUrl, internal, base, isTarget) {
+  if (import_node_process.default.noDeprecation) {
+    return;
+  }
+  const pjsonPath = (0, import_node_url6.fileURLToPath)(packageJsonUrl);
+  const double = doubleSlashRegEx.exec(isTarget ? target : request) !== null;
+  import_node_process.default.emitWarning(
+    `Use of deprecated ${double ? "double slash" : "leading or trailing slash matching"} resolving "${target}" for module request "${request}" ${request === match ? "" : `matched to "${match}" `}in the "${internal ? "imports" : "exports"}" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${(0, import_node_url6.fileURLToPath)(base)}` : ""}.`,
+    "DeprecationWarning",
+    "DEP0166"
+  );
+}
+function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
+  if (import_node_process.default.noDeprecation) {
+    return;
+  }
+  const format2 = defaultGetFormatWithoutErrors(url, { parentURL: base.href });
+  if (format2 !== "module") return;
+  const urlPath = (0, import_node_url6.fileURLToPath)(url.href);
+  const packagePath = (0, import_node_url6.fileURLToPath)(new URL(".", packageJsonUrl));
+  const basePath = (0, import_node_url6.fileURLToPath)(base);
+  if (!main) {
+    import_node_process.default.emitWarning(
+      `No "main" or "exports" field defined in the package.json for ${packagePath} resolving the main entry point "${urlPath.slice(
+        packagePath.length
+      )}", imported from ${basePath}.
+Default "index" lookups for the main are deprecated for ES modules.`,
+      "DeprecationWarning",
+      "DEP0151"
+    );
+  } else if (import_node_path12.default.resolve(packagePath, main) !== urlPath) {
+    import_node_process.default.emitWarning(
+      `Package ${packagePath} has a "main" field set to "${main}", excluding the full filename and extension to the resolved file at "${urlPath.slice(
+        packagePath.length
+      )}", imported from ${basePath}.
+ Automatic extension resolution of the "main" field is deprecated for ES modules.`,
+      "DeprecationWarning",
+      "DEP0151"
+    );
+  }
+}
+function tryStatSync(path21) {
+  try {
+    return (0, import_node_fs10.statSync)(path21);
+  } catch {
+  }
+}
+function fileExists(url) {
+  const stats = (0, import_node_fs10.statSync)(url, { throwIfNoEntry: false });
+  const isFile = stats ? stats.isFile() : void 0;
+  return isFile === null || isFile === void 0 ? false : isFile;
+}
+function legacyMainResolve(packageJsonUrl, packageConfig, base) {
+  let guess;
+  if (packageConfig.main !== void 0) {
+    guess = new URL(packageConfig.main, packageJsonUrl);
+    if (fileExists(guess)) return guess;
+    const tries2 = [
+      `./${packageConfig.main}.js`,
+      `./${packageConfig.main}.json`,
+      `./${packageConfig.main}.node`,
+      `./${packageConfig.main}/index.js`,
+      `./${packageConfig.main}/index.json`,
+      `./${packageConfig.main}/index.node`
+    ];
+    let i2 = -1;
+    while (++i2 < tries2.length) {
+      guess = new URL(tries2[i2], packageJsonUrl);
+      if (fileExists(guess)) break;
+      guess = void 0;
+    }
+    if (guess) {
+      emitLegacyIndexDeprecation(
+        guess,
+        packageJsonUrl,
+        base,
+        packageConfig.main
+      );
+      return guess;
+    }
+  }
+  const tries = ["./index.js", "./index.json", "./index.node"];
+  let i = -1;
+  while (++i < tries.length) {
+    guess = new URL(tries[i], packageJsonUrl);
+    if (fileExists(guess)) break;
+    guess = void 0;
+  }
+  if (guess) {
+    emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main);
+    return guess;
+  }
+  throw new ERR_MODULE_NOT_FOUND(
+    (0, import_node_url6.fileURLToPath)(new URL(".", packageJsonUrl)),
+    (0, import_node_url6.fileURLToPath)(base)
+  );
+}
+function finalizeResolution(resolved, base, preserveSymlinks) {
+  if (encodedSeparatorRegEx.exec(resolved.pathname) !== null) {
+    throw new ERR_INVALID_MODULE_SPECIFIER(
+      resolved.pathname,
+      'must not include encoded "/" or "\\" characters',
+      (0, import_node_url6.fileURLToPath)(base)
+    );
+  }
+  let filePath;
+  try {
+    filePath = (0, import_node_url6.fileURLToPath)(resolved);
+  } catch (error) {
+    const cause = (
+      /** @type {ErrnoException} */
+      error
+    );
+    Object.defineProperty(cause, "input", { value: String(resolved) });
+    Object.defineProperty(cause, "module", { value: String(base) });
+    throw cause;
+  }
+  const stats = tryStatSync(
+    filePath.endsWith("/") ? filePath.slice(-1) : filePath
+  );
+  if (stats && stats.isDirectory()) {
+    const error = new ERR_UNSUPPORTED_DIR_IMPORT(filePath, (0, import_node_url6.fileURLToPath)(base));
+    error.url = String(resolved);
+    throw error;
+  }
+  if (!stats || !stats.isFile()) {
+    const error = new ERR_MODULE_NOT_FOUND(
+      filePath || resolved.pathname,
+      base && (0, import_node_url6.fileURLToPath)(base),
+      true
+    );
+    error.url = String(resolved);
+    throw error;
+  }
+  if (!preserveSymlinks) {
+    const real = (0, import_node_fs10.realpathSync)(filePath);
+    const { search, hash } = resolved;
+    resolved = (0, import_node_url6.pathToFileURL)(real + (filePath.endsWith(import_node_path12.default.sep) ? "/" : ""));
+    resolved.search = search;
+    resolved.hash = hash;
+  }
+  return resolved;
+}
+function importNotDefined(specifier, packageJsonUrl, base) {
+  return new ERR_PACKAGE_IMPORT_NOT_DEFINED(
+    specifier,
+    packageJsonUrl && (0, import_node_url6.fileURLToPath)(new URL(".", packageJsonUrl)),
+    (0, import_node_url6.fileURLToPath)(base)
+  );
+}
+function exportsNotFound(subpath, packageJsonUrl, base) {
+  return new ERR_PACKAGE_PATH_NOT_EXPORTED(
+    (0, import_node_url6.fileURLToPath)(new URL(".", packageJsonUrl)),
+    subpath,
+    base && (0, import_node_url6.fileURLToPath)(base)
+  );
+}
+function throwInvalidSubpath(request, match, packageJsonUrl, internal, base) {
+  const reason = `request is not a valid match in pattern "${match}" for the "${internal ? "imports" : "exports"}" resolution of ${(0, import_node_url6.fileURLToPath)(packageJsonUrl)}`;
+  throw new ERR_INVALID_MODULE_SPECIFIER(
+    request,
+    reason,
+    base && (0, import_node_url6.fileURLToPath)(base)
+  );
+}
+function invalidPackageTarget(subpath, target, packageJsonUrl, internal, base) {
+  target = typeof target === "object" && target !== null ? JSON.stringify(target, null, "") : `${target}`;
+  return new ERR_INVALID_PACKAGE_TARGET(
+    (0, import_node_url6.fileURLToPath)(new URL(".", packageJsonUrl)),
+    subpath,
+    target,
+    internal,
+    base && (0, import_node_url6.fileURLToPath)(base)
+  );
+}
+function resolvePackageTargetString(target, subpath, match, packageJsonUrl, base, pattern, internal, isPathMap, conditions) {
+  if (subpath !== "" && !pattern && target[target.length - 1] !== "/")
+    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+  if (!target.startsWith("./")) {
+    if (internal && !target.startsWith("../") && !target.startsWith("/")) {
+      let isURL = false;
+      try {
+        new URL(target);
+        isURL = true;
+      } catch {
+      }
+      if (!isURL) {
+        const exportTarget = pattern ? RegExpPrototypeSymbolReplace.call(
+          patternRegEx,
+          target,
+          () => subpath
+        ) : target + subpath;
+        return packageResolve(exportTarget, packageJsonUrl, conditions);
+      }
+    }
+    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+  }
+  if (invalidSegmentRegEx.exec(target.slice(2)) !== null) {
+    if (deprecatedInvalidSegmentRegEx.exec(target.slice(2)) === null) {
+      if (!isPathMap) {
+        const request = pattern ? match.replace("*", () => subpath) : match + subpath;
+        const resolvedTarget = pattern ? RegExpPrototypeSymbolReplace.call(
+          patternRegEx,
+          target,
+          () => subpath
+        ) : target;
+        emitInvalidSegmentDeprecation(
+          resolvedTarget,
+          request,
+          match,
+          packageJsonUrl,
+          internal,
+          base,
+          true
+        );
+      }
+    } else {
+      throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+    }
+  }
+  const resolved = new URL(target, packageJsonUrl);
+  const resolvedPath = resolved.pathname;
+  const packagePath = new URL(".", packageJsonUrl).pathname;
+  if (!resolvedPath.startsWith(packagePath))
+    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+  if (subpath === "") return resolved;
+  if (invalidSegmentRegEx.exec(subpath) !== null) {
+    const request = pattern ? match.replace("*", () => subpath) : match + subpath;
+    if (deprecatedInvalidSegmentRegEx.exec(subpath) === null) {
+      if (!isPathMap) {
+        const resolvedTarget = pattern ? RegExpPrototypeSymbolReplace.call(
+          patternRegEx,
+          target,
+          () => subpath
+        ) : target;
+        emitInvalidSegmentDeprecation(
+          resolvedTarget,
+          request,
+          match,
+          packageJsonUrl,
+          internal,
+          base,
+          false
+        );
+      }
+    } else {
+      throwInvalidSubpath(request, match, packageJsonUrl, internal, base);
+    }
+  }
+  if (pattern) {
+    return new URL(
+      RegExpPrototypeSymbolReplace.call(
+        patternRegEx,
+        resolved.href,
+        () => subpath
+      )
+    );
+  }
+  return new URL(subpath, resolved);
+}
+function isArrayIndex(key) {
+  const keyNumber = Number(key);
+  if (`${keyNumber}` !== key) return false;
+  return keyNumber >= 0 && keyNumber < 4294967295;
+}
+function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions) {
+  if (typeof target === "string") {
+    return resolvePackageTargetString(
+      target,
+      subpath,
+      packageSubpath,
+      packageJsonUrl,
+      base,
+      pattern,
+      internal,
+      isPathMap,
+      conditions
+    );
+  }
+  if (Array.isArray(target)) {
+    const targetList = target;
+    if (targetList.length === 0) return null;
+    let lastException;
+    let i = -1;
+    while (++i < targetList.length) {
+      const targetItem = targetList[i];
+      let resolveResult;
+      try {
+        resolveResult = resolvePackageTarget(
+          packageJsonUrl,
+          targetItem,
+          subpath,
+          packageSubpath,
+          base,
+          pattern,
+          internal,
+          isPathMap,
+          conditions
+        );
+      } catch (error) {
+        const exception = (
+          /** @type {ErrnoException} */
+          error
+        );
+        lastException = exception;
+        if (exception.code === "ERR_INVALID_PACKAGE_TARGET") continue;
+        throw error;
+      }
+      if (resolveResult === void 0) continue;
+      if (resolveResult === null) {
+        lastException = null;
+        continue;
+      }
+      return resolveResult;
+    }
+    if (lastException === void 0 || lastException === null) {
+      return null;
+    }
+    throw lastException;
+  }
+  if (typeof target === "object" && target !== null) {
+    const keys = Object.getOwnPropertyNames(target);
+    let i = -1;
+    while (++i < keys.length) {
+      const key = keys[i];
+      if (isArrayIndex(key)) {
+        throw new ERR_INVALID_PACKAGE_CONFIG2(
+          (0, import_node_url6.fileURLToPath)(packageJsonUrl),
+          base,
+          '"exports" cannot contain numeric property keys.'
+        );
+      }
+    }
+    i = -1;
+    while (++i < keys.length) {
+      const key = keys[i];
+      if (key === "default" || conditions && conditions.has(key)) {
+        const conditionalTarget = (
+          /** @type {unknown} */
+          target[key]
+        );
+        const resolveResult = resolvePackageTarget(
+          packageJsonUrl,
+          conditionalTarget,
+          subpath,
+          packageSubpath,
+          base,
+          pattern,
+          internal,
+          isPathMap,
+          conditions
+        );
+        if (resolveResult === void 0) continue;
+        return resolveResult;
+      }
+    }
+    return null;
+  }
+  if (target === null) {
+    return null;
+  }
+  throw invalidPackageTarget(
+    packageSubpath,
+    target,
+    packageJsonUrl,
+    internal,
+    base
+  );
+}
+function isConditionalExportsMainSugar(exports2, packageJsonUrl, base) {
+  if (typeof exports2 === "string" || Array.isArray(exports2)) return true;
+  if (typeof exports2 !== "object" || exports2 === null) return false;
+  const keys = Object.getOwnPropertyNames(exports2);
+  let isConditionalSugar = false;
+  let i = 0;
+  let keyIndex = -1;
+  while (++keyIndex < keys.length) {
+    const key = keys[keyIndex];
+    const currentIsConditionalSugar = key === "" || key[0] !== ".";
+    if (i++ === 0) {
+      isConditionalSugar = currentIsConditionalSugar;
+    } else if (isConditionalSugar !== currentIsConditionalSugar) {
+      throw new ERR_INVALID_PACKAGE_CONFIG2(
+        (0, import_node_url6.fileURLToPath)(packageJsonUrl),
+        base,
+        `"exports" cannot contain some keys starting with '.' and some not. The exports object must either be an object of package subpath keys or an object of main entry condition name keys only.`
+      );
+    }
+  }
+  return isConditionalSugar;
+}
+function emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) {
+  if (import_node_process.default.noDeprecation) {
+    return;
+  }
+  const pjsonPath = (0, import_node_url6.fileURLToPath)(pjsonUrl);
+  if (emittedPackageWarnings.has(pjsonPath + "|" + match)) return;
+  emittedPackageWarnings.add(pjsonPath + "|" + match);
+  import_node_process.default.emitWarning(
+    `Use of deprecated trailing slash pattern mapping "${match}" in the "exports" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${(0, import_node_url6.fileURLToPath)(base)}` : ""}. Mapping specifiers ending in "/" is no longer supported.`,
+    "DeprecationWarning",
+    "DEP0155"
+  );
+}
+function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions) {
+  let exports2 = packageConfig.exports;
+  if (isConditionalExportsMainSugar(exports2, packageJsonUrl, base)) {
+    exports2 = { ".": exports2 };
+  }
+  if (own2.call(exports2, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) {
+    const target = exports2[packageSubpath];
+    const resolveResult = resolvePackageTarget(
+      packageJsonUrl,
+      target,
+      "",
+      packageSubpath,
+      base,
+      false,
+      false,
+      false,
+      conditions
+    );
+    if (resolveResult === null || resolveResult === void 0) {
+      throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+    }
+    return resolveResult;
+  }
+  let bestMatch = "";
+  let bestMatchSubpath = "";
+  const keys = Object.getOwnPropertyNames(exports2);
+  let i = -1;
+  while (++i < keys.length) {
+    const key = keys[i];
+    const patternIndex = key.indexOf("*");
+    if (patternIndex !== -1 && packageSubpath.startsWith(key.slice(0, patternIndex))) {
+      if (packageSubpath.endsWith("/")) {
+        emitTrailingSlashPatternDeprecation(
+          packageSubpath,
+          packageJsonUrl,
+          base
+        );
+      }
+      const patternTrailer = key.slice(patternIndex + 1);
+      if (packageSubpath.length >= key.length && packageSubpath.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
+        bestMatch = key;
+        bestMatchSubpath = packageSubpath.slice(
+          patternIndex,
+          packageSubpath.length - patternTrailer.length
+        );
+      }
+    }
+  }
+  if (bestMatch) {
+    const target = (
+      /** @type {unknown} */
+      exports2[bestMatch]
+    );
+    const resolveResult = resolvePackageTarget(
+      packageJsonUrl,
+      target,
+      bestMatchSubpath,
+      bestMatch,
+      base,
+      true,
+      false,
+      packageSubpath.endsWith("/"),
+      conditions
+    );
+    if (resolveResult === null || resolveResult === void 0) {
+      throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+    }
+    return resolveResult;
+  }
+  throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+}
+function patternKeyCompare(a, b) {
+  const aPatternIndex = a.indexOf("*");
+  const bPatternIndex = b.indexOf("*");
+  const baseLengthA = aPatternIndex === -1 ? a.length : aPatternIndex + 1;
+  const baseLengthB = bPatternIndex === -1 ? b.length : bPatternIndex + 1;
+  if (baseLengthA > baseLengthB) return -1;
+  if (baseLengthB > baseLengthA) return 1;
+  if (aPatternIndex === -1) return 1;
+  if (bPatternIndex === -1) return -1;
+  if (a.length > b.length) return -1;
+  if (b.length > a.length) return 1;
+  return 0;
+}
+function packageImportsResolve(name, base, conditions) {
+  if (name === "#" || name.startsWith("#/") || name.endsWith("/")) {
+    const reason = "is not a valid internal imports specifier name";
+    throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, (0, import_node_url6.fileURLToPath)(base));
+  }
+  let packageJsonUrl;
+  const packageConfig = getPackageScopeConfig(base);
+  if (packageConfig.exists) {
+    packageJsonUrl = (0, import_node_url6.pathToFileURL)(packageConfig.pjsonPath);
+    const imports = packageConfig.imports;
+    if (imports) {
+      if (own2.call(imports, name) && !name.includes("*")) {
+        const resolveResult = resolvePackageTarget(
+          packageJsonUrl,
+          imports[name],
+          "",
+          name,
+          base,
+          false,
+          true,
+          false,
+          conditions
+        );
+        if (resolveResult !== null && resolveResult !== void 0) {
+          return resolveResult;
+        }
+      } else {
+        let bestMatch = "";
+        let bestMatchSubpath = "";
+        const keys = Object.getOwnPropertyNames(imports);
+        let i = -1;
+        while (++i < keys.length) {
+          const key = keys[i];
+          const patternIndex = key.indexOf("*");
+          if (patternIndex !== -1 && name.startsWith(key.slice(0, -1))) {
+            const patternTrailer = key.slice(patternIndex + 1);
+            if (name.length >= key.length && name.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
+              bestMatch = key;
+              bestMatchSubpath = name.slice(
+                patternIndex,
+                name.length - patternTrailer.length
+              );
+            }
+          }
+        }
+        if (bestMatch) {
+          const target = imports[bestMatch];
+          const resolveResult = resolvePackageTarget(
+            packageJsonUrl,
+            target,
+            bestMatchSubpath,
+            bestMatch,
+            base,
+            true,
+            true,
+            false,
+            conditions
+          );
+          if (resolveResult !== null && resolveResult !== void 0) {
+            return resolveResult;
+          }
+        }
+      }
+    }
+  }
+  throw importNotDefined(name, packageJsonUrl, base);
+}
+function parsePackageName(specifier, base) {
+  let separatorIndex = specifier.indexOf("/");
+  let validPackageName = true;
+  let isScoped = false;
+  if (specifier[0] === "@") {
+    isScoped = true;
+    if (separatorIndex === -1 || specifier.length === 0) {
+      validPackageName = false;
+    } else {
+      separatorIndex = specifier.indexOf("/", separatorIndex + 1);
+    }
+  }
+  const packageName = separatorIndex === -1 ? specifier : specifier.slice(0, separatorIndex);
+  if (invalidPackageNameRegEx.exec(packageName) !== null) {
+    validPackageName = false;
+  }
+  if (!validPackageName) {
+    throw new ERR_INVALID_MODULE_SPECIFIER(
+      specifier,
+      "is not a valid package name",
+      (0, import_node_url6.fileURLToPath)(base)
+    );
+  }
+  const packageSubpath = "." + (separatorIndex === -1 ? "" : specifier.slice(separatorIndex));
+  return { packageName, packageSubpath, isScoped };
+}
+function packageResolve(specifier, base, conditions) {
+  if (import_node_module4.builtinModules.includes(specifier)) {
+    return new URL("node:" + specifier);
+  }
+  const { packageName, packageSubpath, isScoped } = parsePackageName(
+    specifier,
+    base
+  );
+  const packageConfig = getPackageScopeConfig(base);
+  if (packageConfig.exists) {
+    const packageJsonUrl2 = (0, import_node_url6.pathToFileURL)(packageConfig.pjsonPath);
+    if (packageConfig.name === packageName && packageConfig.exports !== void 0 && packageConfig.exports !== null) {
+      return packageExportsResolve(
+        packageJsonUrl2,
+        packageSubpath,
+        packageConfig,
+        base,
+        conditions
+      );
+    }
+  }
+  let packageJsonUrl = new URL(
+    "./node_modules/" + packageName + "/package.json",
+    base
+  );
+  let packageJsonPath = (0, import_node_url6.fileURLToPath)(packageJsonUrl);
+  let lastPath;
+  do {
+    const stat = tryStatSync(packageJsonPath.slice(0, -13));
+    if (!stat || !stat.isDirectory()) {
+      lastPath = packageJsonPath;
+      packageJsonUrl = new URL(
+        (isScoped ? "../../../../node_modules/" : "../../../node_modules/") + packageName + "/package.json",
+        packageJsonUrl
+      );
+      packageJsonPath = (0, import_node_url6.fileURLToPath)(packageJsonUrl);
+      continue;
+    }
+    const packageConfig2 = read(packageJsonPath, { base, specifier });
+    if (packageConfig2.exports !== void 0 && packageConfig2.exports !== null) {
+      return packageExportsResolve(
+        packageJsonUrl,
+        packageSubpath,
+        packageConfig2,
+        base,
+        conditions
+      );
+    }
+    if (packageSubpath === ".") {
+      return legacyMainResolve(packageJsonUrl, packageConfig2, base);
+    }
+    return new URL(packageSubpath, packageJsonUrl);
+  } while (packageJsonPath.length !== lastPath.length);
+  throw new ERR_MODULE_NOT_FOUND(packageName, (0, import_node_url6.fileURLToPath)(base), false);
+}
+function isRelativeSpecifier(specifier) {
+  if (specifier[0] === ".") {
+    if (specifier.length === 1 || specifier[1] === "/") return true;
+    if (specifier[1] === "." && (specifier.length === 2 || specifier[2] === "/")) {
+      return true;
+    }
+  }
+  return false;
+}
+function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
+  if (specifier === "") return false;
+  if (specifier[0] === "/") return true;
+  return isRelativeSpecifier(specifier);
+}
+function moduleResolve(specifier, base, conditions, preserveSymlinks) {
+  if (conditions === void 0) {
+    conditions = getConditionsSet();
+  }
+  const protocol = base.protocol;
+  const isData = protocol === "data:";
+  const isRemote = isData || protocol === "http:" || protocol === "https:";
+  let resolved;
+  if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
+    try {
+      resolved = new URL(specifier, base);
+    } catch (error_) {
+      const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
+      error.cause = error_;
+      throw error;
+    }
+  } else if (protocol === "file:" && specifier[0] === "#") {
+    resolved = packageImportsResolve(specifier, base, conditions);
+  } else {
+    try {
+      resolved = new URL(specifier);
+    } catch (error_) {
+      if (isRemote && !import_node_module4.builtinModules.includes(specifier)) {
+        const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
+        error.cause = error_;
+        throw error;
+      }
+      resolved = packageResolve(specifier, base, conditions);
+    }
+  }
+  import_node_assert2.default.ok(resolved !== void 0, "expected to be defined");
+  if (resolved.protocol !== "file:") {
+    return resolved;
+  }
+  return finalizeResolution(resolved, base, preserveSymlinks);
+}
+var import_node_assert2, import_node_fs10, import_node_process, import_node_url6, import_node_path12, import_node_module4, RegExpPrototypeSymbolReplace, ERR_NETWORK_IMPORT_DISALLOWED, ERR_INVALID_MODULE_SPECIFIER, ERR_INVALID_PACKAGE_CONFIG2, ERR_INVALID_PACKAGE_TARGET, ERR_MODULE_NOT_FOUND, ERR_PACKAGE_IMPORT_NOT_DEFINED, ERR_PACKAGE_PATH_NOT_EXPORTED, ERR_UNSUPPORTED_DIR_IMPORT, ERR_UNSUPPORTED_RESOLVE_REQUEST, own2, invalidSegmentRegEx, deprecatedInvalidSegmentRegEx, invalidPackageNameRegEx, patternRegEx, encodedSeparatorRegEx, emittedPackageWarnings, doubleSlashRegEx;
+var init_resolve2 = __esm({
+  "node_modules/import-meta-resolve/lib/resolve.js"() {
+    "use strict";
+    import_node_assert2 = __toESM(require("assert"), 1);
+    import_node_fs10 = require("fs");
+    import_node_process = __toESM(require("process"), 1);
+    import_node_url6 = require("url");
+    import_node_path12 = __toESM(require("path"), 1);
+    import_node_module4 = require("module");
+    init_get_format();
+    init_errors();
+    init_package_json_reader();
+    init_utils();
+    RegExpPrototypeSymbolReplace = RegExp.prototype[Symbol.replace];
+    ({
+      ERR_NETWORK_IMPORT_DISALLOWED,
+      ERR_INVALID_MODULE_SPECIFIER,
+      ERR_INVALID_PACKAGE_CONFIG: ERR_INVALID_PACKAGE_CONFIG2,
+      ERR_INVALID_PACKAGE_TARGET,
+      ERR_MODULE_NOT_FOUND,
+      ERR_PACKAGE_IMPORT_NOT_DEFINED,
+      ERR_PACKAGE_PATH_NOT_EXPORTED,
+      ERR_UNSUPPORTED_DIR_IMPORT,
+      ERR_UNSUPPORTED_RESOLVE_REQUEST
+    } = codes);
+    own2 = {}.hasOwnProperty;
+    invalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))?(\\|\/|$)/i;
+    deprecatedInvalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))(\\|\/|$)/i;
+    invalidPackageNameRegEx = /^\.|%|\\/;
+    patternRegEx = /\*/g;
+    encodedSeparatorRegEx = /%2f|%5c/i;
+    emittedPackageWarnings = /* @__PURE__ */ new Set();
+    doubleSlashRegEx = /[/\\]{2}/;
+  }
+});
+
+// node_modules/import-meta-resolve/index.js
+var init_import_meta_resolve = __esm({
+  "node_modules/import-meta-resolve/index.js"() {
+    "use strict";
+    init_resolve2();
+  }
+});
+
 // src/server/runnable-environment.ts
 var runnable_environment_exports = {};
 __export(runnable_environment_exports, {
@@ -4981,25 +6294,27 @@ function createModuleRunner(environment) {
   }
   return new NastiModuleRunner(environment);
 }
-var import_node_path11, import_node_fs9, import_node_module4, import_node_url4, debug4, NODE_BUILTINS, NastiModuleRunner, AsyncFunction;
+var import_node_path13, import_node_fs11, import_node_module5, import_node_url7, debug4, NODE_BUILTINS, NastiModuleRunner, AsyncFunction;
 var init_runnable_environment = __esm({
   "src/server/runnable-environment.ts"() {
     "use strict";
-    import_node_path11 = __toESM(require("path"), 1);
-    import_node_fs9 = __toESM(require("fs"), 1);
-    import_node_module4 = require("module");
-    import_node_url4 = require("url");
+    import_node_path13 = __toESM(require("path"), 1);
+    import_node_fs11 = __toESM(require("fs"), 1);
+    import_node_module5 = require("module");
+    import_node_url7 = require("url");
+    init_import_meta_resolve();
     init_transformer();
     init_env();
     init_debug();
     debug4 = createDebugger("nasti:ssr");
-    NODE_BUILTINS = /* @__PURE__ */ new Set([...import_node_module4.builtinModules, ...import_node_module4.builtinModules.map((m) => `node:${m}`)]);
+    NODE_BUILTINS = /* @__PURE__ */ new Set([...import_node_module5.builtinModules, ...import_node_module5.builtinModules.map((m) => `node:${m}`)]);
     NastiModuleRunner = class {
       environment;
       config;
       cache = /* @__PURE__ */ new Map();
       envDefine;
-      require;
+      externalImportParent;
+      externalImportConditions;
       constructor(environment) {
         this.environment = environment;
         this.config = environment.config;
@@ -5008,10 +6323,15 @@ var init_runnable_environment = __esm({
           this.config.mode,
           ssrDefineOverrides(environment.consumer)
         );
-        this.require = (0, import_node_module4.createRequire)(import_node_path11.default.join(this.config.root, "package.json"));
+        this.externalImportParent = (0, import_node_url7.pathToFileURL)(import_node_path13.default.join(this.config.root, "package.json"));
+        this.externalImportConditions = /* @__PURE__ */ new Set([
+          ...environment.options.resolve.conditions.filter((condition) => condition !== "require"),
+          "node",
+          "import"
+        ]);
         const handlers = {
           fetchModule: async (id, importer) => this.fetchModule(id, importer),
-          getBuiltins: () => [/^node:/, ...import_node_module4.builtinModules]
+          getBuiltins: () => [/^node:/, ...import_node_module5.builtinModules]
         };
         environment.hot.setInvokeHandler?.(handlers);
       }
@@ -5032,9 +6352,9 @@ var init_runnable_environment = __esm({
         this.cache.clear();
       }
       resolveToId(rawUrl) {
-        if (import_node_path11.default.isAbsolute(rawUrl) && import_node_fs9.default.existsSync(rawUrl.split("?")[0])) return rawUrl;
+        if (import_node_path13.default.isAbsolute(rawUrl) && import_node_fs11.default.existsSync(rawUrl.split("?")[0])) return rawUrl;
         const clean = rawUrl.replace(/^\//, "");
-        return import_node_path11.default.resolve(this.config.root, clean);
+        return import_node_path13.default.resolve(this.config.root, clean);
       }
       /**
        * fetchModule（invoke 契约方法）：环境管线产出 runner 可执行代码。
@@ -5043,14 +6363,14 @@ var init_runnable_environment = __esm({
        */
       async fetchModule(id, importer) {
         if (NODE_BUILTINS.has(id)) return { externalize: id };
-        if (!id.startsWith(".") && !import_node_path11.default.isAbsolute(id) && !id.startsWith("\0")) {
+        if (!id.startsWith(".") && !import_node_path13.default.isAbsolute(id) && !id.startsWith("\0")) {
           return { externalize: id };
         }
         const container = this.environment.pluginContainer;
         let resolvedId = id;
         if (id.startsWith(".") && importer) {
           const resolved = await container.resolveId(id, importer);
-          resolvedId = resolved ? typeof resolved === "string" ? resolved : resolved.id : import_node_path11.default.resolve(import_node_path11.default.dirname(importer.split("?")[0]), id);
+          resolvedId = resolved ? typeof resolved === "string" ? resolved : resolved.id : import_node_path13.default.resolve(import_node_path13.default.dirname(importer.split("?")[0]), id);
         }
         resolvedId = this.completeExtension(resolvedId);
         const cleanId = resolvedId.split("?")[0];
@@ -5058,8 +6378,8 @@ var init_runnable_environment = __esm({
         const loaded = await container.load(resolvedId);
         if (loaded != null) {
           code = typeof loaded === "string" ? loaded : loaded.code;
-        } else if (import_node_fs9.default.existsSync(cleanId)) {
-          code = import_node_fs9.default.readFileSync(cleanId, "utf-8");
+        } else if (import_node_fs11.default.existsSync(cleanId)) {
+          code = import_node_fs11.default.readFileSync(cleanId, "utf-8");
         } else {
           throw new Error(`[nasti:ssr] cannot load module: ${resolvedId}`);
         }
@@ -5113,19 +6433,19 @@ var init_runnable_environment = __esm({
       completeExtension(id) {
         const clean = id.split("?")[0];
         const query = id.includes("?") ? id.slice(id.indexOf("?")) : "";
-        if (import_node_fs9.default.existsSync(clean) && import_node_fs9.default.statSync(clean).isFile()) return id;
+        if (import_node_fs11.default.existsSync(clean) && import_node_fs11.default.statSync(clean).isFile()) return id;
         const jsMatch = clean.match(/^(.*)\.([mc]?)jsx?$/);
         if (jsMatch) {
           for (const tsExt of [`.${jsMatch[2]}ts`, `.${jsMatch[2]}tsx`]) {
-            if (import_node_fs9.default.existsSync(jsMatch[1] + tsExt)) return jsMatch[1] + tsExt + query;
+            if (import_node_fs11.default.existsSync(jsMatch[1] + tsExt)) return jsMatch[1] + tsExt + query;
           }
         }
         for (const ext of this.config.resolve.extensions) {
-          if (import_node_fs9.default.existsSync(clean + ext)) return clean + ext + query;
+          if (import_node_fs11.default.existsSync(clean + ext)) return clean + ext + query;
         }
         for (const ext of this.config.resolve.extensions) {
-          const indexPath = import_node_path11.default.join(clean, `index${ext}`);
-          if (import_node_fs9.default.existsSync(indexPath)) return indexPath;
+          const indexPath = import_node_path13.default.join(clean, `index${ext}`);
+          if (import_node_fs11.default.existsSync(indexPath)) return indexPath;
         }
         return id;
       }
@@ -5152,10 +6472,10 @@ var init_runnable_environment = __esm({
           return;
         }
         const ssrImport = async (dep) => {
-          if (NODE_BUILTINS.has(dep) || !dep.startsWith(".") && !import_node_path11.default.isAbsolute(dep) && !dep.startsWith("\0")) {
+          if (NODE_BUILTINS.has(dep) || !dep.startsWith(".") && !import_node_path13.default.isAbsolute(dep) && !dep.startsWith("\0")) {
             return this.importExternal(dep);
           }
-          const depId = dep.startsWith(".") ? this.completeExtension(import_node_path11.default.resolve(import_node_path11.default.dirname(fetched.id.split("?")[0]), dep)) : this.completeExtension(dep);
+          const depId = dep.startsWith(".") ? this.completeExtension(import_node_path13.default.resolve(import_node_path13.default.dirname(fetched.id.split("?")[0]), dep)) : this.completeExtension(dep);
           return this.instantiate(depId);
         };
         const ssrExportAll = (sourceModule) => {
@@ -5170,7 +6490,7 @@ var init_runnable_environment = __esm({
           }
         };
         const importMeta = {
-          url: (0, import_node_url4.pathToFileURL)(fetched.id.split("?")[0]).href,
+          url: (0, import_node_url7.pathToFileURL)(fetched.id.split("?")[0]).href,
           env: { SSR: true, MODE: this.config.mode, DEV: this.config.mode !== "production", PROD: this.config.mode === "production" },
           hot: void 0
         };
@@ -5187,20 +6507,21 @@ var init_runnable_environment = __esm({
       }
       async importExternal(spec) {
         try {
-          return await (spec.startsWith("node:") || !import_node_path11.default.isAbsolute(spec) ? import(this.resolveExternalSpecifier(spec)) : import((0, import_node_url4.pathToFileURL)(spec).href));
+          return await (spec.startsWith("node:") || !import_node_path13.default.isAbsolute(spec) ? import(this.resolveExternalSpecifier(spec)) : import((0, import_node_url7.pathToFileURL)(spec).href));
         } catch (err) {
           throw new Error(`[nasti:ssr] failed to import external "${spec}": ${err.message}`);
         }
       }
-      /** bare specifier → 项目 node_modules 的绝对 URL（避免相对 Nasti 自身解析） */
+      /** bare specifier → 项目 node_modules 的 ESM URL（避免相对 Nasti 自身解析） */
       resolveExternalSpecifier(spec) {
         if (spec.startsWith("node:")) return spec;
         if (NODE_BUILTINS.has(spec)) return `node:${spec}`;
-        try {
-          return (0, import_node_url4.pathToFileURL)(this.require.resolve(spec)).href;
-        } catch {
-          return spec;
-        }
+        return moduleResolve(
+          spec,
+          this.externalImportParent,
+          this.externalImportConditions,
+          false
+        ).href;
       }
     };
     AsyncFunction = Object.getPrototypeOf(async function() {
@@ -5285,7 +6606,7 @@ function reportBuildOutput(output, config, logger) {
     if (compressed && content != null) {
       gzip = (0, import_node_zlib.gzipSync)(typeof content === "string" ? Buffer.from(content) : content).byteLength;
     }
-    const ext = import_node_path12.default.extname(file.fileName);
+    const ext = import_node_path14.default.extname(file.fileName);
     const group = file.type === "chunk" ? "js" : ext === ".css" ? "css" : "assets";
     entries.push({ name: file.fileName, size, gzip, group });
   }
@@ -5319,11 +6640,11 @@ function warnLargeChunks(output, config, logger) {
     )
   );
 }
-var import_node_path12, import_node_zlib, import_picocolors5, debug5, numberFormatter;
+var import_node_path14, import_node_zlib, import_picocolors5, debug5, numberFormatter;
 var init_reporter = __esm({
   "src/build/reporter.ts"() {
     "use strict";
-    import_node_path12 = __toESM(require("path"), 1);
+    import_node_path14 = __toESM(require("path"), 1);
     import_node_zlib = require("zlib");
     import_picocolors5 = __toESM(require("picocolors"), 1);
     init_debug();
@@ -5339,7 +6660,7 @@ var init_reporter = __esm({
 function createBuildAppContext(config, results) {
   const output = [];
   const emitted = /* @__PURE__ */ new Set();
-  const outDir = import_node_path13.default.resolve(config.root, config.build.outDir);
+  const outDir = import_node_path15.default.resolve(config.root, config.build.outDir);
   let environmentArtifacts;
   return {
     config,
@@ -5395,14 +6716,14 @@ function createBuildAppContext(config, results) {
       if (environmentArtifacts.has(collisionKey)) {
         throw new Error(`[nasti] app artifact conflicts with environment output: ${fileName}`);
       }
-      const target = import_node_path13.default.resolve(outDir, ...fileName.split("/"));
-      const relative = import_node_path13.default.relative(outDir, target);
-      if (relative.startsWith("..") || import_node_path13.default.isAbsolute(relative)) {
+      const target = import_node_path15.default.resolve(outDir, ...fileName.split("/"));
+      const relative = import_node_path15.default.relative(outDir, target);
+      if (relative.startsWith("..") || import_node_path15.default.isAbsolute(relative)) {
         throw new Error(`[nasti] app artifact must stay inside build.outDir: ${file.fileName}`);
       }
       assertNoSymlinkComponents(outDir, fileName);
-      import_node_fs10.default.mkdirSync(import_node_path13.default.dirname(target), { recursive: true });
-      import_node_fs10.default.writeFileSync(target, file.source);
+      import_node_fs12.default.mkdirSync(import_node_path15.default.dirname(target), { recursive: true });
+      import_node_fs12.default.writeFileSync(target, file.source);
       const artifact = {
         ...file,
         fileName,
@@ -5418,10 +6739,10 @@ function joinPublicPath(base, fileName) {
   return `${base.endsWith("/") ? base : `${base}/`}${fileName.replace(/^\//, "")}`;
 }
 function normalizeEnvironmentFileName(fileName) {
-  return import_node_path13.default.posix.normalize(fileName.replace(/\\/g, "/").replace(/^\.\//, ""));
+  return import_node_path15.default.posix.normalize(fileName.replace(/\\/g, "/").replace(/^\.\//, ""));
 }
 function isInvalidEnvironmentFileName(fileName) {
-  return !fileName || fileName === "." || fileName === ".." || fileName.startsWith("../") || import_node_path13.default.posix.isAbsolute(fileName) || /^[A-Za-z]:\//.test(fileName);
+  return !fileName || fileName === "." || fileName === ".." || fileName.startsWith("../") || import_node_path15.default.posix.isAbsolute(fileName) || /^[A-Za-z]:\//.test(fileName);
 }
 function normalizeAppFileName(fileName) {
   const normalized = normalizeEnvironmentFileName(fileName);
@@ -5438,14 +6759,14 @@ function collectEnvironmentArtifacts(config, results, appOutDir) {
   for (const [environmentName, result] of Object.entries(results)) {
     const environment = config.environments[environmentName];
     if (!environment) continue;
-    const environmentOutDir = import_node_path13.default.resolve(config.root, environment.build.outDir);
+    const environmentOutDir = import_node_path15.default.resolve(config.root, environment.build.outDir);
     for (const artifact of result.output) {
-      const artifactPath = import_node_path13.default.resolve(
+      const artifactPath = import_node_path15.default.resolve(
         environmentOutDir,
         ...normalizeEnvironmentFileName(artifact.fileName).split("/")
       );
-      const relative = import_node_path13.default.relative(appOutDir, artifactPath);
-      if (!relative.startsWith("..") && !import_node_path13.default.isAbsolute(relative)) {
+      const relative = import_node_path15.default.relative(appOutDir, artifactPath);
+      if (!relative.startsWith("..") && !import_node_path15.default.isAbsolute(relative)) {
         occupied.add(artifactCollisionKey(relative));
       }
     }
@@ -5455,10 +6776,10 @@ function collectEnvironmentArtifacts(config, results, appOutDir) {
 function assertNoSymlinkComponents(outDir, fileName) {
   let current = outDir;
   for (const segment of fileName.split("/")) {
-    current = import_node_path13.default.join(current, segment);
+    current = import_node_path15.default.join(current, segment);
     let stats;
     try {
-      stats = import_node_fs10.default.lstatSync(current);
+      stats = import_node_fs12.default.lstatSync(current);
     } catch (error) {
       if (error.code === "ENOENT") continue;
       throw error;
@@ -5476,12 +6797,12 @@ function inferEnvironmentEntries(output) {
   }
   return Object.keys(entries).length > 0 ? entries : void 0;
 }
-var import_node_fs10, import_node_path13;
+var import_node_fs12, import_node_path15;
 var init_build_app_context = __esm({
   "src/core/build-app-context.ts"() {
     "use strict";
-    import_node_fs10 = __toESM(require("fs"), 1);
-    import_node_path13 = __toESM(require("path"), 1);
+    import_node_fs12 = __toESM(require("fs"), 1);
+    import_node_path15 = __toESM(require("path"), 1);
   }
 });
 
@@ -5498,7 +6819,7 @@ function getRolldownOptions(environment, entryPoints, rolldownPlugins) {
   const config = environment.config;
   const envOptions = environment.options;
   const isServer = environment.consumer === "server";
-  const outDir = import_node_path14.default.resolve(config.root, envOptions.build.outDir);
+  const outDir = import_node_path16.default.resolve(config.root, envOptions.build.outDir);
   const assetsDir = envOptions.build.assetsDir;
   const {
     output: userOutput,
@@ -5538,7 +6859,7 @@ function getRolldownOptions(environment, entryPoints, rolldownPlugins) {
       // 相对/绝对/虚拟模块照常打包。需要内联依赖时经 rolldownOptions.external 覆盖。
       external: restInputOptions.external ?? ((id) => {
         if (NODE_BUILTINS2.has(id)) return true;
-        return !id.startsWith(".") && !import_node_path14.default.isAbsolute(id) && !id.startsWith("\0") && !id.startsWith("virtual:");
+        return !id.startsWith(".") && !import_node_path16.default.isAbsolute(id) && !id.startsWith("\0") && !id.startsWith("virtual:");
       })
     } : {}
   };
@@ -5695,11 +7016,11 @@ function prepareBuildOutputDirectories(config, buildableNames) {
   const protectedPaths = /* @__PURE__ */ new Set();
   const clientIsBuilt = buildableNames.includes("client");
   if (!clientIsBuilt && config.build.emptyOutDir) {
-    directories.add(import_node_path14.default.resolve(config.root, config.build.outDir));
+    directories.add(import_node_path16.default.resolve(config.root, config.build.outDir));
   }
   for (const name of buildableNames) {
     const environment = config.environments[name];
-    const outDir = import_node_path14.default.resolve(config.root, environment.build.outDir);
+    const outDir = import_node_path16.default.resolve(config.root, environment.build.outDir);
     if (!environment.build.emptyOutDir) {
       protectedPaths.add(outDir);
       continue;
@@ -5707,8 +7028,8 @@ function prepareBuildOutputDirectories(config, buildableNames) {
     if (!environment.driver) directories.add(outDir);
   }
   const containsPath = (parent, child) => {
-    const relative = import_node_path14.default.relative(parent, child);
-    return relative === "" || !relative.startsWith("..") && !import_node_path14.default.isAbsolute(relative);
+    const relative = import_node_path16.default.relative(parent, child);
+    return relative === "" || !relative.startsWith("..") && !import_node_path16.default.isAbsolute(relative);
   };
   const roots = [...directories].filter(
     (directory) => ![...protectedPaths].some((protectedPath) => containsPath(directory, protectedPath))
@@ -5716,7 +7037,7 @@ function prepareBuildOutputDirectories(config, buildableNames) {
     (directory, index2, all) => !all.slice(0, index2).some((parent) => containsPath(parent, directory))
   );
   for (const directory of roots) {
-    if (import_node_fs11.default.existsSync(directory)) import_node_fs11.default.rmSync(directory, { recursive: true, force: true });
+    if (import_node_fs13.default.existsSync(directory)) import_node_fs13.default.rmSync(directory, { recursive: true, force: true });
   }
 }
 function assertDriverBuildResult(environment, result) {
@@ -5735,7 +7056,7 @@ function resolveClientEntries(config, html) {
   if (configuredEntries.length > 0) return configuredEntries;
   const entryPoints = [];
   const htmlFile = config.environments.client?.html;
-  const htmlDir = htmlFile ? import_node_path14.default.dirname(htmlFile) : config.root;
+  const htmlDir = htmlFile ? import_node_path16.default.dirname(htmlFile) : config.root;
   if (html) {
     const scriptMatches = html.matchAll(/<script[^>]+src=["']([^"']+)["'][^>]*>/gi);
     for (const match of scriptMatches) {
@@ -5743,7 +7064,7 @@ function resolveClientEntries(config, html) {
       if (src && !src.startsWith("http")) {
         const cleanSrc = src.split(/[?#]/, 1)[0];
         entryPoints.push(
-          cleanSrc.startsWith("/") ? import_node_path14.default.resolve(config.root, cleanSrc.replace(/^\//, "")) : import_node_path14.default.resolve(htmlDir, cleanSrc)
+          cleanSrc.startsWith("/") ? import_node_path16.default.resolve(config.root, cleanSrc.replace(/^\//, "")) : import_node_path16.default.resolve(htmlDir, cleanSrc)
         );
       }
     }
@@ -5751,8 +7072,8 @@ function resolveClientEntries(config, html) {
   if (entryPoints.length === 0) {
     const fallbackEntries = ["src/main.ts", "src/main.tsx", "src/main.js", "src/index.ts", "src/index.tsx", "src/index.js"];
     for (const entry of fallbackEntries) {
-      const fullPath = import_node_path14.default.resolve(config.root, entry);
-      if (import_node_fs11.default.existsSync(fullPath)) {
+      const fullPath = import_node_path16.default.resolve(config.root, entry);
+      if (import_node_fs13.default.existsSync(fullPath)) {
         entryPoints.push(fullPath);
         break;
       }
@@ -5782,7 +7103,7 @@ async function build(inlineConfig = {}) {
   const startTime = performance.now();
   logger.info(
     import_picocolors6.default.cyan(`
-nasti v${"2.5.0"} `) + import_picocolors6.default.green(`building for ${config.mode}...`)
+nasti v${"2.5.1"} `) + import_picocolors6.default.green(`building for ${config.mode}...`)
   );
   debug6?.(`root: ${config.root}`);
   const buildableNames = Object.keys(config.environments).filter((name) => {
@@ -5857,7 +7178,7 @@ nasti v${"2.5.0"} `) + import_picocolors6.default.green(`building for ${config.m
 }
 async function buildClientEnvironment(config) {
   const logger = config.logger;
-  const outDir = import_node_path14.default.resolve(config.root, config.build.outDir);
+  const outDir = import_node_path16.default.resolve(config.root, config.build.outDir);
   const cssEngine = createCssEngine();
   const pluginList = resolvePluginList(config, config.plugins, {
     cssEngine,
@@ -5880,8 +7201,8 @@ async function buildClientEnvironment(config) {
       assertDriverBuildResult(clientEnv, result);
       return { environment: clientEnv, result: finalizeEnvironmentResult(clientEnv, result) };
     }
-    import_node_fs11.default.mkdirSync(outDir, { recursive: true });
-    const htmlFile = config.environments.client.html ?? import_node_path14.default.resolve(config.root, "index.html");
+    import_node_fs13.default.mkdirSync(outDir, { recursive: true });
+    const htmlFile = config.environments.client.html ?? import_node_path16.default.resolve(config.root, "index.html");
     const html = await readHtmlFile(config.root, htmlFile);
     const entryPoints = resolveClientEntries(config, html);
     if (entryPoints.length === 0) {
@@ -5931,7 +7252,7 @@ async function buildClientEnvironment(config) {
           );
         }
       }
-      import_node_fs11.default.writeFileSync(import_node_path14.default.resolve(outDir, "index.html"), processedHtml);
+      import_node_fs13.default.writeFileSync(import_node_path16.default.resolve(outDir, "index.html"), processedHtml);
     }
     if (!nativeReporter && config.logLevel !== "silent") {
       reportBuildOutput(output, config, logger);
@@ -5985,7 +7306,7 @@ async function buildServerEnvironment(config, name) {
     }
   }
   for (const entry of envOptions.entry) {
-    if (!import_node_fs11.default.existsSync(entry)) {
+    if (!import_node_fs13.default.existsSync(entry)) {
       await environment.close();
       throw new Error(`[nasti] environment "${name}" entry not found: ${entry}`);
     }
@@ -5999,13 +7320,13 @@ async function buildServerEnvironment(config, name) {
     envOptions.entry,
     rolldownPlugins
   );
-  import_node_fs11.default.mkdirSync(outDir, { recursive: true });
+  import_node_fs13.default.mkdirSync(outDir, { recursive: true });
   const bundle2 = await (0, import_rolldown.rolldown)(inputOptions);
   const { output } = await bundle2.write(outputOptions);
   await bundle2.close();
   if (cssEngine) environment.setBuildMetadata({ css: getCssMetadata(cssEngine) });
   logger.info(
-    import_picocolors6.default.dim(`  [${name}] `) + output.map((o) => import_node_path14.default.join(envOptions.build.outDir, o.fileName)).join(import_picocolors6.default.dim(", "))
+    import_picocolors6.default.dim(`  [${name}] `) + output.map((o) => import_node_path16.default.join(envOptions.build.outDir, o.fileName)).join(import_picocolors6.default.dim(", "))
   );
   return {
     environment,
@@ -6037,9 +7358,9 @@ function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function replaceEntryScript(html, facadeModuleId, fileName, config, htmlFile, urlPrefix) {
-  const rootRelative = import_node_path14.default.relative(config.root, facadeModuleId).split(import_node_path14.default.sep).join("/");
-  const resolvedHtmlFile = import_node_path14.default.resolve(config.root, htmlFile);
-  const htmlRelative = import_node_path14.default.relative(import_node_path14.default.dirname(resolvedHtmlFile), facadeModuleId).split(import_node_path14.default.sep).join("/");
+  const rootRelative = import_node_path16.default.relative(config.root, facadeModuleId).split(import_node_path16.default.sep).join("/");
+  const resolvedHtmlFile = import_node_path16.default.resolve(config.root, htmlFile);
+  const htmlRelative = import_node_path16.default.relative(import_node_path16.default.dirname(resolvedHtmlFile), facadeModuleId).split(import_node_path16.default.sep).join("/");
   const candidates = /* @__PURE__ */ new Set([
     rootRelative,
     `/${rootRelative}`,
@@ -6055,13 +7376,13 @@ function replaceEntryScript(html, facadeModuleId, fileName, config, htmlFile, ur
   }
   return processed;
 }
-var import_node_path14, import_node_fs11, import_node_module5, import_rolldown, import_picocolors6, debug6, NODE_BUILTINS2;
+var import_node_path16, import_node_fs13, import_node_module6, import_rolldown, import_picocolors6, debug6, NODE_BUILTINS2;
 var init_build = __esm({
   "src/build/index.ts"() {
     "use strict";
-    import_node_path14 = __toESM(require("path"), 1);
-    import_node_fs11 = __toESM(require("fs"), 1);
-    import_node_module5 = require("module");
+    import_node_path16 = __toESM(require("path"), 1);
+    import_node_fs13 = __toESM(require("fs"), 1);
+    import_node_module6 = require("module");
     import_rolldown = require("rolldown");
     init_config();
     init_builtins();
@@ -6077,7 +7398,7 @@ var init_build = __esm({
     init_build_app_context();
     import_picocolors6 = __toESM(require("picocolors"), 1);
     debug6 = createDebugger("nasti:build");
-    NODE_BUILTINS2 = /* @__PURE__ */ new Set([...import_node_module5.builtinModules, ...import_node_module5.builtinModules.map((m) => `node:${m}`)]);
+    NODE_BUILTINS2 = /* @__PURE__ */ new Set([...import_node_module6.builtinModules, ...import_node_module6.builtinModules.map((m) => `node:${m}`)]);
   }
 });
 
@@ -6167,7 +7488,7 @@ async function createBundledDevServer(opts) {
       }
       const url = `/${patchPath}`;
       logger.info(
-        import_picocolors7.default.green("hmr update ") + import_picocolors7.default.dim(changedFiles.map((f) => import_node_path15.default.relative(config.root, f)).join(", ")),
+        import_picocolors7.default.green("hmr update ") + import_picocolors7.default.dim(changedFiles.map((f) => import_node_path17.default.relative(config.root, f)).join(", ")),
         { timestamp: true }
       );
       sendTo(clientId, { type: "hmr:update", path: url, url });
@@ -6322,7 +7643,7 @@ async function createBundledDevServer(opts) {
           return;
         }
         res.setHeader("ETag", hit.etag);
-        res.setHeader("Content-Type", MIME_TYPES[import_node_path15.default.extname(fileName)] ?? "application/octet-stream");
+        res.setHeader("Content-Type", MIME_TYPES[import_node_path17.default.extname(fileName)] ?? "application/octet-stream");
         res.setHeader("Cache-Control", "no-cache");
         res.once("finish", () => {
           void engine.notifyPayloadDelivered(fileName).catch(
@@ -6363,7 +7684,7 @@ function stripCatchAllLoad(plugins) {
   );
 }
 function createReactRefreshRuntimePlugin(entryPoints) {
-  const entryIds = new Set(entryPoints.map((p) => import_node_path15.default.resolve(p)));
+  const entryIds = new Set(entryPoints.map((p) => import_node_path17.default.resolve(p)));
   return {
     name: "nasti:bundled-react-refresh",
     resolveId(source) {
@@ -6381,7 +7702,7 @@ function createReactRefreshRuntimePlugin(entryPoints) {
       return null;
     },
     transform(code, id) {
-      if (!entryIds.has(import_node_path15.default.resolve(id.split("?")[0]))) return null;
+      if (!entryIds.has(import_node_path17.default.resolve(id.split("?")[0]))) return null;
       return { code: `import ${JSON.stringify(PREAMBLE_SPEC)};
 ${code}`, map: null };
     }
@@ -6431,11 +7752,11 @@ async function renderBundledIndexHtml(html, config, entryFileNames) {
   }
   return processed;
 }
-var import_node_path15, import_node_crypto3, import_ws2, import_picocolors7, debug7, MIME_TYPES, MemoryFiles, PREAMBLE_SPEC, RESOLVED_PREAMBLE_ID, REFRESH_RUNTIME_URL, BUNDLED_PREAMBLE_CODE, WRAPPER_RUNTIME_HELPERS;
+var import_node_path17, import_node_crypto3, import_ws2, import_picocolors7, debug7, MIME_TYPES, MemoryFiles, PREAMBLE_SPEC, RESOLVED_PREAMBLE_ID, REFRESH_RUNTIME_URL, BUNDLED_PREAMBLE_CODE, WRAPPER_RUNTIME_HELPERS;
 var init_dev_engine = __esm({
   "src/server/bundled/dev-engine.ts"() {
     "use strict";
-    import_node_path15 = __toESM(require("path"), 1);
+    import_node_path17 = __toESM(require("path"), 1);
     import_node_crypto3 = __toESM(require("crypto"), 1);
     import_ws2 = require("ws");
     import_picocolors7 = __toESM(require("picocolors"), 1);
@@ -6645,19 +7966,19 @@ async function createServer(inlineConfig = {}) {
     app.use(bundledServer.middleware);
   }
   const ignoredSegments = /* @__PURE__ */ new Set(["node_modules", ".git", ".nasti"]);
-  const outDirAbs = import_node_path16.default.resolve(config.root, config.build.outDir);
+  const outDirAbs = import_node_path18.default.resolve(config.root, config.build.outDir);
   const linkedPackageRoots = getLinkedPackageRoots(config.root).filter(
     (r) => r !== config.root && !isUnderRoot(config.root, r)
   );
   const watchTargets = [config.root, ...linkedPackageRoots];
   const watcher = (0, import_chokidar.watch)(watchTargets, {
     ignored: (filePath) => {
-      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + import_node_path16.default.sep)) return true;
+      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + import_node_path18.default.sep)) return true;
       for (const watchRoot of watchTargets) {
         if (filePath === watchRoot) return false;
-        const rel = import_node_path16.default.relative(watchRoot, filePath);
-        if (!rel || rel.startsWith("..") || import_node_path16.default.isAbsolute(rel)) continue;
-        for (const seg of rel.split(import_node_path16.default.sep)) {
+        const rel = import_node_path18.default.relative(watchRoot, filePath);
+        if (!rel || rel.startsWith("..") || import_node_path18.default.isAbsolute(rel)) continue;
+        for (const seg of rel.split(import_node_path18.default.sep)) {
           if (ignoredSegments.has(seg)) return true;
         }
         return false;
@@ -6789,7 +8110,7 @@ async function createServer(inlineConfig = {}) {
     });
   };
   watcher.on("change", (file) => {
-    if (file.includes(`${import_node_path16.default.sep}node_modules${import_node_path16.default.sep}`) || file.endsWith(`${import_node_path16.default.sep}node_modules`)) {
+    if (file.includes(`${import_node_path18.default.sep}node_modules${import_node_path18.default.sep}`) || file.endsWith(`${import_node_path18.default.sep}node_modules`)) {
       clearLinkedPackageRootsCache();
     }
     ssrRunner?.invalidateFile(file);
@@ -6797,7 +8118,7 @@ async function createServer(inlineConfig = {}) {
     notifyEnvironmentDrivers(file, "change");
   });
   watcher.on("add", (file) => {
-    if (file.includes(`${import_node_path16.default.sep}node_modules${import_node_path16.default.sep}`) || file.endsWith(`${import_node_path16.default.sep}node_modules`)) {
+    if (file.includes(`${import_node_path18.default.sep}node_modules${import_node_path18.default.sep}`) || file.endsWith(`${import_node_path18.default.sep}node_modules`)) {
       clearLinkedPackageRootsCache();
     }
     ssrRunner?.invalidateFile(file);
@@ -6805,7 +8126,7 @@ async function createServer(inlineConfig = {}) {
     notifyEnvironmentDrivers(file, "add");
   });
   watcher.on("unlink", (file) => {
-    if (file.includes(`${import_node_path16.default.sep}node_modules${import_node_path16.default.sep}`) || file.endsWith(`${import_node_path16.default.sep}node_modules`)) {
+    if (file.includes(`${import_node_path18.default.sep}node_modules${import_node_path18.default.sep}`) || file.endsWith(`${import_node_path18.default.sep}node_modules`)) {
       clearLinkedPackageRootsCache();
     }
     ssrRunner?.invalidateFile(file);
@@ -6837,7 +8158,7 @@ async function createServer(inlineConfig = {}) {
           const readyIn = Math.ceil(performance.now() - startTime);
           logger.info(
             `
-  ${import_picocolors8.default.cyan(import_picocolors8.default.bold("NASTI"))} ${import_picocolors8.default.cyan(`v${"2.5.0"}`)}  ${import_picocolors8.default.dim("ready in")} ${import_picocolors8.default.bold(readyIn)} ${import_picocolors8.default.dim("ms")}
+  ${import_picocolors8.default.cyan(import_picocolors8.default.bold("NASTI"))} ${import_picocolors8.default.cyan(`v${"2.5.1"}`)}  ${import_picocolors8.default.dim("ready in")} ${import_picocolors8.default.bold(readyIn)} ${import_picocolors8.default.dim("ms")}
 `
           );
           printServerUrls(
@@ -6934,7 +8255,7 @@ async function createServer(inlineConfig = {}) {
     throw error;
   }
   app.use(transformMiddleware(transformContexts.get("client")));
-  const publicDir = import_node_path16.default.resolve(config.root, "public");
+  const publicDir = import_node_path18.default.resolve(config.root, "public");
   app.use((0, import_sirv.default)(publicDir, { dev: true, etag: true }));
   app.use((0, import_sirv.default)(config.root, { dev: true, etag: true }));
   const postMiddlewares = [];
@@ -6960,12 +8281,12 @@ function getNetworkAddress() {
   }
   return "localhost";
 }
-var import_node_http, import_node_path16, import_node_os, import_connect, import_sirv, import_chokidar, import_picocolors8;
+var import_node_http, import_node_path18, import_node_os, import_connect, import_sirv, import_chokidar, import_picocolors8;
 var init_server = __esm({
   "src/server/index.ts"() {
     "use strict";
     import_node_http = __toESM(require("http"), 1);
-    import_node_path16 = __toESM(require("path"), 1);
+    import_node_path18 = __toESM(require("path"), 1);
     import_node_os = __toESM(require("os"), 1);
     import_connect = __toESM(require("connect"), 1);
     import_sirv = __toESM(require("sirv"), 1);
@@ -7006,14 +8327,14 @@ function electronPlugin(config) {
     }
   };
 }
-var import_node_module6, NODE_BUILTINS3, ELECTRON_MODULES;
+var import_node_module7, NODE_BUILTINS3, ELECTRON_MODULES;
 var init_electron = __esm({
   "src/plugins/electron.ts"() {
     "use strict";
-    import_node_module6 = require("module");
+    import_node_module7 = require("module");
     NODE_BUILTINS3 = /* @__PURE__ */ new Set([
-      ...import_node_module6.builtinModules,
-      ...import_node_module6.builtinModules.map((m) => `node:${m}`)
+      ...import_node_module7.builtinModules,
+      ...import_node_module7.builtinModules.map((m) => `node:${m}`)
     ]);
     ELECTRON_MODULES = /* @__PURE__ */ new Set([
       "electron",
@@ -7036,16 +8357,16 @@ async function buildElectron(inlineConfig = {}) {
   const config = await resolveConfig({ ...inlineConfig, target: "electron" }, "build");
   const startTime = performance.now();
   assertElectronVersion(config);
-  console.log(import_picocolors9.default.cyan("\n\u26A1 nasti build (electron)") + import_picocolors9.default.dim(` v${"2.5.0"}`));
+  console.log(import_picocolors9.default.cyan("\n\u26A1 nasti build (electron)") + import_picocolors9.default.dim(` v${"2.5.1"}`));
   console.log(import_picocolors9.default.dim(`  root: ${config.root}`));
   console.log(import_picocolors9.default.dim(`  mode: ${config.mode}`));
   console.log(import_picocolors9.default.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
-  const outDir = import_node_path17.default.resolve(config.root, config.build.outDir);
-  if (config.build.emptyOutDir && import_node_fs12.default.existsSync(outDir)) {
-    import_node_fs12.default.rmSync(outDir, { recursive: true, force: true });
+  const outDir = import_node_path19.default.resolve(config.root, config.build.outDir);
+  if (config.build.emptyOutDir && import_node_fs14.default.existsSync(outDir)) {
+    import_node_fs14.default.rmSync(outDir, { recursive: true, force: true });
   }
-  import_node_fs12.default.mkdirSync(outDir, { recursive: true });
-  const rendererOutDir = import_node_path17.default.join(outDir, "renderer");
+  import_node_fs14.default.mkdirSync(outDir, { recursive: true });
+  const rendererOutDir = import_node_path19.default.join(outDir, "renderer");
   const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
   await build2(createElectronRendererConfig(config, inlineConfig, {
     build: {
@@ -7054,8 +8375,8 @@ async function buildElectron(inlineConfig = {}) {
       emptyOutDir: false
     }
   }));
-  const mainEntry = import_node_path17.default.resolve(config.root, config.electron.main);
-  if (!import_node_fs12.default.existsSync(mainEntry)) {
+  const mainEntry = import_node_path19.default.resolve(config.root, config.electron.main);
+  if (!import_node_fs14.default.existsSync(mainEntry)) {
     throw new Error(
       `Electron main entry not found: ${config.electron.main}
 \u5728 nasti.config.ts \u7684 electron.main \u6307\u5B9A\u4E3B\u8FDB\u7A0B\u5165\u53E3\u6587\u4EF6\u3002`
@@ -7069,11 +8390,11 @@ async function buildElectron(inlineConfig = {}) {
   const preloadEntries = normalizePreload(config.electron.preload, config.root);
   const preloadFiles = [];
   for (const entry of preloadEntries) {
-    if (!import_node_fs12.default.existsSync(entry)) {
+    if (!import_node_fs14.default.existsSync(entry)) {
       console.warn(import_picocolors9.default.yellow(`  \u26A0 preload entry not found, skipped: ${entry}`));
       continue;
     }
-    const base = import_node_path17.default.basename(entry).replace(/\.[^.]+$/, "");
+    const base = import_node_path19.default.basename(entry).replace(/\.[^.]+$/, "");
     const out = outFileName(outDir, base, config.electron.preloadFormat);
     await bundleNode(config, entry, {
       outFile: out,
@@ -7085,10 +8406,10 @@ async function buildElectron(inlineConfig = {}) {
   const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
   console.log(import_picocolors9.default.green(`
 \u2713 Electron build complete in ${elapsed}s`));
-  console.log(import_picocolors9.default.dim(`  renderer: ${import_node_path17.default.relative(config.root, rendererOutDir)}/`));
-  console.log(import_picocolors9.default.dim(`  main:     ${import_node_path17.default.relative(config.root, mainFile)}`));
+  console.log(import_picocolors9.default.dim(`  renderer: ${import_node_path19.default.relative(config.root, rendererOutDir)}/`));
+  console.log(import_picocolors9.default.dim(`  main:     ${import_node_path19.default.relative(config.root, mainFile)}`));
   for (const pf of preloadFiles) {
-    console.log(import_picocolors9.default.dim(`  preload:  ${import_node_path17.default.relative(config.root, pf)}`));
+    console.log(import_picocolors9.default.dim(`  preload:  ${import_node_path19.default.relative(config.root, pf)}`));
   }
   console.log();
   return { rendererOutDir, mainFile, preloadFiles };
@@ -7133,7 +8454,7 @@ async function bundleNode(config, entry, opts) {
     },
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)]
   });
-  import_node_fs12.default.mkdirSync(import_node_path17.default.dirname(opts.outFile), { recursive: true });
+  import_node_fs14.default.mkdirSync(import_node_path19.default.dirname(opts.outFile), { recursive: true });
   await bundle2.write({
     sourcemap: !!config.build.sourcemap,
     minify: !!config.build.minify,
@@ -7144,7 +8465,7 @@ async function bundleNode(config, entry, opts) {
     codeSplitting: false
   });
   await bundle2.close();
-  console.log(import_picocolors9.default.dim(`  \u2713 ${opts.label} \u2192 ${import_node_path17.default.relative(config.root, opts.outFile)}`));
+  console.log(import_picocolors9.default.dim(`  \u2713 ${opts.label} \u2192 ${import_node_path19.default.relative(config.root, opts.outFile)}`));
   return opts.outFile;
 }
 function createElectronRendererConfig(config, inlineConfig = {}, overrides = {}) {
@@ -7166,13 +8487,13 @@ function createElectronRendererConfig(config, inlineConfig = {}, overrides = {})
     }
   };
 }
-function outFileName(outDir, base, format) {
-  const ext = format === "cjs" ? ".cjs" : ".mjs";
-  return import_node_path17.default.join(outDir, base + ext);
+function outFileName(outDir, base, format2) {
+  const ext = format2 === "cjs" ? ".cjs" : ".mjs";
+  return import_node_path19.default.join(outDir, base + ext);
 }
 function normalizePreload(preload, root) {
   const list = Array.isArray(preload) ? preload : preload ? [preload] : [];
-  return list.map((p) => import_node_path17.default.resolve(root, p));
+  return list.map((p) => import_node_path19.default.resolve(root, p));
 }
 function assertElectronVersion(config) {
   const min = config.electron.minVersion;
@@ -7187,16 +8508,16 @@ function assertElectronVersion(config) {
 }
 function detectInstalledElectron(root) {
   try {
-    const require2 = (0, import_node_module7.createRequire)(import_node_path17.default.resolve(root, "package.json"));
+    const require2 = (0, import_node_module8.createRequire)(import_node_path19.default.resolve(root, "package.json"));
     const pkgPath = require2.resolve("electron/package.json");
-    const pkg = JSON.parse(import_node_fs12.default.readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(import_node_fs14.default.readFileSync(pkgPath, "utf-8"));
     const major = parseInt(String(pkg.version).split(".")[0], 10);
     return Number.isFinite(major) ? major : null;
   } catch {
     try {
-      const pkgPath = import_node_path17.default.resolve(root, "node_modules/electron/package.json");
-      if (!import_node_fs12.default.existsSync(pkgPath)) return null;
-      const pkg = JSON.parse(import_node_fs12.default.readFileSync(pkgPath, "utf-8"));
+      const pkgPath = import_node_path19.default.resolve(root, "node_modules/electron/package.json");
+      if (!import_node_fs14.default.existsSync(pkgPath)) return null;
+      const pkg = JSON.parse(import_node_fs14.default.readFileSync(pkgPath, "utf-8"));
       const major = parseInt(String(pkg.version).split(".")[0], 10);
       return Number.isFinite(major) ? major : null;
     } catch {
@@ -7204,13 +8525,13 @@ function detectInstalledElectron(root) {
     }
   }
 }
-var import_node_path17, import_node_fs12, import_node_module7, import_rolldown2, import_picocolors9;
+var import_node_path19, import_node_fs14, import_node_module8, import_rolldown2, import_picocolors9;
 var init_electron2 = __esm({
   "src/build/electron.ts"() {
     "use strict";
-    import_node_path17 = __toESM(require("path"), 1);
-    import_node_fs12 = __toESM(require("fs"), 1);
-    import_node_module7 = require("module");
+    import_node_path19 = __toESM(require("path"), 1);
+    import_node_fs14 = __toESM(require("fs"), 1);
+    import_node_module8 = require("module");
     import_rolldown2 = require("rolldown");
     import_picocolors9 = __toESM(require("picocolors"), 1);
     init_config();
@@ -7231,7 +8552,7 @@ async function startElectronDev(inlineConfig = {}) {
   const { noSpawn, ...rest } = inlineConfig;
   const config = await resolveConfig({ ...rest, target: "electron" }, "serve");
   warnElectronVersion(config);
-  console.log(import_picocolors10.default.cyan("\n\u26A1 nasti electron dev") + import_picocolors10.default.dim(` v${"2.5.0"}`));
+  console.log(import_picocolors10.default.cyan("\n\u26A1 nasti electron dev") + import_picocolors10.default.dim(` v${"2.5.1"}`));
   const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
   const server = await createServer2({
     ...rest,
@@ -7241,11 +8562,11 @@ async function startElectronDev(inlineConfig = {}) {
   await server.listen();
   const devUrl = `http://localhost:${server.config.server.port}` + electronRendererDevPath(config.electron.renderer);
   console.log(import_picocolors10.default.dim(`  renderer: ${devUrl}`));
-  const stageDir = import_node_path18.default.resolve(config.root, ".nasti");
-  import_node_fs13.default.mkdirSync(stageDir, { recursive: true });
-  const mainEntry = import_node_path18.default.resolve(config.root, config.electron.main);
+  const stageDir = import_node_path20.default.resolve(config.root, ".nasti");
+  import_node_fs15.default.mkdirSync(stageDir, { recursive: true });
+  const mainEntry = import_node_path20.default.resolve(config.root, config.electron.main);
   const preloadEntries = normalizePreload(config.electron.preload, config.root);
-  const builtMainFile = import_node_path18.default.join(stageDir, "main" + extFor(config.electron.mainFormat));
+  const builtMainFile = import_node_path20.default.join(stageDir, "main" + extFor(config.electron.mainFormat));
   const builtPreloadFiles = [];
   const compileAll = async () => {
     await compileNode(config, mainEntry, {
@@ -7255,9 +8576,9 @@ async function startElectronDev(inlineConfig = {}) {
     });
     builtPreloadFiles.length = 0;
     for (const entry of preloadEntries) {
-      if (!import_node_fs13.default.existsSync(entry)) continue;
-      const base = import_node_path18.default.basename(entry).replace(/\.[^.]+$/, "");
-      const out = import_node_path18.default.join(stageDir, base + extFor(config.electron.preloadFormat));
+      if (!import_node_fs15.default.existsSync(entry)) continue;
+      const base = import_node_path20.default.basename(entry).replace(/\.[^.]+$/, "");
+      const out = import_node_path20.default.join(stageDir, base + extFor(config.electron.preloadFormat));
       await compileNode(config, entry, {
         outFile: out,
         format: config.electron.preloadFormat,
@@ -7296,7 +8617,7 @@ async function startElectronDev(inlineConfig = {}) {
   };
   spawnElectron();
   if (config.electron.autoRestart) {
-    const watchTargets = [mainEntry, ...preloadEntries].filter(import_node_fs13.default.existsSync);
+    const watchTargets = [mainEntry, ...preloadEntries].filter(import_node_fs15.default.existsSync);
     const watcher = import_chokidar2.default.watch(watchTargets, { ignoreInitial: true });
     let restarting = null;
     let pending = false;
@@ -7343,8 +8664,8 @@ async function startElectronDev(inlineConfig = {}) {
     });
   }
 }
-function extFor(format) {
-  return format === "cjs" ? ".cjs" : ".mjs";
+function extFor(format2) {
+  return format2 === "cjs" ? ".cjs" : ".mjs";
 }
 async function compileNode(config, entry, opts) {
   const env = loadEnv(config.mode, config.root, config.envPrefix);
@@ -7383,7 +8704,7 @@ async function compileNode(config, entry, opts) {
     platform: "node",
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)]
   });
-  import_node_fs13.default.mkdirSync(import_node_path18.default.dirname(opts.outFile), { recursive: true });
+  import_node_fs15.default.mkdirSync(import_node_path20.default.dirname(opts.outFile), { recursive: true });
   await bundle2.write({
     file: opts.outFile,
     format: opts.format === "cjs" ? "cjs" : "esm",
@@ -7396,18 +8717,18 @@ async function compileNode(config, entry, opts) {
   await bundle2.close();
 }
 function electronRendererDevPath(renderer) {
-  const normalized = renderer.split(import_node_path18.default.sep).join("/").replace(/^\.?\//, "");
+  const normalized = renderer.split(import_node_path20.default.sep).join("/").replace(/^\.?\//, "");
   return normalized === "index.html" ? "/" : `/${normalized}`;
 }
 function resolveElectronBinary(config) {
-  if (config.electron.electronPath && import_node_fs13.default.existsSync(config.electron.electronPath)) {
+  if (config.electron.electronPath && import_node_fs15.default.existsSync(config.electron.electronPath)) {
     return config.electron.electronPath;
   }
   try {
-    const require2 = (0, import_node_module8.createRequire)(import_node_path18.default.resolve(config.root, "package.json"));
+    const require2 = (0, import_node_module9.createRequire)(import_node_path20.default.resolve(config.root, "package.json"));
     const pathFile = require2.resolve("electron");
     const electronModule = require2(pathFile);
-    if (typeof electronModule === "string" && import_node_fs13.default.existsSync(electronModule)) {
+    if (typeof electronModule === "string" && import_node_fs15.default.existsSync(electronModule)) {
       return electronModule;
     }
   } catch {
@@ -7432,13 +8753,13 @@ function warnElectronVersion(config) {
     );
   }
 }
-var import_node_path18, import_node_fs13, import_node_module8, import_node_child_process, import_chokidar2, import_picocolors10, import_rolldown3;
+var import_node_path20, import_node_fs15, import_node_module9, import_node_child_process, import_chokidar2, import_picocolors10, import_rolldown3;
 var init_electron_dev = __esm({
   "src/server/electron-dev.ts"() {
     "use strict";
-    import_node_path18 = __toESM(require("path"), 1);
-    import_node_fs13 = __toESM(require("fs"), 1);
-    import_node_module8 = require("module");
+    import_node_path20 = __toESM(require("path"), 1);
+    import_node_fs15 = __toESM(require("fs"), 1);
+    import_node_module9 = require("module");
     import_node_child_process = require("child_process");
     import_chokidar2 = __toESM(require("chokidar"), 1);
     import_picocolors10 = __toESM(require("picocolors"), 1);
@@ -7590,20 +8911,20 @@ cli.command("preview [root]", "Preview production build").option("--port <port>"
   const logger = createCliLogger(options);
   try {
     const http2 = await import("http");
-    const path19 = await import("path");
+    const path21 = await import("path");
     const os2 = await import("os");
     const sirv2 = (await import("sirv")).default;
     const connect2 = (await import("connect")).default;
     const { printServerUrls: printServerUrls2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
-    const resolvedRoot = path19.resolve(root ?? ".");
-    const outDir = path19.resolve(resolvedRoot, options.outDir);
+    const resolvedRoot = path21.resolve(root ?? ".");
+    const outDir = path21.resolve(resolvedRoot, options.outDir);
     const app = connect2();
     app.use(sirv2(outDir, { single: true, etag: true, gzip: true, brotli: true }));
     const port = options.port;
     const host = options.host === true ? "0.0.0.0" : options.host ?? "localhost";
     http2.createServer(app).listen(port, host, () => {
       logger.info(`
-  ${import_picocolors11.default.cyan(import_picocolors11.default.bold("NASTI"))} ${import_picocolors11.default.cyan(`v${"2.5.0"}`)}  ${import_picocolors11.default.dim("preview")}
+  ${import_picocolors11.default.cyan(import_picocolors11.default.bold("NASTI"))} ${import_picocolors11.default.cyan(`v${"2.5.1"}`)}  ${import_picocolors11.default.dim("preview")}
 `);
       printServerUrls2(
         {
@@ -7620,6 +8941,6 @@ cli.command("preview [root]", "Preview production build").option("--port <port>"
   }
 });
 cli.help();
-cli.version("2.5.0");
+cli.version("2.5.1");
 cli.parse();
 //# sourceMappingURL=cli.cjs.map