vitest 0.21.1 → 0.23.0

package/dist/{chunk-runtime-chain.98d42d89.mjs → chunk-runtime-chain.2af36ddf.mjs}

@@ -1,12 +1,12 @@
 import util$1 from 'util';
-import { i as isObject, j as join, d as dirname, g as getCallLastIndex, s as slash, b as getNames, c as assertTypes, p as picocolors, e as getFullName, n as noop } from './chunk-mock-date.bc81a3ac.mjs';
+import { i as isObject, b as getCallLastIndex, s as slash, g as getWorkerState, c as getNames, d as assertTypes, e as getFullName, f as isRunningInTest, n as noop, h as isRunningInBenchmark } from './chunk-mock-date.0d86eaa5.mjs';
 import * as chai$2 from 'chai';
 import { expect, AssertionError, util } from 'chai';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.4da45ef5.mjs';
-import { r as rpc } from './chunk-runtime-rpc.b50ab560.mjs';
+import { r as rpc } from './chunk-runtime-rpc.3fe371e9.mjs';
 import fs, { promises } from 'fs';
-import { a as plugins_1, f as format_1, g as getOriginalPos, b as posToNumber, n as numberToPos, l as lineSplitRE, p as parseStacktrace, u as unifiedDiff, s as stringify, m as matcherUtils } from './chunk-utils-source-map.94107ee8.mjs';
-import { g as getWorkerState } from './chunk-utils-global.fa20c2f6.mjs';
+import { j as join, d as dirname, p as picocolors } from './chunk-constants.6196597b.mjs';
+import { a as plugins_1, f as format_1, g as getOriginalPos, b as posToNumber, n as numberToPos, l as lineSplitRE, p as parseStacktrace, u as unifiedDiff, s as stringify, m as matcherUtils } from './chunk-utils-source-map.70ee97e1.mjs';
 import { isMockFunction } from './spy.mjs';
 import { s as safeSetTimeout, a as safeClearTimeout } from './chunk-utils-timers.b48455ed.mjs';
 
@@ -208,7 +208,11 @@ function keys(obj, hasKey2) {
     if (hasKey2(obj, key))
       keys2.push(key);
   }
-  return keys2.concat(Object.getOwnPropertySymbols(obj).filter((symbol) => Object.getOwnPropertyDescriptor(obj, symbol).enumerable));
+  return keys2.concat(
+    Object.getOwnPropertySymbols(obj).filter(
+      (symbol) => Object.getOwnPropertyDescriptor(obj, symbol).enumerable
+    )
+  );
 }
 function hasDefinedKey(obj, key) {
   return hasKey(obj, key) && obj[key] !== void 0;
@@ -498,13 +502,15 @@ const removeExtraLineBreaks = (string) => string.length > 2 && string.startsWith
 const escapeRegex = true;
 const printFunctionName = false;
 function serialize(val, indent = 2, formatOverrides = {}) {
-  return normalizeNewlines(format_1(val, {
-    escapeRegex,
-    indent,
-    plugins: getSerializers(),
-    printFunctionName,
-    ...formatOverrides
-  }));
+  return normalizeNewlines(
+    format_1(val, {
+      escapeRegex,
+      indent,
+      plugins: getSerializers(),
+      printFunctionName,
+      ...formatOverrides
+    })
+  );
 }
 function escapeBacktickString(str) {
   return str.replace(/`|\\|\${/g, "\\$&");
@@ -523,7 +529,9 @@ function normalizeNewlines(string) {
 }
 async function saveSnapshotFile(snapshotData, snapshotPath) {
   var _a, _b;
-  const snapshots = Object.keys(snapshotData).sort(naturalCompare$1.exports).map((key) => `exports[${printBacktickString(key)}] = ${printBacktickString(normalizeNewlines(snapshotData[key]))};`);
+  const snapshots = Object.keys(snapshotData).sort(naturalCompare$1.exports).map(
+    (key) => `exports[${printBacktickString(key)}] = ${printBacktickString(normalizeNewlines(snapshotData[key]))};`
+  );
   const content = `${writeSnapshotVersion()}
 
 ${snapshots.join("\n\n")}
@@ -532,7 +540,11 @@ ${snapshots.join("\n\n")}
   if (skipWriting)
     return;
   ensureDirectoryExists(snapshotPath);
-  await ((_b = fs) == null ? void 0 : _b.promises.writeFile(snapshotPath, content, "utf-8"));
+  await ((_b = fs) == null ? void 0 : _b.promises.writeFile(
+    snapshotPath,
+    content,
+    "utf-8"
+  ));
 }
 function prepareExpected(expected) {
   function findStartIndent() {
@@ -588,7 +600,7 @@ function deepMergeSnapshot(target, source) {
 }
 
 async function saveInlineSnapshots(snapshots) {
-  const MagicString = (await import('./chunk-magic-string.efe26975.mjs')).default;
+  const MagicString = (await import('./chunk-magic-string.56b2b543.mjs')).default;
   const files = new Set(snapshots.map((i) => i.file));
   await Promise.all(Array.from(files).map(async (file) => {
     const map = await rpc().getSourceMap(file);
@@ -684,7 +696,10 @@ class SnapshotState {
   constructor(testFilePath, snapshotPath, options) {
     this.testFilePath = testFilePath;
     this.snapshotPath = snapshotPath;
-    const { data, dirty } = getSnapshotData(this.snapshotPath, options.updateSnapshot);
+    const { data, dirty } = getSnapshotData(
+      this.snapshotPath,
+      options.updateSnapshot
+    );
     this._initialData = data;
     this._snapshotData = data;
     this._dirty = dirty;
@@ -723,8 +738,10 @@ class SnapshotState {
       stacks.forEach((i) => i.file = slash(i.file));
       const stack = this._inferInlineSnapshotStack(stacks);
       if (!stack) {
-        throw new Error(`Vitest: Couldn't infer stack frame for inline snapshot.
-${JSON.stringify(stacks)}`);
+        throw new Error(
+          `Vitest: Couldn't infer stack frame for inline snapshot.
+${JSON.stringify(stacks)}`
+        );
       }
       stack.column--;
       this._inlineSnapshots.push({
@@ -883,7 +900,14 @@ class SnapshotClient {
       this.saveCurrent();
       const filePath = this.test.file.filepath;
       if (!this.getSnapshotState(test)) {
-        this.snapshotStateMap.set(filePath, new SnapshotState(filePath, await rpc().resolveSnapshotPath(filePath), getWorkerState().config.snapshotOptions));
+        this.snapshotStateMap.set(
+          filePath,
+          new SnapshotState(
+            filePath,
+            await rpc().resolveSnapshotPath(filePath),
+            getWorkerState().config.snapshotOptions
+          )
+        );
       }
       this.snapshotState = this.getSnapshotState(test);
     }
@@ -980,79 +1004,95 @@ const getErrorString = (expected, promise) => {
   } catch (e) {
     return getErrorMessage(e);
   }
-  throw new Error("snapshot function didn't threw");
+  throw new Error("snapshot function didn't throw");
 };
 const SnapshotPlugin = (chai, utils) => {
   for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
-    utils.addMethod(chai.Assertion.prototype, key, function(properties, message) {
+    utils.addMethod(
+      chai.Assertion.prototype,
+      key,
+      function(properties, message) {
+        const expected = utils.flag(this, "object");
+        const test = utils.flag(this, "vitest-test");
+        if (typeof properties === "string" && typeof message === "undefined") {
+          message = properties;
+          properties = void 0;
+        }
+        const errorMessage = utils.flag(this, "message");
+        getSnapshotClient().assert({
+          received: expected,
+          test,
+          message,
+          isInline: false,
+          properties,
+          errorMessage
+        });
+      }
+    );
+  }
+  utils.addMethod(
+    chai.Assertion.prototype,
+    "toMatchInlineSnapshot",
+    function __VITEST_INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
       const expected = utils.flag(this, "object");
+      const error = utils.flag(this, "error");
       const test = utils.flag(this, "vitest-test");
-      if (typeof properties === "string" && typeof message === "undefined") {
-        message = properties;
+      if (typeof properties === "string") {
+        message = inlineSnapshot;
+        inlineSnapshot = properties;
         properties = void 0;
       }
+      if (inlineSnapshot)
+        inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
       const errorMessage = utils.flag(this, "message");
       getSnapshotClient().assert({
         received: expected,
         test,
         message,
-        isInline: false,
+        isInline: true,
         properties,
+        inlineSnapshot,
+        error,
         errorMessage
       });
-    });
-  }
-  utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", function __VITEST_INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
-    const expected = utils.flag(this, "object");
-    const error = utils.flag(this, "error");
-    const test = utils.flag(this, "vitest-test");
-    if (typeof properties === "string") {
-      message = inlineSnapshot;
-      inlineSnapshot = properties;
-      properties = void 0;
     }
-    if (inlineSnapshot)
-      inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
-    const errorMessage = utils.flag(this, "message");
-    getSnapshotClient().assert({
-      received: expected,
-      test,
-      message,
-      isInline: true,
-      properties,
-      inlineSnapshot,
-      error,
-      errorMessage
-    });
-  });
-  utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", function(message) {
-    const expected = utils.flag(this, "object");
-    const test = utils.flag(this, "vitest-test");
-    const promise = utils.flag(this, "promise");
-    const errorMessage = utils.flag(this, "message");
-    getSnapshotClient().assert({
-      received: getErrorString(expected, promise),
-      test,
-      message,
-      errorMessage
-    });
-  });
-  utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", function __VITEST_INLINE_SNAPSHOT__(inlineSnapshot, message) {
-    const expected = utils.flag(this, "object");
-    const error = utils.flag(this, "error");
-    const test = utils.flag(this, "vitest-test");
-    const promise = utils.flag(this, "promise");
-    const errorMessage = utils.flag(this, "message");
-    getSnapshotClient().assert({
-      received: getErrorString(expected, promise),
-      test,
-      message,
-      inlineSnapshot,
-      isInline: true,
-      error,
-      errorMessage
-    });
-  });
+  );
+  utils.addMethod(
+    chai.Assertion.prototype,
+    "toThrowErrorMatchingSnapshot",
+    function(message) {
+      const expected = utils.flag(this, "object");
+      const test = utils.flag(this, "vitest-test");
+      const promise = utils.flag(this, "promise");
+      const errorMessage = utils.flag(this, "message");
+      getSnapshotClient().assert({
+        received: getErrorString(expected, promise),
+        test,
+        message,
+        errorMessage
+      });
+    }
+  );
+  utils.addMethod(
+    chai.Assertion.prototype,
+    "toThrowErrorMatchingInlineSnapshot",
+    function __VITEST_INLINE_SNAPSHOT__(inlineSnapshot, message) {
+      const expected = utils.flag(this, "object");
+      const error = utils.flag(this, "error");
+      const test = utils.flag(this, "vitest-test");
+      const promise = utils.flag(this, "promise");
+      const errorMessage = utils.flag(this, "message");
+      getSnapshotClient().assert({
+        received: getErrorString(expected, promise),
+        test,
+        message,
+        inlineSnapshot,
+        isInline: true,
+        error,
+        errorMessage
+      });
+    }
+  );
 };
 
 var chai$1 = /*#__PURE__*/Object.freeze({
@@ -1063,10 +1103,20 @@ var chai$1 = /*#__PURE__*/Object.freeze({
 
 const GLOBAL_EXPECT = Symbol.for("expect-global");
 const MATCHERS_OBJECT = Symbol.for("matchers-object");
+const JEST_MATCHERS_OBJECT = Symbol.for("$$jest-matchers-object");
 
 if (!Object.prototype.hasOwnProperty.call(globalThis, MATCHERS_OBJECT)) {
+  const globalState = /* @__PURE__ */ new WeakMap();
+  const matchers = /* @__PURE__ */ Object.create(null);
   Object.defineProperty(globalThis, MATCHERS_OBJECT, {
-    value: /* @__PURE__ */ new WeakMap()
+    get: () => globalState
+  });
+  Object.defineProperty(globalThis, JEST_MATCHERS_OBJECT, {
+    configurable: true,
+    get: () => ({
+      state: globalState.get(globalThis[GLOBAL_EXPECT]),
+      matchers
+    })
   });
 }
 const getState = (expect) => globalThis[MATCHERS_OBJECT].get(expect);
@@ -1080,6 +1130,7 @@ const JestChaiExpect = (chai, utils) => {
   function def(name, fn) {
     const addMethod = (n) => {
       utils.addMethod(chai.Assertion.prototype, n, fn);
+      utils.addMethod(globalThis[JEST_MATCHERS_OBJECT].matchers, n, fn);
     };
     if (Array.isArray(name))
       name.forEach((n) => addMethod(n));
@@ -1117,43 +1168,85 @@ const JestChaiExpect = (chai, utils) => {
   });
   def("toEqual", function(expected) {
     const actual = utils.flag(this, "object");
-    const equal = equals(actual, expected, [iterableEquality]);
-    return this.assert(equal, "expected #{this} to deeply equal #{exp}", "expected #{this} to not deeply equal #{exp}", expected, actual);
+    const equal = equals(
+      actual,
+      expected,
+      [iterableEquality]
+    );
+    return this.assert(
+      equal,
+      "expected #{this} to deeply equal #{exp}",
+      "expected #{this} to not deeply equal #{exp}",
+      expected,
+      actual
+    );
   });
   def("toStrictEqual", function(expected) {
     const obj = utils.flag(this, "object");
-    const equal = equals(obj, expected, [
-      iterableEquality,
-      typeEquality,
-      sparseArrayEquality,
-      arrayBufferEquality
-    ], true);
-    return this.assert(equal, "expected #{this} to strictly equal #{exp}", "expected #{this} to not strictly equal #{exp}", expected, obj);
+    const equal = equals(
+      obj,
+      expected,
+      [
+        iterableEquality,
+        typeEquality,
+        sparseArrayEquality,
+        arrayBufferEquality
+      ],
+      true
+    );
+    return this.assert(
+      equal,
+      "expected #{this} to strictly equal #{exp}",
+      "expected #{this} to not strictly equal #{exp}",
+      expected,
+      obj
+    );
   });
   def("toBe", function(expected) {
     const actual = this._obj;
     const pass = Object.is(actual, expected);
     let deepEqualityName = "";
     if (!pass) {
-      const toStrictEqualPass = equals(actual, expected, [
-        iterableEquality,
-        typeEquality,
-        sparseArrayEquality,
-        arrayBufferEquality
-      ], true);
+      const toStrictEqualPass = equals(
+        actual,
+        expected,
+        [
+          iterableEquality,
+          typeEquality,
+          sparseArrayEquality,
+          arrayBufferEquality
+        ],
+        true
+      );
       if (toStrictEqualPass) {
         deepEqualityName = "toStrictEqual";
       } else {
-        const toEqualPass = equals(actual, expected, [iterableEquality]);
+        const toEqualPass = equals(
+          actual,
+          expected,
+          [iterableEquality]
+        );
         if (toEqualPass)
           deepEqualityName = "toEqual";
       }
     }
-    return this.assert(pass, generateToBeMessage(deepEqualityName), "expected #{this} not to be #{exp} // Object.is equality", expected, actual);
+    return this.assert(
+      pass,
+      generateToBeMessage(deepEqualityName),
+      "expected #{this} not to be #{exp} // Object.is equality",
+      expected,
+      actual
+    );
   });
   def("toMatchObject", function(expected) {
     const actual = this._obj;
-    return this.assert(equals(actual, expected, [iterableEquality, subsetEquality]), "expected #{this} to match object #{exp}", "expected #{this} to not match object #{exp}", expected, actual);
+    return this.assert(
+      equals(actual, expected, [iterableEquality, subsetEquality]),
+      "expected #{this} to match object #{exp}",
+      "expected #{this} to not match object #{exp}",
+      expected,
+      actual
+    );
   });
   def("toMatch", function(expected) {
     if (typeof expected === "string")
@@ -1169,39 +1262,78 @@ const JestChaiExpect = (chai, utils) => {
     const index = Array.from(obj).findIndex((item) => {
       return equals(item, expected);
     });
-    this.assert(index !== -1, "expected #{this} to deep equally contain #{exp}", "expected #{this} to not deep equally contain #{exp}", expected);
+    this.assert(
+      index !== -1,
+      "expected #{this} to deep equally contain #{exp}",
+      "expected #{this} to not deep equally contain #{exp}",
+      expected
+    );
   });
   def("toBeTruthy", function() {
     const obj = utils.flag(this, "object");
-    this.assert(Boolean(obj), "expected #{this} to be truthy", "expected #{this} to not be truthy", obj);
+    this.assert(
+      Boolean(obj),
+      "expected #{this} to be truthy",
+      "expected #{this} to not be truthy",
+      obj
+    );
   });
   def("toBeFalsy", function() {
     const obj = utils.flag(this, "object");
-    this.assert(!obj, "expected #{this} to be falsy", "expected #{this} to not be falsy", obj);
+    this.assert(
+      !obj,
+      "expected #{this} to be falsy",
+      "expected #{this} to not be falsy",
+      obj
+    );
   });
   def("toBeGreaterThan", function(expected) {
     const actual = this._obj;
     assertTypes(actual, "actual", ["number", "bigint"]);
     assertTypes(expected, "expected", ["number", "bigint"]);
-    return this.assert(actual > expected, `expected ${actual} to be greater than ${expected}`, `expected ${actual} to be not greater than ${expected}`, actual, expected);
+    return this.assert(
+      actual > expected,
+      `expected ${actual} to be greater than ${expected}`,
+      `expected ${actual} to be not greater than ${expected}`,
+      actual,
+      expected
+    );
   });
   def("toBeGreaterThanOrEqual", function(expected) {
     const actual = this._obj;
     assertTypes(actual, "actual", ["number", "bigint"]);
     assertTypes(expected, "expected", ["number", "bigint"]);
-    return this.assert(actual >= expected, `expected ${actual} to be greater than or equal to ${expected}`, `expected ${actual} to be not greater than or equal to ${expected}`, actual, expected);
+    return this.assert(
+      actual >= expected,
+      `expected ${actual} to be greater than or equal to ${expected}`,
+      `expected ${actual} to be not greater than or equal to ${expected}`,
+      actual,
+      expected
+    );
   });
   def("toBeLessThan", function(expected) {
     const actual = this._obj;
     assertTypes(actual, "actual", ["number", "bigint"]);
     assertTypes(expected, "expected", ["number", "bigint"]);
-    return this.assert(actual < expected, `expected ${actual} to be less than ${expected}`, `expected ${actual} to be not less than ${expected}`, actual, expected);
+    return this.assert(
+      actual < expected,
+      `expected ${actual} to be less than ${expected}`,
+      `expected ${actual} to be not less than ${expected}`,
+      actual,
+      expected
+    );
   });
   def("toBeLessThanOrEqual", function(expected) {
     const actual = this._obj;
     assertTypes(actual, "actual", ["number", "bigint"]);
     assertTypes(expected, "expected", ["number", "bigint"]);
-    return this.assert(actual <= expected, `expected ${actual} to be less than or equal to ${expected}`, `expected ${actual} to be not less than or equal to ${expected}`, actual, expected);
+    return this.assert(
+      actual <= expected,
+      `expected ${actual} to be less than or equal to ${expected}`,
+      `expected ${actual} to be not less than or equal to ${expected}`,
+      actual,
+      expected
+    );
   });
   def("toBeNaN", function() {
     return this.be.NaN;
@@ -1222,7 +1354,13 @@ const JestChaiExpect = (chai, utils) => {
   def("toBeTypeOf", function(expected) {
     const actual = typeof this._obj;
     const equal = expected === actual;
-    return this.assert(equal, "expected #{this} to be type of #{exp}", "expected #{this} not to be type of #{exp}", expected, actual);
+    return this.assert(
+      equal,
+      "expected #{this} to be type of #{exp}",
+      "expected #{this} not to be type of #{exp}",
+      expected,
+      actual
+    );
   });
   def("toBeInstanceOf", function(obj) {
     return this.instanceOf(obj);
@@ -1235,14 +1373,21 @@ const JestChaiExpect = (chai, utils) => {
       args[0] = args[0].map((key) => key.replace(/([.[\]])/g, "\\$1")).join(".");
     const actual = this._obj;
     const [propertyName, expected] = args;
-    let pass = false;
-    if (Object.prototype.hasOwnProperty.call(actual, propertyName)) {
-      pass = true;
-    } else {
-      const { value, exists } = utils.getPathInfo(actual, propertyName);
-      pass = exists && (args.length === 1 || equals(expected, value));
-    }
-    return this.assert(pass, "expected #{this} to have property #{exp}", "expected #{this} to not have property #{exp}", expected, actual);
+    const getValue = () => {
+      const hasOwn = Object.prototype.hasOwnProperty.call(actual, propertyName);
+      if (hasOwn)
+        return { value: actual[propertyName], exists: true };
+      return utils.getPathInfo(actual, propertyName);
+    };
+    const { value, exists } = getValue();
+    const pass = exists && (args.length === 1 || equals(expected, value));
+    const valueString = args.length === 1 ? "" : ` with value ${utils.objDisplay(expected)}`;
+    return this.assert(
+      pass,
+      `expected #{this} to have property "${propertyName}"${valueString}`,
+      `expected #{this} to not have property "${propertyName}"${valueString}`,
+      actual
+    );
   });
   def("toBeCloseTo", function(received, precision = 2) {
     const expected = this._obj;
@@ -1258,7 +1403,13 @@ const JestChaiExpect = (chai, utils) => {
       receivedDiff = Math.abs(expected - received);
       pass = receivedDiff < expectedDiff;
     }
-    return this.assert(pass, `expected #{this} to be close to #{exp}, received difference is ${receivedDiff}, but expected ${expectedDiff}`, `expected #{this} to not be close to #{exp}, received difference is ${receivedDiff}, but expected ${expectedDiff}`, received, expected);
+    return this.assert(
+      pass,
+      `expected #{this} to be close to #{exp}, received difference is ${receivedDiff}, but expected ${expectedDiff}`,
+      `expected #{this} to not be close to #{exp}, received difference is ${receivedDiff}, but expected ${expectedDiff}`,
+      received,
+      expected
+    );
   });
   const assertIsMock = (assertion) => {
     if (!isMockFunction(assertion._obj))
@@ -1304,26 +1455,41 @@ Number of calls: ${picocolors.exports.bold(spy.mock.calls.length)}
     const spy = getSpy(this);
     const spyName = spy.getMockName();
     const callCount = spy.mock.calls.length;
-    return this.assert(callCount === number, `expected "${spyName}" to be called #{exp} times`, `expected "${spyName}" to not be called #{exp} times`, number, callCount);
+    return this.assert(
+      callCount === number,
+      `expected "${spyName}" to be called #{exp} times`,
+      `expected "${spyName}" to not be called #{exp} times`,
+      number,
+      callCount
+    );
   });
   def("toHaveBeenCalledOnce", function() {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
     const callCount = spy.mock.calls.length;
-    return this.assert(callCount === 1, `expected "${spyName}" to be called once`, `expected "${spyName}" to not be called once`, 1, callCount);
+    return this.assert(
+      callCount === 1,
+      `expected "${spyName}" to be called once`,
+      `expected "${spyName}" to not be called once`,
+      1,
+      callCount
+    );
   });
   def(["toHaveBeenCalled", "toBeCalled"], function() {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
     const called = spy.mock.calls.length > 0;
     const isNot = utils.flag(this, "negate");
-    let msg = utils.getMessage(this, [
-      called,
-      `expected "${spyName}" to be called at least once`,
-      `expected "${spyName}" to not be called at all`,
-      true,
-      called
-    ]);
+    let msg = utils.getMessage(
+      this,
+      [
+        called,
+        `expected "${spyName}" to be called at least once`,
+        `expected "${spyName}" to not be called at all`,
+        true,
+        called
+      ]
+    );
     if (called && isNot)
       msg += formatCalls(spy, msg);
     if (called && isNot || !called && !isNot) {
@@ -1337,12 +1503,15 @@ Number of calls: ${picocolors.exports.bold(spy.mock.calls.length)}
     const spyName = spy.getMockName();
     const pass = spy.mock.calls.some((callArg) => equals(callArg, args, [iterableEquality]));
     const isNot = utils.flag(this, "negate");
-    let msg = utils.getMessage(this, [
-      pass,
-      `expected "${spyName}" to be called with arguments: #{exp}`,
-      `expected "${spyName}" to not be called with arguments: #{exp}`,
-      args
-    ]);
+    let msg = utils.getMessage(
+      this,
+      [
+        pass,
+        `expected "${spyName}" to be called with arguments: #{exp}`,
+        `expected "${spyName}" to not be called with arguments: #{exp}`,
+        args
+      ]
+    );
     if (pass && isNot || !pass && !isNot) {
       msg += formatCalls(spy, msg, args);
       const err = new Error(msg);
@@ -1354,13 +1523,25 @@ Number of calls: ${picocolors.exports.bold(spy.mock.calls.length)}
     const spy = getSpy(this);
     const spyName = spy.getMockName();
     const nthCall = spy.mock.calls[times - 1];
-    this.assert(equals(nthCall, args, [iterableEquality]), `expected ${ordinalOf(times)} "${spyName}" call to have been called with #{exp}`, `expected ${ordinalOf(times)} "${spyName}" call to not have been called with #{exp}`, args, nthCall);
+    this.assert(
+      equals(nthCall, args, [iterableEquality]),
+      `expected ${ordinalOf(times)} "${spyName}" call to have been called with #{exp}`,
+      `expected ${ordinalOf(times)} "${spyName}" call to not have been called with #{exp}`,
+      args,
+      nthCall
+    );
   });
   def(["toHaveBeenLastCalledWith", "lastCalledWith"], function(...args) {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
     const lastCall = spy.mock.calls[spy.calls.length - 1];
-    this.assert(equals(lastCall, args, [iterableEquality]), `expected last "${spyName}" call to have been called with #{exp}`, `expected last "${spyName}" call to not have been called with #{exp}`, args, lastCall);
+    this.assert(
+      equals(lastCall, args, [iterableEquality]),
+      `expected last "${spyName}" call to have been called with #{exp}`,
+      `expected last "${spyName}" call to not have been called with #{exp}`,
+      args,
+      lastCall
+    );
   });
   def(["toThrow", "toThrowError"], function(expected) {
     if (typeof expected === "string" || typeof expected === "undefined" || expected instanceof RegExp)
@@ -1390,14 +1571,32 @@ Number of calls: ${picocolors.exports.bold(spy.mock.calls.length)}
     }
     if (typeof expected === "function") {
       const name = expected.name || expected.prototype.constructor.name;
-      return this.assert(thrown && thrown instanceof expected, `expected error to be instance of ${name}`, `expected error not to be instance of ${name}`, expected, thrown);
+      return this.assert(
+        thrown && thrown instanceof expected,
+        `expected error to be instance of ${name}`,
+        `expected error not to be instance of ${name}`,
+        expected,
+        thrown
+      );
     }
     if (expected instanceof Error) {
-      return this.assert(thrown && expected.message === thrown.message, `expected error to have message: ${expected.message}`, `expected error not to have message: ${expected.message}`, expected.message, thrown && thrown.message);
+      return this.assert(
+        thrown && expected.message === thrown.message,
+        `expected error to have message: ${expected.message}`,
+        `expected error not to have message: ${expected.message}`,
+        expected.message,
+        thrown && thrown.message
+      );
     }
     if (typeof expected.asymmetricMatch === "function") {
       const matcher = expected;
-      return this.assert(thrown && matcher.asymmetricMatch(thrown), "expected error to match asymmetric matcher", "expected error not to match asymmetric matcher", matcher.toString(), thrown);
+      return this.assert(
+        thrown && matcher.asymmetricMatch(thrown),
+        "expected error to match asymmetric matcher",
+        "expected error not to match asymmetric matcher",
+        matcher.toString(),
+        thrown
+      );
     }
     throw new Error(`"toThrow" expects string, RegExp, function, Error instance or asymmetric matcher, got "${typeof expected}"`);
   });
@@ -1405,26 +1604,49 @@ Number of calls: ${picocolors.exports.bold(spy.mock.calls.length)}
     const spy = getSpy(this);
     const spyName = spy.getMockName();
     const calledAndNotThrew = spy.mock.calls.length > 0 && !spy.mock.results.some(({ type }) => type === "throw");
-    this.assert(calledAndNotThrew, `expected "${spyName}" to be successfully called at least once`, `expected "${spyName}" to not be successfully called`, calledAndNotThrew, !calledAndNotThrew);
+    this.assert(
+      calledAndNotThrew,
+      `expected "${spyName}" to be successfully called at least once`,
+      `expected "${spyName}" to not be successfully called`,
+      calledAndNotThrew,
+      !calledAndNotThrew
+    );
   });
   def(["toHaveReturnedTimes", "toReturnTimes"], function(times) {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
     const successfulReturns = spy.mock.results.reduce((success, { type }) => type === "throw" ? success : ++success, 0);
-    this.assert(successfulReturns === times, `expected "${spyName}" to be successfully called ${times} times`, `expected "${spyName}" to not be successfully called ${times} times`, `expected number of returns: ${times}`, `received number of returns: ${successfulReturns}`);
+    this.assert(
+      successfulReturns === times,
+      `expected "${spyName}" to be successfully called ${times} times`,
+      `expected "${spyName}" to not be successfully called ${times} times`,
+      `expected number of returns: ${times}`,
+      `received number of returns: ${successfulReturns}`
+    );
   });
   def(["toHaveReturnedWith", "toReturnWith"], function(value) {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
     const pass = spy.mock.results.some(({ type, value: result }) => type === "return" && equals(value, result));
-    this.assert(pass, `expected "${spyName}" to be successfully called with #{exp}`, `expected "${spyName}" to not be successfully called with #{exp}`, value);
+    this.assert(
+      pass,
+      `expected "${spyName}" to be successfully called with #{exp}`,
+      `expected "${spyName}" to not be successfully called with #{exp}`,
+      value
+    );
   });
   def(["toHaveLastReturnedWith", "lastReturnedWith"], function(value) {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
     const { value: lastResult } = spy.mock.results[spy.returns.length - 1];
     const pass = equals(lastResult, value);
-    this.assert(pass, `expected last "${spyName}" call to return #{exp}`, `expected last "${spyName}" call to not return #{exp}`, value, lastResult);
+    this.assert(
+      pass,
+      `expected last "${spyName}" call to return #{exp}`,
+      `expected last "${spyName}" call to not return #{exp}`,
+      value,
+      lastResult
+    );
   });
   def(["toHaveNthReturnedWith", "nthReturnedWith"], function(nthCall, value) {
     const spy = getSpy(this);
@@ -1435,7 +1657,13 @@ Number of calls: ${picocolors.exports.bold(spy.mock.calls.length)}
     if (!isNot && callType === "throw")
       chai.assert.fail(`expected ${ordinalCall} to return #{exp}, but instead it threw an error`);
     const nthCallReturn = equals(callResult, value);
-    this.assert(nthCallReturn, `expected ${ordinalCall} "${spyName}" call to return #{exp}`, `expected ${ordinalCall} "${spyName}" call to not return #{exp}`, value, callResult);
+    this.assert(
+      nthCallReturn,
+      `expected ${ordinalCall} "${spyName}" call to return #{exp}`,
+      `expected ${ordinalCall} "${spyName}" call to not return #{exp}`,
+      value,
+      callResult
+    );
   });
   def("toSatisfy", function(matcher, message) {
     return this.be.satisfy(matcher, message);
@@ -1452,12 +1680,15 @@ Number of calls: ${picocolors.exports.bold(spy.mock.calls.length)}
         if (typeof result !== "function")
           return result instanceof chai.Assertion ? proxy : result;
         return async (...args) => {
-          return obj.then((value) => {
-            utils.flag(this, "object", value);
-            return result.call(this, ...args);
-          }, (err) => {
-            throw new Error(`promise rejected "${toString(err)}" instead of resolving`);
-          });
+          return obj.then(
+            (value) => {
+              utils.flag(this, "object", value);
+              return result.call(this, ...args);
+            },
+            (err) => {
+              throw new Error(`promise rejected "${toString(err)}" instead of resolving`);
+            }
+          );
         };
       }
     });
@@ -1476,18 +1707,25 @@ Number of calls: ${picocolors.exports.bold(spy.mock.calls.length)}
         if (typeof result !== "function")
           return result instanceof chai.Assertion ? proxy : result;
         return async (...args) => {
-          return wrapper.then((value) => {
-            throw new Error(`promise resolved "${toString(value)}" instead of rejecting`);
-          }, (err) => {
-            utils.flag(this, "object", err);
-            return result.call(this, ...args);
-          });
+          return wrapper.then(
+            (value) => {
+              throw new Error(`promise resolved "${toString(value)}" instead of rejecting`);
+            },
+            (err) => {
+              utils.flag(this, "object", err);
+              return result.call(this, ...args);
+            }
+          );
         };
       }
     });
     return proxy;
   });
-  utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
+  utils.addMethod(
+    chai.expect,
+    "addSnapshotSerializer",
+    addSerializer
+  );
 };
 function toString(value) {
   try {
@@ -1560,7 +1798,9 @@ class ObjectContaining extends AsymmetricMatcher {
   }
   asymmetricMatch(other) {
     if (typeof this.sample !== "object") {
-      throw new TypeError(`You must provide an object to ${this.toString()}, not '${typeof this.sample}'.`);
+      throw new TypeError(
+        `You must provide an object to ${this.toString()}, not '${typeof this.sample}'.`
+      );
     }
     let result = true;
     for (const property in this.sample) {
@@ -1584,9 +1824,13 @@ class ArrayContaining extends AsymmetricMatcher {
   }
   asymmetricMatch(other) {
     if (!Array.isArray(this.sample)) {
-      throw new TypeError(`You must provide an array to ${this.toString()}, not '${typeof this.sample}'.`);
+      throw new TypeError(
+        `You must provide an array to ${this.toString()}, not '${typeof this.sample}'.`
+      );
     }
-    const result = this.sample.length === 0 || Array.isArray(other) && this.sample.every((item) => other.some((another) => equals(item, another)));
+    const result = this.sample.length === 0 || Array.isArray(other) && this.sample.every(
+      (item) => other.some((another) => equals(item, another))
+    );
     return this.inverse ? !result : result;
   }
   toString() {
@@ -1599,7 +1843,9 @@ class ArrayContaining extends AsymmetricMatcher {
 class Any extends AsymmetricMatcher {
   constructor(sample) {
     if (typeof sample === "undefined") {
-      throw new TypeError("any() expects to be passed a constructor function. Please pass one or use anything() to match any object.");
+      throw new TypeError(
+        "any() expects to be passed a constructor function. Please pass one or use anything() to match any object."
+      );
     }
     super(sample);
   }
@@ -1665,12 +1911,36 @@ class StringMatching extends AsymmetricMatcher {
   }
 }
 const JestAsymmetricMatchers = (chai, utils) => {
-  utils.addMethod(chai.expect, "anything", () => new Anything());
-  utils.addMethod(chai.expect, "any", (expected) => new Any(expected));
-  utils.addMethod(chai.expect, "stringContaining", (expected) => new StringContaining(expected));
-  utils.addMethod(chai.expect, "objectContaining", (expected) => new ObjectContaining(expected));
-  utils.addMethod(chai.expect, "arrayContaining", (expected) => new ArrayContaining(expected));
-  utils.addMethod(chai.expect, "stringMatching", (expected) => new StringMatching(expected));
+  utils.addMethod(
+    chai.expect,
+    "anything",
+    () => new Anything()
+  );
+  utils.addMethod(
+    chai.expect,
+    "any",
+    (expected) => new Any(expected)
+  );
+  utils.addMethod(
+    chai.expect,
+    "stringContaining",
+    (expected) => new StringContaining(expected)
+  );
+  utils.addMethod(
+    chai.expect,
+    "objectContaining",
+    (expected) => new ObjectContaining(expected)
+  );
+  utils.addMethod(
+    chai.expect,
+    "arrayContaining",
+    (expected) => new ArrayContaining(expected)
+  );
+  utils.addMethod(
+    chai.expect,
+    "stringMatching",
+    (expected) => new StringMatching(expected)
+  );
   chai.expect.not = {
     stringContaining: (expected) => new StringContaining(expected, true),
     objectContaining: (expected) => new ObjectContaining(expected, true),
@@ -1727,13 +1997,18 @@ function JestExtendPlugin(expect, matchers) {
           throw new JestExtendError(message(), actual, expected);
       }
       const expectAssertionWrapper = isAsyncFunction(expectAssertion) ? expectAsyncWrapper : expectSyncWrapper;
+      utils.addMethod(globalThis[JEST_MATCHERS_OBJECT].matchers, expectAssertionName, expectAssertionWrapper);
       utils.addMethod(c.Assertion.prototype, expectAssertionName, expectAssertionWrapper);
       class CustomMatcher extends AsymmetricMatcher {
         constructor(inverse = false, ...sample) {
           super(sample, inverse);
         }
         asymmetricMatch(other) {
-          const { pass } = expectAssertion.call(this.getMatcherContext(expect), other, ...this.sample);
+          const { pass } = expectAssertion.call(
+            this.getMatcherContext(expect),
+            other,
+            ...this.sample
+          );
           return this.inverse ? !pass : pass;
         }
         toString() {
@@ -1773,6 +2048,7 @@ chai$2.use(Subset);
 chai$2.use(SnapshotPlugin);
 chai$2.use(JestAsymmetricMatchers);
 
+const workerState$1 = getWorkerState();
 function createExpect(test) {
   var _a;
   const expect = (value, message) => {
@@ -1793,6 +2069,7 @@ function createExpect(test) {
     isExpectingAssertionsError: null,
     expectedAssertionsNumber: null,
     expectedAssertionsNumberErrorGen: null,
+    environment: workerState$1.config.environment,
     testPath: (_a = test == null ? void 0 : test.suite.file) == null ? void 0 : _a.filepath,
     currentTestName: test ? getFullName(test) : void 0
   }, expect);
@@ -1887,6 +2164,7 @@ If this is a long-running test, pass a timeout value as the last argument or con
 
 const fnMap = /* @__PURE__ */ new WeakMap();
 const hooksMap = /* @__PURE__ */ new WeakMap();
+const benchmarkMap = /* @__PURE__ */ new WeakMap();
 function setFn(key, fn) {
   fnMap.set(key, fn);
 }
@@ -1899,11 +2177,29 @@ function setHooks(key, hooks) {
 function getHooks(key) {
   return hooksMap.get(key);
 }
+async function getBenchmarkFactory(key) {
+  let benchmark = benchmarkMap.get(key);
+  if (!benchmark) {
+    if (!globalThis.EventTarget)
+      await import('./vendor-index.0557b03a.mjs').then(function (n) { return n.i; });
+    const Bench = (await import('tinybench')).default;
+    benchmark = new Bench({});
+    benchmarkMap.set(key, benchmark);
+  }
+  return benchmark;
+}
 
 const suite = createSuite();
-const test = createTest(function(name, fn, timeout) {
-  getCurrentSuite().test.fn.call(this, name, fn, timeout);
-});
+const test = createTest(
+  function(name, fn, options) {
+    getCurrentSuite().test.fn.call(this, name, fn, options);
+  }
+);
+const bench = createBenchmark(
+  function(name, fn, options) {
+    getCurrentSuite().benchmark.fn.call(this, name, fn, options);
+  }
+);
 function formatTitle(template, items, idx) {
   if (template.includes("%#")) {
     template = template.replace(/%%/g, "__vitest_escaped_%__").replace(/%#/g, `${idx}`).replace(/__vitest_escaped_%__/g, "%%");
@@ -1943,15 +2239,20 @@ function createSuiteCollector(name, factory = () => {
   const factoryQueue = [];
   let suite2;
   initSuite();
-  const test2 = createTest(function(name2, fn = noop, timeout) {
+  const test2 = createTest(function(name2, fn = noop, options) {
+    if (!isRunningInTest())
+      throw new Error("`test()` and `it()` is only available in test mode.");
     const mode2 = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
+    if (typeof options === "number")
+      options = { timeout: options };
     const test3 = {
       id: "",
       type: "test",
       name: name2,
       mode: mode2,
       suite: void 0,
-      fails: this.fails
+      fails: this.fails,
+      retry: options == null ? void 0 : options.retry
     };
     if (this.concurrent || concurrent)
       test3.concurrent = true;
@@ -1962,15 +2263,34 @@ function createSuiteCollector(name, factory = () => {
       value: context,
       enumerable: false
     });
-    setFn(test3, withTimeout(() => fn(context), timeout));
+    setFn(test3, withTimeout(
+      () => fn(context),
+      options == null ? void 0 : options.timeout
+    ));
     tasks.push(test3);
   });
+  const benchmark = createBenchmark(function(name2, fn = noop, options) {
+    const mode2 = this.skip ? "skip" : "run";
+    if (!isRunningInBenchmark())
+      throw new Error("`bench()` is only available in benchmark mode. Run with `vitest bench` instead.");
+    const benchmark2 = {
+      type: "benchmark",
+      id: "",
+      name: name2,
+      mode: mode2,
+      options,
+      suite: void 0
+    };
+    setFn(benchmark2, fn);
+    tasks.push(benchmark2);
+  });
   const collector = {
     type: "collector",
     name,
     mode,
     test: test2,
     tasks,
+    benchmark,
     collect,
     clear,
     on: addHook
@@ -2029,22 +2349,37 @@ function createSuite() {
   };
   suiteFn.skipIf = (condition) => condition ? suite.skip : suite;
   suiteFn.runIf = (condition) => condition ? suite : suite.skip;
-  return createChainable(["concurrent", "shuffle", "skip", "only", "todo"], suiteFn);
+  return createChainable(
+    ["concurrent", "shuffle", "skip", "only", "todo"],
+    suiteFn
+  );
 }
 function createTest(fn) {
   const testFn = fn;
   testFn.each = function(cases) {
     const test2 = this.withContext();
-    return (name, fn2, timeout) => {
+    return (name, fn2, options) => {
       cases.forEach((i, idx) => {
         const items = Array.isArray(i) ? i : [i];
-        test2(formatTitle(name, items, idx), () => fn2(...items), timeout);
+        test2(formatTitle(name, items, idx), () => fn2(...items), options);
       });
     };
   };
   testFn.skipIf = (condition) => condition ? test.skip : test;
   testFn.runIf = (condition) => condition ? test : test.skip;
-  return createChainable(["concurrent", "skip", "only", "todo", "fails"], testFn);
+  return createChainable(
+    ["concurrent", "skip", "only", "todo", "fails"],
+    testFn
+  );
+}
+function createBenchmark(fn) {
+  const benchmark = createChainable(
+    ["skip"],
+    fn
+  );
+  benchmark.skipIf = (condition) => condition ? benchmark.skip : benchmark;
+  benchmark.runIf = (condition) => condition ? benchmark : benchmark.skip;
+  return benchmark;
 }
 
-export { GLOBAL_EXPECT as G, getDefaultHookTimeout as a, globalExpect as b, createExpect as c, describe as d, clearCollectorContext as e, defaultSuite as f, getCurrentSuite as g, setHooks as h, it as i, getHooks as j, collectorContext as k, setState as l, getFn as m, getState as n, createSuiteHooks as o, chai$1 as p, suite as s, test as t, withTimeout as w };
+export { GLOBAL_EXPECT as G, getDefaultHookTimeout as a, bench as b, createExpect as c, describe as d, globalExpect as e, clearCollectorContext as f, getCurrentSuite as g, defaultSuite as h, it as i, setHooks as j, getHooks as k, collectorContext as l, getBenchmarkFactory as m, getFn as n, setState as o, getState as p, createSuiteHooks as q, chai$1 as r, suite as s, test as t, withTimeout as w };