npm - vitest - Versions diffs - 0.0.69 → 0.0.73 - Mend

vitest 0.0.69 → 0.0.73

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/entry.js CHANGED Viewed

@@ -1,12 +1,18 @@
-import chai, { expect } from 'chai';
+import { Console } from 'console';
+import { Writable } from 'stream';
+import { importModule } from 'local-pkg';
+import chai, { expect, util } from 'chai';
 import SinonChai from 'sinon-chai';
 import Subset from 'chai-subset';
 import path, { basename } from 'path';
 import { g as getNames, i as interpretOnlyMode, p as partitionSuiteChildren, c as hasTests, h as hasFailed } from './utils-9dcc4050.js';
 import fs from 'fs';
+import { d as c$1, l as generateDiff } from './error-5a04e54b.js';
 import { performance } from 'perf_hooks';
 import { j as setHooks, c as createSuiteHooks, h as clearContext, d as defaultSuite, k as context, l as getHooks, m as getFn } from './suite-819c135e.js';
 import { n as nanoid } from './index-6427e0f2.js';
+import 'tty';
+import 'source-map';
 var node = {
   name: "node",
@@ -235,7 +241,7 @@ const KEYS = LIVING_KEYS.concat(OTHER_KEYS);
 var jsdom = {
   name: "jsdom",
   async setup(global) {
-    const { JSDOM } = await import('jsdom');
+    const { JSDOM } = await importModule("jsdom");
     const dom = new JSDOM("<!DOCTYPE html>", {
       pretendToBeVisual: true,
       runScripts: "dangerously",
@@ -255,7 +261,7 @@ var jsdom = {
 var happy = {
   name: "happy-dom",
   async setup(global) {
-    const { Window } = await import('happy-dom');
+    const { Window } = await importModule("happy-dom");
     const win = new Window();
     const keys = KEYS.concat(Object.getOwnPropertyNames(win)).filter((k) => !k.startsWith("_")).filter((k) => !(k in global));
     for (const key of keys)
@@ -701,12 +707,12 @@ function printObjectProperties(val, config, indentation, depth, refs, printer) {
   return result;
 }
-var AsymmetricMatcher$1 = {};
+var AsymmetricMatcher$2 = {};
-Object.defineProperty(AsymmetricMatcher$1, '__esModule', {
+Object.defineProperty(AsymmetricMatcher$2, '__esModule', {
   value: true
 });
-AsymmetricMatcher$1.default = AsymmetricMatcher$1.test = AsymmetricMatcher$1.serialize = void 0;
+AsymmetricMatcher$2.default = AsymmetricMatcher$2.test = AsymmetricMatcher$2.serialize = void 0;
 var _collections$3 = collections;
@@ -807,17 +813,17 @@ const serialize$7 = (val, config, indentation, depth, refs, printer) => {
   return val.toAsymmetricMatcher();
 };
-AsymmetricMatcher$1.serialize = serialize$7;
+AsymmetricMatcher$2.serialize = serialize$7;
 const test$6 = val => val && val.$$typeof === asymmetricMatcher;
-AsymmetricMatcher$1.test = test$6;
+AsymmetricMatcher$2.test = test$6;
 const plugin$6 = {
   serialize: serialize$7,
   test: test$6
 };
 var _default$7 = plugin$6;
-AsymmetricMatcher$1.default = _default$7;
+AsymmetricMatcher$2.default = _default$7;
 var ConvertAnsi = {};
@@ -925,12 +931,12 @@ const plugin$5 = {
 var _default$6 = plugin$5;
 ConvertAnsi.default = _default$6;
-var DOMCollection$1 = {};
+var DOMCollection$2 = {};
-Object.defineProperty(DOMCollection$1, '__esModule', {
+Object.defineProperty(DOMCollection$2, '__esModule', {
   value: true
 });
-DOMCollection$1.default = DOMCollection$1.serialize = DOMCollection$1.test = void 0;
+DOMCollection$2.default = DOMCollection$2.serialize = DOMCollection$2.test = void 0;
 var _collections$2 = collections;
@@ -955,7 +961,7 @@ const test$4 = val =>
   !!val.constructor.name &&
   testName(val.constructor.name);
-DOMCollection$1.test = test$4;
+DOMCollection$2.test = test$4;
 const isNamedNodeMap = collection =>
   collection.constructor.name === 'NamedNodeMap';
@@ -998,15 +1004,15 @@ const serialize$5 = (collection, config, indentation, depth, refs, printer) => {
   );
 };
-DOMCollection$1.serialize = serialize$5;
+DOMCollection$2.serialize = serialize$5;
 const plugin$4 = {
   serialize: serialize$5,
   test: test$4
 };
 var _default$5 = plugin$4;
-DOMCollection$1.default = _default$5;
+DOMCollection$2.default = _default$5;
-var DOMElement$1 = {};
+var DOMElement$2 = {};
 var markup = {};
@@ -1179,10 +1185,10 @@ const printElementAsLeaf = (type, config) => {
 markup.printElementAsLeaf = printElementAsLeaf;
-Object.defineProperty(DOMElement$1, '__esModule', {
+Object.defineProperty(DOMElement$2, '__esModule', {
   value: true
 });
-DOMElement$1.default = DOMElement$1.serialize = DOMElement$1.test = void 0;
+DOMElement$2.default = DOMElement$2.serialize = DOMElement$2.test = void 0;
 var _markup$2 = markup;
@@ -1234,7 +1240,7 @@ const test$3 = val => {
   );
 };
-DOMElement$1.test = test$3;
+DOMElement$2.test = test$3;
 function nodeIsText(node) {
   return node.nodeType === TEXT_NODE;
@@ -1298,20 +1304,20 @@ const serialize$4 = (node, config, indentation, depth, refs, printer) => {
   );
 };
-DOMElement$1.serialize = serialize$4;
+DOMElement$2.serialize = serialize$4;
 const plugin$3 = {
   serialize: serialize$4,
   test: test$3
 };
 var _default$4 = plugin$3;
-DOMElement$1.default = _default$4;
+DOMElement$2.default = _default$4;
-var Immutable$1 = {};
+var Immutable$2 = {};
-Object.defineProperty(Immutable$1, '__esModule', {
+Object.defineProperty(Immutable$2, '__esModule', {
   value: true
 });
-Immutable$1.default = Immutable$1.test = Immutable$1.serialize = void 0;
+Immutable$2.default = Immutable$2.test = Immutable$2.serialize = void 0;
 var _collections$1 = collections;
@@ -1324,13 +1330,13 @@ var _collections$1 = collections;
 // SENTINEL constants are from https://github.com/facebook/immutable-js
 const IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
 const IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';
-const IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
+const IS_KEYED_SENTINEL$1 = '@@__IMMUTABLE_KEYED__@@';
 const IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';
-const IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
+const IS_ORDERED_SENTINEL$1 = '@@__IMMUTABLE_ORDERED__@@';
 const IS_RECORD_SENTINEL = '@@__IMMUTABLE_RECORD__@@'; // immutable v4
 const IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';
-const IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
+const IS_SET_SENTINEL$1 = '@@__IMMUTABLE_SET__@@';
 const IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';
 const getImmutableName = name => 'Immutable.' + name;
@@ -1419,7 +1425,7 @@ const printImmutableSeq = (val, config, indentation, depth, refs, printer) => {
     return printAsLeaf(name);
   }
-  if (val[IS_KEYED_SENTINEL]) {
+  if (val[IS_KEYED_SENTINEL$1]) {
     return (
       name +
       SPACE +
@@ -1492,7 +1498,7 @@ const serialize$3 = (val, config, indentation, depth, refs, printer) => {
       depth,
       refs,
       printer,
-      val[IS_ORDERED_SENTINEL] ? 'OrderedMap' : 'Map'
+      val[IS_ORDERED_SENTINEL$1] ? 'OrderedMap' : 'Map'
     );
   }
@@ -1508,7 +1514,7 @@ const serialize$3 = (val, config, indentation, depth, refs, printer) => {
     );
   }
-  if (val[IS_SET_SENTINEL]) {
+  if (val[IS_SET_SENTINEL$1]) {
     return printImmutableValues(
       val,
       config,
@@ -1516,7 +1522,7 @@ const serialize$3 = (val, config, indentation, depth, refs, printer) => {
       depth,
       refs,
       printer,
-      val[IS_ORDERED_SENTINEL] ? 'OrderedSet' : 'Set'
+      val[IS_ORDERED_SENTINEL$1] ? 'OrderedSet' : 'Set'
     );
   }
@@ -1540,21 +1546,21 @@ const serialize$3 = (val, config, indentation, depth, refs, printer) => {
 }; // Explicitly comparing sentinel properties to true avoids false positive
 // when mock identity-obj-proxy returns the key as the value for any key.
-Immutable$1.serialize = serialize$3;
+Immutable$2.serialize = serialize$3;
 const test$2 = val =>
   val &&
   (val[IS_ITERABLE_SENTINEL] === true || val[IS_RECORD_SENTINEL] === true);
-Immutable$1.test = test$2;
+Immutable$2.test = test$2;
 const plugin$2 = {
   serialize: serialize$3,
   test: test$2
 };
 var _default$3 = plugin$2;
-Immutable$1.default = _default$3;
+Immutable$2.default = _default$3;
-var ReactElement$1 = {};
+var ReactElement$2 = {};
 var reactIs = {exports: {}};
@@ -1804,10 +1810,10 @@ if (process.env.NODE_ENV === 'production') {
   reactIs.exports = reactIs_development;
 }
-Object.defineProperty(ReactElement$1, '__esModule', {
+Object.defineProperty(ReactElement$2, '__esModule', {
   value: true
 });
-ReactElement$1.default = ReactElement$1.test = ReactElement$1.serialize = void 0;
+ReactElement$2.default = ReactElement$2.test = ReactElement$2.serialize = void 0;
 var ReactIs = _interopRequireWildcard(reactIs.exports);
@@ -1957,24 +1963,24 @@ const serialize$2 = (element, config, indentation, depth, refs, printer) =>
         indentation
       );
-ReactElement$1.serialize = serialize$2;
+ReactElement$2.serialize = serialize$2;
 const test$1 = val => val != null && ReactIs.isElement(val);
-ReactElement$1.test = test$1;
+ReactElement$2.test = test$1;
 const plugin$1 = {
   serialize: serialize$2,
   test: test$1
 };
 var _default$2 = plugin$1;
-ReactElement$1.default = _default$2;
+ReactElement$2.default = _default$2;
-var ReactTestComponent$1 = {};
+var ReactTestComponent$2 = {};
-Object.defineProperty(ReactTestComponent$1, '__esModule', {
+Object.defineProperty(ReactTestComponent$2, '__esModule', {
   value: true
 });
-ReactTestComponent$1.default = ReactTestComponent$1.test = ReactTestComponent$1.serialize = void 0;
+ReactTestComponent$2.default = ReactTestComponent$2.test = ReactTestComponent$2.serialize = void 0;
 var _markup = markup;
@@ -2037,17 +2043,17 @@ const serialize$1 = (object, config, indentation, depth, refs, printer) =>
         indentation
       );
-ReactTestComponent$1.serialize = serialize$1;
+ReactTestComponent$2.serialize = serialize$1;
 const test = val => val && val.$$typeof === testSymbol;
-ReactTestComponent$1.test = test;
+ReactTestComponent$2.test = test;
 const plugin = {
   serialize: serialize$1,
   test
 };
 var _default$1 = plugin;
-ReactTestComponent$1.default = _default$1;
+ReactTestComponent$2.default = _default$1;
 Object.defineProperty(build, '__esModule', {
   value: true
@@ -2060,21 +2066,21 @@ var _ansiStyles = _interopRequireDefault(ansiStyles.exports);
 var _collections = collections;
 var _AsymmetricMatcher = _interopRequireDefault(
-  AsymmetricMatcher$1
+  AsymmetricMatcher$2
 );
 var _ConvertAnsi = _interopRequireDefault(ConvertAnsi);
-var _DOMCollection = _interopRequireDefault(DOMCollection$1);
+var _DOMCollection = _interopRequireDefault(DOMCollection$2);
-var _DOMElement = _interopRequireDefault(DOMElement$1);
+var _DOMElement = _interopRequireDefault(DOMElement$2);
-var _Immutable = _interopRequireDefault(Immutable$1);
+var _Immutable = _interopRequireDefault(Immutable$2);
-var _ReactElement = _interopRequireDefault(ReactElement$1);
+var _ReactElement = _interopRequireDefault(ReactElement$2);
 var _ReactTestComponent = _interopRequireDefault(
-  ReactTestComponent$1
+  ReactTestComponent$2
 );
 function _interopRequireDefault(obj) {
@@ -2089,7 +2095,7 @@ function _interopRequireDefault(obj) {
  */
 /* eslint-disable local/ban-types-eventually */
-const toString = Object.prototype.toString;
+const toString$1 = Object.prototype.toString;
 const toISOString = Date.prototype.toISOString;
 const errorToString = Error.prototype.toString;
 const regExpToString = RegExp.prototype.toString;
@@ -2201,7 +2207,7 @@ function printBasicValue(val, printFunctionName, escapeRegex, escapeString) {
     return printSymbol(val);
   }
-  const toStringed = toString.call(val);
+  const toStringed = toString$1.call(val);
   if (toStringed === '[object WeakMap]') {
     return 'WeakMap {}';
@@ -2277,7 +2283,7 @@ function printComplexValue(
     return printer(val.toJSON(), config, indentation, depth, refs, true);
   }
-  const toStringed = toString.call(val);
+  const toStringed = toString$1.call(val);
   if (toStringed === '[object Arguments]') {
     return hitMaxDepth
@@ -2645,36 +2651,36 @@ var _default = format;
 build.default = _default;
 const {
-  DOMCollection,
-  DOMElement,
-  Immutable,
-  ReactElement,
-  ReactTestComponent,
-  AsymmetricMatcher
+  DOMCollection: DOMCollection$1,
+  DOMElement: DOMElement$1,
+  Immutable: Immutable$1,
+  ReactElement: ReactElement$1,
+  ReactTestComponent: ReactTestComponent$1,
+  AsymmetricMatcher: AsymmetricMatcher$1
 } = plugins_1;
-let PLUGINS = [
-  ReactTestComponent,
-  ReactElement,
-  DOMElement,
-  DOMCollection,
-  Immutable,
-  AsymmetricMatcher
+let PLUGINS$1 = [
+  ReactTestComponent$1,
+  ReactElement$1,
+  DOMElement$1,
+  DOMCollection$1,
+  Immutable$1,
+  AsymmetricMatcher$1
 ];
-const getSerializers = () => PLUGINS;
-var __defProp = Object.defineProperty;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
+const getSerializers = () => PLUGINS$1;
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
     }
   return a;
 };
@@ -2710,7 +2716,7 @@ 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, __spreadValues({
+  return normalizeNewlines(format_1(val, __spreadValues$1({
     escapeRegex,
     indent,
     plugins: getSerializers(),
@@ -2967,6 +2973,426 @@ function SnapshotPlugin() {
   };
 }
+const EXPECTED_COLOR = c$1.green;
+const RECEIVED_COLOR = c$1.red;
+const INVERTED_COLOR = c$1.inverse;
+const BOLD_WEIGHT = c$1.bold;
+const DIM_COLOR = c$1.dim;
+const {
+  AsymmetricMatcher,
+  DOMCollection,
+  DOMElement,
+  Immutable,
+  ReactElement,
+  ReactTestComponent
+} = plugins_1;
+const PLUGINS = [
+  ReactTestComponent,
+  ReactElement,
+  DOMElement,
+  DOMCollection,
+  Immutable,
+  AsymmetricMatcher
+];
+function matcherHint(matcherName, received = "received", expected = "expected", options = {}) {
+  const {
+    comment = "",
+    expectedColor = EXPECTED_COLOR,
+    isDirectExpectCall = false,
+    isNot = false,
+    promise = "",
+    receivedColor = RECEIVED_COLOR,
+    secondArgument = "",
+    secondArgumentColor = EXPECTED_COLOR
+  } = options;
+  let hint = "";
+  let dimString = "expect";
+  if (!isDirectExpectCall && received !== "") {
+    hint += DIM_COLOR(`${dimString}(`) + receivedColor(received);
+    dimString = ")";
+  }
+  if (promise !== "") {
+    hint += DIM_COLOR(`${dimString}.`) + promise;
+    dimString = "";
+  }
+  if (isNot) {
+    hint += `${DIM_COLOR(`${dimString}.`)}not`;
+    dimString = "";
+  }
+  if (matcherName.includes(".")) {
+    dimString += matcherName;
+  } else {
+    hint += DIM_COLOR(`${dimString}.`) + matcherName;
+    dimString = "";
+  }
+  if (expected === "") {
+    dimString += "()";
+  } else {
+    hint += DIM_COLOR(`${dimString}(`) + expectedColor(expected);
+    if (secondArgument)
+      hint += DIM_COLOR(", ") + secondArgumentColor(secondArgument);
+    dimString = ")";
+  }
+  if (comment !== "")
+    dimString += ` // ${comment}`;
+  if (dimString !== "")
+    hint += DIM_COLOR(dimString);
+  return hint;
+}
+const SPACE_SYMBOL = "\xB7";
+const replaceTrailingSpaces = (text) => text.replace(/\s+$/gm, (spaces) => SPACE_SYMBOL.repeat(spaces.length));
+const stringify = (object, maxDepth = 10) => {
+  const MAX_LENGTH = 1e4;
+  let result;
+  try {
+    result = format_1(object, {
+      maxDepth,
+      min: true,
+      plugins: PLUGINS
+    });
+  } catch {
+    result = format_1(object, {
+      callToJSON: false,
+      maxDepth,
+      min: true,
+      plugins: PLUGINS
+    });
+  }
+  return result.length >= MAX_LENGTH && maxDepth > 1 ? stringify(object, Math.floor(maxDepth / 2)) : result;
+};
+const printReceived = (object) => RECEIVED_COLOR(replaceTrailingSpaces(stringify(object)));
+const printExpected = (value) => EXPECTED_COLOR(replaceTrailingSpaces(stringify(value)));
+function diff(a, b, options) {
+  return generateDiff(stringify(a), stringify(b));
+}
+var matcherUtils = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  EXPECTED_COLOR: EXPECTED_COLOR,
+  RECEIVED_COLOR: RECEIVED_COLOR,
+  INVERTED_COLOR: INVERTED_COLOR,
+  BOLD_WEIGHT: BOLD_WEIGHT,
+  DIM_COLOR: DIM_COLOR,
+  matcherHint: matcherHint,
+  stringify: stringify,
+  printReceived: printReceived,
+  printExpected: printExpected,
+  diff: diff
+});
+// src/math.ts
+var isObject = (val) => toString.call(val) === "[object Object]";
+function equals(a, b, customTesters, strictCheck) {
+  customTesters = customTesters || [];
+  return eq(a, b, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
+}
+function isAsymmetric(obj) {
+  return !!obj && isA("Function", obj.asymmetricMatch);
+}
+function asymmetricMatch(a, b) {
+  var asymmetricA = isAsymmetric(a), asymmetricB = isAsymmetric(b);
+  if (asymmetricA && asymmetricB) {
+    return void 0;
+  }
+  if (asymmetricA) {
+    return a.asymmetricMatch(b);
+  }
+  if (asymmetricB) {
+    return b.asymmetricMatch(a);
+  }
+}
+function eq(a, b, aStack, bStack, customTesters, hasKey2) {
+  var result = true;
+  var asymmetricResult = asymmetricMatch(a, b);
+  if (asymmetricResult !== void 0) {
+    return asymmetricResult;
+  }
+  for (var i = 0; i < customTesters.length; i++) {
+    var customTesterResult = customTesters[i](a, b);
+    if (customTesterResult !== void 0) {
+      return customTesterResult;
+    }
+  }
+  if (a instanceof Error && b instanceof Error) {
+    return a.message == b.message;
+  }
+  if (Object.is(a, b)) {
+    return true;
+  }
+  if (a === null || b === null) {
+    return a === b;
+  }
+  var className = Object.prototype.toString.call(a);
+  if (className != Object.prototype.toString.call(b)) {
+    return false;
+  }
+  switch (className) {
+    case "[object Boolean]":
+    case "[object String]":
+    case "[object Number]":
+      if (typeof a !== typeof b) {
+        return false;
+      } else if (typeof a !== "object" && typeof b !== "object") {
+        return Object.is(a, b);
+      } else {
+        return Object.is(a.valueOf(), b.valueOf());
+      }
+    case "[object Date]":
+      return +a == +b;
+    case "[object RegExp]":
+      return a.source === b.source && a.flags === b.flags;
+  }
+  if (typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  if (isDomNode(a) && isDomNode(b)) {
+    return a.isEqualNode(b);
+  }
+  var length = aStack.length;
+  while (length--) {
+    if (aStack[length] === a) {
+      return bStack[length] === b;
+    } else if (bStack[length] === b) {
+      return false;
+    }
+  }
+  aStack.push(a);
+  bStack.push(b);
+  if (className == "[object Array]" && a.length !== b.length) {
+    return false;
+  }
+  var aKeys = keys(a, hasKey2), key;
+  var size = aKeys.length;
+  if (keys(b, hasKey2).length !== size) {
+    return false;
+  }
+  while (size--) {
+    key = aKeys[size];
+    result = hasKey2(b, key) && eq(a[key], b[key], aStack, bStack, customTesters, hasKey2);
+    if (!result) {
+      return false;
+    }
+  }
+  aStack.pop();
+  bStack.pop();
+  return result;
+}
+function keys(obj, hasKey2) {
+  var keys2 = [];
+  for (var key in obj) {
+    if (hasKey2(obj, key)) {
+      keys2.push(key);
+    }
+  }
+  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;
+}
+function hasKey(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function isA(typeName, value) {
+  return Object.prototype.toString.apply(value) === "[object " + typeName + "]";
+}
+function isDomNode(obj) {
+  return obj !== null && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string" && typeof obj.isEqualNode === "function";
+}
+const IS_KEYED_SENTINEL = "@@__IMMUTABLE_KEYED__@@";
+const IS_SET_SENTINEL = "@@__IMMUTABLE_SET__@@";
+const IS_ORDERED_SENTINEL = "@@__IMMUTABLE_ORDERED__@@";
+function isImmutableUnorderedKeyed(maybeKeyed) {
+  return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL] && !maybeKeyed[IS_ORDERED_SENTINEL]);
+}
+function isImmutableUnorderedSet(maybeSet) {
+  return !!(maybeSet && maybeSet[IS_SET_SENTINEL] && !maybeSet[IS_ORDERED_SENTINEL]);
+}
+const IteratorSymbol = Symbol.iterator;
+const hasIterator = (object) => !!(object != null && object[IteratorSymbol]);
+const iterableEquality = (a, b, aStack = [], bStack = []) => {
+  if (typeof a !== "object" || typeof b !== "object" || Array.isArray(a) || Array.isArray(b) || !hasIterator(a) || !hasIterator(b)) {
+    return void 0;
+  }
+  if (a.constructor !== b.constructor) {
+    return false;
+  }
+  let length = aStack.length;
+  while (length--) {
+    if (aStack[length] === a) {
+      return bStack[length] === b;
+    }
+  }
+  aStack.push(a);
+  bStack.push(b);
+  const iterableEqualityWithStack = (a2, b2) => iterableEquality(a2, b2, [...aStack], [...bStack]);
+  if (a.size !== void 0) {
+    if (a.size !== b.size) {
+      return false;
+    } else if (isA("Set", a) || isImmutableUnorderedSet(a)) {
+      let allFound = true;
+      for (const aValue of a) {
+        if (!b.has(aValue)) {
+          let has = false;
+          for (const bValue of b) {
+            const isEqual = equals(aValue, bValue, [iterableEqualityWithStack]);
+            if (isEqual === true) {
+              has = true;
+            }
+          }
+          if (has === false) {
+            allFound = false;
+            break;
+          }
+        }
+      }
+      aStack.pop();
+      bStack.pop();
+      return allFound;
+    } else if (isA("Map", a) || isImmutableUnorderedKeyed(a)) {
+      let allFound = true;
+      for (const aEntry of a) {
+        if (!b.has(aEntry[0]) || !equals(aEntry[1], b.get(aEntry[0]), [iterableEqualityWithStack])) {
+          let has = false;
+          for (const bEntry of b) {
+            const matchedKey = equals(aEntry[0], bEntry[0], [
+              iterableEqualityWithStack
+            ]);
+            let matchedValue = false;
+            if (matchedKey === true) {
+              matchedValue = equals(aEntry[1], bEntry[1], [
+                iterableEqualityWithStack
+              ]);
+            }
+            if (matchedValue === true) {
+              has = true;
+            }
+          }
+          if (has === false) {
+            allFound = false;
+            break;
+          }
+        }
+      }
+      aStack.pop();
+      bStack.pop();
+      return allFound;
+    }
+  }
+  const bIterator = b[IteratorSymbol]();
+  for (const aValue of a) {
+    const nextB = bIterator.next();
+    if (nextB.done || !equals(aValue, nextB.value, [iterableEqualityWithStack])) {
+      return false;
+    }
+  }
+  if (!bIterator.next().done) {
+    return false;
+  }
+  aStack.pop();
+  bStack.pop();
+  return true;
+};
+const hasPropertyInObject = (object, key) => {
+  const shouldTerminate = !object || typeof object !== "object" || object === Object.prototype;
+  if (shouldTerminate) {
+    return false;
+  }
+  return Object.prototype.hasOwnProperty.call(object, key) || hasPropertyInObject(Object.getPrototypeOf(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) => {
+    if (!isObjectWithKeys(subset2)) {
+      return void 0;
+    }
+    return Object.keys(subset2).every((key) => {
+      if (isObjectWithKeys(subset2[key])) {
+        if (seenReferences.has(subset2[key])) {
+          return equals(object2[key], subset2[key], [iterableEquality]);
+        }
+        seenReferences.set(subset2[key], true);
+      }
+      const result = object2 != null && hasPropertyInObject(object2, key) && equals(object2[key], subset2[key], [
+        iterableEquality,
+        subsetEqualityWithContext(seenReferences)
+      ]);
+      seenReferences.delete(subset2[key]);
+      return result;
+    });
+  };
+  return subsetEqualityWithContext()(object, subset);
+};
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const isAsyncFunction = (fn) => typeof fn === "function" && fn[Symbol.toStringTag] === "AsyncFunction";
+const getMatcherState = (assertion) => {
+  const actual = assertion._obj;
+  const isNot = util.flag(assertion, "negate");
+  const jestUtils = __spreadProps(__spreadValues({}, matcherUtils), {
+    iterableEquality,
+    subsetEquality
+  });
+  const matcherState = {
+    isNot,
+    utils: jestUtils,
+    assertionCalls: 0,
+    promise: "",
+    equals,
+    suppressedErrors: []
+  };
+  return {
+    state: matcherState,
+    isNot,
+    actual
+  };
+};
+function JestExtendPlugin(expects) {
+  return (c, utils) => {
+    Object.entries(expects).forEach(([expectAssertionName, expectAssertion]) => {
+      function expectSyncWrapper(...args) {
+        const { state, isNot, actual } = getMatcherState(this);
+        const { pass, message } = expectAssertion.call(state, actual, ...args);
+        if (pass && isNot || !pass && !isNot)
+          c.expect.fail(message());
+      }
+      async function expectAsyncWrapper(...args) {
+        const { state, isNot, actual } = getMatcherState(this);
+        const { pass, message } = await expectAssertion.call(state, actual, ...args);
+        if (pass && isNot || !pass && !isNot)
+          c.expect.fail(message());
+      }
+      const expectAssertionWrapper = isAsyncFunction(expectAssertion) ? expectAsyncWrapper : expectSyncWrapper;
+      utils.addMethod(chai.Assertion.prototype, expectAssertionName, expectAssertionWrapper);
+    });
+  };
+}
+function JestExtend() {
+  return (chai2, utils) => {
+    utils.addMethod(chai2.expect, "extend", (expects) => {
+      chai2.use(JestExtendPlugin(expects));
+    });
+  };
+}
 function JestChaiExpect() {
   return (chai, utils) => {
     function def(name, fn) {
@@ -3049,6 +3475,9 @@ function JestChaiExpect() {
     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);
@@ -3150,17 +3579,54 @@ async function setupChai() {
   if (installed)
     return;
   chai.use(SinonChai);
+  chai.use(JestExtend());
   chai.use(JestChaiExpect());
   chai.use(Subset);
   chai.use(SnapshotPlugin());
   installed = true;
 }
+let globalSetup = false;
 async function setupGlobalEnv(config) {
+  if (globalSetup)
+    return;
+  globalSetup = true;
+  setupConsoleLogSpy();
   await setupChai();
   if (config.global)
     (await import('./global-e40b54d6.js')).registerApiGlobally();
 }
+function setupConsoleLogSpy() {
+  const stdout = new Writable({
+    write(data, encoding, callback) {
+      var _a;
+      send("log", {
+        type: "stdout",
+        content: String(data),
+        taskId: (_a = process.__vitest_worker__.current) == null ? void 0 : _a.id
+      });
+      callback();
+    }
+  });
+  const stderr = new Writable({
+    write(data, encoding, callback) {
+      var _a;
+      send("log", {
+        type: "stderr",
+        content: String(data),
+        taskId: (_a = process.__vitest_worker__.current) == null ? void 0 : _a.id
+      });
+      callback();
+    }
+  });
+  const newConsole = new Console({
+    stdout,
+    stderr,
+    colorMode: true,
+    groupIndentation: 2
+  });
+  globalThis.console = newConsole;
+}
 async function withEnv(name, fn) {
   const env = await environments[name].setup(globalThis);
   try {
@@ -3243,6 +3709,7 @@ async function runTest(test) {
   };
   updateTask(test);
   getSnapshotClient().setTest(test);
+  process.__vitest_worker__.current = test;
   try {
     await callHook(test.suite, "beforeEach", [test, test.suite]);
     await getFn(test)();
@@ -3259,6 +3726,7 @@ async function runTest(test) {
   }
   getSnapshotClient().clearTest();
   test.result.end = performance.now();
+  process.__vitest_worker__.current = void 0;
   updateTask(test);
 }
 async function runSuite(suite) {