vitest 0.0.94 → 0.0.98

package/dist/worker.js

@@ -1,211 +1,18 @@
-import path, { resolve as resolve$3, dirname as dirname$3 } from 'path';
+import { a as resolve, d as dirname$2 } from './index-1488b423.js';
 import { n as nanoid } from './index-9e71c815.js';
-import { c as distDir } from './constants-9cfa4d7b.js';
+import { c as distDir } from './constants-e78c749a.js';
 import { builtinModules, createRequire } from 'module';
-import { pathToFileURL, fileURLToPath, URL as URL$1 } from 'url';
+import { pathToFileURL, fileURLToPath as fileURLToPath$2, URL as URL$1 } from 'url';
 import vm from 'vm';
-import { s as slash } from './utils-576876dc.js';
-import fs, { realpathSync, statSync, Stats, promises } from 'fs';
+import path from 'path';
+import fs, { promises, realpathSync, statSync, Stats } from 'fs';
 import assert from 'assert';
-import { format as format$3, inspect } from 'util';
+import { format as format$2, inspect } from 'util';
+import { s as slash } from './utils-70b78878.js';
 import { s as send } from './rpc-7de86f29.js';
 import 'tty';
 import 'local-pkg';
 
-function normalizeWindowsPath$2(input = "") {
-  if (!input.includes("\\")) {
-    return input;
-  }
-  return input.replace(/\\/g, "/");
-}
-
-const _UNC_REGEX$2 = /^[/][/]/;
-const _UNC_DRIVE_REGEX$2 = /^[/][/]([.]{1,2}[/])?([a-zA-Z]):[/]/;
-const _IS_ABSOLUTE_RE$2 = /^\/|^\\|^[a-zA-Z]:[/\\]/;
-const sep$2 = "/";
-const delimiter$2 = ":";
-const normalize$2 = function(path2) {
-  if (path2.length === 0) {
-    return ".";
-  }
-  path2 = normalizeWindowsPath$2(path2);
-  const isUNCPath = path2.match(_UNC_REGEX$2);
-  const hasUNCDrive = isUNCPath && path2.match(_UNC_DRIVE_REGEX$2);
-  const isPathAbsolute = isAbsolute$2(path2);
-  const trailingSeparator = path2[path2.length - 1] === "/";
-  path2 = normalizeString$2(path2, !isPathAbsolute);
-  if (path2.length === 0) {
-    if (isPathAbsolute) {
-      return "/";
-    }
-    return trailingSeparator ? "./" : ".";
-  }
-  if (trailingSeparator) {
-    path2 += "/";
-  }
-  if (isUNCPath) {
-    if (hasUNCDrive) {
-      return `//./${path2}`;
-    }
-    return `//${path2}`;
-  }
-  return isPathAbsolute && !isAbsolute$2(path2) ? `/${path2}` : path2;
-};
-const join$2 = function(...args) {
-  if (args.length === 0) {
-    return ".";
-  }
-  let joined;
-  for (let i = 0; i < args.length; ++i) {
-    const arg = args[i];
-    if (arg.length > 0) {
-      if (joined === void 0) {
-        joined = arg;
-      } else {
-        joined += `/${arg}`;
-      }
-    }
-  }
-  if (joined === void 0) {
-    return ".";
-  }
-  return normalize$2(joined);
-};
-const resolve = function(...args) {
-  args = args.map((arg) => normalizeWindowsPath$2(arg));
-  let resolvedPath = "";
-  let resolvedAbsolute = false;
-  for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-    const path2 = i >= 0 ? args[i] : process.cwd();
-    if (path2.length === 0) {
-      continue;
-    }
-    resolvedPath = `${path2}/${resolvedPath}`;
-    resolvedAbsolute = isAbsolute$2(path2);
-  }
-  resolvedPath = normalizeString$2(resolvedPath, !resolvedAbsolute);
-  if (resolvedAbsolute && !isAbsolute$2(resolvedPath)) {
-    return `/${resolvedPath}`;
-  }
-  return resolvedPath.length > 0 ? resolvedPath : ".";
-};
-function normalizeString$2(path2, allowAboveRoot) {
-  let res = "";
-  let lastSegmentLength = 0;
-  let lastSlash = -1;
-  let dots = 0;
-  let char = null;
-  for (let i = 0; i <= path2.length; ++i) {
-    if (i < path2.length) {
-      char = path2[i];
-    } else if (char === "/") {
-      break;
-    } else {
-      char = "/";
-    }
-    if (char === "/") {
-      if (lastSlash === i - 1 || dots === 1) ; else if (dots === 2) {
-        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
-          if (res.length > 2) {
-            const lastSlashIndex = res.lastIndexOf("/");
-            if (lastSlashIndex === -1) {
-              res = "";
-              lastSegmentLength = 0;
-            } else {
-              res = res.slice(0, lastSlashIndex);
-              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-            }
-            lastSlash = i;
-            dots = 0;
-            continue;
-          } else if (res.length !== 0) {
-            res = "";
-            lastSegmentLength = 0;
-            lastSlash = i;
-            dots = 0;
-            continue;
-          }
-        }
-        if (allowAboveRoot) {
-          res += res.length > 0 ? "/.." : "..";
-          lastSegmentLength = 2;
-        }
-      } else {
-        if (res.length > 0) {
-          res += `/${path2.slice(lastSlash + 1, i)}`;
-        } else {
-          res = path2.slice(lastSlash + 1, i);
-        }
-        lastSegmentLength = i - lastSlash - 1;
-      }
-      lastSlash = i;
-      dots = 0;
-    } else if (char === "." && dots !== -1) {
-      ++dots;
-    } else {
-      dots = -1;
-    }
-  }
-  return res;
-}
-const isAbsolute$2 = function(p) {
-  return _IS_ABSOLUTE_RE$2.test(p);
-};
-const toNamespacedPath$2 = function(p) {
-  return normalizeWindowsPath$2(p);
-};
-const extname$2 = function(p) {
-  return path.posix.extname(normalizeWindowsPath$2(p));
-};
-const relative$2 = function(from, to) {
-  return path.posix.relative(normalizeWindowsPath$2(from), normalizeWindowsPath$2(to));
-};
-const dirname$2 = function(p) {
-  return path.posix.dirname(normalizeWindowsPath$2(p));
-};
-const format$2 = function(p) {
-  return normalizeWindowsPath$2(path.posix.format(p));
-};
-const basename$2 = function(p, ext) {
-  return path.posix.basename(normalizeWindowsPath$2(p), ext);
-};
-const parse$e = function(p) {
-  return path.posix.parse(normalizeWindowsPath$2(p));
-};
-
-const _path$2 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  sep: sep$2,
-  delimiter: delimiter$2,
-  normalize: normalize$2,
-  join: join$2,
-  resolve: resolve,
-  normalizeString: normalizeString$2,
-  isAbsolute: isAbsolute$2,
-  toNamespacedPath: toNamespacedPath$2,
-  extname: extname$2,
-  relative: relative$2,
-  dirname: dirname$2,
-  format: format$2,
-  basename: basename$2,
-  parse: parse$e
-});
-
-({
-  ..._path$2
-});
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-var ParseOptions$1;
-(function (ParseOptions) {
-    ParseOptions.DEFAULT = {
-        allowTrailingComma: false
-    };
-})(ParseOptions$1 || (ParseOptions$1 = {}));
-
 const BUILTIN_MODULES$1 = new Set(builtinModules);
 function normalizeSlash$1(str) {
   return str.replace(/\\/g, "/");
@@ -223,12 +30,17 @@ function perr$1(_err) {
   Error.captureStackTrace(err, pcall$1);
   return Promise.reject(err);
 }
+const ProtocolRegex = /^(?<proto>.{2,}):.+$/;
+function getProtocol(id) {
+  const proto = id.match(ProtocolRegex);
+  return proto ? proto.groups.proto : null;
+}
 
 function fileURLToPath$1(id) {
   if (typeof id === "string" && !id.startsWith("file://")) {
     return normalizeSlash$1(id);
   }
-  return normalizeSlash$1(fileURLToPath(id));
+  return normalizeSlash$1(fileURLToPath$2(id));
 }
 function normalizeid$1(id) {
   if (typeof id !== "string") {
@@ -3641,7 +3453,7 @@ function getMessage$1(key, args, self) {
   if (args.length === 0) return message
 
   args.unshift(message);
-  return Reflect.apply(format$3, null, args)
+  return Reflect.apply(format$2, null, args)
 }
 
 // Manually “tree shaken” from:
@@ -3685,7 +3497,7 @@ function defaultGetFormat$1(url) {
     }
 
     if (!format) {
-      throw new ERR_UNKNOWN_FILE_EXTENSION$1(ext, fileURLToPath(url))
+      throw new ERR_UNKNOWN_FILE_EXTENSION$1(ext, fileURLToPath$2(url))
     }
 
     return {format: format || null}
@@ -3730,7 +3542,7 @@ const packageJsonCache$1 = new Map();
  * @returns {void}
  */
 function emitFolderMapDeprecation$1(match, pjsonUrl, isExports, base) {
-  const pjsonPath = fileURLToPath(pjsonUrl);
+  const pjsonPath = fileURLToPath$2(pjsonUrl);
 
   if (emittedPackageWarnings$1.has(pjsonPath + '|' + match)) return
   emittedPackageWarnings$1.add(pjsonPath + '|' + match);
@@ -3738,7 +3550,7 @@ function emitFolderMapDeprecation$1(match, pjsonUrl, isExports, base) {
     `Use of deprecated folder mapping "${match}" in the ${
       isExports ? '"exports"' : '"imports"'
     } field module resolution of the package at ${pjsonPath}${
-      base ? ` imported from ${fileURLToPath(base)}` : ''
+      base ? ` imported from ${fileURLToPath$2(base)}` : ''
     }.\n` +
       `Update this package.json to use a subpath pattern like "${match}*".`,
     'DeprecationWarning',
@@ -3756,9 +3568,9 @@ function emitFolderMapDeprecation$1(match, pjsonUrl, isExports, base) {
 function emitLegacyIndexDeprecation$1(url, packageJsonUrl, base, main) {
   const {format} = defaultGetFormat$1(url.href);
   if (format !== 'module') return
-  const path = fileURLToPath(url.href);
-  const pkgPath = fileURLToPath(new URL$1('.', packageJsonUrl));
-  const basePath = fileURLToPath(base);
+  const path = fileURLToPath$2(url.href);
+  const pkgPath = fileURLToPath$2(new URL$1('.', packageJsonUrl));
+  const basePath = fileURLToPath$2(base);
   if (main)
     process.emitWarning(
       `Package ${pkgPath} has a "main" field set to ${JSON.stringify(main)}, ` +
@@ -3828,7 +3640,7 @@ function getPackageConfig$1(path, specifier, base) {
   } catch (error) {
     throw new ERR_INVALID_PACKAGE_CONFIG$1(
       path,
-      (base ? `"${specifier}" from ` : '') + fileURLToPath(base || specifier),
+      (base ? `"${specifier}" from ` : '') + fileURLToPath$2(base || specifier),
       error.message
     )
   }
@@ -3864,7 +3676,7 @@ function getPackageScopeConfig$1(resolved) {
     if (packageJsonPath.endsWith('node_modules/package.json')) break
 
     const packageConfig = getPackageConfig$1(
-      fileURLToPath(packageJsonUrl),
+      fileURLToPath$2(packageJsonUrl),
       resolved
     );
     if (packageConfig.exists) return packageConfig
@@ -3877,7 +3689,7 @@ function getPackageScopeConfig$1(resolved) {
     if (packageJsonUrl.pathname === lastPackageJsonUrl.pathname) break
   }
 
-  const packageJsonPath = fileURLToPath(packageJsonUrl);
+  const packageJsonPath = fileURLToPath$2(packageJsonUrl);
   /** @type {PackageConfig} */
   const packageConfig = {
     pjsonPath: packageJsonPath,
@@ -3904,7 +3716,7 @@ function getPackageScopeConfig$1(resolved) {
  * @returns {boolean}
  */
 function fileExists$1(url) {
-  return tryStatSync$1(fileURLToPath(url)).isFile()
+  return tryStatSync$1(fileURLToPath$2(url)).isFile()
 }
 
 /**
@@ -3965,8 +3777,8 @@ function legacyMainResolve$1(packageJsonUrl, packageConfig, base) {
 
   // Not found.
   throw new ERR_MODULE_NOT_FOUND$1(
-    fileURLToPath(new URL$1('.', packageJsonUrl)),
-    fileURLToPath(base)
+    fileURLToPath$2(new URL$1('.', packageJsonUrl)),
+    fileURLToPath$2(base)
   )
 }
 
@@ -3980,15 +3792,15 @@ function finalizeResolution$1(resolved, base) {
     throw new ERR_INVALID_MODULE_SPECIFIER$1(
       resolved.pathname,
       'must not include encoded "/" or "\\" characters',
-      fileURLToPath(base)
+      fileURLToPath$2(base)
     )
 
-  const path = fileURLToPath(resolved);
+  const path = fileURLToPath$2(resolved);
 
   const stats = tryStatSync$1(path.endsWith('/') ? path.slice(-1) : path);
 
   if (stats.isDirectory()) {
-    const error = new ERR_UNSUPPORTED_DIR_IMPORT$1(path, fileURLToPath(base));
+    const error = new ERR_UNSUPPORTED_DIR_IMPORT$1(path, fileURLToPath$2(base));
     // @ts-expect-error Add this for `import.meta.resolve`.
     error.url = String(resolved);
     throw error
@@ -3997,7 +3809,7 @@ function finalizeResolution$1(resolved, base) {
   if (!stats.isFile()) {
     throw new ERR_MODULE_NOT_FOUND$1(
       path || resolved.pathname,
-      base && fileURLToPath(base),
+      base && fileURLToPath$2(base),
       'module'
     )
   }
@@ -4014,8 +3826,8 @@ function finalizeResolution$1(resolved, base) {
 function throwImportNotDefined$1(specifier, packageJsonUrl, base) {
   throw new ERR_PACKAGE_IMPORT_NOT_DEFINED$1(
     specifier,
-    packageJsonUrl && fileURLToPath(new URL$1('.', packageJsonUrl)),
-    fileURLToPath(base)
+    packageJsonUrl && fileURLToPath$2(new URL$1('.', packageJsonUrl)),
+    fileURLToPath$2(base)
   )
 }
 
@@ -4027,9 +3839,9 @@ function throwImportNotDefined$1(specifier, packageJsonUrl, base) {
  */
 function throwExportsNotFound$1(subpath, packageJsonUrl, base) {
   throw new ERR_PACKAGE_PATH_NOT_EXPORTED$1(
-    fileURLToPath(new URL$1('.', packageJsonUrl)),
+    fileURLToPath$2(new URL$1('.', packageJsonUrl)),
     subpath,
-    base && fileURLToPath(base)
+    base && fileURLToPath$2(base)
   )
 }
 
@@ -4043,12 +3855,12 @@ function throwExportsNotFound$1(subpath, packageJsonUrl, base) {
 function throwInvalidSubpath$1(subpath, packageJsonUrl, internal, base) {
   const reason = `request is not a valid subpath for the "${
     internal ? 'imports' : 'exports'
-  }" resolution of ${fileURLToPath(packageJsonUrl)}`;
+  }" resolution of ${fileURLToPath$2(packageJsonUrl)}`;
 
   throw new ERR_INVALID_MODULE_SPECIFIER$1(
     subpath,
     reason,
-    base && fileURLToPath(base)
+    base && fileURLToPath$2(base)
   )
 }
 
@@ -4073,11 +3885,11 @@ function throwInvalidPackageTarget$1(
       : `${target}`;
 
   throw new ERR_INVALID_PACKAGE_TARGET$1(
-    fileURLToPath(new URL$1('.', packageJsonUrl)),
+    fileURLToPath$2(new URL$1('.', packageJsonUrl)),
     subpath,
     target,
     internal,
-    base && fileURLToPath(base)
+    base && fileURLToPath$2(base)
   )
 }
 
@@ -4246,7 +4058,7 @@ function resolvePackageTarget$1(
       const key = keys[i];
       if (isArrayIndex$1(key)) {
         throw new ERR_INVALID_PACKAGE_CONFIG$1(
-          fileURLToPath(packageJsonUrl),
+          fileURLToPath$2(packageJsonUrl),
           base,
           '"exports" cannot contain numeric property keys.'
         )
@@ -4312,7 +4124,7 @@ function isConditionalExportsMainSugar$1(exports, packageJsonUrl, base) {
       isConditionalSugar = curIsConditionalSugar;
     } else if (isConditionalSugar !== curIsConditionalSugar) {
       throw new ERR_INVALID_PACKAGE_CONFIG$1(
-        fileURLToPath(packageJsonUrl),
+        fileURLToPath$2(packageJsonUrl),
         base,
         '"exports" cannot contain some keys starting with \'.\' and some not.' +
           ' The exports object must either be an object of package subpath keys' +
@@ -4415,7 +4227,7 @@ function packageExportsResolve$1(
 function packageImportsResolve$1(name, base, conditions) {
   if (name === '#' || name.startsWith('#/')) {
     const reason = 'is not a valid internal imports specifier name';
-    throw new ERR_INVALID_MODULE_SPECIFIER$1(name, reason, fileURLToPath(base))
+    throw new ERR_INVALID_MODULE_SPECIFIER$1(name, reason, fileURLToPath$2(base))
   }
 
   /** @type {URL} */
@@ -4533,7 +4345,7 @@ function parsePackageName$1(specifier, base) {
     throw new ERR_INVALID_MODULE_SPECIFIER$1(
       specifier,
       'is not a valid package name',
-      fileURLToPath(base)
+      fileURLToPath$2(base)
     )
   }
 
@@ -4581,7 +4393,7 @@ function packageResolve$1(specifier, base, conditions) {
     './node_modules/' + packageName + '/package.json',
     base
   );
-  let packageJsonPath = fileURLToPath(packageJsonUrl);
+  let packageJsonPath = fileURLToPath$2(packageJsonUrl);
   /** @type {string} */
   let lastPath;
   do {
@@ -4594,7 +4406,7 @@ function packageResolve$1(specifier, base, conditions) {
           '/package.json',
         packageJsonUrl
       );
-      packageJsonPath = fileURLToPath(packageJsonUrl);
+      packageJsonPath = fileURLToPath$2(packageJsonUrl);
       continue
     }
 
@@ -4614,7 +4426,7 @@ function packageResolve$1(specifier, base, conditions) {
     // Cross-platform root check.
   } while (packageJsonPath.length !== lastPath.length)
 
-  throw new ERR_MODULE_NOT_FOUND$1(packageName, fileURLToPath(base))
+  throw new ERR_MODULE_NOT_FOUND$1(packageName, fileURLToPath$2(base))
 }
 
 /**
@@ -4761,6 +4573,43 @@ var ParseOptions;
     };
 })(ParseOptions || (ParseOptions = {}));
 
+const BUILTIN_MODULES = new Set(builtinModules);
+function normalizeSlash(str) {
+  return str.replace(/\\/g, "/");
+}
+function pcall(fn, ...args) {
+  try {
+    return Promise.resolve(fn(...args)).catch((err) => perr(err));
+  } catch (err) {
+    return perr(err);
+  }
+}
+function perr(_err) {
+  const err = new Error(_err);
+  err.code = _err.code;
+  Error.captureStackTrace(err, pcall);
+  return Promise.reject(err);
+}
+
+function fileURLToPath(id) {
+  if (typeof id === "string" && !id.startsWith("file://")) {
+    return normalizeSlash(id);
+  }
+  return normalizeSlash(fileURLToPath$2(id));
+}
+function normalizeid(id) {
+  if (typeof id !== "string") {
+    id = id.toString();
+  }
+  if (/(node|data|http|https|file):/.test(id)) {
+    return id;
+  }
+  if (BUILTIN_MODULES.has(id)) {
+    return "node:" + id;
+  }
+  return "file://" + normalizeSlash(id);
+}
+
 function normalizeWindowsPath(input = "") {
   if (!input.includes("\\")) {
     return input;
@@ -7776,10 +7625,49 @@ var builtins = function ({
 
 // Manually “tree shaken” from:
 
+const reader = {read};
+const packageJsonReader = reader;
+
+/**
+ * @param {string} jsonPath
+ * @returns {{string: string}}
+ */
+function read(jsonPath) {
+  return find(path.dirname(jsonPath))
+}
+
+/**
+ * @param {string} dir
+ * @returns {{string: string}}
+ */
+function find(dir) {
+  try {
+    const string = fs.readFileSync(
+      path.toNamespacedPath(path.join(dir, 'package.json')),
+      'utf8'
+    );
+    return {string}
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      const parent = path.dirname(dir);
+      if (dir !== parent) return find(parent)
+      return {string: undefined}
+      // Throw all other errors.
+      /* c8 ignore next 4 */
+    }
+
+    throw error
+  }
+}
+
+// Manually “tree shaken” from:
+
 const isWindows$2 = process.platform === 'win32';
 
 const own$1 = {}.hasOwnProperty;
 
+const codes = {};
+
 /**
  * @typedef {(...args: unknown[]) => string} MessageFunction
  */
@@ -7790,7 +7678,7 @@ const nodeInternalPrefix = '__node_internal_';
 /** @type {number} */
 let userStackTraceLimit;
 
-createError(
+codes.ERR_INVALID_MODULE_SPECIFIER = createError(
   'ERR_INVALID_MODULE_SPECIFIER',
   /**
    * @param {string} request
@@ -7805,7 +7693,7 @@ createError(
   TypeError
 );
 
-createError(
+codes.ERR_INVALID_PACKAGE_CONFIG = createError(
   'ERR_INVALID_PACKAGE_CONFIG',
   /**
    * @param {string} path
@@ -7820,7 +7708,7 @@ createError(
   Error
 );
 
-createError(
+codes.ERR_INVALID_PACKAGE_TARGET = createError(
   'ERR_INVALID_PACKAGE_TARGET',
   /**
    * @param {string} pkgPath
@@ -7856,7 +7744,7 @@ createError(
   Error
 );
 
-createError(
+codes.ERR_MODULE_NOT_FOUND = createError(
   'ERR_MODULE_NOT_FOUND',
   /**
    * @param {string} path
@@ -7869,7 +7757,7 @@ createError(
   Error
 );
 
-createError(
+codes.ERR_PACKAGE_IMPORT_NOT_DEFINED = createError(
   'ERR_PACKAGE_IMPORT_NOT_DEFINED',
   /**
    * @param {string} specifier
@@ -7884,7 +7772,7 @@ createError(
   TypeError
 );
 
-createError(
+codes.ERR_PACKAGE_PATH_NOT_EXPORTED = createError(
   'ERR_PACKAGE_PATH_NOT_EXPORTED',
   /**
    * @param {string} pkgPath
@@ -7903,20 +7791,20 @@ createError(
   Error
 );
 
-createError(
+codes.ERR_UNSUPPORTED_DIR_IMPORT = createError(
   'ERR_UNSUPPORTED_DIR_IMPORT',
   "Directory import '%s' is not supported " +
     'resolving ES modules imported from %s',
   Error
 );
 
-createError(
+codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
   'ERR_UNKNOWN_FILE_EXTENSION',
   'Unknown file extension "%s" for %s',
   TypeError
 );
 
-createError(
+codes.ERR_INVALID_ARG_VALUE = createError(
   'ERR_INVALID_ARG_VALUE',
   /**
    * @param {string} name
@@ -7939,7 +7827,7 @@ createError(
   // , RangeError
 );
 
-createError(
+codes.ERR_UNSUPPORTED_ESM_URL_SCHEME = createError(
   'ERR_UNSUPPORTED_ESM_URL_SCHEME',
   /**
    * @param {URL} url
@@ -8116,112 +8004,1196 @@ function getMessage(key, args, self) {
   if (args.length === 0) return message
 
   args.unshift(message);
-  return Reflect.apply(format$3, null, args)
+  return Reflect.apply(format$2, null, args)
 }
 
 // Manually “tree shaken” from:
 
-builtins();
-
-Object.freeze(['node', 'import']);
-pathToFileURL(process.cwd());
-const CJS_RE = /([\s;]|^)(module.exports\b|exports\.\w|require\s*\(|global\.\w)/m;
-function hasCJSSyntax(code) {
-  return CJS_RE.test(code);
-}
+const {ERR_UNKNOWN_FILE_EXTENSION} = codes;
 
-const defaultFindOptions = {
-  startingFrom: ".",
-  rootPattern: /^node_modules$/,
-  test: (filePath) => {
-    try {
-      if (statSync(filePath).isFile()) {
-        return true;
-      }
-    } catch {
-    }
-    return null;
-  }
+const extensionFormatMap = {
+  __proto__: null,
+  '.cjs': 'commonjs',
+  '.js': 'module',
+  '.mjs': 'module'
 };
-async function findNearestFile(filename, _options = {}) {
-  const options = { ...defaultFindOptions, ..._options };
-  const basePath = resolve(options.startingFrom);
-  const leadingSlash = basePath[0] === "/";
-  const segments = basePath.split("/").filter(Boolean);
-  if (leadingSlash) {
-    segments[0] = "/" + segments[0];
-  }
-  let root = segments.findIndex((r) => r.match(options.rootPattern));
-  if (root === -1)
-    root = 0;
-  for (let i = segments.length; i > root; i--) {
-    const filePath = join$2(...segments.slice(0, i), filename);
-    if (await options.test(filePath)) {
-      return filePath;
-    }
+
+/**
+ * @param {string} url
+ * @returns {{format: string|null}}
+ */
+function defaultGetFormat(url) {
+  if (url.startsWith('node:')) {
+    return {format: 'builtin'}
   }
-  throw new Error(`Cannot find matching ${filename} in ${options.startingFrom} or parent directories`);
-}
-async function readPackageJSON(id, opts = {}) {
-  const resolvedPath = await resolvePackageJSON(id, opts);
-  const blob = await promises.readFile(resolvedPath, "utf-8");
-  return JSON.parse(blob);
-}
-async function resolvePackageJSON(id = process.cwd(), opts = {}) {
-  const resolvedPath = isAbsolute$2(id) ? id : await resolvePath$1(id, opts);
-  return findNearestFile("package.json", { startingFrom: resolvedPath, ...opts });
-}
 
-var __defProp = Object.defineProperty;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-const ProtocolRegex = /^(?<proto>.{2,}):.+$/;
-function getProtocol(id) {
-  const proto = id.match(ProtocolRegex);
-  return proto ? proto.groups.proto : null;
+  const parsed = new URL$1(url);
+
+  if (parsed.protocol === 'data:') {
+    const {1: mime} = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(
+      parsed.pathname
+    ) || [null, null];
+    const format = mime === 'text/javascript' ? 'module' : null;
+    return {format}
+  }
+
+  if (parsed.protocol === 'file:') {
+    const ext = path.extname(parsed.pathname);
+    /** @type {string} */
+    let format;
+    if (ext === '.js') {
+      format = getPackageType(parsed.href) === 'module' ? 'module' : 'commonjs';
+    } else {
+      format = extensionFormatMap[ext];
+    }
+
+    if (!format) {
+      throw new ERR_UNKNOWN_FILE_EXTENSION(ext, fileURLToPath$2(url))
+    }
+
+    return {format: format || null}
+  }
+
+  return {format: null}
+}
+
+// Manually “tree shaken” from:
+
+builtins();
+
+const {
+  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;
+
+const own = {}.hasOwnProperty;
+
+Object.freeze(['node', 'import']);
+
+const invalidSegmentRegEx = /(^|\\|\/)(\.\.?|node_modules)(\\|\/|$)/;
+const patternRegEx = /\*/g;
+const encodedSepRegEx = /%2f|%2c/i;
+/** @type {Set<string>} */
+const emittedPackageWarnings = new Set();
+/** @type {Map<string, PackageConfig>} */
+const packageJsonCache = new Map();
+
+/**
+ * @param {string} match
+ * @param {URL} pjsonUrl
+ * @param {boolean} isExports
+ * @param {URL} base
+ * @returns {void}
+ */
+function emitFolderMapDeprecation(match, pjsonUrl, isExports, base) {
+  const pjsonPath = fileURLToPath$2(pjsonUrl);
+
+  if (emittedPackageWarnings.has(pjsonPath + '|' + match)) return
+  emittedPackageWarnings.add(pjsonPath + '|' + match);
+  process.emitWarning(
+    `Use of deprecated folder mapping "${match}" in the ${
+      isExports ? '"exports"' : '"imports"'
+    } field module resolution of the package at ${pjsonPath}${
+      base ? ` imported from ${fileURLToPath$2(base)}` : ''
+    }.\n` +
+      `Update this package.json to use a subpath pattern like "${match}*".`,
+    'DeprecationWarning',
+    'DEP0148'
+  );
+}
+
+/**
+ * @param {URL} url
+ * @param {URL} packageJsonUrl
+ * @param {URL} base
+ * @param {unknown} [main]
+ * @returns {void}
+ */
+function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
+  const {format} = defaultGetFormat(url.href);
+  if (format !== 'module') return
+  const path = fileURLToPath$2(url.href);
+  const pkgPath = fileURLToPath$2(new URL$1('.', packageJsonUrl));
+  const basePath = fileURLToPath$2(base);
+  if (main)
+    process.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.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 {string} path
+ * @returns {Stats}
+ */
+function tryStatSync(path) {
+  // Note: from Node 15 onwards we can use `throwIfNoEntry: false` instead.
+  try {
+    return statSync(path)
+  } catch {
+    return new Stats()
+  }
+}
+
+/**
+ * @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 {Object.<string, unknown>} */
+  let packageJson;
+  try {
+    packageJson = JSON.parse(source);
+  } catch (error) {
+    throw new ERR_INVALID_PACKAGE_CONFIG(
+      path,
+      (base ? `"${specifier}" from ` : '') + fileURLToPath$2(base || specifier),
+      error.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 `Object.<string, unknown>`.
+    exports,
+    // @ts-expect-error Assume `Object.<string, unknown>`.
+    imports: imports && typeof imports === 'object' ? imports : undefined
+  };
+  packageJsonCache.set(path, packageConfig);
+  return packageConfig
+}
+
+/**
+ * @param {URL|string} resolved
+ * @returns {PackageConfig}
+ */
+function getPackageScopeConfig(resolved) {
+  let packageJsonUrl = new URL$1('./package.json', resolved);
+
+  while (true) {
+    const packageJsonPath = packageJsonUrl.pathname;
+
+    if (packageJsonPath.endsWith('node_modules/package.json')) break
+
+    const packageConfig = getPackageConfig(
+      fileURLToPath$2(packageJsonUrl),
+      resolved
+    );
+    if (packageConfig.exists) return packageConfig
+
+    const lastPackageJsonUrl = packageJsonUrl;
+    packageJsonUrl = new URL$1('../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$2(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) {
+  return tryStatSync(fileURLToPath$2(url)).isFile()
+}
+
+/**
+ * @param {URL} packageJsonUrl
+ * @param {PackageConfig} packageConfig
+ * @param {URL} base
+ * @returns {URL}
+ */
+function legacyMainResolve(packageJsonUrl, packageConfig, base) {
+  /** @type {URL} */
+  let guess;
+  if (packageConfig.main !== undefined) {
+    guess = new URL$1(`./${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$1(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$1(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$2(new URL$1('.', packageJsonUrl)),
+    fileURLToPath$2(base)
+  )
+}
+
+/**
+ * @param {URL} resolved
+ * @param {URL} base
+ * @returns {URL}
+ */
+function finalizeResolution(resolved, base) {
+  if (encodedSepRegEx.test(resolved.pathname))
+    throw new ERR_INVALID_MODULE_SPECIFIER(
+      resolved.pathname,
+      'must not include encoded "/" or "\\" characters',
+      fileURLToPath$2(base)
+    )
+
+  const path = fileURLToPath$2(resolved);
+
+  const stats = tryStatSync(path.endsWith('/') ? path.slice(-1) : path);
+
+  if (stats.isDirectory()) {
+    const error = new ERR_UNSUPPORTED_DIR_IMPORT(path, fileURLToPath$2(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(
+      path || resolved.pathname,
+      base && fileURLToPath$2(base),
+      'module'
+    )
+  }
+
+  return resolved
+}
+
+/**
+ * @param {string} specifier
+ * @param {URL?} packageJsonUrl
+ * @param {URL} base
+ * @returns {never}
+ */
+function throwImportNotDefined(specifier, packageJsonUrl, base) {
+  throw new ERR_PACKAGE_IMPORT_NOT_DEFINED(
+    specifier,
+    packageJsonUrl && fileURLToPath$2(new URL$1('.', packageJsonUrl)),
+    fileURLToPath$2(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$2(new URL$1('.', packageJsonUrl)),
+    subpath,
+    base && fileURLToPath$2(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$2(packageJsonUrl)}`;
+
+  throw new ERR_INVALID_MODULE_SPECIFIER(
+    subpath,
+    reason,
+    base && fileURLToPath$2(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$2(new URL$1('.', packageJsonUrl)),
+    subpath,
+    target,
+    internal,
+    base && fileURLToPath$2(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>} 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$1(target);
+        isURL = true;
+      } catch {}
+
+      if (!isURL) {
+        const exportTarget = pattern
+          ? target.replace(patternRegEx, 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$1(target, packageJsonUrl);
+  const resolvedPath = resolved.pathname;
+  const packagePath = new URL$1('.', packageJsonUrl).pathname;
+
+  if (!resolvedPath.startsWith(packagePath))
+    throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base);
+
+  if (subpath === '') return resolved
+
+  if (invalidSegmentRegEx.test(subpath))
+    throwInvalidSubpath(match + subpath, packageJsonUrl, internal, base);
+
+  if (pattern) return new URL$1(resolved.href.replace(patternRegEx, subpath))
+  return new URL$1(subpath, resolved)
+}
+
+/**
+ * @param {string} key
+ * @returns {boolean}
+ */
+function isArrayIndex(key) {
+  const keyNumber = Number(key);
+  if (`${keyNumber}` !== key) return false
+  return keyNumber >= 0 && keyNumber < 0xffff_ffff
+}
+
+/**
+ * @param {URL} packageJsonUrl
+ * @param {unknown} target
+ * @param {string} subpath
+ * @param {string} packageSubpath
+ * @param {URL} base
+ * @param {boolean} pattern
+ * @param {boolean} internal
+ * @param {Set<string>} conditions
+ * @returns {URL}
+ */
+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 {unknown[]} */
+    const targetList = target;
+    if (targetList.length === 0) return null
+
+    /** @type {Error} */
+    let lastException;
+    let i = -1;
+
+    while (++i < targetList.length) {
+      const targetItem = targetList[i];
+      /** @type {URL} */
+      let resolved;
+      try {
+        resolved = resolvePackageTarget(
+          packageJsonUrl,
+          targetItem,
+          subpath,
+          packageSubpath,
+          base,
+          pattern,
+          internal,
+          conditions
+        );
+      } catch (error) {
+        lastException = error;
+        if (error.code === 'ERR_INVALID_PACKAGE_TARGET') continue
+        throw error
+      }
+
+      if (resolved === undefined) continue
+
+      if (resolved === null) {
+        lastException = null;
+        continue
+      }
+
+      return resolved
+    }
+
+    if (lastException === undefined || lastException === null) {
+      // @ts-expect-error The diff between `undefined` and `null` seems to be
+      // intentional
+      return lastException
+    }
+
+    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$2(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))) {
+        /** @type {unknown} */
+        const conditionalTarget = target[key];
+        const resolved = resolvePackageTarget(
+          packageJsonUrl,
+          conditionalTarget,
+          subpath,
+          packageSubpath,
+          base,
+          pattern,
+          internal,
+          conditions
+        );
+        if (resolved === undefined) continue
+        return resolved
+      }
+    }
+
+    return undefined
+  }
+
+  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$2(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 {URL} packageJsonUrl
+ * @param {string} packageSubpath
+ * @param {Object.<string, unknown>} packageConfig
+ * @param {URL} base
+ * @param {Set<string>} conditions
+ * @returns {ResolveObject}
+ */
+function packageExportsResolve(
+  packageJsonUrl,
+  packageSubpath,
+  packageConfig,
+  base,
+  conditions
+) {
+  let exports = packageConfig.exports;
+  if (isConditionalExportsMainSugar(exports, packageJsonUrl, base))
+    exports = {'.': exports};
+
+  if (own.call(exports, packageSubpath)) {
+    const target = exports[packageSubpath];
+    const resolved = resolvePackageTarget(
+      packageJsonUrl,
+      target,
+      '',
+      packageSubpath,
+      base,
+      false,
+      false,
+      conditions
+    );
+    if (resolved === null || resolved === undefined)
+      throwExportsNotFound(packageSubpath, packageJsonUrl, base);
+    return {resolved, exact: true}
+  }
+
+  let bestMatch = '';
+  const keys = Object.getOwnPropertyNames(exports);
+  let i = -1;
+
+  while (++i < keys.length) {
+    const key = keys[i];
+    if (
+      key[key.length - 1] === '*' &&
+      packageSubpath.startsWith(key.slice(0, -1)) &&
+      packageSubpath.length >= key.length &&
+      key.length > bestMatch.length
+    ) {
+      bestMatch = key;
+    } else if (
+      key[key.length - 1] === '/' &&
+      packageSubpath.startsWith(key) &&
+      key.length > bestMatch.length
+    ) {
+      bestMatch = key;
+    }
+  }
+
+  if (bestMatch) {
+    const target = exports[bestMatch];
+    const pattern = bestMatch[bestMatch.length - 1] === '*';
+    const subpath = packageSubpath.slice(bestMatch.length - (pattern ? 1 : 0));
+    const resolved = resolvePackageTarget(
+      packageJsonUrl,
+      target,
+      subpath,
+      bestMatch,
+      base,
+      pattern,
+      false,
+      conditions
+    );
+    if (resolved === null || resolved === undefined)
+      throwExportsNotFound(packageSubpath, packageJsonUrl, base);
+    if (!pattern)
+      emitFolderMapDeprecation(bestMatch, packageJsonUrl, true, base);
+    return {resolved, exact: pattern}
+  }
+
+  throwExportsNotFound(packageSubpath, packageJsonUrl, base);
+}
+
+/**
+ * @param {string} name
+ * @param {URL} base
+ * @param {Set<string>} [conditions]
+ * @returns {ResolveObject}
+ */
+function packageImportsResolve(name, base, conditions) {
+  if (name === '#' || name.startsWith('#/')) {
+    const reason = 'is not a valid internal imports specifier name';
+    throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, fileURLToPath$2(base))
+  }
+
+  /** @type {URL} */
+  let packageJsonUrl;
+
+  const packageConfig = getPackageScopeConfig(base);
+
+  if (packageConfig.exists) {
+    packageJsonUrl = pathToFileURL(packageConfig.pjsonPath);
+    const imports = packageConfig.imports;
+    if (imports) {
+      if (own.call(imports, name)) {
+        const resolved = resolvePackageTarget(
+          packageJsonUrl,
+          imports[name],
+          '',
+          name,
+          base,
+          false,
+          true,
+          conditions
+        );
+        if (resolved !== null) return {resolved, exact: true}
+      } else {
+        let bestMatch = '';
+        const keys = Object.getOwnPropertyNames(imports);
+        let i = -1;
+
+        while (++i < keys.length) {
+          const key = keys[i];
+
+          if (
+            key[key.length - 1] === '*' &&
+            name.startsWith(key.slice(0, -1)) &&
+            name.length >= key.length &&
+            key.length > bestMatch.length
+          ) {
+            bestMatch = key;
+          } else if (
+            key[key.length - 1] === '/' &&
+            name.startsWith(key) &&
+            key.length > bestMatch.length
+          ) {
+            bestMatch = key;
+          }
+        }
+
+        if (bestMatch) {
+          const target = imports[bestMatch];
+          const pattern = bestMatch[bestMatch.length - 1] === '*';
+          const subpath = name.slice(bestMatch.length - (pattern ? 1 : 0));
+          const resolved = resolvePackageTarget(
+            packageJsonUrl,
+            target,
+            subpath,
+            bestMatch,
+            base,
+            pattern,
+            true,
+            conditions
+          );
+          if (resolved !== null) {
+            if (!pattern)
+              emitFolderMapDeprecation(bestMatch, packageJsonUrl, false, base);
+            return {resolved, exact: pattern}
+          }
+        }
+      }
+    }
+  }
+
+  throwImportNotDefined(name, packageJsonUrl, base);
+}
+
+/**
+ * @param {string} 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.
+  let i = -1;
+  while (++i < packageName.length) {
+    if (packageName[i] === '%' || packageName[i] === '\\') {
+      validPackageName = false;
+      break
+    }
+  }
+
+  if (!validPackageName) {
+    throw new ERR_INVALID_MODULE_SPECIFIER(
+      specifier,
+      'is not a valid package name',
+      fileURLToPath$2(base)
+    )
+  }
+
+  const packageSubpath =
+    '.' + (separatorIndex === -1 ? '' : specifier.slice(separatorIndex));
+
+  return {packageName, packageSubpath, isScoped}
+}
+
+/**
+ * @param {string} specifier
+ * @param {URL} base
+ * @param {Set<string>} conditions
+ * @returns {URL}
+ */
+function packageResolve(specifier, base, conditions) {
+  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
+      ).resolved
+    }
+  }
+
+  let packageJsonUrl = new URL$1(
+    './node_modules/' + packageName + '/package.json',
+    base
+  );
+  let packageJsonPath = fileURLToPath$2(packageJsonUrl);
+  /** @type {string} */
+  let lastPath;
+  do {
+    const stat = tryStatSync(packageJsonPath.slice(0, -13));
+    if (!stat.isDirectory()) {
+      lastPath = packageJsonPath;
+      packageJsonUrl = new URL$1(
+        (isScoped ? '../../../../node_modules/' : '../../../node_modules/') +
+          packageName +
+          '/package.json',
+        packageJsonUrl
+      );
+      packageJsonPath = fileURLToPath$2(packageJsonUrl);
+      continue
+    }
+
+    // Package match.
+    const packageConfig = getPackageConfig(packageJsonPath, specifier, base);
+    if (packageConfig.exports !== undefined && packageConfig.exports !== null)
+      return packageExportsResolve(
+        packageJsonUrl,
+        packageSubpath,
+        packageConfig,
+        base,
+        conditions
+      ).resolved
+    if (packageSubpath === '.')
+      return legacyMainResolve(packageJsonUrl, packageConfig, base)
+    return new URL$1(packageSubpath, packageJsonUrl)
+    // Cross-platform root check.
+  } while (packageJsonPath.length !== lastPath.length)
+
+  throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath$2(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]
+ * @returns {URL}
+ */
+function moduleResolve(specifier, base, conditions) {
+  // Order swapped from spec for minor perf gain.
+  // Ok since relative URLs cannot parse as URLs.
+  /** @type {URL} */
+  let resolved;
+
+  if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
+    resolved = new URL$1(specifier, base);
+  } else if (specifier[0] === '#') {
+({resolved} = packageImportsResolve(specifier, base, conditions));
+  } else {
+    try {
+      resolved = new URL$1(specifier);
+    } catch {
+      resolved = packageResolve(specifier, base, conditions);
+    }
+  }
+
+  return finalizeResolution(resolved, base)
+}
+
+const DEFAULT_CONDITIONS_SET = new Set(["node", "import"]);
+const DEFAULT_URL = pathToFileURL(process.cwd());
+const DEFAULT_EXTENSIONS = [".mjs", ".cjs", ".js", ".json"];
+const NOT_FOUND_ERRORS = new Set(["ERR_MODULE_NOT_FOUND", "ERR_UNSUPPORTED_DIR_IMPORT", "MODULE_NOT_FOUND"]);
+function _tryModuleResolve(id, url, conditions) {
+  try {
+    return moduleResolve(id, url, conditions);
+  } catch (err) {
+    if (!NOT_FOUND_ERRORS.has(err.code)) {
+      throw err;
+    }
+    return null;
+  }
+}
+function _resolve(id, opts = {}) {
+  if (/(node|data|http|https):/.test(id)) {
+    return id;
+  }
+  if (BUILTIN_MODULES.has(id)) {
+    return "node:" + id;
+  }
+  if (isAbsolute(id)) {
+    return id;
+  }
+  const conditionsSet = opts.conditions ? new Set(opts.conditions) : DEFAULT_CONDITIONS_SET;
+  const _urls = (Array.isArray(opts.url) ? opts.url : [opts.url]).filter(Boolean).map((u) => new URL(normalizeid(u.toString())));
+  if (!_urls.length) {
+    _urls.push(DEFAULT_URL);
+  }
+  const urls = [..._urls];
+  for (const url of _urls) {
+    if (url.protocol === "file:" && !url.pathname.includes("node_modules")) {
+      const newURL = new URL(url);
+      newURL.pathname += "/node_modules";
+      urls.push(newURL);
+    }
+  }
+  let resolved;
+  for (const url of urls) {
+    resolved = _tryModuleResolve(id, url, conditionsSet);
+    if (resolved) {
+      break;
+    }
+    for (const prefix of ["", "/index"]) {
+      for (const ext of opts.extensions || DEFAULT_EXTENSIONS) {
+        resolved = _tryModuleResolve(id + prefix + ext, url, conditionsSet);
+        if (resolved) {
+          break;
+        }
+      }
+      if (resolved) {
+        break;
+      }
+    }
+  }
+  if (!resolved) {
+    const err = new Error(`Cannot find module ${id} imported from ${urls.join(", ")}`);
+    err.code = "ERR_MODULE_NOT_FOUND";
+    throw err;
+  }
+  const realPath = realpathSync(fileURLToPath(resolved));
+  return pathToFileURL(realPath).toString();
+}
+function resolveSync(id, opts) {
+  return _resolve(id, opts);
+}
+function resolvePathSync(id, opts) {
+  return fileURLToPath(resolveSync(id, opts));
+}
+function resolvePath(id, opts) {
+  return pcall(resolvePathSync, id, opts);
+}
+
+const defaultFindOptions = {
+  startingFrom: ".",
+  rootPattern: /^node_modules$/,
+  test: (filePath) => {
+    try {
+      if (statSync(filePath).isFile()) {
+        return true;
+      }
+    } catch {
+    }
+    return null;
+  }
+};
+async function findNearestFile(filename, _options = {}) {
+  const options = { ...defaultFindOptions, ..._options };
+  const basePath = resolve$2(options.startingFrom);
+  const leadingSlash = basePath[0] === "/";
+  const segments = basePath.split("/").filter(Boolean);
+  if (leadingSlash) {
+    segments[0] = "/" + segments[0];
+  }
+  let root = segments.findIndex((r) => r.match(options.rootPattern));
+  if (root === -1)
+    root = 0;
+  for (let i = segments.length; i > root; i--) {
+    const filePath = join$1(...segments.slice(0, i), filename);
+    if (await options.test(filePath)) {
+      return filePath;
+    }
+  }
+  throw new Error(`Cannot find matching ${filename} in ${options.startingFrom} or parent directories`);
+}
+async function readPackageJSON(id, opts = {}) {
+  const resolvedPath = await resolvePackageJSON(id, opts);
+  const blob = await promises.readFile(resolvedPath, "utf-8");
+  return JSON.parse(blob);
+}
+async function resolvePackageJSON(id = process.cwd(), opts = {}) {
+  const resolvedPath = isAbsolute$1(id) ? id : await resolvePath(id, opts);
+  return findNearestFile("package.json", { startingFrom: resolvedPath });
 }
+
 const ESM_RE = /([\s;]|^)(import[\w,{}\s*]*from|import\s*['"*{]|export\b\s*(?:[*{]|default|type|function|const|var|let|async function)|import\.meta\b)/m;
-const BUILTIN_EXTENSIONS = /* @__PURE__ */ new Set([".mjs", ".cjs", ".node", ".wasm"]);
+const BUILTIN_EXTENSIONS = new Set([".mjs", ".cjs", ".node", ".wasm"]);
 function hasESMSyntax(code) {
   return ESM_RE.test(code);
 }
+const CJS_RE = /([\s;]|^)(module.exports\b|exports\.\w|require\s*\(|global\.\w)/m;
+function hasCJSSyntax(code) {
+  return CJS_RE.test(code);
+}
 const validNodeImportDefaults = {
   allowedProtocols: ["node", "file", "data"]
 };
 async function isValidNodeImport(id, _opts = {}) {
-  var _a;
-  if (isNodeBuiltin(id))
+  if (isNodeBuiltin(id)) {
     return true;
-  const opts = __spreadValues(__spreadValues({}, validNodeImportDefaults), _opts);
+  }
+  const opts = { ...validNodeImportDefaults, ..._opts };
   const proto = getProtocol(id);
-  if (proto && !((_a = opts.allowedProtocols) == null ? void 0 : _a.includes(proto)))
+  if (proto && !opts.allowedProtocols.includes(proto)) {
     return false;
-  if (proto === "data")
+  }
+  if (proto === "data") {
     return true;
+  }
   const resolvedPath = await resolvePath$1(id, opts);
-  const extension = extname$2(resolvedPath);
-  if (BUILTIN_EXTENSIONS.has(extension))
+  const extension = extname$1(resolvedPath);
+  if (BUILTIN_EXTENSIONS.has(extension)) {
     return true;
-  if (extension !== ".js")
+  }
+  if (extension !== ".js") {
     return false;
-  if (resolvedPath.match(/\.(\w+-)?esm?(-\w+)?\.js$/))
+  }
+  if (resolvedPath.match(/\.(\w+-)?esm?(-\w+)?\.js$/)) {
     return false;
+  }
   const pkg = await readPackageJSON(resolvedPath).catch(() => null);
-  if ((pkg == null ? void 0 : pkg.type) === "module")
+  if (pkg?.type === "module") {
     return true;
+  }
   const code = opts.code || await promises.readFile(resolvedPath, "utf-8").catch(() => null) || "";
   return hasCJSSyntax(code) || !hasESMSyntax(code);
 }
@@ -8255,18 +9227,21 @@ const stubRequests = {
 };
 async function interpretedImport(path, interpretDefault) {
   const mod = await import(path);
-  if (interpretDefault && "__esModule" in mod && "default" in mod) {
-    const defaultExport = mod.default;
-    if (!("default" in defaultExport)) {
-      Object.defineProperty(defaultExport, "default", {
-        enumerable: true,
-        configurable: true,
-        get() {
-          return defaultExport;
-        }
-      });
-    }
-    return defaultExport;
+  if (interpretDefault && "default" in mod) {
+    return new Proxy(mod, {
+      get(target, key, receiver) {
+        return Reflect.get(target, key, receiver) || Reflect.get(target.default, key, receiver);
+      },
+      set(target, key, value, receiver) {
+        return Reflect.set(target, key, value, receiver) || Reflect.set(target.default, key, value, receiver);
+      },
+      has(target, key) {
+        return Reflect.has(target, key) || Reflect.has(target.default, key);
+      },
+      deleteProperty(target, key) {
+        return Reflect.deleteProperty(target, key) || Reflect.deleteProperty(target.default, key);
+      }
+    });
   }
   return mod;
 }
@@ -8276,7 +9251,7 @@ async function executeInViteNode(options) {
   builtinModules.forEach((m) => externalCache.set(m, true));
   const result = [];
   for (const file of files)
-    result.push(await cachedRequest(`/@fs/${slash(resolve$3(file))}`, []));
+    result.push(await cachedRequest(`/@fs/${slash(resolve(file))}`, []));
   return result;
   async function directRequest(id, fsPath, callstack) {
     callstack = [...callstack, id];
@@ -8300,7 +9275,7 @@ ${[...callstack, dep].reverse().map((p) => `- ${p}`).join("\n")}`);
     const url = pathToFileURL(fsPath).href;
     const exports = {};
     setCache(fsPath, { code: transformed, exports });
-    const __filename = fileURLToPath(url);
+    const __filename = fileURLToPath$2(url);
     const moduleProxy = {
       set exports(value) {
         exportAll(exports, value);
@@ -8320,10 +9295,10 @@ ${[...callstack, dep].reverse().map((p) => `- ${p}`).join("\n")}`);
       exports,
       module: moduleProxy,
       __filename,
-      __dirname: dirname$3(__filename)
+      __dirname: dirname$2(__filename)
     };
-    const fn = vm.runInThisContext(`async (${Object.keys(context).join(",")})=>{${transformed}
-}`, {
+    const fn = vm.runInThisContext(`async (${Object.keys(context).join(",")})=>{{${transformed}
+}}`, {
       filename: fsPath,
       lineOffset: 0
     });
@@ -8340,7 +9315,7 @@ ${[...callstack, dep].reverse().map((p) => `- ${p}`).join("\n")}`);
     var _a, _b;
     const id = normalizeId(rawId);
     if (externalCache.get(id))
-      return interpretedImport(id, options.interpretDefault);
+      return interpretedImport(patchWindowsImportPath(id), options.interpretDefault);
     const fsPath = toFilePath(id, root);
     const importPath = patchWindowsImportPath(fsPath);
     if (!externalCache.has(importPath))
@@ -8385,10 +9360,10 @@ async function shouldExternalize(id, config) {
   return id.includes("/node_modules/") && await isValidNodeImport(id);
 }
 function toFilePath(id, root) {
-  let absolute = slash(id).startsWith("/@fs/") ? id.slice(4) : id.startsWith(dirname$3(root)) ? id : id.startsWith("/") ? slash(resolve$3(root, id.slice(1))) : id;
+  let absolute = slash(id).startsWith("/@fs/") ? id.slice(4) : id.startsWith(dirname$2(root)) ? id : id.startsWith("/") ? slash(resolve(root, id.slice(1))) : id;
   if (absolute.startsWith("//"))
     absolute = absolute.slice(1);
-  return isWindows && absolute.startsWith("/") ? fileURLToPath(pathToFileURL(absolute.slice(1)).href) : absolute;
+  return isWindows && absolute.startsWith("/") ? fileURLToPath$2(pathToFileURL(absolute.slice(1)).href) : absolute;
 }
 function matchExternalizePattern(id, patterns) {
   for (const ex of patterns) {
@@ -8405,6 +9380,8 @@ function matchExternalizePattern(id, patterns) {
 function patchWindowsImportPath(path) {
   if (path.match(/^\w:\\/))
     return `file:///${slash(path)}`;
+  else if (path.match(/^\w:\//))
+    return `file:///${path}`;
   else
     return path;
 }
@@ -8426,7 +9403,7 @@ async function startViteNode(ctx) {
   const { run: run2, collect: collect2 } = (await executeInViteNode({
     root: config.root,
     files: [
-      resolve$3(distDir, "entry.js")
+      resolve(distDir, "entry.js")
     ],
     fetch(id) {
       return process.__vitest_worker__.rpc("fetch", id);