strong-mock 7.3.0 → 8.0.0-beta.0

package/dist/index.js

@@ -1,180 +1,124 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var jestMatcherUtils = require('jest-matcher-utils');
 var lodash = require('lodash');
 
-var MATCHER_SYMBOL = Symbol('matcher');
+const MATCHER_SYMBOL = Symbol('matcher');
 /**
  * Used to test if an expectation on an argument is a custom matcher.
- */
-function isMatcher(f) {
-    return !!(f && f[MATCHER_SYMBOL]);
-}
+ */
 
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise */
-
-var extendStatics = function(d, b) {
-    extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-    return extendStatics(d, b);
-};
-
-function __extends(d, b) {
-    if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-function __read(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-}
-
-function __spreadArray(to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
+function isMatcher(f) {
+  return !!(f && f[MATCHER_SYMBOL]);
 }
 
 /**
  * Special symbol denoting the call of a function.
- */
-var ApplyProp = Symbol('apply');
-
-var printProperty = function (property) {
-    if (property === ApplyProp) {
-        return '';
-    }
-    if (typeof property === 'symbol') {
-        return "[" + property.toString() + "]";
-    }
-    return "." + property;
-};
-var printArg = function (arg) {
-    // Call toJSON on matchers directly to avoid wrapping them in quotes.
-    return isMatcher(arg) ? arg.toJSON() : jestMatcherUtils.printExpected(arg);
-};
-var printCall = function (property, args) {
-    var prettyArgs = args.map(function (arg) { return printArg(arg); }).join(', ');
-    var prettyProperty = printProperty(property);
-    return prettyProperty + "(" + prettyArgs + ")";
-};
-var printReturns = function (_a, min, max) {
-    var isError = _a.isError, isPromise = _a.isPromise, value = _a.value;
-    var thenPrefix = '';
-    if (isPromise) {
-        if (isError) {
-            thenPrefix += 'thenReject';
-        }
-        else {
-            thenPrefix += 'thenResolve';
-        }
-    }
-    else if (isError) {
-        thenPrefix += 'thenThrow';
-    }
-    else {
-        thenPrefix += 'thenReturn';
-    }
-    return "." + thenPrefix + "(" + jestMatcherUtils.printExpected(value) + ").between(" + min + ", " + max + ")";
-};
-var printWhen = function (property, args) {
-    if (args) {
-        return "when(" + jestMatcherUtils.EXPECTED_COLOR("mock" + printCall(property, args)) + ")";
-    }
-    return "when(" + jestMatcherUtils.EXPECTED_COLOR("mock" + printProperty(property)) + ")";
-};
-var printExpectation = function (property, args, returnValue, min, max) { return "" + printWhen(property, args) + printReturns(returnValue, min, max); };
-var printRemainingExpectations = function (expectations) {
-    return expectations.length
-        ? "Remaining unmet expectations:\n - " + expectations.map(function (e) { return e.toJSON(); }).join('\n - ')
-        : 'There are no remaining unmet expectations.';
+ */
+const ApplyProp = Symbol('apply');
+
+const printProperty = property => {
+  if (property === ApplyProp) {
+    return '';
+  }
+
+  if (typeof property === 'symbol') {
+    return `[${property.toString()}]`;
+  }
+
+  return `.${property}`;
+};
+const printArg = arg => // Call toJSON on matchers directly to avoid wrapping them in quotes.
+isMatcher(arg) ? arg.toJSON() : jestMatcherUtils.printExpected(arg);
+const printCall = (property, args) => {
+  const prettyArgs = args.map(arg => printArg(arg)).join(', ');
+  const prettyProperty = printProperty(property);
+  return `${prettyProperty}(${prettyArgs})`;
 };
+const printReturns = ({
+  isError,
+  isPromise,
+  value
+}, min, max) => {
+  let thenPrefix = '';
+
+  if (isPromise) {
+    if (isError) {
+      thenPrefix += 'thenReject';
+    } else {
+      thenPrefix += 'thenResolve';
+    }
+  } else if (isError) {
+    thenPrefix += 'thenThrow';
+  } else {
+    thenPrefix += 'thenReturn';
+  }
+
+  return `.${thenPrefix}(${jestMatcherUtils.printExpected(value)}).between(${min}, ${max})`;
+};
+const printWhen = (property, args) => {
+  if (args) {
+    return `when(${jestMatcherUtils.EXPECTED_COLOR(`mock${printCall(property, args)}`)})`;
+  }
+
+  return `when(${jestMatcherUtils.EXPECTED_COLOR(`mock${printProperty(property)}`)})`;
+};
+const printExpectation = (property, args, returnValue, min, max) => `${printWhen(property, args)}${printReturns(returnValue, min, max)}`;
+const printRemainingExpectations = expectations => expectations.length ? `Remaining unmet expectations:
+ - ${expectations.map(e => e.toJSON()).join('\n - ')}` : 'There are no remaining unmet expectations.';
+
+class UnfinishedExpectation extends Error {
+  constructor(pendingExpectation) {
+    super(`There is an unfinished pending expectation:
 
-var UnfinishedExpectation = /** @class */ (function (_super) {
-    __extends(UnfinishedExpectation, _super);
-    function UnfinishedExpectation(pendingExpectation) {
-        return _super.call(this, "There is an unfinished pending expectation:\n\n" + pendingExpectation.toJSON() + "\n\nPlease finish it by setting a return value even if the value\nis undefined.\n\nThis may have been caused by using the mock without getting\nan instance from it first. Please use instance(mock) and use\nthat value in the code you're testing.") || this;
-    }
-    return UnfinishedExpectation;
-}(Error));
-var MissingWhen = /** @class */ (function (_super) {
-    __extends(MissingWhen, _super);
-    function MissingWhen() {
-        return _super.call(this, "You tried setting a return value without an expectation.\n\nEvery call to set a return value must be preceded by an expectation.") || this;
-    }
-    return MissingWhen;
-}(Error));
-var UnexpectedAccess = /** @class */ (function (_super) {
-    __extends(UnexpectedAccess, _super);
-    function UnexpectedAccess(property, expectations) {
-        return _super.call(this, "Didn't expect " + jestMatcherUtils.EXPECTED_COLOR("mock" + printProperty(property)) + " to be accessed.\n\nIf you expect this property to be accessed then please\nset an expectation for it.\n\n" + printRemainingExpectations(expectations)) || this;
-    }
-    return UnexpectedAccess;
-}(Error));
-var UnexpectedCall = /** @class */ (function (_super) {
-    __extends(UnexpectedCall, _super);
-    function UnexpectedCall(property, args, expectations) {
-        return _super.call(this, "Didn't expect " + jestMatcherUtils.EXPECTED_COLOR("mock" + printCall(property, args)) + " to be called.\n\n" + printRemainingExpectations(expectations)) || this;
-    }
-    return UnexpectedCall;
-}(Error));
-var NotAMock = /** @class */ (function (_super) {
-    __extends(NotAMock, _super);
-    function NotAMock() {
-        return _super.call(this, "We couldn't find the mock.\n\nMake sure you're passing in an actual mock.") || this;
-    }
-    return NotAMock;
-}(Error));
-var UnmetExpectations = /** @class */ (function (_super) {
-    __extends(UnmetExpectations, _super);
-    function UnmetExpectations(expectations) {
-        return _super.call(this, "There are unmet expectations:\n\n - " + expectations.map(function (e) { return e.toJSON(); }).join('\n - ')) || this;
-    }
-    return UnmetExpectations;
-}(Error));
+${pendingExpectation.toJSON()}
+
+Please finish it by setting a return value even if the value
+is undefined.`);
+  }
+
+}
+class MissingWhen extends Error {
+  constructor() {
+    super(`You tried setting a return value without an expectation.
+
+Every call to set a return value must be preceded by an expectation.`);
+  }
+
+}
+class UnexpectedAccess extends Error {
+  constructor(property, expectations) {
+    super(`Didn't expect ${jestMatcherUtils.EXPECTED_COLOR(`mock${printProperty(property)}`)} to be accessed.
+
+If you expect this property to be accessed then please
+set an expectation for it.
+
+${printRemainingExpectations(expectations)}`);
+  }
+
+}
+class UnexpectedCall extends Error {
+  constructor(property, args, expectations) {
+    super(`Didn't expect ${jestMatcherUtils.EXPECTED_COLOR(`mock${printCall(property, args)}`)} to be called.
+
+${printRemainingExpectations(expectations)}`);
+  }
+
+}
+class NotAMock extends Error {
+  constructor() {
+    super(`We couldn't find the mock.
+
+Make sure you're passing in an actual mock.`);
+  }
+
+}
+class UnmetExpectations extends Error {
+  constructor(expectations) {
+    super(`There are unmet expectations:
+
+ - ${expectations.map(e => e.toJSON()).join('\n - ')}`);
+  }
+
+}
 /**
  * Merge property accesses and method calls for the same property
  * into a single call.
@@ -182,335 +126,375 @@ var UnmetExpectations = /** @class */ (function (_super) {
  * @example
  * mergeCalls({ foo: [{ arguments: undefined }, { arguments: [1, 2, 3] }] }
  * // returns { foo: [{ arguments: [1, 2, 3] } }
- */
-var mergeCalls = function (callMap) {
-    return new Map(Array.from(callMap.entries()).map(function (_a) {
-        var _b = __read(_a, 2), property = _b[0], calls = _b[1];
-        var hasMethodCalls = calls.some(function (call) { return call.arguments; });
-        var hasPropertyAccesses = calls.some(function (call) { return !call.arguments; });
-        if (hasMethodCalls && hasPropertyAccesses) {
-            return [property, calls.filter(function (call) { return call.arguments; })];
-        }
-        return [property, calls];
-    }));
-};
-var UnexpectedCalls = /** @class */ (function (_super) {
-    __extends(UnexpectedCalls, _super);
-    function UnexpectedCalls(unexpectedCalls, expectations) {
-        var _this = this;
-        var printedCalls = Array.from(mergeCalls(unexpectedCalls).entries())
-            .map(function (_a) {
-            var _b = __read(_a, 2), property = _b[0], calls = _b[1];
-            return calls
-                .map(function (call) {
-                return call.arguments
-                    ? jestMatcherUtils.EXPECTED_COLOR("mock" + printCall(property, call.arguments))
-                    : jestMatcherUtils.EXPECTED_COLOR("mock" + printProperty(property));
-            })
-                .join('\n - ');
-        })
-            .join('\n - ');
-        _this = _super.call(this, "The following calls were unexpected:\n\n - " + printedCalls + "\n\n" + printRemainingExpectations(expectations)) || this;
-        return _this;
-    }
-    return UnexpectedCalls;
-}(Error));
-var NestedWhen = /** @class */ (function (_super) {
-    __extends(NestedWhen, _super);
-    function NestedWhen(parentProp, childProp) {
-        var _this = this;
-        var snippet = "\nconst parentMock = mock<T1>();\nconst childMock = mock<T2>();\n\nwhen(childMock" + printProperty(childProp) + ").thenReturn(...);\nwhen(parentMock" + printProperty(parentProp) + ").thenReturn(instance(childMock))\n";
-        _this = _super.call(this, "Setting an expectation on a nested property is not supported.\n\nYou can return an object directly when the first property is accessed,\nor you can even return a separate mock:\n" + snippet) || this;
-        return _this;
-    }
-    return NestedWhen;
-}(Error));
+ */
+
+const mergeCalls = callMap => new Map(Array.from(callMap.entries()).map(([property, calls]) => {
+  const hasMethodCalls = calls.some(call => call.arguments);
+  const hasPropertyAccesses = calls.some(call => !call.arguments);
+
+  if (hasMethodCalls && hasPropertyAccesses) {
+    return [property, calls.filter(call => call.arguments)];
+  }
+
+  return [property, calls];
+}));
+
+class UnexpectedCalls extends Error {
+  constructor(unexpectedCalls, expectations) {
+    const printedCalls = Array.from(mergeCalls(unexpectedCalls).entries()).map(([property, calls]) => calls.map(call => call.arguments ? jestMatcherUtils.EXPECTED_COLOR(`mock${printCall(property, call.arguments)}`) : jestMatcherUtils.EXPECTED_COLOR(`mock${printProperty(property)}`)).join('\n - ')).join('\n - ');
+    super(`The following calls were unexpected:
+
+ - ${printedCalls}
+
+${printRemainingExpectations(expectations)}`);
+  }
+
+}
+class NestedWhen extends Error {
+  constructor(parentProp, childProp) {
+    const snippet = `
+const parentMock = mock<T1>();
+const childMock = mock<T2>();
+
+when(() => childMock${printProperty(childProp)}).thenReturn(...);
+when(() => parentMock${printProperty(parentProp)}).thenReturn(childMock)
+`;
+    super(`Setting an expectation on a nested property is not supported.
+
+You can return an object directly when the first property is accessed,
+or you can even return a separate mock:
+${snippet}`);
+  }
+
+}
+
+const createProxy = traps => // eslint-disable-next-line no-empty-function
+new Proxy(
+/* istanbul ignore next */
+() => {}, {
+  get: (target, prop) => {
+    if (prop === 'bind') {
+      return (thisArg, ...args) => (...moreArgs) => traps.apply([...args, ...moreArgs]);
+    }
+
+    if (prop === 'apply') {
+      return (thisArg, args) => traps.apply(args || []);
+    }
+
+    if (prop === 'call') {
+      return (thisArg, ...args) => traps.apply(args);
+    }
+
+    return traps.property(prop);
+  },
+  apply: (target, thisArg, args) => traps.apply(args),
+  ownKeys: () => traps.ownKeys(),
+
+  getOwnPropertyDescriptor(target, prop) {
+    const keys = traps.ownKeys();
+
+    if (keys.includes(prop)) {
+      return {
+        configurable: true,
+        enumerable: true
+      };
+    }
+
+    return undefined;
+  }
+
+});
 
 /**
- * Since `when()` doesn't receive the mock subject (because we can't make it
+ * Since `when` doesn't receive the mock subject (because we can't make it
  * consistently return it from `mock()`, `mock.foo` and `mock.bar()`) we need
  * to store a global state for the currently active mock.
  *
  * We also want to throw in the following case:
  *
  * ```
- * when(mock()) // forgot returns here
- * when(mock()) // should throw
+ * when(() => mock()) // forgot returns here
+ * when(() => mock()) // should throw
  * ```
  *
  * For that reason we can't just store the currently active mock, but also
  * whether we finished the expectation or not.
- */
-var activeMock;
-var setActiveMock = function (mock) {
-    activeMock = mock;
-};
-var getActiveMock = function () { return activeMock; };
+ */
+
+let activeMock;
+const setActiveMock = mock => {
+  activeMock = mock;
+};
+const getActiveMock = () => activeMock;
 /**
  * Store a global map of all mocks created and their state.
  *
- * This is needed because we can't reliably pass the state between `when`,
- * `thenReturn` and `instance`.
- */
-var mockMap = new Map();
-var getMockState = function (mock) {
-    if (mockMap.has(mock)) {
-        return mockMap.get(mock);
-    }
-    throw new NotAMock();
-};
-var setMockState = function (mock, state) {
-    mockMap.set(mock, state);
-};
-var getAllMocks = function () {
-    return Array.from(mockMap.entries());
-};
+ * This is needed because we can't reliably pass the state between `when`
+ * and `thenReturn`.
+ */
 
-var createProxy = function (traps) {
-    // eslint-disable-next-line no-empty-function
-    return new Proxy(/* istanbul ignore next */ function () { }, {
-        get: function (target, prop) {
-            if (prop === 'bind') {
-                return function (thisArg) {
-                    var args = [];
-                    for (var _i = 1; _i < arguments.length; _i++) {
-                        args[_i - 1] = arguments[_i];
-                    }
-                    return function () {
-                        var moreArgs = [];
-                        for (var _i = 0; _i < arguments.length; _i++) {
-                            moreArgs[_i] = arguments[_i];
-                        }
-                        return traps.apply(__spreadArray(__spreadArray([], __read(args), false), __read(moreArgs)));
-                    };
-                };
-            }
-            if (prop === 'apply') {
-                return function (thisArg, args) {
-                    return traps.apply(args || []);
-                };
-            }
-            if (prop === 'call') {
-                return function (thisArg) {
-                    var args = [];
-                    for (var _i = 1; _i < arguments.length; _i++) {
-                        args[_i - 1] = arguments[_i];
-                    }
-                    return traps.apply(args);
-                };
-            }
-            return traps.property(prop);
-        },
-        apply: function (target, thisArg, args) { return traps.apply(args); },
-        ownKeys: function () { return traps.ownKeys(); },
-        getOwnPropertyDescriptor: function (target, prop) {
-            var keys = traps.ownKeys();
-            if (keys.includes(prop)) {
-                return {
-                    configurable: true,
-                    enumerable: true,
-                };
-            }
-            return undefined;
-        },
-    });
+const mockMap = new Map();
+const getMockState = mock => {
+  if (mockMap.has(mock)) {
+    return mockMap.get(mock);
+  }
+
+  throw new NotAMock();
+};
+const setMockState = (mock, state) => {
+  mockMap.set(mock, state);
 };
+const getAllMocks = () => Array.from(mockMap.entries());
 
-// Keep a cache of all mock instances so that we can return a stable reference
-// if `instance` is used multiple times.
-var cache = new Map();
 /**
  * Return the expectation's return value.
  *
  * If the value is an error then throw it.
  *
  * If the value is a promise then resolve/reject it.
- */
-var returnOrThrow = function (_a) {
-    var isError = _a.isError, isPromise = _a.isPromise, value = _a.value;
-    if (isError) {
-        if (isPromise) {
-            return Promise.reject(value);
-        }
-        if (value instanceof Error) {
-            throw value;
-        }
-        throw new Error(value);
-    }
-    if (isPromise) {
-        return Promise.resolve(value);
-    }
-    return value;
-};
-/**
- * Get a real instance from the mock that you can pass to your code under test.
- */
-var instance = function (mock) {
-    if (cache.has(mock)) {
-        return cache.get(mock);
-    }
-    var repository = getMockState(mock).repository;
-    var proxy = createProxy({
-        property: function (property) { return returnOrThrow(repository.get(property)); },
-        apply: function (args) {
-            var fn = repository.get(ApplyProp);
-            // This is not using `returnOrThrow` because the repo will use it.
-            return fn.value.apply(fn, __spreadArray([], __read(args)));
-        },
-        ownKeys: function () { return repository.getAllProperties(); },
-    });
-    cache.set(mock, proxy);
-    return proxy;
+ */
+
+const returnOrThrow = ({
+  isError,
+  isPromise,
+  value
+}) => {
+  if (isError) {
+    if (isPromise) {
+      return Promise.reject(value);
+    }
+
+    if (value instanceof Error) {
+      throw value;
+    }
+
+    throw new Error(value);
+  }
+
+  if (isPromise) {
+    return Promise.resolve(value);
+  }
+
+  return value;
 };
+const createStub = (repo, pendingExpectation, isRecording = () => true) => {
+  const stub = createProxy({
+    property: property => {
+      if (!isRecording()) {
+        return returnOrThrow(repo.get(property));
+      }
+
+      setActiveMock(stub);
+      pendingExpectation.start(repo); // eslint-disable-next-line no-param-reassign
+
+      pendingExpectation.property = property;
+      return createProxy({
+        property: childProp => {
+          pendingExpectation.clear();
+          throw new NestedWhen(property, childProp);
+        },
+        apply: args => {
+          // eslint-disable-next-line no-param-reassign
+          pendingExpectation.args = args;
+        },
+        ownKeys: () => {
+          throw new Error('Spreading during an expectation is not supported.');
+        }
+      });
+    },
+    apply: args => {
+      if (!isRecording()) {
+        const fn = repo.get(ApplyProp); // This is not using `returnOrThrow` because the repo will use it.
+
+        return fn.value(...args);
+      }
+
+      setActiveMock(stub);
+      pendingExpectation.start(repo); // eslint-disable-next-line no-param-reassign
+
+      pendingExpectation.property = ApplyProp; // eslint-disable-next-line no-param-reassign
+
+      pendingExpectation.args = args;
+      return undefined;
+    },
+    ownKeys: () => {
+      if (!isRecording()) {
+        return repo.getAllProperties();
+      }
+
+      throw new Error('Spreading during an expectation is not supported.');
+    }
+  });
+  return stub;
+};
+
+class BaseRepository {
+  constructor() {
+    this.expectations = new Map();
+    this.expectedCallStats = new Map();
+    this.unexpectedCallStats = new Map();
+  }
+
+  add(expectation) {
+    const {
+      property
+    } = expectation;
+    const expectations = this.expectations.get(property) || [];
+    this.expectations.set(property, [...expectations, {
+      expectation,
+      matchCount: 0
+    }]);
+  }
+
+  clear() {
+    this.expectations.clear();
+    this.expectedCallStats.clear();
+    this.unexpectedCallStats.clear();
+  }
+
+  get(property) {
+    const expectations = this.expectations.get(property);
+
+    if (expectations && expectations.length) {
+      // We record that an expected property access has happened, but an
+      // unexpected call could still happen later.
+      this.recordExpected(property, undefined);
+      const propertyExpectation = expectations.find(e => e.expectation.matches(undefined));
 
-var BaseRepository = /** @class */ (function () {
-    function BaseRepository() {
-        this.expectations = new Map();
-        this.expectedCallStats = new Map();
-        this.unexpectedCallStats = new Map();
-    }
-    BaseRepository.prototype.add = function (expectation) {
-        var property = expectation.property;
-        var expectations = this.expectations.get(property) || [];
-        this.expectations.set(property, __spreadArray(__spreadArray([], __read(expectations), false), [
-            {
-                expectation: expectation,
-                matchCount: 0,
-            },
-        ]));
-    };
-    BaseRepository.prototype.clear = function () {
-        this.expectations.clear();
-        this.expectedCallStats.clear();
-        this.unexpectedCallStats.clear();
-    };
-    BaseRepository.prototype.get = function (property) {
-        var _this = this;
-        var expectations = this.expectations.get(property);
-        if (expectations && expectations.length) {
-            // We record that an expected property access has happened, but an
-            // unexpected call could still happen later.
-            this.recordExpected(property, undefined);
-            var propertyExpectation = expectations.find(function (e) {
-                return e.expectation.matches(undefined);
-            });
-            if (propertyExpectation) {
-                this.countAndConsume(propertyExpectation);
-                return propertyExpectation.expectation.returnValue;
-            }
-            return {
-                value: function () {
-                    var args = [];
-                    for (var _i = 0; _i < arguments.length; _i++) {
-                        args[_i] = arguments[_i];
-                    }
-                    var callExpectation = expectations.find(function (e) {
-                        return e.expectation.matches(args);
-                    });
-                    if (callExpectation) {
-                        _this.recordExpected(property, args);
-                        _this.countAndConsume(callExpectation);
-                        // TODO: this is duplicated in instance
-                        return returnOrThrow(callExpectation.expectation.returnValue);
-                    }
-                    _this.recordUnexpected(property, args);
-                    return _this.getValueForUnexpectedCall(property, args);
-                },
-            };
-        }
-        switch (property) {
-            case 'toString':
-                return { value: function () { return 'mock'; } };
-            case '@@toStringTag':
-            case Symbol.toStringTag:
-            case 'name':
-                return { value: 'mock' };
-            // pretty-format
-            case '$$typeof':
-            case 'constructor':
-            case '@@__IMMUTABLE_ITERABLE__@@':
-            case '@@__IMMUTABLE_RECORD__@@':
-                return { value: null };
-            case MATCHER_SYMBOL:
-                return { value: false };
-            case ApplyProp:
-                return {
-                    value: function () {
-                        var args = [];
-                        for (var _i = 0; _i < arguments.length; _i++) {
-                            args[_i] = arguments[_i];
-                        }
-                        _this.recordUnexpected(property, args);
-                        return _this.getValueForUnexpectedCall(property, args);
-                    },
-                };
-            default:
-                this.recordUnexpected(property, undefined);
-                return this.getValueForUnexpectedAccess(property);
-        }
-    };
-    BaseRepository.prototype.getAllProperties = function () {
-        return Array.from(this.expectations.keys());
-    };
-    BaseRepository.prototype.getCallStats = function () {
-        return {
-            expected: this.expectedCallStats,
-            unexpected: this.unexpectedCallStats,
-        };
-    };
-    BaseRepository.prototype.getUnmet = function () {
-        var _a;
-        return (_a = []).concat.apply(_a, __spreadArray([], __read(Array.from(this.expectations.values()).map(function (expectations) {
-            return expectations
-                .filter(function (e) { return e.expectation.min > e.matchCount; })
-                .map(function (e) { return e.expectation; });
-        }))));
-    };
-    /**
-     * Record an expected property access/method call.
-     */
-    BaseRepository.prototype.recordExpected = function (property, args) {
-        var calls = this.expectedCallStats.get(property) || [];
-        this.expectedCallStats.set(property, __spreadArray(__spreadArray([], __read(calls), false), [{ arguments: args }]));
-    };
-    /**
-     * Record an unexpected property access/method call.
-     */
-    BaseRepository.prototype.recordUnexpected = function (property, args) {
-        var calls = this.unexpectedCallStats.get(property) || [];
-        this.unexpectedCallStats.set(property, __spreadArray(__spreadArray([], __read(calls), false), [{ arguments: args }]));
-    };
-    BaseRepository.prototype.countAndConsume = function (expectation) {
-        // eslint-disable-next-line no-param-reassign
-        expectation.matchCount++;
-        this.consumeExpectation(expectation);
-    };
-    return BaseRepository;
-}());
+      if (propertyExpectation) {
+        this.countAndConsume(propertyExpectation);
+        return propertyExpectation.expectation.returnValue;
+      }
+
+      return {
+        value: (...args) => {
+          const callExpectation = expectations.find(e => e.expectation.matches(args));
+
+          if (callExpectation) {
+            this.recordExpected(property, args);
+            this.countAndConsume(callExpectation); // TODO: this is duplicated in stub
+
+            return returnOrThrow(callExpectation.expectation.returnValue);
+          }
+
+          this.recordUnexpected(property, args);
+          return this.getValueForUnexpectedCall(property, args);
+        }
+      };
+    }
+
+    switch (property) {
+      case 'toString':
+        return {
+          value: () => 'mock'
+        };
+
+      case '@@toStringTag':
+      case Symbol.toStringTag:
+      case 'name':
+        return {
+          value: 'mock'
+        };
+      // pretty-format
+
+      case '$$typeof':
+      case 'constructor':
+      case '@@__IMMUTABLE_ITERABLE__@@':
+      case '@@__IMMUTABLE_RECORD__@@':
+        return {
+          value: null
+        };
+
+      case MATCHER_SYMBOL:
+        return {
+          value: false
+        };
+
+      case ApplyProp:
+        return {
+          value: (...args) => {
+            this.recordUnexpected(property, args);
+            return this.getValueForUnexpectedCall(property, args);
+          }
+        };
+
+      default:
+        this.recordUnexpected(property, undefined);
+        return this.getValueForUnexpectedAccess(property);
+    }
+  }
+
+  getAllProperties() {
+    return Array.from(this.expectations.keys());
+  }
+
+  getCallStats() {
+    return {
+      expected: this.expectedCallStats,
+      unexpected: this.unexpectedCallStats
+    };
+  }
+
+  getUnmet() {
+    return [].concat(...Array.from(this.expectations.values()).map(expectations => expectations.filter(e => e.expectation.min > e.matchCount).map(e => e.expectation)));
+  }
+  /**
+   * Record an expected property access/method call.
+   */
+
+
+  recordExpected(property, args) {
+    const calls = this.expectedCallStats.get(property) || [];
+    this.expectedCallStats.set(property, [...calls, {
+      arguments: args
+    }]);
+  }
+  /**
+   * Record an unexpected property access/method call.
+   */
+
+
+  recordUnexpected(property, args) {
+    const calls = this.unexpectedCallStats.get(property) || [];
+    this.unexpectedCallStats.set(property, [...calls, {
+      arguments: args
+    }]);
+  }
+
+  countAndConsume(expectation) {
+    // eslint-disable-next-line no-param-reassign
+    expectation.matchCount++;
+    this.consumeExpectation(expectation);
+  }
+
+}
 
 /**
  * Throw if no expectation matches.
- */
-var StrongRepository = /** @class */ (function (_super) {
-    __extends(StrongRepository, _super);
-    function StrongRepository() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    StrongRepository.prototype.consumeExpectation = function (expectation) {
-        var _a = expectation.expectation, property = _a.property, max = _a.max;
-        var expectations = this.expectations.get(property);
-        if (expectation.matchCount === max) {
-            this.expectations.set(property, expectations.filter(function (e) { return e !== expectation; }));
-        }
-    };
-    StrongRepository.prototype.getValueForUnexpectedCall = function (property, args) {
-        throw new UnexpectedCall(property, args, this.getUnmet());
-    };
-    StrongRepository.prototype.getValueForUnexpectedAccess = function (property) {
-        throw new UnexpectedAccess(property, this.getUnmet());
-    };
-    return StrongRepository;
-}(BaseRepository));
+ */
+
+class StrongRepository extends BaseRepository {
+  consumeExpectation(expectation) {
+    const {
+      property,
+      max
+    } = expectation.expectation;
+    const expectations = this.expectations.get(property);
+
+    if (expectation.matchCount === max) {
+      this.expectations.set(property, expectations.filter(e => e !== expectation));
+    }
+  }
+
+  getValueForUnexpectedCall(property, args) {
+    throw new UnexpectedCall(property, args, this.getUnmet());
+  }
+
+  getValueForUnexpectedAccess(property) {
+    throw new UnexpectedAccess(property, this.getUnmet());
+  }
+
+}
 
 /**
  * Matches a call with more parameters than expected because it is assumed the
@@ -522,91 +506,125 @@ var StrongRepository = /** @class */ (function (_super) {
  *   deepEquals([1, 2, 3]),
  *   23
  * ).matches('bar', [1, 2, 3]) === true;
- */
-var StrongExpectation = /** @class */ (function () {
-    function StrongExpectation(property, args, returnValue) {
-        this.property = property;
-        this.args = args;
-        this.returnValue = returnValue;
-        this.matched = 0;
-        this.min = 1;
-        this.max = 1;
-    }
-    StrongExpectation.prototype.setInvocationCount = function (min, max) {
-        if (max === void 0) { max = 1; }
-        this.min = min;
-        this.max = max;
-    };
-    StrongExpectation.prototype.matches = function (args) {
-        if (!this.matchesArgs(args)) {
-            return false;
-        }
-        this.matched++;
-        return this.max === 0 || this.matched <= this.max;
-    };
-    StrongExpectation.prototype.isUnmet = function () {
-        return this.matched < this.min;
-    };
-    StrongExpectation.prototype.matchesArgs = function (received) {
-        if (this.args === undefined) {
-            return !received;
-        }
-        if (!received) {
-            return false;
-        }
-        return this.args.every(function (arg, i) { return arg.matches(received[i]); });
-    };
-    StrongExpectation.prototype.toJSON = function () {
-        return printExpectation(this.property, this.args, this.returnValue, this.min, this.max);
-    };
-    return StrongExpectation;
-}());
-
-var RepoSideEffectPendingExpectation = /** @class */ (function () {
-    function RepoSideEffectPendingExpectation(createExpectation) {
-        this.createExpectation = createExpectation;
-        this._property = '';
-    }
-    RepoSideEffectPendingExpectation.prototype.start = function (repo) {
-        if (this._repo) {
-            throw new UnfinishedExpectation(this);
-        }
-        this.clear();
-        this._repo = repo;
-    };
-    Object.defineProperty(RepoSideEffectPendingExpectation.prototype, "property", {
-        set: function (value) {
-            this._property = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RepoSideEffectPendingExpectation.prototype, "args", {
-        set: function (value) {
-            this._args = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    RepoSideEffectPendingExpectation.prototype.finish = function (returnValue) {
-        if (!this._repo) {
-            throw new MissingWhen();
-        }
-        var expectation = this.createExpectation(this._property, this._args, returnValue);
-        this._repo.add(expectation);
-        this.clear();
-        return expectation;
-    };
-    RepoSideEffectPendingExpectation.prototype.clear = function () {
-        this._repo = undefined;
-        this._args = undefined;
-        this._property = '';
-    };
-    RepoSideEffectPendingExpectation.prototype.toJSON = function () {
-        return printWhen(this._property, this._args);
-    };
-    return RepoSideEffectPendingExpectation;
-}());
+ */
+
+class StrongExpectation {
+  constructor(property, args, returnValue) {
+    this.property = void 0;
+    this.args = void 0;
+    this.returnValue = void 0;
+    this.matched = 0;
+    this.min = 1;
+    this.max = 1;
+    this.property = property;
+    this.args = args;
+    this.returnValue = returnValue;
+  }
+
+  setInvocationCount(min, max = 1) {
+    this.min = min;
+    this.max = max;
+  }
+
+  matches(args) {
+    if (!this.matchesArgs(args)) {
+      return false;
+    }
+
+    this.matched++;
+    return this.max === 0 || this.matched <= this.max;
+  }
+
+  isUnmet() {
+    return this.matched < this.min;
+  }
+
+  matchesArgs(received) {
+    if (this.args === undefined) {
+      return !received;
+    }
+
+    if (!received) {
+      return false;
+    }
+
+    return this.args.every((arg, i) => arg.matches(received[i]));
+  }
+
+  toJSON() {
+    return printExpectation(this.property, this.args, this.returnValue, this.min, this.max);
+  }
+
+}
+
+class RepoSideEffectPendingExpectation {
+  constructor(createExpectation) {
+    this.createExpectation = void 0;
+    this._repo = void 0;
+    this._args = void 0;
+    this._property = '';
+    this.createExpectation = createExpectation;
+  }
+
+  start(repo) {
+    if (this._repo) {
+      throw new UnfinishedExpectation(this);
+    }
+
+    this.clear();
+    this._repo = repo;
+  }
+
+  set property(value) {
+    this._property = value;
+  }
+
+  set args(value) {
+    this._args = value;
+  }
+
+  finish(returnValue) {
+    if (!this._repo) {
+      throw new MissingWhen();
+    }
+
+    const expectation = this.createExpectation(this._property, this._args, returnValue);
+
+    this._repo.add(expectation);
+
+    this.clear();
+    return expectation;
+  }
+
+  clear() {
+    this._repo = undefined;
+    this._args = undefined;
+    this._property = '';
+  }
+
+  toJSON() {
+    return printWhen(this._property, this._args);
+  }
+
+}
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
 
 /**
  * Match a custom predicate.
@@ -618,30 +636,34 @@ var RepoSideEffectPendingExpectation = /** @class */ (function () {
  *
  * @example
  * const fn = mock<(x: number) => number>();
- * when(fn(It.matches(x => x >= 0))).returns(42);
+ * when(() => fn(It.matches(x => x >= 0))).returns(42);
  *
- * instance(fn)(2) === 42
- * instance(fn)(-1) // throws
- */
-var matches = function (cb, _a) {
-    var _b;
-    var _c = _a === void 0 ? {} : _a, _d = _c.toJSON, toJSON = _d === void 0 ? function () { return "matches(" + cb.toString() + ")"; } : _d;
-    var matcher = (_b = {},
-        _b[MATCHER_SYMBOL] = true,
-        _b.matches = function (arg) { return cb(arg); },
-        _b.toJSON = toJSON,
-        _b);
-    return matcher;
-};
-var removeUndefined = function (object) {
-    if (Array.isArray(object)) {
-        return object.map(function (x) { return removeUndefined(x); });
-    }
-    if (!lodash.isObjectLike(object)) {
-        return object;
-    }
-    return lodash.omitBy(object, lodash.isUndefined);
-};
+ * fn(2) === 42
+ * fn(-1) // throws
+ */
+
+const matches = (cb, {
+  toJSON = () => `matches(${cb.toString()})`
+} = {}) => {
+  const matcher = {
+    [MATCHER_SYMBOL]: true,
+    matches: arg => cb(arg),
+    toJSON
+  };
+  return matcher;
+};
+
+const removeUndefined = object => {
+  if (Array.isArray(object)) {
+    return object.map(x => removeUndefined(x));
+  }
+
+  if (!lodash.isObjectLike(object)) {
+    return object;
+  }
+
+  return lodash.omitBy(object, lodash.isUndefined);
+};
 /**
  * Compare values using deep equality.
  *
@@ -652,40 +674,46 @@ var removeUndefined = function (object) {
  *   this to `false` will consider the objects in both cases as equal.
  *
  * @see It.is A matcher that uses strict equality.
- */
-var deepEquals = function (expected, _a) {
-    var _b = _a === void 0 ? {} : _a, _c = _b.strict, strict = _c === void 0 ? true : _c;
-    return matches(function (actual) {
-        if (strict) {
-            return lodash.isEqual(actual, expected);
-        }
-        return lodash.isEqual(removeUndefined(actual), removeUndefined(expected));
-    }, { toJSON: function () { return printArg(expected); } });
-};
+ */
+
+
+const deepEquals = (expected, {
+  strict = true
+} = {}) => matches(actual => {
+  if (strict) {
+    return lodash.isEqual(actual, expected);
+  }
+
+  return lodash.isEqual(removeUndefined(actual), removeUndefined(expected));
+}, {
+  toJSON: () => printArg(expected)
+});
 /**
  * Compare values using `Object.is`.
  *
  * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
  *
  * @see It.deepEquals A matcher that uses deep equality.
- */
-var is = function (expected) {
-    return matches(function (actual) { return Object.is(actual, expected); }, {
-        toJSON: function () { return "" + jestMatcherUtils.printExpected(expected); },
-    });
-};
+ */
+
+
+const is = expected => matches(actual => Object.is(actual, expected), {
+  toJSON: () => `${jestMatcherUtils.printExpected(expected)}`
+});
 /**
  * Match any value, including `undefined` and `null`.
  *
  * @example
  * const fn = mock<(x: number, y: string) => number>();
- * when(fn(It.isAny(), It.isAny())).thenReturn(1);
+ * when(() => fn(It.isAny(), It.isAny())).thenReturn(1);
  *
- * instance(fn)(23, 'foobar') === 1
- */
-var isAny = function () {
-    return matches(function () { return true; }, { toJSON: function () { return 'anything'; } });
-};
+ * fn(23, 'foobar') === 1
+ */
+
+
+const isAny = () => matches(() => true, {
+  toJSON: () => 'anything'
+});
 /**
  * Recursively match an object.
  *
@@ -695,40 +723,41 @@ var isAny = function () {
  *
  * @example
  * const fn = mock<(foo: { x: number, y: number }) => number>();
- * when(fn(It.isObject({ x: 23 }))).returns(42);
+ * when(() => fn(It.isObject({ x: 23 }))).returns(42);
  *
- * instance(fn)({ x: 100, y: 200 }) // throws
- * instance(fn)({ x: 23, y: 200 }) // returns 42
+ * fn({ x: 100, y: 200 }) // throws
+ * fn({ x: 23, y: 200 }) // returns 42
  *
  * @example
  * It.isObject({ foo: It.isString() })
- */
-var isObject = function (partial) {
-    return matches(function (actual) {
-        return lodash.isMatchWith(actual, partial || {}, function (argValue, partialValue) {
-            if (isMatcher(partialValue)) {
-                return partialValue.matches(argValue);
-            }
-            // Let lodash handle it otherwise.
-            return undefined;
-        });
-    }, { toJSON: function () { return (partial ? "object(" + jestMatcherUtils.printExpected(partial) + ")" : 'object'); } });
-};
+ */
+
+
+const isObject = partial => matches(actual => lodash.isMatchWith(actual, partial || {}, (argValue, partialValue) => {
+  if (isMatcher(partialValue)) {
+    return partialValue.matches(argValue);
+  } // Let lodash handle it otherwise.
+
+
+  return undefined;
+}), {
+  toJSON: () => partial ? `object(${jestMatcherUtils.printExpected(partial)})` : 'object'
+});
 /**
  * Match any number.
  *
  * @example
  * const fn = mock<(x: number) => number>();
- * when(fn(It.isNumber())).returns(42);
+ * when(() => fn(It.isNumber())).returns(42);
  *
- * instance(fn)(20.5) === 42
- * instance(fn)(NaN) // throws
- */
-var isNumber = function () {
-    return matches(function (actual) { return typeof actual === 'number' && !Number.isNaN(actual); }, {
-        toJSON: function () { return 'number'; },
-    });
-};
+ * fn(20.5) === 42
+ * fn(NaN) // throws
+ */
+
+
+const isNumber = () => matches(actual => typeof actual === 'number' && !Number.isNaN(actual), {
+  toJSON: () => 'number'
+});
 /**
  * Match a string, potentially by a pattern.
  *
@@ -737,33 +766,37 @@ var isNumber = function () {
  *
  * @example
  * const fn = mock<(x: string, y: string) => number>();
- * when(fn(It.isString(), It.isString({ containing: 'bar' }))).returns(42);
+ * when(() => fn(It.isString(), It.isString({ containing: 'bar' }))).returns(42);
  *
- * instance(fn)('foo', 'baz') // throws
- * instance(fn)('foo', 'bar') === 42
- */
-var isString = function (_a) {
-    var _b = _a === void 0 ? {} : _a, matching = _b.matching, containing = _b.containing;
-    if (matching && containing) {
-        throw new Error('You can only pass `matching` or `containing`, not both.');
-    }
-    return matches(function (actual) {
-        var _a;
-        if (typeof actual !== 'string') {
-            return false;
-        }
-        if (containing) {
-            return actual.indexOf(containing) !== -1;
-        }
-        return (_a = matching === null || matching === void 0 ? void 0 : matching.test(actual)) !== null && _a !== void 0 ? _a : true;
-    }, {
-        toJSON: function () {
-            return containing || matching
-                ? "string(" + jestMatcherUtils.printExpected(containing || matching) + ")"
-                : 'string';
-        },
-    });
-};
+ * fn('foo', 'baz') // throws
+ * fn('foo', 'bar') === 42
+ */
+
+
+const isString = ({
+  matching,
+  containing
+} = {}) => {
+  if (matching && containing) {
+    throw new Error('You can only pass `matching` or `containing`, not both.');
+  }
+
+  return matches(actual => {
+    var _matching$test;
+
+    if (typeof actual !== 'string') {
+      return false;
+    }
+
+    if (containing) {
+      return actual.indexOf(containing) !== -1;
+    }
+
+    return (_matching$test = matching == null ? void 0 : matching.test(actual)) != null ? _matching$test : true;
+  }, {
+    toJSON: () => containing || matching ? `string(${jestMatcherUtils.printExpected(containing || matching)})` : 'string'
+  });
+};
 /**
  * Match an array.
  *
@@ -774,38 +807,37 @@ var isString = function (_a) {
  *
  * @example
  * const fn = mock<(arr: number[]) => number>();
- * when(fn(It.isArray())).thenReturn(1);
- * when(fn(It.isArray([2, 3]))).thenReturn(2);
+ * when(() => fn(It.isArray())).thenReturn(1);
+ * when(() => fn(It.isArray([2, 3]))).thenReturn(2);
  *
- * instance(fn)({ length: 1, 0: 42 }) // throws
- * instance(fn)([]) === 1
- * instance(fn)([3, 2, 1]) === 2
+ * fn({ length: 1, 0: 42 }) // throws
+ * fn([]) === 1
+ * fn([3, 2, 1]) === 2
  *
  * @example
  * It.isArray([It.isString({ containing: 'foobar' })])
- */
-var isArray = function (containing) {
-    return matches(function (actual) {
-        if (!Array.isArray(actual)) {
-            return false;
-        }
-        if (!containing) {
-            return true;
-        }
-        return containing.every(function (x) {
-            return actual.find(function (y) {
-                if (isMatcher(x)) {
-                    return x.matches(y);
-                }
-                return deepEquals(x).matches(y);
-            }) !== undefined;
-        });
-    }, {
-        toJSON: function () {
-            return containing ? "array(" + jestMatcherUtils.printExpected(containing) + ")" : 'array';
-        },
-    });
-};
+ */
+
+
+const isArray = containing => matches(actual => {
+  if (!Array.isArray(actual)) {
+    return false;
+  }
+
+  if (!containing) {
+    return true;
+  }
+
+  return containing.every(x => actual.find(y => {
+    if (isMatcher(x)) {
+      return x.matches(y);
+    }
+
+    return deepEquals(x).matches(y);
+  }) !== undefined);
+}, {
+  toJSON: () => containing ? `array(${jestMatcherUtils.printExpected(containing)})` : 'array'
+});
 /**
  * Matches anything and stores the received value.
  *
@@ -818,208 +850,196 @@ var isArray = function (containing) {
  * @example
  * const fn = mock<(cb: (value: number) => number) => void>();
  * const matcher = It.willCapture();
- * when(fn(matcher)).thenReturn();
+ * when(() => fn(matcher)).thenReturn();
  *
- * instance(fn)(x => x + 1);
+ * fn(x => x + 1);
  * matcher.value?.(3) === 4
- */
-var willCapture = function (name) {
-    var _a;
-    var capturedValue;
-    var matcher = (_a = {},
-        _a[MATCHER_SYMBOL] = true,
-        _a.matches = function (actual) {
-            capturedValue = actual;
-            return true;
-        },
-        _a.toJSON = function () { return name !== null && name !== void 0 ? name : 'captures'; },
-        Object.defineProperty(_a, "value", {
-            get: function () {
-                return capturedValue;
-            },
-            enumerable: false,
-            configurable: true
-        }),
-        _a);
-    return matcher;
-};
+ */
+
+
+const willCapture = name => {
+  let capturedValue;
+  const matcher = {
+    [MATCHER_SYMBOL]: true,
+    matches: actual => {
+      capturedValue = actual;
+      return true;
+    },
+    toJSON: () => name != null ? name : 'captures',
+
+    get value() {
+      return capturedValue;
+    }
+
+  };
+  return matcher;
+};
 /**
  * Contains argument matchers that can be used to ignore arguments in an
  * expectation or to match complex arguments.
- */
-var It = {
-    matches: matches,
-    deepEquals: deepEquals,
-    is: is,
-    isAny: isAny,
-    isObject: isObject,
-    isNumber: isNumber,
-    isString: isString,
-    isArray: isArray,
-    willCapture: willCapture,
+ */
+
+
+const It = {
+  matches,
+  deepEquals,
+  is,
+  isAny,
+  isObject,
+  isNumber,
+  isString,
+  isArray,
+  willCapture
 };
 
-var defaults = {
-    matcher: It.deepEquals,
-};
-var currentDefaults = defaults;
+const defaults = {
+  matcher: It.deepEquals
+};
+let currentDefaults = defaults;
 /**
  * Override strong-mock's defaults.
  *
  * @param newDefaults These will be applied to the library defaults. Multiple
  *   calls don't stack e.g. calling this with `{}` will clear any previously
  *   applied defaults.
- */
-var setDefaults = function (newDefaults) {
-    currentDefaults = __assign(__assign({}, defaults), newDefaults);
-};
+ */
 
-var createStub = function (repo, pendingExpectation) {
-    var stub = createProxy({
-        property: function (property) {
-            setActiveMock(stub);
-            pendingExpectation.start(repo);
-            // eslint-disable-next-line no-param-reassign
-            pendingExpectation.property = property;
-            return createProxy({
-                property: function (childProp) {
-                    pendingExpectation.clear();
-                    throw new NestedWhen(property, childProp);
-                },
-                apply: function (args) {
-                    // eslint-disable-next-line no-param-reassign
-                    pendingExpectation.args = args;
-                },
-                ownKeys: function () {
-                    throw new Error('Spreading during an expectation is not supported.');
-                },
-            });
-        },
-        apply: function (args) {
-            setActiveMock(stub);
-            pendingExpectation.start(repo);
-            // eslint-disable-next-line no-param-reassign
-            pendingExpectation.property = ApplyProp;
-            // eslint-disable-next-line no-param-reassign
-            pendingExpectation.args = args;
-        },
-        ownKeys: function () {
-            throw new Error('Spreading during an expectation is not supported.');
-        },
-    });
-    return stub;
+const setDefaults = newDefaults => {
+  currentDefaults = _extends({}, defaults, newDefaults);
 };
 
-var strongExpectationFactory = function (property, args, returnValue) {
-    return new StrongExpectation(property, 
-    // Wrap every non-matcher in the default matcher.
-    args === null || args === void 0 ? void 0 : args.map(function (arg) { return (isMatcher(arg) ? arg : currentDefaults.matcher(arg)); }), returnValue);
-};
+const strongExpectationFactory = (property, args, returnValue) => new StrongExpectation(property, // Wrap every non-matcher in the default matcher.
+args == null ? void 0 : args.map(arg => isMatcher(arg) ? arg : currentDefaults.matcher(arg)), returnValue);
+
+let isRecording = false;
+const setRecording = recording => {
+  isRecording = recording;
+};
 /**
  * Create a type safe mock.
  *
- * Set expectations on the mock using `when` and `thenReturn` and get an
- * instance from the mock using `instance`.
+ * @see {@link when} Set expectations on the mock using `when`.
  *
  * @example
  * const fn = mock<() => number>();
  *
- * when(fn()).thenReturn(23);
+ * when(() => fn()).thenReturn(23);
  *
- * instance(fn) === 23;
- */
-var mock = function (_a) {
-    var _b = _a === void 0 ? {} : _a, _c = _b.repository, repository = _c === void 0 ? new StrongRepository() : _c, _d = _b.expectationFactory, expectationFactory = _d === void 0 ? strongExpectationFactory : _d;
-    var pendingExpectation = new RepoSideEffectPendingExpectation(expectationFactory);
-    var stub = createStub(repository, pendingExpectation);
-    setMockState(stub, { repository: repository, pendingExpectation: pendingExpectation });
-    return stub;
+ * fn() === 23;
+ */
+
+const mock = ({
+  repository = new StrongRepository(),
+  expectationFactory = strongExpectationFactory
+} = {}) => {
+  const pendingExpectation = new RepoSideEffectPendingExpectation(expectationFactory);
+  const stub = createStub(repository, pendingExpectation, () => isRecording);
+  setMockState(stub, {
+    repository,
+    pendingExpectation
+  });
+  return stub;
 };
 
-var createInvocationCount = function (expectation) { return ({
-    between: function (min, max) {
-        expectation.setInvocationCount(min, max);
-    },
-    /* istanbul ignore next */
-    times: function (exact) {
-        expectation.setInvocationCount(exact, exact);
-    },
-    /* istanbul ignore next */
-    anyTimes: function () {
-        expectation.setInvocationCount(0, 0);
-    },
-    /* istanbul ignore next */
-    atLeast: function (min) {
-        expectation.setInvocationCount(min, Infinity);
-    },
-    /* istanbul ignore next */
-    atMost: function (max) {
-        expectation.setInvocationCount(0, max);
-    },
-    /* istanbul ignore next */
-    once: function () {
-        expectation.setInvocationCount(1, 1);
-    },
-    /* istanbul ignore next */
-    twice: function () {
-        expectation.setInvocationCount(2, 2);
-    },
-    /* eslint-enable no-param-reassign, no-multi-assign */
-}); };
+const createInvocationCount = expectation => ({
+  between(min, max) {
+    expectation.setInvocationCount(min, max);
+  },
+
+  /* istanbul ignore next */
+  times(exact) {
+    expectation.setInvocationCount(exact, exact);
+  },
+
+  /* istanbul ignore next */
+  anyTimes() {
+    expectation.setInvocationCount(0, 0);
+  },
+
+  /* istanbul ignore next */
+  atLeast(min) {
+    expectation.setInvocationCount(min, Infinity);
+  },
+
+  /* istanbul ignore next */
+  atMost(max) {
+    expectation.setInvocationCount(0, max);
+  },
+
+  /* istanbul ignore next */
+  once() {
+    expectation.setInvocationCount(1, 1);
+  },
+
+  /* istanbul ignore next */
+  twice() {
+    expectation.setInvocationCount(2, 2);
+  }
+  /* eslint-enable no-param-reassign, no-multi-assign */
+
+
+});
 
 /**
  * Set a return value for the currently pending expectation.
- */
-var finishPendingExpectation = function (returnValue, pendingExpectation) {
-    var finishedExpectation = pendingExpectation.finish(returnValue);
-    pendingExpectation.clear();
-    return createInvocationCount(finishedExpectation);
-};
-var getError = function (errorOrMessage) {
-    if (typeof errorOrMessage === 'string') {
-        return new Error(errorOrMessage);
-    }
-    if (errorOrMessage instanceof Error) {
-        return errorOrMessage;
-    }
-    return new Error();
-};
-var createReturns = function (pendingExpectation) {
-    var nonPromiseStub = {
-        // TODO: merge this with the promise version
-        thenReturn: /* istanbul ignore next: because this is overwritten by the promise version */ function (returnValue) {
-            return finishPendingExpectation({ value: returnValue, isError: false, isPromise: false }, pendingExpectation);
-        },
-        thenThrow: function (errorOrMessage) {
-            return finishPendingExpectation({ value: getError(errorOrMessage), isError: true, isPromise: false }, pendingExpectation);
-        },
-    };
-    var promiseStub = {
-        thenReturn: function (promise) {
-            return finishPendingExpectation({
-                value: promise,
-                isError: false,
-                // We're setting this to false because we can't distinguish between a
-                // promise thenReturn and a normal thenReturn.
-                isPromise: false,
-            }, pendingExpectation);
-        },
-        thenResolve: function (promiseValue) {
-            return finishPendingExpectation({
-                value: promiseValue,
-                isError: false,
-                isPromise: true,
-            }, pendingExpectation);
-        },
-        thenReject: function (errorOrMessage) {
-            return finishPendingExpectation({
-                value: getError(errorOrMessage),
-                isError: true,
-                isPromise: true,
-            }, pendingExpectation);
-        },
-    };
-    return __assign(__assign({}, nonPromiseStub), promiseStub);
+ */
+
+const finishPendingExpectation = (returnValue, pendingExpectation) => {
+  const finishedExpectation = pendingExpectation.finish(returnValue);
+  pendingExpectation.clear();
+  return createInvocationCount(finishedExpectation);
+};
+
+const getError = errorOrMessage => {
+  if (typeof errorOrMessage === 'string') {
+    return new Error(errorOrMessage);
+  }
+
+  if (errorOrMessage instanceof Error) {
+    return errorOrMessage;
+  }
+
+  return new Error();
+};
+
+const createReturns = pendingExpectation => {
+  const nonPromiseStub = {
+    // TODO: merge this with the promise version
+    thenReturn:
+    /* istanbul ignore next: because this is overwritten by the promise version */
+    returnValue => finishPendingExpectation({
+      value: returnValue,
+      isError: false,
+      isPromise: false
+    }, pendingExpectation),
+    thenThrow: errorOrMessage => finishPendingExpectation({
+      value: getError(errorOrMessage),
+      isError: true,
+      isPromise: false
+    }, pendingExpectation)
+  };
+  const promiseStub = {
+    thenReturn: promise => finishPendingExpectation({
+      value: promise,
+      isError: false,
+      // We're setting this to false because we can't distinguish between a
+      // promise thenReturn and a normal thenReturn.
+      isPromise: false
+    }, pendingExpectation),
+    thenResolve: promiseValue => finishPendingExpectation({
+      value: promiseValue,
+      isError: false,
+      isPromise: true
+    }, pendingExpectation),
+    thenReject: errorOrMessage => finishPendingExpectation({
+      value: getError(errorOrMessage),
+      isError: true,
+      isPromise: true
+    }, pendingExpectation)
+  }; // @ts-expect-error because the return type is a conditional, and we're merging
+  // both branches here
+
+  return _extends({}, nonPromiseStub, promiseStub);
 };
 
 /**
@@ -1032,23 +1052,28 @@ var createReturns = function (pendingExpectation) {
  * By default, the call is expected to only be made once. Use the invocation
  * count helpers to expect a call multiple times.
  *
- * @param expectedCall Make a "real" call using the value returned by `mock()`.
+ * @param expectation A callback to set the expectation on your mock. The
+ *   callback must return the value from the mock to properly infer types.
  *
  * @example
  * const fn = mock<() => void>();
- * when(fn()).thenReturn(undefined);
+ * when(() => fn()).thenReturn(undefined);
  *
  * @example
  * const fn = mock<() => number>();
- * when(fn()).thenReturn(42).atMost(3);
+ * when(() => fn()).thenReturn(42).atMost(3);
  *
  * @example
  * const fn = mock<(x: number) => Promise<number>();
- * when(fn(23)).thenResolve(42);
- */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars,no-unused-vars
-var when = function (expectedCall) {
-    return createReturns(getMockState(getActiveMock()).pendingExpectation);
+ * when(() => fn(23)).thenResolve(42);
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars,no-unused-vars
+
+const when = expectation => {
+  setRecording(true);
+  expectation();
+  setRecording(false);
+  return createReturns(getMockState(getActiveMock()).pendingExpectation);
 };
 
 /**
@@ -1057,37 +1082,41 @@ var when = function (expectedCall) {
  * @example
  * const fn = mock<() => number>();
  *
- * when(fn()).thenReturn(23);
+ * when(() => fn()).thenReturn(23);
  *
  * reset(fn);
  *
- * instance(fn)(); // throws
- */
-var reset = function (mock) {
-    getMockState(mock).repository.clear();
-};
+ * fn(); // throws
+ */
+
+const reset = mock => {
+  getMockState(mock).repository.clear();
+};
 /**
  * Reset all existing mocks.
  *
  * @see reset
- */
-var resetAll = function () {
-    getAllMocks().forEach(function (_a) {
-        var _b = __read(_a, 1), mock = _b[0];
-        reset(mock);
-    });
+ */
+
+const resetAll = () => {
+  getAllMocks().forEach(([mock]) => {
+    reset(mock);
+  });
 };
 
-var verifyRepo = function (repository) {
-    var unmetExpectations = repository.getUnmet();
-    if (unmetExpectations.length) {
-        throw new UnmetExpectations(unmetExpectations);
-    }
-    var callStats = repository.getCallStats();
-    if (callStats.unexpected.size) {
-        throw new UnexpectedCalls(callStats.unexpected, unmetExpectations);
-    }
-};
+const verifyRepo = repository => {
+  const unmetExpectations = repository.getUnmet();
+
+  if (unmetExpectations.length) {
+    throw new UnmetExpectations(unmetExpectations);
+  }
+
+  const callStats = repository.getCallStats();
+
+  if (callStats.unexpected.size) {
+    throw new UnexpectedCalls(callStats.unexpected, unmetExpectations);
+  }
+};
 /**
  * Verify that all expectations on the given mock have been met.
  *
@@ -1101,28 +1130,30 @@ var verifyRepo = function (repository) {
  * @example
  * const fn = mock<() => number>();
  *
- * when(fn()).thenReturn(23);
+ * when(() => fn()).thenReturn(23);
  *
  * verify(fn); // throws
- */
-var verify = function (mock) {
-    var repository = getMockState(mock).repository;
-    verifyRepo(repository);
-};
+ */
+
+const verify = mock => {
+  const {
+    repository
+  } = getMockState(mock);
+  verifyRepo(repository);
+};
 /**
  * Verify all existing mocks.
  *
  * @see verify
- */
-var verifyAll = function () {
-    getAllMocks().forEach(function (_a) {
-        var _b = __read(_a, 1), mock = _b[0];
-        verify(mock);
-    });
+ */
+
+const verifyAll = () => {
+  getAllMocks().forEach(([mock]) => {
+    verify(mock);
+  });
 };
 
 exports.It = It;
-exports.instance = instance;
 exports.mock = mock;
 exports.reset = reset;
 exports.resetAll = resetAll;
@@ -1130,3 +1161,4 @@ exports.setDefaults = setDefaults;
 exports.verify = verify;
 exports.verifyAll = verifyAll;
 exports.when = when;
+//# sourceMappingURL=index.js.map