vite 3.2.0-beta.1 → 3.2.0-beta.3

package/dist/node/chunks/{dep-34b5a6bf.js → dep-5fd8eb18.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$3, 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$2, 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
@@ -4331,7 +6087,7 @@ function ownProp (obj, field) {
 var fs$i = require$$0__default;
 var path$i = require$$0$4;
 var minimatch = minimatch_1;
-var isAbsolute$1 = pathIsAbsolute.exports;
+var isAbsolute = pathIsAbsolute.exports;
 var Minimatch = minimatch.Minimatch;
 
 function alphasort (a, b) {
@@ -4419,7 +6175,7 @@ function setopts (self, pattern, options) {
 
   // TODO: is an absolute `cwd` supposed to be resolved against `root`?
   // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test')
-  self.cwdAbs = isAbsolute$1(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
+  self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
   if (process.platform === "win32")
     self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
   self.nomount = !!options.nomount;
@@ -4518,7 +6274,7 @@ function makeAbs (self, f) {
   var abs = f;
   if (f.charAt(0) === '/') {
     abs = path$i.join(self.root, f);
-  } else if (isAbsolute$1(f) || f === '') {
+  } else if (isAbsolute(f) || f === '') {
     abs = f;
   } else if (self.changedCwd) {
     abs = path$i.resolve(self.cwd, f);
@@ -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,
@@ -11526,11 +13282,11 @@ const normalizePath$4 = function normalizePath(filename) {
 };
 
 function getMatcherString(id, resolutionBase) {
-    if (resolutionBase === false || isAbsolute$2(id) || id.startsWith('*')) {
+    if (resolutionBase === false || isAbsolute$1(id) || id.startsWith('*')) {
         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="AGFzbQEAAAABKghgAX8Bf2AEf39/fwBgAAF/YAAAYAF/AGADf39/AX9gAn9/AX9gAn9/AAMtLAABAQICAgICAgICAgICAgICAgIAAwMDBAQAAAADAAAAAAMDBQYAAAcABgIFBAUBcAEBAQUDAQABBg8CfwFBsPIAC38AQbDyAAsHcBMGbWVtb3J5AgACc2EAAAFlAAMCaXMABAJpZQAFAnNzAAYCc2UABwJhaQAIAmlkAAkCaXAACgJlcwALAmVlAAwDZWxzAA0DZWxlAA4CcmkADwJyZQAQAWYAEQVwYXJzZQASC19faGVhcF9iYXNlAwEK6TosaAEBf0EAIAA2AvgJQQAoAtQJIgEgAEEBdGoiAEEAOwEAQQAgAEECaiIANgL8CUEAIAA2AoAKQQBBADYC2AlBAEEANgLoCUEAQQA2AuAJQQBBADYC3AlBAEEANgLwCUEAQQA2AuQJIAELnwEBA39BACgC6AkhBEEAQQAoAoAKIgU2AugJQQAgBDYC7AlBACAFQSBqNgKACiAEQRxqQdgJIAQbIAU2AgBBACgCzAkhBEEAKALICSEGIAUgATYCACAFIAA2AgggBSACIAJBAmpBACAGIANGGyAEIANGGzYCDCAFIAM2AhQgBUEANgIQIAUgAjYCBCAFQQA2AhwgBUEAKALICSADRjoAGAtWAQF/QQAoAvAJIgRBEGpB3AkgBBtBACgCgAoiBDYCAEEAIAQ2AvAJQQAgBEEUajYCgAogBEEANgIQIAQgAzYCDCAEIAI2AgggBCABNgIEIAQgADYCAAsIAEEAKAKECgsVAEEAKALgCSgCAEEAKALUCWtBAXULHgEBf0EAKALgCSgCBCIAQQAoAtQJa0EBdUF/IAAbCxUAQQAoAuAJKAIIQQAoAtQJa0EBdQseAQF/QQAoAuAJKAIMIgBBACgC1AlrQQF1QX8gABsLHgEBf0EAKALgCSgCECIAQQAoAtQJa0EBdUF/IAAbCzsBAX8CQEEAKALgCSgCFCIAQQAoAsgJRw0AQX8PCwJAIABBACgCzAlHDQBBfg8LIABBACgC1AlrQQF1CwsAQQAoAuAJLQAYCxUAQQAoAuQJKAIAQQAoAtQJa0EBdQsVAEEAKALkCSgCBEEAKALUCWtBAXULHgEBf0EAKALkCSgCCCIAQQAoAtQJa0EBdUF/IAAbCx4BAX9BACgC5AkoAgwiAEEAKALUCWtBAXVBfyAAGwslAQF/QQBBACgC4AkiAEEcakHYCSAAGygCACIANgLgCSAAQQBHCyUBAX9BAEEAKALkCSIAQRBqQdwJIAAbKAIAIgA2AuQJIABBAEcLCABBAC0AiAoL5gwBBn8jAEGA0ABrIgAkAEEAQQE6AIgKQQBBACgC0Ak2ApAKQQBBACgC1AlBfmoiATYCpApBACABQQAoAvgJQQF0aiICNgKoCkEAQQA7AYoKQQBBADsBjApBAEEAOgCUCkEAQQA2AoQKQQBBADoA9AlBACAAQYAQajYCmApBACAANgKcCkEAQQA6AKAKAkACQAJAAkADQEEAIAFBAmoiAzYCpAogASACTw0BAkAgAy8BACICQXdqQQVJDQACQAJAAkACQAJAIAJBm39qDgUBCAgIAgALIAJBIEYNBCACQS9GDQMgAkE7Rg0CDAcLQQAvAYwKDQEgAxATRQ0BIAFBBGpBgghBChArDQEQFEEALQCICg0BQQBBACgCpAoiATYCkAoMBwsgAxATRQ0AIAFBBGpBjAhBChArDQAQFQtBAEEAKAKkCjYCkAoMAQsCQCABLwEEIgNBKkYNACADQS9HDQQQFgwBC0EBEBcLQQAoAqgKIQJBACgCpAohAQwACwtBACECIAMhAUEALQD0CQ0CDAELQQAgATYCpApBAEEAOgCICgsDQEEAIAFBAmoiAzYCpAoCQAJAAkACQAJAAkACQAJAAkAgAUEAKAKoCk8NACADLwEAIgJBd2pBBUkNCAJAAkACQAJAAkACQAJAAkACQAJAIAJBYGoOChIRBhEREREFAQIACwJAAkACQAJAIAJBoH9qDgoLFBQDFAEUFBQCAAsgAkGFf2oOAwUTBgkLQQAvAYwKDRIgAxATRQ0SIAFBBGpBgghBChArDRIQFAwSCyADEBNFDREgAUEEakGMCEEKECsNERAVDBELIAMQE0UNECABKQAEQuyAhIOwjsA5Ug0QIAEvAQwiA0F3aiIBQRdLDQ5BASABdEGfgIAEcUUNDgwPC0EAQQAvAYwKIgFBAWo7AYwKQQAoApgKIAFBA3RqIgFBATYCACABQQAoApAKNgIEDA8LQQAvAYwKIgJFDQtBACACQX9qIgQ7AYwKQQAvAYoKIgJFDQ4gAkECdEEAKAKcCmpBfGooAgAiBSgCFEEAKAKYCiAEQf//A3FBA3RqKAIERw0OAkAgBSgCBA0AIAUgAzYCBAtBACACQX9qOwGKCiAFIAFBBGo2AgwMDgsCQEEAKAKQCiIBLwEAQSlHDQBBACgC6AkiA0UNACADKAIEIAFHDQBBAEEAKALsCSIDNgLoCQJAIANFDQAgA0EANgIcDAELQQBBADYC2AkLQQBBAC8BjAoiA0EBajsBjApBACgCmAogA0EDdGoiA0EGQQJBAC0AoAobNgIAIAMgATYCBEEAQQA6AKAKDA0LQQAvAYwKIgFFDQlBACABQX9qIgE7AYwKQQAoApgKIAFB//8DcUEDdGooAgBBBEYNBAwMC0EnEBgMCwtBIhAYDAoLIAJBL0cNCQJAAkAgAS8BBCIBQSpGDQAgAUEvRw0BEBYMDAtBARAXDAsLAkACQEEAKAKQCiIBLwEAIgMQGUUNAAJAAkAgA0FVag4EAAgBAwgLIAFBfmovAQBBK0YNBgwHCyABQX5qLwEAQS1GDQUMBgsCQCADQf0ARg0AIANBKUcNBUEAKAKYCkEALwGMCkEDdGooAgQQGkUNBQwGC0EAKAKYCkEALwGMCkEDdGoiAigCBBAbDQUgAigCAEEGRg0FDAQLIAFBfmovAQBBUGpB//8DcUEKSQ0DDAQLQQAoApgKQQAvAYwKIgFBA3QiA2pBACgCkAo2AgRBACABQQFqOwGMCkEAKAKYCiADakEDNgIACxAcDAcLQQAtAPQJQQAvAYoKQQAvAYwKcnJFIQIMCQsgARAdDQAgA0UNACADQS9GQQAtAJQKQQBHcQ0AIAFBfmohAUEAKALUCSECAkADQCABQQJqIgQgAk0NAUEAIAE2ApAKIAEvAQAhAyABQX5qIgQhASADEB5FDQALIARBAmohBAtBASEFIANB//8DcRAfRQ0BIARBfmohAQJAA0AgAUECaiIDIAJNDQFBACABNgKQCiABLwEAIQMgAUF+aiIEIQEgAxAfDQALIARBAmohAwsgAxAgRQ0BECFBAEEAOgCUCgwFCxAhQQAhBQtBACAFOgCUCgwDCxAiQQAhAgwFCyADQaABRw0BC0EAQQE6AKAKC0EAQQAoAqQKNgKQCgtBACgCpAohAQwACwsgAEGA0ABqJAAgAgsdAAJAQQAoAtQJIABHDQBBAQ8LIABBfmovAQAQHgv8CQEGf0EAQQAoAqQKIgBBDGoiATYCpApBACgC8AkhAkEBECYhAwJAAkACQAJAAkACQAJAQQAoAqQKIgQgAUcNACADECVFDQELAkACQAJAAkAgA0EqRg0AIANB+wBHDQFBACAEQQJqNgKkCkEBECYhBEEAKAKkCiEBA0ACQAJAIARB//8DcSIDQSJGDQAgA0EnRg0AIAMQKBpBACgCpAohAwwBCyADEBhBAEEAKAKkCkECaiIDNgKkCgtBARAmGgJAIAEgAxApIgRBLEcNAEEAQQAoAqQKQQJqNgKkCkEBECYhBAtBACgCpAohAyAEQf0ARg0DIAMgAUYNCiADIQEgA0EAKAKoCk0NAAwKCwtBACAEQQJqNgKkCkEBECYaQQAoAqQKIgMgAxApGgwCC0EAQQA6AIgKAkACQAJAAkACQAJAIANBn39qDgwCCAQBCAMICAgICAUACyADQfYARg0EDAcLQQAgBEEOaiIDNgKkCkHhACEBAkBBARAmIgJB4QBHDQBBACgCpAoiAhATRQ0LIAIpAAJC84Dkg+CNwDFSDQsgAi8BChAfRQ0LQQAgAkEKajYCpApBABAmIQILQeYAIQEgAkHmAEcNCUEAKAKkCiICEBNFDQogAkECakGkCEEOECsNCiACLwEQIgVBd2oiAEEXSw0HQQEgAHRBn4CABHFFDQcMCAtBACAEQQpqNgKkCkEBECYaQQAoAqQKIQQLQQAgBEEQajYCpAoCQEEBECYiBEEqRw0AQQBBACgCpApBAmo2AqQKQQEQJiEEC0EAKAKkCiEDIAQQKBogA0EAKAKkCiIEIAMgBBACQQBBACgCpApBfmo2AqQKDwsCQCAEKQACQuyAhIOwjsA5Ug0AIAQvAQoQHkUNAEEAIARBCmo2AqQKQQEQJiEEQQAoAqQKIQMgBBAoGiADQQAoAqQKIgQgAyAEEAJBAEEAKAKkCkF+ajYCpAoPC0EAIARBBGoiBDYCpAoLQQAgBEEEaiIDNgKkCkEAQQA6AIgKAkADQEEAIANBAmo2AqQKQQEQJiEEQQAoAqQKIQMgBBAoQSByQfsARg0BQQAoAqQKIgQgA0YNBCADIAQgAyAEEAJBARAmQSxHDQFBACgCpAohAwwACwtBAEEAKAKkCkF+ajYCpAoPC0EAIANBAmo2AqQKC0EBECYhBEEAKAKkCiEDAkAgBEHmAEcNACADQQJqQZ4IQQYQKw0AQQAgA0EIajYCpAogAEEBECYQJyACQRBqQdwJIAIbIQMDQCADKAIAIgNFDQIgA0IANwIIIANBEGohAwwACwtBACADQX5qNgKkCgsPCwJAIAVBWGoOAwEDAQALIAVBoAFHDQILQQAgAkEQajYCpAoCQEEBECYiAkEqRw0AQQBBACgCpApBAmo2AqQKQQEQJiECCyACQShHDQAgBCADQQBBABACQQAgAzYCpAoPCyACIQEgAkHjAEcNAAJAQQAoAqQKIgIQE0UNACACKQACQuyAhIOwjsA5Ug0AAkACQCACLwEKIgBBd2oiAUEXSw0AQQEgAXRBn4CABHENAQsgAEGgAUYNAEHjACEBIABB+wBHDQILQQAgAkEKajYCpApBARAmIgFB+wBHDQEgBCADQQBBABACQQAgAzYCpAoPC0HjACEBC0EAKAKkCiECIAEQKBogBCADIAJBACgCpAoQAkEAIAM2AqQKDwsQIgu+BgEEf0EAQQAoAqQKIgBBDGoiATYCpAoCQAJAAkACQAJAAkACQAJAAkACQEEBECYiAkFZag4IBAIBBAEBAQMACyACQSJGDQMgAkH7AEYNBAtBACgCpAogAUcNAkEAIABBCmo2AqQKDwtBACgCmApBAC8BjAoiAkEDdGoiAUEAKAKkCjYCBEEAIAJBAWo7AYwKIAFBBTYCAEEAKAKQCi8BAEEuRg0DQQBBACgCpAoiAUECajYCpApBARAmIQIgAEEAKAKkCkEAIAEQAUEAQQAvAYoKIgFBAWo7AYoKQQAoApwKIAFBAnRqQQAoAugJNgIAAkAgAkEiRg0AIAJBJ0YNAEEAQQAoAqQKQX5qNgKkCg8LIAIQGEEAQQAoAqQKQQJqIgI2AqQKAkACQAJAQQEQJkFXag4EAQICAAILQQBBACgCpApBAmo2AqQKQQEQJhpBACgC6AkiASACNgIEIAFBAToAGCABQQAoAqQKIgI2AhBBACACQX5qNgKkCg8LQQAoAugJIgEgAjYCBCABQQE6ABhBAEEALwGMCkF/ajsBjAogAUEAKAKkCkECajYCDEEAQQAvAYoKQX9qOwGKCg8LQQBBACgCpApBfmo2AqQKDwtBAEEAKAKkCkECajYCpApBARAmQe0ARw0CQQAoAqQKIgJBAmpBlghBBhArDQJBACgCkAovAQBBLkYNAiAAIAAgAkEIakEAKALMCRABDwtBAC8BjAoNAkEAKAKkCiECQQAoAqgKIQMDQCACIANPDQUCQAJAIAIvAQAiAUEnRg0AIAFBIkcNAQsgACABECcPC0EAIAJBAmoiAjYCpAoMAAsLQQAoAqQKIQJBAC8BjAoNAgJAA0ACQAJAAkAgAkEAKAKoCk8NAEEBECYiAkEiRg0BIAJBJ0YNASACQf0ARw0CQQBBACgCpApBAmo2AqQKC0EBECYaQQAoAqQKIgIpAABC5oDIg/CNwDZSDQdBACACQQhqNgKkCkEBECYiAkEiRg0DIAJBJ0YNAwwHCyACEBgLQQBBACgCpApBAmoiAjYCpAoMAAsLIAAgAhAnCw8LQQBBACgCpApBfmo2AqQKDwtBACACQX5qNgKkCg8LECILRwEDf0EAKAKkCkECaiEAQQAoAqgKIQECQANAIAAiAkF+aiABTw0BIAJBAmohACACLwEAQXZqDgQBAAABAAsLQQAgAjYCpAoLmAEBA39BAEEAKAKkCiIBQQJqNgKkCiABQQZqIQFBACgCqAohAgNAAkACQAJAIAFBfGogAk8NACABQX5qLwEAIQMCQAJAIAANACADQSpGDQEgA0F2ag4EAgQEAgQLIANBKkcNAwsgAS8BAEEvRw0CQQAgAUF+ajYCpAoMAQsgAUF+aiEBC0EAIAE2AqQKDwsgAUECaiEBDAALC4gBAQR/QQAoAqQKIQFBACgCqAohAgJAAkADQCABIgNBAmohASADIAJPDQEgAS8BACIEIABGDQICQCAEQdwARg0AIARBdmoOBAIBAQIBCyADQQRqIQEgAy8BBEENRw0AIANBBmogASADLwEGQQpGGyEBDAALC0EAIAE2AqQKECIPC0EAIAE2AqQKC2wBAX8CQAJAIABBX2oiAUEFSw0AQQEgAXRBMXENAQsgAEFGakH//wNxQQZJDQAgAEEpRyAAQVhqQf//A3FBB0lxDQACQCAAQaV/ag4EAQAAAQALIABB/QBHIABBhX9qQf//A3FBBElxDwtBAQsuAQF/QQEhAQJAIABBmAlBBRAjDQAgAEGiCUEDECMNACAAQagJQQIQIyEBCyABC4MBAQJ/QQEhAQJAAkACQAJAAkACQCAALwEAIgJBRWoOBAUEBAEACwJAIAJBm39qDgQDBAQCAAsgAkEpRg0EIAJB+QBHDQMgAEF+akG0CUEGECMPCyAAQX5qLwEAQT1GDwsgAEF+akGsCUEEECMPCyAAQX5qQcAJQQMQIw8LQQAhAQsgAQveAQEEf0EAKAKkCiEAQQAoAqgKIQECQAJAAkADQCAAIgJBAmohACACIAFPDQECQAJAAkAgAC8BACIDQaR/ag4FAgMDAwEACyADQSRHDQIgAi8BBEH7AEcNAkEAIAJBBGoiADYCpApBAEEALwGMCiICQQFqOwGMCkEAKAKYCiACQQN0aiICQQQ2AgAgAiAANgIEDwtBACAANgKkCkEAQQAvAYwKQX9qIgA7AYwKQQAoApgKIABB//8DcUEDdGooAgBBA0cNAwwECyACQQRqIQAMAAsLQQAgADYCpAoLECILC7QDAQJ/QQAhAQJAAkACQAJAAkACQAJAAkACQAJAIAAvAQBBnH9qDhQAAQIJCQkJAwkJBAUJCQYJBwkJCAkLAkACQCAAQX5qLwEAQZd/ag4EAAoKAQoLIABBfGpBvAhBAhAjDwsgAEF8akHACEEDECMPCwJAAkACQCAAQX5qLwEAQY1/ag4DAAECCgsCQCAAQXxqLwEAIgJB4QBGDQAgAkHsAEcNCiAAQXpqQeUAECQPCyAAQXpqQeMAECQPCyAAQXxqQcYIQQQQIw8LIABBfGpBzghBBhAjDwsgAEF+ai8BAEHvAEcNBiAAQXxqLwEAQeUARw0GAkAgAEF6ai8BACICQfAARg0AIAJB4wBHDQcgAEF4akHaCEEGECMPCyAAQXhqQeYIQQIQIw8LIABBfmpB6ghBBBAjDwtBASEBIABBfmoiAEHpABAkDQQgAEHyCEEFECMPCyAAQX5qQeQAECQPCyAAQX5qQfwIQQcQIw8LIABBfmpBiglBBBAjDwsCQCAAQX5qLwEAIgJB7wBGDQAgAkHlAEcNASAAQXxqQe4AECQPCyAAQXxqQZIJQQMQIyEBCyABCzQBAX9BASEBAkAgAEF3akH//wNxQQVJDQAgAEGAAXJBoAFGDQAgAEEuRyAAECVxIQELIAELMAEBfwJAAkAgAEF3aiIBQRdLDQBBASABdEGNgIAEcQ0BCyAAQaABRg0AQQAPC0EBC04BAn9BACEBAkACQCAALwEAIgJB5QBGDQAgAkHrAEcNASAAQX5qQeoIQQQQIw8LIABBfmovAQBB9QBHDQAgAEF8akHOCEEGECMhAQsgAQtwAQJ/AkACQANAQQBBACgCpAoiAEECaiIBNgKkCiAAQQAoAqgKTw0BAkACQAJAIAEvAQAiAUGlf2oOAgECAAsCQCABQXZqDgQEAwMEAAsgAUEvRw0CDAQLECoaDAELQQAgAEEEajYCpAoMAAsLECILCzUBAX9BAEEBOgD0CUEAKAKkCiEAQQBBACgCqApBAmo2AqQKQQAgAEEAKALUCWtBAXU2AoQKC0kBA39BACEDAkAgACACQQF0IgJrIgRBAmoiAEEAKALUCSIFSQ0AIAAgASACECsNAAJAIAAgBUcNAEEBDwsgBC8BABAeIQMLIAMLPQECf0EAIQICQEEAKALUCSIDIABLDQAgAC8BACABRw0AAkAgAyAARw0AQQEPCyAAQX5qLwEAEB4hAgsgAgtoAQJ/QQEhAQJAAkAgAEFfaiICQQVLDQBBASACdEExcQ0BCyAAQfj/A3FBKEYNACAAQUZqQf//A3FBBkkNAAJAIABBpX9qIgJBA0sNACACQQFHDQELIABBhX9qQf//A3FBBEkhAQsgAQucAQEDf0EAKAKkCiEBAkADQAJAAkAgAS8BACICQS9HDQACQCABLwECIgFBKkYNACABQS9HDQQQFgwCCyAAEBcMAQsCQAJAIABFDQAgAkF3aiIBQRdLDQFBASABdEGfgIAEcUUNAQwCCyACEB9FDQMMAQsgAkGgAUcNAgtBAEEAKAKkCiIDQQJqIgE2AqQKIANBACgCqApJDQALCyACC8IDAQF/AkAgAUEiRg0AIAFBJ0YNABAiDwtBACgCpAohAiABEBggACACQQJqQQAoAqQKQQAoAsgJEAFBAEEAKAKkCkECajYCpApBABAmIQBBACgCpAohAQJAAkAgAEHhAEcNACABQQJqQbIIQQoQK0UNAQtBACABQX5qNgKkCg8LQQAgAUEMajYCpAoCQEEBECZB+wBGDQBBACABNgKkCg8LQQAoAqQKIgIhAANAQQAgAEECajYCpAoCQAJAAkBBARAmIgBBIkYNACAAQSdHDQFBJxAYQQBBACgCpApBAmo2AqQKQQEQJiEADAILQSIQGEEAQQAoAqQKQQJqNgKkCkEBECYhAAwBCyAAECghAAsCQCAAQTpGDQBBACABNgKkCg8LQQBBACgCpApBAmo2AqQKAkBBARAmIgBBIkYNACAAQSdGDQBBACABNgKkCg8LIAAQGEEAQQAoAqQKQQJqNgKkCgJAAkBBARAmIgBBLEYNACAAQf0ARg0BQQAgATYCpAoPC0EAQQAoAqQKQQJqNgKkCkEBECZB/QBGDQBBACgCpAohAAwBCwtBACgC6AkiASACNgIQIAFBACgCpApBAmo2AgwLbQECfwJAAkADQAJAIABB//8DcSIBQXdqIgJBF0sNAEEBIAJ0QZ+AgARxDQILIAFBoAFGDQEgACECIAEQJQ0CQQAhAkEAQQAoAqQKIgBBAmo2AqQKIAAvAQIiAA0ADAILCyAAIQILIAJB//8DcQurAQEEfwJAAkBBACgCpAoiAi8BACIDQeEARg0AIAEhBCAAIQUMAQtBACACQQRqNgKkCkEBECYhAkEAKAKkCiEFAkACQCACQSJGDQAgAkEnRg0AIAIQKBpBACgCpAohBAwBCyACEBhBAEEAKAKkCkECaiIENgKkCgtBARAmIQNBACgCpAohAgsCQCACIAVGDQAgBSAEQQAgACAAIAFGIgIbQQAgASACGxACCyADC3IBBH9BACgCpAohAEEAKAKoCiEBAkACQANAIABBAmohAiAAIAFPDQECQAJAIAIvAQAiA0Gkf2oOAgEEAAsgAiEAIANBdmoOBAIBAQIBCyAAQQRqIQAMAAsLQQAgAjYCpAoQIkEADwtBACACNgKkCkHdAAtJAQN/QQAhAwJAIAJFDQACQANAIAAtAAAiBCABLQAAIgVHDQEgAUEBaiEBIABBAWohACACQX9qIgINAAwCCwsgBCAFayEDCyADCwvkAQIAQYAIC8YBAAB4AHAAbwByAHQAbQBwAG8AcgB0AGUAdABhAGYAcgBvAG0AdQBuAGMAdABpAG8AbgBzAHMAZQByAHQAdgBvAHkAaQBlAGQAZQBsAGUAYwBvAG4AdABpAG4AaQBuAHMAdABhAG4AdAB5AGIAcgBlAGEAcgBlAHQAdQByAGQAZQBiAHUAZwBnAGUAYQB3AGEAaQB0AGgAcgB3AGgAaQBsAGUAZgBvAHIAaQBmAGMAYQB0AGMAZgBpAG4AYQBsAGwAZQBsAHMAAEHICQsQAQAAAAIAAAAABAAAMDkAAA==","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());
@@ -34968,12 +36731,24 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, ex
     if (nestedRoot) {
         basedir = nestedResolveFrom(nestedRoot, basedir, preserveSymlinks);
     }
+    // nearest package.json
+    let nearestPkg;
+    // nearest package.json that may have the `exports` field
     let pkg;
-    const pkgId = possiblePkgIds.reverse().find((pkgId) => {
-        pkg = resolvePackageData(pkgId, basedir, preserveSymlinks, packageCache);
-        return pkg;
+    let pkgId = possiblePkgIds.reverse().find((pkgId) => {
+        nearestPkg = resolvePackageData(pkgId, basedir, preserveSymlinks, packageCache);
+        return nearestPkg;
     });
-    if (!pkg) {
+    const rootPkgId = possiblePkgIds[0];
+    const rootPkg = resolvePackageData(rootPkgId, basedir, preserveSymlinks, packageCache);
+    if (rootPkg?.data?.exports) {
+        pkg = rootPkg;
+        pkgId = rootPkgId;
+    }
+    else {
+        pkg = nearestPkg;
+    }
+    if (!pkg || !nearestPkg) {
         // if import can't be found, check if it's an optional peer dep.
         // if so, we can resolve to a special id that errors only when imported.
         if (basedir !== root && // root has no peer dep
@@ -35060,7 +36835,7 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, ex
         });
     }
     const ext = path$n.extname(resolved);
-    const isCJS = ext === '.cjs' || (ext === '.js' && pkg.data.type !== 'module');
+    const isCJS = ext === '.cjs' || (ext === '.js' && nearestPkg.data.type !== 'module');
     if (!options.ssrOptimizeCheck &&
         (!resolved.includes('node_modules') || // linked
             !depsOptimizer || // resolving before listening to the server
@@ -35541,8 +37316,7 @@ function esbuildDepPlugin(qualified, exportsData, external, config, ssr) {
                 const flatId = flattenId(id);
                 if (flatId in qualified) {
                     return {
-                        path: flatId,
-                        namespace: 'dep'
+                        path: qualified[flatId]
                     };
                 }
             }
@@ -35571,43 +37345,6 @@ function esbuildDepPlugin(qualified, exportsData, external, config, ssr) {
                     return resolveResult(id, resolved);
                 }
             });
-            // For entry files, we'll read it ourselves and construct a proxy module
-            // to retain the entry's raw id instead of file path so that esbuild
-            // outputs desired output file structure.
-            // It is necessary to do the re-exporting to separate the virtual proxy
-            // module from the actual module since the actual module may get
-            // referenced via relative imports - if we don't separate the proxy and
-            // the actual module, esbuild will create duplicated copies of the same
-            // module!
-            const root = path$n.resolve(config.root);
-            build.onLoad({ filter: /.*/, namespace: 'dep' }, ({ path: id }) => {
-                const entryFile = qualified[id];
-                let relativePath = normalizePath$3(path$n.relative(root, entryFile));
-                if (!relativePath.startsWith('./') &&
-                    !relativePath.startsWith('../') &&
-                    relativePath !== '.') {
-                    relativePath = `./${relativePath}`;
-                }
-                let contents = '';
-                const { hasImports, exports, hasReExports } = exportsData[id];
-                if (!hasImports && !exports.length) {
-                    // cjs
-                    contents += `export default require("${relativePath}");`;
-                }
-                else {
-                    if (exports.includes('default')) {
-                        contents += `import d from "${relativePath}";export default d;`;
-                    }
-                    if (hasReExports || exports.length > 1 || exports[0] !== 'default') {
-                        contents += `\nexport * from "${relativePath}"`;
-                    }
-                }
-                return {
-                    loader: 'js',
-                    contents,
-                    resolveDir: root
-                };
-            });
             build.onLoad({ filter: /.*/, namespace: 'browser-external' }, ({ path }) => {
                 if (config.isProduction) {
                     return {
@@ -36497,7 +38234,7 @@ async function toAbsoluteGlob(glob, root, importer, resolveId) {
     if (glob.startsWith('**'))
         return pre + glob;
     const resolved = normalizePath$3((await resolveId(glob, importer)) || glob);
-    if (isAbsolute$3(resolved)) {
+    if (isAbsolute$2(resolved)) {
         return pre + globSafeResolvedPath(resolved, glob);
     }
     throw new Error(`Invalid glob: "${glob}" (resolved: "${resolved}"). It must start with '/' or './'`);
@@ -37066,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 () {
@@ -37152,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 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 decodeBase64(base64) {
-	  return (SafeBuffer.Buffer.from(base64, 'base64') || "").toString();
+	function decodeBase64WithAtob(base64) {
+	  return decodeURIComponent(escape(atob(base64)));
 	}
 
 	function stripComment(sm) {
@@ -37192,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();
@@ -37273,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);
@@ -37432,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;
@@ -39484,7 +41196,7 @@ const lexStates = {
         switch (c) {
         case '\\':
             read();
-            buffer += escape$1();
+            buffer += escape$2();
             return
 
         case '"':
@@ -39639,7 +41351,7 @@ function literal (s) {
     }
 }
 
-function escape$1 () {
+function escape$2 () {
     const c = peek();
     switch (c) {
     case 'b':
@@ -40957,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)
@@ -41042,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'))
@@ -43811,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,
@@ -44753,12 +46469,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 =
@@ -44950,7 +46665,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) {
@@ -44972,7 +46687,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         logger: config.logger
     }));
     if (isModule) {
-        postcssPlugins.unshift((await import('./dep-46ac452b.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-ea6d21e3.js').then(function (n) { return n.i; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -44999,13 +46714,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: {
@@ -53825,7 +55541,7 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
         preserveSymlinks,
         isBuild: true,
         isProduction,
-        isRequire: true,
+        isRequire: false,
         root
     };
     // Since dynamic imports can happen in parallel, we need to
@@ -53896,6 +55612,11 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
     }
     return Object.freeze(ssrModule);
 }
+// `nodeImport` may run in parallel on multiple `ssrLoadModule` calls.
+// We keep track of the current importing count so that the first import
+// would `hookNodeResolve`, and the last import would `unhookNodeResolve`.
+let importingCount = 0;
+let unhookNodeResolve;
 // In node@12+ we can use dynamic import to load CJS and ESM
 async function nodeImport(id, importer, resolveOptions) {
     // Node's module resolution is hi-jacked so Vite can ensure the
@@ -53909,30 +55630,32 @@ async function nodeImport(id, importer, resolveOptions) {
         }
         return resolved.id;
     };
-    // When an ESM module imports an ESM dependency, this hook is *not* used.
-    const unhookNodeResolve = hookNodeResolve((nodeResolve) => (id, parent, isMain, options) => {
-        // Use the Vite resolver only for bare imports while skipping
-        // any absolute paths, built-in modules and binary modules.
-        if (!bareImportRE.test(id) ||
-            path$n.isAbsolute(id) ||
-            isBuiltin(id) ||
-            id.endsWith('.node')) {
-            return nodeResolve(id, parent, isMain, options);
-        }
-        if (parent) {
-            let resolved = viteResolve(id, parent.id);
-            if (resolved) {
-                // hookNodeResolve must use platform-specific path.normalize
-                // to be compatible with dynamicImport (#6080)
-                resolved = path$n.normalize(resolved);
+    if (importingCount === 0) {
+        // When an ESM module imports an ESM dependency, this hook is *not* used.
+        unhookNodeResolve = hookNodeResolve((nodeResolve) => (id, parent, isMain, options) => {
+            // Use the Vite resolver only for bare imports while skipping
+            // any absolute paths, built-in modules and binary modules.
+            if (!bareImportRE.test(id) ||
+                path$n.isAbsolute(id) ||
+                isBuiltin(id) ||
+                id.endsWith('.node')) {
+                return nodeResolve(id, parent, isMain, options);
+            }
+            if (parent) {
+                let resolved = viteResolve(id, parent.id);
+                if (resolved) {
+                    // hookNodeResolve must use platform-specific path.normalize
+                    // to be compatible with dynamicImport (#6080)
+                    resolved = path$n.normalize(resolved);
+                }
+                return resolved;
             }
-            return resolved;
-        }
-        // Importing a CJS module from an ESM module. In this case, the import
-        // specifier is already an absolute path, so this is a no-op.
-        // Options like `resolve.dedupe` and `mode` are not respected.
-        return id;
-    });
+            // Importing a CJS module from an ESM module. In this case, the import
+            // specifier is already an absolute path, so this is a no-op.
+            // Options like `resolve.dedupe` and `mode` are not respected.
+            return id;
+        });
+    }
     let url;
     if (id.startsWith('node:') || isBuiltin(id)) {
         url = id;
@@ -53950,11 +55673,15 @@ async function nodeImport(id, importer, resolveOptions) {
         }
     }
     try {
+        importingCount++;
         const mod = await dynamicImport(url);
         return proxyESM(mod);
     }
     finally {
-        unhookNodeResolve();
+        importingCount--;
+        if (importingCount === 0) {
+            unhookNodeResolve?.();
+        }
     }
 }
 // rollup-style default import interop for cjs
@@ -54174,7 +55901,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;
@@ -59303,7 +61030,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
@@ -60538,7 +62265,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
                 });
@@ -62208,7 +63935,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';
@@ -62255,8 +63982,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(' ');
 
@@ -62438,18 +64165,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".
@@ -62582,6 +64322,11 @@ async function createServer(inlineConfig = {}) {
         ssrRewriteStacktrace(stack) {
             return ssrRewriteStacktrace(stack, moduleGraph);
         },
+        async reloadModule(module) {
+            if (serverConfig.hmr !== false && module.file) {
+                updateModules(module.file, [module], Date.now(), server);
+            }
+        },
         async listen(port, isRestart) {
             await startServer(server, port, isRestart);
             if (httpServer) {
@@ -63490,10 +65235,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;
         }
@@ -63506,22 +65248,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];
@@ -63895,6 +65628,7 @@ async function bundleConfigFile(fileName, isESM) {
         platform: 'node',
         bundle: true,
         format: isESM ? 'esm' : 'cjs',
+        mainFields: ['main'],
         sourcemap: 'inline',
         metafile: true,
         define: {
@@ -63906,32 +65640,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] !== '.' && !isAbsolute(id)) {
-                            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 };
                     });
                 }
             },
@@ -64025,8 +65754,5 @@ function isDepsOptimizerEnabled(config, ssr) {
         (command === 'build' && disabled === 'build') ||
         (command === 'serve' && disabled === 'dev'));
 }
-function isAbsolute(id) {
-    return path$n.isAbsolute(id) || path$n.posix.isAbsolute(id);
-}
 
 export { index$1 as A, build$1 as B, index as C, preview$1 as D, resolvePackageData as a, build as b, createServer as c, defineConfig as d, resolveConfig as e, formatPostcssSourceMap as f, resolveBaseUrl as g, getDepOptimizationConfig as h, isDepsOptimizerEnabled as i, mergeAlias as j, createFilter as k, loadConfigFromFile as l, mergeConfig as m, normalizePath$3 as n, optimizeDeps as o, preview as p, send as q, resolvePackageEntry as r, sortUserPlugins as s, transformWithEsbuild as t, createLogger as u, searchForWorkspaceRoot as v, loadEnv as w, resolveEnvPrefix as x, picocolors as y, commonjsGlobal as z };