storybook 10.0.7 → 10.0.8

package/dist/_node-chunks/{chunk-ODTNT22I.js → chunk-425EMBPZ.js}

@@ -1,10 +1,10 @@
-import CJS_COMPAT_NODE_URL_gikfs3u543o from 'node:url';
-import CJS_COMPAT_NODE_PATH_gikfs3u543o from 'node:path';
-import CJS_COMPAT_NODE_MODULE_gikfs3u543o from "node:module";
+import CJS_COMPAT_NODE_URL_39zvq8kkt8 from 'node:url';
+import CJS_COMPAT_NODE_PATH_39zvq8kkt8 from 'node:path';
+import CJS_COMPAT_NODE_MODULE_39zvq8kkt8 from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_gikfs3u543o.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_gikfs3u543o.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_gikfs3u543o.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_39zvq8kkt8.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_39zvq8kkt8.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_39zvq8kkt8.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
@@ -12,14 +12,14 @@ var require = CJS_COMPAT_NODE_MODULE_gikfs3u543o.createRequire(import.meta.url);
 import {
   dirname,
   join
-} from "./chunk-WRVTNG75.js";
+} from "./chunk-J5R55OCP.js";
 import {
   __name
-} from "./chunk-H6EU5XDR.js";
+} from "./chunk-JBW3FROT.js";
 
 // ../node_modules/exsolve/dist/index.mjs
-import fs, { realpathSync, statSync, lstatSync } from "node:fs";
-import { fileURLToPath, URL as URL$1, pathToFileURL } from "node:url";
+import fs, { lstatSync, realpathSync, statSync } from "node:fs";
+import { URL as URL$1, fileURLToPath, pathToFileURL } from "node:url";
 import path, { isAbsolute } from "node:path";
 import assert from "node:assert";
 import process$1 from "node:process";
@@ -102,7 +102,6 @@ var kTypes = /* @__PURE__ */ new Set([
   "function",
   "number",
   "object",
-  // Accept 'Function' and 'Object' as alternative to the lower cased version.
   "Function",
   "Object",
   "boolean",
@@ -129,8 +128,6 @@ function makeNodeErrorWithCode(Base, key) {
     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,
@@ -138,7 +135,6 @@ function makeNodeErrorWithCode(Base, key) {
         configurable: true
       },
       toString: {
-        /** @this {Error} */
         value() {
           return `${this.name} [${key}]: ${this.message}`;
         },
@@ -155,15 +151,11 @@ function makeNodeErrorWithCode(Base, key) {
 __name(makeNodeErrorWithCode, "makeNodeErrorWithCode");
 function isErrorStackTraceLimitWritable() {
   try {
-    if (v8.startupSnapshot.isBuildingSnapshot()) {
-      return false;
-    }
+    if (v8.startupSnapshot.isBuildingSnapshot()) return false;
   } catch {
   }
   const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
-  if (desc === void 0) {
-    return Object.isExtensible(Error);
-  }
+  if (desc === void 0) return Object.isExtensible(Error);
   return own$1.call(desc, "writable") && desc.writable !== void 0 ? desc.writable : desc.set !== void 0;
 }
 __name(isErrorStackTraceLimitWritable, "isErrorStackTraceLimitWritable");
@@ -185,225 +177,140 @@ var captureLargerStackTrace = hideStackFrames(function(error) {
 });
 function getMessage(key, parameters, self) {
   const message = messages.get(key);
-  assert(message !== void 0, "expected `message` to be found");
+  assert.ok(message !== void 0, "expected `message` to be found");
   if (typeof message === "function") {
-    assert(
-      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}).`
-    );
+    assert.ok(message.length <= parameters.length, `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++;
-  assert(
-    expectedLength === parameters.length,
-    `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${expectedLength}).`
-  );
+  assert.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(format, null, parameters);
 }
 __name(getMessage, "getMessage");
 function determineSpecificType(value) {
-  if (value === null || value === void 0) {
-    return String(value);
-  }
-  if (typeof value === "function" && value.name) {
-    return `function ${value.name}`;
-  }
+  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}`;
-    }
+    if (value.constructor && value.constructor.name) return `an instance of ${value.constructor.name}`;
     return `${inspect(value, { depth: -1 })}`;
   }
   let inspected = inspect(value, { colors: false });
-  if (inspected.length > 28) {
-    inspected = `${inspected.slice(0, 25)}...`;
-  }
+  if (inspected.length > 28) inspected = `${inspected.slice(0, 25)}...`;
   return `type ${typeof value} (${inspected})`;
 }
 __name(determineSpecificType, "determineSpecificType");
-createError(
-  "ERR_INVALID_ARG_TYPE",
-  (name, expected, actual) => {
-    assert(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) {
-      assert(
-        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) {
-        assert(
-          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]}`;
-      }
+var ERR_INVALID_ARG_TYPE = createError("ERR_INVALID_ARG_TYPE", (name, expected, actual) => {
+  assert.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) {
+    assert.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) {
+      assert.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");
     }
-    message += `. Received ${determineSpecificType(actual)}`;
-    return message;
-  },
-  TypeError
-);
+  }
+  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);
 var ERR_INVALID_MODULE_SPECIFIER = createError(
   "ERR_INVALID_MODULE_SPECIFIER",
   /**
-   * @param {string} request
-   * @param {string} reason
-   * @param {string} [base]
-   */
+  * @param {string} request
+  * @param {string} reason
+  * @param {string} [base]
+  */
   (request, reason, base) => {
     return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
   },
   TypeError
 );
-var ERR_INVALID_PACKAGE_CONFIG = createError(
-  "ERR_INVALID_PACKAGE_CONFIG",
-  (path2, base, message) => {
-    return `Invalid package config ${path2}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
-  },
-  Error
-);
-var ERR_INVALID_PACKAGE_TARGET = createError(
-  "ERR_INVALID_PACKAGE_TARGET",
-  (packagePath, key, target, isImport = false, base) => {
-    const relatedError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
-    if (key === ".") {
-      assert(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
-);
-var ERR_MODULE_NOT_FOUND = createError(
-  "ERR_MODULE_NOT_FOUND",
-  (path2, base, exactUrl = false) => {
-    return `Cannot find ${exactUrl ? "module" : "package"} '${path2}' imported from ${base}`;
-  },
-  Error
-);
-createError(
-  "ERR_NETWORK_IMPORT_DISALLOWED",
-  "import of '%s' by %s is not supported: %s",
-  Error
-);
-var ERR_PACKAGE_IMPORT_NOT_DEFINED = createError(
-  "ERR_PACKAGE_IMPORT_NOT_DEFINED",
-  (specifier, packagePath, base) => {
-    return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath || ""}package.json` : ""} imported from ${base}`;
-  },
-  TypeError
-);
+var ERR_INVALID_PACKAGE_CONFIG = createError("ERR_INVALID_PACKAGE_CONFIG", (path$1, base, message) => {
+  return `Invalid package config ${path$1}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+}, Error);
+var ERR_INVALID_PACKAGE_TARGET = createError("ERR_INVALID_PACKAGE_TARGET", (packagePath, key, target, isImport = false, base) => {
+  const relatedError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
+  if (key === ".") {
+    assert.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);
+var ERR_MODULE_NOT_FOUND = createError("ERR_MODULE_NOT_FOUND", (path$1, base, exactUrl = false) => {
+  return `Cannot find ${exactUrl ? "module" : "package"} '${path$1}' imported from ${base}`;
+}, Error);
+var ERR_NETWORK_IMPORT_DISALLOWED = createError("ERR_NETWORK_IMPORT_DISALLOWED", "import of '%s' by %s is not supported: %s", Error);
+var ERR_PACKAGE_IMPORT_NOT_DEFINED = createError("ERR_PACKAGE_IMPORT_NOT_DEFINED", (specifier, packagePath, base) => {
+  return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath || ""}package.json` : ""} imported from ${base}`;
+}, TypeError);
 var ERR_PACKAGE_PATH_NOT_EXPORTED = createError(
   "ERR_PACKAGE_PATH_NOT_EXPORTED",
   /**
-   * @param {string} packagePath
-   * @param {string} subpath
-   * @param {string} [base]
-   */
+  * @param {string} packagePath
+  * @param {string} subpath
+  * @param {string} [base]
+  */
   (packagePath, subpath, base) => {
-    if (subpath === ".")
-      return `No "exports" main defined in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
+    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
 );
-var ERR_UNSUPPORTED_DIR_IMPORT = createError(
-  "ERR_UNSUPPORTED_DIR_IMPORT",
-  "Directory import '%s' is not supported resolving ES modules imported from %s",
-  Error
-);
-var 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
-);
-var ERR_UNKNOWN_FILE_EXTENSION = createError(
-  "ERR_UNKNOWN_FILE_EXTENSION",
-  (extension, path2) => {
-    return `Unknown file extension "${extension}" for ${path2}`;
-  },
-  TypeError
-);
-createError(
-  "ERR_INVALID_ARG_VALUE",
-  (name, value, reason = "is invalid") => {
-    let inspected = 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
-);
+var ERR_UNSUPPORTED_DIR_IMPORT = createError("ERR_UNSUPPORTED_DIR_IMPORT", "Directory import '%s' is not supported resolving ES modules imported from %s", Error);
+var 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);
+var ERR_UNKNOWN_FILE_EXTENSION = createError("ERR_UNKNOWN_FILE_EXTENSION", (extension, path$1) => {
+  return `Unknown file extension "${extension}" for ${path$1}`;
+}, TypeError);
+var ERR_INVALID_ARG_VALUE = createError("ERR_INVALID_ARG_VALUE", (name, value, reason = "is invalid") => {
+  let inspected = inspect(value);
+  if (inspected.length > 128) inspected = `${inspected.slice(0, 128)}...`;
+  return `The ${name.includes(".") ? "property" : "argument"} '${name}' ${reason}. Received ${inspected}`;
+}, TypeError);
 var hasOwnProperty$1 = {}.hasOwnProperty;
 var cache = /* @__PURE__ */ new Map();
 function read(jsonPath, { base, specifier }) {
   const existing = cache.get(jsonPath);
-  if (existing) {
-    return existing;
-  }
+  if (existing) return existing;
   let string;
   try {
     string = fs.readFileSync(path.toNamespacedPath(jsonPath), "utf8");
   } catch (error) {
     const exception = error;
-    if (exception.code !== "ENOENT") {
-      throw exception;
-    }
+    if (exception.code !== "ENOENT") throw exception;
   }
   const result = {
     exists: false,
@@ -411,7 +318,6 @@ function read(jsonPath, { base, specifier }) {
     main: void 0,
     name: void 0,
     type: "none",
-    // Ignore unknown types for forwards compatibility
     exports: void 0,
     imports: void 0
   };
@@ -420,30 +326,16 @@ function read(jsonPath, { base, specifier }) {
     try {
       parsed = JSON.parse(string);
     } catch (error_) {
-      const error = new ERR_INVALID_PACKAGE_CONFIG(
-        jsonPath,
-        (base ? `"${specifier}" from ` : "") + fileURLToPath(base || specifier),
-        error_.message
-      );
+      const error = new ERR_INVALID_PACKAGE_CONFIG(jsonPath, (base ? `"${specifier}" from ` : "") + fileURLToPath(base || specifier), error_.message);
       error.cause = error_;
       throw error;
     }
     result.exists = true;
-    if (hasOwnProperty$1.call(parsed, "name") && typeof parsed.name === "string") {
-      result.name = parsed.name;
-    }
-    if (hasOwnProperty$1.call(parsed, "main") && typeof parsed.main === "string") {
-      result.main = parsed.main;
-    }
-    if (hasOwnProperty$1.call(parsed, "exports")) {
-      result.exports = parsed.exports;
-    }
-    if (hasOwnProperty$1.call(parsed, "imports")) {
-      result.imports = parsed.imports;
-    }
-    if (hasOwnProperty$1.call(parsed, "type") && (parsed.type === "commonjs" || parsed.type === "module")) {
-      result.type = parsed.type;
-    }
+    if (hasOwnProperty$1.call(parsed, "name") && typeof parsed.name === "string") result.name = parsed.name;
+    if (hasOwnProperty$1.call(parsed, "main") && typeof parsed.main === "string") result.main = parsed.main;
+    if (hasOwnProperty$1.call(parsed, "exports")) result.exports = parsed.exports;
+    if (hasOwnProperty$1.call(parsed, "imports")) result.imports = parsed.imports;
+    if (hasOwnProperty$1.call(parsed, "type") && (parsed.type === "commonjs" || parsed.type === "module")) result.type = parsed.type;
   }
   cache.set(jsonPath, result);
   return result;
@@ -452,25 +344,15 @@ __name(read, "read");
 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(fileURLToPath(packageJSONUrl), {
-      specifier: resolved
-    });
-    if (packageConfig.exists) {
-      return packageConfig;
-    }
+    if (packageJSONUrl.pathname.endsWith("node_modules/package.json")) break;
+    const packageConfig = read(fileURLToPath(packageJSONUrl), { specifier: resolved });
+    if (packageConfig.exists) return packageConfig;
     const lastPackageJSONUrl = packageJSONUrl;
     packageJSONUrl = new URL("../package.json", packageJSONUrl);
-    if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) {
-      break;
-    }
+    if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) break;
   }
-  const packageJSONPath = fileURLToPath(packageJSONUrl);
   return {
-    pjsonPath: packageJSONPath,
+    pjsonPath: fileURLToPath(packageJSONUrl),
     exists: false,
     type: "none"
   };
@@ -494,16 +376,17 @@ var protocolHandlers = {
   "node:": /* @__PURE__ */ __name(() => "builtin", "node:")
 };
 function mimeToFormat(mime) {
-  if (mime && /\s*(text|application)\/javascript\s*(;\s*charset=utf-?8\s*)?/i.test(mime))
-    return "module";
+  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;
 }
 __name(mimeToFormat, "mimeToFormat");
 function getDataProtocolModuleFormat(parsed) {
-  const { 1: mime } = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(
-    parsed.pathname
-  ) || [null, null, null];
+  const { 1: mime } = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(parsed.pathname) || [
+    null,
+    null,
+    null
+  ];
   return mimeToFormat(mime);
 }
 __name(getDataProtocolModuleFormat, "getDataProtocolModuleFormat");
@@ -512,12 +395,8 @@ function extname(url) {
   let index = pathname.length;
   while (index--) {
     const code = pathname.codePointAt(index);
-    if (code === 47) {
-      return "";
-    }
-    if (code === 46) {
-      return pathname.codePointAt(index - 1) === 47 ? "" : pathname.slice(index);
-    }
+    if (code === 47) return "";
+    if (code === 46) return pathname.codePointAt(index - 1) === 47 ? "" : pathname.slice(index);
   }
   return "";
 }
@@ -526,32 +405,23 @@ function getFileProtocolModuleFormat(url, _context, ignoreErrors) {
   const ext = extname(url);
   if (ext === ".js") {
     const { type: packageType } = getPackageScopeConfig(url);
-    if (packageType !== "none") {
-      return packageType;
-    }
+    if (packageType !== "none") return packageType;
     return "commonjs";
   }
   if (ext === "") {
     const { type: packageType } = getPackageScopeConfig(url);
-    if (packageType === "none" || packageType === "commonjs") {
-      return "commonjs";
-    }
+    if (packageType === "none" || packageType === "commonjs") return "commonjs";
     return "module";
   }
-  const format2 = extensionFormatMap[ext];
-  if (format2) return format2;
-  if (ignoreErrors) {
-    return void 0;
-  }
-  const filepath = fileURLToPath(url);
-  throw new ERR_UNKNOWN_FILE_EXTENSION(ext, filepath);
+  const format$1 = extensionFormatMap[ext];
+  if (format$1) return format$1;
+  if (ignoreErrors) return;
+  throw new ERR_UNKNOWN_FILE_EXTENSION(ext, fileURLToPath(url));
 }
 __name(getFileProtocolModuleFormat, "getFileProtocolModuleFormat");
 function defaultGetFormatWithoutErrors(url, context) {
   const protocol = url.protocol;
-  if (!hasOwnProperty.call(protocolHandlers, protocol)) {
-    return null;
-  }
+  if (!hasOwnProperty.call(protocolHandlers, protocol)) return null;
   return protocolHandlers[protocol](url, context, true) || null;
 }
 __name(defaultGetFormatWithoutErrors, "defaultGetFormatWithoutErrors");
@@ -565,51 +435,27 @@ var encodedSeparatorRegEx = /%2f|%5c/i;
 var emittedPackageWarnings = /* @__PURE__ */ new Set();
 var doubleSlashRegEx = /[/\\]{2}/;
 function emitInvalidSegmentDeprecation(target, request, match, packageJsonUrl, internal, base, isTarget) {
-  if (process$1.noDeprecation) {
-    return;
-  }
+  if (process$1.noDeprecation) return;
   const pjsonPath = fileURLToPath(packageJsonUrl);
   const double = doubleSlashRegEx.exec(isTarget ? target : request) !== null;
-  process$1.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 ${fileURLToPath(base)}` : ""}.`,
-    "DeprecationWarning",
-    "DEP0166"
-  );
+  process$1.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 ${fileURLToPath(base)}` : ""}.`, "DeprecationWarning", "DEP0166");
 }
 __name(emitInvalidSegmentDeprecation, "emitInvalidSegmentDeprecation");
 function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
-  if (process$1.noDeprecation) {
-    return;
-  }
-  const format2 = defaultGetFormatWithoutErrors(url, { parentURL: base.href });
-  if (format2 !== "module") return;
+  if (process$1.noDeprecation) return;
+  if (defaultGetFormatWithoutErrors(url, { parentURL: base.href }) !== "module") return;
   const urlPath = fileURLToPath(url.href);
   const packagePath = fileURLToPath(new URL$1(".", packageJsonUrl));
   const basePath = fileURLToPath(base);
-  if (!main) {
-    process$1.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 (path.resolve(packagePath, main) !== urlPath) {
-    process$1.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"
-    );
-  }
+  if (!main) process$1.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 (path.resolve(packagePath, main) !== urlPath) process$1.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");
 }
 __name(emitLegacyIndexDeprecation, "emitLegacyIndexDeprecation");
-function tryStatSync(path2) {
+function tryStatSync(path$1) {
   try {
-    return statSync(path2);
+    return statSync(path$1);
   } catch {
   }
 }
@@ -625,7 +471,7 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
   if (packageConfig.main !== void 0) {
     guess = new URL$1(packageConfig.main, packageJsonUrl);
     if (fileExists(guess)) return guess;
-    const tries2 = [
+    const tries$1 = [
       `./${packageConfig.main}.js`,
       `./${packageConfig.main}.json`,
       `./${packageConfig.main}.node`,
@@ -633,23 +479,22 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
       `./${packageConfig.main}/index.json`,
       `./${packageConfig.main}/index.node`
     ];
-    let i2 = -1;
-    while (++i2 < tries2.length) {
-      guess = new URL$1(tries2[i2], packageJsonUrl);
+    let i$1 = -1;
+    while (++i$1 < tries$1.length) {
+      guess = new URL$1(tries$1[i$1], packageJsonUrl);
       if (fileExists(guess)) break;
       guess = void 0;
     }
     if (guess) {
-      emitLegacyIndexDeprecation(
-        guess,
-        packageJsonUrl,
-        base,
-        packageConfig.main
-      );
+      emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main);
       return guess;
     }
   }
-  const tries = ["./index.js", "./index.json", "./index.node"];
+  const tries = [
+    "./index.js",
+    "./index.json",
+    "./index.node"
+  ];
   let i = -1;
   while (++i < tries.length) {
     guess = new URL$1(tries[i], packageJsonUrl);
@@ -660,20 +505,11 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
     emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main);
     return guess;
   }
-  throw new ERR_MODULE_NOT_FOUND(
-    fileURLToPath(new URL$1(".", packageJsonUrl)),
-    fileURLToPath(base)
-  );
+  throw new ERR_MODULE_NOT_FOUND(fileURLToPath(new URL$1(".", packageJsonUrl)), fileURLToPath(base));
 }
 __name(legacyMainResolve, "legacyMainResolve");
 function finalizeResolution(resolved, base, preserveSymlinks) {
-  if (encodedSeparatorRegEx.exec(resolved.pathname) !== null) {
-    throw new ERR_INVALID_MODULE_SPECIFIER(
-      resolved.pathname,
-      String.raw`must not include encoded "/" or "\" characters`,
-      fileURLToPath(base)
-    );
-  }
+  if (encodedSeparatorRegEx.exec(resolved.pathname) !== null) throw new ERR_INVALID_MODULE_SPECIFIER(resolved.pathname, String.raw`must not include encoded "/" or "\" characters`, fileURLToPath(base));
   let filePath;
   try {
     filePath = fileURLToPath(resolved);
@@ -682,24 +518,18 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
     Object.defineProperty(error, "module", { value: String(base) });
     throw error;
   }
-  const stats = tryStatSync(
-    filePath.endsWith("/") ? filePath.slice(-1) : filePath
-  );
+  const stats = tryStatSync(filePath.endsWith("/") ? filePath.slice(-1) : filePath);
   if (stats && stats.isDirectory()) {
     const error = new ERR_UNSUPPORTED_DIR_IMPORT(filePath, fileURLToPath(base));
     error.url = String(resolved);
     throw error;
   }
   if (!stats || !stats.isFile()) {
-    const error = new ERR_MODULE_NOT_FOUND(
-      filePath || resolved.pathname,
-      base && fileURLToPath(base),
-      true
-    );
+    const error = new ERR_MODULE_NOT_FOUND(filePath || resolved.pathname, base && fileURLToPath(base), true);
     error.url = String(resolved);
     throw error;
   }
-  {
+  if (!preserveSymlinks) {
     const real = realpathSync(filePath);
     const { search, hash } = resolved;
     resolved = pathToFileURL(real + (filePath.endsWith(path.sep) ? "/" : ""));
@@ -710,44 +540,24 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
 }
 __name(finalizeResolution, "finalizeResolution");
 function importNotDefined(specifier, packageJsonUrl, base) {
-  return new ERR_PACKAGE_IMPORT_NOT_DEFINED(
-    specifier,
-    packageJsonUrl && fileURLToPath(new URL$1(".", packageJsonUrl)),
-    fileURLToPath(base)
-  );
+  return new ERR_PACKAGE_IMPORT_NOT_DEFINED(specifier, packageJsonUrl && fileURLToPath(new URL$1(".", packageJsonUrl)), fileURLToPath(base));
 }
 __name(importNotDefined, "importNotDefined");
 function exportsNotFound(subpath, packageJsonUrl, base) {
-  return new ERR_PACKAGE_PATH_NOT_EXPORTED(
-    fileURLToPath(new URL$1(".", packageJsonUrl)),
-    subpath,
-    base && fileURLToPath(base)
-  );
+  return new ERR_PACKAGE_PATH_NOT_EXPORTED(fileURLToPath(new URL$1(".", packageJsonUrl)), subpath, base && fileURLToPath(base));
 }
 __name(exportsNotFound, "exportsNotFound");
 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 ${fileURLToPath(packageJsonUrl)}`;
-  throw new ERR_INVALID_MODULE_SPECIFIER(
-    request,
-    reason,
-    base && fileURLToPath(base)
-  );
+  throw new ERR_INVALID_MODULE_SPECIFIER(request, `request is not a valid match in pattern "${match}" for the "${internal ? "imports" : "exports"}" resolution of ${fileURLToPath(packageJsonUrl)}`, base && fileURLToPath(base));
 }
 __name(throwInvalidSubpath, "throwInvalidSubpath");
 function invalidPackageTarget(subpath, target, packageJsonUrl, internal, base) {
   target = typeof target === "object" && target !== null ? JSON.stringify(target, null, "") : `${target}`;
-  return new ERR_INVALID_PACKAGE_TARGET(
-    fileURLToPath(new URL$1(".", packageJsonUrl)),
-    subpath,
-    target,
-    internal,
-    base && fileURLToPath(base)
-  );
+  return new ERR_INVALID_PACKAGE_TARGET(fileURLToPath(new URL$1(".", packageJsonUrl)), subpath, target, internal, base && fileURLToPath(base));
 }
 __name(invalidPackageTarget, "invalidPackageTarget");
 function resolvePackageTargetString(target, subpath, match, packageJsonUrl, base, pattern, internal, isPathMap, conditions) {
-  if (subpath !== "" && !pattern && target.at(-1) !== "/")
-    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+  if (subpath !== "" && !pattern && target.at(-1) !== "/") throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
   if (!target.startsWith("./")) {
     if (internal && !target.startsWith("../") && !target.startsWith("/")) {
       let isURL = false;
@@ -756,78 +566,28 @@ function resolvePackageTargetString(target, subpath, match, packageJsonUrl, base
         isURL = true;
       } catch {
       }
-      if (!isURL) {
-        const exportTarget = pattern ? RegExpPrototypeSymbolReplace.call(
-          patternRegEx,
-          target,
-          () => subpath
-        ) : target + subpath;
-        return packageResolve(exportTarget, packageJsonUrl, conditions);
-      }
+      if (!isURL) return packageResolve(pattern ? RegExpPrototypeSymbolReplace.call(patternRegEx, target, () => subpath) : target + subpath, 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);
+  if (invalidSegmentRegEx.exec(target.slice(2)) !== null) if (deprecatedInvalidSegmentRegEx.exec(target.slice(2)) === null) {
+    if (!isPathMap) {
+      const request = pattern ? match.replace("*", () => subpath) : match + subpath;
+      emitInvalidSegmentDeprecation(pattern ? RegExpPrototypeSymbolReplace.call(patternRegEx, target, () => subpath) : target, request, match, packageJsonUrl, internal, base, true);
     }
-  }
+  } else throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
   const resolved = new URL$1(target, packageJsonUrl);
   const resolvedPath = resolved.pathname;
   const packagePath = new URL$1(".", packageJsonUrl).pathname;
-  if (!resolvedPath.startsWith(packagePath))
-    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+  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$1(
-      RegExpPrototypeSymbolReplace.call(
-        patternRegEx,
-        resolved.href,
-        () => subpath
-      )
-    );
+      if (!isPathMap) emitInvalidSegmentDeprecation(pattern ? RegExpPrototypeSymbolReplace.call(patternRegEx, target, () => subpath) : target, request, match, packageJsonUrl, internal, base, false);
+    } else throwInvalidSubpath(request, match, packageJsonUrl, internal, base);
   }
+  if (pattern) return new URL$1(RegExpPrototypeSymbolReplace.call(patternRegEx, resolved.href, () => subpath));
   return new URL$1(subpath, resolved);
 }
 __name(resolvePackageTargetString, "resolvePackageTargetString");
@@ -838,19 +598,7 @@ function isArrayIndex(key) {
 }
 __name(isArrayIndex, "isArrayIndex");
 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 (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;
@@ -860,17 +608,7 @@ function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, b
       const targetItem = targetList[i];
       let resolveResult;
       try {
-        resolveResult = resolvePackageTarget(
-          packageJsonUrl,
-          targetItem,
-          subpath,
-          packageSubpath,
-          base,
-          pattern,
-          internal,
-          isPathMap,
-          conditions
-        );
+        resolveResult = resolvePackageTarget(packageJsonUrl, targetItem, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions);
       } catch (error) {
         const exception = error;
         lastException = exception;
@@ -884,9 +622,7 @@ function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, b
       }
       return resolveResult;
     }
-    if (lastException === void 0 || lastException === null) {
-      return null;
-    }
+    if (lastException === void 0 || lastException === null) return null;
     throw lastException;
   }
   if (typeof target === "object" && target !== null) {
@@ -894,46 +630,22 @@ function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, b
     let i = -1;
     while (++i < keys.length) {
       const key = keys[i];
-      if (isArrayIndex(key)) {
-        throw new ERR_INVALID_PACKAGE_CONFIG(
-          fileURLToPath(packageJsonUrl),
-          fileURLToPath(base),
-          '"exports" cannot contain numeric property keys.'
-        );
-      }
+      if (isArrayIndex(key)) throw new ERR_INVALID_PACKAGE_CONFIG(fileURLToPath(packageJsonUrl), fileURLToPath(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 = target[key];
-        const resolveResult = resolvePackageTarget(
-          packageJsonUrl,
-          conditionalTarget,
-          subpath,
-          packageSubpath,
-          base,
-          pattern,
-          internal,
-          isPathMap,
-          conditions
-        );
+        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
-  );
+  if (target === null) return null;
+  throw invalidPackageTarget(packageSubpath, target, packageJsonUrl, internal, base);
 }
 __name(resolvePackageTarget, "resolvePackageTarget");
 function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
@@ -946,54 +658,27 @@ function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
   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_CONFIG(
-        fileURLToPath(packageJsonUrl),
-        fileURLToPath(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.`
-      );
-    }
+    if (i++ === 0) isConditionalSugar = currentIsConditionalSugar;
+    else if (isConditionalSugar !== currentIsConditionalSugar) throw new ERR_INVALID_PACKAGE_CONFIG(fileURLToPath(packageJsonUrl), fileURLToPath(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;
 }
 __name(isConditionalExportsMainSugar, "isConditionalExportsMainSugar");
 function emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) {
-  if (process$1.noDeprecation) {
-    return;
-  }
+  if (process$1.noDeprecation) return;
   const pjsonPath = fileURLToPath(pjsonUrl);
   if (emittedPackageWarnings.has(pjsonPath + "|" + match)) return;
   emittedPackageWarnings.add(pjsonPath + "|" + match);
-  process$1.emitWarning(
-    `Use of deprecated trailing slash pattern mapping "${match}" in the "exports" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${fileURLToPath(base)}` : ""}. Mapping specifiers ending in "/" is no longer supported.`,
-    "DeprecationWarning",
-    "DEP0155"
-  );
+  process$1.emitWarning(`Use of deprecated trailing slash pattern mapping "${match}" in the "exports" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${fileURLToPath(base)}` : ""}. Mapping specifiers ending in "/" is no longer supported.`, "DeprecationWarning", "DEP0155");
 }
 __name(emitTrailingSlashPatternDeprecation, "emitTrailingSlashPatternDeprecation");
 function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions) {
   let exports = packageConfig.exports;
-  if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) {
-    exports = { ".": exports };
-  }
+  if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) exports = { ".": exports };
   if (own.call(exports, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) {
     const target = exports[packageSubpath];
-    const resolveResult = resolvePackageTarget(
-      packageJsonUrl,
-      target,
-      "",
-      packageSubpath,
-      base,
-      false,
-      false,
-      false,
-      conditions
-    );
-    if (resolveResult === null || resolveResult === void 0) {
-      throw exportsNotFound(packageSubpath, packageJsonUrl, base);
-    }
+    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 = "";
@@ -1004,39 +689,18 @@ function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, ba
     const key = keys[i];
     const patternIndex = key.indexOf("*");
     if (patternIndex !== -1 && packageSubpath.startsWith(key.slice(0, patternIndex))) {
-      if (packageSubpath.endsWith("/")) {
-        emitTrailingSlashPatternDeprecation(
-          packageSubpath,
-          packageJsonUrl,
-          base
-        );
-      }
+      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
-        );
+        bestMatchSubpath = packageSubpath.slice(patternIndex, packageSubpath.length - patternTrailer.length);
       }
     }
   }
   if (bestMatch) {
     const target = exports[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);
-    }
+    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);
@@ -1057,68 +721,36 @@ function patternKeyCompare(a, b) {
 }
 __name(patternKeyCompare, "patternKeyCompare");
 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, fileURLToPath(base));
-  }
+  if (name === "#" || name.startsWith("#/") || name.endsWith("/")) throw new ERR_INVALID_MODULE_SPECIFIER(name, "is not a valid internal imports specifier name", fileURLToPath(base));
   let packageJsonUrl;
   const packageConfig = getPackageScopeConfig(base);
   if (packageConfig.exists) {
     packageJsonUrl = pathToFileURL(packageConfig.pjsonPath);
     const imports = packageConfig.imports;
-    if (imports) {
-      if (own.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;
+    if (imports) if (own.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);
@@ -1130,76 +762,41 @@ function parsePackageName(specifier, base) {
   let isScoped = false;
   if (specifier[0] === "@") {
     isScoped = true;
-    if (separatorIndex === -1 || specifier.length === 0) {
-      validPackageName = false;
-    } else {
-      separatorIndex = specifier.indexOf("/", separatorIndex + 1);
-    }
+    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",
-      fileURLToPath(base)
-    );
-  }
-  const packageSubpath = "." + (separatorIndex === -1 ? "" : specifier.slice(separatorIndex));
-  return { packageName, packageSubpath, isScoped };
+  if (invalidPackageNameRegEx.exec(packageName) !== null) validPackageName = false;
+  if (!validPackageName) throw new ERR_INVALID_MODULE_SPECIFIER(specifier, "is not a valid package name", fileURLToPath(base));
+  return {
+    packageName,
+    packageSubpath: "." + (separatorIndex === -1 ? "" : specifier.slice(separatorIndex)),
+    isScoped
+  };
 }
 __name(parsePackageName, "parsePackageName");
 function packageResolve(specifier, base, conditions) {
-  if (nodeBuiltins.includes(specifier)) {
-    return new URL$1("node:" + specifier);
-  }
-  const { packageName, packageSubpath, isScoped } = parsePackageName(
-    specifier,
-    base
-  );
+  if (nodeBuiltins.includes(specifier)) return new URL$1("node:" + specifier);
+  const { packageName, packageSubpath, isScoped } = parsePackageName(specifier, base);
   const packageConfig = getPackageScopeConfig(base);
-  if (packageConfig.exists && packageConfig.name === packageName && packageConfig.exports !== void 0 && packageConfig.exports !== null) {
-    const packageJsonUrl2 = pathToFileURL(packageConfig.pjsonPath);
-    return packageExportsResolve(
-      packageJsonUrl2,
-      packageSubpath,
-      packageConfig,
-      base,
-      conditions
-    );
-  }
-  let packageJsonUrl = new URL$1(
-    "./node_modules/" + packageName + "/package.json",
-    base
-  );
+  if (packageConfig.exists && packageConfig.name === packageName && packageConfig.exports !== void 0 && packageConfig.exports !== null) return packageExportsResolve(pathToFileURL(packageConfig.pjsonPath), packageSubpath, packageConfig, base, conditions);
+  let packageJsonUrl = new URL$1("./node_modules/" + packageName + "/package.json", base);
   let packageJsonPath = fileURLToPath(packageJsonUrl);
   let lastPath;
   do {
     const stat = tryStatSync(packageJsonPath.slice(0, -13));
     if (!stat || !stat.isDirectory()) {
       lastPath = packageJsonPath;
-      packageJsonUrl = new URL$1(
-        (isScoped ? "../../../../node_modules/" : "../../../node_modules/") + packageName + "/package.json",
-        packageJsonUrl
-      );
+      packageJsonUrl = new URL$1((isScoped ? "../../../../node_modules/" : "../../../node_modules/") + packageName + "/package.json", packageJsonUrl);
       packageJsonPath = 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);
-    }
+    const packageConfig$1 = read(packageJsonPath, {
+      base,
+      specifier
+    });
+    if (packageConfig$1.exports !== void 0 && packageConfig$1.exports !== null) return packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig$1, base, conditions);
+    if (packageSubpath === ".") return legacyMainResolve(packageJsonUrl, packageConfig$1, base);
     return new URL$1(packageSubpath, packageJsonUrl);
   } while (packageJsonPath.length !== lastPath.length);
   throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath(base), false);
@@ -1208,9 +805,7 @@ __name(packageResolve, "packageResolve");
 function isRelativeSpecifier(specifier) {
   if (specifier[0] === ".") {
     if (specifier.length === 1 || specifier[1] === "/") return true;
-    if (specifier[1] === "." && (specifier.length === 2 || specifier[2] === "/")) {
-      return true;
-    }
+    if (specifier[1] === "." && (specifier.length === 2 || specifier[2] === "/")) return true;
   }
   return false;
 }
@@ -1225,53 +820,35 @@ function moduleResolve(specifier, base, conditions, preserveSymlinks) {
   const protocol = base.protocol;
   const isData = protocol === "data:";
   let resolved;
-  if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
-    try {
-      resolved = new URL$1(specifier, base);
-    } catch (error_) {
+  if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) try {
+    resolved = new URL$1(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$1(specifier);
+  } catch (error_) {
+    if (isData && !nodeBuiltins.includes(specifier)) {
       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$1(specifier);
-    } catch (error_) {
-      if (isData && !nodeBuiltins.includes(specifier)) {
-        const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
-        error.cause = error_;
-        throw error;
-      }
-      resolved = packageResolve(specifier, base, conditions);
-    }
+    resolved = packageResolve(specifier, base, conditions);
   }
-  assert(resolved !== void 0, "expected to be defined");
-  if (resolved.protocol !== "file:") {
-    return resolved;
-  }
-  return finalizeResolution(resolved, base);
+  assert.ok(resolved !== void 0, "expected to be defined");
+  if (resolved.protocol !== "file:") return resolved;
+  return finalizeResolution(resolved, base, preserveSymlinks);
 }
 __name(moduleResolve, "moduleResolve");
 var DEFAULT_CONDITIONS_SET = /* @__PURE__ */ new Set(["node", "import"]);
 var isWindows = (() => process.platform === "win32")();
-var NOT_FOUND_ERRORS = /* @__PURE__ */ new Set([
-  "ERR_MODULE_NOT_FOUND",
-  "ERR_UNSUPPORTED_DIR_IMPORT",
-  "MODULE_NOT_FOUND",
-  "ERR_PACKAGE_PATH_NOT_EXPORTED",
-  "ERR_PACKAGE_IMPORT_NOT_DEFINED"
-]);
-var globalCache = (() => (
-  // eslint-disable-next-line unicorn/no-unreadable-iife
-  globalThis["__EXSOLVE_CACHE__"] ||= /* @__PURE__ */ new Map()
-))();
+var globalCache = (() => globalThis["__EXSOLVE_CACHE__"] ||= /* @__PURE__ */ new Map())();
 function resolveModuleURL(input, options) {
   const parsedInput = _parseInput(input);
-  if ("external" in parsedInput) {
-    return parsedInput.external;
-  }
+  if ("external" in parsedInput) return parsedInput.external;
   const specifier = parsedInput.specifier;
   let url = parsedInput.url;
   let absolutePath = parsedInput.absolutePath;
@@ -1283,36 +860,26 @@ function resolveModuleURL(input, options) {
   }
   if (cacheObj) {
     const cached = cacheObj.get(cacheKey);
-    if (typeof cached === "string") {
-      return cached;
-    }
+    if (typeof cached === "string") return cached;
     if (cached instanceof Error) {
-      if (options?.try) {
-        return void 0;
-      }
+      if (options?.try) return;
       throw cached;
     }
   }
-  if (absolutePath) {
-    try {
-      const stat = lstatSync(absolutePath);
-      if (stat.isSymbolicLink()) {
-        absolutePath = realpathSync(absolutePath);
-        url = pathToFileURL(absolutePath);
-      }
-      if (stat.isFile()) {
-        if (cacheObj) {
-          cacheObj.set(cacheKey, url.href);
-        }
-        return url.href;
-      }
-    } catch (error) {
-      if (error?.code !== "ENOENT") {
-        if (cacheObj) {
-          cacheObj.set(cacheKey, error);
-        }
-        throw error;
-      }
+  if (absolutePath) try {
+    const stat = lstatSync(absolutePath);
+    if (stat.isSymbolicLink()) {
+      absolutePath = realpathSync(absolutePath);
+      url = pathToFileURL(absolutePath);
+    }
+    if (stat.isFile()) {
+      if (cacheObj) cacheObj.set(cacheKey, url.href);
+      return url.href;
+    }
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      if (cacheObj) cacheObj.set(cacheKey, error);
+      throw error;
     }
   }
   const conditionsSet = options?.conditions ? new Set(options.conditions) : DEFAULT_CONDITIONS_SET;
@@ -1324,50 +891,30 @@ function resolveModuleURL(input, options) {
   for (const base of bases) {
     for (const suffix of suffixes) {
       let name = _join(target, suffix);
-      if (name === ".") {
-        name += "/.";
-      }
+      if (name === ".") name += "/.";
       for (const extension of extensions) {
         resolved = _tryModuleResolve(name + extension, base, conditionsSet);
-        if (resolved) {
-          break;
-        }
-      }
-      if (resolved) {
-        break;
+        if (resolved) break;
       }
+      if (resolved) break;
     }
-    if (resolved) {
-      break;
-    }
+    if (resolved) break;
   }
   if (!resolved) {
-    const error = new Error(
-      `Cannot resolve module "${input}" (from: ${bases.map((u) => _fmtPath(u)).join(", ")})`
-    );
+    const error = new Error(`Cannot resolve module "${input}" (from: ${bases.map((u) => _fmtPath(u)).join(", ")})`);
     error.code = "ERR_MODULE_NOT_FOUND";
-    if (cacheObj) {
-      cacheObj.set(cacheKey, error);
-    }
-    if (options?.try) {
-      return void 0;
-    }
+    if (cacheObj) cacheObj.set(cacheKey, error);
+    if (options?.try) return;
     throw error;
   }
-  if (cacheObj) {
-    cacheObj.set(cacheKey, resolved.href);
-  }
+  if (cacheObj) cacheObj.set(cacheKey, resolved.href);
   return resolved.href;
 }
 __name(resolveModuleURL, "resolveModuleURL");
 function resolveModulePath(id, options) {
   const resolved = resolveModuleURL(id, options);
-  if (!resolved) {
-    return void 0;
-  }
-  if (!resolved.startsWith("file://") && options?.try) {
-    return void 0;
-  }
+  if (!resolved) return;
+  if (!resolved.startsWith("file://") && options?.try) return;
   const absolutePath = fileURLToPath(resolved);
   return isWindows ? _normalizeWinPath(absolutePath) : absolutePath;
 }
@@ -1375,40 +922,23 @@ __name(resolveModulePath, "resolveModulePath");
 function _tryModuleResolve(specifier, base, conditions) {
   try {
     return moduleResolve(specifier, base, conditions);
-  } catch (error) {
-    if (!NOT_FOUND_ERRORS.has(error?.code)) {
-      throw error;
-    }
+  } catch {
   }
 }
 __name(_tryModuleResolve, "_tryModuleResolve");
 function _normalizeBases(inputs) {
-  const urls = (Array.isArray(inputs) ? inputs : [inputs]).flatMap(
-    (input) => _normalizeBase(input)
-  );
-  if (urls.length === 0) {
-    return [pathToFileURL("./")];
-  }
+  const urls = (Array.isArray(inputs) ? inputs : [inputs]).flatMap((input) => _normalizeBase(input));
+  if (urls.length === 0) return [pathToFileURL("./")];
   return urls;
 }
 __name(_normalizeBases, "_normalizeBases");
 function _normalizeBase(input) {
-  if (!input) {
-    return [];
-  }
-  if (_isURL(input)) {
-    return [input];
-  }
-  if (typeof input !== "string") {
-    return [];
-  }
-  if (/^(?:node|data|http|https|file):/.test(input)) {
-    return new URL(input);
-  }
+  if (!input) return [];
+  if (_isURL(input)) return [input];
+  if (typeof input !== "string") return [];
+  if (/^(?:node|data|http|https|file):/.test(input)) return new URL(input);
   try {
-    if (input.endsWith("/") || statSync(input).isDirectory()) {
-      return pathToFileURL(input + "/");
-    }
+    if (input.endsWith("/") || statSync(input).isDirectory()) return pathToFileURL(input + "/");
     return pathToFileURL(input);
   } catch {
     return [pathToFileURL(input + "/"), pathToFileURL(input)];
@@ -1434,14 +964,12 @@ function _cacheKey(id, opts) {
 }
 __name(_cacheKey, "_cacheKey");
 function _join(a, b) {
-  if (!a || !b || b === "/") {
-    return a;
-  }
+  if (!a || !b || b === "/") return a;
   return (a.endsWith("/") ? a : a + "/") + (b.startsWith("/") ? b.slice(1) : b);
 }
 __name(_join, "_join");
-function _normalizeWinPath(path2) {
-  return path2.replace(/\\/g, "/").replace(/^[a-z]:\//, (r) => r.toUpperCase());
+function _normalizeWinPath(path$1) {
+  return path$1.replace(/\\/g, "/").replace(/^[a-z]:\//, (r) => r.toUpperCase());
 }
 __name(_normalizeWinPath, "_normalizeWinPath");
 function _isURL(input) {
@@ -1452,23 +980,24 @@ function _parseInput(input) {
   if (typeof input === "string") {
     if (input.startsWith("file:")) {
       const url = new URL(input);
-      return { url, absolutePath: fileURLToPath(url) };
-    }
-    if (isAbsolute(input)) {
-      return { url: pathToFileURL(input), absolutePath: input };
-    }
-    if (/^(?:node|data|http|https):/.test(input)) {
-      return { external: input };
-    }
-    if (nodeBuiltins.includes(input) && !input.includes(":")) {
-      return { external: `node:${input}` };
+      return {
+        url,
+        absolutePath: fileURLToPath(url)
+      };
     }
+    if (isAbsolute(input)) return {
+      url: pathToFileURL(input),
+      absolutePath: input
+    };
+    if (/^(?:node|data|http|https):/.test(input)) return { external: input };
+    if (nodeBuiltins.includes(input) && !input.includes(":")) return { external: `node:${input}` };
     return { specifier: input };
   }
   if (_isURL(input)) {
-    if (input.protocol === "file:") {
-      return { url: input, absolutePath: fileURLToPath(input) };
-    }
+    if (input.protocol === "file:") return {
+      url: input,
+      absolutePath: fileURLToPath(input)
+    };
     return { external: input.href };
   }
   throw new TypeError("id must be a `string` or `URL`");