vitest 0.0.85 → 0.0.90

package/dist/entry.js

@@ -5,12 +5,13 @@ import chai, { expect, util } from 'chai';
 import Subset from 'chai-subset';
 import path, { basename } from 'path';
 import { r as rpc, s as send } from './rpc-7de86f29.js';
-import { g as getNames, t as toArray, i as interpretOnlyMode, p as partitionSuiteChildren, c as hasTests, h as hasFailed } from './utils-9dcc4050.js';
+import { g as getNames, c as c$1, t as toArray, i as interpretOnlyMode, p as partitionSuiteChildren, d as hasTests, h as hasFailed } from './utils-385e2d09.js';
 import fs from 'fs';
-import { c as c$1, u as unifiedDiff } from './error-c651f5ae.js';
+import { u as unifiedDiff } from './error-309196c9.js';
 import { performance } from 'perf_hooks';
-import { b as setHooks, c as createSuiteHooks, e as clearContext, f as defaultSuite, h as context, j as getHooks, k as getFn } from './suite-0e21bf9b.js';
+import { b as setHooks, c as createSuiteHooks, e as clearContext, f as defaultSuite, h as context, j as getHooks, k as getFn } from './suite-b8c6cb53.js';
 import { n as nanoid } from './index-9e71c815.js';
+import 'module';
 import 'tty';
 import 'source-map';
 
@@ -713,12 +714,12 @@ function printObjectProperties(val, config, indentation, depth, refs, printer) {
   return result;
 }
 
-var AsymmetricMatcher$2 = {};
+var AsymmetricMatcher$3 = {};
 
-Object.defineProperty(AsymmetricMatcher$2, '__esModule', {
+Object.defineProperty(AsymmetricMatcher$3, '__esModule', {
   value: true
 });
-AsymmetricMatcher$2.default = AsymmetricMatcher$2.test = AsymmetricMatcher$2.serialize = void 0;
+AsymmetricMatcher$3.default = AsymmetricMatcher$3.test = AsymmetricMatcher$3.serialize = void 0;
 
 var _collections$3 = collections;
 
@@ -819,17 +820,17 @@ const serialize$7 = (val, config, indentation, depth, refs, printer) => {
   return val.toAsymmetricMatcher();
 };
 
-AsymmetricMatcher$2.serialize = serialize$7;
+AsymmetricMatcher$3.serialize = serialize$7;
 
 const test$6 = val => val && val.$$typeof === asymmetricMatcher;
 
-AsymmetricMatcher$2.test = test$6;
+AsymmetricMatcher$3.test = test$6;
 const plugin$6 = {
   serialize: serialize$7,
   test: test$6
 };
 var _default$7 = plugin$6;
-AsymmetricMatcher$2.default = _default$7;
+AsymmetricMatcher$3.default = _default$7;
 
 var ConvertAnsi = {};
 
@@ -2072,7 +2073,7 @@ var _ansiStyles = _interopRequireDefault(ansiStyles.exports);
 var _collections = collections;
 
 var _AsymmetricMatcher = _interopRequireDefault(
-  AsymmetricMatcher$2
+  AsymmetricMatcher$3
 );
 
 var _ConvertAnsi = _interopRequireDefault(ConvertAnsi);
@@ -2662,7 +2663,7 @@ const {
   Immutable: Immutable$1,
   ReactElement: ReactElement$1,
   ReactTestComponent: ReactTestComponent$1,
-  AsymmetricMatcher: AsymmetricMatcher$1
+  AsymmetricMatcher: AsymmetricMatcher$2
 } = plugins_1;
 let PLUGINS$1 = [
   ReactTestComponent$1,
@@ -2670,7 +2671,7 @@ let PLUGINS$1 = [
   DOMElement$1,
   DOMCollection$1,
   Immutable$1,
-  AsymmetricMatcher$1
+  AsymmetricMatcher$2
 ];
 const getSerializers = () => PLUGINS$1;
 
@@ -2761,7 +2762,7 @@ class SnapshotState {
     this._snapshotData = data;
     this._dirty = dirty;
     this._uncheckedKeys = new Set(Object.keys(this._snapshotData));
-    this._counters = new Map();
+    this._counters = /* @__PURE__ */ new Map();
     this._index = 0;
     this.expand = options.expand || false;
     this.added = 0;
@@ -2783,7 +2784,7 @@ class SnapshotState {
   }
   clear() {
     this._snapshotData = this._initialData;
-    this._counters = new Map();
+    this._counters = /* @__PURE__ */ new Map();
     this._index = 0;
     this.added = 0;
     this.matched = 0;
@@ -2975,20 +2976,18 @@ function getSnapshotClient() {
     _client = new SnapshotClient();
   return _client;
 }
-function SnapshotPlugin() {
-  return function(chai, utils) {
-    for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
-      utils.addMethod(chai.Assertion.prototype, key, function(message) {
-        const expected = utils.flag(this, "object");
-        getSnapshotClient().assert(expected, message);
-      });
-    }
-    utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", function(inlineSnapshot, message) {
+const SnapshotPlugin = (chai, utils) => {
+  for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
+    utils.addMethod(chai.Assertion.prototype, key, function(message) {
       const expected = utils.flag(this, "object");
-      getSnapshotClient().assert(expected, message, inlineSnapshot);
+      getSnapshotClient().assert(expected, message);
     });
-  };
-}
+  }
+  utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", function(inlineSnapshot, message) {
+    const expected = utils.flag(this, "object");
+    getSnapshotClient().assert(expected, message, inlineSnapshot);
+  });
+};
 
 const EXPECTED_COLOR = c$1.green;
 const RECEIVED_COLOR = c$1.red;
@@ -2996,7 +2995,7 @@ const INVERTED_COLOR = c$1.inverse;
 const BOLD_WEIGHT = c$1.bold;
 const DIM_COLOR = c$1.dim;
 const {
-  AsymmetricMatcher,
+  AsymmetricMatcher: AsymmetricMatcher$1,
   DOMCollection,
   DOMElement,
   Immutable,
@@ -3009,7 +3008,7 @@ const PLUGINS = [
   DOMElement,
   DOMCollection,
   Immutable,
-  AsymmetricMatcher
+  AsymmetricMatcher$1
 ];
 function matcherHint(matcherName, received = "received", expected = "expected", options = {}) {
   const {
@@ -3105,6 +3104,20 @@ function equals(a, b, customTesters, strictCheck) {
 function isAsymmetric(obj) {
   return !!obj && isA("Function", obj.asymmetricMatch);
 }
+function hasAsymmetric(obj, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(obj))
+    return false;
+  seen.add(obj);
+  if (isAsymmetric(obj))
+    return true;
+  if (Array.isArray(obj))
+    return obj.some((i) => hasAsymmetric(i, seen));
+  if (obj instanceof Set)
+    return Array.from(obj).some((i) => hasAsymmetric(i, seen));
+  if (isObject(obj))
+    return Object.values(obj).some((v) => hasAsymmetric(v, seen));
+  return false;
+}
 function asymmetricMatch(a, b) {
   const asymmetricA = isAsymmetric(a);
   const asymmetricB = isAsymmetric(b);
@@ -3295,7 +3308,7 @@ const hasPropertyInObject = (object, key) => {
 };
 const isObjectWithKeys = (a) => isObject(a) && !(a instanceof Error) && !(a instanceof Array) && !(a instanceof Date);
 const subsetEquality = (object, subset) => {
-  const subsetEqualityWithContext = (seenReferences = new WeakMap()) => (object2, subset2) => {
+  const subsetEqualityWithContext = (seenReferences = /* @__PURE__ */ new WeakMap()) => (object2, subset2) => {
     if (!isObjectWithKeys(subset2))
       return void 0;
     return Object.keys(subset2).every((key) => {
@@ -3376,198 +3389,258 @@ function JestExtendPlugin(expects) {
     });
   };
 }
-function JestExtend() {
-  return (chai2, utils) => {
-    utils.addMethod(chai2.expect, "extend", (expects) => {
-      chai2.use(JestExtendPlugin(expects));
-    });
-  };
-}
+const JestExtend = (chai2, utils) => {
+  utils.addMethod(chai2.expect, "extend", (expects) => {
+    chai2.use(JestExtendPlugin(expects));
+  });
+};
 
-function JestChaiExpect() {
-  return (chai, utils) => {
-    function def(name, fn) {
-      const addMethod = (n) => {
-        utils.addMethod(chai.Assertion.prototype, n, fn);
-      };
-      if (Array.isArray(name))
-        name.forEach((n) => addMethod(n));
-      else
-        addMethod(name);
-    }
-    def("toEqual", function(expected) {
-      return this.eql(expected);
-    });
-    def("toStrictEqual", function(expected) {
-      return this.equal(expected);
-    });
-    def("toBe", function(expected) {
-      return this.equal(expected);
-    });
-    def("toMatchObject", function(expected) {
-      return this.containSubset(expected);
-    });
-    def("toMatch", function(expected) {
-      if (typeof expected === "string")
-        return this.include(expected);
-      else
-        return this.match(expected);
-    });
-    def("toContain", function(item) {
-      return this.contain(item);
-    });
-    def("toContainEqual", function(expected) {
-      const obj = utils.flag(this, "object");
-      const index = Array.from(obj).findIndex((item) => {
-        try {
-          chai.assert.deepEqual(item, expected);
-        } catch {
-          return false;
-        }
-        return true;
-      });
-      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);
-    });
-    def("toBeFalsy", function() {
-      const obj = utils.flag(this, "object");
-      this.assert(!obj, "expected #{this} to be falsy", "expected #{this} to not be falsy", obj);
-    });
-    def("toBeGreaterThan", function(expected) {
-      return this.to.greaterThan(expected);
-    });
-    def("toBeGreaterThanOrEqual", function(expected) {
-      return this.to.greaterThanOrEqual(expected);
-    });
-    def("toBeLessThan", function(expected) {
-      return this.to.lessThan(expected);
-    });
-    def("toBeLessThanOrEqual", function(expected) {
-      return this.to.lessThanOrEqual(expected);
-    });
-    def("toBeNaN", function() {
-      return this.be.NaN;
-    });
-    def("toBeUndefined", function() {
-      return this.be.undefined;
-    });
-    def("toBeNull", function() {
-      return this.be.null;
-    });
-    def("toBeDefined", function() {
-      return this.not.be.undefined;
-    });
-    def("toBeInstanceOf", function(obj) {
-      return this.instanceOf(obj);
-    });
-    def("toHaveLength", function(length) {
-      return this.have.length(length);
-    });
-    def("toHaveProperty", function(...args) {
-      return this.have.deep.nested.property(...args);
-    });
-    def("toBeCloseTo", function(number, numDigits = 2) {
-      utils.expectTypes(this, ["number"]);
-      return this.closeTo(number, numDigits);
-    });
-    function isSpy(putativeSpy) {
-      return typeof putativeSpy === "function" && "__isSpy" in putativeSpy && putativeSpy.__isSpy;
-    }
-    const assertIsMock = (assertion) => {
-      if (!isSpy(assertion._obj))
-        throw new TypeError(`${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`);
+const JestChaiExpect = (chai, utils) => {
+  function def(name, fn) {
+    const addMethod = (n) => {
+      utils.addMethod(chai.Assertion.prototype, n, fn);
     };
-    const getSpy = (assertion) => {
-      assertIsMock(assertion);
-      return assertion._obj;
+    if (Array.isArray(name))
+      name.forEach((n) => addMethod(n));
+    else
+      addMethod(name);
+  }
+  const chaiEqual = chai.Assertion.prototype.equal;
+  def("chaiEqual", function(...args) {
+    return chaiEqual.apply(this, args);
+  });
+  utils.overwriteMethod(chai.Assertion.prototype, "equal", (_super) => {
+    return function(...args) {
+      const expected = args[0];
+      const actual = utils.flag(this, "object");
+      if (hasAsymmetric(expected)) {
+        this.assert(equals(actual, expected, void 0, true), "not match with #{this}", "should not match with #{this}", true);
+      } else {
+        _super.apply(this, args);
+      }
     };
-    def(["toHaveBeenCalledTimes", "toBeCalledTimes"], function(number) {
-      return this.assert(getSpy(this).callCount === number, "expected spy to be called #{exp} times", "expected spy to not be called #{exp} times", number);
-    });
-    def("toHaveBeenCalledOnce", function() {
-      return this.assert(getSpy(this).callCount === 1, "expected spy to be called once", "expected spy to not be called once", 1);
-    });
-    def(["toHaveBeenCalled", "toBeCalled"], function() {
-      return this.assert(getSpy(this).called, "expected spy to be called at least once", "expected spy to not be called at all", true);
-    });
-    def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
-      const spy = getSpy(this);
-      const pass = spy.calls.some((callArg) => equals(callArg, args));
-      return this.assert(pass, "expected spy to be called with arguments: #{exp}", "expected spy to not be called with arguments: #{exp}", args);
-    });
-    const ordinalOf = (i) => {
-      const j = i % 10;
-      const k = i % 100;
-      if (j === 1 && k !== 11)
-        return `${i}st`;
-      if (j === 2 && k !== 12)
-        return `${i}nd`;
-      if (j === 3 && k !== 13)
-        return `${i}rd`;
-      return `${i}th`;
+  });
+  utils.overwriteMethod(chai.Assertion.prototype, "eql", (_super) => {
+    return function(...args) {
+      const expected = args[0];
+      const actual = utils.flag(this, "object");
+      if (hasAsymmetric(expected)) {
+        this.assert(equals(actual, expected), "not match with #{this}", "should not match with #{this}", true);
+      } else {
+        _super.apply(this, args);
+      }
     };
-    def(["toHaveBeenNthCalledWith", "nthCalledWith"], function(times, ...args) {
-      const spy = getSpy(this);
-      const nthCall = spy.calls[times - 1];
-      this.assert(equals(nthCall, args), `expected ${ordinalOf(times)} spy call to have been called with #{exp}`, `expected ${ordinalOf(times)} spy call to not have been called with #{exp}`, args, nthCall);
-    });
-    def(["toHaveBeenLastCalledWith", "lastCalledWith"], function(...args) {
-      const spy = getSpy(this);
-      const lastCall = spy.calls.at(-1);
-      this.assert(equals(lastCall, args), "expected last spy call to have been called with #{exp}", "expected last spy call to not have been called with #{exp}", args, lastCall);
-    });
-    def(["toThrow", "toThrowError"], function(expected) {
-      const negate = utils.flag(this, "negate");
-      if (negate)
-        this.not.to.throw(expected);
-      else
-        this.to.throw(expected);
-    });
-    def(["toHaveReturned", "toReturn"], function() {
-      const spy = getSpy(this);
-      const calledAndNotThrew = spy.called && !spy.results.some(([type]) => type === "error");
-      this.assert(calledAndNotThrew, "expected spy to be successfully called at least once", "expected spy to not be successfully called", calledAndNotThrew, !calledAndNotThrew);
-    });
-    def(["toHaveReturnedTimes", "toReturnTimes"], function(times) {
-      const spy = getSpy(this);
-      const successfullReturns = spy.results.reduce((success, [type]) => type === "error" ? success : ++success, 0);
-      this.assert(successfullReturns === times, `expected spy to be successfully called ${times} times`, `expected spy to not be successfully called ${times} times`, `expected number of returns: ${times}`, `received number of returns: ${successfullReturns}`);
-    });
-    def(["toHaveReturnedWith", "toReturnWith"], function(value) {
-      const spy = getSpy(this);
-      const pass = spy.results.some(([type, result]) => type === "ok" && equals(value, result));
-      this.assert(pass, "expected spy to be successfully called with #{exp}", "expected spy to not be successfully called with #{exp}", value);
-    });
-    def(["toHaveLastReturnedWith", "lastReturnedWith"], function(value) {
-      const spy = getSpy(this);
-      const lastResult = spy.returns.at(-1);
-      const pass = equals(lastResult, value);
-      this.assert(pass, "expected last spy call to return #{exp}", "expected last spy call to not return #{exp}", value, lastResult);
-    });
-    def(["toHaveNthReturnedWith", "nthReturnedWith"], function(nthCall, value) {
-      const spy = getSpy(this);
-      const isNot = utils.flag(this, "negate");
-      const [callType, callResult] = spy.results[nthCall - 1];
-      const ordinalCall = `${ordinalOf(nthCall)} call`;
-      if (!isNot && callType === "error")
-        chai.assert.fail(`expected ${ordinalCall} to return #{exp}, but instead it threw an error`);
-      const nthCallReturn = equals(callResult, value);
-      this.assert(nthCallReturn, `expected ${ordinalCall} spy call to return #{exp}`, `expected ${ordinalCall} spy call to not return #{exp}`, value, callResult);
+  });
+  def("toEqual", function(expected) {
+    return this.eql(expected);
+  });
+  def("toStrictEqual", function(expected) {
+    return this.chaiEqual(expected);
+  });
+  def("toBe", function(expected) {
+    return this.chaiEqual(expected);
+  });
+  def("toMatchObject", function(expected) {
+    return this.containSubset(expected);
+  });
+  def("toMatch", function(expected) {
+    if (typeof expected === "string")
+      return this.include(expected);
+    else
+      return this.match(expected);
+  });
+  def("toContain", function(item) {
+    return this.contain(item);
+  });
+  def("toContainEqual", function(expected) {
+    const obj = utils.flag(this, "object");
+    const index = Array.from(obj).findIndex((item) => {
+      try {
+        chai.assert.deepEqual(item, expected);
+      } catch {
+        return false;
+      }
+      return true;
     });
+    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);
+  });
+  def("toBeFalsy", function() {
+    const obj = utils.flag(this, "object");
+    this.assert(!obj, "expected #{this} to be falsy", "expected #{this} to not be falsy", obj);
+  });
+  def("toBeGreaterThan", function(expected) {
+    return this.to.greaterThan(expected);
+  });
+  def("toBeGreaterThanOrEqual", function(expected) {
+    return this.to.greaterThanOrEqual(expected);
+  });
+  def("toBeLessThan", function(expected) {
+    return this.to.lessThan(expected);
+  });
+  def("toBeLessThanOrEqual", function(expected) {
+    return this.to.lessThanOrEqual(expected);
+  });
+  def("toBeNaN", function() {
+    return this.be.NaN;
+  });
+  def("toBeUndefined", function() {
+    return this.be.undefined;
+  });
+  def("toBeNull", function() {
+    return this.be.null;
+  });
+  def("toBeDefined", function() {
+    return this.not.be.undefined;
+  });
+  def("toBeInstanceOf", function(obj) {
+    return this.instanceOf(obj);
+  });
+  def("toHaveLength", function(length) {
+    return this.have.length(length);
+  });
+  def("toHaveProperty", function(...args) {
+    return this.have.deep.nested.property(...args);
+  });
+  def("toBeCloseTo", function(number, numDigits = 2) {
+    utils.expectTypes(this, ["number"]);
+    return this.closeTo(number, numDigits);
+  });
+  function isSpy(putativeSpy) {
+    return typeof putativeSpy === "function" && "__isSpy" in putativeSpy && putativeSpy.__isSpy;
+  }
+  const assertIsMock = (assertion) => {
+    if (!isSpy(assertion._obj))
+      throw new TypeError(`${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`);
+  };
+  const getSpy = (assertion) => {
+    assertIsMock(assertion);
+    return assertion._obj;
   };
+  def(["toHaveBeenCalledTimes", "toBeCalledTimes"], function(number) {
+    const spy = getSpy(this);
+    return this.assert(spy.callCount === number, "expected spy to be called #{exp} times", "expected spy to not be called #{exp} times", number, spy.callCount);
+  });
+  def("toHaveBeenCalledOnce", function() {
+    const spy = getSpy(this);
+    return this.assert(spy.callCount === 1, "expected spy to be called once", "expected spy to not be called once", 1, spy.callCount);
+  });
+  def(["toHaveBeenCalled", "toBeCalled"], function() {
+    const spy = getSpy(this);
+    return this.assert(spy.called, "expected spy to be called at least once", "expected spy to not be called at all", true, spy.called);
+  });
+  def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
+    const spy = getSpy(this);
+    const pass = spy.calls.some((callArg) => equals(callArg, args));
+    return this.assert(pass, "expected spy to be called with arguments: #{exp}", "expected spy to not be called with arguments: #{exp}", args);
+  });
+  const ordinalOf = (i) => {
+    const j = i % 10;
+    const k = i % 100;
+    if (j === 1 && k !== 11)
+      return `${i}st`;
+    if (j === 2 && k !== 12)
+      return `${i}nd`;
+    if (j === 3 && k !== 13)
+      return `${i}rd`;
+    return `${i}th`;
+  };
+  def(["toHaveBeenNthCalledWith", "nthCalledWith"], function(times, ...args) {
+    const spy = getSpy(this);
+    const nthCall = spy.calls[times - 1];
+    this.assert(equals(nthCall, args), `expected ${ordinalOf(times)} spy call to have been called with #{exp}`, `expected ${ordinalOf(times)} spy call to not have been called with #{exp}`, args, nthCall);
+  });
+  def(["toHaveBeenLastCalledWith", "lastCalledWith"], function(...args) {
+    const spy = getSpy(this);
+    const lastCall = spy.calls.at(-1);
+    this.assert(equals(lastCall, args), "expected last spy call to have been called with #{exp}", "expected last spy call to not have been called with #{exp}", args, lastCall);
+  });
+  def(["toThrow", "toThrowError"], function(expected) {
+    const negate = utils.flag(this, "negate");
+    if (negate)
+      this.not.to.throw(expected);
+    else
+      this.to.throw(expected);
+  });
+  def(["toHaveReturned", "toReturn"], function() {
+    const spy = getSpy(this);
+    const calledAndNotThrew = spy.called && !spy.results.some(([type]) => type === "error");
+    this.assert(calledAndNotThrew, "expected spy to be successfully called at least once", "expected spy to not be successfully called", calledAndNotThrew, !calledAndNotThrew);
+  });
+  def(["toHaveReturnedTimes", "toReturnTimes"], function(times) {
+    const spy = getSpy(this);
+    const successfullReturns = spy.results.reduce((success, [type]) => type === "error" ? success : ++success, 0);
+    this.assert(successfullReturns === times, `expected spy to be successfully called ${times} times`, `expected spy to not be successfully called ${times} times`, `expected number of returns: ${times}`, `received number of returns: ${successfullReturns}`);
+  });
+  def(["toHaveReturnedWith", "toReturnWith"], function(value) {
+    const spy = getSpy(this);
+    const pass = spy.results.some(([type, result]) => type === "ok" && equals(value, result));
+    this.assert(pass, "expected spy to be successfully called with #{exp}", "expected spy to not be successfully called with #{exp}", value);
+  });
+  def(["toHaveLastReturnedWith", "lastReturnedWith"], function(value) {
+    const spy = getSpy(this);
+    const lastResult = spy.returns.at(-1);
+    const pass = equals(lastResult, value);
+    this.assert(pass, "expected last spy call to return #{exp}", "expected last spy call to not return #{exp}", value, lastResult);
+  });
+  def(["toHaveNthReturnedWith", "nthReturnedWith"], function(nthCall, value) {
+    const spy = getSpy(this);
+    const isNot = utils.flag(this, "negate");
+    const [callType, callResult] = spy.results[nthCall - 1];
+    const ordinalCall = `${ordinalOf(nthCall)} call`;
+    if (!isNot && callType === "error")
+      chai.assert.fail(`expected ${ordinalCall} to return #{exp}, but instead it threw an error`);
+    const nthCallReturn = equals(callResult, value);
+    this.assert(nthCallReturn, `expected ${ordinalCall} spy call to return #{exp}`, `expected ${ordinalCall} spy call to not return #{exp}`, value, callResult);
+  });
+};
+
+class AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    this.sample = sample;
+    this.inverse = inverse;
+  }
+  getMatcherContext() {
+    return {
+      equals,
+      isNot: this.inverse,
+      utils: matcherUtils
+    };
+  }
 }
+class StringContaining extends AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    if (!isA("String", sample))
+      throw new Error("Expected is not a string");
+    super(sample, inverse);
+  }
+  asymmetricMatch(other) {
+    const result = isA("String", other) && other.includes(this.sample);
+    return this.inverse ? !result : result;
+  }
+  toString() {
+    return `String${this.inverse ? "Not" : ""}Containing`;
+  }
+  getExpectedType() {
+    return "string";
+  }
+}
+const JestAsymmetricMatchers = (chai, utils) => {
+  utils.addMethod(chai.expect, "stringContaining", (expected) => new StringContaining(expected));
+};
 
 let installed = false;
 async function setupChai() {
   if (installed)
     return;
-  chai.use(JestExtend());
-  chai.use(JestChaiExpect());
+  chai.use(JestExtend);
+  chai.use(JestChaiExpect);
   chai.use(Subset);
-  chai.use(SnapshotPlugin());
+  chai.use(SnapshotPlugin);
+  chai.use(JestAsymmetricMatchers);
   installed = true;
 }
 
@@ -3579,7 +3652,7 @@ async function setupGlobalEnv(config) {
   setupConsoleLogSpy();
   await setupChai();
   if (config.global)
-    (await import('./global-e172af93.js')).registerApiGlobally();
+    (await import('./global-f3eab75a.js')).registerApiGlobally();
 }
 function setupConsoleLogSpy() {
   const stdout = new Writable({
@@ -3707,7 +3780,11 @@ async function collectTests(paths, config) {
 }
 
 async function callSuiteHook(suite, name, args) {
+  if (name === "beforeEach" && suite.suite)
+    await callSuiteHook(suite.suite, name, args);
   await Promise.all(getHooks(suite)[name].map((fn) => fn(...args)));
+  if (name === "afterEach" && suite.suite)
+    await callSuiteHook(suite.suite, name, args);
 }
 function updateTask(task) {
   return rpc("onTaskUpdate", [task.id, task.result]);