vitest 1.5.3 → 2.0.0-beta.1

package/dist/vendor/{cli-api.AmIc1Dmz.js → cli-api.DTeni0Qq.js}

@@ -1,17 +1,17 @@
-import { dirname, resolve, relative, normalize, join, basename, toNamespacedPath, isAbsolute } from 'pathe';
-import { A as API_PATH, d as defaultPort, e as extraInlineDeps, a as defaultBrowserPort, b as defaultInspectPort, E as EXIT_CODE_RESTART, w as workspacesFiles, C as CONFIG_NAMES, c as configFiles } from './constants.5J7I254_.js';
-import { g as getCoverageProvider, C as CoverageProviderMap } from './coverage.E7sG1b3r.js';
-import { g as getEnvPackageName } from './index.GVFv9dZ0.js';
-import { isFileServingAllowed, searchForWorkspaceRoot, version as version$1, createServer, mergeConfig } from 'vite';
-import path$8 from 'node:path';
-import url, { fileURLToPath } from 'node:url';
+import { dirname, join, resolve, relative, isAbsolute, normalize, basename, toNamespacedPath } from 'pathe';
+import { A as API_PATH, d as defaultPort, e as extraInlineDeps, a as defaultBrowserPort, b as defaultInspectPort, E as EXIT_CODE_RESTART, w as workspacesFiles, C as CONFIG_NAMES, c as configFiles } from './constants.5SOfHUj0.js';
+import { g as getCoverageProvider, C as CoverageProviderMap } from './coverage.ChSqD-qS.js';
+import { g as getEnvPackageName } from './index.DeR1hhfY.js';
+import { isFileServingAllowed, searchForWorkspaceRoot, version, createServer, mergeConfig } from 'vite';
+import path$8, { win32 } from 'node:path';
+import url, { fileURLToPath as fileURLToPath$1, pathToFileURL as pathToFileURL$1, URL as URL$2 } from 'node:url';
 import process$1 from 'node:process';
-import fs$8, { promises, existsSync, readFileSync } from 'node:fs';
+import fs$8, { promises as promises$1, existsSync, statSync as statSync$1, realpathSync, readFileSync } from 'node:fs';
 import { MessageChannel, isMainThread } from 'node:worker_threads';
-import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers.jjO7Zipk.js';
+import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
 import require$$0 from 'os';
 import p from 'path';
-import { a as micromatch_1, m as mm } from './index.xL8XjTLv.js';
+import { a as micromatch_1, m as mm } from './index.DP-km6lF.js';
 import require$$0$1 from 'stream';
 import require$$0$3 from 'events';
 import require$$0$2 from 'fs';
@@ -19,12 +19,13 @@ import c from 'picocolors';
 import { ViteNodeRunner } from 'vite-node/client';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { ViteNodeServer } from 'vite-node/server';
-import { hasFailed, getTests } from '@vitest/runner/utils';
-import { n as noop$2, b as isPrimitive, c as groupBy, A as AggregateErrorPonyfill, a as slash$1, t as toArray, d as deepMerge, w as wildcardPatternToRegExp, e as stdout } from './base.Xt0Omgh7.js';
+import { v as version$1 } from './cac.DzKZaJu2.js';
+import { hasFailed, getTasks, getTests } from '@vitest/runner/utils';
+import { n as noop$2, b as isPrimitive, c as groupBy, A as AggregateErrorPonyfill, a as slash$1, t as toArray, d as deepMerge, e as nanoid, w as wildcardPatternToRegExp, f as stdout } from './base._gnK9Slw.js';
 import { createDefer, toArray as toArray$1, notNullish } from '@vitest/utils';
-import { a as isWindows } from './env.AtSIuHFg.js';
+import { a as isWindows } from './env.bmJgw1qP.js';
 import { rootDir } from '../path.js';
-import { c as createBirpc } from './index.8bPxjt7g.js';
+import { c as createBirpc } from './index.BpSiYbpB.js';
 import require$$0$4 from 'zlib';
 import require$$0$5 from 'buffer';
 import require$$1 from 'crypto';
@@ -36,22 +37,21 @@ import require$$7 from 'url';
 import { parseErrorStacktrace } from '@vitest/utils/source-map';
 import v8 from 'node:v8';
 import * as nodeos from 'node:os';
-import nodeos__default from 'node:os';
+import nodeos__default, { tmpdir } from 'node:os';
 import EventEmitter$2 from 'node:events';
 import Tinypool$1, { Tinypool } from 'tinypool';
-import { w as wrapSerializableConfig, f as Typechecker, R as ReportersMap, e as BenchmarkReportsMap, g as RandomSequencer, B as BaseSequencer, h as generateCodeFrame, i as highlightCode, L as Logger } from './index.X7lgIMc_.js';
-import { resolveModule, isPackageExists } from 'local-pkg';
-import { isCI, provider as provider$1 } from 'std-env';
+import { w as wrapSerializableConfig, f as Typechecker, R as ReportersMap, e as BenchmarkReportsMap, g as RandomSequencer, B as BaseSequencer, h as findNodeAround, i as generateCodeFrame, j as highlightCode, L as Logger } from './index.CRxYS9H3.js';
 import crypto, { createHash as createHash$2 } from 'node:crypto';
-import { v as version } from './cac.RDd_SGOd.js';
+import { mkdir, writeFile, rm } from 'node:fs/promises';
+import { builtinModules, createRequire } from 'node:module';
+import assert from 'node:assert';
+import { format as format$2, inspect } from 'node:util';
+import { isCI, provider as provider$1 } from 'std-env';
 import { normalizeRequestId, cleanUrl } from 'vite-node/utils';
 import MagicString from 'magic-string';
-import { findNodeAround } from 'acorn-walk';
 import { esmWalker } from '@vitest/utils/ast';
-import { stripLiteral } from 'strip-literal';
-import { d as divider, s as stripAnsi } from './utils.VYmeMh-u.js';
-import { createRequire } from 'node:module';
-import { a as removeUndefinedValues } from './index.SMVOaj7F.js';
+import { d as divider, s as stripAnsi } from './utils.D5gGkwyH.js';
+import { a as removeUndefinedValues } from './index._7XLd8Kd.js';
 import readline from 'node:readline';
 import require$$0$6 from 'readline';
 
@@ -314,7 +314,7 @@ function checkType(type) {
 
 const matchType = (type, stat) => stat[typeMappings[type]]();
 
-const toPath$1 = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
+const toPath$1 = urlOrPath => urlOrPath instanceof URL ? fileURLToPath$1(urlOrPath) : urlOrPath;
 
 async function locatePath(
 	paths,
@@ -329,7 +329,7 @@ async function locatePath(
 	checkType(type);
 	cwd = toPath$1(cwd);
 
-	const statFunction = allowSymlinks ? promises.stat : promises.lstat;
+	const statFunction = allowSymlinks ? promises$1.stat : promises$1.lstat;
 
 	return pLocate(paths, async path_ => {
 		try {
@@ -341,7 +341,7 @@ async function locatePath(
 	}, {concurrency, preserveOrder});
 }
 
-const toPath = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
+const toPath = urlOrPath => urlOrPath instanceof URL ? fileURLToPath$1(urlOrPath) : urlOrPath;
 
 const findUpStop = Symbol('findUpStop');
 
@@ -1248,7 +1248,7 @@ var async$2 = {};
 
 Object.defineProperty(async$2, "__esModule", { value: true });
 async$2.read = void 0;
-function read$3(path, settings, callback) {
+function read$4(path, settings, callback) {
     settings.fs.lstat(path, (lstatError, lstat) => {
         if (lstatError !== null) {
             callFailureCallback$2(callback, lstatError);
@@ -1274,7 +1274,7 @@ function read$3(path, settings, callback) {
         });
     });
 }
-async$2.read = read$3;
+async$2.read = read$4;
 function callFailureCallback$2(callback, error) {
     callback(error);
 }
@@ -1286,7 +1286,7 @@ var sync$7 = {};
 
 Object.defineProperty(sync$7, "__esModule", { value: true });
 sync$7.read = void 0;
-function read$2(path, settings) {
+function read$3(path, settings) {
     const lstat = settings.fs.lstatSync(path);
     if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
         return lstat;
@@ -1305,7 +1305,7 @@ function read$2(path, settings) {
         throw error;
     }
 }
-sync$7.read = read$2;
+sync$7.read = read$3;
 
 var settings$3 = {};
 
@@ -1374,12 +1374,12 @@ function getSettings$2(settingsOrOptions = {}) {
 
 /*! queue-microtask. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
 
-let promise$1;
+let promise;
 
 var queueMicrotask_1 = typeof queueMicrotask === 'function'
   ? queueMicrotask.bind(typeof window !== 'undefined' ? window : commonjsGlobal)
   // reuse resolved promise, and allocate it lazily
-  : cb => (promise$1 || (promise$1 = Promise.resolve()))
+  : cb => (promise || (promise = Promise.resolve()))
     .then(cb)
     .catch(err => setTimeout(() => { throw err }, 0));
 
@@ -1505,14 +1505,14 @@ const rpl = runParallel_1;
 const constants_1$1 = constants$1;
 const utils$8 = utils$9;
 const common$5 = common$6;
-function read$1(directory, settings, callback) {
+function read$2(directory, settings, callback) {
     if (!settings.stats && constants_1$1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
         readdirWithFileTypes$1(directory, settings, callback);
         return;
     }
     readdir$1(directory, settings, callback);
 }
-async$3.read = read$1;
+async$3.read = read$2;
 function readdirWithFileTypes$1(directory, settings, callback) {
     settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => {
         if (readdirError !== null) {
@@ -1610,13 +1610,13 @@ const fsStat$4 = out$1;
 const constants_1 = constants$1;
 const utils$7 = utils$9;
 const common$4 = common$6;
-function read(directory, settings) {
+function read$1(directory, settings) {
     if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
         return readdirWithFileTypes(directory, settings);
     }
     return readdir(directory, settings);
 }
-sync$5.read = read;
+sync$5.read = read$1;
 function readdirWithFileTypes(directory, settings) {
     const dirents = settings.fs.readdirSync(directory, { withFileTypes: true });
     return dirents.map((dirent) => {
@@ -2744,9 +2744,9 @@ class EntryFilter {
 }
 entry$1.default = EntryFilter;
 
-var error$1 = {};
+var error = {};
 
-Object.defineProperty(error$1, "__esModule", { value: true });
+Object.defineProperty(error, "__esModule", { value: true });
 const utils$2 = utils$b;
 class ErrorFilter {
     constructor(_settings) {
@@ -2759,7 +2759,7 @@ class ErrorFilter {
         return utils$2.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
     }
 }
-error$1.default = ErrorFilter;
+error.default = ErrorFilter;
 
 var entry = {};
 
@@ -2793,7 +2793,7 @@ Object.defineProperty(provider, "__esModule", { value: true });
 const path = p;
 const deep_1 = deep;
 const entry_1 = entry$1;
-const error_1 = error$1;
+const error_1 = error;
 const entry_2 = entry;
 class Provider {
     constructor(_settings) {
@@ -3128,7 +3128,9 @@ var out = FastGlob;
 
 var fg = /*@__PURE__*/getDefaultExportFromCjs(out);
 
-/*! (c) 2020 Andrea Giammarchi */
+/// <reference types="../types/index.d.ts" />
+
+// (c) 2020-present Andrea Giammarchi
 
 const {parse: $parse, stringify: $stringify} = JSON;
 const {keys: keys$1} = Object;
@@ -3180,6 +3182,12 @@ const set = (known, input, value) => {
   return index;
 };
 
+/**
+ * Converts a specialized flatted string into a JS value.
+ * @param {string} text
+ * @param {(this: any, key: string, value: any) => any} [reviver]
+ * @returns {any}
+ */
 const parse$3 = (text, reviver) => {
   const input = $parse(text, Primitives).map(primitives);
   const value = input[0];
@@ -3190,6 +3198,13 @@ const parse$3 = (text, reviver) => {
   return $.call({'': tmp}, '', tmp);
 };
 
+/**
+ * Converts a JS value into a specialized flatted string.
+ * @param {any} value
+ * @param {((this: any, key: string, value: any) => any) | (string | number)[] | null | undefined} [replacer]
+ * @param {string | number | undefined} [space]
+ * @returns {string}
+ */
 const stringify = (value, replacer, space) => {
   const $ = replacer && typeof replacer === object ?
             (k, v) => (k === '' || -1 < replacer.indexOf(k) ? v : void 0) :
@@ -4083,13 +4098,6 @@ const { concat, toArrayBuffer, unmask } = bufferUtilExports;
 const { isValidStatusCode: isValidStatusCode$1, isValidUTF8 } = validationExports;
 
 const FastBuffer = Buffer[Symbol.species];
-const promise = Promise.resolve();
-
-//
-// `queueMicrotask()` is not available in Node.js < 11.
-//
-const queueTask =
-  typeof queueMicrotask === 'function' ? queueMicrotask : queueMicrotaskShim;
 
 const GET_INFO = 0;
 const GET_PAYLOAD_LENGTH_16 = 1;
@@ -4097,7 +4105,7 @@ const GET_PAYLOAD_LENGTH_64 = 2;
 const GET_MASK = 3;
 const GET_DATA = 4;
 const INFLATING = 5;
-const WAIT_MICROTASK = 6;
+const DEFER_EVENT = 6;
 
 /**
  * HyBi Receiver implementation.
@@ -4109,6 +4117,9 @@ let Receiver$1 = class Receiver extends Writable {
    * Creates a Receiver instance.
    *
    * @param {Object} [options] Options object
+   * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
+   *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+   *     multiple times in the same tick
    * @param {String} [options.binaryType=nodebuffer] The type for binary data
    * @param {Object} [options.extensions] An object containing the negotiated
    *     extensions
@@ -4121,6 +4132,10 @@ let Receiver$1 = class Receiver extends Writable {
   constructor(options = {}) {
     super();
 
+    this._allowSynchronousEvents =
+      options.allowSynchronousEvents !== undefined
+        ? options.allowSynchronousEvents
+        : true;
     this._binaryType = options.binaryType || BINARY_TYPES$1[0];
     this._extensions = options.extensions || {};
     this._isServer = !!options.isServer;
@@ -4143,8 +4158,9 @@ let Receiver$1 = class Receiver extends Writable {
     this._messageLength = 0;
     this._fragments = [];
 
-    this._state = GET_INFO;
+    this._errored = false;
     this._loop = false;
+    this._state = GET_INFO;
   }
 
   /**
@@ -4216,53 +4232,42 @@ let Receiver$1 = class Receiver extends Writable {
    * @private
    */
   startLoop(cb) {
-    let err;
     this._loop = true;
 
     do {
       switch (this._state) {
         case GET_INFO:
-          err = this.getInfo();
+          this.getInfo(cb);
           break;
         case GET_PAYLOAD_LENGTH_16:
-          err = this.getPayloadLength16();
+          this.getPayloadLength16(cb);
           break;
         case GET_PAYLOAD_LENGTH_64:
-          err = this.getPayloadLength64();
+          this.getPayloadLength64(cb);
           break;
         case GET_MASK:
           this.getMask();
           break;
         case GET_DATA:
-          err = this.getData(cb);
+          this.getData(cb);
           break;
         case INFLATING:
+        case DEFER_EVENT:
           this._loop = false;
           return;
-        default:
-          //
-          // `WAIT_MICROTASK`.
-          //
-          this._loop = false;
-
-          queueTask(() => {
-            this._state = GET_INFO;
-            this.startLoop(cb);
-          });
-          return;
       }
     } while (this._loop);
 
-    cb(err);
+    if (!this._errored) cb();
   }
 
   /**
    * Reads the first two bytes of a frame.
    *
-   * @return {(RangeError|undefined)} A possible error
+   * @param {Function} cb Callback
    * @private
    */
-  getInfo() {
+  getInfo(cb) {
     if (this._bufferedBytes < 2) {
       this._loop = false;
       return;
@@ -4271,27 +4276,31 @@ let Receiver$1 = class Receiver extends Writable {
     const buf = this.consume(2);
 
     if ((buf[0] & 0x30) !== 0x00) {
-      this._loop = false;
-      return error(
+      const error = this.createError(
         RangeError,
         'RSV2 and RSV3 must be clear',
         true,
         1002,
         'WS_ERR_UNEXPECTED_RSV_2_3'
       );
+
+      cb(error);
+      return;
     }
 
     const compressed = (buf[0] & 0x40) === 0x40;
 
     if (compressed && !this._extensions[PerMessageDeflate$3.extensionName]) {
-      this._loop = false;
-      return error(
+      const error = this.createError(
         RangeError,
         'RSV1 must be clear',
         true,
         1002,
         'WS_ERR_UNEXPECTED_RSV_1'
       );
+
+      cb(error);
+      return;
     }
 
     this._fin = (buf[0] & 0x80) === 0x80;
@@ -4300,86 +4309,100 @@ let Receiver$1 = class Receiver extends Writable {
 
     if (this._opcode === 0x00) {
       if (compressed) {
-        this._loop = false;
-        return error(
+        const error = this.createError(
           RangeError,
           'RSV1 must be clear',
           true,
           1002,
           'WS_ERR_UNEXPECTED_RSV_1'
         );
+
+        cb(error);
+        return;
       }
 
       if (!this._fragmented) {
-        this._loop = false;
-        return error(
+        const error = this.createError(
           RangeError,
           'invalid opcode 0',
           true,
           1002,
           'WS_ERR_INVALID_OPCODE'
         );
+
+        cb(error);
+        return;
       }
 
       this._opcode = this._fragmented;
     } else if (this._opcode === 0x01 || this._opcode === 0x02) {
       if (this._fragmented) {
-        this._loop = false;
-        return error(
+        const error = this.createError(
           RangeError,
           `invalid opcode ${this._opcode}`,
           true,
           1002,
           'WS_ERR_INVALID_OPCODE'
         );
+
+        cb(error);
+        return;
       }
 
       this._compressed = compressed;
     } else if (this._opcode > 0x07 && this._opcode < 0x0b) {
       if (!this._fin) {
-        this._loop = false;
-        return error(
+        const error = this.createError(
           RangeError,
           'FIN must be set',
           true,
           1002,
           'WS_ERR_EXPECTED_FIN'
         );
+
+        cb(error);
+        return;
       }
 
       if (compressed) {
-        this._loop = false;
-        return error(
+        const error = this.createError(
           RangeError,
           'RSV1 must be clear',
           true,
           1002,
           'WS_ERR_UNEXPECTED_RSV_1'
         );
+
+        cb(error);
+        return;
       }
 
       if (
         this._payloadLength > 0x7d ||
         (this._opcode === 0x08 && this._payloadLength === 1)
       ) {
-        this._loop = false;
-        return error(
+        const error = this.createError(
           RangeError,
           `invalid payload length ${this._payloadLength}`,
           true,
           1002,
           'WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH'
         );
+
+        cb(error);
+        return;
       }
     } else {
-      this._loop = false;
-      return error(
+      const error = this.createError(
         RangeError,
         `invalid opcode ${this._opcode}`,
         true,
         1002,
         'WS_ERR_INVALID_OPCODE'
       );
+
+      cb(error);
+      return;
     }
 
     if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
@@ -4387,54 +4410,58 @@ let Receiver$1 = class Receiver extends Writable {
 
     if (this._isServer) {
       if (!this._masked) {
-        this._loop = false;
-        return error(
+        const error = this.createError(
           RangeError,
           'MASK must be set',
           true,
           1002,
           'WS_ERR_EXPECTED_MASK'
         );
+
+        cb(error);
+        return;
       }
     } else if (this._masked) {
-      this._loop = false;
-      return error(
+      const error = this.createError(
         RangeError,
         'MASK must be clear',
         true,
         1002,
         'WS_ERR_UNEXPECTED_MASK'
       );
+
+      cb(error);
+      return;
     }
 
     if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
     else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
-    else return this.haveLength();
+    else this.haveLength(cb);
   }
 
   /**
    * Gets extended payload length (7+16).
    *
-   * @return {(RangeError|undefined)} A possible error
+   * @param {Function} cb Callback
    * @private
    */
-  getPayloadLength16() {
+  getPayloadLength16(cb) {
     if (this._bufferedBytes < 2) {
       this._loop = false;
       return;
     }
 
     this._payloadLength = this.consume(2).readUInt16BE(0);
-    return this.haveLength();
+    this.haveLength(cb);
   }
 
   /**
    * Gets extended payload length (7+64).
    *
-   * @return {(RangeError|undefined)} A possible error
+   * @param {Function} cb Callback
    * @private
    */
-  getPayloadLength64() {
+  getPayloadLength64(cb) {
     if (this._bufferedBytes < 8) {
       this._loop = false;
       return;
@@ -4448,38 +4475,42 @@ let Receiver$1 = class Receiver extends Writable {
     // if payload length is greater than this number.
     //
     if (num > Math.pow(2, 53 - 32) - 1) {
-      this._loop = false;
-      return error(
+      const error = this.createError(
         RangeError,
         'Unsupported WebSocket frame: payload length > 2^53 - 1',
         false,
         1009,
         'WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH'
       );
+
+      cb(error);
+      return;
     }
 
     this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
-    return this.haveLength();
+    this.haveLength(cb);
   }
 
   /**
    * Payload length has been read.
    *
-   * @return {(RangeError|undefined)} A possible error
+   * @param {Function} cb Callback
    * @private
    */
-  haveLength() {
+  haveLength(cb) {
     if (this._payloadLength && this._opcode < 0x08) {
       this._totalPayloadLength += this._payloadLength;
       if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
-        this._loop = false;
-        return error(
+        const error = this.createError(
           RangeError,
           'Max payload size exceeded',
           false,
           1009,
           'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
         );
+
+        cb(error);
+        return;
       }
     }
 
@@ -4506,7 +4537,6 @@ let Receiver$1 = class Receiver extends Writable {
    * Reads data bytes.
    *
    * @param {Function} cb Callback
-   * @return {(Error|RangeError|undefined)} A possible error
    * @private
    */
   getData(cb) {
@@ -4528,7 +4558,10 @@ let Receiver$1 = class Receiver extends Writable {
       }
     }
 
-    if (this._opcode > 0x07) return this.controlMessage(data);
+    if (this._opcode > 0x07) {
+      this.controlMessage(data, cb);
+      return;
+    }
 
     if (this._compressed) {
       this._state = INFLATING;
@@ -4545,7 +4578,7 @@ let Receiver$1 = class Receiver extends Writable {
       this._fragments.push(data);
     }
 
-    return this.dataMessage();
+    this.dataMessage(cb);
   }
 
   /**
@@ -4564,74 +4597,96 @@ let Receiver$1 = class Receiver extends Writable {
       if (buf.length) {
         this._messageLength += buf.length;
         if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
-          return cb(
-            error(
-              RangeError,
-              'Max payload size exceeded',
-              false,
-              1009,
-              'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
-            )
+          const error = this.createError(
+            RangeError,
+            'Max payload size exceeded',
+            false,
+            1009,
+            'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
           );
+
+          cb(error);
+          return;
         }
 
         this._fragments.push(buf);
       }
 
-      const er = this.dataMessage();
-      if (er) return cb(er);
-
-      this.startLoop(cb);
+      this.dataMessage(cb);
+      if (this._state === GET_INFO) this.startLoop(cb);
     });
   }
 
   /**
    * Handles a data message.
    *
-   * @return {(Error|undefined)} A possible error
+   * @param {Function} cb Callback
    * @private
    */
-  dataMessage() {
-    if (this._fin) {
-      const messageLength = this._messageLength;
-      const fragments = this._fragments;
-
-      this._totalPayloadLength = 0;
-      this._messageLength = 0;
-      this._fragmented = 0;
-      this._fragments = [];
-
-      if (this._opcode === 2) {
-        let data;
-
-        if (this._binaryType === 'nodebuffer') {
-          data = concat(fragments, messageLength);
-        } else if (this._binaryType === 'arraybuffer') {
-          data = toArrayBuffer(concat(fragments, messageLength));
-        } else {
-          data = fragments;
-        }
+  dataMessage(cb) {
+    if (!this._fin) {
+      this._state = GET_INFO;
+      return;
+    }
+
+    const messageLength = this._messageLength;
+    const fragments = this._fragments;
+
+    this._totalPayloadLength = 0;
+    this._messageLength = 0;
+    this._fragmented = 0;
+    this._fragments = [];
+
+    if (this._opcode === 2) {
+      let data;
 
+      if (this._binaryType === 'nodebuffer') {
+        data = concat(fragments, messageLength);
+      } else if (this._binaryType === 'arraybuffer') {
+        data = toArrayBuffer(concat(fragments, messageLength));
+      } else {
+        data = fragments;
+      }
+
+      if (this._allowSynchronousEvents) {
         this.emit('message', data, true);
+        this._state = GET_INFO;
       } else {
-        const buf = concat(fragments, messageLength);
+        this._state = DEFER_EVENT;
+        setImmediate(() => {
+          this.emit('message', data, true);
+          this._state = GET_INFO;
+          this.startLoop(cb);
+        });
+      }
+    } else {
+      const buf = concat(fragments, messageLength);
 
-        if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
-          this._loop = false;
-          return error(
-            Error,
-            'invalid UTF-8 sequence',
-            true,
-            1007,
-            'WS_ERR_INVALID_UTF8'
-          );
-        }
+      if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+        const error = this.createError(
+          Error,
+          'invalid UTF-8 sequence',
+          true,
+          1007,
+          'WS_ERR_INVALID_UTF8'
+        );
+
+        cb(error);
+        return;
+      }
 
+      if (this._state === INFLATING || this._allowSynchronousEvents) {
         this.emit('message', buf, false);
+        this._state = GET_INFO;
+      } else {
+        this._state = DEFER_EVENT;
+        setImmediate(() => {
+          this.emit('message', buf, false);
+          this._state = GET_INFO;
+          this.startLoop(cb);
+        });
       }
     }
-
-    this._state = WAIT_MICROTASK;
   }
 
   /**
@@ -4641,26 +4696,26 @@ let Receiver$1 = class Receiver extends Writable {
    * @return {(Error|RangeError|undefined)} A possible error
    * @private
    */
-  controlMessage(data) {
+  controlMessage(data, cb) {
     if (this._opcode === 0x08) {
-      this._loop = false;
-
       if (data.length === 0) {
+        this._loop = false;
         this.emit('conclude', 1005, EMPTY_BUFFER$2);
         this.end();
-
-        this._state = GET_INFO;
       } else {
         const code = data.readUInt16BE(0);
 
         if (!isValidStatusCode$1(code)) {
-          return error(
+          const error = this.createError(
             RangeError,
             `invalid status code ${code}`,
             true,
             1002,
             'WS_ERR_INVALID_CLOSE_CODE'
           );
+
+          cb(error);
+          return;
         }
 
         const buf = new FastBuffer(
@@ -4670,83 +4725,68 @@ let Receiver$1 = class Receiver extends Writable {
         );
 
         if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
-          return error(
+          const error = this.createError(
             Error,
             'invalid UTF-8 sequence',
             true,
             1007,
             'WS_ERR_INVALID_UTF8'
           );
+
+          cb(error);
+          return;
         }
 
+        this._loop = false;
         this.emit('conclude', code, buf);
         this.end();
-
-        this._state = GET_INFO;
       }
-    } else if (this._opcode === 0x09) {
-      this.emit('ping', data);
-      this._state = WAIT_MICROTASK;
+
+      this._state = GET_INFO;
+      return;
+    }
+
+    if (this._allowSynchronousEvents) {
+      this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);
+      this._state = GET_INFO;
     } else {
-      this.emit('pong', data);
-      this._state = WAIT_MICROTASK;
+      this._state = DEFER_EVENT;
+      setImmediate(() => {
+        this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);
+        this._state = GET_INFO;
+        this.startLoop(cb);
+      });
     }
   }
-};
-
-var receiver = Receiver$1;
 
-/**
- * Builds an error object.
- *
- * @param {function(new:Error|RangeError)} ErrorCtor The error constructor
- * @param {String} message The error message
- * @param {Boolean} prefix Specifies whether or not to add a default prefix to
- *     `message`
- * @param {Number} statusCode The status code
- * @param {String} errorCode The exposed error code
- * @return {(Error|RangeError)} The error
- * @private
- */
-function error(ErrorCtor, message, prefix, statusCode, errorCode) {
-  const err = new ErrorCtor(
-    prefix ? `Invalid WebSocket frame: ${message}` : message
-  );
-
-  Error.captureStackTrace(err, error);
-  err.code = errorCode;
-  err[kStatusCode$1] = statusCode;
-  return err;
-}
+  /**
+   * Builds an error object.
+   *
+   * @param {function(new:Error|RangeError)} ErrorCtor The error constructor
+   * @param {String} message The error message
+   * @param {Boolean} prefix Specifies whether or not to add a default prefix to
+   *     `message`
+   * @param {Number} statusCode The status code
+   * @param {String} errorCode The exposed error code
+   * @return {(Error|RangeError)} The error
+   * @private
+   */
+  createError(ErrorCtor, message, prefix, statusCode, errorCode) {
+    this._loop = false;
+    this._errored = true;
 
-/**
- * A shim for `queueMicrotask()`.
- *
- * @param {Function} cb Callback
- */
-function queueMicrotaskShim(cb) {
-  promise.then(cb).catch(throwErrorNextTick);
-}
+    const err = new ErrorCtor(
+      prefix ? `Invalid WebSocket frame: ${message}` : message
+    );
 
-/**
- * Throws an error.
- *
- * @param {Error} err The error to throw
- * @private
- */
-function throwError(err) {
-  throw err;
-}
+    Error.captureStackTrace(err, this.createError);
+    err.code = errorCode;
+    err[kStatusCode$1] = statusCode;
+    return err;
+  }
+};
 
-/**
- * Throws an error in the next tick.
- *
- * @param {Error} err The error to throw
- * @private
- */
-function throwErrorNextTick(err) {
-  process.nextTick(throwError, err);
-}
+var receiver = Receiver$1;
 
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex" }] */
 const { randomFillSync } = require$$1;
@@ -5715,7 +5755,7 @@ function format$1(extensions) {
 
 var extension$1 = { format: format$1, parse: parse$2 };
 
-/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex|Readable$" }] */
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex|Readable$", "caughtErrors": "none" }] */
 
 const EventEmitter$1 = require$$0$3;
 const https = require$$1$1;
@@ -5798,6 +5838,7 @@ let WebSocket$1 = class WebSocket extends EventEmitter$1 {
 
       initAsClient(this, address, protocols, options);
     } else {
+      this._autoPong = options.autoPong;
       this._isServer = true;
     }
   }
@@ -5906,6 +5947,9 @@ let WebSocket$1 = class WebSocket extends EventEmitter$1 {
    * @param {Duplex} socket The network socket between the server and client
    * @param {Buffer} head The first packet of the upgraded stream
    * @param {Object} options Options object
+   * @param {Boolean} [options.allowSynchronousEvents=false] Specifies whether
+   *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+   *     multiple times in the same tick
    * @param {Function} [options.generateMask] The function used to generate the
    *     masking key
    * @param {Number} [options.maxPayload=0] The maximum allowed message size
@@ -5915,6 +5959,7 @@ let WebSocket$1 = class WebSocket extends EventEmitter$1 {
    */
   setSocket(socket, head, options) {
     const receiver = new Receiver({
+      allowSynchronousEvents: options.allowSynchronousEvents,
       binaryType: this.binaryType,
       extensions: this._extensions,
       isServer: this._isServer,
@@ -6332,6 +6377,13 @@ var websocket = WebSocket$1;
  * @param {(String|URL)} address The URL to which to connect
  * @param {Array} protocols The subprotocols
  * @param {Object} [options] Connection options
+ * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether any
+ *     of the `'message'`, `'ping'`, and `'pong'` events can be emitted multiple
+ *     times in the same tick
+ * @param {Boolean} [options.autoPong=true] Specifies whether or not to
+ *     automatically send a pong in response to a ping
+ * @param {Function} [options.finishRequest] A function which can be used to
+ *     customize the headers of each http request before it is sent
  * @param {Boolean} [options.followRedirects=false] Whether or not to follow
  *     redirects
  * @param {Function} [options.generateMask] The function used to generate the
@@ -6354,6 +6406,8 @@ var websocket = WebSocket$1;
  */
 function initAsClient(websocket, address, protocols, options) {
   const opts = {
+    allowSynchronousEvents: true,
+    autoPong: true,
     protocolVersion: protocolVersions[1],
     maxPayload: 100 * 1024 * 1024,
     skipUTF8Validation: false,
@@ -6361,7 +6415,6 @@ function initAsClient(websocket, address, protocols, options) {
     followRedirects: false,
     maxRedirects: 10,
     ...options,
-    createConnection: undefined,
     socketPath: undefined,
     hostname: undefined,
     protocol: undefined,
@@ -6372,6 +6425,8 @@ function initAsClient(websocket, address, protocols, options) {
     port: undefined
   };
 
+  websocket._autoPong = opts.autoPong;
+
   if (!protocolVersions.includes(opts.protocolVersion)) {
     throw new RangeError(
       `Unsupported protocol version: ${opts.protocolVersion} ` +
@@ -6430,7 +6485,8 @@ function initAsClient(websocket, address, protocols, options) {
   const protocolSet = new Set();
   let perMessageDeflate;
 
-  opts.createConnection = isSecure ? tlsConnect : netConnect;
+  opts.createConnection =
+    opts.createConnection || (isSecure ? tlsConnect : netConnect);
   opts.defaultPort = opts.defaultPort || defaultPort;
   opts.port = parsedUrl.port || defaultPort;
   opts.host = parsedUrl.hostname.startsWith('[')
@@ -6520,8 +6576,8 @@ function initAsClient(websocket, address, protocols, options) {
           ? opts.socketPath === websocket._originalHostOrSocketPath
           : false
         : websocket._originalIpc
-        ? false
-        : parsedUrl.host === websocket._originalHostOrSocketPath;
+          ? false
+          : parsedUrl.host === websocket._originalHostOrSocketPath;
 
       if (!isSameHost || (websocket._originalSecure && !isSecure)) {
         //
@@ -6705,6 +6761,7 @@ function initAsClient(websocket, address, protocols, options) {
     }
 
     websocket.setSocket(socket, head, {
+      allowSynchronousEvents: opts.allowSynchronousEvents,
       generateMask: opts.generateMask,
       maxPayload: opts.maxPayload,
       skipUTF8Validation: opts.skipUTF8Validation
@@ -6915,7 +6972,7 @@ function receiverOnMessage(data, isBinary) {
 function receiverOnPing(data) {
   const websocket = this[kWebSocket$1];
 
-  websocket.pong(data, !websocket._isServer, NOOP);
+  if (websocket._autoPong) websocket.pong(data, !this._isServer, NOOP);
   websocket.emit('ping', data);
 }
 
@@ -7093,7 +7150,7 @@ function parse(header) {
 
 var subprotocol$1 = { parse };
 
-/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$" }] */
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$", "caughtErrors": "none" }] */
 
 const EventEmitter = require$$0$3;
 const http = require$$2;
@@ -7121,6 +7178,11 @@ class WebSocketServer extends EventEmitter {
    * Create a `WebSocketServer` instance.
    *
    * @param {Object} options Configuration options
+   * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
+   *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+   *     multiple times in the same tick
+   * @param {Boolean} [options.autoPong=true] Specifies whether or not to
+   *     automatically send a pong in response to a ping
    * @param {Number} [options.backlog=511] The maximum length of the queue of
    *     pending connections
    * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
@@ -7147,6 +7209,8 @@ class WebSocketServer extends EventEmitter {
     super();
 
     options = {
+      allowSynchronousEvents: true,
+      autoPong: true,
       maxPayload: 100 * 1024 * 1024,
       skipUTF8Validation: false,
       perMessageDeflate: false,
@@ -7467,7 +7531,7 @@ class WebSocketServer extends EventEmitter {
       `Sec-WebSocket-Accept: ${digest}`
     ];
 
-    const ws = new this.options.WebSocket(null);
+    const ws = new this.options.WebSocket(null, undefined, this.options);
 
     if (protocols.size) {
       //
@@ -7501,6 +7565,7 @@ class WebSocketServer extends EventEmitter {
     socket.removeListener('error', socketOnError);
 
     ws.setSocket(socket, head, {
+      allowSynchronousEvents: this.options.allowSynchronousEvents,
       maxPayload: this.options.maxPayload,
       skipUTF8Validation: this.options.skipUTF8Validation
     });
@@ -7682,28 +7747,28 @@ function setup(vitestOrWorkspace, _server) {
           checkFileAccess(snapshotPath);
           if (!existsSync(snapshotPath))
             return null;
-          return promises.readFile(snapshotPath, "utf-8");
+          return promises$1.readFile(snapshotPath, "utf-8");
         },
         async readTestFile(id) {
           if (!ctx.state.filesMap.has(id) || !existsSync(id))
             return null;
-          return promises.readFile(id, "utf-8");
+          return promises$1.readFile(id, "utf-8");
         },
         async saveTestFile(id, content) {
           if (!ctx.state.filesMap.has(id) || !existsSync(id))
             throw new Error(`Test file "${id}" was not registered, so it cannot be updated using the API.`);
-          return promises.writeFile(id, content, "utf-8");
+          return promises$1.writeFile(id, content, "utf-8");
         },
         async saveSnapshotFile(id, content) {
           checkFileAccess(id);
-          await promises.mkdir(dirname(id), { recursive: true });
-          return promises.writeFile(id, content, "utf-8");
+          await promises$1.mkdir(dirname(id), { recursive: true });
+          return promises$1.writeFile(id, content, "utf-8");
         },
         async removeSnapshotFile(id) {
           checkFileAccess(id);
           if (!existsSync(id))
             throw new Error(`Snapshot file "${id}" does not exist.`);
-          return promises.unlink(id);
+          return promises$1.unlink(id);
         },
         snapshotSaved(snapshot) {
           ctx.snapshot.add(snapshot);
@@ -7725,7 +7790,7 @@ function setup(vitestOrWorkspace, _server) {
           const result = await ctx.vitenode.transformRequest(id);
           if (result) {
             try {
-              result.source = result.source || await promises.readFile(id, "utf-8");
+              result.source = result.source || await promises$1.readFile(id, "utf-8");
             } catch {
             }
             return result;
@@ -7766,6 +7831,10 @@ function setup(vitestOrWorkspace, _server) {
         },
         getProvidedContext() {
           return "ctx" in vitestOrWorkspace ? vitestOrWorkspace.getProvidedContext() : {};
+        },
+        async getTestFiles() {
+          const spec = await ctx.globTestFiles();
+          return spec.map(([project, file]) => [project.getName(), file]);
         }
       },
       {
@@ -7862,7 +7931,7 @@ function getTransformMode(patterns, filename) {
 async function groupFilesByEnv(files) {
   const filesWithEnv = await Promise.all(files.map(async ([project, file]) => {
     var _a, _b;
-    const code = await promises.readFile(file, "utf-8");
+    const code = await promises$1.readFile(file, "utf-8");
     let env = (_a = code.match(/@(?:vitest|jest)-environment\s+?([\w-]+)\b/)) == null ? void 0 : _a[1];
     if (!env) {
       for (const [glob, target] of project.config.environmentMatchGlobs || []) {
@@ -7890,6 +7959,8 @@ async function groupFilesByEnv(files) {
   return groupBy(filesWithEnv, ({ environment }) => environment.name);
 }
 
+const created = /* @__PURE__ */ new Set();
+const promises = /* @__PURE__ */ new Map();
 function createMethodsRPC(project) {
   const ctx = project.ctx;
   return {
@@ -7908,8 +7979,30 @@ function createMethodsRPC(project) {
       const r = await project.vitenode.transformRequest(id);
       return r == null ? void 0 : r.map;
     },
-    fetch(id, transformMode) {
-      return project.vitenode.fetchModule(id, transformMode);
+    async fetch(id, transformMode) {
+      const result = await project.vitenode.fetchResult(id, transformMode);
+      const code = result.code;
+      if (result.externalize)
+        return result;
+      if ("id" in result && typeof result.id === "string")
+        return { id: result.id };
+      if (code == null)
+        throw new Error(`Failed to fetch module ${id}`);
+      const dir = join(project.tmpDir, transformMode);
+      const name = createHash$2("sha1").update(id).digest("hex");
+      const tmp = join(dir, name);
+      if (promises.has(tmp)) {
+        await promises.get(tmp);
+        return { id: tmp };
+      }
+      if (!created.has(dir)) {
+        await mkdir(dir, { recursive: true });
+        created.add(dir);
+      }
+      promises.set(tmp, writeFile(tmp, code, "utf-8").finally(() => promises.delete(tmp)));
+      await promises.get(tmp);
+      Object.assign(result, { id: tmp });
+      return { id: tmp };
     },
     resolveId(id, importer, transformMode) {
       return project.vitenode.resolveId(id, importer, transformMode);
@@ -8906,144 +8999,2256 @@ function createBenchmarkReporters(reporterReferences, runner) {
   return Promise.all(promisedReporters);
 }
 
-function isAggregateError(err) {
-  if (typeof AggregateError !== "undefined" && err instanceof AggregateError)
-    return true;
-  return err instanceof Error && "errors" in err;
+function isAggregateError(err) {
+  if (typeof AggregateError !== "undefined" && err instanceof AggregateError)
+    return true;
+  return err instanceof Error && "errors" in err;
+}
+class StateManager {
+  filesMap = /* @__PURE__ */ new Map();
+  pathsSet = /* @__PURE__ */ new Set();
+  idMap = /* @__PURE__ */ new Map();
+  taskFileMap = /* @__PURE__ */ new WeakMap();
+  errorsSet = /* @__PURE__ */ new Set();
+  processTimeoutCauses = /* @__PURE__ */ new Set();
+  catchError(err, type) {
+    if (isAggregateError(err))
+      return err.errors.forEach((error) => this.catchError(error, type));
+    if (err === Object(err))
+      err.type = type;
+    else
+      err = { type, message: err };
+    const _err = err;
+    if (_err && typeof _err === "object" && _err.code === "VITEST_PENDING") {
+      const task = this.idMap.get(_err.taskId);
+      if (task) {
+        task.mode = "skip";
+        task.result ?? (task.result = { state: "skip" });
+        task.result.state = "skip";
+      }
+      return;
+    }
+    this.errorsSet.add(err);
+  }
+  clearErrors() {
+    this.errorsSet.clear();
+  }
+  getUnhandledErrors() {
+    return Array.from(this.errorsSet.values());
+  }
+  addProcessTimeoutCause(cause) {
+    this.processTimeoutCauses.add(cause);
+  }
+  getProcessTimeoutCauses() {
+    return Array.from(this.processTimeoutCauses.values());
+  }
+  getPaths() {
+    return Array.from(this.pathsSet);
+  }
+  getFiles(keys) {
+    if (keys)
+      return keys.map((key) => this.filesMap.get(key)).filter(Boolean).flat();
+    return Array.from(this.filesMap.values()).flat();
+  }
+  getFilepaths() {
+    return Array.from(this.filesMap.keys());
+  }
+  getFailedFilepaths() {
+    return this.getFiles().filter((i) => {
+      var _a;
+      return ((_a = i.result) == null ? void 0 : _a.state) === "fail";
+    }).map((i) => i.filepath);
+  }
+  collectPaths(paths = []) {
+    paths.forEach((path) => {
+      this.pathsSet.add(path);
+    });
+  }
+  collectFiles(files = []) {
+    files.forEach((file) => {
+      const existing = this.filesMap.get(file.filepath) || [];
+      const otherProject = existing.filter((i) => i.projectName !== file.projectName);
+      otherProject.push(file);
+      this.filesMap.set(file.filepath, otherProject);
+      this.updateId(file);
+    });
+  }
+  // this file is reused by ws-client, and shoult not rely on heavy dependencies like workspace
+  clearFiles(_project, paths = []) {
+    const project = _project;
+    paths.forEach((path) => {
+      const files = this.filesMap.get(path);
+      if (!files)
+        return;
+      const filtered = files.filter((file) => file.projectName !== project.config.name);
+      if (!filtered.length)
+        this.filesMap.delete(path);
+      else
+        this.filesMap.set(path, filtered);
+    });
+  }
+  updateId(task) {
+    if (this.idMap.get(task.id) === task)
+      return;
+    this.idMap.set(task.id, task);
+    if (task.type === "suite") {
+      task.tasks.forEach((task2) => {
+        this.updateId(task2);
+      });
+    }
+  }
+  updateTasks(packs) {
+    for (const [id, result, meta] of packs) {
+      const task = this.idMap.get(id);
+      if (task) {
+        task.result = result;
+        task.meta = meta;
+        if ((result == null ? void 0 : result.state) === "skip")
+          task.mode = "skip";
+      }
+    }
+  }
+  updateUserLog(log) {
+    const task = log.taskId && this.idMap.get(log.taskId);
+    if (task) {
+      if (!task.logs)
+        task.logs = [];
+      task.logs.push(log);
+    }
+  }
+  getCountOfFailedTests() {
+    return Array.from(this.idMap.values()).filter((t) => {
+      var _a;
+      return ((_a = t.result) == null ? void 0 : _a.state) === "fail";
+    }).length;
+  }
+  cancelFiles(files, root, projectName) {
+    this.collectFiles(files.map((filepath) => {
+      const file = {
+        filepath,
+        name: relative(root, filepath),
+        id: filepath,
+        mode: "skip",
+        type: "suite",
+        result: {
+          state: "skip"
+        },
+        meta: {},
+        // Cancelled files have not yet collected tests
+        tasks: [],
+        projectName,
+        file: null
+      };
+      file.file = file;
+      return file;
+    }));
+  }
+}
+
+const JOIN_LEADING_SLASH_RE = /^\.?\//;
+function withTrailingSlash(input = "", respectQueryAndFragment) {
+  {
+    return input.endsWith("/") ? input : input + "/";
+  }
+}
+function isNonEmptyURL(url) {
+  return url && url !== "/";
+}
+function joinURL(base, ...input) {
+  let url = base || "";
+  for (const segment of input.filter((url2) => isNonEmptyURL(url2))) {
+    if (url) {
+      const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
+      url = withTrailingSlash(url) + _segment;
+    } else {
+      url = segment;
+    }
+  }
+  return url;
+}
+
+const BUILTIN_MODULES = new Set(builtinModules);
+function normalizeSlash(path) {
+  return path.replace(/\\/g, "/");
+}
+
+/**
+ * @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 own$1 = {}.hasOwnProperty;
+
+const classRegExp = /^([A-Z][a-z\d]*)+$/;
+// Sorted by a rough estimate on most frequently used entries.
+const kTypes = new Set([
+  'string',
+  'function',
+  'number',
+  'object',
+  // Accept 'Function' and 'Object' as alternative to the lower cased version.
+  'Function',
+  'Object',
+  'boolean',
+  'bigint',
+  'symbol'
+]);
+
+const codes = {};
+
+/**
+ * Create a list string in the form like 'A and B' or 'A, B, ..., and Z'.
+ * We cannot use Intl.ListFormat because it's not available in
+ * --without-intl builds.
+ *
+ * @param {Array<string>} array
+ *   An array of strings.
+ * @param {string} [type]
+ *   The list type to be inserted before the last element.
+ * @returns {string}
+ */
+function formatList(array, type = 'and') {
+  return array.length < 3
+    ? array.join(` ${type} `)
+    : `${array.slice(0, -1).join(', ')}, ${type} ${array[array.length - 1]}`
+}
+
+/** @type {Map<string, MessageFunction | string>} */
+const messages = new Map();
+const nodeInternalPrefix = '__node_internal_';
+/** @type {number} */
+let userStackTraceLimit;
+
+codes.ERR_INVALID_ARG_TYPE = createError(
+  'ERR_INVALID_ARG_TYPE',
+  /**
+   * @param {string} name
+   * @param {Array<string> | string} expected
+   * @param {unknown} actual
+   */
+  (name, expected, actual) => {
+    assert(typeof name === 'string', "'name' must be a string");
+    if (!Array.isArray(expected)) {
+      expected = [expected];
+    }
+
+    let message = 'The ';
+    if (name.endsWith(' argument')) {
+      // For cases like 'first argument'
+      message += `${name} `;
+    } else {
+      const type = name.includes('.') ? 'property' : 'argument';
+      message += `"${name}" ${type} `;
+    }
+
+    message += 'must be ';
+
+    /** @type {Array<string>} */
+    const types = [];
+    /** @type {Array<string>} */
+    const instances = [];
+    /** @type {Array<string>} */
+    const other = [];
+
+    for (const value of expected) {
+      assert(
+        typeof value === 'string',
+        'All expected entries have to be of type string'
+      );
+
+      if (kTypes.has(value)) {
+        types.push(value.toLowerCase());
+      } else if (classRegExp.exec(value) === null) {
+        assert(
+          value !== 'object',
+          'The value "object" should be written as "Object"'
+        );
+        other.push(value);
+      } else {
+        instances.push(value);
+      }
+    }
+
+    // Special handle `object` in case other instances are allowed to outline
+    // the differences between each other.
+    if (instances.length > 0) {
+      const pos = types.indexOf('object');
+      if (pos !== -1) {
+        types.slice(pos, 1);
+        instances.push('Object');
+      }
+    }
+
+    if (types.length > 0) {
+      message += `${types.length > 1 ? 'one of type' : 'of type'} ${formatList(
+        types,
+        'or'
+      )}`;
+      if (instances.length > 0 || other.length > 0) message += ' or ';
+    }
+
+    if (instances.length > 0) {
+      message += `an instance of ${formatList(instances, 'or')}`;
+      if (other.length > 0) message += ' or ';
+    }
+
+    if (other.length > 0) {
+      if (other.length > 1) {
+        message += `one of ${formatList(other, 'or')}`;
+      } else {
+        if (other[0].toLowerCase() !== other[0]) message += 'an ';
+        message += `${other[0]}`;
+      }
+    }
+
+    message += `. Received ${determineSpecificType(actual)}`;
+
+    return message
+  },
+  TypeError
+);
+
+codes.ERR_INVALID_MODULE_SPECIFIER = createError(
+  '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.ERR_INVALID_PACKAGE_CONFIG = createError(
+  '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.ERR_INVALID_PACKAGE_TARGET = createError(
+  'ERR_INVALID_PACKAGE_TARGET',
+  /**
+   * @param {string} packagePath
+   * @param {string} key
+   * @param {unknown} target
+   * @param {boolean} [isImport=false]
+   * @param {string} [base]
+   */
+  (packagePath, key, target, isImport = false, base = undefined) => {
+    const relatedError =
+      typeof target === 'string' &&
+      !isImport &&
+      target.length > 0 &&
+      !target.startsWith('./');
+    if (key === '.') {
+      assert(isImport === false);
+      return (
+        `Invalid "exports" main target ${JSON.stringify(target)} defined ` +
+        `in the package config ${packagePath}package.json${
+          base ? ` imported from ${base}` : ''
+        }${relatedError ? '; targets must start with "./"' : ''}`
+      )
+    }
+
+    return `Invalid "${
+      isImport ? 'imports' : 'exports'
+    }" target ${JSON.stringify(
+      target
+    )} defined for '${key}' in the package config ${packagePath}package.json${
+      base ? ` imported from ${base}` : ''
+    }${relatedError ? '; targets must start with "./"' : ''}`
+  },
+  Error
+);
+
+codes.ERR_MODULE_NOT_FOUND = createError(
+  'ERR_MODULE_NOT_FOUND',
+  /**
+   * @param {string} path
+   * @param {string} base
+   * @param {boolean} [exactUrl]
+   */
+  (path, base, exactUrl = false) => {
+    return `Cannot find ${
+      exactUrl ? 'module' : 'package'
+    } '${path}' imported from ${base}`
+  },
+  Error
+);
+
+codes.ERR_NETWORK_IMPORT_DISALLOWED = createError(
+  'ERR_NETWORK_IMPORT_DISALLOWED',
+  "import of '%s' by %s is not supported: %s",
+  Error
+);
+
+codes.ERR_PACKAGE_IMPORT_NOT_DEFINED = createError(
+  '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.ERR_PACKAGE_PATH_NOT_EXPORTED = createError(
+  'ERR_PACKAGE_PATH_NOT_EXPORTED',
+  /**
+   * @param {string} packagePath
+   * @param {string} subpath
+   * @param {string} [base]
+   */
+  (packagePath, subpath, base = undefined) => {
+    if (subpath === '.')
+      return `No "exports" main defined in ${packagePath}package.json${
+        base ? ` imported from ${base}` : ''
+      }`
+    return `Package subpath '${subpath}' is not defined by "exports" in ${packagePath}package.json${
+      base ? ` imported from ${base}` : ''
+    }`
+  },
+  Error
+);
+
+codes.ERR_UNSUPPORTED_DIR_IMPORT = createError(
+  'ERR_UNSUPPORTED_DIR_IMPORT',
+  "Directory import '%s' is not supported " +
+    'resolving ES modules imported from %s',
+  Error
+);
+
+codes.ERR_UNSUPPORTED_RESOLVE_REQUEST = createError(
+  'ERR_UNSUPPORTED_RESOLVE_REQUEST',
+  'Failed to resolve module specifier "%s" from "%s": Invalid relative URL or base scheme is not hierarchical.',
+  TypeError
+);
+
+codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
+  'ERR_UNKNOWN_FILE_EXTENSION',
+  /**
+   * @param {string} extension
+   * @param {string} path
+   */
+  (extension, path) => {
+    return `Unknown file extension "${extension}" for ${path}`
+  },
+  TypeError
+);
+
+codes.ERR_INVALID_ARG_VALUE = createError(
+  '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
+);
+
+/**
+ * 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} constructor
+ * @returns {new (...parameters: Array<any>) => Error}
+ */
+function createError(sym, value, constructor) {
+  // Special case for SystemError that formats the error message differently
+  // The SystemErrors only have SystemError as their base classes.
+  messages.set(sym, value);
+
+  return makeNodeErrorWithCode(constructor, sym)
+}
+
+/**
+ * @param {ErrorConstructor} Base
+ * @param {string} key
+ * @returns {ErrorConstructor}
+ */
+function makeNodeErrorWithCode(Base, key) {
+  // @ts-expect-error It’s a Node error.
+  return NodeError
+  /**
+   * @param {Array<unknown>} parameters
+   */
+  function NodeError(...parameters) {
+    const limit = Error.stackTraceLimit;
+    if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;
+    const error = new Base();
+    // Reset the limit and setting the name property.
+    if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = limit;
+    const message = getMessage(key, parameters, error);
+    Object.defineProperties(error, {
+      // Note: no need to implement `kIsNodeError` symbol, would be hard,
+      // probably.
+      message: {
+        value: message,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      },
+      toString: {
+        /** @this {Error} */
+        value() {
+          return `${this.name} [${key}]: ${this.message}`
+        },
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+
+    captureLargerStackTrace(error);
+    // @ts-expect-error It’s a Node error.
+    error.code = key;
+    return error
+  }
+}
+
+/**
+ * @returns {boolean}
+ */
+function isErrorStackTraceLimitWritable() {
+  // Do no touch Error.stackTraceLimit as V8 would attempt to install
+  // it again during deserialization.
+  try {
+    if (v8.startupSnapshot.isBuildingSnapshot()) {
+      return false
+    }
+  } catch {}
+
+  const desc = Object.getOwnPropertyDescriptor(Error, 'stackTraceLimit');
+  if (desc === undefined) {
+    return Object.isExtensible(Error)
+  }
+
+  return own$1.call(desc, 'writable') && desc.writable !== undefined
+    ? desc.writable
+    : desc.set !== undefined
+}
+
+/**
+ * This function removes unnecessary frames from Node.js core errors.
+ * @template {(...parameters: unknown[]) => unknown} T
+ * @param {T} wrappedFunction
+ * @returns {T}
+ */
+function hideStackFrames(wrappedFunction) {
+  // We rename the functions that will be hidden to cut off the stacktrace
+  // at the outermost one
+  const hidden = nodeInternalPrefix + wrappedFunction.name;
+  Object.defineProperty(wrappedFunction, 'name', {value: hidden});
+  return wrappedFunction
+}
+
+const captureLargerStackTrace = hideStackFrames(
+  /**
+   * @param {Error} error
+   * @returns {Error}
+   */
+  // @ts-expect-error: fine
+  function (error) {
+    const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
+    if (stackTraceLimitIsWritable) {
+      userStackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+    }
+
+    Error.captureStackTrace(error);
+
+    // Reset the limit
+    if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;
+
+    return error
+  }
+);
+
+/**
+ * @param {string} key
+ * @param {Array<unknown>} parameters
+ * @param {Error} self
+ * @returns {string}
+ */
+function getMessage(key, parameters, self) {
+  const message = messages.get(key);
+  assert(message !== undefined, 'expected `message` to be found');
+
+  if (typeof message === 'function') {
+    assert(
+      message.length <= parameters.length, // Default options do not count.
+      `Code: ${key}; The provided arguments length (${parameters.length}) does not ` +
+        `match the required ones (${message.length}).`
+    );
+    return Reflect.apply(message, self, parameters)
+  }
+
+  const regex = /%[dfijoOs]/g;
+  let expectedLength = 0;
+  while (regex.exec(message) !== null) expectedLength++;
+  assert(
+    expectedLength === parameters.length,
+    `Code: ${key}; The provided arguments length (${parameters.length}) does not ` +
+      `match the required ones (${expectedLength}).`
+  );
+  if (parameters.length === 0) return message
+
+  parameters.unshift(message);
+  return Reflect.apply(format$2, null, parameters)
+}
+
+/**
+ * Determine the specific type of a value for type-mismatch errors.
+ * @param {unknown} value
+ * @returns {string}
+ */
+function determineSpecificType(value) {
+  if (value === null || value === undefined) {
+    return String(value)
+  }
+
+  if (typeof value === 'function' && value.name) {
+    return `function ${value.name}`
+  }
+
+  if (typeof value === 'object') {
+    if (value.constructor && value.constructor.name) {
+      return `an instance of ${value.constructor.name}`
+    }
+
+    return `${inspect(value, {depth: -1})}`
+  }
+
+  let inspected = inspect(value, {colors: false});
+
+  if (inspected.length > 28) {
+    inspected = `${inspected.slice(0, 25)}...`;
+  }
+
+  return `type ${typeof value} (${inspected})`
+}
+
+// Manually “tree shaken” from:
+// <https://github.com/nodejs/node/blob/7c3dce0/lib/internal/modules/package_json_reader.js>
+// Last checked on: Apr 29, 2023.
+// Removed the native dependency.
+// Also: no need to cache, we do that in resolve already.
+
+
+const hasOwnProperty$1 = {}.hasOwnProperty;
+
+const {ERR_INVALID_PACKAGE_CONFIG: ERR_INVALID_PACKAGE_CONFIG$1} = codes;
+
+/** @type {Map<string, PackageConfig>} */
+const cache = new Map();
+
+/**
+ * @param {string} jsonPath
+ * @param {{specifier: URL | string, base?: URL}} options
+ * @returns {PackageConfig}
+ */
+function read(jsonPath, {base, specifier}) {
+  const existing = cache.get(jsonPath);
+
+  if (existing) {
+    return existing
+  }
+
+  /** @type {string | undefined} */
+  let string;
+
+  try {
+    string = fs$8.readFileSync(path$8.toNamespacedPath(jsonPath), 'utf8');
+  } catch (error) {
+    const exception = /** @type {ErrnoException} */ (error);
+
+    if (exception.code !== 'ENOENT') {
+      throw exception
+    }
+  }
+
+  /** @type {PackageConfig} */
+  const result = {
+    exists: false,
+    pjsonPath: jsonPath,
+    main: undefined,
+    name: undefined,
+    type: 'none', // Ignore unknown types for forwards compatibility
+    exports: undefined,
+    imports: undefined
+  };
+
+  if (string !== undefined) {
+    /** @type {Record<string, unknown>} */
+    let parsed;
+
+    try {
+      parsed = JSON.parse(string);
+    } catch (error_) {
+      const cause = /** @type {ErrnoException} */ (error_);
+      const error = new ERR_INVALID_PACKAGE_CONFIG$1(
+        jsonPath,
+        (base ? `"${specifier}" from ` : '') + fileURLToPath$1(base || specifier),
+        cause.message
+      );
+      error.cause = cause;
+      throw error
+    }
+
+    result.exists = true;
+
+    if (
+      hasOwnProperty$1.call(parsed, 'name') &&
+      typeof parsed.name === 'string'
+    ) {
+      result.name = parsed.name;
+    }
+
+    if (
+      hasOwnProperty$1.call(parsed, 'main') &&
+      typeof parsed.main === 'string'
+    ) {
+      result.main = parsed.main;
+    }
+
+    if (hasOwnProperty$1.call(parsed, 'exports')) {
+      // @ts-expect-error: assume valid.
+      result.exports = parsed.exports;
+    }
+
+    if (hasOwnProperty$1.call(parsed, 'imports')) {
+      // @ts-expect-error: assume valid.
+      result.imports = parsed.imports;
+    }
+
+    // Ignore unknown types for forwards compatibility
+    if (
+      hasOwnProperty$1.call(parsed, 'type') &&
+      (parsed.type === 'commonjs' || parsed.type === 'module')
+    ) {
+      result.type = parsed.type;
+    }
+  }
+
+  cache.set(jsonPath, result);
+
+  return result
+}
+
+/**
+ * @param {URL | string} resolved
+ * @returns {PackageConfig}
+ */
+function getPackageScopeConfig(resolved) {
+  // Note: in Node, this is now a native module.
+  let packageJSONUrl = new URL('package.json', resolved);
+
+  while (true) {
+    const packageJSONPath = packageJSONUrl.pathname;
+    if (packageJSONPath.endsWith('node_modules/package.json')) {
+      break
+    }
+
+    const packageConfig = read(fileURLToPath$1(packageJSONUrl), {
+      specifier: resolved
+    });
+
+    if (packageConfig.exists) {
+      return packageConfig
+    }
+
+    const lastPackageJSONUrl = packageJSONUrl;
+    packageJSONUrl = new URL('../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$1(packageJSONUrl);
+  // ^^ Note: in Node, this is now a native module.
+
+  return {
+    pjsonPath: packageJSONPath,
+    exists: false,
+    type: 'none'
+  }
+}
+
+/**
+ * Returns the package type for a given URL.
+ * @param {URL} url - The URL to get the package type for.
+ * @returns {PackageType}
+ */
+function getPackageType(url) {
+  // To do @anonrig: Write a C++ function that returns only "type".
+  return getPackageScopeConfig(url).type
+}
+
+// Manually “tree shaken” from:
+// <https://github.com/nodejs/node/blob/7c3dce0/lib/internal/modules/esm/get_format.js>
+// Last checked on: Apr 29, 2023.
+
+
+const {ERR_UNKNOWN_FILE_EXTENSION} = codes;
+
+const hasOwnProperty = {}.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, source?: Buffer}} context
+ * @param {boolean} ignoreErrors
+ * @returns {string | null | void}
+ */
+
+/**
+ * @type {Record<string, ProtocolHandler>}
+ */
+const protocolHandlers = {
+  // @ts-expect-error: hush.
+  __proto__: 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)
+}
+
+/**
+ * Returns the file extension from a URL.
+ *
+ * Should give similar result to
+ * `require('node:path').extname(require('node:url').fileURLToPath(url))`
+ * when used with a `file:` URL.
+ *
+ * @param {URL} url
+ * @returns {string}
+ */
+function extname(url) {
+  const pathname = url.pathname;
+  let index = pathname.length;
+
+  while (index--) {
+    const code = pathname.codePointAt(index);
+
+    if (code === 47 /* `/` */) {
+      return ''
+    }
+
+    if (code === 46 /* `.` */) {
+      return pathname.codePointAt(index - 1) === 47 /* `/` */
+        ? ''
+        : pathname.slice(index)
+    }
+  }
+
+  return ''
+}
+
+/**
+ * @type {ProtocolHandler}
+ */
+function getFileProtocolModuleFormat(url, _context, ignoreErrors) {
+  const value = extname(url);
+
+  if (value === '.js') {
+    const packageType = getPackageType(url);
+
+    if (packageType !== 'none') {
+      return packageType
+    }
+
+    return 'commonjs'
+  }
+
+  if (value === '') {
+    const packageType = getPackageType(url);
+
+    // Legacy behavior
+    if (packageType === 'none' || packageType === 'commonjs') {
+      return 'commonjs'
+    }
+
+    // Note: we don’t implement WASM, so we don’t need
+    // `getFormatOfExtensionlessFile` from `formats`.
+    return 'module'
+  }
+
+  const format = extensionFormatMap[value];
+  if (format) return format
+
+  // Explicit undefined return indicates load hook should rerun format check
+  if (ignoreErrors) {
+    return undefined
+  }
+
+  const filepath = fileURLToPath$1(url);
+  throw new ERR_UNKNOWN_FILE_EXTENSION(value, filepath)
+}
+
+function getHttpProtocolModuleFormat() {
+  // To do: HTTPS imports.
+}
+
+/**
+ * @param {URL} url
+ * @param {{parentURL: string}} context
+ * @returns {string | null}
+ */
+function defaultGetFormatWithoutErrors(url, context) {
+  const protocol = url.protocol;
+
+  if (!hasOwnProperty.call(protocolHandlers, protocol)) {
+    return null
+  }
+
+  return protocolHandlers[protocol](url, context, true) || null
+}
+
+// Manually “tree shaken” from:
+// <https://github.com/nodejs/node/blob/81a9a97/lib/internal/modules/esm/resolve.js>
+// Last checked on: Apr 29, 2023.
+
+
+const RegExpPrototypeSymbolReplace = RegExp.prototype[Symbol.replace];
+
+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_RESOLVE_REQUEST
+} = codes;
+
+const own = {}.hasOwnProperty;
+
+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 deprecatedInvalidSegmentRegEx =
+  /(^|\\|\/)((\.|%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 encodedSeparatorRegEx = /%2f|%5c/i;
+/** @type {Set<string>} */
+const emittedPackageWarnings = new Set();
+
+const doubleSlashRegEx = /[/\\]{2}/;
+
+/**
+ *
+ * @param {string} target
+ * @param {string} request
+ * @param {string} match
+ * @param {URL} packageJsonUrl
+ * @param {boolean} internal
+ * @param {URL} base
+ * @param {boolean} isTarget
+ */
+function emitInvalidSegmentDeprecation(
+  target,
+  request,
+  match,
+  packageJsonUrl,
+  internal,
+  base,
+  isTarget
+) {
+  // @ts-expect-error: apparently it does exist, TS.
+  if (process$1.noDeprecation) {
+    return
+  }
+
+  const pjsonPath = fileURLToPath$1(packageJsonUrl);
+  const double = doubleSlashRegEx.exec(isTarget ? target : request) !== null;
+  process$1.emitWarning(
+    `Use of deprecated ${
+      double ? 'double slash' : 'leading or trailing slash matching'
+    } resolving "${target}" for module ` +
+      `request "${request}" ${
+        request === match ? '' : `matched to "${match}" `
+      }in the "${
+        internal ? 'imports' : 'exports'
+      }" field module resolution of the package at ${pjsonPath}${
+        base ? ` imported from ${fileURLToPath$1(base)}` : ''
+      }.`,
+    'DeprecationWarning',
+    'DEP0166'
+  );
+}
+
+/**
+ * @param {URL} url
+ * @param {URL} packageJsonUrl
+ * @param {URL} base
+ * @param {string} [main]
+ * @returns {void}
+ */
+function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
+  // @ts-expect-error: apparently it does exist, TS.
+  if (process$1.noDeprecation) {
+    return
+  }
+
+  const format = defaultGetFormatWithoutErrors(url, {parentURL: base.href});
+  if (format !== 'module') return
+  const urlPath = fileURLToPath$1(url.href);
+  const packagePath = fileURLToPath$1(new URL$2('.', packageJsonUrl));
+  const basePath = fileURLToPath$1(base);
+  if (!main) {
+    process$1.emitWarning(
+      `No "main" or "exports" field defined in the package.json for ${packagePath} resolving the main entry point "${urlPath.slice(
+        packagePath.length
+      )}", imported from ${basePath}.\nDefault "index" lookups for the main are deprecated for ES modules.`,
+      'DeprecationWarning',
+      'DEP0151'
+    );
+  } else if (path$8.resolve(packagePath, main) !== urlPath) {
+    process$1.emitWarning(
+      `Package ${packagePath} has a "main" field set to "${main}", ` +
+        `excluding the full filename and extension to the resolved file at "${urlPath.slice(
+          packagePath.length
+        )}", imported from ${basePath}.\n Automatic extension resolution of the "main" field is ` +
+        'deprecated for ES modules.',
+      'DeprecationWarning',
+      'DEP0151'
+    );
+  }
+}
+
+/**
+ * @param {string} path
+ * @returns {Stats | undefined}
+ */
+function tryStatSync(path) {
+  // Note: from Node 15 onwards we can use `throwIfNoEntry: false` instead.
+  try {
+    return statSync$1(path)
+  } catch {
+    // Note: in Node code this returns `new Stats`,
+    // but in Node 22 that’s marked as a deprecated internal API.
+    // Which, well, we kinda are, but still to prevent that warning,
+    // just yield `undefined`.
+  }
+}
+
+/**
+ * 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$2(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$2(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$2(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$1(new URL$2('.', packageJsonUrl)),
+    fileURLToPath$1(base)
+  )
+}
+
+/**
+ * @param {URL} resolved
+ * @param {URL} base
+ * @param {boolean} [preserveSymlinks]
+ * @returns {URL}
+ */
+function finalizeResolution(resolved, base, preserveSymlinks) {
+  if (encodedSeparatorRegEx.exec(resolved.pathname) !== null) {
+    throw new ERR_INVALID_MODULE_SPECIFIER(
+      resolved.pathname,
+      'must not include encoded "/" or "\\" characters',
+      fileURLToPath$1(base)
+    )
+  }
+
+  /** @type {string} */
+  let filePath;
+
+  try {
+    filePath = fileURLToPath$1(resolved);
+  } catch (error) {
+    const cause = /** @type {ErrnoException} */ (error);
+    Object.defineProperty(cause, 'input', {value: String(resolved)});
+    Object.defineProperty(cause, 'module', {value: String(base)});
+    throw cause
+  }
+
+  const stats = tryStatSync(
+    filePath.endsWith('/') ? filePath.slice(-1) : filePath
+  );
+
+  if (stats && stats.isDirectory()) {
+    const error = new ERR_UNSUPPORTED_DIR_IMPORT(filePath, fileURLToPath$1(base));
+    // @ts-expect-error Add this for `import.meta.resolve`.
+    error.url = String(resolved);
+    throw error
+  }
+
+  if (!stats || !stats.isFile()) {
+    const error = new ERR_MODULE_NOT_FOUND(
+      filePath || resolved.pathname,
+      base && fileURLToPath$1(base),
+      true
+    );
+    // @ts-expect-error Add this for `import.meta.resolve`.
+    error.url = String(resolved);
+    throw error
+  }
+
+  {
+    const real = realpathSync(filePath);
+    const {search, hash} = resolved;
+    resolved = pathToFileURL$1(real + (filePath.endsWith(path$8.sep) ? '/' : ''));
+    resolved.search = search;
+    resolved.hash = hash;
+  }
+
+  return resolved
+}
+
+/**
+ * @param {string} specifier
+ * @param {URL | undefined} packageJsonUrl
+ * @param {URL} base
+ * @returns {Error}
+ */
+function importNotDefined(specifier, packageJsonUrl, base) {
+  return new ERR_PACKAGE_IMPORT_NOT_DEFINED(
+    specifier,
+    packageJsonUrl && fileURLToPath$1(new URL$2('.', packageJsonUrl)),
+    fileURLToPath$1(base)
+  )
+}
+
+/**
+ * @param {string} subpath
+ * @param {URL} packageJsonUrl
+ * @param {URL} base
+ * @returns {Error}
+ */
+function exportsNotFound(subpath, packageJsonUrl, base) {
+  return new ERR_PACKAGE_PATH_NOT_EXPORTED(
+    fileURLToPath$1(new URL$2('.', packageJsonUrl)),
+    subpath,
+    base && fileURLToPath$1(base)
+  )
+}
+
+/**
+ * @param {string} request
+ * @param {string} match
+ * @param {URL} packageJsonUrl
+ * @param {boolean} internal
+ * @param {URL} [base]
+ * @returns {never}
+ */
+function throwInvalidSubpath(request, match, packageJsonUrl, internal, base) {
+  const reason = `request is not a valid match in pattern "${match}" for the "${
+    internal ? 'imports' : 'exports'
+  }" resolution of ${fileURLToPath$1(packageJsonUrl)}`;
+  throw new ERR_INVALID_MODULE_SPECIFIER(
+    request,
+    reason,
+    base && fileURLToPath$1(base)
+  )
+}
+
+/**
+ * @param {string} subpath
+ * @param {unknown} target
+ * @param {URL} packageJsonUrl
+ * @param {boolean} internal
+ * @param {URL} [base]
+ * @returns {Error}
+ */
+function invalidPackageTarget(subpath, target, packageJsonUrl, internal, base) {
+  target =
+    typeof target === 'object' && target !== null
+      ? JSON.stringify(target, null, '')
+      : `${target}`;
+
+  return new ERR_INVALID_PACKAGE_TARGET(
+    fileURLToPath$1(new URL$2('.', packageJsonUrl)),
+    subpath,
+    target,
+    internal,
+    base && fileURLToPath$1(base)
+  )
+}
+
+/**
+ * @param {string} target
+ * @param {string} subpath
+ * @param {string} match
+ * @param {URL} packageJsonUrl
+ * @param {URL} base
+ * @param {boolean} pattern
+ * @param {boolean} internal
+ * @param {boolean} isPathMap
+ * @param {Set<string> | undefined} conditions
+ * @returns {URL}
+ */
+function resolvePackageTargetString(
+  target,
+  subpath,
+  match,
+  packageJsonUrl,
+  base,
+  pattern,
+  internal,
+  isPathMap,
+  conditions
+) {
+  if (subpath !== '' && !pattern && target[target.length - 1] !== '/')
+    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base)
+
+  if (!target.startsWith('./')) {
+    if (internal && !target.startsWith('../') && !target.startsWith('/')) {
+      let isURL = false;
+
+      try {
+        new URL$2(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)
+      }
+    }
+
+    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base)
+  }
+
+  if (invalidSegmentRegEx.exec(target.slice(2)) !== null) {
+    if (deprecatedInvalidSegmentRegEx.exec(target.slice(2)) === null) {
+      if (!isPathMap) {
+        const request = pattern
+          ? match.replace('*', () => subpath)
+          : match + subpath;
+        const resolvedTarget = pattern
+          ? RegExpPrototypeSymbolReplace.call(
+              patternRegEx,
+              target,
+              () => subpath
+            )
+          : target;
+        emitInvalidSegmentDeprecation(
+          resolvedTarget,
+          request,
+          match,
+          packageJsonUrl,
+          internal,
+          base,
+          true
+        );
+      }
+    } else {
+      throw invalidPackageTarget(match, target, packageJsonUrl, internal, base)
+    }
+  }
+
+  const resolved = new URL$2(target, packageJsonUrl);
+  const resolvedPath = resolved.pathname;
+  const packagePath = new URL$2('.', packageJsonUrl).pathname;
+
+  if (!resolvedPath.startsWith(packagePath))
+    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base)
+
+  if (subpath === '') return resolved
+
+  if (invalidSegmentRegEx.exec(subpath) !== null) {
+    const request = pattern
+      ? match.replace('*', () => subpath)
+      : match + subpath;
+    if (deprecatedInvalidSegmentRegEx.exec(subpath) === null) {
+      if (!isPathMap) {
+        const resolvedTarget = pattern
+          ? RegExpPrototypeSymbolReplace.call(
+              patternRegEx,
+              target,
+              () => subpath
+            )
+          : target;
+        emitInvalidSegmentDeprecation(
+          resolvedTarget,
+          request,
+          match,
+          packageJsonUrl,
+          internal,
+          base,
+          false
+        );
+      }
+    } else {
+      throwInvalidSubpath(request, match, packageJsonUrl, internal, base);
+    }
+  }
+
+  if (pattern) {
+    return new URL$2(
+      RegExpPrototypeSymbolReplace.call(
+        patternRegEx,
+        resolved.href,
+        () => subpath
+      )
+    )
+  }
+
+  return new URL$2(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 {boolean} isPathMap
+ * @param {Set<string> | undefined} conditions
+ * @returns {URL | null}
+ */
+function resolvePackageTarget(
+  packageJsonUrl,
+  target,
+  subpath,
+  packageSubpath,
+  base,
+  pattern,
+  internal,
+  isPathMap,
+  conditions
+) {
+  if (typeof target === 'string') {
+    return resolvePackageTargetString(
+      target,
+      subpath,
+      packageSubpath,
+      packageJsonUrl,
+      base,
+      pattern,
+      internal,
+      isPathMap,
+      conditions
+    )
+  }
+
+  if (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,
+          isPathMap,
+          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$1(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,
+          isPathMap,
+          conditions
+        );
+        if (resolveResult === undefined) continue
+        return resolveResult
+      }
+    }
+
+    return null
+  }
+
+  if (target === null) {
+    return null
+  }
+
+  throw invalidPackageTarget(
+    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 keyIndex = -1;
+  while (++keyIndex < keys.length) {
+    const key = keys[keyIndex];
+    const currentIsConditionalSugar = key === '' || key[0] !== '.';
+    if (i++ === 0) {
+      isConditionalSugar = currentIsConditionalSugar;
+    } else if (isConditionalSugar !== currentIsConditionalSugar) {
+      throw new ERR_INVALID_PACKAGE_CONFIG(
+        fileURLToPath$1(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) {
+  // @ts-expect-error: apparently it does exist, TS.
+  if (process$1.noDeprecation) {
+    return
+  }
+
+  const pjsonPath = fileURLToPath$1(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$1(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,
+      false,
+      conditions
+    );
+    if (resolveResult === null || resolveResult === undefined) {
+      throw exportsNotFound(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,
+      packageSubpath.endsWith('/'),
+      conditions
+    );
+
+    if (resolveResult === null || resolveResult === undefined) {
+      throw exportsNotFound(packageSubpath, packageJsonUrl, base)
+    }
+
+    return resolveResult
+  }
+
+  throw exportsNotFound(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$1(base))
+  }
+
+  /** @type {URL | undefined} */
+  let packageJsonUrl;
+
+  const packageConfig = getPackageScopeConfig(base);
+
+  if (packageConfig.exists) {
+    packageJsonUrl = pathToFileURL$1(packageConfig.pjsonPath);
+    const imports = packageConfig.imports;
+    if (imports) {
+      if (own.call(imports, name) && !name.includes('*')) {
+        const resolveResult = resolvePackageTarget(
+          packageJsonUrl,
+          imports[name],
+          '',
+          name,
+          base,
+          false,
+          true,
+          false,
+          conditions
+        );
+        if (resolveResult !== null && resolveResult !== 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,
+            false,
+            conditions
+          );
+
+          if (resolveResult !== null && resolveResult !== undefined) {
+            return resolveResult
+          }
+        }
+      }
+    }
+  }
+
+  throw importNotDefined(name, packageJsonUrl, base)
+}
+
+/**
+ * @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$1(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$2('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$1(packageConfig.pjsonPath);
+    if (
+      packageConfig.name === packageName &&
+      packageConfig.exports !== undefined &&
+      packageConfig.exports !== null
+    ) {
+      return packageExportsResolve(
+        packageJsonUrl,
+        packageSubpath,
+        packageConfig,
+        base,
+        conditions
+      )
+    }
+  }
+
+  let packageJsonUrl = new URL$2(
+    './node_modules/' + packageName + '/package.json',
+    base
+  );
+  let packageJsonPath = fileURLToPath$1(packageJsonUrl);
+  /** @type {string} */
+  let lastPath;
+  do {
+    const stat = tryStatSync(packageJsonPath.slice(0, -13));
+    if (!stat || !stat.isDirectory()) {
+      lastPath = packageJsonPath;
+      packageJsonUrl = new URL$2(
+        (isScoped ? '../../../../node_modules/' : '../../../node_modules/') +
+          packageName +
+          '/package.json',
+        packageJsonUrl
+      );
+      packageJsonPath = fileURLToPath$1(packageJsonUrl);
+      continue
+    }
+
+    // Package match.
+    const packageConfig = read(packageJsonPath, {base, specifier});
+    if (packageConfig.exports !== undefined && packageConfig.exports !== null) {
+      return packageExportsResolve(
+        packageJsonUrl,
+        packageSubpath,
+        packageConfig,
+        base,
+        conditions
+      )
+    }
+
+    if (packageSubpath === '.') {
+      return legacyMainResolve(packageJsonUrl, packageConfig, base)
+    }
+
+    return new URL$2(packageSubpath, packageJsonUrl)
+    // Cross-platform root check.
+  } while (packageJsonPath.length !== lastPath.length)
+
+  throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath$1(base), false)
+}
+
+/**
+ * @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)
 }
-class StateManager {
-  filesMap = /* @__PURE__ */ new Map();
-  pathsSet = /* @__PURE__ */ new Set();
-  idMap = /* @__PURE__ */ new Map();
-  taskFileMap = /* @__PURE__ */ new WeakMap();
-  errorsSet = /* @__PURE__ */ new Set();
-  processTimeoutCauses = /* @__PURE__ */ new Set();
-  catchError(err, type) {
-    if (isAggregateError(err))
-      return err.errors.forEach((error) => this.catchError(error, type));
-    if (err === Object(err))
-      err.type = type;
-    else
-      err = { type, message: err };
-    const _err = err;
-    if (_err && typeof _err === "object" && _err.code === "VITEST_PENDING") {
-      const task = this.idMap.get(_err.taskId);
-      if (task) {
-        task.mode = "skip";
-        task.result ?? (task.result = { state: "skip" });
-        task.result.state = "skip";
+
+/**
+ * The “Resolver Algorithm Specification” as detailed in the Node docs (which is
+ * sync and slightly lower-level than `resolve`).
+ *
+ * @param {string} specifier
+ *   `/example.js`, `./example.js`, `../example.js`, `some-package`, `fs`, etc.
+ * @param {URL} base
+ *   Full URL (to a file) that `specifier` is resolved relative from.
+ * @param {Set<string>} [conditions]
+ *   Conditions.
+ * @param {boolean} [preserveSymlinks]
+ *   Keep symlinks instead of resolving them.
+ * @returns {URL}
+ *   A URL object to the found thing.
+ */
+function moduleResolve(specifier, base, conditions, preserveSymlinks) {
+  // Note: The Node code supports `base` as a string (in this internal API) too,
+  // we don’t.
+  const protocol = base.protocol;
+  const isData = protocol === 'data:';
+  const isRemote = isData || protocol === 'http:' || 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)) {
+    try {
+      resolved = new URL$2(specifier, base);
+    } catch (error_) {
+      const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
+      error.cause = error_;
+      throw error
+    }
+  } else if (protocol === 'file:' && specifier[0] === '#') {
+    resolved = packageImportsResolve(specifier, base, conditions);
+  } else {
+    try {
+      resolved = new URL$2(specifier);
+    } catch (error_) {
+      // Note: actual code uses `canBeRequiredWithoutScheme`.
+      if (isRemote && !builtinModules.includes(specifier)) {
+        const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
+        error.cause = error_;
+        throw error
       }
-      return;
+
+      resolved = packageResolve(specifier, base, conditions);
     }
-    this.errorsSet.add(err);
   }
-  clearErrors() {
-    this.errorsSet.clear();
+
+  assert(resolved !== undefined, 'expected to be defined');
+
+  if (resolved.protocol !== 'file:') {
+    return resolved
   }
-  getUnhandledErrors() {
-    return Array.from(this.errorsSet.values());
+
+  return finalizeResolution(resolved, base)
+}
+
+function fileURLToPath(id) {
+  if (typeof id === "string" && !id.startsWith("file://")) {
+    return normalizeSlash(id);
   }
-  addProcessTimeoutCause(cause) {
-    this.processTimeoutCauses.add(cause);
+  return normalizeSlash(fileURLToPath$1(id));
+}
+function pathToFileURL(id) {
+  return pathToFileURL$1(fileURLToPath(id)).toString();
+}
+function normalizeid(id) {
+  if (typeof id !== "string") {
+    id = id.toString();
   }
-  getProcessTimeoutCauses() {
-    return Array.from(this.processTimeoutCauses.values());
+  if (/(node|data|http|https|file):/.test(id)) {
+    return id;
   }
-  getPaths() {
-    return Array.from(this.pathsSet);
+  if (BUILTIN_MODULES.has(id)) {
+    return "node:" + id;
   }
-  getFiles(keys) {
-    if (keys)
-      return keys.map((key) => this.filesMap.get(key)).filter(Boolean).flat();
-    return Array.from(this.filesMap.values()).flat();
+  return "file://" + encodeURI(normalizeSlash(id));
+}
+
+const DEFAULT_CONDITIONS_SET = /* @__PURE__ */ new Set(["node", "import"]);
+const DEFAULT_EXTENSIONS = [".mjs", ".cjs", ".js", ".json"];
+const NOT_FOUND_ERRORS = /* @__PURE__ */ new Set([
+  "ERR_MODULE_NOT_FOUND",
+  "ERR_UNSUPPORTED_DIR_IMPORT",
+  "MODULE_NOT_FOUND",
+  "ERR_PACKAGE_PATH_NOT_EXPORTED"
+]);
+function _tryModuleResolve(id, url, conditions) {
+  try {
+    return moduleResolve(id, url, conditions);
+  } catch (error) {
+    if (!NOT_FOUND_ERRORS.has(error?.code)) {
+      throw error;
+    }
   }
-  getFilepaths() {
-    return Array.from(this.filesMap.keys());
+}
+function _resolve$1(id, options = {}) {
+  if (typeof id !== "string") {
+    if (id instanceof URL) {
+      id = fileURLToPath(id);
+    } else {
+      throw new TypeError("input must be a `string` or `URL`");
+    }
   }
-  getFailedFilepaths() {
-    return this.getFiles().filter((i) => {
-      var _a;
-      return ((_a = i.result) == null ? void 0 : _a.state) === "fail";
-    }).map((i) => i.filepath);
+  if (/(node|data|http|https):/.test(id)) {
+    return id;
   }
-  collectPaths(paths = []) {
-    paths.forEach((path) => {
-      this.pathsSet.add(path);
-    });
+  if (BUILTIN_MODULES.has(id)) {
+    return "node:" + id;
   }
-  collectFiles(files = []) {
-    files.forEach((file) => {
-      const existing = this.filesMap.get(file.filepath) || [];
-      const otherProject = existing.filter((i) => i.projectName !== file.projectName);
-      otherProject.push(file);
-      this.filesMap.set(file.filepath, otherProject);
-      this.updateId(file);
-    });
+  if (id.startsWith("file://")) {
+    id = fileURLToPath(id);
   }
-  // this file is reused by ws-client, and shoult not rely on heavy dependencies like workspace
-  clearFiles(_project, paths = []) {
-    const project = _project;
-    paths.forEach((path) => {
-      const files = this.filesMap.get(path);
-      if (!files)
-        return;
-      const filtered = files.filter((file) => file.projectName !== project.config.name);
-      if (!filtered.length)
-        this.filesMap.delete(path);
-      else
-        this.filesMap.set(path, filtered);
-    });
+  if (isAbsolute(id)) {
+    try {
+      const stat = statSync$1(id);
+      if (stat.isFile()) {
+        return pathToFileURL(id);
+      }
+    } catch (error) {
+      if (error?.code !== "ENOENT") {
+        throw error;
+      }
+    }
   }
-  updateId(task) {
-    if (this.idMap.get(task.id) === task)
-      return;
-    this.idMap.set(task.id, task);
-    if (task.type === "suite") {
-      task.tasks.forEach((task2) => {
-        this.updateId(task2);
-      });
+  const conditionsSet = options.conditions ? new Set(options.conditions) : DEFAULT_CONDITIONS_SET;
+  const _urls = (Array.isArray(options.url) ? options.url : [options.url]).filter(Boolean).map((url) => new URL(normalizeid(url.toString())));
+  if (_urls.length === 0) {
+    _urls.push(new URL(pathToFileURL(process.cwd())));
+  }
+  const urls = [..._urls];
+  for (const url of _urls) {
+    if (url.protocol === "file:") {
+      urls.push(
+        new URL("./", url),
+        // If url is directory
+        new URL(joinURL(url.pathname, "_index.js"), url),
+        // TODO: Remove in next major version?
+        new URL("node_modules", url)
+      );
     }
   }
-  updateTasks(packs) {
-    for (const [id, result, meta] of packs) {
-      const task = this.idMap.get(id);
-      if (task) {
-        task.result = result;
-        task.meta = meta;
-        if ((result == null ? void 0 : result.state) === "skip")
-          task.mode = "skip";
+  let resolved;
+  for (const url of urls) {
+    resolved = _tryModuleResolve(id, url, conditionsSet);
+    if (resolved) {
+      break;
+    }
+    for (const prefix of ["", "/index"]) {
+      for (const extension of options.extensions || DEFAULT_EXTENSIONS) {
+        resolved = _tryModuleResolve(
+          id + prefix + extension,
+          url,
+          conditionsSet
+        );
+        if (resolved) {
+          break;
+        }
+      }
+      if (resolved) {
+        break;
       }
     }
-  }
-  updateUserLog(log) {
-    const task = log.taskId && this.idMap.get(log.taskId);
-    if (task) {
-      if (!task.logs)
-        task.logs = [];
-      task.logs.push(log);
+    if (resolved) {
+      break;
     }
   }
-  getCountOfFailedTests() {
-    return Array.from(this.idMap.values()).filter((t) => {
-      var _a;
-      return ((_a = t.result) == null ? void 0 : _a.state) === "fail";
-    }).length;
+  if (!resolved) {
+    const error = new Error(
+      `Cannot find module ${id} imported from ${urls.join(", ")}`
+    );
+    error.code = "ERR_MODULE_NOT_FOUND";
+    throw error;
   }
-  cancelFiles(files, root, projectName) {
-    this.collectFiles(files.map((filepath) => ({
-      filepath,
-      name: relative(root, filepath),
-      id: filepath,
-      mode: "skip",
-      type: "suite",
-      result: {
-        state: "skip"
-      },
-      meta: {},
-      // Cancelled files have not yet collected tests
-      tasks: [],
-      projectName
-    })));
+  return pathToFileURL(resolved);
+}
+function resolveSync(id, options) {
+  return _resolve$1(id, options);
+}
+function resolvePathSync(id, options) {
+  return fileURLToPath(resolveSync(id, options));
+}
+
+function _resolve(path, options = {}) {
+  if (options.platform === "auto" || !options.platform)
+    options.platform = process$1.platform === "win32" ? "win32" : "posix";
+  const modulePath = resolvePathSync(path, {
+    url: options.paths
+  });
+  if (options.platform === "win32")
+    return win32.normalize(modulePath);
+  return modulePath;
+}
+function resolveModule(name, options = {}) {
+  try {
+    return _resolve(name, options);
+  } catch (e) {
+    return void 0;
+  }
+}
+function isPackageExists(name, options = {}) {
+  return !!resolvePackage(name, options);
+}
+function resolvePackage(name, options = {}) {
+  try {
+    return _resolve(`${name}/package.json`, options);
+  } catch {
+  }
+  try {
+    return _resolve(name, options);
+  } catch (e) {
+    if (e.code !== "MODULE_NOT_FOUND" && e.code !== "ERR_MODULE_NOT_FOUND")
+      console.error(e);
+    return false;
   }
 }
 
@@ -9068,7 +11273,7 @@ const defaultCoverageExcludes = [
   "cypress/**",
   "test?(s)/**",
   "test?(-*).?(c|m)[jt]s?(x)",
-  "**/*{.,-}{test,spec}.?(c|m)[jt]s?(x)",
+  "**/*{.,-}{test,spec}?(-d).?(c|m)[jt]s?(x)",
   "**/__tests__/**",
   "**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build}.config.*",
   "**/vitest.{workspace,projects}.[jt]s?(on)",
@@ -9086,7 +11291,7 @@ const coverageConfigDefaults = {
   reporter: [["text", {}], ["html", {}], ["clover", {}], ["json", {}]],
   extension: [".js", ".cjs", ".mjs", ".ts", ".mts", ".cts", ".tsx", ".jsx", ".vue", ".svelte", ".marko"],
   allowExternal: false,
-  ignoreEmptyLines: false,
+  ignoreEmptyLines: true,
   processingConcurrency: Math.min(20, ((_b = (_a = nodeos__default).availableParallelism) == null ? void 0 : _b.call(_a)) ?? nodeos__default.cpus().length)
 };
 const fakeTimersDefaults = {
@@ -9117,7 +11322,6 @@ const config = {
   testTimeout: 5e3,
   hookTimeout: 1e4,
   teardownTimeout: 1e4,
-  watchExclude: ["**/node_modules/**", "**/dist/**"],
   forceRerunTriggers: [
     "**/package.json/**",
     "**/{vitest,vite}.config.*/**"
@@ -9177,8 +11381,11 @@ class ResultsCache {
   cache = /* @__PURE__ */ new Map();
   workspacesKeyMap = /* @__PURE__ */ new Map();
   cachePath = null;
-  version = version;
+  version;
   root = "/";
+  constructor(version) {
+    this.version = version;
+  }
   getCachePath() {
     return this.cachePath;
   }
@@ -9196,10 +11403,10 @@ class ResultsCache {
     if (!fs$8.existsSync(this.cachePath))
       return;
     const resultsCache = await fs$8.promises.readFile(this.cachePath, "utf8");
-    const { results, version: version2 } = JSON.parse(resultsCache || "[]");
-    if (Number(version2.split(".")[1]) >= 30) {
+    const { results, version } = JSON.parse(resultsCache || "[]");
+    if (Number(version.split(".")[1]) >= 30) {
       this.cache = new Map(results);
-      this.version = version2;
+      this.version = version;
       results.forEach(([spec]) => {
         const [projectName, relativePath] = spec.split(":");
         const keyMap = this.workspacesKeyMap.get(relativePath) || [];
@@ -9243,8 +11450,11 @@ class ResultsCache {
 }
 
 class VitestCache {
-  results = new ResultsCache();
+  results;
   stats = new FilesStatsCache();
+  constructor(version) {
+    this.results = new ResultsCache(version);
+  }
   getFileTestResults(key) {
     return this.results.getResults(key);
   }
@@ -9259,7 +11469,7 @@ class VitestCache {
 
 function resolvePath(path, root) {
   return normalize(
-    resolveModule(path, { paths: [root] }) ?? resolve(root, path)
+    /* @__PURE__ */ resolveModule(path, { paths: [root] }) ?? resolve(root, path)
   );
 }
 function parseInspector(inspect) {
@@ -9342,6 +11552,8 @@ function resolveConfig(mode, options, viteConfig, logger) {
       throw new Error("--shard <index> must be a positive number less then <count>");
     resolved.shard = { index, count };
   }
+  if (resolved.standalone && !resolved.watch)
+    throw new Error(`Vitest standalone mode requires --watch`);
   if (resolved.maxWorkers)
     resolved.maxWorkers = Number(resolved.maxWorkers);
   if (resolved.minWorkers)
@@ -9424,6 +11636,8 @@ function resolveConfig(mode, options, viteConfig, logger) {
   resolved.server.deps.moduleDirectories.push(...resolved.deps.moduleDirectories);
   if (resolved.runner)
     resolved.runner = resolvePath(resolved.runner, resolved.root);
+  if (resolved.snapshotEnvironment)
+    resolved.snapshotEnvironment = resolvePath(resolved.snapshotEnvironment, resolved.root);
   resolved.testNamePattern = resolved.testNamePattern ? resolved.testNamePattern instanceof RegExp ? resolved.testNamePattern : new RegExp(resolved.testNamePattern) : void 0;
   if (resolved.snapshotFormat && "plugins" in resolved.snapshotFormat)
     resolved.snapshotFormat.plugins = [];
@@ -9526,6 +11740,10 @@ function resolveConfig(mode, options, viteConfig, logger) {
       resolved.benchmark.reporters = ["default"];
     if (options.outputFile)
       resolved.benchmark.outputFile = options.outputFile;
+    if (options.compare)
+      resolved.benchmark.compare = options.compare;
+    if (options.outputJson)
+      resolved.benchmark.outputJson = options.outputJson;
   }
   resolved.setupFiles = toArray(resolved.setupFiles || []).map(
     (file) => resolvePath(file, resolved.root)
@@ -9607,7 +11825,7 @@ function resolveConfig(mode, options, viteConfig, logger) {
   if (!((_F = resolved.sequence) == null ? void 0 : _F.sequencer)) {
     resolved.sequence.sequencer = resolved.sequence.shuffle ? RandomSequencer : BaseSequencer;
   }
-  (_G = resolved.sequence).hooks ?? (_G.hooks = "parallel");
+  (_G = resolved.sequence).hooks ?? (_G.hooks = "stack");
   if (resolved.sequence.sequencer === RandomSequencer)
     (_H = resolved.sequence).seed ?? (_H.seed = Date.now());
   resolved.typecheck = {
@@ -9683,7 +11901,7 @@ function getBetterEnd(code, node) {
     end += 1;
   return end;
 }
-const regexpHoistable = /\b(vi|vitest)\s*\.\s*(mock|unmock|hoisted)\(/;
+const regexpHoistable = /\b(vi|vitest)\s*\.\s*(mock|unmock|hoisted|doMock|doUnmock)\(/;
 const hashbangRE = /^#!.*\n/;
 function hoistMocks(code, id, parse, colors) {
   var _a;
@@ -9758,7 +11976,7 @@ ${err.message}`);
       name: "SyntaxError",
       message: _error.message,
       stack: _error.stack,
-      frame: generateCodeFrame(highlightCode(id, code, colors), 4, node.start + 1)
+      frame: generateCodeFrame(highlightCode(id, code), 4, node.start + 1)
     };
   }
   function assertNotDefaultExport(node, error) {
@@ -9813,6 +12031,21 @@ ${err.message}`);
             assertNotNamedExport(declarationNode, `Cannot export the result of "${method}". Remove export declaration because "${method}" doesn't return anything.`);
           hoistedNodes.push(node);
         }
+        if (methodName === "doMock" || methodName === "doUnmock") {
+          const moduleInfo = node.arguments[0];
+          let source = null;
+          if (moduleInfo.type === "ImportExpression")
+            source = moduleInfo.source;
+          if (moduleInfo.type === "AwaitExpression" && moduleInfo.argument.type === "ImportExpression")
+            source = moduleInfo.argument.source;
+          if (source) {
+            s.overwrite(
+              moduleInfo.start,
+              moduleInfo.end,
+              s.slice(source.start, source.end)
+            );
+          }
+        }
         if (methodName === "hoisted") {
           assertNotDefaultExport(node, "Cannot export hoisted variable. You can control hoisting behavior by placing the import from this file first.");
           const declarationNode = getVariableDeclaration(node);
@@ -9857,6 +12090,13 @@ ${err.message}`);
       `Cannot call ${getNodeName(insideCall)} inside ${getNodeName(outsideCall)}: both methods are hoisted to the top of the file and not actually called inside each other.`
     );
   }
+  function rewriteMockDynamicImport(nodeCode, moduleInfo, expressionStart, expressionEnd, mockStart) {
+    const source = moduleInfo.source;
+    const importPath = s.slice(source.start, source.end);
+    const nodeCodeStart = expressionStart - mockStart;
+    const nodeCodeEnd = expressionEnd - mockStart;
+    return nodeCode.slice(0, nodeCodeStart) + importPath + nodeCode.slice(nodeCodeEnd);
+  }
   for (let i = 0; i < hoistedNodes.length; i++) {
     const node = hoistedNodes[i];
     for (let j = i + 1; j < hoistedNodes.length; j++) {
@@ -9869,7 +12109,28 @@ ${err.message}`);
   }
   const hoistedCode = hoistedNodes.map((node) => {
     const end = getBetterEnd(code, node);
-    const nodeCode = s.slice(node.start, end);
+    let nodeCode = s.slice(node.start, end);
+    if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && (node.callee.property.name === "mock" || node.callee.property.name === "unmock")) {
+      const moduleInfo = node.arguments[0];
+      if (moduleInfo.type === "ImportExpression") {
+        nodeCode = rewriteMockDynamicImport(
+          nodeCode,
+          moduleInfo,
+          moduleInfo.start,
+          moduleInfo.end,
+          node.start
+        );
+      }
+      if (moduleInfo.type === "AwaitExpression" && moduleInfo.argument.type === "ImportExpression") {
+        nodeCode = rewriteMockDynamicImport(
+          nodeCode,
+          moduleInfo.argument,
+          moduleInfo.start,
+          moduleInfo.end,
+          node.start
+        );
+      }
+    }
     s.remove(node.start, end);
     return `${nodeCode}${nodeCode.endsWith("\n") ? "" : "\n"}`;
   }).join("");
@@ -9899,10 +12160,10 @@ function resolveOptimizerConfig(_testOptions, viteOptions, testConfig) {
   var _a;
   const testOptions = _testOptions || {};
   const newConfig = {};
-  const [major, minor, fix] = version$1.split(".").map(Number);
+  const [major, minor, fix] = version.split(".").map(Number);
   const allowed = major >= 5 || major === 4 && minor >= 4 || major === 4 && minor === 3 && fix >= 2;
   if (!allowed && (testOptions == null ? void 0 : testOptions.enabled) === true)
-    console.warn(`Vitest: "deps.optimizer" is only available in Vite >= 4.3.2, current Vite version: ${version$1}`);
+    console.warn(`Vitest: "deps.optimizer" is only available in Vite >= 4.3.2, current Vite version: ${version}`);
   else
     testOptions.enabled ?? (testOptions.enabled = false);
   if (!allowed || (testOptions == null ? void 0 : testOptions.enabled) !== true) {
@@ -10148,6 +12409,481 @@ function CSSEnablerPlugin(ctx) {
   ];
 }
 
+// Copyright 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Simon Lydell
+// License: MIT.
+var HashbangComment, Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
+RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:[^\]\\\n\r\u2028\u2029]+|\\.)*\]|[^\/\\\n\r\u2028\u2029]+|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/yu;
+Punctuator = /--|\+\+|=>|\.{3}|\??\.(?!\d)|(?:&&|\|\||\?\?|[+\-%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2}|\/(?![\/*]))=?|[?~,:;[\](){}]/y;
+Identifier = /(\x23?)(?=[$_\p{ID_Start}\\])(?:[$_\u200C\u200D\p{ID_Continue}]+|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+/yu;
+StringLiteral = /(['"])(?:[^'"\\\n\r]+|(?!\1)['"]|\\(?:\r\n|[^]))*(\1)?/y;
+NumericLiteral = /(?:0[xX][\da-fA-F](?:_?[\da-fA-F])*|0[oO][0-7](?:_?[0-7])*|0[bB][01](?:_?[01])*)n?|0n|[1-9](?:_?\d)*n|(?:(?:0(?!\d)|0\d*[89]\d*|[1-9](?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:[eE][+-]?\d(?:_?\d)*)?|0[0-7]+/y;
+Template = /[`}](?:[^`\\$]+|\\[^]|\$(?!\{))*(`|\$\{)?/y;
+WhiteSpace = /[\t\v\f\ufeff\p{Zs}]+/yu;
+LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y;
+MultiLineComment = /\/\*(?:[^*]+|\*(?!\/))*(\*\/)?/y;
+SingleLineComment = /\/\/.*/y;
+HashbangComment = /^#!.*/;
+JSXPunctuator = /[<>.:={}]|\/(?![\/*])/y;
+JSXIdentifier = /[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}-]*/yu;
+JSXString = /(['"])(?:[^'"]+|(?!\1)['"])*(\1)?/y;
+JSXText = /[^<>{}]+/y;
+TokensPrecedingExpression = /^(?:[\/+-]|\.{3}|\?(?:InterpolationIn(?:JSX|Template)|NoLineTerminatorHere|NonExpressionParenEnd|UnaryIncDec))?$|[{}([,;<>=*%&|^!~?:]$/;
+TokensNotPrecedingObjectLiteral = /^(?:=>|[;\]){}]|else|\?(?:NoLineTerminatorHere|NonExpressionParenEnd))?$/;
+KeywordsWithExpressionAfter = /^(?:await|case|default|delete|do|else|instanceof|new|return|throw|typeof|void|yield)$/;
+KeywordsWithNoLineTerminatorAfter = /^(?:return|throw|yield)$/;
+Newline = RegExp(LineTerminatorSequence.source);
+var jsTokens_1 = function*(input, {jsx = false} = {}) {
+	var braces, firstCodePoint, isExpression, lastIndex, lastSignificantToken, length, match, mode, nextLastIndex, nextLastSignificantToken, parenNesting, postfixIncDec, punctuator, stack;
+	({length} = input);
+	lastIndex = 0;
+	lastSignificantToken = "";
+	stack = [
+		{tag: "JS"}
+	];
+	braces = [];
+	parenNesting = 0;
+	postfixIncDec = false;
+	if (match = HashbangComment.exec(input)) {
+		yield ({
+			type: "HashbangComment",
+			value: match[0]
+		});
+		lastIndex = match[0].length;
+	}
+	while (lastIndex < length) {
+		mode = stack[stack.length - 1];
+		switch (mode.tag) {
+			case "JS":
+			case "JSNonExpressionParen":
+			case "InterpolationInTemplate":
+			case "InterpolationInJSX":
+				if (input[lastIndex] === "/" && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
+					RegularExpressionLiteral.lastIndex = lastIndex;
+					if (match = RegularExpressionLiteral.exec(input)) {
+						lastIndex = RegularExpressionLiteral.lastIndex;
+						lastSignificantToken = match[0];
+						postfixIncDec = true;
+						yield ({
+							type: "RegularExpressionLiteral",
+							value: match[0],
+							closed: match[1] !== void 0 && match[1] !== "\\"
+						});
+						continue;
+					}
+				}
+				Punctuator.lastIndex = lastIndex;
+				if (match = Punctuator.exec(input)) {
+					punctuator = match[0];
+					nextLastIndex = Punctuator.lastIndex;
+					nextLastSignificantToken = punctuator;
+					switch (punctuator) {
+						case "(":
+							if (lastSignificantToken === "?NonExpressionParenKeyword") {
+								stack.push({
+									tag: "JSNonExpressionParen",
+									nesting: parenNesting
+								});
+							}
+							parenNesting++;
+							postfixIncDec = false;
+							break;
+						case ")":
+							parenNesting--;
+							postfixIncDec = true;
+							if (mode.tag === "JSNonExpressionParen" && parenNesting === mode.nesting) {
+								stack.pop();
+								nextLastSignificantToken = "?NonExpressionParenEnd";
+								postfixIncDec = false;
+							}
+							break;
+						case "{":
+							Punctuator.lastIndex = 0;
+							isExpression = !TokensNotPrecedingObjectLiteral.test(lastSignificantToken) && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken));
+							braces.push(isExpression);
+							postfixIncDec = false;
+							break;
+						case "}":
+							switch (mode.tag) {
+								case "InterpolationInTemplate":
+									if (braces.length === mode.nesting) {
+										Template.lastIndex = lastIndex;
+										match = Template.exec(input);
+										lastIndex = Template.lastIndex;
+										lastSignificantToken = match[0];
+										if (match[1] === "${") {
+											lastSignificantToken = "?InterpolationInTemplate";
+											postfixIncDec = false;
+											yield ({
+												type: "TemplateMiddle",
+												value: match[0]
+											});
+										} else {
+											stack.pop();
+											postfixIncDec = true;
+											yield ({
+												type: "TemplateTail",
+												value: match[0],
+												closed: match[1] === "`"
+											});
+										}
+										continue;
+									}
+									break;
+								case "InterpolationInJSX":
+									if (braces.length === mode.nesting) {
+										stack.pop();
+										lastIndex += 1;
+										lastSignificantToken = "}";
+										yield ({
+											type: "JSXPunctuator",
+											value: "}"
+										});
+										continue;
+									}
+							}
+							postfixIncDec = braces.pop();
+							nextLastSignificantToken = postfixIncDec ? "?ExpressionBraceEnd" : "}";
+							break;
+						case "]":
+							postfixIncDec = true;
+							break;
+						case "++":
+						case "--":
+							nextLastSignificantToken = postfixIncDec ? "?PostfixIncDec" : "?UnaryIncDec";
+							break;
+						case "<":
+							if (jsx && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
+								stack.push({tag: "JSXTag"});
+								lastIndex += 1;
+								lastSignificantToken = "<";
+								yield ({
+									type: "JSXPunctuator",
+									value: punctuator
+								});
+								continue;
+							}
+							postfixIncDec = false;
+							break;
+						default:
+							postfixIncDec = false;
+					}
+					lastIndex = nextLastIndex;
+					lastSignificantToken = nextLastSignificantToken;
+					yield ({
+						type: "Punctuator",
+						value: punctuator
+					});
+					continue;
+				}
+				Identifier.lastIndex = lastIndex;
+				if (match = Identifier.exec(input)) {
+					lastIndex = Identifier.lastIndex;
+					nextLastSignificantToken = match[0];
+					switch (match[0]) {
+						case "for":
+						case "if":
+						case "while":
+						case "with":
+							if (lastSignificantToken !== "." && lastSignificantToken !== "?.") {
+								nextLastSignificantToken = "?NonExpressionParenKeyword";
+							}
+					}
+					lastSignificantToken = nextLastSignificantToken;
+					postfixIncDec = !KeywordsWithExpressionAfter.test(match[0]);
+					yield ({
+						type: match[1] === "#" ? "PrivateIdentifier" : "IdentifierName",
+						value: match[0]
+					});
+					continue;
+				}
+				StringLiteral.lastIndex = lastIndex;
+				if (match = StringLiteral.exec(input)) {
+					lastIndex = StringLiteral.lastIndex;
+					lastSignificantToken = match[0];
+					postfixIncDec = true;
+					yield ({
+						type: "StringLiteral",
+						value: match[0],
+						closed: match[2] !== void 0
+					});
+					continue;
+				}
+				NumericLiteral.lastIndex = lastIndex;
+				if (match = NumericLiteral.exec(input)) {
+					lastIndex = NumericLiteral.lastIndex;
+					lastSignificantToken = match[0];
+					postfixIncDec = true;
+					yield ({
+						type: "NumericLiteral",
+						value: match[0]
+					});
+					continue;
+				}
+				Template.lastIndex = lastIndex;
+				if (match = Template.exec(input)) {
+					lastIndex = Template.lastIndex;
+					lastSignificantToken = match[0];
+					if (match[1] === "${") {
+						lastSignificantToken = "?InterpolationInTemplate";
+						stack.push({
+							tag: "InterpolationInTemplate",
+							nesting: braces.length
+						});
+						postfixIncDec = false;
+						yield ({
+							type: "TemplateHead",
+							value: match[0]
+						});
+					} else {
+						postfixIncDec = true;
+						yield ({
+							type: "NoSubstitutionTemplate",
+							value: match[0],
+							closed: match[1] === "`"
+						});
+					}
+					continue;
+				}
+				break;
+			case "JSXTag":
+			case "JSXTagEnd":
+				JSXPunctuator.lastIndex = lastIndex;
+				if (match = JSXPunctuator.exec(input)) {
+					lastIndex = JSXPunctuator.lastIndex;
+					nextLastSignificantToken = match[0];
+					switch (match[0]) {
+						case "<":
+							stack.push({tag: "JSXTag"});
+							break;
+						case ">":
+							stack.pop();
+							if (lastSignificantToken === "/" || mode.tag === "JSXTagEnd") {
+								nextLastSignificantToken = "?JSX";
+								postfixIncDec = true;
+							} else {
+								stack.push({tag: "JSXChildren"});
+							}
+							break;
+						case "{":
+							stack.push({
+								tag: "InterpolationInJSX",
+								nesting: braces.length
+							});
+							nextLastSignificantToken = "?InterpolationInJSX";
+							postfixIncDec = false;
+							break;
+						case "/":
+							if (lastSignificantToken === "<") {
+								stack.pop();
+								if (stack[stack.length - 1].tag === "JSXChildren") {
+									stack.pop();
+								}
+								stack.push({tag: "JSXTagEnd"});
+							}
+					}
+					lastSignificantToken = nextLastSignificantToken;
+					yield ({
+						type: "JSXPunctuator",
+						value: match[0]
+					});
+					continue;
+				}
+				JSXIdentifier.lastIndex = lastIndex;
+				if (match = JSXIdentifier.exec(input)) {
+					lastIndex = JSXIdentifier.lastIndex;
+					lastSignificantToken = match[0];
+					yield ({
+						type: "JSXIdentifier",
+						value: match[0]
+					});
+					continue;
+				}
+				JSXString.lastIndex = lastIndex;
+				if (match = JSXString.exec(input)) {
+					lastIndex = JSXString.lastIndex;
+					lastSignificantToken = match[0];
+					yield ({
+						type: "JSXString",
+						value: match[0],
+						closed: match[2] !== void 0
+					});
+					continue;
+				}
+				break;
+			case "JSXChildren":
+				JSXText.lastIndex = lastIndex;
+				if (match = JSXText.exec(input)) {
+					lastIndex = JSXText.lastIndex;
+					lastSignificantToken = match[0];
+					yield ({
+						type: "JSXText",
+						value: match[0]
+					});
+					continue;
+				}
+				switch (input[lastIndex]) {
+					case "<":
+						stack.push({tag: "JSXTag"});
+						lastIndex++;
+						lastSignificantToken = "<";
+						yield ({
+							type: "JSXPunctuator",
+							value: "<"
+						});
+						continue;
+					case "{":
+						stack.push({
+							tag: "InterpolationInJSX",
+							nesting: braces.length
+						});
+						lastIndex++;
+						lastSignificantToken = "?InterpolationInJSX";
+						postfixIncDec = false;
+						yield ({
+							type: "JSXPunctuator",
+							value: "{"
+						});
+						continue;
+				}
+		}
+		WhiteSpace.lastIndex = lastIndex;
+		if (match = WhiteSpace.exec(input)) {
+			lastIndex = WhiteSpace.lastIndex;
+			yield ({
+				type: "WhiteSpace",
+				value: match[0]
+			});
+			continue;
+		}
+		LineTerminatorSequence.lastIndex = lastIndex;
+		if (match = LineTerminatorSequence.exec(input)) {
+			lastIndex = LineTerminatorSequence.lastIndex;
+			postfixIncDec = false;
+			if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) {
+				lastSignificantToken = "?NoLineTerminatorHere";
+			}
+			yield ({
+				type: "LineTerminatorSequence",
+				value: match[0]
+			});
+			continue;
+		}
+		MultiLineComment.lastIndex = lastIndex;
+		if (match = MultiLineComment.exec(input)) {
+			lastIndex = MultiLineComment.lastIndex;
+			if (Newline.test(match[0])) {
+				postfixIncDec = false;
+				if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) {
+					lastSignificantToken = "?NoLineTerminatorHere";
+				}
+			}
+			yield ({
+				type: "MultiLineComment",
+				value: match[0],
+				closed: match[1] !== void 0
+			});
+			continue;
+		}
+		SingleLineComment.lastIndex = lastIndex;
+		if (match = SingleLineComment.exec(input)) {
+			lastIndex = SingleLineComment.lastIndex;
+			postfixIncDec = false;
+			yield ({
+				type: "SingleLineComment",
+				value: match[0]
+			});
+			continue;
+		}
+		firstCodePoint = String.fromCodePoint(input.codePointAt(lastIndex));
+		lastIndex += firstCodePoint.length;
+		lastSignificantToken = firstCodePoint;
+		postfixIncDec = false;
+		yield ({
+			type: mode.tag.startsWith("JSX") ? "JSXInvalid" : "Invalid",
+			value: firstCodePoint
+		});
+	}
+	return void 0;
+};
+
+var jsTokens = /*@__PURE__*/getDefaultExportFromCjs(jsTokens_1);
+
+function stripLiteralJsTokens(code, options) {
+  const FILL = " ";
+  const FILL_COMMENT = " ";
+  let result = "";
+  const tokens = [];
+  for (const token of jsTokens(code, { jsx: false })) {
+    tokens.push(token);
+    if (token.type === "SingleLineComment") {
+      result += FILL_COMMENT.repeat(token.value.length);
+      continue;
+    }
+    if (token.type === "MultiLineComment") {
+      result += token.value.replace(/[^\n]/g, FILL_COMMENT);
+      continue;
+    }
+    if (token.type === "StringLiteral") {
+      if (!token.closed) {
+        result += token.value;
+        continue;
+      }
+      const body = token.value.slice(1, -1);
+      {
+        result += token.value[0] + FILL.repeat(body.length) + token.value[token.value.length - 1];
+        continue;
+      }
+    }
+    if (token.type === "NoSubstitutionTemplate") {
+      const body = token.value.slice(1, -1);
+      {
+        result += `\`${body.replace(/[^\n]/g, FILL)}\``;
+        continue;
+      }
+    }
+    if (token.type === "RegularExpressionLiteral") {
+      const body = token.value;
+      {
+        result += body.replace(/\/(.*)\/(\w?)$/g, (_, $1, $2) => `/${FILL.repeat($1.length)}/${$2}`);
+        continue;
+      }
+    }
+    if (token.type === "TemplateHead") {
+      const body = token.value.slice(1, -2);
+      {
+        result += `\`${body.replace(/[^\n]/g, FILL)}\${`;
+        continue;
+      }
+    }
+    if (token.type === "TemplateTail") {
+      const body = token.value.slice(0, -2);
+      {
+        result += `}${body.replace(/[^\n]/g, FILL)}\``;
+        continue;
+      }
+    }
+    if (token.type === "TemplateMiddle") {
+      const body = token.value.slice(1, -2);
+      {
+        result += `}${body.replace(/[^\n]/g, FILL)}\${`;
+        continue;
+      }
+    }
+    result += token.value;
+  }
+  return {
+    result,
+    tokens
+  };
+}
+
+function stripLiteral(code, options) {
+  return stripLiteralDetailed(code).result;
+}
+function stripLiteralDetailed(code, options) {
+  return stripLiteralJsTokens(code);
+}
+
 function SsrReplacerPlugin() {
   return {
     name: "vitest:ssr-replacer",
@@ -10325,7 +13061,7 @@ function WorkspaceVitestPlugin(project, options) {
           );
           await project.setServer(options2, server);
         } catch (err) {
-          await project.ctx.logger.printError(err, { fullStack: true });
+          project.ctx.logger.printError(err, { fullStack: true });
           process.exit(1);
         }
         await server.watcher.close();
@@ -10419,6 +13155,8 @@ class WorkspaceProject {
   browserProvider;
   browserState;
   testFilesList = null;
+  id = nanoid();
+  tmpDir = join(tmpdir(), this.id);
   _globalSetups;
   _provided = {};
   getName() {
@@ -10462,7 +13200,7 @@ class WorkspaceProject {
     } catch (e) {
       this.logger.error(`
 ${c.red(divider(c.bold(c.inverse(" Error during global setup "))))}`);
-      await this.logger.printError(e);
+      this.logger.printError(e);
       process.exit(1);
     }
   }
@@ -10475,7 +13213,7 @@ ${c.red(divider(c.bold(c.inverse(" Error during global setup "))))}`);
         await ((_a = globalSetupFile.teardown) == null ? void 0 : _a.call(globalSetupFile));
       } catch (error) {
         this.logger.error(`error during global teardown of ${globalSetupFile.file}`, error);
-        await this.logger.printError(error);
+        this.logger.printError(error);
         process.exitCode = 1;
       }
     }
@@ -10523,7 +13261,7 @@ ${c.red(divider(c.bold(c.inverse(" Error during global setup "))))}`);
       const files = await this.globFiles(includeSource, exclude, cwd);
       await Promise.all(files.map(async (file) => {
         try {
-          const code = await promises.readFile(file, "utf-8");
+          const code = await promises$1.readFile(file, "utf-8");
           if (this.isInSourceTestFile(code))
             testFiles.push(file);
         } catch {
@@ -10554,7 +13292,7 @@ ${c.red(divider(c.bold(c.inverse(" Error during global setup "))))}`);
     if (mm.isMatch(relativeId, this.config.include))
       return true;
     if (((_a = this.config.includeSource) == null ? void 0 : _a.length) && mm.isMatch(relativeId, this.config.includeSource)) {
-      source = source || await promises.readFile(id, "utf-8");
+      source = source || await promises$1.readFile(id, "utf-8");
       return this.isInSourceTestFile(source);
     }
     return false;
@@ -10690,11 +13428,18 @@ ${c.red(divider(c.bold(c.inverse(" Error during global setup "))))}`);
       this.closingPromise = Promise.all([
         this.server.close(),
         (_a = this.typechecker) == null ? void 0 : _a.stop(),
-        (_b = this.browser) == null ? void 0 : _b.close()
+        (_b = this.browser) == null ? void 0 : _b.close(),
+        this.clearTmpDir()
       ].filter(Boolean)).then(() => this._provided = {});
     }
     return this.closingPromise;
   }
+  async clearTmpDir() {
+    try {
+      await rm(this.tmpDir, { force: true, recursive: true });
+    } catch {
+    }
+  }
   async initBrowserProvider() {
     if (!this.isBrowserEnabled())
       return;
@@ -10726,7 +13471,7 @@ class VitestPackageInstaller {
       } catch (error) {
       }
     }
-    if (isPackageExists(dependency, { paths: [root, __dirname] }))
+    if (/* @__PURE__ */ isPackageExists(dependency, { paths: [root, __dirname] }))
       return true;
     const promptInstall = !isCI && process.stdout.isTTY;
     process.stderr.write(c.red(`${c.inverse(c.red(" MISSING DEPENDENCY "))} Cannot find dependency '${dependency}'
@@ -10741,7 +13486,7 @@ class VitestPackageInstaller {
       message: c.reset(`Do you want to install ${c.green(dependency)}?`)
     });
     if (install) {
-      await (await import('../chunks/install-pkg.LE8oaA1t.js')).installPackage(dependency, { dev: true });
+      await (await import('../chunks/install-pkg.DNUmWFkO.js')).installPackage(dependency, { dev: true });
       process.stderr.write(c.yellow(`
 Package ${dependency} installed, re-run the command to start.
 `));
@@ -10759,6 +13504,7 @@ class Vitest {
     this.logger = new Logger(this, options.stdout, options.stderr);
     this.packageInstaller = options.packageInstaller || new VitestPackageInstaller();
   }
+  version = version$1;
   config = void 0;
   configOverride = {};
   server = void 0;
@@ -10799,19 +13545,17 @@ class Vitest {
     this.pool = void 0;
     this.coverageProvider = void 0;
     this.runningPromise = void 0;
+    this.distPath = void 0;
     this.projectsTestFiles.clear();
     const resolved = resolveConfig(this.mode, options, server.config, this.logger);
     this.server = server;
     this.config = resolved;
     this.state = new StateManager();
-    this.cache = new VitestCache();
+    this.cache = new VitestCache(this.version);
     this.snapshot = new SnapshotManager({ ...resolved.snapshotOptions });
     if (this.config.watch)
       this.registerWatcher();
     this.vitenode = new ViteNodeServer(server, this.config.server);
-    const projectVitestPath = await this.vitenode.resolveId("vitest");
-    const vitestDir = projectVitestPath ? resolve(projectVitestPath.id, "../..") : rootDir;
-    this.distPath = join(vitestDir, "dist");
     const node = this.vitenode;
     this.runner = new ViteNodeRunner({
       root: server.config.root,
@@ -10880,7 +13624,7 @@ class Vitest {
     if (this.config.workspace)
       return this.config.workspace;
     const configDir = this.server.config.configFile ? dirname(this.server.config.configFile) : this.config.root;
-    const rootFiles = await promises.readdir(configDir);
+    const rootFiles = await promises$1.readdir(configDir);
     const workspaceConfigName = workspacesFiles.find((configFile) => {
       return rootFiles.includes(configFile);
     });
@@ -10931,7 +13675,7 @@ class Vitest {
       return CONFIG_NAMES.some((configName) => filename.startsWith(configName));
     }).map(async (filepath) => {
       if (filepath.endsWith("/")) {
-        const filesInside = await promises.readdir(filepath);
+        const filesInside = await promises$1.readdir(filepath);
         const configFile = configFiles.find((config) => filesInside.includes(config));
         return configFile ? join(filepath, configFile) : filepath;
       }
@@ -11050,6 +13794,20 @@ class Vitest {
     if (this.config.watch)
       await this.report("onWatcherStart");
   }
+  async init() {
+    var _a;
+    this._onClose = [];
+    try {
+      await this.initCoverageProvider();
+      await ((_a = this.coverageProvider) == null ? void 0 : _a.clean(this.config.coverage.clean));
+      await this.initBrowserProviders();
+    } finally {
+      await this.report("onInit", this);
+    }
+    await this.globTestFiles();
+    if (this.config.watch)
+      await this.report("onWatcherStart");
+  }
   async getTestDependencies(filepath, deps = /* @__PURE__ */ new Set()) {
     const addImports = async ([project, filepath2]) => {
       if (deps.has(filepath2))
@@ -11073,7 +13831,7 @@ class Vitest {
   }
   async filterTestsBySource(specs) {
     if (this.config.changed && !this.config.related) {
-      const { VitestGit } = await import('../chunks/node-git.Hw101KjS.js');
+      const { VitestGit } = await import('../chunks/node-git.CCI8evVZ.js');
       const vitestGit = new VitestGit(this.config.root);
       const related2 = await vitestGit.findChangedFiles({
         changedSince: this.config.changed
@@ -11119,7 +13877,15 @@ class Vitest {
     for await (const project of projects)
       await project.initializeGlobalSetup();
   }
+  async initializeDistPath() {
+    if (this.distPath)
+      return;
+    const projectVitestPath = await this.vitenode.resolveId("vitest");
+    const vitestDir = projectVitestPath ? resolve(projectVitestPath.id, "../..") : rootDir;
+    this.distPath = join(vitestDir, "dist");
+  }
   async runFiles(paths, allTestsRun) {
+    await this.initializeDistPath();
     const filepaths = paths.map(([, file]) => file);
     this.state.collectPaths(filepaths);
     await this.report("onPathsCollected", filepaths);
@@ -11183,12 +13949,21 @@ class Vitest {
   async changeNamePattern(pattern, files = this.state.getFilepaths(), trigger) {
     if (pattern === "")
       this.filenamePattern = void 0;
-    this.configOverride.testNamePattern = pattern ? new RegExp(pattern) : void 0;
+    const testNamePattern = pattern ? new RegExp(pattern) : void 0;
+    this.configOverride.testNamePattern = testNamePattern;
+    if (testNamePattern) {
+      files = files.filter((filepath) => {
+        const files2 = this.state.getFiles([filepath]);
+        return !files2.length || files2.some((file) => {
+          const tasks = getTasks(file);
+          return !tasks.length || tasks.some((task) => testNamePattern.test(task.name));
+        });
+      });
+    }
     await this.rerunFiles(files, trigger);
   }
-  async changeFilenamePattern(pattern) {
+  async changeFilenamePattern(pattern, files = this.state.getFilepaths()) {
     this.filenamePattern = pattern;
-    const files = this.state.getFilepaths();
     const trigger = this.filenamePattern ? "change filename pattern" : "reset filename pattern";
     await this.rerunFiles(files, trigger);
   }
@@ -11300,8 +14075,11 @@ class Vitest {
       updateLastChanged(id);
       const matchingProjects = [];
       await Promise.all(this.projects.map(async (project) => {
-        if (await project.isTargetFile(id))
+        var _a;
+        if (await project.isTargetFile(id)) {
           matchingProjects.push(project);
+          (_a = project.testFilesList) == null ? void 0 : _a.push(id);
+        }
       }));
       if (matchingProjects.length > 0) {
         this.projectsTestFiles.set(id, new Set(matchingProjects));
@@ -11316,7 +14094,6 @@ class Vitest {
     const watcher = this.server.watcher;
     if (this.config.forceRerunTriggers.length)
       watcher.add(this.config.forceRerunTriggers);
-    watcher.unwatch(this.config.watchExclude);
     watcher.on("change", onChange);
     watcher.on("unlink", onUnlink);
     watcher.on("add", onAdd);
@@ -11445,6 +14222,9 @@ class Vitest {
       );
     }));
   }
+  async getTestFilepaths() {
+    return this.globTestFiles().then((files) => files.map(([, file]) => file));
+  }
   async globTestFiles(filters = []) {
     const files = [];
     await Promise.all(this.projects.map(async (project) => {
@@ -11527,9 +14307,6 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
           },
           server: {
             ...testConfig.api,
-            watch: {
-              ignored: testConfig.watchExclude
-            },
             open,
             hmr: false,
             preTransformRequests: false,
@@ -11571,8 +14348,11 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
           }
         }
         if (process.platform === "darwin" && process.env.VITE_TEST_WATCHER_DEBUG) {
-          config.server.watch.useFsEvents = false;
-          config.server.watch.usePolling = false;
+          const watch = config.server.watch;
+          if (watch) {
+            watch.useFsEvents = false;
+            watch.usePolling = false;
+          }
         }
         const classNameStrategy = typeof testConfig.css !== "boolean" && ((_q = (_p = testConfig.css) == null ? void 0 : _p.modules) == null ? void 0 : _q.classNameStrategy) || "stable";
         if (classNameStrategy !== "scoped") {
@@ -11621,7 +14401,7 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
           if (options.api && options.watch)
             (await Promise.resolve().then(function () { return setup$1; })).setup(ctx);
         } catch (err) {
-          await ctx.logger.printError(err, { fullStack: true });
+          ctx.logger.printError(err, { fullStack: true });
           process.exit(1);
         }
         if (!options.watch)
@@ -11906,7 +14686,7 @@ function requireClear$1 () {
 	if (hasRequiredClear$1) return clear$1;
 	hasRequiredClear$1 = 1;
 
-	function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+	function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike  ) { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
 	function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
@@ -14865,7 +17645,7 @@ function requireDist () {
 
 	function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-	function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+	function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike  ) { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
 	function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
@@ -18073,6 +20853,9 @@ ${resultBody}`;
   write(data) {
     this.stdout.write(data);
   }
+  getLastResults() {
+    return this.results;
+  }
 }
 
 const keys = [
@@ -18124,8 +20907,10 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout2) {
       return printShortcutsHelp();
     if (name === "u")
       return ctx.updateSnapshot();
-    if (name === "a" || name === "return")
-      return ctx.changeNamePattern("");
+    if (name === "a" || name === "return") {
+      const files = await ctx.getTestFilepaths();
+      return ctx.changeNamePattern("", files, "rerun all tests");
+    }
     if (name === "r")
       return ctx.rerunFiles();
     if (name === "f")
@@ -18144,8 +20929,8 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout2) {
     off();
     const watchFilter = new WatchFilter("Input test name pattern (RegExp)", stdin, stdout2);
     const filter = await watchFilter.filter((str) => {
-      const files = ctx.state.getFiles();
-      const tests = getTests(files);
+      const files2 = ctx.state.getFiles();
+      const tests = getTests(files2);
       try {
         const reg = new RegExp(str);
         return tests.map((test) => test.name).filter((testName) => testName.match(reg));
@@ -18154,7 +20939,9 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout2) {
       }
     });
     on();
-    await ctx.changeNamePattern((filter == null ? void 0 : filter.trim()) || "", void 0, "change pattern");
+    const files = ctx.state.getFilepaths();
+    const cliFiles = ctx.config.standalone && !files.length ? await ctx.getTestFilepaths() : void 0;
+    await ctx.changeNamePattern((filter == null ? void 0 : filter.trim()) || "", cliFiles, "change pattern");
   }
   async function inputProjectName() {
     off();
@@ -18178,7 +20965,11 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout2) {
     });
     on();
     latestFilename = (filter == null ? void 0 : filter.trim()) || "";
-    await ctx.changeFilenamePattern(latestFilename);
+    const lastResults = watchFilter.getLastResults();
+    await ctx.changeFilenamePattern(
+      latestFilename,
+      filter && lastResults.length ? lastResults.map((i) => resolve(ctx.config.root, i)) : void 0
+    );
   }
   let rl;
   function on() {
@@ -18241,10 +21032,16 @@ async function startVitest(mode, cliFilters = [], options = {}, viteOverrides, v
       process.exit(EXIT_CODE_RESTART);
   });
   ctx.onAfterSetServer(() => {
-    ctx.start(cliFilters);
+    if (ctx.config.standalone)
+      ctx.init();
+    else
+      ctx.start(cliFilters);
   });
   try {
-    await ctx.start(cliFilters);
+    if (ctx.config.standalone)
+      await ctx.init();
+    else
+      await ctx.start(cliFilters);
   } catch (e) {
     process.exitCode = 1;
     await ctx.logger.printError(e, { fullStack: true, type: "Unhandled Error" });