vite 3.2.0 → 3.2.2

package/dist/node/chunks/{dep-61d2428a.js → dep-c842e491.js}

@@ -1,30 +1,28 @@
-import fs$l, { realpathSync as realpathSync$1, statSync as statSync$1, Stats as Stats$1, promises as promises$2 } from 'node:fs';
-import path$n, { posix as posix$2, isAbsolute as isAbsolute$2, resolve as resolve$7, join as join$2, relative as relative$2, dirname as dirname$2, basename as basename$2, extname as extname$1 } from 'node:path';
-import { fileURLToPath, URL as URL$3, pathToFileURL, URLSearchParams, parse as parse$k } from 'node:url';
+import fs$l, { promises as promises$2 } from 'node:fs';
+import path$n, { posix as posix$2, isAbsolute as isAbsolute$2, resolve as resolve$6, join as join$2, relative as relative$2, dirname as dirname$2, basename as basename$2, extname as extname$1 } from 'node:path';
+import { URL as URL$3, URLSearchParams, parse as parse$k, pathToFileURL as pathToFileURL$1 } from 'node:url';
 import { performance } from 'node:perf_hooks';
-import { builtinModules, createRequire as createRequire$1 } from 'node:module';
+import { createRequire as createRequire$1, builtinModules } from 'node:module';
 import require$$0$3 from 'tty';
 import { transform as transform$2, build as build$3, formatMessages } from 'esbuild';
-import assert$1 from 'node:assert';
-import process$1 from 'node:process';
-import { format as format$2, inspect, promisify as promisify$4 } from 'node:util';
-import require$$0$4, { sep, resolve as resolve$5, posix as posix$1, relative as relative$1, basename as basename$1, extname, dirname as dirname$1, join as join$1, win32 as win32$1, isAbsolute as isAbsolute$1, normalize } from 'path';
+import require$$0$4, { sep, resolve as resolve$4, posix as posix$1, relative as relative$1, basename as basename$1, extname, dirname as dirname$1, join as join$1, win32 as win32$1, isAbsolute as isAbsolute$1, normalize } from 'path';
 import * as require$$0$2 from 'fs';
-import require$$0__default, { existsSync, readFileSync, statSync as statSync$2, promises as promises$1, readdirSync } from 'fs';
+import require$$0__default, { existsSync, readFileSync, statSync as statSync$1, promises as promises$1, readdirSync } from 'fs';
 import require$$0$5 from 'events';
-import assert$2 from 'assert';
-import require$$0$6, { format as format$3, inspect as inspect$1 } from 'util';
+import assert$1 from 'assert';
+import require$$0$6, { format as format$2, inspect } from 'util';
 import require$$3$1 from 'net';
-import require$$0$9, { pathToFileURL as pathToFileURL$1 } from 'url';
+import require$$0$9, { pathToFileURL } from 'url';
 import require$$1$1 from 'http';
 import require$$0$7 from 'stream';
 import require$$2 from 'os';
 import require$$2$1 from 'child_process';
 import os$3 from 'node:os';
 import { createHash as createHash$2 } from 'node:crypto';
+import { promisify as promisify$4 } from 'node:util';
 import { promises } from 'node:dns';
-import resolve$6 from 'resolve';
-import { CLIENT_ENTRY, OPTIMIZABLE_ENTRY_RE, DEFAULT_EXTENSIONS as DEFAULT_EXTENSIONS$1, wildcardHosts, loopbackHosts, VALID_ID_PREFIX, NULL_BYTE_PLACEHOLDER, FS_PREFIX, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, ENV_ENTRY, DEP_VERSION_RE, DEFAULT_MAIN_FIELDS, SPECIAL_QUERY_RE, KNOWN_ASSET_TYPES, CLIENT_DIR, JS_TYPES_RE, ESBUILD_MODULES_TARGET, VERSION, VITE_PACKAGE_DIR, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES } from '../constants.js';
+import resolve$5 from 'resolve';
+import { CLIENT_ENTRY, OPTIMIZABLE_ENTRY_RE, DEFAULT_EXTENSIONS as DEFAULT_EXTENSIONS$1, wildcardHosts, loopbackHosts, VALID_ID_PREFIX, NULL_BYTE_PLACEHOLDER, FS_PREFIX, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, ENV_ENTRY, DEFAULT_MAIN_FIELDS, SPECIAL_QUERY_RE, DEP_VERSION_RE, KNOWN_ASSET_TYPES, CLIENT_DIR, JS_TYPES_RE, ESBUILD_MODULES_TARGET, VERSION, VITE_PACKAGE_DIR, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES } from '../constants.js';
 import require$$5 from 'crypto';
 import { Buffer as Buffer$1 } from 'node:buffer';
 import require$$0$8, { createRequire as createRequire$2 } from 'module';
@@ -215,1761 +213,6 @@ function alias$1(options = {}) {
     };
 }
 
-// Manually “tree shaken” from:
-
-const reader$2 = {read: read$5};
-var packageJsonReader = reader$2;
-
-/**
- * @param {string} jsonPath
- * @returns {{string: string|undefined}}
- */
-function read$5(jsonPath) {
-  try {
-    const string = fs$l.readFileSync(
-      path$n.toNamespacedPath(path$n.join(path$n.dirname(jsonPath), 'package.json')),
-      'utf8'
-    );
-    return {string}
-  } catch (error) {
-    const exception = /** @type {ErrnoException} */ (error);
-
-    if (exception.code === 'ENOENT') {
-      return {string: undefined}
-      // Throw all other errors.
-      /* c8 ignore next 4 */
-    }
-
-    throw exception
-  }
-}
-
-/**
- * @typedef ErrnoExceptionFields
- * @property {number|undefined} [errnode]
- * @property {string|undefined} [code]
- * @property {string|undefined} [path]
- * @property {string|undefined} [syscall]
- * @property {string|undefined} [url]
- *
- * @typedef {Error & ErrnoExceptionFields} ErrnoException
- */
-
-const isWindows$6 = process$1.platform === 'win32';
-
-const own$2 = {}.hasOwnProperty;
-
-const codes$1 = {};
-
-/** @type {Map<string, MessageFunction|string>} */
-const messages$1 = new Map();
-const nodeInternalPrefix$1 = '__node_internal_';
-/** @type {number} */
-let userStackTraceLimit$1;
-
-codes$1.ERR_INVALID_MODULE_SPECIFIER = createError$1(
-  'ERR_INVALID_MODULE_SPECIFIER',
-  /**
-   * @param {string} request
-   * @param {string} reason
-   * @param {string} [base]
-   */
-  (request, reason, base = undefined) => {
-    return `Invalid module "${request}" ${reason}${
-      base ? ` imported from ${base}` : ''
-    }`
-  },
-  TypeError
-);
-
-codes$1.ERR_INVALID_PACKAGE_CONFIG = createError$1(
-  'ERR_INVALID_PACKAGE_CONFIG',
-  /**
-   * @param {string} path
-   * @param {string} [base]
-   * @param {string} [message]
-   */
-  (path, base, message) => {
-    return `Invalid package config ${path}${
-      base ? ` while importing ${base}` : ''
-    }${message ? `. ${message}` : ''}`
-  },
-  Error
-);
-
-codes$1.ERR_INVALID_PACKAGE_TARGET = createError$1(
-  'ERR_INVALID_PACKAGE_TARGET',
-  /**
-   * @param {string} pkgPath
-   * @param {string} key
-   * @param {unknown} target
-   * @param {boolean} [isImport=false]
-   * @param {string} [base]
-   */
-  (pkgPath, key, target, isImport = false, base = undefined) => {
-    const relError =
-      typeof target === 'string' &&
-      !isImport &&
-      target.length > 0 &&
-      !target.startsWith('./');
-    if (key === '.') {
-      assert$1(isImport === false);
-      return (
-        `Invalid "exports" main target ${JSON.stringify(target)} defined ` +
-        `in the package config ${pkgPath}package.json${
-          base ? ` imported from ${base}` : ''
-        }${relError ? '; targets must start with "./"' : ''}`
-      )
-    }
-
-    return `Invalid "${
-      isImport ? 'imports' : 'exports'
-    }" target ${JSON.stringify(
-      target
-    )} defined for '${key}' in the package config ${pkgPath}package.json${
-      base ? ` imported from ${base}` : ''
-    }${relError ? '; targets must start with "./"' : ''}`
-  },
-  Error
-);
-
-codes$1.ERR_MODULE_NOT_FOUND = createError$1(
-  'ERR_MODULE_NOT_FOUND',
-  /**
-   * @param {string} path
-   * @param {string} base
-   * @param {string} [type]
-   */
-  (path, base, type = 'package') => {
-    return `Cannot find ${type} '${path}' imported from ${base}`
-  },
-  Error
-);
-
-codes$1.ERR_NETWORK_IMPORT_DISALLOWED = createError$1(
-  'ERR_NETWORK_IMPORT_DISALLOWED',
-  "import of '%s' by %s is not supported: %s",
-  Error
-);
-
-codes$1.ERR_PACKAGE_IMPORT_NOT_DEFINED = createError$1(
-  '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$1.ERR_PACKAGE_PATH_NOT_EXPORTED = createError$1(
-  'ERR_PACKAGE_PATH_NOT_EXPORTED',
-  /**
-   * @param {string} pkgPath
-   * @param {string} subpath
-   * @param {string} [base]
-   */
-  (pkgPath, subpath, base = undefined) => {
-    if (subpath === '.')
-      return `No "exports" main defined in ${pkgPath}package.json${
-        base ? ` imported from ${base}` : ''
-      }`
-    return `Package subpath '${subpath}' is not defined by "exports" in ${pkgPath}package.json${
-      base ? ` imported from ${base}` : ''
-    }`
-  },
-  Error
-);
-
-codes$1.ERR_UNSUPPORTED_DIR_IMPORT = createError$1(
-  'ERR_UNSUPPORTED_DIR_IMPORT',
-  "Directory import '%s' is not supported " +
-    'resolving ES modules imported from %s',
-  Error
-);
-
-codes$1.ERR_UNKNOWN_FILE_EXTENSION = createError$1(
-  'ERR_UNKNOWN_FILE_EXTENSION',
-  /**
-   * @param {string} ext
-   * @param {string} path
-   */
-  (ext, path) => {
-    return `Unknown file extension "${ext}" for ${path}`
-  },
-  TypeError
-);
-
-codes$1.ERR_INVALID_ARG_VALUE = createError$1(
-  'ERR_INVALID_ARG_VALUE',
-  /**
-   * @param {string} name
-   * @param {unknown} value
-   * @param {string} [reason='is invalid']
-   */
-  (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
-);
-
-codes$1.ERR_UNSUPPORTED_ESM_URL_SCHEME = createError$1(
-  'ERR_UNSUPPORTED_ESM_URL_SCHEME',
-  /**
-   * @param {URL} url
-   * @param {Array<string>} supported
-   */
-  (url, supported) => {
-    let message = `Only URLs with a scheme in: ${supported.join(
-      ', '
-    )} are supported by the default ESM loader`;
-    // Let message =
-    //   'Only file and data URLs are supported by the default ESM loader'
-
-    if (isWindows$6 && url.protocol.length === 2) {
-      message += '. On Windows, absolute paths must be valid file:// URLs';
-    }
-
-    message += `. Received protocol '${url.protocol}'`;
-    return message
-  },
-  Error
-);
-
-/**
- * Utility function for registering the error codes. Only used here. Exported
- * *only* to allow for testing.
- * @param {string} sym
- * @param {MessageFunction|string} value
- * @param {ErrorConstructor} def
- * @returns {new (...args: Array<any>) => Error}
- */
-function createError$1(sym, value, def) {
-  // Special case for SystemError that formats the error message differently
-  // The SystemErrors only have SystemError as their base classes.
-  messages$1.set(sym, value);
-
-  return makeNodeErrorWithCode$1(def, sym)
-}
-
-/**
- * @param {ErrorConstructor} Base
- * @param {string} key
- * @returns {ErrorConstructor}
- */
-function makeNodeErrorWithCode$1(Base, key) {
-  // @ts-expect-error It’s a Node error.
-  return NodeError
-  /**
-   * @param {Array<unknown>} args
-   */
-  function NodeError(...args) {
-    const limit = Error.stackTraceLimit;
-    if (isErrorStackTraceLimitWritable$1()) Error.stackTraceLimit = 0;
-    const error = new Base();
-    // Reset the limit and setting the name property.
-    if (isErrorStackTraceLimitWritable$1()) Error.stackTraceLimit = limit;
-    const message = getMessage$1(key, args, 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$1(error);
-    // @ts-expect-error It’s a Node error.
-    error.code = key;
-    return error
-  }
-}
-
-/**
- * @returns {boolean}
- */
-function isErrorStackTraceLimitWritable$1() {
-  const desc = Object.getOwnPropertyDescriptor(Error, 'stackTraceLimit');
-  if (desc === undefined) {
-    return Object.isExtensible(Error)
-  }
-
-  return own$2.call(desc, 'writable') && desc.writable !== undefined
-    ? desc.writable
-    : desc.set !== undefined
-}
-
-/**
- * This function removes unnecessary frames from Node.js core errors.
- * @template {(...args: Array<any>) => unknown} T
- * @type {(fn: T) => T}
- */
-function hideStackFrames$1(fn) {
-  // We rename the functions that will be hidden to cut off the stacktrace
-  // at the outermost one
-  const hidden = nodeInternalPrefix$1 + fn.name;
-  Object.defineProperty(fn, 'name', {value: hidden});
-  return fn
-}
-
-const captureLargerStackTrace$1 = hideStackFrames$1(
-  /**
-   * @param {Error} error
-   * @returns {Error}
-   */
-  function (error) {
-    const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable$1();
-    if (stackTraceLimitIsWritable) {
-      userStackTraceLimit$1 = Error.stackTraceLimit;
-      Error.stackTraceLimit = Number.POSITIVE_INFINITY;
-    }
-
-    Error.captureStackTrace(error);
-
-    // Reset the limit
-    if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit$1;
-
-    return error
-  }
-);
-
-/**
- * @param {string} key
- * @param {Array<unknown>} args
- * @param {Error} self
- * @returns {string}
- */
-function getMessage$1(key, args, self) {
-  const message = messages$1.get(key);
-  assert$1(typeof message !== 'undefined', 'expected `message` to be found');
-
-  if (typeof message === 'function') {
-    assert$1(
-      message.length <= args.length, // Default options do not count.
-      `Code: ${key}; The provided arguments length (${args.length}) does not ` +
-        `match the required ones (${message.length}).`
-    );
-    return Reflect.apply(message, self, args)
-  }
-
-  const expectedLength = (message.match(/%[dfijoOs]/g) || []).length;
-  assert$1(
-    expectedLength === args.length,
-    `Code: ${key}; The provided arguments length (${args.length}) does not ` +
-      `match the required ones (${expectedLength}).`
-  );
-  if (args.length === 0) return message
-
-  args.unshift(message);
-  return Reflect.apply(format$2, null, args)
-}
-
-// Manually “tree shaken” from:
-
-const {ERR_UNKNOWN_FILE_EXTENSION} = codes$1;
-
-const hasOwnProperty$2 = {}.hasOwnProperty;
-
-/** @type {Record<string, string>} */
-const extensionFormatMap = {
-  // @ts-expect-error: hush.
-  __proto__: null,
-  '.cjs': 'commonjs',
-  '.js': 'module',
-  '.json': 'json',
-  '.mjs': 'module'
-};
-
-/**
- * @param {string|null} mime
- * @returns {string | null}
- */
-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
-}
-
-/**
- * @callback ProtocolHandler
- * @param {URL} parsed
- * @param {{parentURL: string}} context
- * @param {boolean} ignoreErrors
- * @returns {string|null}
- */
-
-/**
- * @type {Record<string, ProtocolHandler>}
- */
-const protocolHandlers = Object.assign(Object.create(null), {
-  'data:': getDataProtocolModuleFormat,
-  'file:': getFileProtocolModuleFormat,
-  'http:': getHttpProtocolModuleFormat,
-  'https:': getHttpProtocolModuleFormat,
-  'node:'() {
-    return 'builtin'
-  }
-});
-
-/**
- * @param {URL} parsed
- */
-function getDataProtocolModuleFormat(parsed) {
-  const {1: mime} = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(
-    parsed.pathname
-  ) || [null, null, null];
-  return mimeToFormat(mime)
-}
-
-/**
- * @type {ProtocolHandler}
- */
-function getFileProtocolModuleFormat(url, _context, ignoreErrors) {
-  const filepath = fileURLToPath(url);
-  const ext = path$n.extname(filepath);
-  if (ext === '.js') {
-    return getPackageType(url) === 'module' ? 'module' : 'commonjs'
-  }
-
-  const format = extensionFormatMap[ext];
-  if (format) return format
-  if (ignoreErrors) return null
-
-  throw new ERR_UNKNOWN_FILE_EXTENSION(ext, filepath)
-}
-
-function getHttpProtocolModuleFormat() {
-  // To do: HTTPS imports.
-}
-
-/**
- * @param {URL} url
- * @param {{parentURL: string}} context
- * @returns {string|null}
- */
-function defaultGetFormatWithoutErrors(url, context) {
-  if (!hasOwnProperty$2.call(protocolHandlers, url.protocol)) {
-    return null
-  }
-
-  return protocolHandlers[url.protocol](url, context, true)
-}
-
-// Manually “tree shaken” from:
-
-const RegExpPrototypeSymbolReplace = RegExp.prototype[Symbol.replace];
-
-// To do: potentially enable?
-const experimentalNetworkImports = false;
-
-const {
-  ERR_NETWORK_IMPORT_DISALLOWED,
-  ERR_INVALID_MODULE_SPECIFIER,
-  ERR_INVALID_PACKAGE_CONFIG,
-  ERR_INVALID_PACKAGE_TARGET,
-  ERR_MODULE_NOT_FOUND,
-  ERR_PACKAGE_IMPORT_NOT_DEFINED,
-  ERR_PACKAGE_PATH_NOT_EXPORTED,
-  ERR_UNSUPPORTED_DIR_IMPORT,
-  ERR_UNSUPPORTED_ESM_URL_SCHEME,
-  ERR_INVALID_ARG_VALUE
-} = codes$1;
-
-const own = {}.hasOwnProperty;
-
-const DEFAULT_CONDITIONS = Object.freeze(['node', 'import']);
-const DEFAULT_CONDITIONS_SET = new Set(DEFAULT_CONDITIONS);
-
-const 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;
-const invalidPackageNameRegEx = /^\.|%|\\/;
-const patternRegEx = /\*/g;
-const encodedSepRegEx = /%2f|%5c/i;
-/** @type {Set<string>} */
-const emittedPackageWarnings = new Set();
-/** @type {Map<string, PackageConfig>} */
-const packageJsonCache = new Map();
-
-/**
- * @param {URL} url
- * @param {URL} packageJsonUrl
- * @param {URL} base
- * @param {unknown} [main]
- * @returns {void}
- */
-function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
-  const format = defaultGetFormatWithoutErrors(url, {parentURL: base.href});
-  if (format !== 'module') return
-  const path = fileURLToPath(url.href);
-  const pkgPath = fileURLToPath(new URL$3('.', packageJsonUrl));
-  const basePath = fileURLToPath(base);
-  if (main)
-    process$1.emitWarning(
-      `Package ${pkgPath} has a "main" field set to ${JSON.stringify(main)}, ` +
-        `excluding the full filename and extension to the resolved file at "${path.slice(
-          pkgPath.length
-        )}", imported from ${basePath}.\n Automatic extension resolution of the "main" field is` +
-        'deprecated for ES modules.',
-      'DeprecationWarning',
-      'DEP0151'
-    );
-  else
-    process$1.emitWarning(
-      `No "main" or "exports" field defined in the package.json for ${pkgPath} resolving the main entry point "${path.slice(
-        pkgPath.length
-      )}", imported from ${basePath}.\nDefault "index" lookups for the main are deprecated for ES modules.`,
-      'DeprecationWarning',
-      'DEP0151'
-    );
-}
-
-/**
- * @param {Array<string>} [conditions]
- * @returns {Set<string>}
- */
-function getConditionsSet(conditions) {
-  if (conditions !== undefined && conditions !== DEFAULT_CONDITIONS) {
-    if (!Array.isArray(conditions)) {
-      throw new ERR_INVALID_ARG_VALUE(
-        'conditions',
-        conditions,
-        'expected an array'
-      )
-    }
-
-    return new Set(conditions)
-  }
-
-  return DEFAULT_CONDITIONS_SET
-}
-
-/**
- * @param {string} path
- * @returns {Stats}
- */
-function tryStatSync(path) {
-  // Note: from Node 15 onwards we can use `throwIfNoEntry: false` instead.
-  try {
-    return statSync$1(path)
-  } catch {
-    return new Stats$1()
-  }
-}
-
-/**
- * @param {string} path
- * @param {string|URL} specifier Note: `specifier` is actually optional, not base.
- * @param {URL} [base]
- * @returns {PackageConfig}
- */
-function getPackageConfig(path, specifier, base) {
-  const existing = packageJsonCache.get(path);
-  if (existing !== undefined) {
-    return existing
-  }
-
-  const source = packageJsonReader.read(path).string;
-
-  if (source === undefined) {
-    /** @type {PackageConfig} */
-    const packageConfig = {
-      pjsonPath: path,
-      exists: false,
-      main: undefined,
-      name: undefined,
-      type: 'none',
-      exports: undefined,
-      imports: undefined
-    };
-    packageJsonCache.set(path, packageConfig);
-    return packageConfig
-  }
-
-  /** @type {Record<string, unknown>} */
-  let packageJson;
-  try {
-    packageJson = JSON.parse(source);
-  } catch (error) {
-    const exception = /** @type {ErrnoException} */ (error);
-
-    throw new ERR_INVALID_PACKAGE_CONFIG(
-      path,
-      (base ? `"${specifier}" from ` : '') + fileURLToPath(base || specifier),
-      exception.message
-    )
-  }
-
-  const {exports, imports, main, name, type} = packageJson;
-
-  /** @type {PackageConfig} */
-  const packageConfig = {
-    pjsonPath: path,
-    exists: true,
-    main: typeof main === 'string' ? main : undefined,
-    name: typeof name === 'string' ? name : undefined,
-    type: type === 'module' || type === 'commonjs' ? type : 'none',
-    // @ts-expect-error Assume `Record<string, unknown>`.
-    exports,
-    // @ts-expect-error Assume `Record<string, unknown>`.
-    imports: imports && typeof imports === 'object' ? imports : undefined
-  };
-  packageJsonCache.set(path, packageConfig);
-  return packageConfig
-}
-
-/**
- * @param {URL} resolved
- * @returns {PackageConfig}
- */
-function getPackageScopeConfig(resolved) {
-  let packageJsonUrl = new URL$3('package.json', resolved);
-
-  while (true) {
-    const packageJsonPath = packageJsonUrl.pathname;
-
-    if (packageJsonPath.endsWith('node_modules/package.json')) break
-
-    const packageConfig = getPackageConfig(
-      fileURLToPath(packageJsonUrl),
-      resolved
-    );
-    if (packageConfig.exists) return packageConfig
-
-    const lastPackageJsonUrl = packageJsonUrl;
-    packageJsonUrl = new URL$3('../package.json', packageJsonUrl);
-
-    // Terminates at root where ../package.json equals ../../package.json
-    // (can't just check "/package.json" for Windows support).
-    if (packageJsonUrl.pathname === lastPackageJsonUrl.pathname) break
-  }
-
-  const packageJsonPath = fileURLToPath(packageJsonUrl);
-  /** @type {PackageConfig} */
-  const packageConfig = {
-    pjsonPath: packageJsonPath,
-    exists: false,
-    main: undefined,
-    name: undefined,
-    type: 'none',
-    exports: undefined,
-    imports: undefined
-  };
-  packageJsonCache.set(packageJsonPath, packageConfig);
-  return packageConfig
-}
-
-/**
- * Legacy CommonJS main resolution:
- * 1. let M = pkg_url + (json main field)
- * 2. TRY(M, M.js, M.json, M.node)
- * 3. TRY(M/index.js, M/index.json, M/index.node)
- * 4. TRY(pkg_url/index.js, pkg_url/index.json, pkg_url/index.node)
- * 5. NOT_FOUND
- *
- * @param {URL} url
- * @returns {boolean}
- */
-function fileExists(url) {
-  const stats = statSync$1(url, {throwIfNoEntry: false});
-  const isFile = stats ? stats.isFile() : undefined;
-  return isFile === null || isFile === undefined ? false : isFile
-}
-
-/**
- * @param {URL} packageJsonUrl
- * @param {PackageConfig} packageConfig
- * @param {URL} base
- * @returns {URL}
- */
-function legacyMainResolve(packageJsonUrl, packageConfig, base) {
-  /** @type {URL|undefined} */
-  let guess;
-  if (packageConfig.main !== undefined) {
-    guess = new URL$3(packageConfig.main, packageJsonUrl);
-    // Note: fs check redundances will be handled by Descriptor cache here.
-    if (fileExists(guess)) return guess
-
-    const tries = [
-      `./${packageConfig.main}.js`,
-      `./${packageConfig.main}.json`,
-      `./${packageConfig.main}.node`,
-      `./${packageConfig.main}/index.js`,
-      `./${packageConfig.main}/index.json`,
-      `./${packageConfig.main}/index.node`
-    ];
-    let i = -1;
-
-    while (++i < tries.length) {
-      guess = new URL$3(tries[i], packageJsonUrl);
-      if (fileExists(guess)) break
-      guess = undefined;
-    }
-
-    if (guess) {
-      emitLegacyIndexDeprecation(
-        guess,
-        packageJsonUrl,
-        base,
-        packageConfig.main
-      );
-      return guess
-    }
-    // Fallthrough.
-  }
-
-  const tries = ['./index.js', './index.json', './index.node'];
-  let i = -1;
-
-  while (++i < tries.length) {
-    guess = new URL$3(tries[i], packageJsonUrl);
-    if (fileExists(guess)) break
-    guess = undefined;
-  }
-
-  if (guess) {
-    emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main);
-    return guess
-  }
-
-  // Not found.
-  throw new ERR_MODULE_NOT_FOUND(
-    fileURLToPath(new URL$3('.', packageJsonUrl)),
-    fileURLToPath(base)
-  )
-}
-
-/**
- * @param {URL} resolved
- * @param {URL} base
- * @param {boolean} [preserveSymlinks]
- * @returns {URL}
- */
-function finalizeResolution(resolved, base, preserveSymlinks) {
-  if (encodedSepRegEx.test(resolved.pathname))
-    throw new ERR_INVALID_MODULE_SPECIFIER(
-      resolved.pathname,
-      'must not include encoded "/" or "\\" characters',
-      fileURLToPath(base)
-    )
-
-  const filePath = fileURLToPath(resolved);
-
-  const stats = tryStatSync(
-    filePath.endsWith('/') ? filePath.slice(-1) : filePath
-  );
-
-  if (stats.isDirectory()) {
-    const error = new ERR_UNSUPPORTED_DIR_IMPORT(filePath, fileURLToPath(base));
-    // @ts-expect-error Add this for `import.meta.resolve`.
-    error.url = String(resolved);
-    throw error
-  }
-
-  if (!stats.isFile()) {
-    throw new ERR_MODULE_NOT_FOUND(
-      filePath || resolved.pathname,
-      base && fileURLToPath(base),
-      'module'
-    )
-  }
-
-  if (!preserveSymlinks) {
-    const real = realpathSync$1(filePath);
-    const {search, hash} = resolved;
-    resolved = pathToFileURL(real + (filePath.endsWith(path$n.sep) ? '/' : ''));
-    resolved.search = search;
-    resolved.hash = hash;
-  }
-
-  return resolved
-}
-
-/**
- * @param {string} specifier
- * @param {URL|undefined} packageJsonUrl
- * @param {URL} base
- * @returns {never}
- */
-function throwImportNotDefined(specifier, packageJsonUrl, base) {
-  throw new ERR_PACKAGE_IMPORT_NOT_DEFINED(
-    specifier,
-    packageJsonUrl && fileURLToPath(new URL$3('.', packageJsonUrl)),
-    fileURLToPath(base)
-  )
-}
-
-/**
- * @param {string} subpath
- * @param {URL} packageJsonUrl
- * @param {URL} base
- * @returns {never}
- */
-function throwExportsNotFound(subpath, packageJsonUrl, base) {
-  throw new ERR_PACKAGE_PATH_NOT_EXPORTED(
-    fileURLToPath(new URL$3('.', packageJsonUrl)),
-    subpath,
-    base && fileURLToPath(base)
-  )
-}
-
-/**
- * @param {string} subpath
- * @param {URL} packageJsonUrl
- * @param {boolean} internal
- * @param {URL} [base]
- * @returns {never}
- */
-function throwInvalidSubpath(subpath, packageJsonUrl, internal, base) {
-  const reason = `request is not a valid subpath for the "${
-    internal ? 'imports' : 'exports'
-  }" resolution of ${fileURLToPath(packageJsonUrl)}`;
-
-  throw new ERR_INVALID_MODULE_SPECIFIER(
-    subpath,
-    reason,
-    base && fileURLToPath(base)
-  )
-}
-
-/**
- * @param {string} subpath
- * @param {unknown} target
- * @param {URL} packageJsonUrl
- * @param {boolean} internal
- * @param {URL} [base]
- * @returns {never}
- */
-function throwInvalidPackageTarget(
-  subpath,
-  target,
-  packageJsonUrl,
-  internal,
-  base
-) {
-  target =
-    typeof target === 'object' && target !== null
-      ? JSON.stringify(target, null, '')
-      : `${target}`;
-
-  throw new ERR_INVALID_PACKAGE_TARGET(
-    fileURLToPath(new URL$3('.', packageJsonUrl)),
-    subpath,
-    target,
-    internal,
-    base && fileURLToPath(base)
-  )
-}
-
-/**
- * @param {string} target
- * @param {string} subpath
- * @param {string} match
- * @param {URL} packageJsonUrl
- * @param {URL} base
- * @param {boolean} pattern
- * @param {boolean} internal
- * @param {Set<string>|undefined} conditions
- * @returns {URL}
- */
-function resolvePackageTargetString(
-  target,
-  subpath,
-  match,
-  packageJsonUrl,
-  base,
-  pattern,
-  internal,
-  conditions
-) {
-  if (subpath !== '' && !pattern && target[target.length - 1] !== '/')
-    throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base);
-
-  if (!target.startsWith('./')) {
-    if (internal && !target.startsWith('../') && !target.startsWith('/')) {
-      let isURL = false;
-
-      try {
-        new URL$3(target);
-        isURL = true;
-      } catch {
-        // Continue regardless of error.
-      }
-
-      if (!isURL) {
-        const exportTarget = pattern
-          ? RegExpPrototypeSymbolReplace.call(
-              patternRegEx,
-              target,
-              () => subpath
-            )
-          : target + subpath;
-
-        return packageResolve(exportTarget, packageJsonUrl, conditions)
-      }
-    }
-
-    throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base);
-  }
-
-  if (invalidSegmentRegEx.test(target.slice(2)))
-    throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base);
-
-  const resolved = new URL$3(target, packageJsonUrl);
-  const resolvedPath = resolved.pathname;
-  const packagePath = new URL$3('.', packageJsonUrl).pathname;
-
-  if (!resolvedPath.startsWith(packagePath))
-    throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base);
-
-  if (subpath === '') return resolved
-
-  if (invalidSegmentRegEx.test(subpath)) {
-    const request = pattern
-      ? match.replace('*', () => subpath)
-      : match + subpath;
-    throwInvalidSubpath(request, packageJsonUrl, internal, base);
-  }
-
-  if (pattern) {
-    return new URL$3(
-      RegExpPrototypeSymbolReplace.call(
-        patternRegEx,
-        resolved.href,
-        () => subpath
-      )
-    )
-  }
-
-  return new URL$3(subpath, resolved)
-}
-
-/**
- * @param {string} key
- * @returns {boolean}
- */
-function isArrayIndex(key) {
-  const keyNumber = Number(key);
-  if (`${keyNumber}` !== key) return false
-  return keyNumber >= 0 && keyNumber < 0xff_ff_ff_ff
-}
-
-/**
- * @param {URL} packageJsonUrl
- * @param {unknown} target
- * @param {string} subpath
- * @param {string} packageSubpath
- * @param {URL} base
- * @param {boolean} pattern
- * @param {boolean} internal
- * @param {Set<string>|undefined} conditions
- * @returns {URL|null}
- */
-function resolvePackageTarget(
-  packageJsonUrl,
-  target,
-  subpath,
-  packageSubpath,
-  base,
-  pattern,
-  internal,
-  conditions
-) {
-  if (typeof target === 'string') {
-    return resolvePackageTargetString(
-      target,
-      subpath,
-      packageSubpath,
-      packageJsonUrl,
-      base,
-      pattern,
-      internal,
-      conditions
-    )
-  }
-
-  if (Array.isArray(target)) {
-    /** @type {Array<unknown>} */
-    const targetList = target;
-    if (targetList.length === 0) return null
-
-    /** @type {ErrnoException|null|undefined} */
-    let lastException;
-    let i = -1;
-
-    while (++i < targetList.length) {
-      const targetItem = targetList[i];
-      /** @type {URL|null} */
-      let resolveResult;
-      try {
-        resolveResult = resolvePackageTarget(
-          packageJsonUrl,
-          targetItem,
-          subpath,
-          packageSubpath,
-          base,
-          pattern,
-          internal,
-          conditions
-        );
-      } catch (error) {
-        const exception = /** @type {ErrnoException} */ (error);
-        lastException = exception;
-        if (exception.code === 'ERR_INVALID_PACKAGE_TARGET') continue
-        throw error
-      }
-
-      if (resolveResult === undefined) continue
-
-      if (resolveResult === null) {
-        lastException = null;
-        continue
-      }
-
-      return resolveResult
-    }
-
-    if (lastException === undefined || 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_CONFIG(
-          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))) {
-        // @ts-expect-error: indexable.
-        const conditionalTarget = /** @type {unknown} */ (target[key]);
-        const resolveResult = resolvePackageTarget(
-          packageJsonUrl,
-          conditionalTarget,
-          subpath,
-          packageSubpath,
-          base,
-          pattern,
-          internal,
-          conditions
-        );
-        if (resolveResult === undefined) continue
-        return resolveResult
-      }
-    }
-
-    return null
-  }
-
-  if (target === null) {
-    return null
-  }
-
-  throwInvalidPackageTarget(
-    packageSubpath,
-    target,
-    packageJsonUrl,
-    internal,
-    base
-  );
-}
-
-/**
- * @param {unknown} exports
- * @param {URL} packageJsonUrl
- * @param {URL} base
- * @returns {boolean}
- */
-function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
-  if (typeof exports === 'string' || Array.isArray(exports)) return true
-  if (typeof exports !== 'object' || exports === null) return false
-
-  const keys = Object.getOwnPropertyNames(exports);
-  let isConditionalSugar = false;
-  let i = 0;
-  let j = -1;
-  while (++j < keys.length) {
-    const key = keys[j];
-    const curIsConditionalSugar = key === '' || key[0] !== '.';
-    if (i++ === 0) {
-      isConditionalSugar = curIsConditionalSugar;
-    } else if (isConditionalSugar !== curIsConditionalSugar) {
-      throw new ERR_INVALID_PACKAGE_CONFIG(
-        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
-}
-
-/**
- * @param {string} match
- * @param {URL} pjsonUrl
- * @param {URL} base
- */
-function emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) {
-  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'
-  );
-}
-
-/**
- * @param {URL} packageJsonUrl
- * @param {string} packageSubpath
- * @param {Record<string, unknown>} packageConfig
- * @param {URL} base
- * @param {Set<string>|undefined} conditions
- * @returns {URL}
- */
-function packageExportsResolve(
-  packageJsonUrl,
-  packageSubpath,
-  packageConfig,
-  base,
-  conditions
-) {
-  let exports = packageConfig.exports;
-
-  if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) {
-    exports = {'.': exports};
-  }
-
-  if (
-    own.call(exports, packageSubpath) &&
-    !packageSubpath.includes('*') &&
-    !packageSubpath.endsWith('/')
-  ) {
-    // @ts-expect-error: indexable.
-    const target = exports[packageSubpath];
-    const resolveResult = resolvePackageTarget(
-      packageJsonUrl,
-      target,
-      '',
-      packageSubpath,
-      base,
-      false,
-      false,
-      conditions
-    );
-    if (resolveResult === null || resolveResult === undefined) {
-      throwExportsNotFound(packageSubpath, packageJsonUrl, base);
-    }
-
-    return resolveResult
-  }
-
-  let bestMatch = '';
-  let bestMatchSubpath = '';
-  const keys = Object.getOwnPropertyNames(exports);
-  let i = -1;
-
-  while (++i < keys.length) {
-    const key = keys[i];
-    const patternIndex = key.indexOf('*');
-
-    if (
-      patternIndex !== -1 &&
-      packageSubpath.startsWith(key.slice(0, patternIndex))
-    ) {
-      // When this reaches EOL, this can throw at the top of the whole function:
-      //
-      // if (StringPrototypeEndsWith(packageSubpath, '/'))
-      //   throwInvalidSubpath(packageSubpath)
-      //
-      // To match "imports" and the spec.
-      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) {
-    // @ts-expect-error: indexable.
-    const target = /** @type {unknown} */ (exports[bestMatch]);
-    const resolveResult = resolvePackageTarget(
-      packageJsonUrl,
-      target,
-      bestMatchSubpath,
-      bestMatch,
-      base,
-      true,
-      false,
-      conditions
-    );
-
-    if (resolveResult === null || resolveResult === undefined) {
-      throwExportsNotFound(packageSubpath, packageJsonUrl, base);
-    }
-
-    return resolveResult
-  }
-
-  throwExportsNotFound(packageSubpath, packageJsonUrl, base);
-}
-
-/**
- * @param {string} a
- * @param {string} b
- */
-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
-}
-
-/**
- * @param {string} name
- * @param {URL} base
- * @param {Set<string>} [conditions]
- * @returns {URL}
- */
-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))
-  }
-
-  /** @type {URL|undefined} */
-  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,
-          conditions
-        );
-        if (resolveResult !== null && resolveResult !== undefined) {
-          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,
-            conditions
-          );
-
-          if (resolveResult !== null && resolveResult !== undefined) {
-            return resolveResult
-          }
-        }
-      }
-    }
-  }
-
-  throwImportNotDefined(name, packageJsonUrl, base);
-}
-
-/**
- * @param {URL} url
- * @returns {PackageType}
- */
-function getPackageType(url) {
-  const packageConfig = getPackageScopeConfig(url);
-  return packageConfig.type
-}
-
-/**
- * @param {string} specifier
- * @param {URL} 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);
-
-  // Package name cannot have leading . and cannot have percent-encoding or
-  // \\ separators.
-  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}
-}
-
-/**
- * @param {string} specifier
- * @param {URL} base
- * @param {Set<string>|undefined} conditions
- * @returns {URL}
- */
-function packageResolve(specifier, base, conditions) {
-  if (builtinModules.includes(specifier)) {
-    return new URL$3('node:' + specifier)
-  }
-
-  const {packageName, packageSubpath, isScoped} = parsePackageName(
-    specifier,
-    base
-  );
-
-  // ResolveSelf
-  const packageConfig = getPackageScopeConfig(base);
-
-  // Can’t test.
-  /* c8 ignore next 16 */
-  if (packageConfig.exists) {
-    const packageJsonUrl = pathToFileURL(packageConfig.pjsonPath);
-    if (
-      packageConfig.name === packageName &&
-      packageConfig.exports !== undefined &&
-      packageConfig.exports !== null
-    ) {
-      return packageExportsResolve(
-        packageJsonUrl,
-        packageSubpath,
-        packageConfig,
-        base,
-        conditions
-      )
-    }
-  }
-
-  let packageJsonUrl = new URL$3(
-    './node_modules/' + packageName + '/package.json',
-    base
-  );
-  let packageJsonPath = fileURLToPath(packageJsonUrl);
-  /** @type {string} */
-  let lastPath;
-  do {
-    const stat = tryStatSync(packageJsonPath.slice(0, -13));
-    if (!stat.isDirectory()) {
-      lastPath = packageJsonPath;
-      packageJsonUrl = new URL$3(
-        (isScoped ? '../../../../node_modules/' : '../../../node_modules/') +
-          packageName +
-          '/package.json',
-        packageJsonUrl
-      );
-      packageJsonPath = fileURLToPath(packageJsonUrl);
-      continue
-    }
-
-    // Package match.
-    const packageConfig = getPackageConfig(packageJsonPath, specifier, base);
-    if (packageConfig.exports !== undefined && packageConfig.exports !== null) {
-      return packageExportsResolve(
-        packageJsonUrl,
-        packageSubpath,
-        packageConfig,
-        base,
-        conditions
-      )
-    }
-
-    if (packageSubpath === '.') {
-      return legacyMainResolve(packageJsonUrl, packageConfig, base)
-    }
-
-    return new URL$3(packageSubpath, packageJsonUrl)
-    // Cross-platform root check.
-  } while (packageJsonPath.length !== lastPath.length)
-
-  throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath(base))
-}
-
-/**
- * @param {string} specifier
- * @returns {boolean}
- */
-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
-}
-
-/**
- * @param {string} specifier
- * @returns {boolean}
- */
-function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
-  if (specifier === '') return false
-  if (specifier[0] === '/') return true
-  return isRelativeSpecifier(specifier)
-}
-
-/**
- * The “Resolver Algorithm Specification” as detailed in the Node docs (which is
- * sync and slightly lower-level than `resolve`).
- *
- * @param {string} specifier
- * @param {URL} base
- * @param {Set<string>} [conditions]
- * @param {boolean} [preserveSymlinks]
- * @returns {URL}
- */
-function moduleResolve(specifier, base, conditions, preserveSymlinks) {
-  const isRemote = base.protocol === 'http:' || base.protocol === 'https:';
-  // Order swapped from spec for minor perf gain.
-  // Ok since relative URLs cannot parse as URLs.
-  /** @type {URL|undefined} */
-  let resolved;
-
-  if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
-    resolved = new URL$3(specifier, base);
-  } else if (!isRemote && specifier[0] === '#') {
-    resolved = packageImportsResolve(specifier, base, conditions);
-  } else {
-    try {
-      resolved = new URL$3(specifier);
-    } catch {
-      if (!isRemote) {
-        resolved = packageResolve(specifier, base, conditions);
-      }
-    }
-  }
-
-  assert$1(typeof resolved !== 'undefined', 'expected to be defined');
-
-  if (resolved.protocol !== 'file:') {
-    return resolved
-  }
-
-  return finalizeResolution(resolved, base, preserveSymlinks)
-}
-
-/**
- * @param {string} specifier
- * @param {URL|undefined} parsed
- * @param {URL|undefined} parsedParentURL
- */
-function checkIfDisallowedImport(specifier, parsed, parsedParentURL) {
-  if (
-    parsed &&
-    parsedParentURL &&
-    (parsedParentURL.protocol === 'http:' ||
-      parsedParentURL.protocol === 'https:')
-  ) {
-    if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
-      // Data: and blob: disallowed due to allowing file: access via
-      // indirection
-      if (
-        parsed &&
-        parsed.protocol !== 'https:' &&
-        parsed.protocol !== 'http:'
-      ) {
-        throw new ERR_NETWORK_IMPORT_DISALLOWED(
-          specifier,
-          parsedParentURL,
-          'remote imports cannot import from a local location.'
-        )
-      }
-
-      return {url: parsed.href}
-    }
-
-    if (builtinModules.includes(specifier)) {
-      throw new ERR_NETWORK_IMPORT_DISALLOWED(
-        specifier,
-        parsedParentURL,
-        'remote imports cannot import from a local location.'
-      )
-    }
-
-    throw new ERR_NETWORK_IMPORT_DISALLOWED(
-      specifier,
-      parsedParentURL,
-      'only relative and absolute specifiers are supported.'
-    )
-  }
-}
-
-/**
- * @param {URL} url
- */
-function throwIfUnsupportedURLProtocol(url) {
-  if (
-    url.protocol !== 'file:' &&
-    url.protocol !== 'data:' &&
-    url.protocol !== 'node:'
-  ) {
-    throw new ERR_UNSUPPORTED_ESM_URL_SCHEME(url)
-  }
-}
-
-/**
- * @param {URL|undefined} parsed
- * @param {boolean} experimentalNetworkImports
- */
-function throwIfUnsupportedURLScheme(parsed, experimentalNetworkImports) {
-  if (
-    parsed &&
-    parsed.protocol !== 'file:' &&
-    parsed.protocol !== 'data:' &&
-    (!experimentalNetworkImports ||
-      (parsed.protocol !== 'https:' && parsed.protocol !== 'http:'))
-  ) {
-    throw new ERR_UNSUPPORTED_ESM_URL_SCHEME(
-      parsed,
-      ['file', 'data'].concat(
-        experimentalNetworkImports ? ['https', 'http'] : []
-      )
-    )
-  }
-}
-
-/**
- * @param {string} specifier
- * @param {{parentURL?: string, conditions?: Array<string>}} context
- * @returns {{url: string, format?: string|null}}
- */
-function defaultResolve(specifier, context = {}) {
-  const {parentURL} = context;
-  assert$1(typeof parentURL !== 'undefined', 'expected `parentURL` to be defined');
-
-  /** @type {URL|undefined} */
-  let parsedParentURL;
-  if (parentURL) {
-    try {
-      parsedParentURL = new URL$3(parentURL);
-    } catch {
-      // Ignore exception
-    }
-  }
-
-  /** @type {URL|undefined} */
-  let parsed;
-  try {
-    parsed = shouldBeTreatedAsRelativeOrAbsolutePath(specifier)
-      ? new URL$3(specifier, parsedParentURL)
-      : new URL$3(specifier);
-
-    if (
-      parsed.protocol === 'data:' ||
-      (experimentalNetworkImports )
-    ) {
-      return {url: parsed.href, format: null}
-    }
-  } catch {
-    // Ignore exception
-  }
-
-  // There are multiple deep branches that can either throw or return; instead
-  // of duplicating that deeply nested logic for the possible returns, DRY and
-  // check for a return. This seems the least gnarly.
-  const maybeReturn = checkIfDisallowedImport(
-    specifier,
-    parsed,
-    parsedParentURL
-  );
-
-  if (maybeReturn) return maybeReturn
-
-  // This must come after checkIfDisallowedImport
-  if (parsed && parsed.protocol === 'node:') return {url: specifier}
-
-  throwIfUnsupportedURLScheme(parsed, experimentalNetworkImports);
-
-  const conditions = getConditionsSet(context.conditions);
-
-  const url = moduleResolve(specifier, new URL$3(parentURL), conditions, false);
-
-  throwIfUnsupportedURLProtocol(url);
-
-  return {
-    // Do NOT cast `url` to a string: that will work even when there are real
-    // problems, silencing them
-    url: url.href,
-    format: defaultGetFormatWithoutErrors(url, {parentURL})
-  }
-}
-
-/**
- * @typedef {import('./lib/errors.js').ErrnoException} ErrnoException
- */
-
-/**
- * Provides a module-relative resolution function scoped to each module,
- * returning the URL string.
- * `import.meta.resolve` also accepts a second argument which is the parent
- * module from which to resolve from.
- *
- * This function is asynchronous because the ES module resolver in Node.js is
- * allowed to be asynchronous.
- *
- * @param {string} specifier The module specifier to resolve relative to parent.
- * @param {string} parent The absolute parent module URL to resolve from.
- *   You should pass `import.meta.url` or something else
- * @returns {Promise<string>}
- */
-async function resolve$4(specifier, parent) {
-  if (!parent) {
-    throw new Error(
-      'Please pass `parent`: `import-meta-resolve` cannot ponyfill that'
-    )
-  }
-
-  try {
-    return defaultResolve(specifier, {parentURL: parent}).url
-  } catch (error) {
-    const exception = /** @type {ErrnoException} */ (error);
-
-    return exception.code === 'ERR_UNSUPPORTED_DIR_IMPORT' &&
-      typeof exception.url === 'string'
-      ? exception.url
-      : Promise.reject(error)
-  }
-}
-
 var picomatch$5 = {exports: {}};
 
 var utils$k = {};
@@ -4317,7 +2560,7 @@ function getMatcherString$1(id, resolutionBase) {
         return id;
     }
     // resolve('') is valid and will default to process.cwd()
-    const basePath = resolve$5(resolutionBase || '')
+    const basePath = resolve$4(resolutionBase || '')
         .split(sep)
         .join('/')
         // escape all possible (posix + win) path characters that might interfere with regex
@@ -6322,7 +4565,7 @@ function requireSync () {
 	var minimatch = minimatch_1;
 	requireGlob().Glob;
 	var path = require$$0$4;
-	var assert = assert$2;
+	var assert = assert$1;
 	var isAbsolute = pathIsAbsolute.exports;
 	var common = common$c;
 	var setopts = common.setopts;
@@ -6982,7 +5225,7 @@ function requireGlob () {
 	var inherits$1 = inherits.exports;
 	var EE = require$$0$5.EventEmitter;
 	var path = require$$0$4;
-	var assert = assert$2;
+	var assert = assert$1;
 	var isAbsolute = pathIsAbsolute.exports;
 	var globSync = requireSync();
 	var common = common$c;
@@ -9165,7 +7408,7 @@ function getPackageEntryPoint(dirPath) {
 
 function isDirectory(path) {
   try {
-    if (statSync$2(path).isDirectory()) return true;
+    if (statSync$1(path).isDirectory()) return true;
   } catch (ignored) {
     // Nothing to do here
   }
@@ -9182,11 +7425,11 @@ function getDynamicRequireModules(patterns, dynamicRequireRoot) {
         ? dynamicRequireModules.delete(targetPath)
         : dynamicRequireModules.set(targetPath, resolvedPath);
     for (const path of globExports.sync(isNegated ? pattern.substr(1) : pattern)) {
-      const resolvedPath = resolve$5(path);
+      const resolvedPath = resolve$4(path);
       const requirePath = normalizePathSlashes(resolvedPath);
       if (isDirectory(resolvedPath)) {
         dirNames.add(resolvedPath);
-        const modulePath = resolve$5(join$1(resolvedPath, getPackageEntryPoint(path)));
+        const modulePath = resolve$4(join$1(resolvedPath, getPackageEntryPoint(path)));
         modifyMap(requirePath, modulePath);
         modifyMap(normalizePathSlashes(modulePath), modulePath);
       } else {
@@ -9483,12 +7726,12 @@ function resolveExtensions(importee, importer, extensions) {
   // not our problem
   if (importee[0] !== '.' || !importer) return undefined;
 
-  const resolved = resolve$5(dirname$1(importer), importee);
+  const resolved = resolve$4(dirname$1(importer), importee);
   const candidates = getCandidates(resolved, extensions);
 
   for (let i = 0; i < candidates.length; i += 1) {
     try {
-      const stats = statSync$2(candidates[i]);
+      const stats = statSync$1(candidates[i]);
       if (stats.isFile()) return { id: candidates[i] };
     } catch (err) {
       /* noop */
@@ -10996,7 +9239,7 @@ function commonjs(options = {}) {
 
   const dynamicRequireRoot =
     typeof options.dynamicRequireRoot === 'string'
-      ? resolve$5(options.dynamicRequireRoot)
+      ? resolve$4(options.dynamicRequireRoot)
       : process.cwd();
   const { commonDir, dynamicRequireModules } = getDynamicRequireModules(
     options.dynamicRequireTargets,
@@ -13286,7 +11529,7 @@ function getMatcherString(id, resolutionBase) {
         return normalizePath$4(id);
     }
     // resolve('') is valid and will default to process.cwd()
-    const basePath = normalizePath$4(resolve$5(resolutionBase || ''))
+    const basePath = normalizePath$4(resolve$4(resolutionBase || ''))
         // escape all possible (posix + win) path characters that might interfere with regex
         .replace(/[-^$*+?.()|[\]{}]/g, '\\$&');
     // Note that we use posix.join because:
@@ -13493,7 +11736,7 @@ try {
 catch { }
 const ssrExtensions = ['.js', '.cjs', '.json', '.node'];
 function resolveFrom(id, basedir, preserveSymlinks = false, ssr = false) {
-    return resolve$6.sync(id, {
+    return resolve$5.sync(id, {
         basedir,
         paths: [],
         extensions: ssr ? ssrExtensions : DEFAULT_EXTENSIONS$1,
@@ -13585,7 +11828,7 @@ const dataUrlRE = /^\s*data:/i;
 const isDataUrl = (url) => dataUrlRE.test(url);
 const virtualModuleRE = /^virtual-module:.*/;
 const virtualModulePrefix = 'virtual-module:';
-const knownJsSrcRE = /\.((j|t)sx?|m[jt]s|vue|marko|svelte|astro)($|\?)/;
+const knownJsSrcRE = /\.((j|t)sx?|m[jt]s|vue|marko|svelte|astro|imba)($|\?)/;
 const isJSRequest = (url) => {
     url = cleanUrl(url);
     if (knownJsSrcRE.test(url)) {
@@ -14299,6 +12542,18 @@ const isNonDriveRelativeAbsolutePath = (p) => {
         return p.startsWith('/');
     return windowsDrivePathPrefixRE.test(p);
 };
+function joinUrlSegments(a, b) {
+    if (!a || !b) {
+        return a || b || '';
+    }
+    if (a.endsWith('/')) {
+        a = a.substring(0, a.length - 1);
+    }
+    if (!b.startsWith('/')) {
+        b = '/' + b;
+    }
+    return a + b;
+}
 
 /* eslint no-console: 0 */
 const LogLevels = {
@@ -15124,15 +13379,12 @@ async function transformWithEsbuild(code, filename, options, inMap) {
         // these fields would affect the compilation result
         // https://esbuild.github.io/content-types/#tsconfig-json
         const meaningfulFields = [
-            'alwaysStrict',
-            'importsNotUsedAsValues',
-            'jsx',
+            'target',
             'jsxFactory',
             'jsxFragmentFactory',
-            'jsxImportSource',
-            'preserveValueImports',
-            'target',
-            'useDefineForClassFields'
+            'useDefineForClassFields',
+            'importsNotUsedAsValues',
+            'preserveValueImports'
         ];
         const compilerOptionsForFile = {};
         if (loader === 'ts' || loader === 'tsx') {
@@ -35378,9 +33630,8 @@ function fileToDevUrl(id, config) {
         // (this is special handled by the serve static middleware
         rtn = path$n.posix.join(FS_PREFIX + id);
     }
-    const origin = config.server?.origin ?? '';
-    const devBase = config.base;
-    return origin + devBase + rtn.replace(/^\//, '');
+    const base = joinUrlSegments(config.server?.origin ?? '', config.base);
+    return joinUrlSegments(base, rtn.replace(/^\//, ''));
 }
 function getAssetFilename(hash, config) {
     return assetHashToFilenameMap.get(config)?.get(hash);
@@ -35479,7 +33730,7 @@ const publicAssetUrlRE = /__VITE_PUBLIC_ASSET__([a-z\d]{8})__/g;
 function publicFileToBuiltUrl(url, config) {
     if (config.command !== 'build') {
         // We don't need relative base or renderBuiltUrl support during dev
-        return config.base + url.slice(1);
+        return joinUrlSegments(config.base, url);
     }
     const hash = getHash(url);
     let cache = publicAssetUrlCache.get(config);
@@ -35771,7 +34022,7 @@ createError(
   (pkgPath, key, target, isImport = false, base = void 0) => {
     const relError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
     if (key === ".") {
-      assert$2(isImport === false);
+      assert$1(isImport === false);
       return `Invalid "exports" main target ${JSON.stringify(target)} defined in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ""}${relError ? '; targets must start with "./"' : ""}`;
     }
     return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(
@@ -35817,7 +34068,7 @@ createError(
 createError(
   "ERR_INVALID_ARG_VALUE",
   (name, value, reason = "is invalid") => {
-    let inspected = inspect$1(value);
+    let inspected = inspect(value);
     if (inspected.length > 128) {
       inspected = `${inspected.slice(0, 128)}...`;
     }
@@ -35918,14 +34169,14 @@ const captureLargerStackTrace = hideStackFrames(
 function getMessage(key, args, self) {
   const message = messages.get(key);
   if (typeof message === "function") {
-    assert$2(
+    assert$1(
       message.length <= args.length,
       `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${message.length}).`
     );
     return Reflect.apply(message, self, args);
   }
   const expectedLength = (message.match(/%[dfijoOs]/g) || []).length;
-  assert$2(
+  assert$1(
     expectedLength === args.length,
     `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`
   );
@@ -35933,10 +34184,10 @@ function getMessage(key, args, self) {
     return message;
   }
   args.unshift(message);
-  return Reflect.apply(format$3, null, args);
+  return Reflect.apply(format$2, null, args);
 }
 Object.freeze(["node", "import"]);
-pathToFileURL$1(process.cwd());
+pathToFileURL(process.cwd());
 
 const ESM_STATIC_IMPORT_RE = /(?<=\s|^|;)import\s*(["'\s]*(?<imports>[\w*${}\n\r\t, /]+)from\s*)?["']\s*(?<specifier>(?<="\s*)[^"]*[^"\s](?=\s*")|(?<='\s*)[^']*[^'\s](?=\s*'))\s*["'][\s;]*/gm;
 function findStaticImports(code) {
@@ -37043,12 +35294,28 @@ function packageEntryFailure(id, details) {
         `The package may have incorrect main/module/exports specified in its package.json` +
         (details ? ': ' + details : '.'));
 }
+const conditionalConditions = new Set(['production', 'development', 'module']);
 function resolveExports(pkg, key, options, targetWeb) {
-    const conditions = [options.isProduction ? 'production' : 'development'];
-    if (!options.isRequire) {
+    const overrideConditions = options.overrideConditions
+        ? new Set(options.overrideConditions)
+        : undefined;
+    const conditions = [];
+    if ((!overrideConditions || overrideConditions.has('production')) &&
+        options.isProduction) {
+        conditions.push('production');
+    }
+    if ((!overrideConditions || overrideConditions.has('development')) &&
+        !options.isProduction) {
+        conditions.push('development');
+    }
+    if ((!overrideConditions || overrideConditions.has('module')) &&
+        !options.isRequire) {
         conditions.push('module');
     }
-    if (options.conditions.length > 0) {
+    if (options.overrideConditions) {
+        conditions.push(...options.overrideConditions.filter((condition) => conditionalConditions.has(condition)));
+    }
+    else if (options.conditions.length > 0) {
         conditions.push(...options.conditions);
     }
     return resolve(pkg, key, {
@@ -37211,6 +35478,7 @@ const externalTypes = [
     'svelte',
     'marko',
     'astro',
+    'imba',
     // JSX/TSX may be configured to be compiled differently from how esbuild
     // handles it by default, so exclude them as well
     'jsx',
@@ -38982,12 +37250,12 @@ var convertSourceMap = {};
 } (convertSourceMap));
 
 function totalist(dir, callback, pre='') {
-	dir = resolve$5('.', dir);
+	dir = resolve$4('.', dir);
 	let arr = readdirSync(dir);
 	let i=0, abs, stats;
 	for (; i < arr.length; i++) {
 		abs = join$1(dir, arr[i]);
-		stats = statSync$2(abs);
+		stats = statSync$1(abs);
 		stats.isDirectory()
 			? totalist(abs, callback, join$1(pre, arr[i]))
 			: callback(join$1(pre, arr[i]), abs, stats);
@@ -39141,7 +37409,7 @@ function toHeaders(name, stats, isEtag) {
 }
 
 function sirv (dir, opts={}) {
-	dir = resolve$5(dir || '.');
+	dir = resolve$4(dir || '.');
 
 	let isNotFound = opts.onNoMatch || is404;
 	let setHeaders = opts.setHeaders || noop$2;
@@ -39502,6 +37770,7 @@ async function loadAndTransform(id, url, server, options, timestamp) {
             try {
                 map = (convertSourceMap.fromSource(code) ||
                     convertSourceMap.fromMapFileSource(code, path$n.dirname(file)))?.toObject();
+                code = code.replace(convertSourceMap.mapFileCommentRegex, blankReplacer);
             }
             catch (e) {
                 logger.warn(`Failed to load source map for ${url}.`, {
@@ -42754,7 +41023,7 @@ async function createPluginContainer(config, moduleGraph, watcher) {
     // TODO: use import()
     const _require = createRequire$1(import.meta.url);
     // get rollup version
-    const rollupPkgPath = resolve$7(_require.resolve('rollup'), '../../package.json');
+    const rollupPkgPath = resolve$6(_require.resolve('rollup'), '../../package.json');
     const minimalContext = {
         meta: {
             rollupVersion: JSON.parse(fs$l.readFileSync(rollupPkgPath, 'utf-8'))
@@ -42979,6 +41248,10 @@ async function createPluginContainer(config, moduleGraph, watcher) {
             this.filename = filename;
             this.originalCode = code;
             if (inMap) {
+                if (isDebugSourcemapCombineFocused) {
+                    // @ts-expect-error inject name for debug purpose
+                    inMap.name = '$inMap';
+                }
                 this.sourcemapChain.push(inMap);
             }
         }
@@ -43189,7 +41462,7 @@ async function createPluginContainer(config, moduleGraph, watcher) {
 }
 
 const debug$8 = createDebugger('vite:deps');
-const htmlTypesRE = /\.(html|vue|svelte|astro)$/;
+const htmlTypesRE = /\.(html|vue|svelte|astro|imba)$/;
 // A simple regex to detect import sources. This is only used on
 // <script lang="ts"> blocks in vue (setup only) or svelte files, since
 // seemingly unused imports are dropped by esbuild when transpiling TS which
@@ -46205,7 +44478,7 @@ function cssPlugin(config) {
                         return publicFileToBuiltUrl(url, config);
                     }
                     else {
-                        return config.base + url.slice(1);
+                        return joinUrlSegments(config.base, url);
                     }
                 }
                 const resolved = await resolveUrl(url, importer);
@@ -46233,7 +44506,6 @@ function cssPlugin(config) {
                 // server only logic for handling CSS @import dependency hmr
                 const { moduleGraph } = server;
                 const thisModule = moduleGraph.getModuleById(id);
-                const devBase = config.base;
                 if (thisModule) {
                     // CSS modules cannot self-accept since it exports values
                     const isSelfAccepting = !modules && !inlineRE.test(id) && !htmlProxyRE.test(id);
@@ -46241,6 +44513,7 @@ function cssPlugin(config) {
                         // record deps in the module graph so edits to @import css can trigger
                         // main import to hot update
                         const depModules = new Set();
+                        const devBase = config.base;
                         for (const file of deps) {
                             depModules.add(isCSSRequest(file)
                                 ? moduleGraph.createFileOnlyEntry(file)
@@ -46339,9 +44612,8 @@ function cssPostPlugin(config) {
                     return `export default ${JSON.stringify(css)}`;
                 }
                 const cssContent = await getContentWithSourcemap(css);
-                const devBase = config.base;
                 const code = [
-                    `import { updateStyle as __vite__updateStyle, removeStyle as __vite__removeStyle } from ${JSON.stringify(path$n.posix.join(devBase, CLIENT_PUBLIC_PATH))}`,
+                    `import { updateStyle as __vite__updateStyle, removeStyle as __vite__removeStyle } from ${JSON.stringify(path$n.posix.join(config.base, CLIENT_PUBLIC_PATH))}`,
                     `const __vite__id = ${JSON.stringify(id)}`,
                     `const __vite__css = ${JSON.stringify(cssContent)}`,
                     `__vite__updateStyle(__vite__id, __vite__css)`,
@@ -46698,7 +44970,7 @@ async function compileCSS(id, code, config, urlReplacer) {
         }));
     }
     if (isModule) {
-        postcssPlugins.unshift((await import('./dep-1180cbc3.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-6873f27c.js').then(function (n) { return n.i; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -47559,15 +45831,15 @@ function ssrManifestPlugin(config) {
                         const normalizedId = normalizePath$3(relative$2(config.root, id));
                         const mappedChunks = ssrManifest[normalizedId] ?? (ssrManifest[normalizedId] = []);
                         if (!chunk.isEntry) {
-                            mappedChunks.push(base + chunk.fileName);
+                            mappedChunks.push(joinUrlSegments(base, chunk.fileName));
                             // <link> tags for entry chunks are already generated in static HTML,
                             // so we only need to record info for non-entry chunks.
                             chunk.viteMetadata.importedCss.forEach((file) => {
-                                mappedChunks.push(base + file);
+                                mappedChunks.push(joinUrlSegments(base, file));
                             });
                         }
                         chunk.viteMetadata.importedAssets.forEach((file) => {
-                            mappedChunks.push(base + file);
+                            mappedChunks.push(joinUrlSegments(base, file));
                         });
                     }
                     if (chunk.code.includes(preloadMethod)) {
@@ -47598,7 +45870,7 @@ function ssrManifestPlugin(config) {
                                     const chunk = bundle[filename];
                                     if (chunk) {
                                         chunk.viteMetadata.importedCss.forEach((file) => {
-                                            deps.push(join$2(base, file)); // TODO:base
+                                            deps.push(joinUrlSegments(base, file)); // TODO:base
                                         });
                                         chunk.imports.forEach(addDeps);
                                     }
@@ -47969,14 +46241,6 @@ function loadEnv(mode, envDir, prefixes = 'VITE_') {
         /** mode file */ `.env.${mode}`,
         /** mode local file */ `.env.${mode}.local`
     ];
-    // check if there are actual env variables starting with VITE_*
-    // these are typically provided inline and should be prioritized
-    for (const key in process.env) {
-        if (prefixes.some((prefix) => key.startsWith(prefix)) &&
-            env[key] === undefined) {
-            env[key] = process.env[key];
-        }
-    }
     const parsed = Object.fromEntries(envFiles.flatMap((file) => {
         const path = lookupFile(envDir, [file], {
             pathOnly: true,
@@ -48005,6 +46269,13 @@ function loadEnv(mode, envDir, prefixes = 'VITE_') {
             process.env.VITE_USER_NODE_ENV = value;
         }
     }
+    // check if there are actual env variables starting with VITE_*
+    // these are typically provided inline and should be prioritized
+    for (const key in process.env) {
+        if (prefixes.some((prefix) => key.startsWith(prefix))) {
+            env[key] = process.env[key];
+        }
+    }
     return env;
 }
 function resolveEnvPrefix({ envPrefix = 'VITE_' }) {
@@ -48613,7 +46884,7 @@ function toOutputFilePathInJS(filename, type, hostId, hostType, config, toRelati
     if (relative && !config.build.ssr) {
         return toRelative(filename, hostId);
     }
-    return config.base + filename;
+    return joinUrlSegments(config.base, filename);
 }
 function createToImportMetaURLBasedRelativeRuntime(format) {
     const toRelativePath = relativeUrlMechanisms[format];
@@ -55891,7 +54162,7 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
     mod.ssrModule = ssrModule;
     const ssrImportMeta = {
         // The filesystem URL, matching native Node.js modules
-        url: pathToFileURL(mod.file).toString()
+        url: pathToFileURL$1(mod.file).toString()
     };
     urlStack = urlStack.concat(url);
     const isCircular = (url) => urlStack.includes(url);
@@ -56036,7 +54307,7 @@ async function nodeImport(id, importer, resolveOptions) {
             ? { ...resolveOptions, tryEsmOnly: true }
             : resolveOptions);
         if (usingDynamicImport) {
-            url = pathToFileURL(url).toString();
+            url = pathToFileURL$1(url).toString();
         }
     }
     try {
@@ -60555,7 +58826,7 @@ function createWebSocketServer(server, config, httpsOptions) {
 
 // this middleware is only active when (config.base !== '/')
 function baseMiddleware({ config }) {
-    const devBase = config.base;
+    const devBase = config.base.endsWith('/') ? config.base : config.base + '/';
     // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
     return function viteBaseMiddleware(req, res, next) {
         const url = req.url;
@@ -60574,18 +58845,18 @@ function baseMiddleware({ config }) {
         if (path === '/' || path === '/index.html') {
             // redirect root visit to based url with search and hash
             res.writeHead(302, {
-                Location: devBase + (parsed.search || '') + (parsed.hash || '')
+                Location: config.base + (parsed.search || '') + (parsed.hash || '')
             });
             res.end();
             return;
         }
         else if (req.headers.accept?.includes('text/html')) {
             // non-based page visit
-            const redirectPath = devBase + url.slice(1);
+            const redirectPath = joinUrlSegments(config.base, url);
             res.writeHead(404, {
                 'Content-Type': 'text/html'
             });
-            res.end(`The server is configured with a public base URL of ${devBase} - ` +
+            res.end(`The server is configured with a public base URL of ${config.base} - ` +
                 `did you mean to visit <a href="${redirectPath}">${redirectPath}</a> instead?`);
             return;
         }
@@ -61397,7 +59668,7 @@ var URL$1 = url.URL;
 var http$1 = require$$1$1;
 var https$1 = require$$1$2;
 var Writable = require$$0$7.Writable;
-var assert = assert$2;
+var assert = assert$1;
 var debug$2 = debug_1;
 
 // Create handlers that pass events from native requests
@@ -63073,7 +61344,8 @@ const processNodeUrl = (attr, sourceCodeLocation, s, config, htmlPath, originalU
     const devBase = config.base;
     if (startsWithSingleSlashRE.test(url)) {
         // prefix with base (dev only, base is never relative)
-        overwriteAttrValue(s, sourceCodeLocation, devBase + url.slice(1));
+        const fullUrl = joinUrlSegments(devBase, url);
+        overwriteAttrValue(s, sourceCodeLocation, fullUrl);
     }
     else if (url.startsWith('.') &&
         originalUrl &&
@@ -63098,7 +61370,7 @@ const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl
     const trailingSlash = htmlPath.endsWith('/');
     if (!trailingSlash && fs$l.existsSync(filename)) {
         proxyModulePath = htmlPath;
-        proxyModuleUrl = base + htmlPath.slice(1);
+        proxyModuleUrl = joinUrlSegments(base, htmlPath);
     }
     else {
         // There are users of vite.transformIndexHtml calling it with url '/'
@@ -64736,8 +63008,7 @@ async function createServer(inlineConfig = {}) {
         middlewares.use(proxyMiddleware(httpServer, proxy, config));
     }
     // base
-    const devBase = config.base;
-    if (devBase !== '/') {
+    if (config.base !== '/') {
         middlewares.use(baseMiddleware(server));
     }
     // open in editor support
@@ -64822,7 +63093,6 @@ async function startServer(server, inlinePort, isRestart = false) {
     const hostname = await resolveHostname(options.host);
     const protocol = options.https ? 'https' : 'http';
     const info = server.config.logger.info;
-    const devBase = server.config.base;
     const serverPort = await httpServerStart(httpServer, {
         port,
         strictPort: options.strictPort,
@@ -64845,7 +63115,7 @@ async function startServer(server, inlinePort, isRestart = false) {
         });
     }
     if (options.open && !isRestart) {
-        const path = typeof options.open === 'string' ? options.open : devBase;
+        const path = typeof options.open === 'string' ? options.open : server.config.base;
         openBrowser(path.startsWith('http')
             ? path
             : `${protocol}://${hostname.name}:${serverPort}${path}`, true, server.config.logger);
@@ -65666,27 +63936,40 @@ async function bundleConfigFile(fileName, isESM) {
             {
                 name: 'externalize-deps',
                 setup(build) {
+                    const options = {
+                        root: path$n.dirname(fileName),
+                        isBuild: true,
+                        isProduction: true,
+                        isRequire: !isESM,
+                        preferRelative: false,
+                        tryIndex: true,
+                        mainFields: [],
+                        browserField: false,
+                        conditions: [],
+                        overrideConditions: ['node'],
+                        dedupe: [],
+                        extensions: DEFAULT_EXTENSIONS$1,
+                        preserveSymlinks: false
+                    };
                     // externalize bare imports
                     build.onResolve({ filter: /^[^.].*/ }, async ({ path: id, importer, kind }) => {
-                        if (kind === 'entry-point' || path$n.isAbsolute(id)) {
+                        if (kind === 'entry-point' ||
+                            path$n.isAbsolute(id) ||
+                            isBuiltin(id)) {
                             return;
                         }
                         // partial deno support as `npm:` does not work with esbuild
                         if (id.startsWith('npm:')) {
                             return { external: true };
                         }
-                        const resolveWithRequire = kind === 'require-call' ||
-                            kind === 'require-resolve' ||
-                            (kind === 'import-statement' && !isESM);
-                        let resolved;
-                        if (resolveWithRequire) {
-                            const require = createRequire$1(importer);
-                            resolved = require.resolve(id);
+                        let idFsPath = tryNodeResolve(id, importer, options, false)?.id;
+                        if (idFsPath && (isESM || kind === 'dynamic-import')) {
+                            idFsPath = pathToFileURL$1(idFsPath).href;
                         }
-                        else {
-                            resolved = await resolve$4(id, pathToFileURL(importer).href);
-                        }
-                        return { path: resolved, external: true };
+                        return {
+                            path: idFsPath,
+                            external: true
+                        };
                     });
                 }
             },
@@ -65697,7 +63980,7 @@ async function bundleConfigFile(fileName, isESM) {
                         const contents = await fs$l.promises.readFile(args.path, 'utf8');
                         const injectValues = `const ${dirnameVarName} = ${JSON.stringify(path$n.dirname(args.path))};` +
                             `const ${filenameVarName} = ${JSON.stringify(args.path)};` +
-                            `const ${importMetaUrlVarName} = ${JSON.stringify(pathToFileURL(args.path).href)};`;
+                            `const ${importMetaUrlVarName} = ${JSON.stringify(pathToFileURL$1(args.path).href)};`;
                         return {
                             loader: args.path.endsWith('ts') ? 'ts' : 'js',
                             contents: injectValues + contents
@@ -65721,7 +64004,7 @@ async function loadConfigFromBundledFile(fileName, bundledCode, isESM) {
     if (isESM) {
         const fileBase = `${fileName}.timestamp-${Date.now()}`;
         const fileNameTmp = `${fileBase}.mjs`;
-        const fileUrl = `${pathToFileURL(fileBase)}.mjs`;
+        const fileUrl = `${pathToFileURL$1(fileBase)}.mjs`;
         fs$l.writeFileSync(fileNameTmp, bundledCode);
         try {
             return (await dynamicImport(fileUrl)).default;