@vitest/expect 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/index.js

@@ -8,7 +8,9 @@ import { use, util } from 'chai';
 const MATCHERS_OBJECT = Symbol.for("matchers-object");
 const JEST_MATCHERS_OBJECT = Symbol.for("$$jest-matchers-object");
 const GLOBAL_EXPECT = Symbol.for("expect-global");
-const ASYMMETRIC_MATCHERS_OBJECT = Symbol.for("asymmetric-matchers-object");
+const ASYMMETRIC_MATCHERS_OBJECT = Symbol.for(
+  "asymmetric-matchers-object"
+);
 
 if (!Object.prototype.hasOwnProperty.call(globalThis, MATCHERS_OBJECT)) {
   const globalState = /* @__PURE__ */ new WeakMap();
@@ -83,14 +85,17 @@ function getMatcherUtils() {
       dimString += "()";
     } else {
       hint += DIM_COLOR(`${dimString}(`) + expectedColor(expected);
-      if (secondArgument)
+      if (secondArgument) {
         hint += DIM_COLOR(", ") + secondArgumentColor(secondArgument);
+      }
       dimString = ")";
     }
-    if (comment !== "")
+    if (comment !== "") {
       dimString += ` // ${comment}`;
-    if (dimString !== "")
+    }
+    if (dimString !== "") {
       hint += DIM_COLOR(dimString);
+    }
     return hint;
   }
   const SPACE_SYMBOL = "\xB7";
@@ -133,51 +138,71 @@ function isAsymmetric(obj) {
   return !!obj && typeof obj === "object" && "asymmetricMatch" in obj && isA("Function", obj.asymmetricMatch);
 }
 function hasAsymmetric(obj, seen = /* @__PURE__ */ new Set()) {
-  if (seen.has(obj))
+  if (seen.has(obj)) {
     return false;
+  }
   seen.add(obj);
-  if (isAsymmetric(obj))
+  if (isAsymmetric(obj)) {
     return true;
-  if (Array.isArray(obj))
+  }
+  if (Array.isArray(obj)) {
     return obj.some((i) => hasAsymmetric(i, seen));
-  if (obj instanceof Set)
+  }
+  if (obj instanceof Set) {
     return Array.from(obj).some((i) => hasAsymmetric(i, seen));
-  if (isObject(obj))
+  }
+  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);
-  if (asymmetricA && asymmetricB)
+  if (asymmetricA && asymmetricB) {
     return void 0;
-  if (asymmetricA)
+  }
+  if (asymmetricA) {
     return a.asymmetricMatch(b);
-  if (asymmetricB)
+  }
+  if (asymmetricB) {
     return b.asymmetricMatch(a);
+  }
 }
 function eq(a, b, aStack, bStack, customTesters, hasKey2) {
   let result = true;
   const asymmetricResult = asymmetricMatch(a, b);
-  if (asymmetricResult !== void 0)
+  if (asymmetricResult !== void 0) {
     return asymmetricResult;
+  }
   const testerContext = { equals };
   for (let i = 0; i < customTesters.length; i++) {
-    const customTesterResult = customTesters[i].call(testerContext, a, b, customTesters);
-    if (customTesterResult !== void 0)
+    const customTesterResult = customTesters[i].call(
+      testerContext,
+      a,
+      b,
+      customTesters
+    );
+    if (customTesterResult !== void 0) {
       return customTesterResult;
+    }
   }
-  if (a instanceof Error && b instanceof Error)
+  if (a instanceof Error && b instanceof Error) {
     return a.message === b.message;
-  if (typeof URL === "function" && a instanceof URL && b instanceof URL)
+  }
+  if (typeof URL === "function" && a instanceof URL && b instanceof URL) {
     return a.href === b.href;
-  if (Object.is(a, b))
+  }
+  if (Object.is(a, b)) {
     return true;
-  if (a === null || b === null)
+  }
+  if (a === null || b === null) {
     return a === b;
+  }
   const className = Object.prototype.toString.call(a);
-  if (className !== Object.prototype.toString.call(b))
+  if (className !== Object.prototype.toString.call(b)) {
     return false;
+  }
   switch (className) {
     case "[object Boolean]":
     case "[object String]":
@@ -197,31 +222,37 @@ function eq(a, b, aStack, bStack, customTesters, hasKey2) {
     case "[object RegExp]":
       return a.source === b.source && a.flags === b.flags;
   }
-  if (typeof a !== "object" || typeof b !== "object")
+  if (typeof a !== "object" || typeof b !== "object") {
     return false;
-  if (isDomNode(a) && isDomNode(b))
+  }
+  if (isDomNode(a) && isDomNode(b)) {
     return a.isEqualNode(b);
+  }
   let length = aStack.length;
   while (length--) {
-    if (aStack[length] === a)
+    if (aStack[length] === a) {
       return bStack[length] === b;
-    else if (bStack[length] === b)
+    } else if (bStack[length] === b) {
       return false;
+    }
   }
   aStack.push(a);
   bStack.push(b);
-  if (className === "[object Array]" && a.length !== b.length)
+  if (className === "[object Array]" && a.length !== b.length) {
     return false;
+  }
   const aKeys = keys(a, hasKey2);
   let key;
   let size = aKeys.length;
-  if (keys(b, hasKey2).length !== size)
+  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)
+    if (!result) {
       return false;
+    }
   }
   aStack.pop();
   bStack.pop();
@@ -230,8 +261,9 @@ function eq(a, b, aStack, bStack, customTesters, hasKey2) {
 function keys(obj, hasKey2) {
   const keys2 = [];
   for (const key in obj) {
-    if (hasKey2(obj, key))
+    if (hasKey2(obj, key)) {
       keys2.push(key);
+    }
   }
   return keys2.concat(
     Object.getOwnPropertySymbols(obj).filter(
@@ -252,23 +284,28 @@ function isDomNode(obj) {
   return obj !== null && typeof obj === "object" && "nodeType" in obj && typeof obj.nodeType === "number" && "nodeName" in obj && typeof obj.nodeName === "string" && "isEqualNode" in obj && typeof obj.isEqualNode === "function";
 }
 function fnNameFor(func) {
-  if (func.name)
+  if (func.name) {
     return func.name;
-  const matches = functionToString.call(func).match(/^(?:async)?\s*function\s*\*?\s*([\w$]+)\s*\(/);
+  }
+  const matches = functionToString.call(func).match(/^(?:async)?\s*function\s*(?:\*\s*)?([\w$]+)\s*\(/);
   return matches ? matches[1] : "<anonymous>";
 }
 function getPrototype(obj) {
-  if (Object.getPrototypeOf)
+  if (Object.getPrototypeOf) {
     return Object.getPrototypeOf(obj);
-  if (obj.constructor.prototype === obj)
+  }
+  if (obj.constructor.prototype === obj) {
     return null;
+  }
   return obj.constructor.prototype;
 }
 function hasProperty(obj, property) {
-  if (!obj)
+  if (!obj) {
     return false;
-  if (Object.prototype.hasOwnProperty.call(obj, property))
+  }
+  if (Object.prototype.hasOwnProperty.call(obj, property)) {
     return true;
+  }
   return hasProperty(getPrototype(obj), property);
 }
 const IS_KEYED_SENTINEL = "@@__IMMUTABLE_KEYED__@@";
@@ -306,14 +343,17 @@ function hasIterator(object) {
   return !!(object != null && object[IteratorSymbol]);
 }
 function iterableEquality(a, b, customTesters = [], aStack = [], bStack = []) {
-  if (typeof a !== "object" || typeof b !== "object" || Array.isArray(a) || Array.isArray(b) || !hasIterator(a) || !hasIterator(b))
+  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)
+  }
+  if (a.constructor !== b.constructor) {
     return false;
+  }
   let length = aStack.length;
   while (length--) {
-    if (aStack[length] === a)
+    if (aStack[length] === a) {
       return bStack[length] === b;
+    }
   }
   aStack.push(a);
   bStack.push(b);
@@ -322,13 +362,7 @@ function iterableEquality(a, b, customTesters = [], aStack = [], bStack = []) {
     iterableEqualityWithStack
   ];
   function iterableEqualityWithStack(a2, b2) {
-    return iterableEquality(
-      a2,
-      b2,
-      [...customTesters],
-      [...aStack],
-      [...bStack]
-    );
+    return iterableEquality(a2, b2, [...customTesters], [...aStack], [...bStack]);
   }
   if (a.size !== void 0) {
     if (a.size !== b.size) {
@@ -340,8 +374,9 @@ function iterableEquality(a, b, customTesters = [], aStack = [], bStack = []) {
           let has = false;
           for (const bValue of b) {
             const isEqual = equals(aValue, bValue, filteredCustomTesters);
-            if (isEqual === true)
+            if (isEqual === true) {
               has = true;
+            }
           }
           if (has === false) {
             allFound = false;
@@ -358,12 +393,22 @@ function iterableEquality(a, b, customTesters = [], aStack = [], bStack = []) {
         if (!b.has(aEntry[0]) || !equals(aEntry[1], b.get(aEntry[0]), filteredCustomTesters)) {
           let has = false;
           for (const bEntry of b) {
-            const matchedKey = equals(aEntry[0], bEntry[0], filteredCustomTesters);
+            const matchedKey = equals(
+              aEntry[0],
+              bEntry[0],
+              filteredCustomTesters
+            );
             let matchedValue = false;
-            if (matchedKey === true)
-              matchedValue = equals(aEntry[1], bEntry[1], filteredCustomTesters);
-            if (matchedValue === true)
+            if (matchedKey === true) {
+              matchedValue = equals(
+                aEntry[1],
+                bEntry[1],
+                filteredCustomTesters
+              );
+            }
+            if (matchedValue === true) {
               has = true;
+            }
           }
           if (has === false) {
             allFound = false;
@@ -379,16 +424,19 @@ function iterableEquality(a, b, customTesters = [], aStack = [], bStack = []) {
   const bIterator = b[IteratorSymbol]();
   for (const aValue of a) {
     const nextB = bIterator.next();
-    if (nextB.done || !equals(aValue, nextB.value, filteredCustomTesters))
+    if (nextB.done || !equals(aValue, nextB.value, filteredCustomTesters)) {
       return false;
+    }
   }
-  if (!bIterator.next().done)
+  if (!bIterator.next().done) {
     return false;
+  }
   if (!isImmutableList(a) && !isImmutableOrderedKeyed(a) && !isImmutableOrderedSet(a) && !isImmutableRecord(a)) {
     const aEntries = Object.entries(a);
     const bEntries = Object.entries(b);
-    if (!equals(aEntries, bEntries))
+    if (!equals(aEntries, bEntries)) {
       return false;
+    }
   }
   aStack.pop();
   bStack.pop();
@@ -396,22 +444,27 @@ function iterableEquality(a, b, customTesters = [], aStack = [], bStack = []) {
 }
 function hasPropertyInObject(object, key) {
   const shouldTerminate = !object || typeof object !== "object" || object === Object.prototype;
-  if (shouldTerminate)
+  if (shouldTerminate) {
     return false;
+  }
   return Object.prototype.hasOwnProperty.call(object, key) || hasPropertyInObject(Object.getPrototypeOf(object), key);
 }
 function isObjectWithKeys(a) {
   return isObject(a) && !(a instanceof Error) && !Array.isArray(a) && !(a instanceof Date);
 }
 function subsetEquality(object, subset, customTesters = []) {
-  const filteredCustomTesters = customTesters.filter((t) => t !== subsetEquality);
+  const filteredCustomTesters = customTesters.filter(
+    (t) => t !== subsetEquality
+  );
   const subsetEqualityWithContext = (seenReferences = /* @__PURE__ */ new WeakMap()) => (object2, subset2) => {
-    if (!isObjectWithKeys(subset2))
+    if (!isObjectWithKeys(subset2)) {
       return void 0;
+    }
     return Object.keys(subset2).every((key) => {
       if (subset2[key] != null && typeof subset2[key] === "object") {
-        if (seenReferences.has(subset2[key]))
+        if (seenReferences.has(subset2[key])) {
           return equals(object2[key], subset2[key], filteredCustomTesters);
+        }
         seenReferences.set(subset2[key], true);
       }
       const result = object2 != null && hasPropertyInObject(object2, key) && equals(object2[key], subset2[key], [
@@ -425,16 +478,18 @@ function subsetEquality(object, subset, customTesters = []) {
   return subsetEqualityWithContext()(object, subset);
 }
 function typeEquality(a, b) {
-  if (a == null || b == null || a.constructor === b.constructor)
+  if (a == null || b == null || a.constructor === b.constructor) {
     return void 0;
+  }
   return false;
 }
 function arrayBufferEquality(a, b) {
   let dataViewA = a;
   let dataViewB = b;
   if (!(a instanceof DataView && b instanceof DataView)) {
-    if (!(a instanceof ArrayBuffer) || !(b instanceof ArrayBuffer))
+    if (!(a instanceof ArrayBuffer) || !(b instanceof ArrayBuffer)) {
       return void 0;
+    }
     try {
       dataViewA = new DataView(a);
       dataViewB = new DataView(b);
@@ -442,25 +497,30 @@ function arrayBufferEquality(a, b) {
       return void 0;
     }
   }
-  if (dataViewA.byteLength !== dataViewB.byteLength)
+  if (dataViewA.byteLength !== dataViewB.byteLength) {
     return false;
+  }
   for (let i = 0; i < dataViewA.byteLength; i++) {
-    if (dataViewA.getUint8(i) !== dataViewB.getUint8(i))
+    if (dataViewA.getUint8(i) !== dataViewB.getUint8(i)) {
       return false;
+    }
   }
   return true;
 }
 function sparseArrayEquality(a, b, customTesters = []) {
-  if (!Array.isArray(a) || !Array.isArray(b))
+  if (!Array.isArray(a) || !Array.isArray(b)) {
     return void 0;
+  }
   const aKeys = Object.keys(a);
   const bKeys = Object.keys(b);
-  const filteredCustomTesters = customTesters.filter((t) => t !== sparseArrayEquality);
+  const filteredCustomTesters = customTesters.filter(
+    (t) => t !== sparseArrayEquality
+  );
   return equals(a, b, filteredCustomTesters, true) && equals(aKeys, bKeys);
 }
 function generateToBeMessage(deepEqualityName, expected = "#{this}", actual = "#{exp}") {
   const toBeMessage = `expected ${expected} to be ${actual} // Object.is equality`;
-  if (["toStrictEqual", "toEqual"].includes(deepEqualityName))
+  if (["toStrictEqual", "toEqual"].includes(deepEqualityName)) {
     return `${toBeMessage}
 
 If it should pass with deep equality, replace "toBe" with "${deepEqualityName}"
@@ -468,6 +528,7 @@ If it should pass with deep equality, replace "toBe" with "${deepEqualityName}"
 Expected: ${expected}
 Received: serializes to the same string
 `;
+  }
   return toBeMessage;
 }
 function pluralize(word, count) {
@@ -507,18 +568,26 @@ function getObjectSubset(object, subset, customTesters = []) {
       seenReferences.set(object2, trimmed);
       for (const key of getObjectKeys(object2)) {
         if (hasPropertyInObject(subset2, key)) {
-          trimmed[key] = seenReferences.has(object2[key]) ? seenReferences.get(object2[key]) : getObjectSubsetWithContext(seenReferences)(object2[key], subset2[key]);
+          trimmed[key] = seenReferences.has(object2[key]) ? seenReferences.get(object2[key]) : getObjectSubsetWithContext(seenReferences)(
+            object2[key],
+            subset2[key]
+          );
         } else {
           if (!seenReferences.has(object2[key])) {
             stripped += 1;
-            if (isObject(object2[key]))
+            if (isObject(object2[key])) {
               stripped += getObjectKeys(object2[key]).length;
-            getObjectSubsetWithContext(seenReferences)(object2[key], subset2[key]);
+            }
+            getObjectSubsetWithContext(seenReferences)(
+              object2[key],
+              subset2[key]
+            );
           }
         }
       }
-      if (getObjectKeys(trimmed).length > 0)
+      if (getObjectKeys(trimmed).length > 0) {
         return trimmed;
+      }
     }
     return object2;
   };
@@ -551,15 +620,17 @@ class AsymmetricMatcher {
   // https://github.com/chaijs/loupe/blob/9b8a6deabcd50adc056a64fb705896194710c5c6/src/index.ts#L29
   [Symbol.for("chai/inspect")](options) {
     const result = stringify(this, options.depth, { min: true });
-    if (result.length <= options.truncate)
+    if (result.length <= options.truncate) {
       return result;
+    }
     return `${this.toString()}{\u2026}`;
   }
 }
 class StringContaining extends AsymmetricMatcher {
   constructor(sample, inverse = false) {
-    if (!isA("String", sample))
+    if (!isA("String", sample)) {
       throw new Error("Expected is not a string");
+    }
     super(sample, inverse);
   }
   asymmetricMatch(other) {
@@ -589,17 +660,21 @@ class ObjectContaining extends AsymmetricMatcher {
     super(sample, inverse);
   }
   getPrototype(obj) {
-    if (Object.getPrototypeOf)
+    if (Object.getPrototypeOf) {
       return Object.getPrototypeOf(obj);
-    if (obj.constructor.prototype === obj)
+    }
+    if (obj.constructor.prototype === obj) {
       return null;
+    }
     return obj.constructor.prototype;
   }
   hasProperty(obj, property) {
-    if (!obj)
+    if (!obj) {
       return false;
-    if (Object.prototype.hasOwnProperty.call(obj, property))
+    }
+    if (Object.prototype.hasOwnProperty.call(obj, property)) {
       return true;
+    }
     return this.hasProperty(this.getPrototype(obj), property);
   }
   asymmetricMatch(other) {
@@ -611,7 +686,11 @@ class ObjectContaining extends AsymmetricMatcher {
     let result = true;
     const matcherContext = this.getMatcherContext();
     for (const property in this.sample) {
-      if (!this.hasProperty(other, property) || !equals(this.sample[property], other[property], matcherContext.customTesters)) {
+      if (!this.hasProperty(other, property) || !equals(
+        this.sample[property],
+        other[property],
+        matcherContext.customTesters
+      )) {
         result = false;
         break;
       }
@@ -637,7 +716,9 @@ class ArrayContaining extends AsymmetricMatcher {
     }
     const matcherContext = this.getMatcherContext();
     const result = this.sample.length === 0 || Array.isArray(other) && this.sample.every(
-      (item) => other.some((another) => equals(item, another, matcherContext.customTesters))
+      (item) => other.some(
+        (another) => equals(item, another, matcherContext.customTesters)
+      )
     );
     return this.inverse ? !result : result;
   }
@@ -658,43 +739,56 @@ class Any extends AsymmetricMatcher {
     super(sample);
   }
   fnNameFor(func) {
-    if (func.name)
+    if (func.name) {
       return func.name;
+    }
     const functionToString = Function.prototype.toString;
-    const matches = functionToString.call(func).match(/^(?:async)?\s*function\s*\*?\s*([\w$]+)\s*\(/);
+    const matches = functionToString.call(func).match(/^(?:async)?\s*function\s*(?:\*\s*)?([\w$]+)\s*\(/);
     return matches ? matches[1] : "<anonymous>";
   }
   asymmetricMatch(other) {
-    if (this.sample === String)
+    if (this.sample === String) {
       return typeof other == "string" || other instanceof String;
-    if (this.sample === Number)
+    }
+    if (this.sample === Number) {
       return typeof other == "number" || other instanceof Number;
-    if (this.sample === Function)
+    }
+    if (this.sample === Function) {
       return typeof other == "function" || other instanceof Function;
-    if (this.sample === Boolean)
+    }
+    if (this.sample === Boolean) {
       return typeof other == "boolean" || other instanceof Boolean;
-    if (this.sample === BigInt)
+    }
+    if (this.sample === BigInt) {
       return typeof other == "bigint" || other instanceof BigInt;
-    if (this.sample === Symbol)
+    }
+    if (this.sample === Symbol) {
       return typeof other == "symbol" || other instanceof Symbol;
-    if (this.sample === Object)
+    }
+    if (this.sample === Object) {
       return typeof other == "object";
+    }
     return other instanceof this.sample;
   }
   toString() {
     return "Any";
   }
   getExpectedType() {
-    if (this.sample === String)
+    if (this.sample === String) {
       return "string";
-    if (this.sample === Number)
+    }
+    if (this.sample === Number) {
       return "number";
-    if (this.sample === Function)
+    }
+    if (this.sample === Function) {
       return "function";
-    if (this.sample === Object)
+    }
+    if (this.sample === Object) {
       return "object";
-    if (this.sample === Boolean)
+    }
+    if (this.sample === Boolean) {
       return "boolean";
+    }
     return this.fnNameFor(this.sample);
   }
   toAsymmetricMatcher() {
@@ -703,8 +797,9 @@ class Any extends AsymmetricMatcher {
 }
 class StringMatching extends AsymmetricMatcher {
   constructor(sample, inverse = false) {
-    if (!isA("String", sample) && !isA("RegExp", sample))
+    if (!isA("String", sample) && !isA("RegExp", sample)) {
       throw new Error("Expected is not a String or a RegExp");
+    }
     super(new RegExp(sample), inverse);
   }
   asymmetricMatch(other) {
@@ -721,17 +816,20 @@ class StringMatching extends AsymmetricMatcher {
 class CloseTo extends AsymmetricMatcher {
   precision;
   constructor(sample, precision = 2, inverse = false) {
-    if (!isA("Number", sample))
+    if (!isA("Number", sample)) {
       throw new Error("Expected is not a Number");
-    if (!isA("Number", precision))
+    }
+    if (!isA("Number", precision)) {
       throw new Error("Precision is not a Number");
+    }
     super(sample);
     this.inverse = inverse;
     this.precision = precision;
   }
   asymmetricMatch(other) {
-    if (!isA("Number", other))
+    if (!isA("Number", other)) {
       return false;
+    }
     let result = false;
     if (other === Number.POSITIVE_INFINITY && this.sample === Number.POSITIVE_INFINITY) {
       result = true;
@@ -757,16 +855,8 @@ class CloseTo extends AsymmetricMatcher {
   }
 }
 const JestAsymmetricMatchers = (chai, utils) => {
-  utils.addMethod(
-    chai.expect,
-    "anything",
-    () => new Anything()
-  );
-  utils.addMethod(
-    chai.expect,
-    "any",
-    (expected) => new Any(expected)
-  );
+  utils.addMethod(chai.expect, "anything", () => new Anything());
+  utils.addMethod(chai.expect, "any", (expected) => new Any(expected));
   utils.addMethod(
     chai.expect,
     "stringContaining",
@@ -805,11 +895,13 @@ function recordAsyncExpect(test, promise) {
   if (test && promise instanceof Promise) {
     promise = promise.finally(() => {
       const index = test.promises.indexOf(promise);
-      if (index !== -1)
+      if (index !== -1) {
         test.promises.splice(index, 1);
+      }
     });
-    if (!test.promises)
+    if (!test.promises) {
       test.promises = [];
+    }
     test.promises.push(promise);
   }
   return promise;
@@ -817,12 +909,13 @@ function recordAsyncExpect(test, promise) {
 function wrapSoft(utils, fn) {
   return function(...args) {
     var _a;
-    const test = utils.flag(this, "vitest-test");
-    const state = (test == null ? void 0 : test.context._local) ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
-    if (!state.soft)
+    if (!utils.flag(this, "soft")) {
       return fn.apply(this, args);
-    if (!test)
+    }
+    const test = utils.flag(this, "vitest-test");
+    if (!test) {
       throw new Error("expect.soft() can only be used inside a test");
+    }
     try {
       return fn.apply(this, args);
     } catch (err) {
@@ -842,12 +935,17 @@ const JestChaiExpect = (chai, utils) => {
     const addMethod = (n) => {
       const softWrapper = wrapSoft(utils, fn);
       utils.addMethod(chai.Assertion.prototype, n, softWrapper);
-      utils.addMethod(globalThis[JEST_MATCHERS_OBJECT].matchers, n, softWrapper);
+      utils.addMethod(
+        globalThis[JEST_MATCHERS_OBJECT].matchers,
+        n,
+        softWrapper
+      );
     };
-    if (Array.isArray(name))
+    if (Array.isArray(name)) {
       name.forEach((n) => addMethod(n));
-    else
+    } else {
       addMethod(name);
+    }
   }
   ["throw", "throws", "Throw"].forEach((m) => {
     utils.overwriteMethod(chai.Assertion.prototype, m, (_super) => {
@@ -880,11 +978,10 @@ const JestChaiExpect = (chai, utils) => {
   });
   def("toEqual", function(expected) {
     const actual = utils.flag(this, "object");
-    const equal = equals(
-      actual,
-      expected,
-      [...customTesters, iterableEquality]
-    );
+    const equal = equals(actual, expected, [
+      ...customTesters,
+      iterableEquality
+    ]);
     return this.assert(
       equal,
       "expected #{this} to deeply equal #{exp}",
@@ -935,13 +1032,13 @@ const JestChaiExpect = (chai, utils) => {
       if (toStrictEqualPass) {
         deepEqualityName = "toStrictEqual";
       } else {
-        const toEqualPass = equals(
-          actual,
-          expected,
-          [...customTesters, iterableEquality]
-        );
-        if (toEqualPass)
+        const toEqualPass = equals(actual, expected, [
+          ...customTesters,
+          iterableEquality
+        ]);
+        if (toEqualPass) {
           deepEqualityName = "toEqual";
+        }
       }
     }
     return this.assert(
@@ -954,30 +1051,41 @@ const JestChaiExpect = (chai, utils) => {
   });
   def("toMatchObject", function(expected) {
     const actual = this._obj;
-    const pass = equals(actual, expected, [...customTesters, iterableEquality, subsetEquality]);
+    const pass = equals(actual, expected, [
+      ...customTesters,
+      iterableEquality,
+      subsetEquality
+    ]);
     const isNot = utils.flag(this, "negate");
-    const { subset: actualSubset, stripped } = getObjectSubset(actual, expected);
+    const { subset: actualSubset, stripped } = getObjectSubset(
+      actual,
+      expected
+    );
     if (pass && isNot || !pass && !isNot) {
-      const msg = utils.getMessage(
-        this,
-        [
-          pass,
-          "expected #{this} to match object #{exp}",
-          "expected #{this} to not match object #{exp}",
-          expected,
-          actualSubset,
-          false
-        ]
-      );
+      const msg = utils.getMessage(this, [
+        pass,
+        "expected #{this} to match object #{exp}",
+        "expected #{this} to not match object #{exp}",
+        expected,
+        actualSubset,
+        false
+      ]);
       const message = stripped === 0 ? msg : `${msg}
 (${stripped} matching ${stripped === 1 ? "property" : "properties"} omitted from actual)`;
-      throw new AssertionError(message, { showDiff: true, expected, actual: actualSubset });
+      throw new AssertionError(message, {
+        showDiff: true,
+        expected,
+        actual: actualSubset
+      });
     }
   });
   def("toMatch", function(expected) {
     const actual = this._obj;
-    if (typeof actual !== "string")
-      throw new TypeError(`.toMatch() expects to receive a string, but got ${typeof actual}`);
+    if (typeof actual !== "string") {
+      throw new TypeError(
+        `.toMatch() expects to receive a string, but got ${typeof actual}`
+      );
+    }
     return this.assert(
       typeof expected === "string" ? actual.includes(expected) : actual.match(expected),
       `expected #{this} to match #{exp}`,
@@ -989,8 +1097,11 @@ const JestChaiExpect = (chai, utils) => {
   def("toContain", function(item) {
     const actual = this._obj;
     if (typeof Node !== "undefined" && actual instanceof Node) {
-      if (!(item instanceof Node))
-        throw new TypeError(`toContain() expected a DOM node as the argument, but got ${typeof item}`);
+      if (!(item instanceof Node)) {
+        throw new TypeError(
+          `toContain() expected a DOM node as the argument, but got ${typeof item}`
+        );
+      }
       return this.assert(
         actual.contains(item),
         "expected #{this} to contain element #{exp}",
@@ -1020,8 +1131,9 @@ const JestChaiExpect = (chai, utils) => {
         actual
       );
     }
-    if (actual != null && typeof actual !== "string")
+    if (actual != null && typeof actual !== "string") {
       utils.flag(this, "object", Array.from(actual));
+    }
     return this.contain(item);
   });
   def("toContainEqual", function(expected) {
@@ -1120,49 +1232,61 @@ const JestChaiExpect = (chai, utils) => {
   def("toBeDefined", function() {
     const negate = utils.flag(this, "negate");
     utils.flag(this, "negate", false);
-    if (negate)
+    if (negate) {
       return this.be.undefined;
+    }
     return this.not.be.undefined;
   });
-  def("toBeTypeOf", function(expected) {
-    const actual = typeof this._obj;
-    const equal = expected === actual;
-    return this.assert(
-      equal,
-      "expected #{this} to be type of #{exp}",
-      "expected #{this} not to be type of #{exp}",
-      expected,
-      actual
-    );
-  });
+  def(
+    "toBeTypeOf",
+    function(expected) {
+      const actual = typeof this._obj;
+      const equal = expected === actual;
+      return this.assert(
+        equal,
+        "expected #{this} to be type of #{exp}",
+        "expected #{this} not to be type of #{exp}",
+        expected,
+        actual
+      );
+    }
+  );
   def("toBeInstanceOf", function(obj) {
     return this.instanceOf(obj);
   });
   def("toHaveLength", function(length) {
     return this.have.length(length);
   });
-  def("toHaveProperty", function(...args) {
-    if (Array.isArray(args[0]))
-      args[0] = args[0].map((key) => String(key).replace(/([.[\]])/g, "\\$1")).join(".");
-    const actual = this._obj;
-    const [propertyName, expected] = args;
-    const getValue = () => {
-      const hasOwn = Object.prototype.hasOwnProperty.call(actual, propertyName);
-      if (hasOwn)
-        return { value: actual[propertyName], exists: true };
-      return utils.getPathInfo(actual, propertyName);
-    };
-    const { value, exists } = getValue();
-    const pass = exists && (args.length === 1 || equals(expected, value, customTesters));
-    const valueString = args.length === 1 ? "" : ` with value ${utils.objDisplay(expected)}`;
-    return this.assert(
-      pass,
-      `expected #{this} to have property "${propertyName}"${valueString}`,
-      `expected #{this} to not have property "${propertyName}"${valueString}`,
-      expected,
-      exists ? value : void 0
-    );
-  });
+  def(
+    "toHaveProperty",
+    function(...args) {
+      if (Array.isArray(args[0])) {
+        args[0] = args[0].map((key) => String(key).replace(/([.[\]])/g, "\\$1")).join(".");
+      }
+      const actual = this._obj;
+      const [propertyName, expected] = args;
+      const getValue = () => {
+        const hasOwn = Object.prototype.hasOwnProperty.call(
+          actual,
+          propertyName
+        );
+        if (hasOwn) {
+          return { value: actual[propertyName], exists: true };
+        }
+        return utils.getPathInfo(actual, propertyName);
+      };
+      const { value, exists } = getValue();
+      const pass = exists && (args.length === 1 || equals(expected, value, customTesters));
+      const valueString = args.length === 1 ? "" : ` with value ${utils.objDisplay(expected)}`;
+      return this.assert(
+        pass,
+        `expected #{this} to have property "${propertyName}"${valueString}`,
+        `expected #{this} to not have property "${propertyName}"${valueString}`,
+        expected,
+        exists ? value : void 0
+      );
+    }
+  );
   def("toBeCloseTo", function(received, precision = 2) {
     const expected = this._obj;
     let pass = false;
@@ -1187,8 +1311,11 @@ const JestChaiExpect = (chai, utils) => {
     );
   });
   const assertIsMock = (assertion) => {
-    if (!isMockFunction(assertion._obj))
-      throw new TypeError(`${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`);
+    if (!isMockFunction(assertion._obj)) {
+      throw new TypeError(
+        `${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`
+      );
+    }
   };
   const getSpy = (assertion) => {
     assertIsMock(assertion);
@@ -1197,58 +1324,79 @@ const JestChaiExpect = (chai, utils) => {
   const ordinalOf = (i) => {
     const j = i % 10;
     const k = i % 100;
-    if (j === 1 && k !== 11)
+    if (j === 1 && k !== 11) {
       return `${i}st`;
-    if (j === 2 && k !== 12)
+    }
+    if (j === 2 && k !== 12) {
       return `${i}nd`;
-    if (j === 3 && k !== 13)
+    }
+    if (j === 3 && k !== 13) {
       return `${i}rd`;
+    }
     return `${i}th`;
   };
-  const formatCalls = (spy, msg, actualCall) => {
+  const formatCalls = (spy, msg, showActualCall) => {
     if (spy.mock.calls) {
-      msg += c().gray(`
+      msg += c().gray(
+        `
 
 Received: 
 
 ${spy.mock.calls.map((callArg, i) => {
-        let methodCall = c().bold(`  ${ordinalOf(i + 1)} ${spy.getMockName()} call:
+          let methodCall = c().bold(
+            `  ${ordinalOf(i + 1)} ${spy.getMockName()} call:
 
-`);
-        if (actualCall)
-          methodCall += diff(actualCall, callArg, { omitAnnotationLines: true });
-        else
-          methodCall += stringify(callArg).split("\n").map((line) => `    ${line}`).join("\n");
-        methodCall += "\n";
-        return methodCall;
-      }).join("\n")}`);
+`
+          );
+          if (showActualCall) {
+            methodCall += diff(showActualCall, callArg, {
+              omitAnnotationLines: true
+            });
+          } else {
+            methodCall += stringify(callArg).split("\n").map((line) => `    ${line}`).join("\n");
+          }
+          methodCall += "\n";
+          return methodCall;
+        }).join("\n")}`
+      );
     }
-    msg += c().gray(`
+    msg += c().gray(
+      `
 
 Number of calls: ${c().bold(spy.mock.calls.length)}
-`);
+`
+    );
     return msg;
   };
-  const formatReturns = (spy, msg, actualReturn) => {
-    msg += c().gray(`
+  const formatReturns = (spy, results, msg, showActualReturn) => {
+    msg += c().gray(
+      `
 
 Received: 
 
-${spy.mock.results.map((callReturn, i) => {
-      let methodCall = c().bold(`  ${ordinalOf(i + 1)} ${spy.getMockName()} call return:
+${results.map((callReturn, i) => {
+        let methodCall = c().bold(
+          `  ${ordinalOf(i + 1)} ${spy.getMockName()} call return:
 
-`);
-      if (actualReturn)
-        methodCall += diff(actualReturn, callReturn.value, { omitAnnotationLines: true });
-      else
-        methodCall += stringify(callReturn).split("\n").map((line) => `    ${line}`).join("\n");
-      methodCall += "\n";
-      return methodCall;
-    }).join("\n")}`);
-    msg += c().gray(`
+`
+        );
+        if (showActualReturn) {
+          methodCall += diff(showActualReturn, callReturn.value, {
+            omitAnnotationLines: true
+          });
+        } else {
+          methodCall += stringify(callReturn).split("\n").map((line) => `    ${line}`).join("\n");
+        }
+        methodCall += "\n";
+        return methodCall;
+      }).join("\n")}`
+    );
+    msg += c().gray(
+      `
 
 Number of calls: ${c().bold(spy.mock.calls.length)}
-`);
+`
+    );
     return msg;
   };
   def(["toHaveBeenCalledTimes", "toBeCalledTimes"], function(number) {
@@ -1283,277 +1431,421 @@ Number of calls: ${c().bold(spy.mock.calls.length)}
     const callCount = spy.mock.calls.length;
     const called = callCount > 0;
     const isNot = utils.flag(this, "negate");
-    let msg = utils.getMessage(
-      this,
-      [
-        called,
-        `expected "${spyName}" to be called at least once`,
-        `expected "${spyName}" to not be called at all, but actually been called ${callCount} times`,
-        true,
-        called
-      ]
-    );
-    if (called && isNot)
+    let msg = utils.getMessage(this, [
+      called,
+      `expected "${spyName}" to be called at least once`,
+      `expected "${spyName}" to not be called at all, but actually been called ${callCount} times`,
+      true,
+      called
+    ]);
+    if (called && isNot) {
       msg = formatCalls(spy, msg);
-    if (called && isNot || !called && !isNot)
+    }
+    if (called && isNot || !called && !isNot) {
       throw new AssertionError(msg);
+    }
   });
   def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
-    const pass = spy.mock.calls.some((callArg) => equals(callArg, args, [...customTesters, iterableEquality]));
-    const isNot = utils.flag(this, "negate");
-    const msg = utils.getMessage(
-      this,
-      [
-        pass,
-        `expected "${spyName}" to be called with arguments: #{exp}`,
-        `expected "${spyName}" to not be called with arguments: #{exp}`,
-        args
-      ]
+    const pass = spy.mock.calls.some(
+      (callArg) => equals(callArg, args, [...customTesters, iterableEquality])
     );
-    if (pass && isNot || !pass && !isNot)
+    const isNot = utils.flag(this, "negate");
+    const msg = utils.getMessage(this, [
+      pass,
+      `expected "${spyName}" to be called with arguments: #{exp}`,
+      `expected "${spyName}" to not be called with arguments: #{exp}`,
+      args
+    ]);
+    if (pass && isNot || !pass && !isNot) {
       throw new AssertionError(formatCalls(spy, msg, args));
+    }
   });
-  def(["toHaveBeenNthCalledWith", "nthCalledWith"], function(times, ...args) {
-    const spy = getSpy(this);
-    const spyName = spy.getMockName();
-    const nthCall = spy.mock.calls[times - 1];
-    const callCount = spy.mock.calls.length;
-    const isCalled = times <= callCount;
-    this.assert(
-      equals(nthCall, args, [...customTesters, iterableEquality]),
-      `expected ${ordinalOf(times)} "${spyName}" call to have been called with #{exp}${isCalled ? `` : `, but called only ${callCount} times`}`,
-      `expected ${ordinalOf(times)} "${spyName}" call to not have been called with #{exp}`,
-      args,
-      nthCall,
-      isCalled
-    );
-  });
-  def(["toHaveBeenLastCalledWith", "lastCalledWith"], function(...args) {
-    const spy = getSpy(this);
-    const spyName = spy.getMockName();
-    const lastCall = spy.mock.calls[spy.mock.calls.length - 1];
-    this.assert(
-      equals(lastCall, args, [...customTesters, iterableEquality]),
-      `expected last "${spyName}" call to have been called with #{exp}`,
-      `expected last "${spyName}" call to not have been called with #{exp}`,
-      args,
-      lastCall
-    );
-  });
-  def(["toThrow", "toThrowError"], function(expected) {
-    if (typeof expected === "string" || typeof expected === "undefined" || expected instanceof RegExp)
-      return this.throws(expected);
-    const obj = this._obj;
-    const promise = utils.flag(this, "promise");
-    const isNot = utils.flag(this, "negate");
-    let thrown = null;
-    if (promise === "rejects") {
-      thrown = obj;
-    } else if (promise === "resolves" && typeof obj !== "function") {
-      if (!isNot) {
-        const message = utils.flag(this, "message") || "expected promise to throw an error, but it didn't";
-        const error = {
-          showDiff: false
-        };
-        throw new AssertionError(message, error, utils.flag(this, "ssfi"));
+  def(
+    ["toHaveBeenNthCalledWith", "nthCalledWith"],
+    function(times, ...args) {
+      const spy = getSpy(this);
+      const spyName = spy.getMockName();
+      const nthCall = spy.mock.calls[times - 1];
+      const callCount = spy.mock.calls.length;
+      const isCalled = times <= callCount;
+      this.assert(
+        equals(nthCall, args, [...customTesters, iterableEquality]),
+        `expected ${ordinalOf(
+          times
+        )} "${spyName}" call to have been called with #{exp}${isCalled ? `` : `, but called only ${callCount} times`}`,
+        `expected ${ordinalOf(
+          times
+        )} "${spyName}" call to not have been called with #{exp}`,
+        args,
+        nthCall,
+        isCalled
+      );
+    }
+  );
+  def(
+    ["toHaveBeenLastCalledWith", "lastCalledWith"],
+    function(...args) {
+      const spy = getSpy(this);
+      const spyName = spy.getMockName();
+      const lastCall = spy.mock.calls[spy.mock.calls.length - 1];
+      this.assert(
+        equals(lastCall, args, [...customTesters, iterableEquality]),
+        `expected last "${spyName}" call to have been called with #{exp}`,
+        `expected last "${spyName}" call to not have been called with #{exp}`,
+        args,
+        lastCall
+      );
+    }
+  );
+  def(
+    ["toThrow", "toThrowError"],
+    function(expected) {
+      if (typeof expected === "string" || typeof expected === "undefined" || expected instanceof RegExp) {
+        return this.throws(expected);
+      }
+      const obj = this._obj;
+      const promise = utils.flag(this, "promise");
+      const isNot = utils.flag(this, "negate");
+      let thrown = null;
+      if (promise === "rejects") {
+        thrown = obj;
+      } else if (promise === "resolves" && typeof obj !== "function") {
+        if (!isNot) {
+          const message = utils.flag(this, "message") || "expected promise to throw an error, but it didn't";
+          const error = {
+            showDiff: false
+          };
+          throw new AssertionError(message, error, utils.flag(this, "ssfi"));
+        } else {
+          return;
+        }
       } else {
-        return;
+        let isThrow = false;
+        try {
+          obj();
+        } catch (err) {
+          isThrow = true;
+          thrown = err;
+        }
+        if (!isThrow && !isNot) {
+          const message = utils.flag(this, "message") || "expected function to throw an error, but it didn't";
+          const error = {
+            showDiff: false
+          };
+          throw new AssertionError(message, error, utils.flag(this, "ssfi"));
+        }
       }
-    } else {
-      let isThrow = false;
-      try {
-        obj();
-      } catch (err) {
-        isThrow = true;
-        thrown = err;
+      if (typeof expected === "function") {
+        const name = expected.name || expected.prototype.constructor.name;
+        return this.assert(
+          thrown && thrown instanceof expected,
+          `expected error to be instance of ${name}`,
+          `expected error not to be instance of ${name}`,
+          expected,
+          thrown
+        );
       }
-      if (!isThrow && !isNot) {
-        const message = utils.flag(this, "message") || "expected function to throw an error, but it didn't";
-        const error = {
-          showDiff: false
-        };
-        throw new AssertionError(message, error, utils.flag(this, "ssfi"));
+      if (expected instanceof Error) {
+        return this.assert(
+          thrown && expected.message === thrown.message,
+          `expected error to have message: ${expected.message}`,
+          `expected error not to have message: ${expected.message}`,
+          expected.message,
+          thrown && thrown.message
+        );
       }
-    }
-    if (typeof expected === "function") {
-      const name = expected.name || expected.prototype.constructor.name;
-      return this.assert(
-        thrown && thrown instanceof expected,
-        `expected error to be instance of ${name}`,
-        `expected error not to be instance of ${name}`,
-        expected,
-        thrown
+      if (typeof expected === "object" && "asymmetricMatch" in expected && typeof expected.asymmetricMatch === "function") {
+        const matcher = expected;
+        return this.assert(
+          thrown && matcher.asymmetricMatch(thrown),
+          "expected error to match asymmetric matcher",
+          "expected error not to match asymmetric matcher",
+          matcher,
+          thrown
+        );
+      }
+      throw new Error(
+        `"toThrow" expects string, RegExp, function, Error instance or asymmetric matcher, got "${typeof expected}"`
       );
     }
-    if (expected instanceof Error) {
-      return this.assert(
-        thrown && expected.message === thrown.message,
-        `expected error to have message: ${expected.message}`,
-        `expected error not to have message: ${expected.message}`,
-        expected.message,
-        thrown && thrown.message
-      );
+  );
+  [
+    {
+      name: "toHaveResolved",
+      condition: (spy) => spy.mock.settledResults.length > 0 && spy.mock.settledResults.some(({ type }) => type === "fulfilled"),
+      action: "resolved"
+    },
+    {
+      name: ["toHaveReturned", "toReturn"],
+      condition: (spy) => spy.mock.calls.length > 0 && spy.mock.results.some(({ type }) => type !== "throw"),
+      action: "called"
     }
-    if (typeof expected === "object" && "asymmetricMatch" in expected && typeof expected.asymmetricMatch === "function") {
-      const matcher = expected;
-      return this.assert(
-        thrown && matcher.asymmetricMatch(thrown),
-        "expected error to match asymmetric matcher",
-        "expected error not to match asymmetric matcher",
-        matcher,
-        thrown
+  ].forEach(({ name, condition, action }) => {
+    def(name, function() {
+      const spy = getSpy(this);
+      const spyName = spy.getMockName();
+      const pass = condition(spy);
+      this.assert(
+        pass,
+        `expected "${spyName}" to be successfully ${action} at least once`,
+        `expected "${spyName}" to not be successfully ${action}`,
+        pass,
+        !pass,
+        false
       );
-    }
-    throw new Error(`"toThrow" expects string, RegExp, function, Error instance or asymmetric matcher, got "${typeof expected}"`);
-  });
-  def(["toHaveReturned", "toReturn"], function() {
-    const spy = getSpy(this);
-    const spyName = spy.getMockName();
-    const calledAndNotThrew = spy.mock.calls.length > 0 && spy.mock.results.some(({ type }) => type !== "throw");
-    this.assert(
-      calledAndNotThrew,
-      `expected "${spyName}" to be successfully called at least once`,
-      `expected "${spyName}" to not be successfully called`,
-      calledAndNotThrew,
-      !calledAndNotThrew,
-      false
-    );
-  });
-  def(["toHaveReturnedTimes", "toReturnTimes"], function(times) {
-    const spy = getSpy(this);
-    const spyName = spy.getMockName();
-    const successfulReturns = spy.mock.results.reduce((success, { type }) => type === "throw" ? success : ++success, 0);
-    this.assert(
-      successfulReturns === times,
-      `expected "${spyName}" to be successfully called ${times} times`,
-      `expected "${spyName}" to not be successfully called ${times} times`,
-      `expected number of returns: ${times}`,
-      `received number of returns: ${successfulReturns}`,
-      false
-    );
+    });
   });
-  def(["toHaveReturnedWith", "toReturnWith"], function(value) {
-    const spy = getSpy(this);
-    const spyName = spy.getMockName();
-    const pass = spy.mock.results.some(({ type, value: result }) => type === "return" && equals(value, result));
-    const isNot = utils.flag(this, "negate");
-    const msg = utils.getMessage(
-      this,
-      [
+  [
+    {
+      name: "toHaveResolvedTimes",
+      condition: (spy, times) => spy.mock.settledResults.reduce(
+        (s, { type }) => type === "fulfilled" ? ++s : s,
+        0
+      ) === times,
+      action: "resolved"
+    },
+    {
+      name: ["toHaveReturnedTimes", "toReturnTimes"],
+      condition: (spy, times) => spy.mock.results.reduce(
+        (s, { type }) => type === "throw" ? s : ++s,
+        0
+      ) === times,
+      action: "called"
+    }
+  ].forEach(({ name, condition, action }) => {
+    def(name, function(times) {
+      const spy = getSpy(this);
+      const spyName = spy.getMockName();
+      const pass = condition(spy, times);
+      this.assert(
         pass,
-        `expected "${spyName}" to return with: #{exp} at least once`,
-        `expected "${spyName}" to not return with: #{exp}`,
-        value
-      ]
-    );
-    if (pass && isNot || !pass && !isNot)
-      throw new AssertionError(formatReturns(spy, msg, value));
+        `expected "${spyName}" to be successfully ${action} ${times} times`,
+        `expected "${spyName}" to not be successfully ${action} ${times} times`,
+        `expected resolved times: ${times}`,
+        `received resolved times: ${pass}`,
+        false
+      );
+    });
   });
-  def(["toHaveLastReturnedWith", "lastReturnedWith"], function(value) {
-    const spy = getSpy(this);
-    const spyName = spy.getMockName();
-    const { value: lastResult } = spy.mock.results[spy.mock.results.length - 1];
-    const pass = equals(lastResult, value);
-    this.assert(
-      pass,
-      `expected last "${spyName}" call to return #{exp}`,
-      `expected last "${spyName}" call to not return #{exp}`,
-      value,
-      lastResult
-    );
+  [
+    {
+      name: "toHaveResolvedWith",
+      condition: (spy, value) => spy.mock.settledResults.some(
+        ({ type, value: result }) => type === "fulfilled" && equals(value, result)
+      ),
+      action: "resolve"
+    },
+    {
+      name: ["toHaveReturnedWith", "toReturnWith"],
+      condition: (spy, value) => spy.mock.results.some(
+        ({ type, value: result }) => type === "return" && equals(value, result)
+      ),
+      action: "return"
+    }
+  ].forEach(({ name, condition, action }) => {
+    def(name, function(value) {
+      const spy = getSpy(this);
+      const pass = condition(spy, value);
+      const isNot = utils.flag(this, "negate");
+      if (pass && isNot || !pass && !isNot) {
+        const spyName = spy.getMockName();
+        const msg = utils.getMessage(this, [
+          pass,
+          `expected "${spyName}" to ${action} with: #{exp} at least once`,
+          `expected "${spyName}" to not ${action} with: #{exp}`,
+          value
+        ]);
+        const results = action === "return" ? spy.mock.results : spy.mock.settledResults;
+        throw new AssertionError(formatReturns(spy, results, msg, value));
+      }
+    });
   });
-  def(["toHaveNthReturnedWith", "nthReturnedWith"], function(nthCall, value) {
-    const spy = getSpy(this);
-    const spyName = spy.getMockName();
-    const isNot = utils.flag(this, "negate");
-    const { type: callType, value: callResult } = spy.mock.results[nthCall - 1];
-    const ordinalCall = `${ordinalOf(nthCall)} call`;
-    if (!isNot && callType === "throw")
-      chai.assert.fail(`expected ${ordinalCall} to return #{exp}, but instead it threw an error`);
-    const nthCallReturn = equals(callResult, value);
-    this.assert(
-      nthCallReturn,
-      `expected ${ordinalCall} "${spyName}" call to return #{exp}`,
-      `expected ${ordinalCall} "${spyName}" call to not return #{exp}`,
-      value,
-      callResult
-    );
+  [
+    {
+      name: "toHaveLastResolvedWith",
+      condition: (spy, value) => {
+        const result = spy.mock.settledResults[spy.mock.settledResults.length - 1];
+        return result && result.type === "fulfilled" && equals(result.value, value);
+      },
+      action: "resolve"
+    },
+    {
+      name: ["toHaveLastReturnedWith", "lastReturnedWith"],
+      condition: (spy, value) => {
+        const result = spy.mock.results[spy.mock.results.length - 1];
+        return result && result.type === "return" && equals(result.value, value);
+      },
+      action: "return"
+    }
+  ].forEach(({ name, condition, action }) => {
+    def(name, function(value) {
+      const spy = getSpy(this);
+      const results = action === "return" ? spy.mock.results : spy.mock.settledResults;
+      const result = results[results.length - 1];
+      const spyName = spy.getMockName();
+      this.assert(
+        condition(spy, value),
+        `expected last "${spyName}" call to ${action} #{exp}`,
+        `expected last "${spyName}" call to not ${action} #{exp}`,
+        value,
+        result == null ? void 0 : result.value
+      );
+    });
+  });
+  [
+    {
+      name: "toHaveNthResolvedWith",
+      condition: (spy, index, value) => {
+        const result = spy.mock.settledResults[index - 1];
+        return result && result.type === "fulfilled" && equals(result.value, value);
+      },
+      action: "resolve"
+    },
+    {
+      name: ["toHaveNthReturnedWith", "nthReturnedWith"],
+      condition: (spy, index, value) => {
+        const result = spy.mock.results[index - 1];
+        return result && result.type === "return" && equals(result.value, value);
+      },
+      action: "return"
+    }
+  ].forEach(({ name, condition, action }) => {
+    def(name, function(nthCall, value) {
+      const spy = getSpy(this);
+      const spyName = spy.getMockName();
+      const results = action === "return" ? spy.mock.results : spy.mock.settledResults;
+      const result = results[nthCall - 1];
+      const ordinalCall = `${ordinalOf(nthCall)} call`;
+      this.assert(
+        condition(spy, nthCall, value),
+        `expected ${ordinalCall} "${spyName}" call to ${action} #{exp}`,
+        `expected ${ordinalCall} "${spyName}" call to not ${action} #{exp}`,
+        value,
+        result == null ? void 0 : result.value
+      );
+    });
   });
   def("toSatisfy", function(matcher, message) {
     return this.be.satisfy(matcher, message);
   });
-  utils.addProperty(chai.Assertion.prototype, "resolves", function __VITEST_RESOLVES__() {
-    const error = new Error("resolves");
-    utils.flag(this, "promise", "resolves");
-    utils.flag(this, "error", error);
-    const test = utils.flag(this, "vitest-test");
-    const obj = utils.flag(this, "object");
-    if (typeof (obj == null ? void 0 : obj.then) !== "function")
-      throw new TypeError(`You must provide a Promise to expect() when using .resolves, not '${typeof obj}'.`);
-    const proxy = new Proxy(this, {
-      get: (target, key, receiver) => {
-        const result = Reflect.get(target, key, receiver);
-        if (typeof result !== "function")
-          return result instanceof chai.Assertion ? proxy : result;
-        return async (...args) => {
-          const promise = obj.then(
-            (value) => {
-              utils.flag(this, "object", value);
-              return result.call(this, ...args);
-            },
-            (err) => {
-              const _error = new AssertionError(
-                `promise rejected "${utils.inspect(err)}" instead of resolving`,
-                { showDiff: false }
-              );
-              _error.cause = err;
-              _error.stack = error.stack.replace(error.message, _error.message);
-              throw _error;
-            }
-          );
-          return recordAsyncExpect(test, promise);
-        };
-      }
-    });
-    return proxy;
+  def("withContext", function(context) {
+    for (const key in context) {
+      utils.flag(this, key, context[key]);
+    }
+    return this;
   });
-  utils.addProperty(chai.Assertion.prototype, "rejects", function __VITEST_REJECTS__() {
-    const error = new Error("rejects");
-    utils.flag(this, "promise", "rejects");
-    utils.flag(this, "error", error);
-    const test = utils.flag(this, "vitest-test");
-    const obj = utils.flag(this, "object");
-    const wrapper = typeof obj === "function" ? obj() : obj;
-    if (typeof (wrapper == null ? void 0 : wrapper.then) !== "function")
-      throw new TypeError(`You must provide a Promise to expect() when using .rejects, not '${typeof wrapper}'.`);
-    const proxy = new Proxy(this, {
-      get: (target, key, receiver) => {
-        const result = Reflect.get(target, key, receiver);
-        if (typeof result !== "function")
-          return result instanceof chai.Assertion ? proxy : result;
-        return async (...args) => {
-          const promise = wrapper.then(
-            (value) => {
-              const _error = new AssertionError(
-                `promise resolved "${utils.inspect(value)}" instead of rejecting`,
-                { showDiff: true, expected: new Error("rejected promise"), actual: value }
-              );
-              _error.stack = error.stack.replace(error.message, _error.message);
-              throw _error;
-            },
-            (err) => {
-              utils.flag(this, "object", err);
-              return result.call(this, ...args);
-            }
-          );
-          return recordAsyncExpect(test, promise);
-        };
+  utils.addProperty(
+    chai.Assertion.prototype,
+    "resolves",
+    function __VITEST_RESOLVES__() {
+      const error = new Error("resolves");
+      utils.flag(this, "promise", "resolves");
+      utils.flag(this, "error", error);
+      const test = utils.flag(this, "vitest-test");
+      const obj = utils.flag(this, "object");
+      if (utils.flag(this, "poll")) {
+        throw new SyntaxError(
+          `expect.poll() is not supported in combination with .resolves`
+        );
       }
-    });
-    return proxy;
-  });
+      if (typeof (obj == null ? void 0 : obj.then) !== "function") {
+        throw new TypeError(
+          `You must provide a Promise to expect() when using .resolves, not '${typeof obj}'.`
+        );
+      }
+      const proxy = new Proxy(this, {
+        get: (target, key, receiver) => {
+          const result = Reflect.get(target, key, receiver);
+          if (typeof result !== "function") {
+            return result instanceof chai.Assertion ? proxy : result;
+          }
+          return async (...args) => {
+            const promise = obj.then(
+              (value) => {
+                utils.flag(this, "object", value);
+                return result.call(this, ...args);
+              },
+              (err) => {
+                const _error = new AssertionError(
+                  `promise rejected "${utils.inspect(
+                    err
+                  )}" instead of resolving`,
+                  { showDiff: false }
+                );
+                _error.cause = err;
+                _error.stack = error.stack.replace(
+                  error.message,
+                  _error.message
+                );
+                throw _error;
+              }
+            );
+            return recordAsyncExpect(test, promise);
+          };
+        }
+      });
+      return proxy;
+    }
+  );
+  utils.addProperty(
+    chai.Assertion.prototype,
+    "rejects",
+    function __VITEST_REJECTS__() {
+      const error = new Error("rejects");
+      utils.flag(this, "promise", "rejects");
+      utils.flag(this, "error", error);
+      const test = utils.flag(this, "vitest-test");
+      const obj = utils.flag(this, "object");
+      const wrapper = typeof obj === "function" ? obj() : obj;
+      if (utils.flag(this, "poll")) {
+        throw new SyntaxError(
+          `expect.poll() is not supported in combination with .rejects`
+        );
+      }
+      if (typeof (wrapper == null ? void 0 : wrapper.then) !== "function") {
+        throw new TypeError(
+          `You must provide a Promise to expect() when using .rejects, not '${typeof wrapper}'.`
+        );
+      }
+      const proxy = new Proxy(this, {
+        get: (target, key, receiver) => {
+          const result = Reflect.get(target, key, receiver);
+          if (typeof result !== "function") {
+            return result instanceof chai.Assertion ? proxy : result;
+          }
+          return async (...args) => {
+            const promise = wrapper.then(
+              (value) => {
+                const _error = new AssertionError(
+                  `promise resolved "${utils.inspect(
+                    value
+                  )}" instead of rejecting`,
+                  {
+                    showDiff: true,
+                    expected: new Error("rejected promise"),
+                    actual: value
+                  }
+                );
+                _error.stack = error.stack.replace(
+                  error.message,
+                  _error.message
+                );
+                throw _error;
+              },
+              (err) => {
+                utils.flag(this, "object", err);
+                return result.call(this, ...args);
+              }
+            );
+            return recordAsyncExpect(test, promise);
+          };
+        }
+      });
+      return proxy;
+    }
+  );
 };
 
 function getMatcherState(assertion, expect) {
@@ -1575,7 +1867,9 @@ function getMatcherState(assertion, expect) {
     promise,
     equals,
     // needed for built-in jest-snapshots, but we don't use it
-    suppressedErrors: []
+    suppressedErrors: [],
+    soft: util.flag(assertion, "soft"),
+    poll: util.flag(assertion, "poll")
   };
   return {
     state: matcherState,
@@ -1592,71 +1886,91 @@ class JestExtendError extends Error {
 }
 function JestExtendPlugin(c, expect, matchers) {
   return (_, utils) => {
-    Object.entries(matchers).forEach(([expectAssertionName, expectAssertion]) => {
-      function expectWrapper(...args) {
-        const { state, isNot, obj } = getMatcherState(this, expect);
-        const result = expectAssertion.call(state, obj, ...args);
-        if (result && typeof result === "object" && result instanceof Promise) {
-          return result.then(({ pass: pass2, message: message2, actual: actual2, expected: expected2 }) => {
-            if (pass2 && isNot || !pass2 && !isNot)
-              throw new JestExtendError(message2(), actual2, expected2);
-          });
-        }
-        const { pass, message, actual, expected } = result;
-        if (pass && isNot || !pass && !isNot)
-          throw new JestExtendError(message(), actual, expected);
-      }
-      const softWrapper = wrapSoft(utils, expectWrapper);
-      utils.addMethod(globalThis[JEST_MATCHERS_OBJECT].matchers, expectAssertionName, softWrapper);
-      utils.addMethod(c.Assertion.prototype, expectAssertionName, softWrapper);
-      class CustomMatcher extends AsymmetricMatcher {
-        constructor(inverse = false, ...sample) {
-          super(sample, inverse);
-        }
-        asymmetricMatch(other) {
-          const { pass } = expectAssertion.call(
-            this.getMatcherContext(expect),
-            other,
-            ...this.sample
-          );
-          return this.inverse ? !pass : pass;
-        }
-        toString() {
-          return `${this.inverse ? "not." : ""}${expectAssertionName}`;
-        }
-        getExpectedType() {
-          return "any";
+    Object.entries(matchers).forEach(
+      ([expectAssertionName, expectAssertion]) => {
+        function expectWrapper(...args) {
+          const { state, isNot, obj } = getMatcherState(this, expect);
+          const result = expectAssertion.call(state, obj, ...args);
+          if (result && typeof result === "object" && result instanceof Promise) {
+            return result.then(({ pass: pass2, message: message2, actual: actual2, expected: expected2 }) => {
+              if (pass2 && isNot || !pass2 && !isNot) {
+                throw new JestExtendError(message2(), actual2, expected2);
+              }
+            });
+          }
+          const { pass, message, actual, expected } = result;
+          if (pass && isNot || !pass && !isNot) {
+            throw new JestExtendError(message(), actual, expected);
+          }
         }
-        toAsymmetricMatcher() {
-          return `${this.toString()}<${this.sample.map(String).join(", ")}>`;
+        const softWrapper = wrapSoft(utils, expectWrapper);
+        utils.addMethod(
+          globalThis[JEST_MATCHERS_OBJECT].matchers,
+          expectAssertionName,
+          softWrapper
+        );
+        utils.addMethod(
+          c.Assertion.prototype,
+          expectAssertionName,
+          softWrapper
+        );
+        class CustomMatcher extends AsymmetricMatcher {
+          constructor(inverse = false, ...sample) {
+            super(sample, inverse);
+          }
+          asymmetricMatch(other) {
+            const { pass } = expectAssertion.call(
+              this.getMatcherContext(expect),
+              other,
+              ...this.sample
+            );
+            return this.inverse ? !pass : pass;
+          }
+          toString() {
+            return `${this.inverse ? "not." : ""}${expectAssertionName}`;
+          }
+          getExpectedType() {
+            return "any";
+          }
+          toAsymmetricMatcher() {
+            return `${this.toString()}<${this.sample.map(String).join(", ")}>`;
+          }
         }
+        const customMatcher = (...sample) => new CustomMatcher(false, ...sample);
+        Object.defineProperty(expect, expectAssertionName, {
+          configurable: true,
+          enumerable: true,
+          value: customMatcher,
+          writable: true
+        });
+        Object.defineProperty(expect.not, expectAssertionName, {
+          configurable: true,
+          enumerable: true,
+          value: (...sample) => new CustomMatcher(true, ...sample),
+          writable: true
+        });
+        Object.defineProperty(
+          globalThis[ASYMMETRIC_MATCHERS_OBJECT],
+          expectAssertionName,
+          {
+            configurable: true,
+            enumerable: true,
+            value: customMatcher,
+            writable: true
+          }
+        );
       }
-      const customMatcher = (...sample) => new CustomMatcher(false, ...sample);
-      Object.defineProperty(expect, expectAssertionName, {
-        configurable: true,
-        enumerable: true,
-        value: customMatcher,
-        writable: true
-      });
-      Object.defineProperty(expect.not, expectAssertionName, {
-        configurable: true,
-        enumerable: true,
-        value: (...sample) => new CustomMatcher(true, ...sample),
-        writable: true
-      });
-      Object.defineProperty(globalThis[ASYMMETRIC_MATCHERS_OBJECT], expectAssertionName, {
-        configurable: true,
-        enumerable: true,
-        value: customMatcher,
-        writable: true
-      });
-    });
+    );
   };
 }
 const JestExtend = (chai, utils) => {
-  utils.addMethod(chai.expect, "extend", (expect, expects) => {
-    use(JestExtendPlugin(chai, expect, expects));
-  });
+  utils.addMethod(
+    chai.expect,
+    "extend",
+    (expect, expects) => {
+      use(JestExtendPlugin(chai, expect, expects));
+    }
+  );
 };
 
 export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, AsymmetricMatcher, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, ObjectContaining, StringContaining, StringMatching, addCustomEqualityTesters, arrayBufferEquality, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isImmutableUnorderedKeyed, isImmutableUnorderedSet, iterableEquality, pluralize, setState, sparseArrayEquality, subsetEquality, typeEquality };