vitest 0.10.0 → 0.10.3

package/dist/{chunk-api-setup.d70fc960.js → chunk-api-setup.0baa5b9c.js}

@@ -1,5 +1,5 @@
 import { promises } from 'fs';
-import { c as createBirpc } from './chunk-vite-node-utils.33447cc0.js';
+import { c as createBirpc } from './chunk-vite-node-utils.3cb38009.js';
 import require$$0$1 from 'stream';
 import require$$0 from 'zlib';
 import require$$3 from 'net';
@@ -9,11 +9,11 @@ import require$$2 from 'events';
 import require$$1 from 'https';
 import require$$2$1 from 'http';
 import url from 'url';
-import { A as API_PATH } from './chunk-constants.d540b1d1.js';
-import { r as interpretSourcePos, b as parseStacktrace } from './chunk-utils-timers.12bc05d1.js';
+import { A as API_PATH } from './chunk-constants.54c46a47.js';
+import { r as interpretSourcePos, b as parseStacktrace } from './chunk-utils-timers.8a5e7cd5.js';
 import 'module';
 import 'vm';
-import './chunk-utils-global.37a7c822.js';
+import './chunk-utils-global.eb31f3da.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
@@ -2526,10 +2526,11 @@ const {
 const { format, parse: parse$1 } = extension$1;
 const { toBuffer } = bufferUtil$1.exports;
 
+const closeTimeout = 30 * 1000;
+const kAborted = Symbol('kAborted');
+const protocolVersions = [8, 13];
 const readyStates = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
 const subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
-const protocolVersions = [8, 13];
-const closeTimeout = 30 * 1000;
 
 /**
  * Class representing a WebSocket.
@@ -3143,7 +3144,7 @@ function initAsClient(websocket, address, protocols, options) {
     hostname: undefined,
     protocol: undefined,
     timeout: undefined,
-    method: undefined,
+    method: 'GET',
     host: undefined,
     path: undefined,
     port: undefined
@@ -3197,7 +3198,7 @@ function initAsClient(websocket, address, protocols, options) {
 
   const defaultPort = isSecure ? 443 : 80;
   const key = randomBytes(16).toString('base64');
-  const get = isSecure ? https.get : http$1.get;
+  const request = isSecure ? https.request : http$1.request;
   const protocolSet = new Set();
   let perMessageDeflate;
 
@@ -3262,6 +3263,8 @@ function initAsClient(websocket, address, protocols, options) {
     opts.path = parts[1];
   }
 
+  let req;
+
   if (opts.followRedirects) {
     if (websocket._redirects === 0) {
       websocket._originalHost = parsedUrl.host;
@@ -3279,7 +3282,10 @@ function initAsClient(websocket, address, protocols, options) {
           options.headers[key.toLowerCase()] = value;
         }
       }
-    } else if (parsedUrl.host !== websocket._originalHost) {
+    } else if (
+      websocket.listenerCount('redirect') === 0 &&
+      parsedUrl.host !== websocket._originalHost
+    ) {
       //
       // Match curl 7.77.0 behavior and drop the following headers. These
       // headers are also dropped when following a redirect to a subdomain.
@@ -3299,9 +3305,24 @@ function initAsClient(websocket, address, protocols, options) {
       options.headers.authorization =
         'Basic ' + Buffer.from(opts.auth).toString('base64');
     }
-  }
 
-  let req = (websocket._req = get(opts));
+    req = websocket._req = request(opts);
+
+    if (websocket._redirects) {
+      //
+      // Unlike what is done for the `'upgrade'` event, no early exit is
+      // triggered here if the user calls `websocket.close()` or
+      // `websocket.terminate()` from a listener of the `'redirect'` event. This
+      // is because the user can also call `request.destroy()` with an error
+      // before calling `websocket.close()` or `websocket.terminate()` and this
+      // would result in an error being emitted on the `request` object with no
+      // `'error'` event listeners attached.
+      //
+      websocket.emit('redirect', websocket.url, req);
+    }
+  } else {
+    req = websocket._req = request(opts);
+  }
 
   if (opts.timeout) {
     req.on('timeout', () => {
@@ -3310,7 +3331,7 @@ function initAsClient(websocket, address, protocols, options) {
   }
 
   req.on('error', (err) => {
-    if (req === null || req.aborted) return;
+    if (req === null || req[kAborted]) return;
 
     req = websocket._req = null;
     emitErrorAndClose(websocket, err);
@@ -3357,8 +3378,8 @@ function initAsClient(websocket, address, protocols, options) {
     websocket.emit('upgrade', res);
 
     //
-    // The user may have closed the connection from a listener of the `upgrade`
-    // event.
+    // The user may have closed the connection from a listener of the
+    // `'upgrade'` event.
     //
     if (websocket.readyState !== WebSocket$1.CONNECTING) return;
 
@@ -3443,10 +3464,12 @@ function initAsClient(websocket, address, protocols, options) {
       skipUTF8Validation: opts.skipUTF8Validation
     });
   });
+
+  req.end();
 }
 
 /**
- * Emit the `'error'` and `'close'` event.
+ * Emit the `'error'` and `'close'` events.
  *
  * @param {WebSocket} websocket The WebSocket instance
  * @param {Error} The error to emit
@@ -3503,6 +3526,7 @@ function abortHandshake$1(websocket, stream, message) {
   Error.captureStackTrace(err, abortHandshake$1);
 
   if (stream.setHeader) {
+    stream[kAborted] = true;
     stream.abort();
 
     if (stream.socket && !stream.socket.destroyed) {
@@ -3514,8 +3538,7 @@ function abortHandshake$1(websocket, stream, message) {
       stream.socket.destroy();
     }
 
-    stream.once('abort', websocket.emitClose.bind(websocket));
-    websocket.emit('error', err);
+    process.nextTick(emitErrorAndClose, websocket, err);
   } else {
     stream.destroy(err);
     stream.once('error', websocket.emit.bind(websocket, 'error'));

package/dist/{chunk-constants.d540b1d1.js → chunk-constants.54c46a47.js}

@@ -1,5 +1,5 @@
 import { fileURLToPath } from 'url';
-import { k as resolve } from './chunk-utils-global.37a7c822.js';
+import { k as resolve } from './chunk-utils-global.eb31f3da.js';
 
 const distDir = resolve(fileURLToPath(import.meta.url), "../../dist");
 const defaultPort = 51204;

package/dist/{chunk-defaults.04d5d90b.js → chunk-defaults.c143550b.js}

@@ -1,7 +1,7 @@
 import { existsSync, promises } from 'fs';
 import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
-import { t as toArray, k as resolve } from './chunk-utils-global.37a7c822.js';
+import { t as toArray, k as resolve } from './chunk-utils-global.eb31f3da.js';
 
 const defaultInclude = ["**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"];
 const defaultExclude = ["**/node_modules/**", "**/dist/**", "**/cypress/**", "**/.{idea,git,cache,output,temp}/**"];

package/dist/{chunk-integrations-globals.d2c09cd2.js → chunk-integrations-globals.12eb8517.js}

@@ -1,22 +1,22 @@
-import { g as globalApis } from './chunk-constants.d540b1d1.js';
-import { i as index } from './vendor-entry.369fd6c9.js';
+import { g as globalApis } from './chunk-constants.54c46a47.js';
+import { i as index } from './vendor-entry.2f0617df.js';
 import 'url';
-import './chunk-utils-global.37a7c822.js';
+import './chunk-utils-global.eb31f3da.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
 import 'fs';
 import 'console';
 import 'stream';
-import './chunk-runtime-chain.f863f182.js';
+import './chunk-runtime-chain.0ac0691b.js';
 import 'chai';
 import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-runtime-rpc.8f648236.js';
-import './chunk-utils-timers.12bc05d1.js';
+import './chunk-runtime-rpc.710f6f7f.js';
+import './chunk-utils-timers.8a5e7cd5.js';
 import './chunk-integrations-spy.f036df6f.js';
 import 'tinyspy';
 import 'util';
-import './chunk-defaults.04d5d90b.js';
+import './chunk-defaults.c143550b.js';
 import 'module';
 import 'crypto';
 

package/dist/{chunk-runtime-chain.f863f182.js → chunk-runtime-chain.0ac0691b.js}

@@ -1,9 +1,9 @@
 import chai$1, { expect as expect$1, util } from 'chai';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.addc3445.js';
-import { r as rpc } from './chunk-runtime-rpc.8f648236.js';
-import { i as isObject, a as index, g as getCallLastIndex, s as slash, b as getWorkerState, c as getNames, d as assertTypes, p as picocolors, n as noop, t as toArray, r as resetModules } from './chunk-utils-global.37a7c822.js';
+import { r as rpc } from './chunk-runtime-rpc.710f6f7f.js';
+import { i as isObject, a as index, g as getCallLastIndex, s as slash, b as getWorkerState, c as getNames, d as assertTypes, p as picocolors, n as noop, t as toArray, r as resetModules } from './chunk-utils-global.eb31f3da.js';
 import fs, { promises } from 'fs';
-import { p as plugins_1, f as format_1, g as getOriginalPos, a as posToNumber, n as numberToPos, l as lineSplitRE, b as parseStacktrace, u as unifiedDiff, s as stringify, m as matcherUtils, c as setTimeout, d as clearTimeout } from './chunk-utils-timers.12bc05d1.js';
+import { p as plugins_1, f as format_1, g as getOriginalPos, a as posToNumber, n as numberToPos, l as lineSplitRE, b as parseStacktrace, u as unifiedDiff, s as stringify, m as matcherUtils, c as setTimeout, d as clearTimeout } from './chunk-utils-timers.8a5e7cd5.js';
 import { i as isMockFunction, s as spyOn, f as fn, a as spies } from './chunk-integrations-spy.f036df6f.js';
 import require$$0, { format } from 'util';
 
@@ -534,14 +534,18 @@ ${snapshots.join("\n\n")}
 }
 function prepareExpected(expected) {
   function findStartIndent() {
-    var _a;
-    const match = /^( +)}\s+$/m.exec(expected || "");
-    return ((_a = match == null ? void 0 : match[1]) == null ? void 0 : _a.length) || 0;
+    var _a, _b;
+    const matchObject = /^( +)}\s+$/m.exec(expected || "");
+    const objectIndent = (_a = matchObject == null ? void 0 : matchObject[1]) == null ? void 0 : _a.length;
+    if (objectIndent)
+      return objectIndent;
+    const matchText = /^\n( +)"/.exec(expected || "");
+    return ((_b = matchText == null ? void 0 : matchText[1]) == null ? void 0 : _b.length) || 0;
   }
-  const startIdent = findStartIndent();
+  const startIndent = findStartIndent();
   let expectedTrimmed = expected == null ? void 0 : expected.trim();
-  if (startIdent) {
-    expectedTrimmed = expectedTrimmed == null ? void 0 : expectedTrimmed.replace(new RegExp(`^${" ".repeat(startIdent)}`, "gm"), "").replace(/ +}$/, "}");
+  if (startIndent) {
+    expectedTrimmed = expectedTrimmed == null ? void 0 : expectedTrimmed.replace(new RegExp(`^${" ".repeat(startIndent)}`, "gm"), "").replace(/ +}$/, "}");
   }
   return expectedTrimmed;
 }
@@ -898,7 +902,17 @@ class SnapshotClient {
   clearTest() {
     this.test = void 0;
   }
-  assert(received, test = this.test, message, isInline = false, properties, inlineSnapshot, error) {
+  assert(options) {
+    const {
+      test = this.test,
+      message,
+      isInline = false,
+      properties,
+      inlineSnapshot,
+      error,
+      errorMessage
+    } = options;
+    let { received } = options;
     if (!test)
       throw new Error("Snapshot cannot be used outside of test");
     if (typeof properties === "object") {
@@ -911,7 +925,7 @@ class SnapshotClient {
         else
           received = deepMergeSnapshot(received, properties);
       } catch (err) {
-        err.message = "Snapshot mismatched";
+        err.message = errorMessage || "Snapshot mismatched";
         throw err;
       }
     }
@@ -931,7 +945,7 @@ class SnapshotClient {
       try {
         expect$1(actual.trim()).equals(expected ? expected.trim() : "");
       } catch (error2) {
-        error2.message = `Snapshot \`${key || "unknown"}\` mismatched`;
+        error2.message = errorMessage || `Snapshot \`${key || "unknown"}\` mismatched`;
         throw error2;
       }
     }
@@ -973,7 +987,15 @@ const SnapshotPlugin = (chai, utils) => {
         message = properties;
         properties = void 0;
       }
-      getSnapshotClient().assert(expected, test, message, false, properties);
+      const errorMessage = utils.flag(this, "message");
+      getSnapshotClient().assert({
+        received: expected,
+        test,
+        message,
+        isInline: false,
+        properties,
+        errorMessage
+      });
     });
   }
   utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", function __VITEST_INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
@@ -987,18 +1009,43 @@ const SnapshotPlugin = (chai, utils) => {
     }
     if (inlineSnapshot)
       inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
-    getSnapshotClient().assert(expected, test, message, true, properties, inlineSnapshot, error);
+    const errorMessage = utils.flag(this, "message");
+    getSnapshotClient().assert({
+      received: expected,
+      test,
+      message,
+      isInline: true,
+      properties,
+      inlineSnapshot,
+      error,
+      errorMessage
+    });
   });
   utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", function(message) {
     const expected = utils.flag(this, "object");
     const test = utils.flag(this, "vitest-test");
-    getSnapshotClient().assert(getErrorString(expected), test, message);
+    const errorMessage = utils.flag(this, "message");
+    getSnapshotClient().assert({
+      received: getErrorString(expected),
+      test,
+      message,
+      errorMessage
+    });
   });
   utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", function __VITEST_INLINE_SNAPSHOT__(inlineSnapshot, message) {
     const expected = utils.flag(this, "object");
     const error = utils.flag(this, "error");
     const test = utils.flag(this, "vitest-test");
-    getSnapshotClient().assert(getErrorString(expected), test, message, true, void 0, inlineSnapshot, error);
+    const errorMessage = utils.flag(this, "message");
+    getSnapshotClient().assert({
+      received: getErrorString(expected),
+      test,
+      message,
+      inlineSnapshot,
+      isInline: true,
+      error,
+      errorMessage
+    });
   });
 };
 
@@ -1307,8 +1354,8 @@ Number of calls: ${picocolors.exports.bold(spy.mock.calls.length)}
   def(["toHaveReturnedTimes", "toReturnTimes"], function(times) {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
-    const successfullReturns = spy.mock.results.reduce((success, { type }) => type === "throw" ? success : ++success, 0);
-    this.assert(successfullReturns === times, `expected "${spyName}" to be successfully called ${times} times`, `expected "${spyName}" to not be successfully called ${times} times`, `expected number of returns: ${times}`, `received number of returns: ${successfullReturns}`);
+    const successfulReturns = spy.mock.results.reduce((success, { type }) => type === "throw" ? success : ++success, 0);
+    this.assert(successfulReturns === times, `expected "${spyName}" to be successfully called ${times} times`, `expected "${spyName}" to not be successfully called ${times} times`, `expected number of returns: ${times}`, `received number of returns: ${successfulReturns}`);
   });
   def(["toHaveReturnedWith", "toReturnWith"], function(value) {
     const spy = getSpy(this);
@@ -1764,7 +1811,7 @@ function withTimeout(fn, timeout = getDefaultTestTimeout(), isHook = false) {
 }
 function createTestContext(test) {
   const context = function() {
-    throw new Error("done() callback is deperated, use promise instead");
+    throw new Error("done() callback is deprecated, use promise instead");
   };
   context.meta = test;
   let _expect;
@@ -1919,6 +1966,8 @@ function createSuite() {
       });
     };
   };
+  suite2.skipIf = (condition) => condition ? suite2.skip : suite2;
+  suite2.runIf = (condition) => condition ? suite2 : suite2.skip;
   return suite2;
 }
 function createTest(fn) {
@@ -1931,6 +1980,8 @@ function createTest(fn) {
       });
     };
   };
+  test2.skipIf = (condition) => condition ? test2.skip : test2;
+  test2.runIf = (condition) => condition ? test2 : test2.skip;
   return test2;
 }
 
@@ -4632,8 +4683,10 @@ class VitestUtils {
     });
     this._mocker = typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : null;
     this._mockedDate = null;
-    if (!this._mocker)
-      throw new Error("Vitest was initialized with native Node instead of Vite Node");
+    if (!this._mocker) {
+      const errorMsg = 'Vitest was initialized with native Node instead of Vite Node.\n\nOne of the following is possible:\n- "vitest" is imported outside of your tests (in that case, use "vitest/node" or import.meta.vitest)\n- "vitest" is imported inside "globalSetup" (use "setupFiles", because "globalSetup" runs in a different context)\n- Your dependency inside "node_modules" imports "vitest" directly (in that case, inline that dependency, using "deps.inline" config)\n- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues\n';
+      throw new Error(errorMsg);
+    }
   }
   useFakeTimers() {
     this._timers.useFakeTimers();

package/dist/{chunk-runtime-mocker.111ac858.js → chunk-runtime-mocker.89015cf8.js}

@@ -1,8 +1,8 @@
-import { n as normalizeRequestId, i as isNodeBuiltin, t as toFilePath, V as ViteNodeRunner } from './chunk-vite-node-utils.33447cc0.js';
+import { n as normalizeRequestId, i as isNodeBuiltin, t as toFilePath, V as ViteNodeRunner } from './chunk-vite-node-utils.3cb38009.js';
 import { normalizePath } from 'vite';
-import { b as getWorkerState, B as isWindows, C as mergeSlashes, h as dirname, f as basename, k as resolve, s as slash } from './chunk-utils-global.37a7c822.js';
+import { b as getWorkerState, D as isWindows, E as mergeSlashes, h as dirname, f as basename, k as resolve, F as getType, G as getAllProperties, s as slash } from './chunk-utils-global.eb31f3da.js';
 import { existsSync, readdirSync } from 'fs';
-import { d as distDir } from './chunk-constants.d540b1d1.js';
+import { d as distDir } from './chunk-constants.54c46a47.js';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
@@ -20,22 +20,6 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-function getType(value) {
-  return Object.prototype.toString.apply(value).slice(8, -1);
-}
-function getAllProperties(obj) {
-  const allProps = /* @__PURE__ */ new Set();
-  let curr = obj;
-  do {
-    if (curr === Object.prototype || curr === Function.prototype || curr === RegExp.prototype)
-      break;
-    const props = Object.getOwnPropertyNames(curr);
-    const symbs = Object.getOwnPropertySymbols(curr);
-    props.forEach((prop) => allProps.add(prop));
-    symbs.forEach((symb) => allProps.add(symb));
-  } while (curr = Object.getPrototypeOf(curr));
-  return Array.from(allProps);
-}
 const _VitestMocker = class {
   constructor(options, moduleCache, request) {
     this.options = options;
@@ -136,8 +120,8 @@ const _VitestMocker = class {
     else if (type !== "Object" && type !== "Module")
       return value;
     const newObj = {};
-    const proproperties = getAllProperties(value);
-    for (const k of proproperties) {
+    const properties = getAllProperties(value);
+    for (const k of properties) {
       newObj[k] = this.mockValue(value[k]);
       const type2 = getType(value[k]);
       if (type2.includes("Function") && !value[k]._isMockFunction) {

package/dist/{chunk-runtime-rpc.8f648236.js → chunk-runtime-rpc.710f6f7f.js}

@@ -1,4 +1,4 @@
-import { b as getWorkerState } from './chunk-utils-global.37a7c822.js';
+import { b as getWorkerState } from './chunk-utils-global.eb31f3da.js';
 
 const rpc = () => {
   return getWorkerState().rpc;

package/dist/{chunk-utils-global.37a7c822.js → chunk-utils-global.eb31f3da.js}

@@ -250,6 +250,19 @@ function getWorkerState() {
   return globalThis.__vitest_worker__;
 }
 
+function getAllProperties(obj) {
+  const allProps = /* @__PURE__ */ new Set();
+  let curr = obj;
+  do {
+    if (curr === Object.prototype || curr === Function.prototype || curr === RegExp.prototype)
+      break;
+    const props = Object.getOwnPropertyNames(curr);
+    const symbs = Object.getOwnPropertySymbols(curr);
+    props.forEach((prop) => allProps.add(prop));
+    symbs.forEach((symb) => allProps.add(symb));
+  } while (curr = Object.getPrototypeOf(curr));
+  return Array.from(allProps);
+}
 function notNullish(v) {
   return v != null;
 }
@@ -261,6 +274,27 @@ function mergeSlashes(str) {
 }
 const noop = () => {
 };
+function getType(value) {
+  return Object.prototype.toString.apply(value).slice(8, -1);
+}
+function clone(val) {
+  let k, out, tmp;
+  if (Array.isArray(val)) {
+    out = Array(k = val.length);
+    while (k--)
+      out[k] = (tmp = val[k]) && typeof tmp === "object" ? clone(tmp) : tmp;
+    return out;
+  }
+  if (Object.prototype.toString.call(val) === "[object Object]") {
+    out = Object.create(Object.getPrototypeOf(val));
+    const props = getAllProperties(val);
+    for (const k2 of props) {
+      out[k2] = (tmp = val[k2]) && typeof tmp === "object" ? clone(tmp) : tmp;
+    }
+    return out;
+  }
+  return val;
+}
 function toArray(array) {
   if (array === null || array === void 0)
     array = [];
@@ -301,6 +335,9 @@ function assertTypes(value, name, types) {
   if (!pass)
     throw new TypeError(`${name} value must be ${types.join(" or ")}, received "${receivedType}"`);
 }
+function stdout() {
+  return console._stdout || process.stdout;
+}
 
 function getTests(suite) {
   return toArray(suite).flatMap((s) => s.type === "test" ? [s] : s.tasks.flatMap((c) => c.type === "test" ? [c] : getTests(c)));
@@ -420,4 +457,4 @@ function getCallLastIndex(code) {
   return null;
 }
 
-export { extname as A, isWindows as B, mergeSlashes as C, partitionSuiteChildren as D, hasTests as E, index as a, getWorkerState as b, getNames as c, assertTypes as d, notNullish as e, basename as f, getCallLastIndex as g, dirname as h, isObject as i, join as j, resolve as k, isAbsolute as l, relative as m, noop as n, getTests as o, picocolors as p, getFullName as q, resetModules as r, slash as s, toArray as t, hasFailed as u, hasFailedSnapshot as v, getSuites as w, deepMerge as x, toNamespacedPath as y, ensurePackageInstalled as z };
+export { ensurePackageInstalled as A, stdout as B, extname as C, isWindows as D, mergeSlashes as E, getType as F, getAllProperties as G, clone as H, partitionSuiteChildren as I, hasTests as J, index as a, getWorkerState as b, getNames as c, assertTypes as d, notNullish as e, basename as f, getCallLastIndex as g, dirname as h, isObject as i, join as j, resolve as k, isAbsolute as l, relative as m, noop as n, getTests as o, picocolors as p, getFullName as q, resetModules as r, slash as s, toArray as t, hasFailed as u, hasFailedSnapshot as v, getSuites as w, normalize as x, deepMerge as y, toNamespacedPath as z };

package/dist/{chunk-utils-timers.12bc05d1.js → chunk-utils-timers.8a5e7cd5.js}

@@ -1,4 +1,4 @@
-import { s as slash, e as notNullish, p as picocolors } from './chunk-utils-global.37a7c822.js';
+import { s as slash, e as notNullish, p as picocolors } from './chunk-utils-global.eb31f3da.js';
 
 const setTimeout$1 = globalThis.setTimeout;
 const setInterval = globalThis.setInterval;
@@ -5656,6 +5656,8 @@ const stackBarePathRE = /at ?(.*) (.+):(\d+):(\d+)$/;
 async function interpretSourcePos(stackFrames, ctx) {
   var _a;
   for (const frame of stackFrames) {
+    if ("sourcePos" in frame)
+      continue;
     const transformResult = (_a = ctx.server.moduleGraph.getModuleById(frame.file)) == null ? void 0 : _a.ssrTransformResult;
     if (!transformResult)
       continue;