@accelint/design-system 0.12.2 → 0.12.3

package/dist/test/setup.js

@@ -12,18 +12,16 @@ import 'react-dom';
 import 'react-dom/client';
 import * as prettyFormat from 'pretty-format.js';
 import lzString from 'lz-string.js';
-import { test, suite, onTestFinished, onTestFailed, it, describe, beforeEach, beforeAll as beforeAll$1, afterEach as afterEach$1, afterAll as afterAll$1, getCurrentSuite, getCurrentTest } from '@vitest/runner.js';
-import { createChainable, getNames } from '@vitest/runner/utils.js';
-import { noop, getSafeTimers, assertTypes, createSimpleStackTrace } from '@vitest/utils.js';
-import 'pathe.js';
-import * as chai$1 from 'chai.js';
-import { should, assert } from 'chai.js';
 import { JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, equals, iterableEquality, subsetEquality } from '@vitest/expect.js';
+import { afterEach as afterEach$1, getCurrentTest } from '@vitest/runner.js';
+import { getNames } from '@vitest/runner/utils.js';
+import * as chai$1 from 'chai.js';
+import { assertTypes, getSafeTimers, createSimpleStackTrace } from '@vitest/utils.js';
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest/snapshot.js';
 import '@vitest/utils/error.js';
 import { parseSingleStack } from '@vitest/utils/source-map.js';
 import { fn, spyOn, mocks, isMockFunction } from '@vitest/spy.js';
-import 'std-env.js';
+import 'expect-type.js';
 
 // ../node_modules/.pnpm/@testing-library+jest-dom@6.6.3/node_modules/@testing-library/jest-dom/dist/matchers.mjs
 var matchers_exports = {};
@@ -4024,10 +4022,9 @@ if (typeof process === "undefined" || !process.env?.RTL_SKIP_AUTO_CLEANUP) {
     });
   }
 }
-
-// ../node_modules/.pnpm/vitest@2.1.3_@types+node@24.6.2_jsdom@25.0.1_msw@2.11.3_@types+node@24.6.2_typescript@5.8.3_/node_modules/vitest/dist/chunks/utils.Ck2hJTRs.js
+var NAME_WORKER_STATE = "__vitest_worker__";
 function getWorkerState() {
-  const workerState = globalThis.__vitest_worker__;
+  const workerState = globalThis[NAME_WORKER_STATE];
   if (!workerState) {
     const errorMsg = 'Vitest failed to access its internal state.\n\nOne of the following is possible:\n- "vitest" is imported directly without running "vitest" command\n- "vitest" is imported inside "globalSetup" (to fix this, use "setupFiles" instead, because "globalSetup" runs in a different context)\n- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues\n';
     throw new Error(errorMsg);
@@ -4038,80 +4035,59 @@ function getCurrentEnvironment() {
   const state = getWorkerState();
   return state?.environment.name;
 }
-
-// ../node_modules/.pnpm/vitest@2.1.3_@types+node@24.6.2_jsdom@25.0.1_msw@2.11.3_@types+node@24.6.2_typescript@5.8.3_/node_modules/vitest/dist/chunks/index.CxRxs566.js
-function getRunMode() {
-  return getWorkerState().config.mode;
-}
-function isRunningInBenchmark() {
-  return getRunMode() === "benchmark";
+function isChildProcess() {
+  return typeof process !== "undefined" && !!process.send;
 }
-
-// ../node_modules/.pnpm/vitest@2.1.3_@types+node@24.6.2_jsdom@25.0.1_msw@2.11.3_@types+node@24.6.2_typescript@5.8.3_/node_modules/vitest/dist/chunks/benchmark.C8CRJYG4.js
-var benchFns = /* @__PURE__ */ new WeakMap();
-var benchOptsMap = /* @__PURE__ */ new WeakMap();
-var bench = createBenchmark(function(name, fn2 = noop, options = {}) {
-  if (!isRunningInBenchmark()) {
-    throw new Error("`bench()` is only available in benchmark mode.");
-  }
-  const task = getCurrentSuite().task(formatName(name), {
-    ...this,
-    meta: {
-      benchmark: true
+function resetModules(modules, resetMocks = false) {
+  const skipPaths = [
+    // Vitest
+    /\/vitest\/dist\//,
+    /\/vite-node\/dist\//,
+    // yarn's .store folder
+    /vitest-virtual-\w+\/dist/,
+    // cnpm
+    /@vitest\/dist/,
+    // don't clear mocks
+    ...!resetMocks ? [/^mock:/] : []
+  ];
+  modules.forEach((mod, path) => {
+    if (skipPaths.some((re) => re.test(path))) {
+      return;
     }
+    modules.invalidateModule(mod);
   });
-  benchFns.set(task, fn2);
-  benchOptsMap.set(task, options);
-});
-function createBenchmark(fn2) {
-  const benchmark = createChainable(
-    ["skip", "only", "todo"],
-    fn2
-  );
-  benchmark.skipIf = (condition) => condition ? benchmark.skip : benchmark;
-  benchmark.runIf = (condition) => condition ? benchmark : benchmark.skip;
-  return benchmark;
 }
-function formatName(name) {
-  return typeof name === "string" ? name : name instanceof Function ? name.name || "<anonymous>" : String(name);
+function waitNextTick() {
+  const { setTimeout: setTimeout2 } = getSafeTimers();
+  return new Promise((resolve) => setTimeout2(resolve, 0));
 }
-
-// ../node_modules/.pnpm/vitest@2.1.3_@types+node@24.6.2_jsdom@25.0.1_msw@2.11.3_@types+node@24.6.2_typescript@5.8.3_/node_modules/vitest/dist/chunks/run-once.Sxe67Wng.js
-var filesCount = /* @__PURE__ */ new Map();
-var cache = /* @__PURE__ */ new Map();
-function runOnce(fn2, key) {
-  const filepath = getWorkerState().filepath || "__unknown_files__";
-  if (!key) {
-    filesCount.set(filepath, (filesCount.get(filepath) || 0) + 1);
-    key = String(filesCount.get(filepath));
-  }
-  const id = `${filepath}:${key}`;
-  if (!cache.has(id)) {
-    cache.set(id, fn2());
-  }
-  return cache.get(id);
-}
-function isFirstRun() {
-  let firstRun = false;
-  runOnce(() => {
-    firstRun = true;
-  }, "__vitest_first_run__");
-  return firstRun;
+async function waitForImportsToResolve() {
+  await waitNextTick();
+  const state = getWorkerState();
+  const promises = [];
+  let resolvingCount = 0;
+  for (const mod of state.moduleCache.values()) {
+    if (mod.promise && !mod.evaluated) {
+      promises.push(mod.promise);
+    }
+    if (mod.resolving) {
+      resolvingCount++;
+    }
+  }
+  if (!promises.length && !resolvingCount) {
+    return;
+  }
+  await Promise.allSettled(promises);
+  await waitForImportsToResolve();
 }
 
-// ../node_modules/.pnpm/vitest@2.1.3_@types+node@24.6.2_jsdom@25.0.1_msw@2.11.3_@types+node@24.6.2_typescript@5.8.3_/node_modules/vitest/dist/chunks/_commonjsHelpers.BFTU3MAI.js
+// ../node_modules/.pnpm/vitest@2.1.9_@types+node@24.6.2_jsdom@25.0.1_msw@2.11.3_@types+node@24.6.2_typescript@5.8.3_/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 : {};
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
-function getTestName(task, separator = " > ") {
-  return getNames(task).slice(1).join(separator);
-}
-function isChildProcess() {
-  return typeof process !== "undefined" && !!process.send;
-}
 
-// ../node_modules/.pnpm/vitest@2.1.3_@types+node@24.6.2_jsdom@25.0.1_msw@2.11.3_@types+node@24.6.2_typescript@5.8.3_/node_modules/vitest/dist/chunks/date.W2xKR2qe.js
+// ../node_modules/.pnpm/vitest@2.1.9_@types+node@24.6.2_jsdom@25.0.1_msw@2.11.3_@types+node@24.6.2_typescript@5.8.3_/node_modules/vitest/dist/chunks/date.W2xKR2qe.js
 var RealDate = Date;
 var now = null;
 var MockDate = class _MockDate extends RealDate {
@@ -4163,47 +4139,130 @@ function mockDate(date) {
 function resetDate() {
   globalThis.Date = RealDate;
 }
-function resetModules(modules, resetMocks = false) {
-  const skipPaths = [
-    // Vitest
-    /\/vitest\/dist\//,
-    /\/vite-node\/dist\//,
-    // yarn's .store folder
-    /vitest-virtual-\w+\/dist/,
-    // cnpm
-    /@vitest\/dist/,
-    // don't clear mocks
-    ...!resetMocks ? [/^mock:/] : []
-  ];
-  modules.forEach((mod, path) => {
-    if (skipPaths.some((re) => re.test(path))) {
-      return;
+var unsupported = [
+  // .poll is meant to retry matchers until they succeed, and
+  // snapshots will always succeed as long as the poll method doesn't thow an error
+  // in this case using the `vi.waitFor` method is more appropriate
+  "matchSnapshot",
+  "toMatchSnapshot",
+  "toMatchInlineSnapshot",
+  "toThrowErrorMatchingSnapshot",
+  "toThrowErrorMatchingInlineSnapshot",
+  // toThrow will never succeed because we call the poll callback until it doesn't throw
+  "throws",
+  "Throw",
+  "throw",
+  "toThrow",
+  "toThrowError"
+  // these are not supported because you can call them without `.poll`,
+  // we throw an error inside the rejects/resolves methods to prevent this
+  // rejects,
+  // resolves
+];
+function createExpectPoll(expect2) {
+  return function poll(fn2, options = {}) {
+    const state = getWorkerState();
+    const defaults = state.config.expect?.poll ?? {};
+    const {
+      interval = defaults.interval ?? 50,
+      timeout = defaults.timeout ?? 1e3,
+      message
+    } = options;
+    const assertion = expect2(null, message).withContext({
+      poll: true
+    });
+    fn2 = fn2.bind(assertion);
+    const test2 = chai$1.util.flag(assertion, "vitest-test");
+    if (!test2) {
+      throw new Error("expect.poll() must be called inside a test");
     }
-    modules.invalidateModule(mod);
-  });
-}
-function waitNextTick() {
-  const { setTimeout: setTimeout2 } = getSafeTimers();
-  return new Promise((resolve) => setTimeout2(resolve, 0));
+    const proxy = new Proxy(assertion, {
+      get(target, key, receiver) {
+        const assertionFunction = Reflect.get(target, key, receiver);
+        if (typeof assertionFunction !== "function") {
+          return assertionFunction instanceof chai$1.Assertion ? proxy : assertionFunction;
+        }
+        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 = new Error("STACK_TRACE_ERROR");
+          const promise = () => new Promise((resolve, reject) => {
+            let intervalId;
+            let lastError;
+            const { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = getSafeTimers();
+            const timeoutId = setTimeout2(() => {
+              clearTimeout2(intervalId);
+              reject(
+                copyStackTrace$1(
+                  new Error(`Matcher did not succeed in ${timeout}ms`, {
+                    cause: lastError
+                  }),
+                  STACK_TRACE_ERROR
+                )
+              );
+            }, timeout);
+            const check = async () => {
+              try {
+                chai$1.util.flag(assertion, "_name", key);
+                const obj = await fn2();
+                chai$1.util.flag(assertion, "object", obj);
+                resolve(await assertionFunction.call(assertion, ...args));
+                clearTimeout2(intervalId);
+                clearTimeout2(timeoutId);
+              } catch (err) {
+                lastError = err;
+                intervalId = setTimeout2(check, interval);
+              }
+            };
+            check();
+          });
+          let awaited = false;
+          test2.onFinished ??= [];
+          test2.onFinished.push(() => {
+            if (!awaited) {
+              const negated = chai$1.util.flag(assertion, "negate") ? "not." : "";
+              const name = chai$1.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)";
+              const assertionString = `expect.${name}.${negated}${String(key)}()`;
+              const error = 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);
+            }
+          });
+          let resultPromise;
+          return {
+            then(onFulfilled, onRejected) {
+              awaited = true;
+              return (resultPromise ||= promise()).then(onFulfilled, onRejected);
+            },
+            catch(onRejected) {
+              return (resultPromise ||= promise()).catch(onRejected);
+            },
+            finally(onFinally) {
+              return (resultPromise ||= promise()).finally(onFinally);
+            },
+            [Symbol.toStringTag]: "Promise"
+          };
+        };
+      }
+    });
+    return proxy;
+  };
 }
-async function waitForImportsToResolve() {
-  await waitNextTick();
-  const state = getWorkerState();
-  const promises = [];
-  let resolvingCount = 0;
-  for (const mod of state.moduleCache.values()) {
-    if (mod.promise && !mod.evaluated) {
-      promises.push(mod.promise);
-    }
-    if (mod.resolving) {
-      resolvingCount++;
-    }
-  }
-  if (!promises.length && !resolvingCount) {
-    return;
+function copyStackTrace$1(target, source) {
+  if (source.stack !== void 0) {
+    target.stack = source.stack.replace(source.message, target.message);
   }
-  await Promise.allSettled(promises);
-  await waitForImportsToResolve();
+  return target;
 }
 function commonjsRequire(path) {
   throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
@@ -4222,12 +4281,12 @@ function requireChaiSubset() {
         } else {
           return chai.use(chaiSubset2);
         }
-      })(function(chai4, utils) {
-        var Assertion2 = chai4.Assertion;
+      })(function(chai3, utils) {
+        var Assertion2 = chai3.Assertion;
         var assertionPrototype = Assertion2.prototype;
         Assertion2.addMethod("containSubset", function(expected) {
           var actual = utils.flag(this, "object");
-          var showDiff = chai4.config.showDiff;
+          var showDiff = chai3.config.showDiff;
           assertionPrototype.assert.call(
             this,
             compare(expected, actual),
@@ -4238,8 +4297,8 @@ function requireChaiSubset() {
             showDiff
           );
         });
-        chai4.assert.containSubset = function(val, exp, msg) {
-          new chai4.Assertion(val, msg).to.be.containSubset(exp);
+        chai3.assert.containSubset = function(val, exp, msg) {
+          new chai3.Assertion(val, msg).to.be.containSubset(exp);
         };
         function compare(expected, actual) {
           if (expected === actual) {
@@ -4291,18 +4350,56 @@ function requireChaiSubset() {
 }
 var chaiSubsetExports = requireChaiSubset();
 var Subset = /* @__PURE__ */ getDefaultExportFromCjs(chaiSubsetExports);
-function recordAsyncExpect(test3, promise) {
-  if (test3 && promise instanceof Promise) {
+function createAssertionMessage(util2, assertion, hasArgs) {
+  const not = util2.flag(assertion, "negate") ? "not." : "";
+  const name = `${util2.flag(assertion, "_name")}(${"expected"})`;
+  const promiseName = util2.flag(assertion, "promise");
+  const promise = promiseName ? `.${promiseName}` : "";
+  return `expect(actual)${promise}.${not}${name}`;
+}
+function recordAsyncExpect(_test, promise, assertion, error) {
+  const test2 = _test;
+  if (test2 && promise instanceof Promise) {
     promise = promise.finally(() => {
-      const index = test3.promises.indexOf(promise);
+      if (!test2.promises) {
+        return;
+      }
+      const index = test2.promises.indexOf(promise);
       if (index !== -1) {
-        test3.promises.splice(index, 1);
+        test2.promises.splice(index, 1);
       }
     });
-    if (!test3.promises) {
-      test3.promises = [];
-    }
-    test3.promises.push(promise);
+    if (!test2.promises) {
+      test2.promises = [];
+    }
+    test2.promises.push(promise);
+    let resolved = false;
+    test2.onFinished ??= [];
+    test2.onFinished.push(() => {
+      if (!resolved) {
+        const processor = globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || "");
+        const stack = processor(error.stack);
+        console.warn([
+          `Promise returned by \`${assertion}\` was not awaited. `,
+          "Vitest currently auto-awaits hanging assertions at the end of the test, but this will cause the test to fail in Vitest 3. ",
+          "Please remember to await the assertion.\n",
+          stack
+        ].join(""));
+      }
+    });
+    return {
+      then(onFullfilled, onRejected) {
+        resolved = true;
+        return promise.then(onFullfilled, onRejected);
+      },
+      catch(onRejected) {
+        return promise.catch(onRejected);
+      },
+      finally(onFinally) {
+        return promise.finally(onFinally);
+      },
+      [Symbol.toStringTag]: "Promise"
+    };
   }
   return promise;
 }
@@ -4333,27 +4430,28 @@ function getError(expected, promise) {
   }
   throw new Error("snapshot function didn't throw");
 }
-function getTestNames(test3) {
-  if (!test3) {
+function getTestNames(test2) {
+  if (!test2) {
     return {};
   }
   return {
-    filepath: test3.file.filepath,
-    name: getNames(test3).slice(1).join(" > ")
+    filepath: test2.file.filepath,
+    name: getNames(test2).slice(1).join(" > ")
   };
 }
-var SnapshotPlugin = (chai4, utils) => {
+var SnapshotPlugin = (chai3, utils) => {
   for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
     utils.addMethod(
-      chai4.Assertion.prototype,
+      chai3.Assertion.prototype,
       key,
       function(properties, message) {
+        utils.flag(this, "_name", key);
         const isNot = utils.flag(this, "negate");
         if (isNot) {
           throw new Error(`${key} cannot be used with "not"`);
         }
         const expected = utils.flag(this, "object");
-        const test3 = utils.flag(this, "vitest-test");
+        const test2 = utils.flag(this, "vitest-test");
         if (typeof properties === "string" && typeof message === "undefined") {
           message = properties;
           properties = void 0;
@@ -4365,21 +4463,23 @@ var SnapshotPlugin = (chai4, utils) => {
           isInline: false,
           properties,
           errorMessage,
-          ...getTestNames(test3)
+          ...getTestNames(test2)
         });
       }
     );
   }
   utils.addMethod(
-    chai4.Assertion.prototype,
+    chai3.Assertion.prototype,
     "toMatchFileSnapshot",
     function(file, message) {
+      utils.flag(this, "_name", "toMatchFileSnapshot");
       const isNot = utils.flag(this, "negate");
       if (isNot) {
         throw new Error('toMatchFileSnapshot cannot be used with "not"');
       }
+      const error = new Error("resolves");
       const expected = utils.flag(this, "object");
-      const test3 = utils.flag(this, "vitest-test");
+      const test2 = utils.flag(this, "vitest-test");
       const errorMessage = utils.flag(this, "message");
       const promise = getSnapshotClient().assertRaw({
         received: expected,
@@ -4389,21 +4489,27 @@ var SnapshotPlugin = (chai4, utils) => {
           file
         },
         errorMessage,
-        ...getTestNames(test3)
+        ...getTestNames(test2)
       });
-      return recordAsyncExpect(test3, promise);
+      return recordAsyncExpect(
+        test2,
+        promise,
+        createAssertionMessage(utils, this),
+        error
+      );
     }
   );
   utils.addMethod(
-    chai4.Assertion.prototype,
+    chai3.Assertion.prototype,
     "toMatchInlineSnapshot",
     function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
+      utils.flag(this, "_name", "toMatchInlineSnapshot");
       const isNot = utils.flag(this, "negate");
       if (isNot) {
         throw new Error('toMatchInlineSnapshot cannot be used with "not"');
       }
-      const test3 = utils.flag(this, "vitest-test");
-      const isInsideEach = test3 && (test3.each || test3.suite?.each);
+      const test2 = utils.flag(this, "vitest-test");
+      const isInsideEach = test2 && (test2.each || test2.suite?.each);
       if (isInsideEach) {
         throw new Error(
           "InlineSnapshot cannot be used inside of test.each or describe.each"
@@ -4428,14 +4534,15 @@ var SnapshotPlugin = (chai4, utils) => {
         inlineSnapshot,
         error,
         errorMessage,
-        ...getTestNames(test3)
+        ...getTestNames(test2)
       });
     }
   );
   utils.addMethod(
-    chai4.Assertion.prototype,
+    chai3.Assertion.prototype,
     "toThrowErrorMatchingSnapshot",
     function(message) {
+      utils.flag(this, "_name", "toThrowErrorMatchingSnapshot");
       const isNot = utils.flag(this, "negate");
       if (isNot) {
         throw new Error(
@@ -4443,19 +4550,19 @@ var SnapshotPlugin = (chai4, utils) => {
         );
       }
       const expected = utils.flag(this, "object");
-      const test3 = utils.flag(this, "vitest-test");
+      const test2 = utils.flag(this, "vitest-test");
       const promise = utils.flag(this, "promise");
       const errorMessage = utils.flag(this, "message");
       getSnapshotClient().assert({
         received: getError(expected, promise),
         message,
         errorMessage,
-        ...getTestNames(test3)
+        ...getTestNames(test2)
       });
     }
   );
   utils.addMethod(
-    chai4.Assertion.prototype,
+    chai3.Assertion.prototype,
     "toThrowErrorMatchingInlineSnapshot",
     function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
       const isNot = utils.flag(this, "negate");
@@ -4464,8 +4571,8 @@ var SnapshotPlugin = (chai4, utils) => {
           'toThrowErrorMatchingInlineSnapshot cannot be used with "not"'
         );
       }
-      const test3 = utils.flag(this, "vitest-test");
-      const isInsideEach = test3 && (test3.each || test3.suite?.each);
+      const test2 = utils.flag(this, "vitest-test");
+      const isInsideEach = test2 && (test2.each || test2.suite?.each);
       if (isInsideEach) {
         throw new Error(
           "InlineSnapshot cannot be used inside of test.each or describe.each"
@@ -4485,114 +4592,23 @@ var SnapshotPlugin = (chai4, utils) => {
         isInline: true,
         error,
         errorMessage,
-        ...getTestNames(test3)
+        ...getTestNames(test2)
       });
     }
   );
-  utils.addMethod(chai4.expect, "addSnapshotSerializer", addSerializer);
+  utils.addMethod(chai3.expect, "addSnapshotSerializer", addSerializer);
 };
 chai$1.use(JestExtend);
 chai$1.use(JestChaiExpect);
 chai$1.use(Subset);
 chai$1.use(SnapshotPlugin);
 chai$1.use(JestAsymmetricMatchers);
-var unsupported = [
-  // .poll is meant to retry matchers until they succeed, and
-  // snapshots will always succeed as long as the poll method doesn't thow an error
-  // in this case using the `vi.waitFor` method is more appropriate
-  "matchSnapshot",
-  "toMatchSnapshot",
-  "toMatchInlineSnapshot",
-  "toThrowErrorMatchingSnapshot",
-  "toThrowErrorMatchingInlineSnapshot",
-  // toThrow will never succeed because we call the poll callback until it doesn't throw
-  "throws",
-  "Throw",
-  "throw",
-  "toThrow",
-  "toThrowError"
-  // these are not supported because you can call them without `.poll`,
-  // we throw an error inside the rejects/resolves methods to prevent this
-  // rejects,
-  // resolves
-];
-function createExpectPoll(expect2) {
-  return function poll(fn2, options = {}) {
-    const state = getWorkerState();
-    const defaults = state.config.expect?.poll ?? {};
-    const {
-      interval = defaults.interval ?? 50,
-      timeout = defaults.timeout ?? 1e3,
-      message
-    } = options;
-    const assertion = expect2(null, message).withContext({
-      poll: true
-    });
-    fn2 = fn2.bind(assertion);
-    const proxy = new Proxy(assertion, {
-      get(target, key, receiver) {
-        const assertionFunction = Reflect.get(target, key, receiver);
-        if (typeof assertionFunction !== "function") {
-          return assertionFunction instanceof chai$1.Assertion ? proxy : assertionFunction;
-        }
-        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 = new Error("STACK_TRACE_ERROR");
-          return new Promise((resolve, reject) => {
-            let intervalId;
-            let lastError;
-            const { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = getSafeTimers();
-            const timeoutId = setTimeout2(() => {
-              clearTimeout2(intervalId);
-              reject(
-                copyStackTrace$1(
-                  new Error(`Matcher did not succeed in ${timeout}ms`, {
-                    cause: lastError
-                  }),
-                  STACK_TRACE_ERROR
-                )
-              );
-            }, timeout);
-            const check = async () => {
-              try {
-                chai$1.util.flag(assertion, "_name", key);
-                const obj = await fn2();
-                chai$1.util.flag(assertion, "object", obj);
-                resolve(await assertionFunction.call(assertion, ...args));
-                clearTimeout2(intervalId);
-                clearTimeout2(timeoutId);
-              } catch (err) {
-                lastError = err;
-                intervalId = setTimeout2(check, interval);
-              }
-            };
-            check();
-          });
-        };
-      }
-    });
-    return proxy;
-  };
-}
-function copyStackTrace$1(target, source) {
-  if (source.stack !== void 0) {
-    target.stack = source.stack.replace(source.message, target.message);
-  }
-  return target;
-}
-function createExpect(test3) {
+function createExpect(test2) {
   const expect2 = (value, message) => {
     const { assertionCalls } = getState(expect2);
     setState({ assertionCalls: assertionCalls + 1 }, expect2);
     const assert22 = chai$1.expect(value, message);
-    const _test = test3 || getCurrentTest();
+    const _test = getCurrentTest();
     if (_test) {
       return assert22.withTest(_test);
     } else {
@@ -4617,7 +4633,7 @@ function createExpect(test3) {
       get testPath() {
         return getWorkerState().filepath;
       },
-      currentTestName: test3 ? getTestName(test3) : globalState.currentTestName
+      currentTestName: globalState.currentTestName
     },
     expect2
   );
@@ -6853,108 +6869,6 @@ function getImporter(name) {
   const stack = parseSingleStack(stackArray[importerStackIndex + 1]);
   return stack?.file || "";
 }
-var dist = {};
-var hasRequiredDist;
-function requireDist() {
-  if (hasRequiredDist) return dist;
-  hasRequiredDist = 1;
-  (function(exports) {
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.expectTypeOf = void 0;
-    const fn2 = () => true;
-    const expectTypeOf2 = (_actual) => {
-      const nonFunctionProperties = [
-        "parameters",
-        "returns",
-        "resolves",
-        "not",
-        "items",
-        "constructorParameters",
-        "thisParameter",
-        "instance",
-        "guards",
-        "asserts",
-        "branded"
-      ];
-      const obj = {
-        /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-        toBeAny: fn2,
-        toBeUnknown: fn2,
-        toBeNever: fn2,
-        toBeFunction: fn2,
-        toBeObject: fn2,
-        toBeArray: fn2,
-        toBeString: fn2,
-        toBeNumber: fn2,
-        toBeBoolean: fn2,
-        toBeVoid: fn2,
-        toBeSymbol: fn2,
-        toBeNull: fn2,
-        toBeUndefined: fn2,
-        toBeNullable: fn2,
-        toMatchTypeOf: fn2,
-        toEqualTypeOf: fn2,
-        toBeCallableWith: fn2,
-        toBeConstructibleWith: fn2,
-        /* eslint-enable @typescript-eslint/no-unsafe-assignment */
-        extract: exports.expectTypeOf,
-        exclude: exports.expectTypeOf,
-        pick: exports.expectTypeOf,
-        omit: exports.expectTypeOf,
-        toHaveProperty: exports.expectTypeOf,
-        parameter: exports.expectTypeOf
-      };
-      const getterProperties = nonFunctionProperties;
-      getterProperties.forEach((prop) => Object.defineProperty(obj, prop, { get: () => (0, exports.expectTypeOf)({}) }));
-      return obj;
-    };
-    exports.expectTypeOf = expectTypeOf2;
-  })(dist);
-  return dist;
-}
-var distExports = requireDist();
-function noop2() {
-}
-var assertType = noop2;
-function getRunningMode() {
-  return process.env.VITEST_MODE === "WATCH" ? "watch" : "run";
-}
-function isWatchMode() {
-  return getRunningMode() === "watch";
-}
-function inject(key) {
-  const workerState = getWorkerState();
-  return workerState.providedContext[key];
-}
-/* @__PURE__ */ Object.freeze({
-  __proto__: null,
-  afterAll: afterAll$1,
-  afterEach: afterEach$1,
-  assert: assert,
-  assertType,
-  beforeAll: beforeAll$1,
-  beforeEach,
-  bench,
-  chai: chai$1,
-  createExpect,
-  describe,
-  expect: globalExpect,
-  expectTypeOf: distExports.expectTypeOf,
-  getRunningMode,
-  inject,
-  isFirstRun,
-  isWatchMode,
-  it,
-  onTestFailed,
-  onTestFinished,
-  runOnce,
-  should,
-  suite,
-  test,
-  vi,
-  vitest
-});
-distExports.expectTypeOf;
 
 // src/test/setup.ts
 globalExpect.extend(matchers_exports);