vitest 2.0.3 → 2.0.4

package/dist/vendor/{cli-api.CsgSG1Ir.js → cli-api.CTkP2Ier.js}

@@ -17,14 +17,14 @@ import require$$0$3 from 'fs';
 import { ViteNodeRunner } from 'vite-node/client';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { ViteNodeServer } from 'vite-node/server';
-import { v as version$1 } from './cac.DUiZvzF_.js';
+import { v as version$1 } from './cac.DFtWvZc2.js';
 import { hasFailed, createFileTask, getTasks, getTests, getNames } from '@vitest/runner/utils';
-import { n as noop$1, 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.CTYV4Gnz.js';
+import { n as noop$1, 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.DRHPZCCj.js';
 import { createDefer, toArray as toArray$1, notNullish } from '@vitest/utils';
 import { b as isWindows } from './env.2ltrQNq0.js';
 import { rootDir, distDir } from '../path.js';
 import { c as createBirpc } from './index.BpSiYbpB.js';
-import { s as stringify, p as parse$3, w as wrapSerializableConfig, f as Typechecker, R as ReportersMap, d as BenchmarkReportsMap, g as RandomSequencer, e as BaseSequencer, h as findNodeAround, i as generateCodeFrame, j as highlightCode, L as Logger, k as BlobReporter, r as readBlobs } from './index.BCwvoAaf.js';
+import { s as stringify, p as parse$3, w as wrapSerializableConfig, f as Typechecker, R as ReportersMap, d as BenchmarkReportsMap, g as RandomSequencer, e as BaseSequencer, h as findNodeAround, i as generateCodeFrame, j as highlightCode, L as Logger, k as BlobReporter, r as readBlobs } from './index.CuuL9y4g.js';
 import require$$0$5 from 'zlib';
 import require$$0$6 from 'buffer';
 import require$$1 from 'crypto';
@@ -54,7 +54,7 @@ import MagicString from 'magic-string';
 import { esmWalker } from '@vitest/utils/ast';
 import { a as removeUndefinedValues } from './index.BJmtb_7W.js';
 import readline from 'node:readline';
-import { s as stripAnsi } from './utils.DyTe1Nxn.js';
+import { s as stripAnsi } from './utils.BySfPUwy.js';
 
 async function getModuleGraph(ctx, projectName, id, browser = false) {
   const graph = {};
@@ -3358,10 +3358,16 @@ var fg = /*@__PURE__*/getDefaultExportFromCjs(out);
 
 var bufferUtil$1 = {exports: {}};
 
+const BINARY_TYPES$2 = ['nodebuffer', 'arraybuffer', 'fragments'];
+const hasBlob$1 = typeof Blob !== 'undefined';
+
+if (hasBlob$1) BINARY_TYPES$2.push('blob');
+
 var constants = {
-  BINARY_TYPES: ['nodebuffer', 'arraybuffer', 'fragments'],
+  BINARY_TYPES: BINARY_TYPES$2,
   EMPTY_BUFFER: Buffer.alloc(0),
   GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
+  hasBlob: hasBlob$1,
   kForOnEventAttribute: Symbol('kIsForOnEventAttribute'),
   kListener: Symbol('kListener'),
   kStatusCode: Symbol('status-code'),
@@ -4077,6 +4083,8 @@ var isValidUTF8_1;
 
 const { isUtf8 } = require$$0$6;
 
+const { hasBlob } = constants;
+
 //
 // Allowed token characters:
 //
@@ -4182,7 +4190,27 @@ function _isValidUTF8(buf) {
   return true;
 }
 
+/**
+ * Determines whether a value is a `Blob`.
+ *
+ * @param {*} value The value to be tested
+ * @return {Boolean} `true` if `value` is a `Blob`, else `false`
+ * @private
+ */
+function isBlob$2(value) {
+  return (
+    hasBlob &&
+    typeof value === 'object' &&
+    typeof value.arrayBuffer === 'function' &&
+    typeof value.type === 'string' &&
+    typeof value.stream === 'function' &&
+    (value[Symbol.toStringTag] === 'Blob' ||
+      value[Symbol.toStringTag] === 'File')
+  );
+}
+
 validation.exports = {
+  isBlob: isBlob$2,
   isValidStatusCode: isValidStatusCode$2,
   isValidUTF8: _isValidUTF8,
   tokenChars: tokenChars$2
@@ -4213,7 +4241,7 @@ const {
   BINARY_TYPES: BINARY_TYPES$1,
   EMPTY_BUFFER: EMPTY_BUFFER$2,
   kStatusCode: kStatusCode$1,
-  kWebSocket: kWebSocket$2
+  kWebSocket: kWebSocket$3
 } = constants;
 const { concat, toArrayBuffer, unmask } = bufferUtilExports;
 const { isValidStatusCode: isValidStatusCode$1, isValidUTF8 } = validationExports;
@@ -4262,7 +4290,7 @@ let Receiver$1 = class Receiver extends Writable {
     this._isServer = !!options.isServer;
     this._maxPayload = options.maxPayload | 0;
     this._skipUTF8Validation = !!options.skipUTF8Validation;
-    this[kWebSocket$2] = undefined;
+    this[kWebSocket$3] = undefined;
 
     this._bufferedBytes = 0;
     this._buffers = [];
@@ -4765,6 +4793,8 @@ let Receiver$1 = class Receiver extends Writable {
         data = concat(fragments, messageLength);
       } else if (this._binaryType === 'arraybuffer') {
         data = toArrayBuffer(concat(fragments, messageLength));
+      } else if (this._binaryType === 'blob') {
+        data = new Blob(fragments);
       } else {
         data = fragments;
       }
@@ -4913,8 +4943,8 @@ var receiver = Receiver$1;
 const { randomFillSync } = require$$1;
 
 const PerMessageDeflate$2 = permessageDeflate;
-const { EMPTY_BUFFER: EMPTY_BUFFER$1 } = constants;
-const { isValidStatusCode } = validationExports;
+const { EMPTY_BUFFER: EMPTY_BUFFER$1, kWebSocket: kWebSocket$2, NOOP: NOOP$1 } = constants;
+const { isBlob: isBlob$1, isValidStatusCode } = validationExports;
 const { mask: applyMask, toBuffer: toBuffer$1 } = bufferUtilExports;
 
 const kByteLength = Symbol('kByteLength');
@@ -4923,6 +4953,10 @@ const RANDOM_POOL_SIZE = 8 * 1024;
 let randomPool;
 let randomPoolPointer = RANDOM_POOL_SIZE;
 
+const DEFAULT = 0;
+const DEFLATING = 1;
+const GET_BLOB_DATA = 2;
+
 /**
  * HyBi Sender implementation.
  */
@@ -4949,8 +4983,10 @@ let Sender$1 = class Sender {
     this._compress = false;
 
     this._bufferedBytes = 0;
-    this._deflating = false;
     this._queue = [];
+    this._state = DEFAULT;
+    this.onerror = NOOP$1;
+    this[kWebSocket$2] = undefined;
   }
 
   /**
@@ -5117,7 +5153,7 @@ let Sender$1 = class Sender {
       rsv1: false
     };
 
-    if (this._deflating) {
+    if (this._state !== DEFAULT) {
       this.enqueue([this.dispatch, buf, false, options, cb]);
     } else {
       this.sendFrame(Sender.frame(buf, options), cb);
@@ -5139,6 +5175,9 @@ let Sender$1 = class Sender {
     if (typeof data === 'string') {
       byteLength = Buffer.byteLength(data);
       readOnly = false;
+    } else if (isBlob$1(data)) {
+      byteLength = data.size;
+      readOnly = false;
     } else {
       data = toBuffer$1(data);
       byteLength = data.length;
@@ -5160,7 +5199,13 @@ let Sender$1 = class Sender {
       rsv1: false
     };
 
-    if (this._deflating) {
+    if (isBlob$1(data)) {
+      if (this._state !== DEFAULT) {
+        this.enqueue([this.getBlobData, data, false, options, cb]);
+      } else {
+        this.getBlobData(data, false, options, cb);
+      }
+    } else if (this._state !== DEFAULT) {
       this.enqueue([this.dispatch, data, false, options, cb]);
     } else {
       this.sendFrame(Sender.frame(data, options), cb);
@@ -5182,6 +5227,9 @@ let Sender$1 = class Sender {
     if (typeof data === 'string') {
       byteLength = Buffer.byteLength(data);
       readOnly = false;
+    } else if (isBlob$1(data)) {
+      byteLength = data.size;
+      readOnly = false;
     } else {
       data = toBuffer$1(data);
       byteLength = data.length;
@@ -5203,7 +5251,13 @@ let Sender$1 = class Sender {
       rsv1: false
     };
 
-    if (this._deflating) {
+    if (isBlob$1(data)) {
+      if (this._state !== DEFAULT) {
+        this.enqueue([this.getBlobData, data, false, options, cb]);
+      } else {
+        this.getBlobData(data, false, options, cb);
+      }
+    } else if (this._state !== DEFAULT) {
       this.enqueue([this.dispatch, data, false, options, cb]);
     } else {
       this.sendFrame(Sender.frame(data, options), cb);
@@ -5237,6 +5291,9 @@ let Sender$1 = class Sender {
     if (typeof data === 'string') {
       byteLength = Buffer.byteLength(data);
       readOnly = false;
+    } else if (isBlob$1(data)) {
+      byteLength = data.size;
+      readOnly = false;
     } else {
       data = toBuffer$1(data);
       byteLength = data.length;
@@ -5264,40 +5321,94 @@ let Sender$1 = class Sender {
 
     if (options.fin) this._firstFragment = true;
 
-    if (perMessageDeflate) {
-      const opts = {
-        [kByteLength]: byteLength,
-        fin: options.fin,
-        generateMask: this._generateMask,
-        mask: options.mask,
-        maskBuffer: this._maskBuffer,
-        opcode,
-        readOnly,
-        rsv1
-      };
+    const opts = {
+      [kByteLength]: byteLength,
+      fin: options.fin,
+      generateMask: this._generateMask,
+      mask: options.mask,
+      maskBuffer: this._maskBuffer,
+      opcode,
+      readOnly,
+      rsv1
+    };
 
-      if (this._deflating) {
-        this.enqueue([this.dispatch, data, this._compress, opts, cb]);
+    if (isBlob$1(data)) {
+      if (this._state !== DEFAULT) {
+        this.enqueue([this.getBlobData, data, this._compress, opts, cb]);
       } else {
-        this.dispatch(data, this._compress, opts, cb);
+        this.getBlobData(data, this._compress, opts, cb);
       }
+    } else if (this._state !== DEFAULT) {
+      this.enqueue([this.dispatch, data, this._compress, opts, cb]);
     } else {
-      this.sendFrame(
-        Sender.frame(data, {
-          [kByteLength]: byteLength,
-          fin: options.fin,
-          generateMask: this._generateMask,
-          mask: options.mask,
-          maskBuffer: this._maskBuffer,
-          opcode,
-          readOnly,
-          rsv1: false
-        }),
-        cb
-      );
+      this.dispatch(data, this._compress, opts, cb);
     }
   }
 
+  /**
+   * Gets the contents of a blob as binary data.
+   *
+   * @param {Blob} blob The blob
+   * @param {Boolean} [compress=false] Specifies whether or not to compress
+   *     the data
+   * @param {Object} options Options object
+   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+   *     FIN bit
+   * @param {Function} [options.generateMask] The function used to generate the
+   *     masking key
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+   *     key
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+   *     modified
+   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+   *     RSV1 bit
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  getBlobData(blob, compress, options, cb) {
+    this._bufferedBytes += options[kByteLength];
+    this._state = GET_BLOB_DATA;
+
+    blob
+      .arrayBuffer()
+      .then((arrayBuffer) => {
+        if (this._socket.destroyed) {
+          const err = new Error(
+            'The socket was closed while the blob was being read'
+          );
+
+          //
+          // `callCallbacks` is called in the next tick to ensure that errors
+          // that might be thrown in the callbacks behave like errors thrown
+          // outside the promise chain.
+          //
+          process.nextTick(callCallbacks, this, err, cb);
+          return;
+        }
+
+        this._bufferedBytes -= options[kByteLength];
+        const data = toBuffer$1(arrayBuffer);
+
+        if (!compress) {
+          this._state = DEFAULT;
+          this.sendFrame(Sender.frame(data, options), cb);
+          this.dequeue();
+        } else {
+          this.dispatch(data, compress, options, cb);
+        }
+      })
+      .catch((err) => {
+        //
+        // `onError` is called in the next tick for the same reason that
+        // `callCallbacks` above is.
+        //
+        process.nextTick(onError, this, err, cb);
+      });
+  }
+
   /**
    * Dispatches a message.
    *
@@ -5330,27 +5441,19 @@ let Sender$1 = class Sender {
     const perMessageDeflate = this._extensions[PerMessageDeflate$2.extensionName];
 
     this._bufferedBytes += options[kByteLength];
-    this._deflating = true;
+    this._state = DEFLATING;
     perMessageDeflate.compress(data, options.fin, (_, buf) => {
       if (this._socket.destroyed) {
         const err = new Error(
           'The socket was closed while data was being compressed'
         );
 
-        if (typeof cb === 'function') cb(err);
-
-        for (let i = 0; i < this._queue.length; i++) {
-          const params = this._queue[i];
-          const callback = params[params.length - 1];
-
-          if (typeof callback === 'function') callback(err);
-        }
-
+        callCallbacks(this, err, cb);
         return;
       }
 
       this._bufferedBytes -= options[kByteLength];
-      this._deflating = false;
+      this._state = DEFAULT;
       options.readOnly = false;
       this.sendFrame(Sender.frame(buf, options), cb);
       this.dequeue();
@@ -5363,7 +5466,7 @@ let Sender$1 = class Sender {
    * @private
    */
   dequeue() {
-    while (!this._deflating && this._queue.length) {
+    while (this._state === DEFAULT && this._queue.length) {
       const params = this._queue.shift();
 
       this._bufferedBytes -= params[3][kByteLength];
@@ -5403,6 +5506,38 @@ let Sender$1 = class Sender {
 
 var sender = Sender$1;
 
+/**
+ * Calls queued callbacks with an error.
+ *
+ * @param {Sender} sender The `Sender` instance
+ * @param {Error} err The error to call the callbacks with
+ * @param {Function} [cb] The first callback
+ * @private
+ */
+function callCallbacks(sender, err, cb) {
+  if (typeof cb === 'function') cb(err);
+
+  for (let i = 0; i < sender._queue.length; i++) {
+    const params = sender._queue[i];
+    const callback = params[params.length - 1];
+
+    if (typeof callback === 'function') callback(err);
+  }
+}
+
+/**
+ * Handles a `Sender` error.
+ *
+ * @param {Sender} sender The `Sender` instance
+ * @param {Error} err The error
+ * @param {Function} [cb] The first pending callback
+ * @private
+ */
+function onError(sender, err, cb) {
+  callCallbacks(sender, err, cb);
+  sender.onerror(err);
+}
+
 const { kForOnEventAttribute: kForOnEventAttribute$1, kListener: kListener$1 } = constants;
 
 const kCode = Symbol('kCode');
@@ -5909,6 +6044,8 @@ const { URL: URL$1 } = require$$7;
 const PerMessageDeflate$1 = permessageDeflate;
 const Receiver = receiver;
 const Sender = sender;
+const { isBlob } = validationExports;
+
 const {
   BINARY_TYPES,
   EMPTY_BUFFER,
@@ -5953,6 +6090,7 @@ let WebSocket$1 = class WebSocket extends EventEmitter$1 {
     this._closeFrameSent = false;
     this._closeMessage = EMPTY_BUFFER;
     this._closeTimer = null;
+    this._errorEmitted = false;
     this._extensions = {};
     this._paused = false;
     this._protocol = '';
@@ -5985,9 +6123,8 @@ let WebSocket$1 = class WebSocket extends EventEmitter$1 {
   }
 
   /**
-   * This deviates from the WHATWG interface since ws doesn't support the
-   * required default "blob" type (instead we define a custom "nodebuffer"
-   * type).
+   * For historical reasons, the custom "nodebuffer" type is used by the default
+   * instead of "blob".
    *
    * @type {String}
    */
@@ -6108,11 +6245,14 @@ let WebSocket$1 = class WebSocket extends EventEmitter$1 {
       skipUTF8Validation: options.skipUTF8Validation
     });
 
-    this._sender = new Sender(socket, this._extensions, options.generateMask);
+    const sender = new Sender(socket, this._extensions, options.generateMask);
+
     this._receiver = receiver;
+    this._sender = sender;
     this._socket = socket;
 
     receiver[kWebSocket$1] = this;
+    sender[kWebSocket$1] = this;
     socket[kWebSocket$1] = this;
 
     receiver.on('conclude', receiverOnConclude);
@@ -6122,6 +6262,8 @@ let WebSocket$1 = class WebSocket extends EventEmitter$1 {
     receiver.on('ping', receiverOnPing);
     receiver.on('pong', receiverOnPong);
 
+    sender.onerror = senderOnError;
+
     //
     // These methods may not be available if `socket` is just a `Duplex`.
     //
@@ -6217,13 +6359,7 @@ let WebSocket$1 = class WebSocket extends EventEmitter$1 {
       }
     });
 
-    //
-    // Specify a timeout for the closing handshake to complete.
-    //
-    this._closeTimer = setTimeout(
-      this._socket.destroy.bind(this._socket),
-      closeTimeout
-    );
+    setCloseTimer(this);
   }
 
   /**
@@ -6927,6 +7063,11 @@ function initAsClient(websocket, address, protocols, options) {
  */
 function emitErrorAndClose(websocket, err) {
   websocket._readyState = WebSocket$1.CLOSING;
+  //
+  // The following assignment is practically useless and is done only for
+  // consistency.
+  //
+  websocket._errorEmitted = true;
   websocket.emit('error', err);
   websocket.emitClose();
 }
@@ -7007,7 +7148,7 @@ function abortHandshake$1(websocket, stream, message) {
  */
 function sendAfterClose(websocket, data, cb) {
   if (data) {
-    const length = toBuffer(data).length;
+    const length = isBlob(data) ? data.size : toBuffer(data).length;
 
     //
     // The `_bufferedAmount` property is used only when the peer is a client and
@@ -7083,7 +7224,10 @@ function receiverOnError(err) {
     websocket.close(err[kStatusCode]);
   }
 
-  websocket.emit('error', err);
+  if (!websocket._errorEmitted) {
+    websocket._errorEmitted = true;
+    websocket.emit('error', err);
+  }
 }
 
 /**
@@ -7139,6 +7283,47 @@ function resume(stream) {
   stream.resume();
 }
 
+/**
+ * The `Sender` error event handler.
+ *
+ * @param {Error} The error
+ * @private
+ */
+function senderOnError(err) {
+  const websocket = this[kWebSocket$1];
+
+  if (websocket.readyState === WebSocket$1.CLOSED) return;
+  if (websocket.readyState === WebSocket$1.OPEN) {
+    websocket._readyState = WebSocket$1.CLOSING;
+    setCloseTimer(websocket);
+  }
+
+  //
+  // `socket.end()` is used instead of `socket.destroy()` to allow the other
+  // peer to finish sending queued data. There is no need to set a timer here
+  // because `CLOSING` means that it is already set or not needed.
+  //
+  this._socket.end();
+
+  if (!websocket._errorEmitted) {
+    websocket._errorEmitted = true;
+    websocket.emit('error', err);
+  }
+}
+
+/**
+ * Set a timer to destroy the underlying raw socket of a WebSocket.
+ *
+ * @param {WebSocket} websocket The WebSocket instance
+ * @private
+ */
+function setCloseTimer(websocket) {
+  websocket._closeTimer = setTimeout(
+    websocket._socket.destroy.bind(websocket._socket),
+    closeTimeout
+  );
+}
+
 /**
  * The listener of the socket `'close'` event.
  *
@@ -8048,9 +8233,11 @@ async function groupFilesByEnv(files) {
         project.config.testTransformMode,
         file
       );
-      const envOptions = JSON.parse(
-        ((_b = code.match(/@(?:vitest|jest)-environment-options\s+?(.+)/)) == null ? void 0 : _b[1]) || "null"
-      );
+      let envOptionsJson = (_b = code.match(/@(?:vitest|jest)-environment-options\s+(.+)/)) == null ? void 0 : _b[1];
+      if (envOptionsJson == null ? void 0 : envOptionsJson.endsWith("*/")) {
+        envOptionsJson = envOptionsJson.slice(0, -2);
+      }
+      const envOptions = JSON.parse(envOptionsJson || "null");
       const envKey = env === "happy-dom" ? "happyDOM" : env;
       const environment = {
         name: env,
@@ -11607,7 +11794,6 @@ const coverageConfigDefaults = {
     ".mjs",
     ".ts",
     ".mts",
-    ".cts",
     ".tsx",
     ".jsx",
     ".vue",
@@ -14187,7 +14373,7 @@ class VitestPackageInstaller {
       try {
         targetRequire.resolve(dependency, { paths: [root, __dirname] });
         return true;
-      } catch (error) {
+      } catch {
       }
     }
     if (/* @__PURE__ */ isPackageExists(dependency, { paths: [root, __dirname] })) {

package/dist/vendor/{execute.Dx503nGn.js → execute.jzOWtys_.js}

@@ -7,7 +7,7 @@ import { resolve, isAbsolute, dirname, join, basename, extname, normalize, relat
 import { processError } from '@vitest/utils/error';
 import { distDir } from '../path.js';
 import { highlight, getType } from '@vitest/utils';
-import { g as getAllMockableProperties } from './base.CTYV4Gnz.js';
+import { g as getAllMockableProperties } from './base.DRHPZCCj.js';
 
 const { existsSync, readdirSync } = fs;
 const spyModulePath = resolve(distDir, "spy.js");
@@ -271,7 +271,7 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
         if (!isModule && descriptor.get) {
           try {
             Object.defineProperty(newContainer, property, descriptor);
-          } catch (error) {
+          } catch {
           }
           continue;
         }

package/dist/vendor/{index.CROIsoiT.js → index.CVqMv71L.js}

@@ -4,7 +4,7 @@ import { distDir } from '../path.js';
 import { g as getWorkerState } from './global.7bFbnyXl.js';
 import { r as rpc } from './rpc.BGx7q_k2.js';
 import { t as takeCoverageInsideWorker } from './coverage.BhYSDdTT.js';
-import { l as loadDiffConfig, a as loadSnapshotSerializers } from './setup-common.yHaxjRhz.js';
+import { l as loadDiffConfig, a as loadSnapshotSerializers } from './setup-common.symvFZPh.js';
 
 function setupChaiConfig(config) {
   Object.assign(chai.config, config);

package/dist/vendor/{index.BCwvoAaf.js → index.CuuL9y4g.js}

@@ -3,15 +3,15 @@ import c from 'tinyrainbow';
 import * as pathe from 'pathe';
 import { basename, dirname, resolve, join, relative, extname, normalize } from 'pathe';
 import { g as getTestName, h as hasFailedSnapshot, a as getFullName } from './tasks.DhVtQBtW.js';
-import { getSafeTimers, notNullish, highlight, shuffle, inspect, positionToOffset, lineSplitRE } from '@vitest/utils';
+import { notNullish, highlight, shuffle, inspect, positionToOffset, lineSplitRE } from '@vitest/utils';
 import { i as isNode, a as isDeno } from './env.2ltrQNq0.js';
-import { g as getStateSymbol, f as formatProjectName, t as taskFail, F as F_RIGHT, a as F_POINTER, r as renderSnapshotSummary, b as getStateString, c as formatTimeString, d as countTestErrors, e as divider, s as stripAnsi, h as getCols, i as getHookStateSymbol } from './utils.DyTe1Nxn.js';
+import { g as getStateSymbol, f as formatProjectName, t as taskFail, F as F_RIGHT, a as F_POINTER, r as renderSnapshotSummary, b as getStateString, c as formatTimeString, d as countTestErrors, e as divider, s as stripAnsi, h as getCols, i as getHookStateSymbol } from './utils.BySfPUwy.js';
 import { generateHash, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, getTasks, getTests, hasFailed, getSuites } from '@vitest/runner/utils';
 import { performance } from 'node:perf_hooks';
 import { TraceMap, generatedPositionFor, parseStacktrace, parseErrorStacktrace } from '@vitest/utils/source-map';
 import { r as relativePath } from './index.BJmtb_7W.js';
 import { UNKNOWN_TEST_ID } from '../chunks/runtime-console.C2L2zykk.js';
-import { t as toArray, b as isPrimitive } from './base.CTYV4Gnz.js';
+import { t as toArray, b as isPrimitive } from './base.DRHPZCCj.js';
 import { isCI } from 'std-env';
 import nodeos__default, { hostname } from 'node:os';
 import { Writable } from 'node:stream';
@@ -1173,7 +1173,6 @@ class BaseReporter {
       ];
       this.ctx.logger.logUpdate(BADGE_PADDING + LAST_RUN_TEXTS[0]);
       this._lastRunTimeout = 0;
-      const { setInterval } = getSafeTimers();
       this._lastRunTimer = setInterval(() => {
         this._lastRunTimeout += 1;
         if (this._lastRunTimeout >= LAST_RUN_TEXTS.length) {
@@ -1187,7 +1186,6 @@ class BaseReporter {
     }
   }
   resetLastRunLog() {
-    const { clearInterval } = getSafeTimers();
     clearInterval(this._lastRunTimer);
     this._lastRunTimer = void 0;
     this.ctx.logger.logUpdate.clear();

package/dist/vendor/{index.Hqvcg1pf.js → index.DI9daj1Q.js}

@@ -1,7 +1,7 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
 import { b as bench } from './benchmark.B6pblCp2.js';
 import { i as isFirstRun, a as runOnce } from './run-once.Db8Hgq9X.js';
-import { c as createExpect, a as globalExpect, v as vi, b as vitest } from './vi.DXACdGTu.js';
+import { c as createExpect, a as globalExpect, v as vi, b as vitest } from './vi.Elqer9-7.js';
 import { g as getWorkerState } from './global.7bFbnyXl.js';
 import * as chai from 'chai';
 import { assert, should } from 'chai';

package/dist/vendor/{setup-common.yHaxjRhz.js → setup-common.symvFZPh.js}

@@ -13,7 +13,7 @@ async function setupCommonEnv(config) {
   globalSetup = true;
   setSafeTimers();
   if (config.globals) {
-    (await import('../chunks/integrations-globals.CzYWb38r.js')).registerApiGlobally();
+    (await import('../chunks/integrations-globals.nDMtdOcn.js')).registerApiGlobally();
   }
 }
 function setupDefines(defines) {

package/dist/vendor/{utils.DyTe1Nxn.js → utils.BySfPUwy.js}

@@ -1,6 +1,6 @@
 import { isAbsolute, relative, dirname, basename } from 'pathe';
 import c from 'tinyrainbow';
-import { a as slash } from './base.CTYV4Gnz.js';
+import { a as slash } from './base.DRHPZCCj.js';
 
 const F_RIGHT = "\u2192";
 const F_DOWN = "\u2193";

package/dist/vendor/{vi.DXACdGTu.js → vi.Elqer9-7.js}

@@ -11,7 +11,7 @@ import { getSafeTimers, assertTypes, createSimpleStackTrace } from '@vitest/util
 import 'pathe';
 import './env.2ltrQNq0.js';
 import { parseSingleStack } from '@vitest/utils/source-map';
-import { i as isChildProcess } from './base.CTYV4Gnz.js';
+import { i as isChildProcess } from './base.DRHPZCCj.js';
 import { R as RealDate, r as resetDate, m as mockDate } from './date.W2xKR2qe.js';
 import { spyOn, fn, isMockFunction, mocks } from '@vitest/spy';