vitest 0.0.70 → 0.0.71

package/dist/entry.js

@@ -1,13 +1,16 @@
 import { importModule } from 'local-pkg';
-import chai, { expect } from 'chai';
+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-fb6ff2e6.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",
@@ -702,12 +705,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;
 
@@ -808,17 +811,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 = {};
 
@@ -926,12 +929,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;
 
@@ -956,7 +959,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';
@@ -999,15 +1002,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 = {};
 
@@ -1180,10 +1183,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;
 
@@ -1235,7 +1238,7 @@ const test$3 = val => {
   );
 };
 
-DOMElement$1.test = test$3;
+DOMElement$2.test = test$3;
 
 function nodeIsText(node) {
   return node.nodeType === TEXT_NODE;
@@ -1299,20 +1302,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;
 
@@ -1325,13 +1328,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;
@@ -1420,7 +1423,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 +
@@ -1493,7 +1496,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'
     );
   }
 
@@ -1509,7 +1512,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,
@@ -1517,7 +1520,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'
     );
   }
 
@@ -1541,21 +1544,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: {}};
 
@@ -1805,10 +1808,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);
 
@@ -1958,24 +1961,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;
 
@@ -2038,17 +2041,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
@@ -2061,21 +2064,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) {
@@ -2090,7 +2093,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;
@@ -2202,7 +2205,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 {}';
@@ -2278,7 +2281,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
@@ -2646,36 +2649,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;
 };
@@ -2711,7 +2714,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(),
@@ -2968,6 +2971,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) {
@@ -3151,6 +3574,7 @@ async function setupChai() {
   if (installed)
     return;
   chai.use(SinonChai);
+  chai.use(JestExtend());
   chai.use(JestChaiExpect());
   chai.use(Subset);
   chai.use(SnapshotPlugin());