@assistant-ui/react 0.11.36 → 0.11.38

package/dist/tests/setup.js

@@ -1,9 +1,9 @@
-// ../../node_modules/.pnpm/vitest@4.0.6_@types+debug@4.1.12_@types+node@24.10.0_@vitest+ui@4.0.6_jiti@2.6.1_jsdom@_38fcb34f3d4da47a9b9d4b13a6949560/node_modules/vitest/dist/chunks/vi.BZvkKVkM.js
+// ../../node_modules/.pnpm/vitest@4.0.8_@types+debug@4.1.12_@types+node@24.10.1_@vitest+ui@4.0.8_jiti@2.6.1_jsdom@_c97fdea49f1663602bf3dfb16acdd85d/node_modules/vitest/dist/chunks/vi.Bgcdy3bQ.js
 import { chai, equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers } from "@vitest/expect.js";
 import { getCurrentTest } from "@vitest/runner.js";
 import { getNames, getTestName } from "@vitest/runner/utils.js";
 
-// ../../node_modules/.pnpm/vitest@4.0.6_@types+debug@4.1.12_@types+node@24.10.0_@vitest+ui@4.0.6_jiti@2.6.1_jsdom@_38fcb34f3d4da47a9b9d4b13a6949560/node_modules/vitest/dist/chunks/utils.CG9h5ccR.js
+// ../../node_modules/.pnpm/vitest@4.0.8_@types+debug@4.1.12_@types+node@24.10.1_@vitest+ui@4.0.8_jiti@2.6.1_jsdom@_c97fdea49f1663602bf3dfb16acdd85d/node_modules/vitest/dist/chunks/utils.DvEY5TfP.js
 import { getSafeTimers } from "@vitest/utils/timers.js";
 var NAME_WORKER_STATE = "__vitest_worker__";
 function getWorkerState() {
@@ -22,7 +22,11 @@ function resetModules(modules, resetMocks = false) {
     ...!resetMocks ? [/^mock:/] : []
   ];
   modules.idToModuleMap.forEach((node, path) => {
-    skipPaths.some((re) => re.test(path)) || (node.promise = void 0, node.exports = void 0, node.evaluated = false, node.importers.clear());
+    if (skipPaths.some((re) => re.test(path))) return;
+    node.promise = void 0;
+    node.exports = void 0;
+    node.evaluated = false;
+    node.importers.clear();
   });
 }
 function waitNextTick() {
@@ -31,12 +35,16 @@ function waitNextTick() {
 }
 async function waitForImportsToResolve() {
   await waitNextTick();
-  const state = getWorkerState(), promises = [], resolvingCount = state.resolvingModules.size;
+  const state = getWorkerState();
+  const promises = [];
+  const resolvingCount = state.resolvingModules.size;
   for (const [_, mod] of state.evaluatedModules.idToModuleMap) if (mod.promise && !mod.evaluated) promises.push(mod.promise);
-  !promises.length && !resolvingCount || (await Promise.allSettled(promises), await waitForImportsToResolve());
+  if (!promises.length && !resolvingCount) return;
+  await Promise.allSettled(promises);
+  await waitForImportsToResolve();
 }
 
-// ../../node_modules/.pnpm/vitest@4.0.6_@types+debug@4.1.12_@types+node@24.10.0_@vitest+ui@4.0.6_jiti@2.6.1_jsdom@_38fcb34f3d4da47a9b9d4b13a6949560/node_modules/vitest/dist/chunks/vi.BZvkKVkM.js
+// ../../node_modules/.pnpm/vitest@4.0.8_@types+debug@4.1.12_@types+node@24.10.1_@vitest+ui@4.0.8_jiti@2.6.1_jsdom@_c97fdea49f1663602bf3dfb16acdd85d/node_modules/vitest/dist/chunks/vi.Bgcdy3bQ.js
 import { getSafeTimers as getSafeTimers2 } from "@vitest/utils/timers.js";
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from "@vitest/snapshot.js";
 import "@vitest/utils/error.js";
@@ -45,10 +53,10 @@ import { fn, spyOn, restoreAllMocks, resetAllMocks, clearAllMocks, isMockFunctio
 import "@vitest/utils/offset.js";
 import { parseSingleStack } from "@vitest/utils/source-map.js";
 
-// ../../node_modules/.pnpm/vitest@4.0.6_@types+debug@4.1.12_@types+node@24.10.0_@vitest+ui@4.0.6_jiti@2.6.1_jsdom@_38fcb34f3d4da47a9b9d4b13a6949560/node_modules/vitest/dist/chunks/_commonjsHelpers.BFTU3MAI.js
+// ../../node_modules/.pnpm/vitest@4.0.8_@types+debug@4.1.12_@types+node@24.10.1_@vitest+ui@4.0.8_jiti@2.6.1_jsdom@_c97fdea49f1663602bf3dfb16acdd85d/node_modules/vitest/dist/chunks/_commonjsHelpers.BFTU3MAI.js
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 
-// ../../node_modules/.pnpm/vitest@4.0.6_@types+debug@4.1.12_@types+node@24.10.0_@vitest+ui@4.0.6_jiti@2.6.1_jsdom@_38fcb34f3d4da47a9b9d4b13a6949560/node_modules/vitest/dist/chunks/date.-jtEtIeV.js
+// ../../node_modules/.pnpm/vitest@4.0.8_@types+debug@4.1.12_@types+node@24.10.1_@vitest+ui@4.0.8_jiti@2.6.1_jsdom@_c97fdea49f1663602bf3dfb16acdd85d/node_modules/vitest/dist/chunks/date.Bq6ZW5rf.js
 var RealDate = Date;
 var now = null;
 var MockDate = class _MockDate extends RealDate {
@@ -64,29 +72,39 @@ var MockDate = class _MockDate extends RealDate {
         date = new RealDate(y);
         break;
       default:
-        d = typeof d === "undefined" ? 1 : d, h = h || 0, M = M || 0, s = s || 0, ms = ms || 0, date = new RealDate(y, m, d, h, M, s, ms);
+        d = typeof d === "undefined" ? 1 : d;
+        h = h || 0;
+        M = M || 0;
+        s = s || 0;
+        ms = ms || 0;
+        date = new RealDate(y, m, d, h, M, s, ms);
         break;
     }
-    return Object.setPrototypeOf(date, _MockDate.prototype), date;
+    Object.setPrototypeOf(date, _MockDate.prototype);
+    return date;
   }
 };
-MockDate.UTC = RealDate.UTC, MockDate.now = function() {
+MockDate.UTC = RealDate.UTC;
+MockDate.now = function() {
   return new MockDate().valueOf();
-}, MockDate.parse = function(dateString) {
+};
+MockDate.parse = function(dateString) {
   return RealDate.parse(dateString);
-}, MockDate.toString = function() {
+};
+MockDate.toString = function() {
   return RealDate.toString();
 };
 function mockDate(date) {
   const dateObj = new RealDate(date.valueOf());
   if (Number.isNaN(dateObj.getTime())) throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);
-  globalThis.Date = MockDate, now = dateObj.valueOf();
+  globalThis.Date = MockDate;
+  now = dateObj.valueOf();
 }
 function resetDate() {
   globalThis.Date = RealDate;
 }
 
-// ../../node_modules/.pnpm/vitest@4.0.6_@types+debug@4.1.12_@types+node@24.10.0_@vitest+ui@4.0.6_jiti@2.6.1_jsdom@_38fcb34f3d4da47a9b9d4b13a6949560/node_modules/vitest/dist/chunks/vi.BZvkKVkM.js
+// ../../node_modules/.pnpm/vitest@4.0.8_@types+debug@4.1.12_@types+node@24.10.1_@vitest+ui@4.0.8_jiti@2.6.1_jsdom@_c97fdea49f1663602bf3dfb16acdd85d/node_modules/vitest/dist/chunks/vi.Bgcdy3bQ.js
 var unsupported = [
   "matchSnapshot",
   "toMatchSnapshot",
@@ -101,7 +119,9 @@ var unsupported = [
 ];
 function createExpectPoll(expect) {
   return function poll(fn2, options = {}) {
-    const defaults = getWorkerState().config.expect?.poll ?? {}, { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options, assertion = expect(null, message).withContext({ poll: true });
+    const defaults = getWorkerState().config.expect?.poll ?? {};
+    const { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options;
+    const assertion = expect(null, message).withContext({ poll: true });
     fn2 = fn2.bind(assertion);
     const test2 = chai.util.flag(assertion, "vitest-test");
     if (!test2) throw new Error("expect.poll() must be called inside a test");
@@ -111,40 +131,53 @@ function createExpectPoll(expect) {
       if (key === "assert") return assertionFunction;
       if (typeof key === "string" && unsupported.includes(key)) throw new SyntaxError(`expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`);
       return function(...args) {
-        const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR"), promise = () => new Promise((resolve, reject) => {
-          let intervalId, timeoutId, lastError;
-          const { setTimeout, clearTimeout } = getSafeTimers2(), check = async () => {
+        const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+        const promise = () => new Promise((resolve, reject) => {
+          let intervalId;
+          let timeoutId;
+          let lastError;
+          const { setTimeout, clearTimeout } = getSafeTimers2();
+          const check = async () => {
             try {
               chai.util.flag(assertion, "_name", key);
               const obj = await fn2();
-              chai.util.flag(assertion, "object", obj), resolve(await assertionFunction.call(assertion, ...args)), clearTimeout(intervalId), clearTimeout(timeoutId);
+              chai.util.flag(assertion, "object", obj);
+              resolve(await assertionFunction.call(assertion, ...args));
+              clearTimeout(intervalId);
+              clearTimeout(timeoutId);
             } catch (err) {
-              if (lastError = err, !chai.util.flag(assertion, "_isLastPollAttempt")) intervalId = setTimeout(check, interval);
+              lastError = err;
+              if (!chai.util.flag(assertion, "_isLastPollAttempt")) intervalId = setTimeout(check, interval);
             }
           };
           timeoutId = setTimeout(() => {
-            clearTimeout(intervalId), chai.util.flag(assertion, "_isLastPollAttempt", true);
+            clearTimeout(intervalId);
+            chai.util.flag(assertion, "_isLastPollAttempt", true);
             const rejectWithCause = (error) => {
               if (error.cause == null) error.cause = /* @__PURE__ */ new Error("Matcher did not succeed in time.");
               reject(copyStackTrace$1(error, STACK_TRACE_ERROR));
             };
             check().then(() => rejectWithCause(lastError)).catch((e) => rejectWithCause(e));
-          }, timeout), check();
+          }, timeout);
+          check();
         });
         let awaited = false;
-        test2.onFinished ??= [], test2.onFinished.push(() => {
+        test2.onFinished ??= [];
+        test2.onFinished.push(() => {
           if (!awaited) {
-            const negated = chai.util.flag(assertion, "negate") ? "not." : "", assertionString = `expect.${chai.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)"}.${negated}${String(key)}()`, error = /* @__PURE__ */ new Error(`${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:
+            const negated = chai.util.flag(assertion, "negate") ? "not." : "";
+            const assertionString = `expect.${chai.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)"}.${negated}${String(key)}()`;
+            throw copyStackTrace$1(/* @__PURE__ */ new Error(`${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:
 
 await ${assertionString}
-`);
-            throw copyStackTrace$1(error, STACK_TRACE_ERROR);
+`), STACK_TRACE_ERROR);
           }
         });
         let resultPromise;
         return {
           then(onFulfilled, onRejected) {
-            return awaited = true, (resultPromise ||= promise()).then(onFulfilled, onRejected);
+            awaited = true;
+            return (resultPromise ||= promise()).then(onFulfilled, onRejected);
           },
           catch(onRejected) {
             return (resultPromise ||= promise()).catch(onRejected);
@@ -164,20 +197,24 @@ function copyStackTrace$1(target, source) {
   return target;
 }
 function createAssertionMessage(util, assertion, hasArgs) {
-  const not = util.flag(assertion, "negate") ? "not." : "", name = `${util.flag(assertion, "_name")}(${"expected"})`, promiseName = util.flag(assertion, "promise");
+  const not = util.flag(assertion, "negate") ? "not." : "";
+  const name = `${util.flag(assertion, "_name")}(${"expected"})`;
+  const promiseName = util.flag(assertion, "promise");
   return `expect(actual)${promiseName ? `.${promiseName}` : ""}.${not}${name}`;
 }
 function recordAsyncExpect(_test, promise, assertion, error) {
   const test2 = _test;
   if (test2 && promise instanceof Promise) {
-    if (promise = promise.finally(() => {
+    promise = promise.finally(() => {
       if (!test2.promises) return;
       const index = test2.promises.indexOf(promise);
       if (index !== -1) test2.promises.splice(index, 1);
-    }), !test2.promises) test2.promises = [];
+    });
+    if (!test2.promises) test2.promises = [];
     test2.promises.push(promise);
     let resolved = false;
-    return test2.onFinished ??= [], test2.onFinished.push(() => {
+    test2.onFinished ??= [];
+    test2.onFinished.push(() => {
       if (!resolved) {
         const stack = (globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || ""))(error.stack);
         console.warn([
@@ -187,9 +224,11 @@ function recordAsyncExpect(_test, promise, assertion, error) {
           stack
         ].join(""));
       }
-    }), {
+    });
+    return {
       then(onFulfilled, onRejected) {
-        return resolved = true, promise.then(onFulfilled, onRejected);
+        resolved = true;
+        return promise.then(onFulfilled, onRejected);
       },
       catch(onRejected) {
         return promise.catch(onRejected);
@@ -235,9 +274,14 @@ var SnapshotPlugin = (chai3, utils) => {
     return test2;
   }
   for (const key of ["matchSnapshot", "toMatchSnapshot"]) utils.addMethod(chai3.Assertion.prototype, key, function(properties, message) {
-    if (utils.flag(this, "_name", key), utils.flag(this, "negate")) throw new Error(`${key} cannot be used with "not"`);
-    const expected = utils.flag(this, "object"), test2 = getTest(key, this);
-    if (typeof properties === "string" && typeof message === "undefined") message = properties, properties = void 0;
+    utils.flag(this, "_name", key);
+    if (utils.flag(this, "negate")) throw new Error(`${key} cannot be used with "not"`);
+    const expected = utils.flag(this, "object");
+    const test2 = getTest(key, this);
+    if (typeof properties === "string" && typeof message === "undefined") {
+      message = properties;
+      properties = void 0;
+    }
     const errorMessage = utils.flag(this, "message");
     getSnapshotClient().assert({
       received: expected,
@@ -249,22 +293,33 @@ var SnapshotPlugin = (chai3, utils) => {
     });
   });
   utils.addMethod(chai3.Assertion.prototype, "toMatchFileSnapshot", function(file, message) {
-    if (utils.flag(this, "_name", "toMatchFileSnapshot"), utils.flag(this, "negate")) throw new Error('toMatchFileSnapshot cannot be used with "not"');
-    const error = /* @__PURE__ */ new Error("resolves"), expected = utils.flag(this, "object"), test2 = getTest("toMatchFileSnapshot", this), errorMessage = utils.flag(this, "message"), promise = getSnapshotClient().assertRaw({
+    utils.flag(this, "_name", "toMatchFileSnapshot");
+    if (utils.flag(this, "negate")) throw new Error('toMatchFileSnapshot cannot be used with "not"');
+    const error = /* @__PURE__ */ new Error("resolves");
+    const expected = utils.flag(this, "object");
+    const test2 = getTest("toMatchFileSnapshot", this);
+    const errorMessage = utils.flag(this, "message");
+    return recordAsyncExpect(test2, getSnapshotClient().assertRaw({
       received: expected,
       message,
       isInline: false,
       rawSnapshot: { file },
       errorMessage,
       ...getTestNames(test2)
-    });
-    return recordAsyncExpect(test2, promise, createAssertionMessage(utils, this), error);
-  }), utils.addMethod(chai3.Assertion.prototype, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
-    if (utils.flag(this, "_name", "toMatchInlineSnapshot"), utils.flag(this, "negate")) throw new Error('toMatchInlineSnapshot cannot be used with "not"');
+    }), createAssertionMessage(utils, this), error);
+  });
+  utils.addMethod(chai3.Assertion.prototype, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
+    utils.flag(this, "_name", "toMatchInlineSnapshot");
+    if (utils.flag(this, "negate")) throw new Error('toMatchInlineSnapshot cannot be used with "not"');
     const test2 = getTest("toMatchInlineSnapshot", this);
     if (test2.each || test2.suite?.each) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
-    const expected = utils.flag(this, "object"), error = utils.flag(this, "error");
-    if (typeof properties === "string") message = inlineSnapshot, inlineSnapshot = properties, properties = void 0;
+    const expected = utils.flag(this, "object");
+    const error = utils.flag(this, "error");
+    if (typeof properties === "string") {
+      message = inlineSnapshot;
+      inlineSnapshot = properties;
+      properties = void 0;
+    }
     if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
     const errorMessage = utils.flag(this, "message");
     getSnapshotClient().assert({
@@ -277,20 +332,29 @@ var SnapshotPlugin = (chai3, utils) => {
       errorMessage,
       ...getTestNames(test2)
     });
-  }), utils.addMethod(chai3.Assertion.prototype, "toThrowErrorMatchingSnapshot", function(message) {
-    if (utils.flag(this, "_name", "toThrowErrorMatchingSnapshot"), utils.flag(this, "negate")) throw new Error('toThrowErrorMatchingSnapshot cannot be used with "not"');
-    const expected = utils.flag(this, "object"), test2 = getTest("toThrowErrorMatchingSnapshot", this), promise = utils.flag(this, "promise"), errorMessage = utils.flag(this, "message");
+  });
+  utils.addMethod(chai3.Assertion.prototype, "toThrowErrorMatchingSnapshot", function(message) {
+    utils.flag(this, "_name", "toThrowErrorMatchingSnapshot");
+    if (utils.flag(this, "negate")) throw new Error('toThrowErrorMatchingSnapshot cannot be used with "not"');
+    const expected = utils.flag(this, "object");
+    const test2 = getTest("toThrowErrorMatchingSnapshot", this);
+    const promise = utils.flag(this, "promise");
+    const errorMessage = utils.flag(this, "message");
     getSnapshotClient().assert({
       received: getError(expected, promise),
       message,
       errorMessage,
       ...getTestNames(test2)
     });
-  }), utils.addMethod(chai3.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
+  });
+  utils.addMethod(chai3.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
     if (utils.flag(this, "negate")) throw new Error('toThrowErrorMatchingInlineSnapshot cannot be used with "not"');
     const test2 = getTest("toThrowErrorMatchingInlineSnapshot", this);
     if (test2.each || test2.suite?.each) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
-    const expected = utils.flag(this, "object"), error = utils.flag(this, "error"), promise = utils.flag(this, "promise"), errorMessage = utils.flag(this, "message");
+    const expected = utils.flag(this, "object");
+    const error = utils.flag(this, "error");
+    const promise = utils.flag(this, "promise");
+    const errorMessage = utils.flag(this, "message");
     if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
     getSnapshotClient().assert({
       received: getError(expected, promise),
@@ -301,17 +365,27 @@ var SnapshotPlugin = (chai3, utils) => {
       errorMessage,
       ...getTestNames(test2)
     });
-  }), utils.addMethod(chai3.expect, "addSnapshotSerializer", addSerializer);
+  });
+  utils.addMethod(chai3.expect, "addSnapshotSerializer", addSerializer);
 };
-chai.use(JestExtend), chai.use(JestChaiExpect), chai.use(SnapshotPlugin), chai.use(JestAsymmetricMatchers);
+chai.use(JestExtend);
+chai.use(JestChaiExpect);
+chai.use(SnapshotPlugin);
+chai.use(JestAsymmetricMatchers);
 function createExpect(test2) {
   const expect = ((value, message) => {
     const { assertionCalls } = getState(expect);
     setState({ assertionCalls: assertionCalls + 1 }, expect);
-    const assert2 = chai.expect(value, message), _test = test2 || getCurrentTest();
-    return _test ? assert2.withTest(_test) : assert2;
+    const assert2 = chai.expect(value, message);
+    const _test = test2 || getCurrentTest();
+    if (_test)
+      return assert2.withTest(_test);
+    else return assert2;
   });
-  Object.assign(expect, chai.expect), Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT]), expect.getState = () => getState(expect), expect.setState = (state) => setState(state, expect);
+  Object.assign(expect, chai.expect);
+  Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
+  expect.getState = () => getState(expect);
+  expect.setState = (state) => setState(state, expect);
   const globalState = getState(globalThis[GLOBAL_EXPECT]) || {};
   setState({
     ...globalState,
@@ -324,9 +398,15 @@ function createExpect(test2) {
       return getWorkerState().filepath;
     },
     currentTestName: test2 ? getTestName(test2) : globalState.currentTestName
-  }, expect), expect.assert = chai.assert, expect.extend = (matchers) => chai.expect.extend(expect, matchers), expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters), expect.soft = (...args) => {
+  }, expect);
+  expect.assert = chai.assert;
+  expect.extend = (matchers) => chai.expect.extend(expect, matchers);
+  expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
+  expect.soft = (...args) => {
     return expect(...args).withContext({ soft: true });
-  }, expect.poll = createExpectPoll(expect), expect.unreachable = (message) => {
+  };
+  expect.poll = createExpectPoll(expect);
+  expect.unreachable = (message) => {
     chai.assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
   };
   function assertions(expected) {
@@ -345,7 +425,10 @@ function createExpect(test2) {
       isExpectingAssertionsError: error
     });
   }
-  return chai.util.addMethod(expect, "assertions", assertions), chai.util.addMethod(expect, "hasAssertions", hasAssertions), expect.extend(customMatchers), expect;
+  chai.util.addMethod(expect, "assertions", assertions);
+  chai.util.addMethod(expect, "hasAssertions", hasAssertions);
+  expect.extend(customMatchers);
+  return expect;
 }
 var globalExpect = createExpect();
 Object.defineProperty(globalThis, GLOBAL_EXPECT, {
@@ -2188,7 +2271,11 @@ var FakeTimers = class {
   _userConfig;
   _now = RealDate.now;
   constructor({ global: global3, config }) {
-    this._userConfig = config, this._fakingDate = null, this._fakingTime = false, this._fakeTimers = fakeTimersSrcExports.withGlobal(global3), this._global = global3;
+    this._userConfig = config;
+    this._fakingDate = null;
+    this._fakingTime = false;
+    this._fakeTimers = fakeTimersSrcExports.withGlobal(global3);
+    this._global = global3;
   }
   clearAllTimers() {
     if (this._fakingTime) this._clock.reset();
@@ -2209,13 +2296,17 @@ var FakeTimers = class {
     if (this._checkFakeTimers()) await this._clock.runToLastAsync();
   }
   advanceTimersToNextTimer(steps = 1) {
-    if (this._checkFakeTimers()) {
-      for (let i = steps; i > 0; i--) if (this._clock.next(), this._clock.tick(0), this._clock.countTimers() === 0) break;
+    if (this._checkFakeTimers()) for (let i = steps; i > 0; i--) {
+      this._clock.next();
+      this._clock.tick(0);
+      if (this._clock.countTimers() === 0) break;
     }
   }
   async advanceTimersToNextTimerAsync(steps = 1) {
-    if (this._checkFakeTimers()) {
-      for (let i = steps; i > 0; i--) if (await this._clock.nextAsync(), this._clock.tick(0), this._clock.countTimers() === 0) break;
+    if (this._checkFakeTimers()) for (let i = steps; i > 0; i--) {
+      await this._clock.nextAsync();
+      this._clock.tick(0);
+      if (this._clock.countTimers() === 0) break;
     }
   }
   advanceTimersByTime(msToRun) {
@@ -2232,12 +2323,21 @@ var FakeTimers = class {
       this._clock.runMicrotasks();
   }
   useRealTimers() {
-    if (this._fakingDate) resetDate(), this._fakingDate = null;
-    if (this._fakingTime) this._clock.uninstall(), this._fakingTime = false;
+    if (this._fakingDate) {
+      resetDate();
+      this._fakingDate = null;
+    }
+    if (this._fakingTime) {
+      this._clock.uninstall();
+      this._fakingTime = false;
+    }
   }
   useFakeTimers() {
     const fakeDate = this._fakingDate || Date.now();
-    if (this._fakingDate) resetDate(), this._fakingDate = null;
+    if (this._fakingDate) {
+      resetDate();
+      this._fakingDate = null;
+    }
     if (this._fakingTime) this._clock.uninstall();
     const toFake = Object.keys(this._fakeTimers.timers).filter((timer) => timer !== "nextTick" && timer !== "queueMicrotask");
     if (this._userConfig?.toFake?.includes("nextTick") && isChildProcess()) throw new Error("process.nextTick cannot be mocked inside child_process");
@@ -2246,18 +2346,23 @@ var FakeTimers = class {
       ...this._userConfig,
       toFake: this._userConfig?.toFake || toFake,
       ignoreMissingTimers: true
-    }), this._fakingTime = true;
+    });
+    this._fakingTime = true;
   }
   reset() {
     if (this._checkFakeTimers()) {
       const { now: now2 } = this._clock;
-      this._clock.reset(), this._clock.setSystemTime(now2);
+      this._clock.reset();
+      this._clock.setSystemTime(now2);
     }
   }
   setSystemTime(now2) {
     const date = typeof now2 === "undefined" || now2 instanceof Date ? now2 : new Date(now2);
     if (this._fakingTime) this._clock.setSystemTime(date);
-    else this._fakingDate = date ?? new Date(this.getRealSystemTime()), mockDate(this._fakingDate);
+    else {
+      this._fakingDate = date ?? new Date(this.getRealSystemTime());
+      mockDate(this._fakingDate);
+    }
   }
   getMockedSystemTime() {
     return this._fakingTime ? new Date(this._clock.now) : this._fakingDate;
@@ -2266,7 +2371,8 @@ var FakeTimers = class {
     return this._now();
   }
   getTimerCount() {
-    return this._checkFakeTimers() ? this._clock.countTimers() : 0;
+    if (this._checkFakeTimers()) return this._clock.countTimers();
+    return 0;
   }
   configure(config) {
     this._userConfig = config;
@@ -2284,68 +2390,96 @@ function copyStackTrace(target, source) {
   return target;
 }
 function waitFor(callback, options = {}) {
-  const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers2(), { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options, STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+  const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers2();
+  const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
+  const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
   return new Promise((resolve, reject) => {
-    let lastError, promiseStatus = "idle", timeoutId, intervalId;
+    let lastError;
+    let promiseStatus = "idle";
+    let timeoutId;
+    let intervalId;
     const onResolve = (result) => {
       if (timeoutId) clearTimeout(timeoutId);
       if (intervalId) clearInterval(intervalId);
       resolve(result);
-    }, handleTimeout = () => {
+    };
+    const handleTimeout = () => {
       if (intervalId) clearInterval(intervalId);
       let error = lastError;
       if (!error) error = copyStackTrace(/* @__PURE__ */ new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
       reject(error);
-    }, checkCallback = () => {
+    };
+    const checkCallback = () => {
       if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
-      if (promiseStatus !== "pending") try {
+      if (promiseStatus === "pending") return;
+      try {
         const result = callback();
         if (result !== null && typeof result === "object" && typeof result.then === "function") {
           const thenable = result;
-          promiseStatus = "pending", thenable.then((resolvedValue) => {
-            promiseStatus = "resolved", onResolve(resolvedValue);
+          promiseStatus = "pending";
+          thenable.then((resolvedValue) => {
+            promiseStatus = "resolved";
+            onResolve(resolvedValue);
           }, (rejectedValue) => {
-            promiseStatus = "rejected", lastError = rejectedValue;
+            promiseStatus = "rejected";
+            lastError = rejectedValue;
           });
-        } else return onResolve(result), true;
+        } else {
+          onResolve(result);
+          return true;
+        }
       } catch (error) {
         lastError = error;
       }
     };
-    checkCallback() !== true && (timeoutId = setTimeout(handleTimeout, timeout), intervalId = setInterval(checkCallback, interval));
+    if (checkCallback() === true) return;
+    timeoutId = setTimeout(handleTimeout, timeout);
+    intervalId = setInterval(checkCallback, interval);
   });
 }
 function waitUntil(callback, options = {}) {
-  const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers2(), { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options, STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+  const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers2();
+  const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
+  const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
   return new Promise((resolve, reject) => {
-    let promiseStatus = "idle", timeoutId, intervalId;
+    let promiseStatus = "idle";
+    let timeoutId;
+    let intervalId;
     const onReject = (error) => {
       if (intervalId) clearInterval(intervalId);
       if (!error) error = copyStackTrace(/* @__PURE__ */ new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR);
       reject(error);
-    }, onResolve = (result) => {
-      if (result) {
-        if (timeoutId) clearTimeout(timeoutId);
-        if (intervalId) clearInterval(intervalId);
-        return resolve(result), true;
-      }
-    }, checkCallback = () => {
+    };
+    const onResolve = (result) => {
+      if (!result) return;
+      if (timeoutId) clearTimeout(timeoutId);
+      if (intervalId) clearInterval(intervalId);
+      resolve(result);
+      return true;
+    };
+    const checkCallback = () => {
       if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
-      if (promiseStatus !== "pending") try {
+      if (promiseStatus === "pending") return;
+      try {
         const result = callback();
         if (result !== null && typeof result === "object" && typeof result.then === "function") {
           const thenable = result;
-          promiseStatus = "pending", thenable.then((resolvedValue) => {
-            promiseStatus = "resolved", onResolve(resolvedValue);
+          promiseStatus = "pending";
+          thenable.then((resolvedValue) => {
+            promiseStatus = "resolved";
+            onResolve(resolvedValue);
           }, (rejectedValue) => {
-            promiseStatus = "rejected", onReject(rejectedValue);
+            promiseStatus = "rejected";
+            onReject(rejectedValue);
           });
         } else return onResolve(result);
       } catch (error) {
         onReject(error);
       }
     };
-    checkCallback() !== true && (timeoutId = setTimeout(onReject, timeout), intervalId = setInterval(checkCallback, interval));
+    if (checkCallback() === true) return;
+    timeoutId = setTimeout(onReject, timeout);
+    intervalId = setInterval(checkCallback, interval);
   });
 }
 function createVitest() {
@@ -2355,11 +2489,15 @@ function createVitest() {
   const timers = () => _timers ||= new FakeTimers({
     global: globalThis,
     config: state().config.fakeTimers
-  }), _stubsGlobal = /* @__PURE__ */ new Map(), _stubsEnv = /* @__PURE__ */ new Map(), _envBooleans = [
+  });
+  const _stubsGlobal = /* @__PURE__ */ new Map();
+  const _stubsEnv = /* @__PURE__ */ new Map();
+  const _envBooleans = [
     "PROD",
     "DEV",
     "SSR"
-  ], utils = {
+  ];
+  const utils = {
     useFakeTimers(config) {
       if (isChildProcess()) {
         if (config?.toFake?.includes("nextTick") || state().config?.fakeTimers?.toFake?.includes("nextTick")) throw new Error('vi.useFakeTimers({ toFake: ["nextTick"] }) is not supported in node:child_process. Use --pool=threads if mocking nextTick is required.');
@@ -2369,49 +2507,62 @@ function createVitest() {
         ...config
       });
       else timers().configure(state().config.fakeTimers);
-      return timers().useFakeTimers(), utils;
+      timers().useFakeTimers();
+      return utils;
     },
     isFakeTimers() {
       return timers().isFakeTimers();
     },
     useRealTimers() {
-      return timers().useRealTimers(), utils;
+      timers().useRealTimers();
+      return utils;
     },
     runOnlyPendingTimers() {
-      return timers().runOnlyPendingTimers(), utils;
+      timers().runOnlyPendingTimers();
+      return utils;
     },
     async runOnlyPendingTimersAsync() {
-      return await timers().runOnlyPendingTimersAsync(), utils;
+      await timers().runOnlyPendingTimersAsync();
+      return utils;
     },
     runAllTimers() {
-      return timers().runAllTimers(), utils;
+      timers().runAllTimers();
+      return utils;
     },
     async runAllTimersAsync() {
-      return await timers().runAllTimersAsync(), utils;
+      await timers().runAllTimersAsync();
+      return utils;
     },
     runAllTicks() {
-      return timers().runAllTicks(), utils;
+      timers().runAllTicks();
+      return utils;
     },
     advanceTimersByTime(ms) {
-      return timers().advanceTimersByTime(ms), utils;
+      timers().advanceTimersByTime(ms);
+      return utils;
     },
     async advanceTimersByTimeAsync(ms) {
-      return await timers().advanceTimersByTimeAsync(ms), utils;
+      await timers().advanceTimersByTimeAsync(ms);
+      return utils;
     },
     advanceTimersToNextTimer() {
-      return timers().advanceTimersToNextTimer(), utils;
+      timers().advanceTimersToNextTimer();
+      return utils;
     },
     async advanceTimersToNextTimerAsync() {
-      return await timers().advanceTimersToNextTimerAsync(), utils;
+      await timers().advanceTimersToNextTimerAsync();
+      return utils;
     },
     advanceTimersToNextFrame() {
-      return timers().advanceTimersToNextFrame(), utils;
+      timers().advanceTimersToNextFrame();
+      return utils;
     },
     getTimerCount() {
       return timers().getTimerCount();
     },
     setSystemTime(time) {
-      return timers().setSystemTime(time), utils;
+      timers().setSystemTime(time);
+      return utils;
     },
     getMockedSystemTime() {
       return timers().getMockedSystemTime();
@@ -2420,14 +2571,16 @@ function createVitest() {
       return timers().getRealSystemTime();
     },
     clearAllTimers() {
-      return timers().clearAllTimers(), utils;
+      timers().clearAllTimers();
+      return utils;
     },
     spyOn,
     fn,
     waitFor,
     waitUntil,
     hoisted(factory) {
-      return assertTypes(factory, '"vi.hoisted" factory', ["function"]), factory();
+      assertTypes(factory, '"vi.hoisted" factory', ["function"]);
+      return factory();
     },
     mock(path, factory) {
       if (typeof path !== "string") throw new TypeError(`vi.mock() expects a string path, but received a ${typeof path}`);
@@ -2466,22 +2619,26 @@ function createVitest() {
       return isMockFunction(fn2);
     },
     clearAllMocks() {
-      return clearAllMocks(), utils;
+      clearAllMocks();
+      return utils;
     },
     resetAllMocks() {
-      return resetAllMocks(), utils;
+      resetAllMocks();
+      return utils;
     },
     restoreAllMocks() {
-      return restoreAllMocks(), utils;
+      restoreAllMocks();
+      return utils;
     },
     stubGlobal(name, value) {
       if (!_stubsGlobal.has(name)) _stubsGlobal.set(name, Object.getOwnPropertyDescriptor(globalThis, name));
-      return Object.defineProperty(globalThis, name, {
+      Object.defineProperty(globalThis, name, {
         value,
         writable: true,
         configurable: true,
         enumerable: true
-      }), utils;
+      });
+      return utils;
     },
     stubEnv(name, value) {
       const env = state().metaEnv;
@@ -2492,20 +2649,25 @@ function createVitest() {
       return utils;
     },
     unstubAllGlobals() {
-      return _stubsGlobal.forEach((original, name) => {
+      _stubsGlobal.forEach((original, name) => {
         if (!original) Reflect.deleteProperty(globalThis, name);
         else Object.defineProperty(globalThis, name, original);
-      }), _stubsGlobal.clear(), utils;
+      });
+      _stubsGlobal.clear();
+      return utils;
     },
     unstubAllEnvs() {
       const env = state().metaEnv;
-      return _stubsEnv.forEach((original, name) => {
+      _stubsEnv.forEach((original, name) => {
         if (original === void 0) delete env[name];
         else env[name] = original;
-      }), _stubsEnv.clear(), utils;
+      });
+      _stubsEnv.clear();
+      return utils;
     },
     resetModules() {
-      return resetModules(state().evaluatedModules), utils;
+      resetModules(state().evaluatedModules);
+      return utils;
     },
     async dynamicImportSettled() {
       return waitForImportsToResolve();
@@ -2528,13 +2690,13 @@ function _mocker() {
   } });
 }
 function getImporter(name) {
-  const stackArray = createSimpleStackTrace({ stackTraceLimit: 5 }).split("\n"), importerStackIndex = stackArray.findLastIndex((stack) => {
+  const stackArray = createSimpleStackTrace({ stackTraceLimit: 5 }).split("\n");
+  return parseSingleStack(stackArray[stackArray.findLastIndex((stack) => {
     return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`);
-  });
-  return parseSingleStack(stackArray[importerStackIndex + 1])?.file || "";
+  }) + 1])?.file || "";
 }
 
-// ../../node_modules/.pnpm/vitest@4.0.6_@types+debug@4.1.12_@types+node@24.10.0_@vitest+ui@4.0.6_jiti@2.6.1_jsdom@_38fcb34f3d4da47a9b9d4b13a6949560/node_modules/vitest/dist/index.js
+// ../../node_modules/.pnpm/vitest@4.0.8_@types+debug@4.1.12_@types+node@24.10.1_@vitest+ui@4.0.8_jiti@2.6.1_jsdom@_c97fdea49f1663602bf3dfb16acdd85d/node_modules/vitest/dist/index.js
 import { expectTypeOf } from "expect-type.js";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from "@vitest/runner.js";
 import { chai as chai2 } from "@vitest/expect.js";