vitest 0.0.89 → 0.0.93

package/dist/entry.js

@@ -1,3 +1,4 @@
+import fs, { promises } from 'fs';
 import { Console } from 'console';
 import { Writable } from 'stream';
 import { importModule } from 'local-pkg';
@@ -5,13 +6,11 @@ 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, 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 { u as unifiedDiff } from './error-309196c9.js';
+import { g as getNames, c as c$1, t as toArray, i as interpretOnlyMode, p as partitionSuiteChildren, f as hasTests, h as hasFailed } from './utils-576876dc.js';
+import { u as unifiedDiff } from './error-bf2213e4.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-b8c6cb53.js';
 import { n as nanoid } from './index-9e71c815.js';
-import 'module';
 import 'tty';
 import 'source-map';
 
@@ -714,12 +713,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;
 
@@ -820,17 +819,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 = {};
 
@@ -2073,7 +2072,7 @@ var _ansiStyles = _interopRequireDefault(ansiStyles.exports);
 var _collections = collections;
 
 var _AsymmetricMatcher = _interopRequireDefault(
-  AsymmetricMatcher$2
+  AsymmetricMatcher$3
 );
 
 var _ConvertAnsi = _interopRequireDefault(ConvertAnsi);
@@ -2663,7 +2662,7 @@ const {
   Immutable: Immutable$1,
   ReactElement: ReactElement$1,
   ReactTestComponent: ReactTestComponent$1,
-  AsymmetricMatcher: AsymmetricMatcher$1
+  AsymmetricMatcher: AsymmetricMatcher$2
 } = plugins_1;
 let PLUGINS$1 = [
   ReactTestComponent$1,
@@ -2671,7 +2670,7 @@ let PLUGINS$1 = [
   DOMElement$1,
   DOMCollection$1,
   Immutable$1,
-  AsymmetricMatcher$1
+  AsymmetricMatcher$2
 ];
 const getSerializers = () => PLUGINS$1;
 
@@ -2976,20 +2975,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;
@@ -2997,7 +2994,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,
@@ -3010,7 +3007,7 @@ const PLUGINS = [
   DOMElement,
   DOMCollection,
   Immutable,
-  AsymmetricMatcher
+  AsymmetricMatcher$1
 ];
 function matcherHint(matcherName, received = "received", expected = "expected", options = {}) {
   const {
@@ -3106,6 +3103,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);
@@ -3377,201 +3388,388 @@ 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) {
-      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`;
+  });
+  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, spy.calls);
+  });
+  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";
+  }
+}
+class Anything extends AsymmetricMatcher {
+  asymmetricMatch(other) {
+    return other != null;
+  }
+  toString() {
+    return "Anything";
+  }
+  toAsymmetricMatcher() {
+    return "Anything";
+  }
+}
+class ObjectContaining extends AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    super(sample, inverse);
+  }
+  getPrototype(obj) {
+    if (Object.getPrototypeOf)
+      return Object.getPrototypeOf(obj);
+    if (obj.constructor.prototype === obj)
+      return null;
+    return obj.constructor.prototype;
+  }
+  hasProperty(obj, property) {
+    if (!obj)
+      return false;
+    if (Object.prototype.hasOwnProperty.call(obj, property))
+      return true;
+    return this.hasProperty(this.getPrototype(obj), property);
+  }
+  asymmetricMatch(other) {
+    if (typeof this.sample !== "object") {
+      throw new TypeError(`You must provide an object to ${this.toString()}, not '${typeof this.sample}'.`);
+    }
+    let result = true;
+    for (const property in this.sample) {
+      if (!this.hasProperty(other, property) || !equals(this.sample[property], other[property])) {
+        result = false;
+        break;
+      }
+    }
+    return this.inverse ? !result : result;
+  }
+  toString() {
+    return `Object${this.inverse ? "Not" : ""}Containing`;
+  }
+  getExpectedType() {
+    return "object";
+  }
 }
+class ArrayContaining extends AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    super(sample, inverse);
+  }
+  asymmetricMatch(other) {
+    if (!Array.isArray(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)));
+    return this.inverse ? !result : result;
+  }
+  toString() {
+    return `Array${this.inverse ? "Not" : ""}Containing`;
+  }
+  getExpectedType() {
+    return "array";
+  }
+}
+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.");
+    }
+    super(sample);
+  }
+  fnNameFor(func) {
+    if (func.name)
+      return func.name;
+    const functionToString = Function.prototype.toString;
+    const matches = functionToString.call(func).match(/^(?:async)?\s*function\s*\*?\s*([\w$]+)\s*\(/);
+    return matches ? matches[1] : "<anonymous>";
+  }
+  asymmetricMatch(other) {
+    if (this.sample === String)
+      return typeof other == "string" || other instanceof String;
+    if (this.sample === Number)
+      return typeof other == "number" || other instanceof Number;
+    if (this.sample === Function)
+      return typeof other == "function" || other instanceof Function;
+    if (this.sample === Boolean)
+      return typeof other == "boolean" || other instanceof Boolean;
+    if (this.sample === BigInt)
+      return typeof other == "bigint" || other instanceof BigInt;
+    if (this.sample === Symbol)
+      return typeof other == "symbol" || other instanceof Symbol;
+    if (this.sample === Object)
+      return typeof other == "object";
+    return other instanceof this.sample;
+  }
+  toString() {
+    return "Any";
+  }
+  getExpectedType() {
+    if (this.sample === String)
+      return "string";
+    if (this.sample === Number)
+      return "number";
+    if (this.sample === Function)
+      return "function";
+    if (this.sample === Object)
+      return "object";
+    if (this.sample === Boolean)
+      return "boolean";
+    return this.fnNameFor(this.sample);
+  }
+  toAsymmetricMatcher() {
+    return `Any<${this.fnNameFor(this.sample)}>`;
+  }
+}
+const JestAsymmetricMatchers = (chai, utils) => {
+  utils.addMethod(chai.expect, "stringContaining", (expected) => new StringContaining(expected));
+  utils.addMethod(chai.expect, "anything", () => {
+    return new Anything();
+  });
+  utils.addMethod(chai.expect, "objectContaining", (expected) => {
+    return new ObjectContaining(expected);
+  });
+  utils.addMethod(chai.expect, "any", (expected) => {
+    return new Any(expected);
+  });
+  utils.addMethod(chai.expect, "arrayContaining", (expected) => {
+    return new ArrayContaining(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;
 }
 
@@ -3583,7 +3781,7 @@ async function setupGlobalEnv(config) {
   setupConsoleLogSpy();
   await setupChai();
   if (config.global)
-    (await import('./global-f3eab75a.js')).registerApiGlobally();
+    (await import('./global-c40aeb86.js')).registerApiGlobally();
 }
 function setupConsoleLogSpy() {
   const stdout = new Writable({
@@ -3699,14 +3897,6 @@ async function collectTests(paths, config) {
   }
   const tasks = files.reduce((tasks2, file) => tasks2.concat(file.tasks), []);
   interpretOnlyMode(tasks);
-  tasks.forEach((i) => {
-    if (i.type === "suite") {
-      if (i.mode === "skip")
-        i.tasks.forEach((c) => c.mode === "run" && (c.mode = "skip"));
-      else
-        interpretOnlyMode(i.tasks);
-    }
-  });
   return files;
 }
 
@@ -3809,10 +3999,17 @@ async function startTests(paths, config) {
 }
 
 async function run(files, config) {
+  var _a;
   await setupGlobalEnv(config);
-  await withEnv(config.environment, async () => {
-    await startTests(files, config);
-  });
+  for (const file of files) {
+    const code = await promises.readFile(file, "utf-8");
+    const env = ((_a = code.match(/@(?:vitest|jest)-environment\s+?([\w-]+)\b/)) == null ? void 0 : _a[1]) || config.environment || "node";
+    if (!["node", "jsdom", "happy-dom"].includes(env))
+      throw new Error(`Unsupported environment: ${env}`);
+    await withEnv(env, async () => {
+      await startTests([file], config);
+    });
+  }
 }
 
 export { run };