vitest 0.22.1 → 0.23.2

package/dist/{chunk-runtime-error.1104e45a.mjs → chunk-runtime-error.2723946b.mjs}

@@ -1,15 +1,23 @@
-import { e as environments, t as takeCoverageInsideWorker, p as pLimit } from './chunk-integrations-coverage.d205bd87.mjs';
-import { r as resetRunOnceCounter, i as index, v as vi } from './chunk-runtime-hooks.5d7073db.mjs';
-import { f as deepClone, h as getType, j as isNode, R as RealDate, t as toArray, k as relativePath, l as isBrowser, p as partitionSuiteChildren, o as shuffle, q as hasTests, u as hasFailed, d as getFullName } from './chunk-mock-date.304e29b1.mjs';
-import { e as clearCollectorContext, f as defaultSuite, h as setHooks, j as getHooks, k as collectorContext, l as setState, G as GLOBAL_EXPECT, m as getFn, n as getState } from './chunk-runtime-chain.be610650.mjs';
-import { r as rpc } from './chunk-runtime-rpc.57586b73.mjs';
+import { performance } from 'perf_hooks';
+import { t as takeCoverageInsideWorker, p as pLimit } from './chunk-integrations-coverage.99c020eb.mjs';
+import { r as resetRunOnceCounter, i as index, v as vi } from './chunk-runtime-hooks.1a0bc3fd.mjs';
+import { k as deepClone, l as getType, o as isNode, g as getWorkerState, R as RealDate, t as toArray, p as relativePath, q as isBrowser, h as isRunningInBenchmark, u as partitionSuiteChildren, v as shuffle, w as hasTests, x as hasFailed, y as createDefer, e as getFullName } from './chunk-mock-date.2917be60.mjs';
+import { f as clearCollectorContext, h as defaultSuite, j as setHooks, k as getHooks, l as collectorContext, m as getFn, n as setState, G as GLOBAL_EXPECT, o as getState } from './chunk-runtime-chain.7a7f3c3b.mjs';
+import { r as rpc } from './chunk-runtime-rpc.00a890d2.mjs';
 import util$1 from 'util';
 import { util } from 'chai';
-import { s as stringify } from './chunk-utils-source-map.bbf3ad19.mjs';
-import { g as getWorkerState } from './chunk-utils-global.fa20c2f6.mjs';
+import { s as stringify } from './chunk-utils-source-map.2be5aa48.mjs';
+import { e as environments } from './chunk-env-node.ceb43f1c.mjs';
 import { a as safeClearTimeout, s as safeSetTimeout } from './chunk-utils-timers.b48455ed.mjs';
 
 const OBJECT_PROTO = Object.getPrototypeOf({});
+function getUnserializableMessage(err) {
+  if (err instanceof Error)
+    return `<unserializable>: ${err.message}`;
+  if (typeof err === "string")
+    return `<unserializable>: ${err}`;
+  return "<unserializable>";
+}
 function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
   if (!val || typeof val === "string")
     return val;
@@ -17,7 +25,7 @@ function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
     return `Function<${val.name}>`;
   if (typeof val !== "object")
     return val;
-  if (val instanceof Promise || "then" in val || val.constructor && val.constructor.prototype === "AsyncFunction")
+  if (val instanceof Promise || val.constructor && val.constructor.prototype === "AsyncFunction")
     return "Promise";
   if (typeof Element !== "undefined" && val instanceof Element)
     return val.tagName;
@@ -29,7 +37,11 @@ function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
     const clone = new Array(val.length);
     seen.set(val, clone);
     val.forEach((e, i) => {
-      clone[i] = serializeError(e, seen);
+      try {
+        clone[i] = serializeError(e, seen);
+      } catch (err) {
+        clone[i] = getUnserializableMessage(err);
+      }
     });
     return clone;
   } else {
@@ -38,8 +50,14 @@ function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
     let obj = val;
     while (obj && obj !== OBJECT_PROTO) {
       Object.getOwnPropertyNames(obj).forEach((key) => {
-        if (!(key in clone))
+        if (key in clone)
+          return;
+        try {
           clone[key] = serializeError(obj[key], seen);
+        } catch (err) {
+          delete clone[key];
+          clone[key] = getUnserializableMessage(err);
+        }
       });
       obj = Object.getPrototypeOf(obj);
     }
@@ -50,7 +68,7 @@ function normalizeErrorMessage(message) {
   return message.replace(/__vite_ssr_import_\d+__\./g, "");
 }
 function processError(err) {
-  if (!err)
+  if (!err || typeof err !== "object")
     return err;
   if (err.stack)
     err.stackStr = String(err.stack);
@@ -105,7 +123,12 @@ function replaceAsymmetricMatcher(actual, expected, actualReplaced = /* @__PURE_
       if (actualValue.asymmetricMatch(expectedValue))
         expected[key] = actualValue;
     } else if (isReplaceable(actualValue, expectedValue)) {
-      const replaced = replaceAsymmetricMatcher(actualValue, expectedValue, actualReplaced, expectedReplaced);
+      const replaced = replaceAsymmetricMatcher(
+        actualValue,
+        expectedValue,
+        actualReplaced,
+        expectedReplaced
+      );
       actual[key] = replaced.replacedActual;
       expected[key] = replaced.replacedExpected;
     }
@@ -131,7 +154,7 @@ async function setupGlobalEnv(config) {
   if (isNode)
     await setupConsoleLogSpy();
   if (config.globals)
-    (await import('./chunk-integrations-globals.60af7da3.mjs')).registerApiGlobally();
+    (await import('./chunk-integrations-globals.ad5b1b51.mjs')).registerApiGlobally();
 }
 function setupDefines(defines) {
   for (const key in defines)
@@ -243,8 +266,18 @@ async function setupConsoleLogSpy() {
     groupIndentation: 2
   });
 }
+async function loadEnvironment(name) {
+  const pkg = await import(`vitest-environment-${name}`);
+  if (!pkg || !pkg.default || typeof pkg.default !== "object" || typeof pkg.default.setup !== "function") {
+    throw new Error(
+      `Environment "${name}" is not a valid environment. Package "vitest-environment-${name}" should have default export with "setup" method.`
+    );
+  }
+  return pkg.default;
+}
 async function withEnv(name, options, fn) {
-  const env = await environments[name].setup(globalThis, options);
+  const config = environments[name] || await loadEnvironment(name);
+  const env = await config.setup(globalThis, options);
   try {
     await fn();
   } finally {
@@ -253,10 +286,12 @@ async function withEnv(name, options, fn) {
 }
 async function runSetupFiles(config) {
   const files = toArray(config.setupFiles);
-  await Promise.all(files.map(async (fsPath) => {
-    getWorkerState().moduleCache.delete(fsPath);
-    await import(fsPath);
-  }));
+  await Promise.all(
+    files.map(async (fsPath) => {
+      getWorkerState().moduleCache.delete(fsPath);
+      await import(fsPath);
+    })
+  );
 }
 
 const now$1 = Date.now;
@@ -307,9 +342,11 @@ async function collectTests(paths, config) {
       for (const c of [...defaultTasks.tasks, ...collectorContext.tasks]) {
         if (c.type === "test") {
           file.tasks.push(c);
+        } else if (c.type === "benchmark") {
+          file.tasks.push(c);
         } else if (c.type === "suite") {
           file.tasks.push(c);
-        } else {
+        } else if (c.type === "collector") {
           const suite = await c.collect(file);
           if (suite.name || suite.tasks.length)
             file.tasks.push(suite);
@@ -394,6 +431,11 @@ function calculateHash(parent) {
   });
 }
 
+async function importTinybench() {
+  if (!globalThis.EventTarget)
+    await import('./vendor-index.0557b03a.mjs').then(function (n) { return n.i; });
+  return await import('tinybench');
+}
 const now = Date.now;
 function updateSuiteHookState(suite, name, state) {
   var _a;
@@ -410,13 +452,19 @@ function updateSuiteHookState(suite, name, state) {
 async function callSuiteHook(suite, currentTask, name, args) {
   const callbacks = [];
   if (name === "beforeEach" && suite.suite) {
-    callbacks.push(...await callSuiteHook(suite.suite, currentTask, name, args));
+    callbacks.push(
+      ...await callSuiteHook(suite.suite, currentTask, name, args)
+    );
   }
   updateSuiteHookState(currentTask, name, "run");
-  callbacks.push(...await Promise.all(getHooks(suite)[name].map((fn) => fn(...args))));
+  callbacks.push(
+    ...await Promise.all(getHooks(suite)[name].map((fn) => fn(...args)))
+  );
   updateSuiteHookState(currentTask, name, "pass");
   if (name === "afterEach" && suite.suite) {
-    callbacks.push(...await callSuiteHook(suite.suite, currentTask, name, args));
+    callbacks.push(
+      ...await callSuiteHook(suite.suite, currentTask, name, args)
+    );
   }
   return callbacks;
 }
@@ -442,7 +490,7 @@ async function sendTasksUpdate() {
 async function runTest(test) {
   var _a, _b;
   if (test.mode !== "run") {
-    const { getSnapshotClient } = await import('./chunk-runtime-chain.be610650.mjs').then(function (n) { return n.p; });
+    const { getSnapshotClient } = await import('./chunk-runtime-chain.7a7f3c3b.mjs').then(function (n) { return n.q; });
     getSnapshotClient().skipTestSnapshots(test);
     return;
   }
@@ -458,46 +506,53 @@ async function runTest(test) {
   updateTask(test);
   clearModuleMocks();
   if (isNode) {
-    const { getSnapshotClient } = await import('./chunk-runtime-chain.be610650.mjs').then(function (n) { return n.p; });
+    const { getSnapshotClient } = await import('./chunk-runtime-chain.7a7f3c3b.mjs').then(function (n) { return n.q; });
     await getSnapshotClient().setTest(test);
   }
   const workerState = getWorkerState();
   workerState.current = test;
-  let beforeEachCleanups = [];
-  try {
-    beforeEachCleanups = await callSuiteHook(test.suite, test, "beforeEach", [test.context, test.suite]);
-    setState({
-      assertionCalls: 0,
-      isExpectingAssertions: false,
-      isExpectingAssertionsError: null,
-      expectedAssertionsNumber: null,
-      expectedAssertionsNumberErrorGen: null,
-      testPath: (_b = test.suite.file) == null ? void 0 : _b.filepath,
-      currentTestName: getFullName(test)
-    }, globalThis[GLOBAL_EXPECT]);
-    await getFn(test)();
-    const {
-      assertionCalls,
-      expectedAssertionsNumber,
-      expectedAssertionsNumberErrorGen,
-      isExpectingAssertions,
-      isExpectingAssertionsError
-    } = test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
-    if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber)
-      throw expectedAssertionsNumberErrorGen();
-    if (isExpectingAssertions === true && assertionCalls === 0)
-      throw isExpectingAssertionsError;
-    test.result.state = "pass";
-  } catch (e) {
-    test.result.state = "fail";
-    test.result.error = processError(e);
-  }
-  try {
-    await callSuiteHook(test.suite, test, "afterEach", [test.context, test.suite]);
-    await Promise.all(beforeEachCleanups.map((i) => i == null ? void 0 : i()));
-  } catch (e) {
-    test.result.state = "fail";
-    test.result.error = processError(e);
+  const retry = test.retry || 1;
+  for (let retryCount = 0; retryCount < retry; retryCount++) {
+    let beforeEachCleanups = [];
+    try {
+      beforeEachCleanups = await callSuiteHook(test.suite, test, "beforeEach", [test.context, test.suite]);
+      setState({
+        assertionCalls: 0,
+        isExpectingAssertions: false,
+        isExpectingAssertionsError: null,
+        expectedAssertionsNumber: null,
+        expectedAssertionsNumberErrorGen: null,
+        testPath: (_b = test.suite.file) == null ? void 0 : _b.filepath,
+        currentTestName: getFullName(test)
+      }, globalThis[GLOBAL_EXPECT]);
+      test.result.retryCount = retryCount;
+      await getFn(test)();
+      const {
+        assertionCalls,
+        expectedAssertionsNumber,
+        expectedAssertionsNumberErrorGen,
+        isExpectingAssertions,
+        isExpectingAssertionsError
+      } = test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
+      if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber)
+        throw expectedAssertionsNumberErrorGen();
+      if (isExpectingAssertions === true && assertionCalls === 0)
+        throw isExpectingAssertionsError;
+      test.result.state = "pass";
+    } catch (e) {
+      test.result.state = "fail";
+      test.result.error = processError(e);
+    }
+    try {
+      await callSuiteHook(test.suite, test, "afterEach", [test.context, test.suite]);
+      await Promise.all(beforeEachCleanups.map((i) => i == null ? void 0 : i()));
+    } catch (e) {
+      test.result.state = "fail";
+      test.result.error = processError(e);
+    }
+    if (test.result.state === "pass")
+      break;
+    updateTask(test);
   }
   if (test.fails) {
     if (test.result.state === "pass") {
@@ -511,7 +566,7 @@ async function runTest(test) {
   if (isBrowser && test.result.error)
     console.error(test.result.error.message, test.result.error.stackStr);
   if (isNode) {
-    const { getSnapshotClient } = await import('./chunk-runtime-chain.be610650.mjs').then(function (n) { return n.p; });
+    const { getSnapshotClient } = await import('./chunk-runtime-chain.7a7f3c3b.mjs').then(function (n) { return n.q; });
     getSnapshotClient().clearTest();
   }
   test.result.duration = now() - start;
@@ -550,20 +605,24 @@ async function runSuite(suite) {
   } else {
     try {
       const beforeAllCleanups = await callSuiteHook(suite, suite, "beforeAll", [suite]);
-      for (let tasksGroup of partitionSuiteChildren(suite)) {
-        if (tasksGroup[0].concurrent === true) {
-          const mutex = pLimit(workerState.config.maxConcurrency);
-          await Promise.all(tasksGroup.map((c) => mutex(() => runSuiteChild(c))));
-        } else {
-          const { sequence } = workerState.config;
-          if (sequence.shuffle || suite.shuffle) {
-            const suites = tasksGroup.filter((group) => group.type === "suite");
-            const tests = tasksGroup.filter((group) => group.type === "test");
-            const groups = shuffle([suites, tests], sequence.seed);
-            tasksGroup = groups.flatMap((group) => shuffle(group, sequence.seed));
+      if (isRunningInBenchmark()) {
+        await runBenchmarkSuit(suite);
+      } else {
+        for (let tasksGroup of partitionSuiteChildren(suite)) {
+          if (tasksGroup[0].concurrent === true) {
+            const mutex = pLimit(workerState.config.maxConcurrency);
+            await Promise.all(tasksGroup.map((c) => mutex(() => runSuiteChild(c))));
+          } else {
+            const { sequence } = workerState.config;
+            if (sequence.shuffle || suite.shuffle) {
+              const suites = tasksGroup.filter((group) => group.type === "suite");
+              const tests = tasksGroup.filter((group) => group.type === "test");
+              const groups = shuffle([suites, tests], sequence.seed);
+              tasksGroup = groups.flatMap((group) => shuffle(group, sequence.seed));
+            }
+            for (const c of tasksGroup)
+              await runSuiteChild(c);
           }
-          for (const c of tasksGroup)
-            await runSuiteChild(c);
         }
       }
       await callSuiteHook(suite, suite, "afterAll", [suite]);
@@ -589,8 +648,93 @@ async function runSuite(suite) {
   }
   updateTask(suite);
 }
+function createBenchmarkResult(name) {
+  return {
+    name,
+    rank: 0,
+    rme: 0,
+    samples: []
+  };
+}
+async function runBenchmarkSuit(suite) {
+  const { Task, Bench } = await importTinybench();
+  const start = performance.now();
+  const benchmarkGroup = [];
+  const benchmarkSuiteGroup = [];
+  for (const task of suite.tasks) {
+    if (task.type === "benchmark")
+      benchmarkGroup.push(task);
+    else if (task.type === "suite")
+      benchmarkSuiteGroup.push(task);
+  }
+  if (benchmarkSuiteGroup.length)
+    await Promise.all(benchmarkSuiteGroup.map((subSuite) => runBenchmarkSuit(subSuite)));
+  if (benchmarkGroup.length) {
+    const defer = createDefer();
+    const benchmarkMap = {};
+    suite.result = {
+      state: "run",
+      startTime: start,
+      benchmark: createBenchmarkResult(suite.name)
+    };
+    updateTask(suite);
+    benchmarkGroup.forEach((benchmark, idx) => {
+      const benchmarkInstance = new Bench(benchmark.options);
+      const benchmarkFn = getFn(benchmark);
+      benchmark.result = {
+        state: "run",
+        startTime: start,
+        benchmark: createBenchmarkResult(benchmark.name)
+      };
+      const id = idx.toString();
+      benchmarkMap[id] = benchmark;
+      const task = new Task(benchmarkInstance, id, benchmarkFn);
+      benchmark.task = task;
+      updateTask(benchmark);
+    });
+    benchmarkGroup.forEach((benchmark) => {
+      benchmark.task.addEventListener("complete", (e) => {
+        const task = e.task;
+        const _benchmark = benchmarkMap[task.name || ""];
+        if (_benchmark) {
+          const taskRes = task.result;
+          const result = _benchmark.result.benchmark;
+          Object.assign(result, taskRes);
+          updateTask(_benchmark);
+        }
+      });
+      benchmark.task.addEventListener("error", (e) => {
+        defer.reject(e);
+      });
+    });
+    Promise.all(benchmarkGroup.map(async (benchmark) => {
+      await benchmark.task.warmup();
+      return await new Promise((resolve) => safeSetTimeout(async () => {
+        resolve(await benchmark.task.run());
+      }));
+    })).then((tasks) => {
+      suite.result.duration = performance.now() - start;
+      suite.result.state = "pass";
+      tasks.sort((a, b) => a.result.mean - b.result.mean).forEach((cycle, idx) => {
+        const benchmark = benchmarkMap[cycle.name || ""];
+        benchmark.result.state = "pass";
+        if (benchmark) {
+          const result = benchmark.result.benchmark;
+          result.rank = Number(idx) + 1;
+          updateTask(benchmark);
+        }
+      });
+      updateTask(suite);
+      defer.resolve(null);
+    });
+    await defer;
+  }
+}
 async function runSuiteChild(c) {
-  return c.type === "test" ? runTest(c) : runSuite(c);
+  if (c.type === "test")
+    return runTest(c);
+  else if (c.type === "suite")
+    return runSuite(c);
 }
 async function runSuites(suites) {
   for (const suite of suites)
@@ -623,7 +767,7 @@ async function startTestsBrowser(paths, config) {
 async function startTestsNode(paths, config) {
   const files = await collectTests(paths, config);
   rpc().onCollected(files);
-  const { getSnapshotClient } = await import('./chunk-runtime-chain.be610650.mjs').then(function (n) { return n.p; });
+  const { getSnapshotClient } = await import('./chunk-runtime-chain.7a7f3c3b.mjs').then(function (n) { return n.q; });
   getSnapshotClient().clear();
   await runFiles(files, config);
   const coverage = await takeCoverageInsideWorker(config.coverage);

package/dist/{chunk-runtime-hooks.5d7073db.mjs → chunk-runtime-hooks.1a0bc3fd.mjs}

@@ -1,7 +1,6 @@
-import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it, c as createExpect, b as globalExpect } from './chunk-runtime-chain.be610650.mjs';
-import { R as RealDate, r as resetDate, m as mockDate, a as resetModules } from './chunk-mock-date.304e29b1.mjs';
-import { g as getWorkerState } from './chunk-utils-global.fa20c2f6.mjs';
-import { p as parseStacktrace } from './chunk-utils-source-map.bbf3ad19.mjs';
+import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it, b as bench, c as createExpect, e as globalExpect } from './chunk-runtime-chain.7a7f3c3b.mjs';
+import { g as getWorkerState, R as RealDate, r as resetDate, m as mockDate, a as resetModules } from './chunk-mock-date.2917be60.mjs';
+import { p as parseStacktrace } from './chunk-utils-source-map.2be5aa48.mjs';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.4da45ef5.mjs';
 import util from 'util';
 import { spyOn, fn, isMockFunction, spies } from './spy.mjs';
@@ -15,12 +14,14 @@ const beforeEach = (fn, timeout) => getCurrentSuite().on("beforeEach", withTimeo
 const afterEach = (fn, timeout) => getCurrentSuite().on("afterEach", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
 
 function withCallback(fn) {
-  return new Promise((resolve, reject) => fn((err) => {
-    if (err)
-      reject(err);
-    else
-      resolve();
-  }));
+  return new Promise(
+    (resolve, reject) => fn((err) => {
+      if (err)
+        reject(err);
+      else
+        resolve();
+    })
+  );
 }
 
 const filesCount = /* @__PURE__ */ new Map();
@@ -2608,7 +2609,9 @@ class FakeTimers {
   }
   useFakeTimers() {
     if (this._fakingDate) {
-      throw new Error('"setSystemTime" was called already and date was mocked. Reset timers using `vi.useRealTimers()` if you want to use fake timers again.');
+      throw new Error(
+        '"setSystemTime" was called already and date was mocked. Reset timers using `vi.useRealTimers()` if you want to use fake timers again.'
+      );
     }
     if (!this._fakingTime) {
       const toFake = Object.keys(this._fakeTimers.timers);
@@ -2648,7 +2651,9 @@ class FakeTimers {
   }
   _checkFakeTimers() {
     if (!this._fakingTime) {
-      throw new Error('Timers are not mocked. Try calling "vi.useFakeTimers()" first.');
+      throw new Error(
+        'Timers are not mocked. Try calling "vi.useFakeTimers()" first.'
+      );
     }
     return this._fakingTime;
   }
@@ -2805,6 +2810,7 @@ var index = /*#__PURE__*/Object.freeze({
   test: test,
   describe: describe,
   it: it,
+  bench: bench,
   runOnce: runOnce,
   isFirstRun: isFirstRun,
   beforeAll: beforeAll,

package/dist/{chunk-runtime-mocker.49d21aa6.mjs → chunk-runtime-mocker.8d4a2494.mjs}

@@ -1,10 +1,9 @@
-import { V as ViteNodeRunner } from './chunk-vite-node-client.cddda63d.mjs';
+import { V as ViteNodeRunner } from './chunk-vite-node-client.da0a17ff.mjs';
 import { normalizePath } from 'vite';
-import { C as isWindows, D as mergeSlashes, s as slash, h as getType, E as getAllMockableProperties } from './chunk-mock-date.304e29b1.mjs';
+import { g as getWorkerState, G as mergeSlashes, s as slash, l as getType, H as getAllMockableProperties } from './chunk-mock-date.2917be60.mjs';
 import { existsSync, readdirSync } from 'fs';
-import { n as normalizeRequestId, i as isNodeBuiltin, b as toFilePath } from './chunk-vite-node-utils.b432150c.mjs';
+import { n as normalizeRequestId, p as pathFromRoot, i as isNodeBuiltin, b as toFilePath } from './chunk-vite-node-utils.473cd0b2.mjs';
 import { d as dirname, j as join, b as basename, a as resolve, c as distDir } from './chunk-constants.71e8a211.mjs';
-import { g as getWorkerState } from './chunk-utils-global.fa20c2f6.mjs';
 
 class RefTracker {
   constructor() {
@@ -102,12 +101,12 @@ const _VitestMocker = class {
     return this.getMocks()[id];
   }
   normalizePath(path) {
-    return normalizeRequestId(path.replace(this.root, ""), this.base).replace(/^\/@fs\//, isWindows ? "" : "/");
+    return pathFromRoot(this.root, normalizeRequestId(path, this.base));
   }
   getFsPath(path, external) {
     if (external)
       return mergeSlashes(`/@fs/${path}`);
-    return normalizeRequestId(path.replace(this.root, ""));
+    return normalizeRequestId(path, this.base);
   }
   resolveMockPath(mockPath, external) {
     const path = normalizeRequestId(external || mockPath);
@@ -132,7 +131,9 @@ const _VitestMocker = class {
   }
   mockObject(object) {
     if (!_VitestMocker.spyModule) {
-      throw new Error("Error: Spy module is not defined. This is likely an internal bug in Vitest. Please report it to https://github.com/vitest-dev/vitest/issues");
+      throw new Error(
+        "Error: Spy module is not defined. This is likely an internal bug in Vitest. Please report it to https://github.com/vitest-dev/vitest/issues"
+      );
     }
     const spyModule = _VitestMocker.spyModule;
     const finalizers = new Array();
@@ -149,15 +150,18 @@ const _VitestMocker = class {
       const containerType = getType(container);
       const isModule = containerType === "Module" || !!container.__esModule;
       for (const { key: property, descriptor } of getAllMockableProperties(container)) {
-        if (!isModule) {
-          if (descriptor.get || descriptor.set)
-            continue;
+        if (!isModule && descriptor.get) {
+          try {
+            Object.defineProperty(newContainer, property, descriptor);
+          } catch (error) {
+          }
+          continue;
         }
         if (isSpecialProp(property, containerType))
           continue;
         const value = container[property];
         const refId = refs.getId(value);
-        if (refId) {
+        if (refId !== void 0) {
           finalizers.push(() => define(newContainer, property, refs.getMockedValue(refId)));
           continue;
         }
@@ -193,6 +197,9 @@ const _VitestMocker = class {
     const mock = this.mockMap.get(suitefile);
     if (mock == null ? void 0 : mock[id])
       delete mock[id];
+    const mockId = this.getMockPath(id);
+    if (this.moduleCache.get(mockId))
+      this.moduleCache.delete(mockId);
   }
   mockPath(path, external, factory) {
     const suitefile = this.getSuiteFilepath();

package/dist/{chunk-runtime-rpc.57586b73.mjs → chunk-runtime-rpc.00a890d2.mjs}

@@ -1,5 +1,4 @@
-import './chunk-mock-date.304e29b1.mjs';
-import { g as getWorkerState } from './chunk-utils-global.fa20c2f6.mjs';
+import { g as getWorkerState } from './chunk-mock-date.2917be60.mjs';
 import { w as withSafeTimers } from './chunk-utils-timers.b48455ed.mjs';
 
 const rpc = () => {

package/dist/{chunk-utils-source-map.bbf3ad19.mjs → chunk-utils-source-map.2be5aa48.mjs}

@@ -1,4 +1,4 @@
-import { s as slash, e as notNullish } from './chunk-mock-date.304e29b1.mjs';
+import { s as slash, j as notNullish } from './chunk-mock-date.2917be60.mjs';
 import { p as picocolors } from './chunk-constants.71e8a211.mjs';
 
 var build = {};
@@ -5725,7 +5725,9 @@ function numberToPos(source, offset) {
   if (typeof offset !== "number")
     return offset;
   if (offset > source.length) {
-    throw new Error(`offset is longer than source length! offset ${offset} > length ${source.length}`);
+    throw new Error(
+      `offset is longer than source length! offset ${offset} > length ${source.length}`
+    );
   }
   const lines = source.split(lineSplitRE);
   let counted = 0;
@@ -7323,7 +7325,11 @@ function unifiedDiff(actual, expected, options = {}) {
       const last = formatted.length - 1;
       if (formatted[last].endsWith('"'))
         formatted[last] = formatted[last].slice(0, formatted[last].length - 1);
-      formatted.unshift(picocolors.exports.green(`- Expected  - ${counts["-"]}`), picocolors.exports.red(`+ Received  + ${counts["+"]}`), "");
+      formatted.unshift(
+        picocolors.exports.green(`- Expected  - ${counts["-"]}`),
+        picocolors.exports.red(`+ Received  + ${counts["+"]}`),
+        ""
+      );
     }
   }
   return formatted.map((i) => indent + i).join("\n");
@@ -7436,4 +7442,4 @@ var matcherUtils = /*#__PURE__*/Object.freeze({
 	diff: diff
 });
 
-export { plugins_1 as a, posToNumber as b, stripAnsi as c, cliTruncate as d, stringWidth as e, format_1 as f, getOriginalPos as g, ansiStyles as h, sliceAnsi as i, interpretSourcePos as j, lineSplitRE as l, matcherUtils as m, numberToPos as n, parseStacktrace as p, stringify as s, unifiedDiff as u };
+export { plugins_1 as a, posToNumber as b, stripAnsi as c, cliTruncate as d, stringWidth as e, format_1 as f, getOriginalPos as g, ansiStyles as h, interpretSourcePos as i, sliceAnsi as j, lineSplitRE as l, matcherUtils as m, numberToPos as n, parseStacktrace as p, stringify as s, unifiedDiff as u };