vite 3.2.0-beta.2 → 3.2.0-beta.4

package/dist/node/chunks/{dep-0856a44a.js → dep-0e9c6c9f.js}

@@ -1,16 +1,19 @@
-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, pathToFileURL, URLSearchParams, parse as parse$k } from 'node:url';
+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 { performance } from 'node:perf_hooks';
-import { createRequire as createRequire$1, builtinModules } from 'node:module';
+import { builtinModules, createRequire as createRequire$1 } from 'node:module';
 import require$$0$3 from 'tty';
 import { transform as transform$2, build as build$3, formatMessages } from 'esbuild';
-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 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 * as require$$0$2 from 'fs';
-import require$$0__default, { existsSync, readFileSync, statSync as statSync$1, promises as promises$1, readdirSync } from 'fs';
+import require$$0__default, { existsSync, readFileSync, statSync as statSync$2, promises as promises$1, readdirSync } from 'fs';
 import require$$0$5 from 'events';
-import assert$1 from 'assert';
-import require$$0$6, { format as format$2, inspect } from 'util';
+import assert$2 from 'assert';
+import require$$0$6, { format as format$3, inspect as inspect$1 } from 'util';
 import require$$3$1 from 'net';
 import require$$0$9, { pathToFileURL as pathToFileURL$1 } from 'url';
 import require$$1$2 from 'http';
@@ -19,16 +22,14 @@ import require$$1 from 'os';
 import require$$2 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$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 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 require$$5 from 'crypto';
-import require$$0$a from 'buffer';
 import { Buffer as Buffer$1 } from 'node:buffer';
 import require$$0$8, { createRequire as createRequire$2 } from 'module';
 import require$$1$1 from 'worker_threads';
-import require$$0$b from 'zlib';
+import require$$0$a from 'zlib';
 import require$$1$3 from 'https';
 import require$$4 from 'tls';
 import { STATUS_CODES } from 'node:http';
@@ -214,6 +215,1761 @@ 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 = {};
@@ -2561,7 +4317,7 @@ function getMatcherString$1(id, resolutionBase) {
         return id;
     }
     // resolve('') is valid and will default to process.cwd()
-    const basePath = resolve$4(resolutionBase || '')
+    const basePath = resolve$5(resolutionBase || '')
         .split(sep)
         .join('/')
         // escape all possible (posix + win) path characters that might interfere with regex
@@ -4566,7 +6322,7 @@ function requireSync () {
 	var minimatch = minimatch_1;
 	requireGlob().Glob;
 	var path = require$$0$4;
-	var assert = assert$1;
+	var assert = assert$2;
 	var isAbsolute = pathIsAbsolute.exports;
 	var common = common$c;
 	var setopts = common.setopts;
@@ -5226,7 +6982,7 @@ function requireGlob () {
 	var inherits$1 = inherits.exports;
 	var EE = require$$0$5.EventEmitter;
 	var path = require$$0$4;
-	var assert = assert$1;
+	var assert = assert$2;
 	var isAbsolute = pathIsAbsolute.exports;
 	var globSync = requireSync();
 	var common = common$c;
@@ -7409,7 +9165,7 @@ function getPackageEntryPoint(dirPath) {
 
 function isDirectory(path) {
   try {
-    if (statSync$1(path).isDirectory()) return true;
+    if (statSync$2(path).isDirectory()) return true;
   } catch (ignored) {
     // Nothing to do here
   }
@@ -7426,11 +9182,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$4(path);
+      const resolvedPath = resolve$5(path);
       const requirePath = normalizePathSlashes(resolvedPath);
       if (isDirectory(resolvedPath)) {
         dirNames.add(resolvedPath);
-        const modulePath = resolve$4(join$1(resolvedPath, getPackageEntryPoint(path)));
+        const modulePath = resolve$5(join$1(resolvedPath, getPackageEntryPoint(path)));
         modifyMap(requirePath, modulePath);
         modifyMap(normalizePathSlashes(modulePath), modulePath);
       } else {
@@ -7727,12 +9483,12 @@ function resolveExtensions(importee, importer, extensions) {
   // not our problem
   if (importee[0] !== '.' || !importer) return undefined;
 
-  const resolved = resolve$4(dirname$1(importer), importee);
+  const resolved = resolve$5(dirname$1(importer), importee);
   const candidates = getCandidates(resolved, extensions);
 
   for (let i = 0; i < candidates.length; i += 1) {
     try {
-      const stats = statSync$1(candidates[i]);
+      const stats = statSync$2(candidates[i]);
       if (stats.isFile()) return { id: candidates[i] };
     } catch (err) {
       /* noop */
@@ -9240,7 +10996,7 @@ function commonjs(options = {}) {
 
   const dynamicRequireRoot =
     typeof options.dynamicRequireRoot === 'string'
-      ? resolve$4(options.dynamicRequireRoot)
+      ? resolve$5(options.dynamicRequireRoot)
       : process.cwd();
   const { commonDir, dynamicRequireModules } = getDynamicRequireModules(
     options.dynamicRequireTargets,
@@ -11530,7 +13286,7 @@ function getMatcherString(id, resolutionBase) {
         return normalizePath$4(id);
     }
     // resolve('') is valid and will default to process.cwd()
-    const basePath = normalizePath$4(resolve$4(resolutionBase || ''))
+    const basePath = normalizePath$4(resolve$5(resolutionBase || ''))
         // escape all possible (posix + win) path characters that might interfere with regex
         .replace(/[-^$*+?.()|[\]{}]/g, '\\$&');
     // Note that we use posix.join because:
@@ -11737,7 +13493,7 @@ try {
 catch { }
 const ssrExtensions = ['.js', '.cjs', '.json', '.node'];
 function resolveFrom(id, basedir, preserveSymlinks = false, ssr = false) {
-    return resolve$5.sync(id, {
+    return resolve$6.sync(id, {
         basedir,
         paths: [],
         extensions: ssr ? ssrExtensions : DEFAULT_EXTENSIONS$1,
@@ -11853,6 +13609,7 @@ function getPotentialTsSrcPaths(filePath) {
     return paths;
 }
 const importQueryRE = /(\?|&)import=?(?:&|$)/;
+const directRequestRE$1 = /(\?|&)direct=?(?:&|$)/;
 const internalPrefixes = [
     FS_PREFIX,
     VALID_ID_PREFIX,
@@ -11866,6 +13623,9 @@ const isInternalRequest = (url) => InternalPrefixRE.test(url);
 function removeImportQuery(url) {
     return url.replace(importQueryRE, '$1').replace(trailingSeparatorRE, '');
 }
+function removeDirectQuery(url) {
+    return url.replace(directRequestRE$1, '$1').replace(trailingSeparatorRE, '');
+}
 function injectQuery(url, queryToInject) {
     // encode percents for consistent behavior with pathToFileURL
     // see #2614 for details
@@ -13367,12 +15127,15 @@ async function transformWithEsbuild(code, filename, options, inMap) {
         // these fields would affect the compilation result
         // https://esbuild.github.io/content-types/#tsconfig-json
         const meaningfulFields = [
-            'target',
+            'alwaysStrict',
+            'importsNotUsedAsValues',
+            'jsx',
             'jsxFactory',
             'jsxFragmentFactory',
-            'useDefineForClassFields',
-            'importsNotUsedAsValues',
-            'preserveValueImports'
+            'jsxImportSource',
+            'preserveValueImports',
+            'target',
+            'useDefineForClassFields'
         ];
         const compilerOptionsForFile = {};
         if (loader === 'ts' || loader === 'tsx') {
@@ -13932,10 +15695,10 @@ function makeAbsolute(cwd, filepath) {
     return path$g.resolve(cwd, filepath);
 }
 path$h.makeAbsolute = makeAbsolute;
-function escape$2(pattern) {
+function escape$3(pattern) {
     return pattern.replace(UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
 }
-path$h.escape = escape$2;
+path$h.escape = escape$3;
 function removeLeadingDotSegment(entry) {
     // We do not use `startsWith` because this is 10x slower than current implementation for some cases.
     // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
@@ -33821,8 +35584,8 @@ async function urlToBuiltUrl(url, importer, config, pluginContext) {
     true);
 }
 
-/* es-module-lexer 1.0.3 */
-const A=1===new Uint8Array(new Uint16Array([1]).buffer)[0];function parse$b(E,g="@"){if(!C)return init.then((()=>parse$b(E)));const I=E.length+1,o=(C.__heap_base.value||C.__heap_base)+4*I-C.memory.buffer.byteLength;o>0&&C.memory.grow(Math.ceil(o/65536));const D=C.sa(I-1);if((A?B:Q)(E,new Uint16Array(C.memory.buffer,D,I)),!C.parse())throw Object.assign(new Error(`Parse error ${g}:${E.slice(0,C.e()).split("\n").length}:${C.e()-E.lastIndexOf("\n",C.e()-1)}`),{idx:C.e()});const J=[],K=[];for(;C.ri();){const A=C.is(),Q=C.ie(),B=C.ai(),g=C.id(),I=C.ss(),o=C.se();let D;C.ip()&&(D=w(E.slice(-1===g?A-1:A,-1===g?Q+1:Q))),J.push({n:D,s:A,e:Q,ss:I,se:o,d:g,a:B});}for(;C.re();){const A=C.es(),Q=C.ee(),B=C.els(),g=C.ele(),I=E.slice(A,Q),o=I[0],D=B<0?void 0:E.slice(B,g),J=D?D[0]:"";K.push({s:A,e:Q,ls:B,le:g,n:'"'===o||"'"===o?w(I):I,ln:'"'===J||"'"===J?w(D):D});}function w(A){try{return (0, eval)(A)}catch(A){}}return [J,K,!!C.f()]}function Q(A,Q){const B=A.length;let C=0;for(;C<B;){const B=A.charCodeAt(C);Q[C++]=(255&B)<<8|B>>>8;}}function B(A,Q){const B=A.length;let C=0;for(;C<B;)Q[C]=A.charCodeAt(C++);}let C;const init=WebAssembly.compile((E="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","undefined"!=typeof Buffer?Buffer.from(E,"base64"):Uint8Array.from(atob(E),(A=>A.charCodeAt(0))))).then(WebAssembly.instantiate).then((({exports:A})=>{C=A;}));var E;
+/* es-module-lexer 1.0.5 */
+const A=1===new Uint8Array(new Uint16Array([1]).buffer)[0];function parse$b(E,g="@"){if(!C)return init.then((()=>parse$b(E)));const I=E.length+1,o=(C.__heap_base.value||C.__heap_base)+4*I-C.memory.buffer.byteLength;o>0&&C.memory.grow(Math.ceil(o/65536));const K=C.sa(I-1);if((A?B:Q)(E,new Uint16Array(C.memory.buffer,K,I)),!C.parse())throw Object.assign(new Error(`Parse error ${g}:${E.slice(0,C.e()).split("\n").length}:${C.e()-E.lastIndexOf("\n",C.e()-1)}`),{idx:C.e()});const k=[],D=[];for(;C.ri();){const A=C.is(),Q=C.ie(),B=C.ai(),g=C.id(),I=C.ss(),o=C.se();let K;C.ip()&&(K=w(E.slice(-1===g?A-1:A,-1===g?Q+1:Q))),k.push({n:K,s:A,e:Q,ss:I,se:o,d:g,a:B});}for(;C.re();){const A=C.es(),Q=C.ee(),B=C.els(),g=C.ele(),I=E.slice(A,Q),o=I[0],K=B<0?void 0:E.slice(B,g),k=K?K[0]:"";D.push({s:A,e:Q,ls:B,le:g,n:'"'===o||"'"===o?w(I):I,ln:'"'===k||"'"===k?w(K):K});}function w(A){try{return (0, eval)(A)}catch(A){}}return [k,D,!!C.f()]}function Q(A,Q){const B=A.length;let C=0;for(;C<B;){const B=A.charCodeAt(C);Q[C++]=(255&B)<<8|B>>>8;}}function B(A,Q){const B=A.length;let C=0;for(;C<B;)Q[C]=A.charCodeAt(C++);}let C;const init=WebAssembly.compile((E="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","undefined"!=typeof Buffer?Buffer.from(E,"base64"):Uint8Array.from(atob(E),(A=>A.charCodeAt(0))))).then(WebAssembly.instantiate).then((({exports:A})=>{C=A;}));var E;
 
 /**
  * @param {object} exports
@@ -34011,7 +35774,7 @@ createError(
   (pkgPath, key, target, isImport = false, base = void 0) => {
     const relError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
     if (key === ".") {
-      assert$1(isImport === false);
+      assert$2(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(
@@ -34057,7 +35820,7 @@ createError(
 createError(
   "ERR_INVALID_ARG_VALUE",
   (name, value, reason = "is invalid") => {
-    let inspected = inspect(value);
+    let inspected = inspect$1(value);
     if (inspected.length > 128) {
       inspected = `${inspected.slice(0, 128)}...`;
     }
@@ -34158,14 +35921,14 @@ const captureLargerStackTrace = hideStackFrames(
 function getMessage(key, args, self) {
   const message = messages.get(key);
   if (typeof message === "function") {
-    assert$1(
+    assert$2(
       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$1(
+  assert$2(
     expectedLength === args.length,
     `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`
   );
@@ -34173,7 +35936,7 @@ function getMessage(key, args, self) {
     return message;
   }
   args.unshift(message);
-  return Reflect.apply(format$2, null, args);
+  return Reflect.apply(format$3, null, args);
 }
 Object.freeze(["node", "import"]);
 pathToFileURL$1(process.cwd());
@@ -37040,78 +38803,9 @@ function stattag (stat) {
 
 var convertSourceMap = {};
 
-var safeBuffer = {exports: {}};
-
-/* eslint-disable node/no-deprecated-api */
-
-(function (module, exports) {
-	var buffer = require$$0$a;
-	var Buffer = buffer.Buffer;
-
-	// alternative to using Object.keys for old browsers
-	function copyProps (src, dst) {
-	  for (var key in src) {
-	    dst[key] = src[key];
-	  }
-	}
-	if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
-	  module.exports = buffer;
-	} else {
-	  // Copy properties from require('buffer')
-	  copyProps(buffer, exports);
-	  exports.Buffer = SafeBuffer;
-	}
-
-	function SafeBuffer (arg, encodingOrOffset, length) {
-	  return Buffer(arg, encodingOrOffset, length)
-	}
-
-	// Copy static methods from Buffer
-	copyProps(Buffer, SafeBuffer);
-
-	SafeBuffer.from = function (arg, encodingOrOffset, length) {
-	  if (typeof arg === 'number') {
-	    throw new TypeError('Argument must not be a number')
-	  }
-	  return Buffer(arg, encodingOrOffset, length)
-	};
-
-	SafeBuffer.alloc = function (size, fill, encoding) {
-	  if (typeof size !== 'number') {
-	    throw new TypeError('Argument must be a number')
-	  }
-	  var buf = Buffer(size);
-	  if (fill !== undefined) {
-	    if (typeof encoding === 'string') {
-	      buf.fill(fill, encoding);
-	    } else {
-	      buf.fill(fill);
-	    }
-	  } else {
-	    buf.fill(0);
-	  }
-	  return buf
-	};
-
-	SafeBuffer.allocUnsafe = function (size) {
-	  if (typeof size !== 'number') {
-	    throw new TypeError('Argument must be a number')
-	  }
-	  return Buffer(size)
-	};
-
-	SafeBuffer.allocUnsafeSlow = function (size) {
-	  if (typeof size !== 'number') {
-	    throw new TypeError('Argument must be a number')
-	  }
-	  return buffer.SlowBuffer(size)
-	};
-} (safeBuffer, safeBuffer.exports));
-
 (function (exports) {
 	var fs = require$$0__default;
 	var path = require$$0$4;
-	var SafeBuffer = safeBuffer.exports;
 
 	Object.defineProperty(exports, 'commentRegex', {
 	  get: function getCommentRegex () {
@@ -37126,9 +38820,30 @@ var safeBuffer = {exports: {}};
 	  }
 	});
 
+	var decodeBase64;
+	if (typeof Buffer !== 'undefined') {
+	  if (typeof Buffer.from === 'function') {
+	    decodeBase64 = decodeBase64WithBufferFrom;
+	  } else {
+	    decodeBase64 = decodeBase64WithNewBuffer;
+	  }
+	} else {
+	  decodeBase64 = decodeBase64WithAtob;
+	}
+
+	function decodeBase64WithBufferFrom(base64) {
+	  return Buffer.from(base64, 'base64').toString();
+	}
 
-	function decodeBase64(base64) {
-	  return (SafeBuffer.Buffer.from(base64, 'base64') || "").toString();
+	function decodeBase64WithNewBuffer(base64) {
+	  if (typeof value === 'number') {
+	    throw new TypeError('The value to decode must not be of type number.');
+	  }
+	  return new Buffer(base64, 'base64').toString();
+	}
+
+	function decodeBase64WithAtob(base64) {
+	  return decodeURIComponent(escape(atob(base64)));
 	}
 
 	function stripComment(sm) {
@@ -37166,10 +38881,33 @@ var safeBuffer = {exports: {}};
 	  return JSON.stringify(this.sourcemap, null, space);
 	};
 
-	Converter.prototype.toBase64 = function () {
+	if (typeof Buffer !== 'undefined') {
+	  if (typeof Buffer.from === 'function') {
+	    Converter.prototype.toBase64 = encodeBase64WithBufferFrom;
+	  } else {
+	    Converter.prototype.toBase64 = encodeBase64WithNewBuffer;
+	  }
+	} else {
+	  Converter.prototype.toBase64 = encodeBase64WithBtoa;
+	}
+
+	function encodeBase64WithBufferFrom() {
 	  var json = this.toJSON();
-	  return (SafeBuffer.Buffer.from(json, 'utf8') || "").toString('base64');
-	};
+	  return Buffer.from(json, 'utf8').toString('base64');
+	}
+
+	function encodeBase64WithNewBuffer() {
+	  var json = this.toJSON();
+	  if (typeof json === 'number') {
+	    throw new TypeError('The json to encode must not be of type number.');
+	  }
+	  return new Buffer(json, 'utf8').toString('base64');
+	}
+
+	function encodeBase64WithBtoa() {
+	  var json = this.toJSON();
+	  return btoa(unescape(encodeURIComponent(json)));
+	}
 
 	Converter.prototype.toComment = function (options) {
 	  var base64 = this.toBase64();
@@ -37247,12 +38985,12 @@ var safeBuffer = {exports: {}};
 } (convertSourceMap));
 
 function totalist(dir, callback, pre='') {
-	dir = resolve$4('.', dir);
+	dir = resolve$5('.', dir);
 	let arr = readdirSync(dir);
 	let i=0, abs, stats;
 	for (; i < arr.length; i++) {
 		abs = join$1(dir, arr[i]);
-		stats = statSync$1(abs);
+		stats = statSync$2(abs);
 		stats.isDirectory()
 			? totalist(abs, callback, join$1(pre, arr[i]))
 			: callback(join$1(pre, arr[i]), abs, stats);
@@ -37406,7 +39144,7 @@ function toHeaders(name, stats, isEtag) {
 }
 
 function sirv (dir, opts={}) {
-	dir = resolve$4(dir || '.');
+	dir = resolve$5(dir || '.');
 
 	let isNotFound = opts.onNoMatch || is404;
 	let setHeaders = opts.setHeaders || noop$2;
@@ -39458,7 +41196,7 @@ const lexStates = {
         switch (c) {
         case '\\':
             read();
-            buffer += escape$1();
+            buffer += escape$2();
             return
 
         case '"':
@@ -39613,7 +41351,7 @@ function literal (s) {
     }
 }
 
-function escape$1 () {
+function escape$2 () {
     const c = peek();
     switch (c) {
     case 'b':
@@ -40931,8 +42669,9 @@ function prepareError(err) {
 function buildErrorMessage(err, args = [], includeStack = true) {
     if (err.plugin)
         args.push(`  Plugin: ${picocolors.exports.magenta(err.plugin)}`);
+    const loc = err.loc ? `:${err.loc.line}:${err.loc.column}` : '';
     if (err.id)
-        args.push(`  File: ${picocolors.exports.cyan(err.id)}`);
+        args.push(`  File: ${picocolors.exports.cyan(err.id)}${loc}`);
     if (err.frame)
         args.push(picocolors.exports.yellow(pad$1(err.frame)));
     if (includeStack && err.stack)
@@ -41016,7 +42755,7 @@ async function createPluginContainer(config, moduleGraph, watcher) {
     // TODO: use import()
     const _require = createRequire$1(import.meta.url);
     // get rollup version
-    const rollupPkgPath = resolve$6(_require.resolve('rollup'), '../../package.json');
+    const rollupPkgPath = resolve$7(_require.resolve('rollup'), '../../package.json');
     const minimalContext = {
         meta: {
             rollupVersion: JSON.parse(fs$l.readFileSync(rollupPkgPath, 'utf-8'))
@@ -43785,6 +45524,9 @@ function handleParseError(parserError, html, filePath) {
             // Accept duplicate attributes #9566
             // The first attribute is used, browsers silently ignore duplicates
             return;
+        case 'non-void-html-element-start-tag-with-trailing-solidus':
+            // Allow self closing on non-void elements #10439
+            return;
     }
     const parseError = {
         loc: filePath,
@@ -44566,6 +46308,7 @@ function cssPostPlugin(config) {
                 SPECIAL_QUERY_RE.test(id)) {
                 return;
             }
+            css = stripBomTag(css);
             const inlined = inlineRE.test(id);
             const modules = cssModulesCache.get(config).get(id);
             // #6984, #7552
@@ -44727,12 +46470,11 @@ function cssPostPlugin(config) {
                 }
                 else if (!config.build.ssr) {
                     // legacy build and inline css
-                    // the legacy build should avoid inserting entry CSS modules here, they
-                    // will be collected into `chunk.viteMetadata.importedCss` and injected
-                    // later by the `'vite:build-html'` plugin into the `index.html`
-                    if (chunk.isEntry && !config.build.lib) {
-                        return null;
-                    }
+                    // Entry chunk CSS will be collected into `chunk.viteMetadata.importedCss`
+                    // and injected later by the `'vite:build-html'` plugin into the `index.html`
+                    // so it will be duplicated. (https://github.com/vitejs/vite/issues/2062#issuecomment-782388010)
+                    // But because entry chunk can be imported by dynamic import,
+                    // we shouldn't remove the inlined CSS. (#10285)
                     chunkCSS = await finalizeCss(chunkCSS, true, config);
                     let cssString = JSON.stringify(chunkCSS);
                     cssString =
@@ -44924,7 +46666,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
     }
     const postcssPlugins = postcssConfig && postcssConfig.plugins ? postcssConfig.plugins.slice() : [];
     if (needInlineImport) {
-        postcssPlugins.unshift((await import('./dep-39e6741e.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-9deb2354.js').then(function (n) { return n.i; })).default({
             async resolve(id, basedir) {
                 const publicFile = checkPublicFile(id, config);
                 if (publicFile) {
@@ -44946,7 +46688,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         logger: config.logger
     }));
     if (isModule) {
-        postcssPlugins.unshift((await import('./dep-0726141c.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-06c4efef.js').then(function (n) { return n.i; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -44973,13 +46715,14 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
     }
     let postcssResult;
     try {
+        const source = removeDirectQuery(id);
         // postcss is an unbundled dep and should be lazy imported
         postcssResult = await (await import('postcss'))
             .default(postcssPlugins)
             .process(code, {
             ...postcssOptions,
-            to: id,
-            from: id,
+            to: source,
+            from: source,
             ...(devSourcemap
                 ? {
                     map: {
@@ -53799,7 +55542,7 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
         preserveSymlinks,
         isBuild: true,
         isProduction,
-        isRequire: false,
+        isRequire: true,
         root
     };
     // Since dynamic imports can happen in parallel, we need to
@@ -54159,7 +55902,7 @@ class Limiter$1 {
 
 var limiter = Limiter$1;
 
-const zlib = require$$0$b;
+const zlib = require$$0$a;
 
 const bufferUtil = bufferUtil$1.exports;
 const Limiter = limiter;
@@ -59288,7 +61031,7 @@ var URL$1 = url.URL;
 var http$1 = require$$1$2;
 var https$1 = require$$1$3;
 var Writable = require$$0$7.Writable;
-var assert = assert$1;
+var assert = assert$2;
 var debug$2 = debug_1;
 
 // Create handlers that pass events from native requests
@@ -60523,7 +62266,7 @@ function proxyMiddleware(httpServer, options, config) {
             // When it is ws proxy, res is net.Socket
             const res = originalRes;
             if ('req' in res) {
-                config.logger.error(`${picocolors.exports.red(`http proxy error:`)}\n${err.stack}`, {
+                config.logger.error(`${picocolors.exports.red(`http proxy error at ${originalRes.req.url}:`)}\n${err.stack}`, {
                     timestamp: true,
                     error: err
                 });
@@ -62193,7 +63936,7 @@ var readShebang_1 = readShebang$1;
 
 const path$1 = require$$0$4;
 const resolveCommand = resolveCommand_1;
-const escape = _escape;
+const escape$1 = _escape;
 const readShebang = readShebang_1;
 
 const isWin$1 = process.platform === 'win32';
@@ -62240,8 +63983,8 @@ function parseNonShell(parsed) {
         parsed.command = path$1.normalize(parsed.command);
 
         // Escape command & arguments
-        parsed.command = escape.command(parsed.command);
-        parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+        parsed.command = escape$1.command(parsed.command);
+        parsed.args = parsed.args.map((arg) => escape$1.argument(arg, needsDoubleEscapeMetaChars));
 
         const shellCommand = [parsed.command].concat(parsed.args).join(' ');
 
@@ -62423,18 +64166,31 @@ function startBrowserProcess(browser, url) {
     // existing tab when possible instead of creating a new one.
     const shouldTryOpenChromeWithAppleScript = process.platform === 'darwin' && (browser === '' || browser === OSX_CHROME);
     if (shouldTryOpenChromeWithAppleScript) {
-        try {
-            // Try our best to reuse existing tab
-            // on OS X Google Chrome with AppleScript
-            execSync('ps cax | grep "Google Chrome"');
-            execSync('osascript openChrome.applescript "' + encodeURI(url) + '"', {
-                cwd: join$2(VITE_PACKAGE_DIR, 'bin'),
-                stdio: 'ignore'
-            });
-            return true;
-        }
-        catch (err) {
-            // Ignore errors
+        // Will use the first open browser found from list
+        const supportedChromiumBrowsers = [
+            'Google Chrome Canary',
+            'Google Chrome Dev',
+            'Google Chrome Beta',
+            'Google Chrome',
+            'Microsoft Edge',
+            'Brave Browser',
+            'Vivaldi',
+            'Chromium'
+        ];
+        for (const chromiumBrowser of supportedChromiumBrowsers) {
+            try {
+                // Try our best to reuse existing tab
+                // on OS X Google Chrome with AppleScript
+                execSync(`ps cax | grep "${chromiumBrowser}"`);
+                execSync(`osascript openChrome.applescript "${encodeURI(url)}" "${chromiumBrowser}"`, {
+                    cwd: join$2(VITE_PACKAGE_DIR, 'bin'),
+                    stdio: 'ignore'
+                });
+                return true;
+            }
+            catch (err) {
+                // Ignore errors
+            }
         }
     }
     // Another special case: on OS X, check if BROWSER has been set to "open".
@@ -63480,10 +65236,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
     // user config may provide an alternative mode. But --mode has a higher priority
     mode = inlineConfig.mode || config.mode || mode;
     configEnv.mode = mode;
-    // Some plugins that aren't intended to work in the bundling of workers (doing post-processing at build time for example).
-    // And Plugins may also have cached that could be corrupted by being used in these extra rollup calls.
-    // So we need to separate the worker plugin from the plugin that vite needs to run.
-    const rawWorkerUserPlugins = (await asyncFlatten(config.worker?.plugins || [])).filter((p) => {
+    const filterPlugin = (p) => {
         if (!p) {
             return false;
         }
@@ -63496,22 +65249,13 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
         else {
             return p.apply === command;
         }
-    });
+    };
+    // Some plugins that aren't intended to work in the bundling of workers (doing post-processing at build time for example).
+    // And Plugins may also have cached that could be corrupted by being used in these extra rollup calls.
+    // So we need to separate the worker plugin from the plugin that vite needs to run.
+    const rawWorkerUserPlugins = (await asyncFlatten(config.worker?.plugins || [])).filter(filterPlugin);
     // resolve plugins
-    const rawUserPlugins = (await asyncFlatten(config.plugins || [])).filter((p) => {
-        if (!p) {
-            return false;
-        }
-        else if (!p.apply) {
-            return true;
-        }
-        else if (typeof p.apply === 'function') {
-            return p.apply({ ...config, mode }, configEnv);
-        }
-        else {
-            return p.apply === command;
-        }
-    });
+    const rawUserPlugins = (await asyncFlatten(config.plugins || [])).filter(filterPlugin);
     const [prePlugins, normalPlugins, postPlugins] = sortUserPlugins(rawUserPlugins);
     // run config hooks
     const userPlugins = [...prePlugins, ...normalPlugins, ...postPlugins];
@@ -63885,6 +65629,7 @@ async function bundleConfigFile(fileName, isESM) {
         platform: 'node',
         bundle: true,
         format: isESM ? 'esm' : 'cjs',
+        mainFields: ['main'],
         sourcemap: 'inline',
         metafile: true,
         define: {
@@ -63896,36 +65641,27 @@ 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: [],
-                        dedupe: [],
-                        extensions: DEFAULT_EXTENSIONS$1,
-                        preserveSymlinks: false
-                    };
-                    build.onResolve({ filter: /.*/ }, ({ path: id, importer, kind }) => {
-                        // externalize bare imports
-                        if (id[0] !== '.' && !path$n.isAbsolute(id) && !isBuiltin(id)) {
-                            // partial deno support as `npm:` does not work in `tryNodeResolve`
-                            if (id.startsWith('npm:')) {
-                                return { external: true };
-                            }
-                            let idFsPath = tryNodeResolve(id, importer, options, false)?.id;
-                            if (idFsPath && (isESM || kind === 'dynamic-import')) {
-                                idFsPath = pathToFileURL(idFsPath).href;
-                            }
-                            return {
-                                path: idFsPath,
-                                external: true
-                            };
+                    // externalize bare imports
+                    build.onResolve({ filter: /^[^.].*/ }, async ({ path: id, importer, kind }) => {
+                        if (kind === 'entry-point' || path$n.isAbsolute(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);
+                        }
+                        else {
+                            resolved = await resolve$4(id, pathToFileURL(importer).href);
                         }
+                        return { path: resolved, external: true };
                     });
                 }
             },