added all files to project

node_modules/expect/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/expect/README.md

@@ -0,0 +1,3 @@
+# expect
+
+This package exports the `expect` function used in [Jest](https://jestjs.io/). You can find its documentation [on Jest's website](https://jestjs.io/docs/expect).

node_modules/expect/build/asymmetricMatchers.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+export declare class AsymmetricMatcher<T> {
+    protected sample: T;
+    $$typeof: symbol;
+    inverse?: boolean;
+    constructor(sample: T);
+}
+declare class Any extends AsymmetricMatcher<any> {
+    constructor(sample: unknown);
+    asymmetricMatch(other: unknown): boolean;
+    toString(): string;
+    getExpectedType(): string;
+    toAsymmetricMatcher(): string;
+}
+declare class Anything extends AsymmetricMatcher<void> {
+    asymmetricMatch(other: unknown): boolean;
+    toString(): string;
+    toAsymmetricMatcher(): string;
+}
+declare class ArrayContaining extends AsymmetricMatcher<Array<unknown>> {
+    constructor(sample: Array<unknown>, inverse?: boolean);
+    asymmetricMatch(other: Array<unknown>): boolean;
+    toString(): string;
+    getExpectedType(): string;
+}
+declare class ObjectContaining extends AsymmetricMatcher<Record<string, unknown>> {
+    constructor(sample: Record<string, unknown>, inverse?: boolean);
+    asymmetricMatch(other: any): boolean;
+    toString(): string;
+    getExpectedType(): string;
+}
+declare class StringContaining extends AsymmetricMatcher<string> {
+    constructor(sample: string, inverse?: boolean);
+    asymmetricMatch(other: string): boolean;
+    toString(): string;
+    getExpectedType(): string;
+}
+declare class StringMatching extends AsymmetricMatcher<RegExp> {
+    constructor(sample: string | RegExp, inverse?: boolean);
+    asymmetricMatch(other: string): boolean;
+    toString(): string;
+    getExpectedType(): string;
+}
+export declare const any: (expectedObject: unknown) => Any;
+export declare const anything: () => Anything;
+export declare const arrayContaining: (sample: Array<unknown>) => ArrayContaining;
+export declare const arrayNotContaining: (sample: Array<unknown>) => ArrayContaining;
+export declare const objectContaining: (sample: Record<string, unknown>) => ObjectContaining;
+export declare const objectNotContaining: (sample: Record<string, unknown>) => ObjectContaining;
+export declare const stringContaining: (expected: string) => StringContaining;
+export declare const stringNotContaining: (expected: string) => StringContaining;
+export declare const stringMatching: (expected: string | RegExp) => StringMatching;
+export declare const stringNotMatching: (expected: string | RegExp) => StringMatching;
+export {};

node_modules/expect/build/asymmetricMatchers.js

@@ -0,0 +1,321 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.stringNotMatching =
+  exports.stringMatching =
+  exports.stringNotContaining =
+  exports.stringContaining =
+  exports.objectNotContaining =
+  exports.objectContaining =
+  exports.arrayNotContaining =
+  exports.arrayContaining =
+  exports.anything =
+  exports.any =
+  exports.AsymmetricMatcher =
+    void 0;
+
+var _jasmineUtils = require('./jasmineUtils');
+
+var global = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global !== 'undefined') {
+    return global;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+class AsymmetricMatcher {
+  constructor(sample) {
+    _defineProperty(this, 'sample', void 0);
+
+    _defineProperty(this, '$$typeof', void 0);
+
+    _defineProperty(this, 'inverse', void 0);
+
+    this.$$typeof = Symbol.for('jest.asymmetricMatcher');
+    this.sample = sample;
+  }
+}
+
+exports.AsymmetricMatcher = AsymmetricMatcher;
+
+class Any extends AsymmetricMatcher {
+  constructor(sample) {
+    if (typeof sample === 'undefined') {
+      throw new TypeError(
+        'any() expects to be passed a constructor function. ' +
+          'Please pass one or use anything() to match any object.'
+      );
+    }
+
+    super(sample);
+  }
+
+  asymmetricMatch(other) {
+    if (this.sample == String) {
+      return typeof other == 'string' || other instanceof String;
+    }
+
+    if (this.sample == Number) {
+      return typeof other == 'number' || other instanceof Number;
+    }
+
+    if (this.sample == Function) {
+      return typeof other == 'function' || other instanceof Function;
+    }
+
+    if (this.sample == Object) {
+      return typeof other == 'object';
+    }
+
+    if (this.sample == Boolean) {
+      return typeof other == 'boolean';
+    }
+    /* global BigInt */
+
+    if (this.sample == BigInt) {
+      return typeof other == 'bigint';
+    }
+
+    if (this.sample == Symbol) {
+      return typeof other == 'symbol';
+    }
+
+    return other instanceof this.sample;
+  }
+
+  toString() {
+    return 'Any';
+  }
+
+  getExpectedType() {
+    if (this.sample == String) {
+      return 'string';
+    }
+
+    if (this.sample == Number) {
+      return 'number';
+    }
+
+    if (this.sample == Function) {
+      return 'function';
+    }
+
+    if (this.sample == Object) {
+      return 'object';
+    }
+
+    if (this.sample == Boolean) {
+      return 'boolean';
+    }
+
+    return (0, _jasmineUtils.fnNameFor)(this.sample);
+  }
+
+  toAsymmetricMatcher() {
+    return 'Any<' + (0, _jasmineUtils.fnNameFor)(this.sample) + '>';
+  }
+}
+
+class Anything extends AsymmetricMatcher {
+  asymmetricMatch(other) {
+    return !(0, _jasmineUtils.isUndefined)(other) && other !== null;
+  }
+
+  toString() {
+    return 'Anything';
+  } // No getExpectedType method, because it matches either null or undefined.
+
+  toAsymmetricMatcher() {
+    return 'Anything';
+  }
+}
+
+class ArrayContaining extends AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    super(sample);
+    this.inverse = inverse;
+  }
+
+  asymmetricMatch(other) {
+    if (!Array.isArray(this.sample)) {
+      throw new Error(
+        `You must provide an array to ${this.toString()}, not '` +
+          typeof this.sample +
+          "'."
+      );
+    }
+
+    const result =
+      this.sample.length === 0 ||
+      (Array.isArray(other) &&
+        this.sample.every(item =>
+          other.some(another => (0, _jasmineUtils.equals)(item, another))
+        ));
+    return this.inverse ? !result : result;
+  }
+
+  toString() {
+    return `Array${this.inverse ? 'Not' : ''}Containing`;
+  }
+
+  getExpectedType() {
+    return 'array';
+  }
+}
+
+class ObjectContaining extends AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    super(sample);
+    this.inverse = inverse;
+  }
+
+  asymmetricMatch(other) {
+    if (typeof this.sample !== 'object') {
+      throw new Error(
+        `You must provide an object to ${this.toString()}, not '` +
+          typeof this.sample +
+          "'."
+      );
+    }
+
+    let result = true;
+
+    for (const property in this.sample) {
+      if (
+        !(0, _jasmineUtils.hasProperty)(other, property) ||
+        !(0, _jasmineUtils.equals)(this.sample[property], other[property])
+      ) {
+        result = false;
+        break;
+      }
+    }
+
+    return this.inverse ? !result : result;
+  }
+
+  toString() {
+    return `Object${this.inverse ? 'Not' : ''}Containing`;
+  }
+
+  getExpectedType() {
+    return 'object';
+  }
+}
+
+class StringContaining extends AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    if (!(0, _jasmineUtils.isA)('String', sample)) {
+      throw new Error('Expected is not a string');
+    }
+
+    super(sample);
+    this.inverse = inverse;
+  }
+
+  asymmetricMatch(other) {
+    const result =
+      (0, _jasmineUtils.isA)('String', other) && other.includes(this.sample);
+    return this.inverse ? !result : result;
+  }
+
+  toString() {
+    return `String${this.inverse ? 'Not' : ''}Containing`;
+  }
+
+  getExpectedType() {
+    return 'string';
+  }
+}
+
+class StringMatching extends AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    if (
+      !(0, _jasmineUtils.isA)('String', sample) &&
+      !(0, _jasmineUtils.isA)('RegExp', sample)
+    ) {
+      throw new Error('Expected is not a String or a RegExp');
+    }
+
+    super(new RegExp(sample));
+    this.inverse = inverse;
+  }
+
+  asymmetricMatch(other) {
+    const result =
+      (0, _jasmineUtils.isA)('String', other) && this.sample.test(other);
+    return this.inverse ? !result : result;
+  }
+
+  toString() {
+    return `String${this.inverse ? 'Not' : ''}Matching`;
+  }
+
+  getExpectedType() {
+    return 'string';
+  }
+}
+
+const any = expectedObject => new Any(expectedObject);
+
+exports.any = any;
+
+const anything = () => new Anything();
+
+exports.anything = anything;
+
+const arrayContaining = sample => new ArrayContaining(sample);
+
+exports.arrayContaining = arrayContaining;
+
+const arrayNotContaining = sample => new ArrayContaining(sample, true);
+
+exports.arrayNotContaining = arrayNotContaining;
+
+const objectContaining = sample => new ObjectContaining(sample);
+
+exports.objectContaining = objectContaining;
+
+const objectNotContaining = sample => new ObjectContaining(sample, true);
+
+exports.objectNotContaining = objectNotContaining;
+
+const stringContaining = expected => new StringContaining(expected);
+
+exports.stringContaining = stringContaining;
+
+const stringNotContaining = expected => new StringContaining(expected, true);
+
+exports.stringNotContaining = stringNotContaining;
+
+const stringMatching = expected => new StringMatching(expected);
+
+exports.stringMatching = stringMatching;
+
+const stringNotMatching = expected => new StringMatching(expected, true);
+
+exports.stringNotMatching = stringNotMatching;

node_modules/expect/build/extractExpectedAssertionsErrors.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { Expect } from './types';
+declare const extractExpectedAssertionsErrors: Expect['extractExpectedAssertionsErrors'];
+export default extractExpectedAssertionsErrors;

node_modules/expect/build/extractExpectedAssertionsErrors.js

@@ -0,0 +1,90 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+var _jestMatcherUtils = require('jest-matcher-utils');
+
+var _jestMatchersObject = require('./jestMatchersObject');
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+const resetAssertionsLocalState = () => {
+  (0, _jestMatchersObject.setState)({
+    assertionCalls: 0,
+    expectedAssertionsNumber: null,
+    isExpectingAssertions: false
+  });
+}; // Create and format all errors related to the mismatched number of `expect`
+// calls and reset the matcher's state.
+
+const extractExpectedAssertionsErrors = () => {
+  const result = [];
+  const {
+    assertionCalls,
+    expectedAssertionsNumber,
+    expectedAssertionsNumberError,
+    isExpectingAssertions,
+    isExpectingAssertionsError
+  } = (0, _jestMatchersObject.getState)();
+  resetAssertionsLocalState();
+
+  if (
+    typeof expectedAssertionsNumber === 'number' &&
+    assertionCalls !== expectedAssertionsNumber
+  ) {
+    const numOfAssertionsExpected = (0, _jestMatcherUtils.EXPECTED_COLOR)(
+      (0, _jestMatcherUtils.pluralize)('assertion', expectedAssertionsNumber)
+    );
+    expectedAssertionsNumberError.message =
+      (0, _jestMatcherUtils.matcherHint)(
+        '.assertions',
+        '',
+        String(expectedAssertionsNumber),
+        {
+          isDirectExpectCall: true
+        }
+      ) +
+      '\n\n' +
+      `Expected ${numOfAssertionsExpected} to be called but received ` +
+      (0, _jestMatcherUtils.RECEIVED_COLOR)(
+        (0, _jestMatcherUtils.pluralize)('assertion call', assertionCalls || 0)
+      ) +
+      '.';
+    result.push({
+      actual: assertionCalls.toString(),
+      error: expectedAssertionsNumberError,
+      expected: expectedAssertionsNumber.toString()
+    });
+  }
+
+  if (isExpectingAssertions && assertionCalls === 0) {
+    const expected = (0, _jestMatcherUtils.EXPECTED_COLOR)(
+      'at least one assertion'
+    );
+    const received = (0, _jestMatcherUtils.RECEIVED_COLOR)('received none');
+    isExpectingAssertionsError.message =
+      (0, _jestMatcherUtils.matcherHint)('.hasAssertions', '', '', {
+        isDirectExpectCall: true
+      }) +
+      '\n\n' +
+      `Expected ${expected} to be called but ${received}.`;
+    result.push({
+      actual: 'none',
+      error: isExpectingAssertionsError,
+      expected: 'at least one'
+    });
+  }
+
+  return result;
+};
+
+var _default = extractExpectedAssertionsErrors;
+exports.default = _default;

node_modules/expect/build/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { Expect, MatcherState as JestMatcherState, Matchers as MatcherInterface } from './types';
+declare const expectExport: Expect;
+declare namespace expectExport {
+    type MatcherState = JestMatcherState;
+    interface Matchers<R> extends MatcherInterface<R> {
+    }
+}
+export = expectExport;

node_modules/expect/build/index.js

@@ -0,0 +1,479 @@
+'use strict';
+
+var global = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global !== 'undefined') {
+    return global;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+var matcherUtils = _interopRequireWildcard(require('jest-matcher-utils'));
+
+var _asymmetricMatchers = require('./asymmetricMatchers');
+
+var _extractExpectedAssertionsErrors = _interopRequireDefault(
+  require('./extractExpectedAssertionsErrors')
+);
+
+var _jasmineUtils = require('./jasmineUtils');
+
+var _jestMatchersObject = require('./jestMatchersObject');
+
+var _matchers = _interopRequireDefault(require('./matchers'));
+
+var _spyMatchers = _interopRequireDefault(require('./spyMatchers'));
+
+var _toThrowMatchers = _interopRequireWildcard(require('./toThrowMatchers'));
+
+var _utils = require('./utils');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== 'function') return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+var global = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global !== 'undefined') {
+    return global;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+var global = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global !== 'undefined') {
+    return global;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var Promise = global[Symbol.for('jest-native-promise')] || global.Promise;
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+class JestAssertionError extends Error {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, 'matcherResult', void 0);
+  }
+}
+
+const isPromise = obj =>
+  !!obj &&
+  (typeof obj === 'object' || typeof obj === 'function') &&
+  typeof obj.then === 'function';
+
+const createToThrowErrorMatchingSnapshotMatcher = function (matcher) {
+  return function (received, testNameOrInlineSnapshot) {
+    return matcher.apply(this, [received, testNameOrInlineSnapshot, true]);
+  };
+};
+
+const getPromiseMatcher = (name, matcher) => {
+  if (name === 'toThrow' || name === 'toThrowError') {
+    return (0, _toThrowMatchers.createMatcher)(name, true);
+  } else if (
+    name === 'toThrowErrorMatchingSnapshot' ||
+    name === 'toThrowErrorMatchingInlineSnapshot'
+  ) {
+    return createToThrowErrorMatchingSnapshotMatcher(matcher);
+  }
+
+  return null;
+};
+
+const expect = (actual, ...rest) => {
+  if (rest.length !== 0) {
+    throw new Error('Expect takes at most one argument.');
+  }
+
+  const allMatchers = (0, _jestMatchersObject.getMatchers)();
+  const expectation = {
+    not: {},
+    rejects: {
+      not: {}
+    },
+    resolves: {
+      not: {}
+    }
+  };
+  const err = new JestAssertionError();
+  Object.keys(allMatchers).forEach(name => {
+    const matcher = allMatchers[name];
+    const promiseMatcher = getPromiseMatcher(name, matcher) || matcher;
+    expectation[name] = makeThrowingMatcher(matcher, false, '', actual);
+    expectation.not[name] = makeThrowingMatcher(matcher, true, '', actual);
+    expectation.resolves[name] = makeResolveMatcher(
+      name,
+      promiseMatcher,
+      false,
+      actual,
+      err
+    );
+    expectation.resolves.not[name] = makeResolveMatcher(
+      name,
+      promiseMatcher,
+      true,
+      actual,
+      err
+    );
+    expectation.rejects[name] = makeRejectMatcher(
+      name,
+      promiseMatcher,
+      false,
+      actual,
+      err
+    );
+    expectation.rejects.not[name] = makeRejectMatcher(
+      name,
+      promiseMatcher,
+      true,
+      actual,
+      err
+    );
+  });
+  return expectation;
+};
+
+const getMessage = message =>
+  (message && message()) ||
+  matcherUtils.RECEIVED_COLOR('No message was specified for this matcher.');
+
+const makeResolveMatcher =
+  (matcherName, matcher, isNot, actual, outerErr) =>
+  (...args) => {
+    const options = {
+      isNot,
+      promise: 'resolves'
+    };
+
+    if (!isPromise(actual)) {
+      throw new JestAssertionError(
+        matcherUtils.matcherErrorMessage(
+          matcherUtils.matcherHint(matcherName, undefined, '', options),
+          `${matcherUtils.RECEIVED_COLOR('received')} value must be a promise`,
+          matcherUtils.printWithType(
+            'Received',
+            actual,
+            matcherUtils.printReceived
+          )
+        )
+      );
+    }
+
+    const innerErr = new JestAssertionError();
+    return actual.then(
+      result =>
+        makeThrowingMatcher(matcher, isNot, 'resolves', result, innerErr).apply(
+          null,
+          args
+        ),
+      reason => {
+        outerErr.message =
+          matcherUtils.matcherHint(matcherName, undefined, '', options) +
+          '\n\n' +
+          `Received promise rejected instead of resolved\n` +
+          `Rejected to value: ${matcherUtils.printReceived(reason)}`;
+        return Promise.reject(outerErr);
+      }
+    );
+  };
+
+const makeRejectMatcher =
+  (matcherName, matcher, isNot, actual, outerErr) =>
+  (...args) => {
+    const options = {
+      isNot,
+      promise: 'rejects'
+    };
+    const actualWrapper = typeof actual === 'function' ? actual() : actual;
+
+    if (!isPromise(actualWrapper)) {
+      throw new JestAssertionError(
+        matcherUtils.matcherErrorMessage(
+          matcherUtils.matcherHint(matcherName, undefined, '', options),
+          `${matcherUtils.RECEIVED_COLOR(
+            'received'
+          )} value must be a promise or a function returning a promise`,
+          matcherUtils.printWithType(
+            'Received',
+            actual,
+            matcherUtils.printReceived
+          )
+        )
+      );
+    }
+
+    const innerErr = new JestAssertionError();
+    return actualWrapper.then(
+      result => {
+        outerErr.message =
+          matcherUtils.matcherHint(matcherName, undefined, '', options) +
+          '\n\n' +
+          `Received promise resolved instead of rejected\n` +
+          `Resolved to value: ${matcherUtils.printReceived(result)}`;
+        return Promise.reject(outerErr);
+      },
+      reason =>
+        makeThrowingMatcher(matcher, isNot, 'rejects', reason, innerErr).apply(
+          null,
+          args
+        )
+    );
+  };
+
+const makeThrowingMatcher = (matcher, isNot, promise, actual, err) =>
+  function throwingMatcher(...args) {
+    let throws = true;
+    const utils = {
+      ...matcherUtils,
+      iterableEquality: _utils.iterableEquality,
+      subsetEquality: _utils.subsetEquality
+    };
+    const matcherContext = {
+      // When throws is disabled, the matcher will not throw errors during test
+      // execution but instead add them to the global matcher state. If a
+      // matcher throws, test execution is normally stopped immediately. The
+      // snapshot matcher uses it because we want to log all snapshot
+      // failures in a test.
+      dontThrow: () => (throws = false),
+      ...(0, _jestMatchersObject.getState)(),
+      equals: _jasmineUtils.equals,
+      error: err,
+      isNot,
+      promise,
+      utils
+    };
+
+    const processResult = (result, asyncError) => {
+      _validateResult(result);
+
+      (0, _jestMatchersObject.getState)().assertionCalls++;
+
+      if ((result.pass && isNot) || (!result.pass && !isNot)) {
+        // XOR
+        const message = getMessage(result.message);
+        let error;
+
+        if (err) {
+          error = err;
+          error.message = message;
+        } else if (asyncError) {
+          error = asyncError;
+          error.message = message;
+        } else {
+          error = new JestAssertionError(message); // Try to remove this function from the stack trace frame.
+          // Guard for some environments (browsers) that do not support this feature.
+
+          if (Error.captureStackTrace) {
+            Error.captureStackTrace(error, throwingMatcher);
+          }
+        } // Passing the result of the matcher with the error so that a custom
+        // reporter could access the actual and expected objects of the result
+        // for example in order to display a custom visual diff
+
+        error.matcherResult = {...result, message};
+
+        if (throws) {
+          throw error;
+        } else {
+          (0, _jestMatchersObject.getState)().suppressedErrors.push(error);
+        }
+      }
+    };
+
+    const handleError = error => {
+      if (
+        matcher[_jestMatchersObject.INTERNAL_MATCHER_FLAG] === true &&
+        !(error instanceof JestAssertionError) &&
+        error.name !== 'PrettyFormatPluginError' && // Guard for some environments (browsers) that do not support this feature.
+        Error.captureStackTrace
+      ) {
+        // Try to remove this and deeper functions from the stack trace frame.
+        Error.captureStackTrace(error, throwingMatcher);
+      }
+
+      throw error;
+    };
+
+    let potentialResult;
+
+    try {
+      potentialResult =
+        matcher[_jestMatchersObject.INTERNAL_MATCHER_FLAG] === true
+          ? matcher.call(matcherContext, actual, ...args) // It's a trap specifically for inline snapshot to capture this name
+          : // in the stack trace, so that it can correctly get the custom matcher
+            // function call.
+            (function __EXTERNAL_MATCHER_TRAP__() {
+              return matcher.call(matcherContext, actual, ...args);
+            })();
+
+      if (isPromise(potentialResult)) {
+        const asyncResult = potentialResult;
+        const asyncError = new JestAssertionError();
+
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(asyncError, throwingMatcher);
+        }
+
+        return asyncResult
+          .then(aResult => processResult(aResult, asyncError))
+          .catch(handleError);
+      } else {
+        const syncResult = potentialResult;
+        return processResult(syncResult);
+      }
+    } catch (error) {
+      return handleError(error);
+    }
+  };
+
+expect.extend = matchers =>
+  (0, _jestMatchersObject.setMatchers)(matchers, false, expect);
+
+expect.anything = _asymmetricMatchers.anything;
+expect.any = _asymmetricMatchers.any;
+expect.not = {
+  arrayContaining: _asymmetricMatchers.arrayNotContaining,
+  objectContaining: _asymmetricMatchers.objectNotContaining,
+  stringContaining: _asymmetricMatchers.stringNotContaining,
+  stringMatching: _asymmetricMatchers.stringNotMatching
+};
+expect.objectContaining = _asymmetricMatchers.objectContaining;
+expect.arrayContaining = _asymmetricMatchers.arrayContaining;
+expect.stringContaining = _asymmetricMatchers.stringContaining;
+expect.stringMatching = _asymmetricMatchers.stringMatching;
+
+const _validateResult = result => {
+  if (
+    typeof result !== 'object' ||
+    typeof result.pass !== 'boolean' ||
+    (result.message &&
+      typeof result.message !== 'string' &&
+      typeof result.message !== 'function')
+  ) {
+    throw new Error(
+      'Unexpected return from a matcher function.\n' +
+        'Matcher functions should ' +
+        'return an object in the following format:\n' +
+        '  {message?: string | function, pass: boolean}\n' +
+        `'${matcherUtils.stringify(result)}' was returned`
+    );
+  }
+};
+
+function assertions(expected) {
+  const error = new Error();
+
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(error, assertions);
+  }
+
+  (0, _jestMatchersObject.getState)().expectedAssertionsNumber = expected;
+  (0, _jestMatchersObject.getState)().expectedAssertionsNumberError = error;
+}
+
+function hasAssertions(...args) {
+  const error = new Error();
+
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(error, hasAssertions);
+  }
+
+  matcherUtils.ensureNoExpected(args[0], '.hasAssertions');
+  (0, _jestMatchersObject.getState)().isExpectingAssertions = true;
+  (0, _jestMatchersObject.getState)().isExpectingAssertionsError = error;
+} // add default jest matchers
+
+(0, _jestMatchersObject.setMatchers)(_matchers.default, true, expect);
+(0, _jestMatchersObject.setMatchers)(_spyMatchers.default, true, expect);
+(0, _jestMatchersObject.setMatchers)(_toThrowMatchers.default, true, expect);
+
+expect.addSnapshotSerializer = () => void 0;
+
+expect.assertions = assertions;
+expect.hasAssertions = hasAssertions;
+expect.getState = _jestMatchersObject.getState;
+expect.setState = _jestMatchersObject.setState;
+expect.extractExpectedAssertionsErrors =
+  _extractExpectedAssertionsErrors.default;
+const expectExport = expect;
+module.exports = expectExport;

node_modules/expect/build/jasmineUtils.d.ts

@@ -0,0 +1,8 @@
+import type { Tester } from './types';
+export declare function equals(a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean): boolean;
+export declare function isA(typeName: string, value: unknown): boolean;
+export declare function fnNameFor(func: Function): string;
+export declare function isUndefined(obj: any): boolean;
+export declare function hasProperty(obj: object | null, property: string): boolean;
+export declare function isImmutableUnorderedKeyed(maybeKeyed: any): boolean;
+export declare function isImmutableUnorderedSet(maybeSet: any): boolean;

node_modules/expect/build/jasmineUtils.js

@@ -0,0 +1,279 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.equals = equals;
+exports.isA = isA;
+exports.fnNameFor = fnNameFor;
+exports.isUndefined = isUndefined;
+exports.hasProperty = hasProperty;
+exports.isImmutableUnorderedKeyed = isImmutableUnorderedKeyed;
+exports.isImmutableUnorderedSet = isImmutableUnorderedSet;
+
+/*
+Copyright (c) 2008-2016 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+*/
+
+/* eslint-disable */
+// Extracted out of jasmine 2.5.2
+function equals(a, b, customTesters, strictCheck) {
+  customTesters = customTesters || [];
+  return eq(a, b, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
+}
+
+const functionToString = Function.prototype.toString;
+
+function isAsymmetric(obj) {
+  return !!obj && isA('Function', obj.asymmetricMatch);
+}
+
+function asymmetricMatch(a, b) {
+  var asymmetricA = isAsymmetric(a),
+    asymmetricB = isAsymmetric(b);
+
+  if (asymmetricA && asymmetricB) {
+    return undefined;
+  }
+
+  if (asymmetricA) {
+    return a.asymmetricMatch(b);
+  }
+
+  if (asymmetricB) {
+    return b.asymmetricMatch(a);
+  }
+} // Equality function lovingly adapted from isEqual in
+//   [Underscore](http://underscorejs.org)
+
+function eq(a, b, aStack, bStack, customTesters, hasKey) {
+  var result = true;
+  var asymmetricResult = asymmetricMatch(a, b);
+
+  if (asymmetricResult !== undefined) {
+    return asymmetricResult;
+  }
+
+  for (var i = 0; i < customTesters.length; i++) {
+    var customTesterResult = customTesters[i](a, b);
+
+    if (customTesterResult !== undefined) {
+      return customTesterResult;
+    }
+  }
+
+  if (a instanceof Error && b instanceof Error) {
+    return a.message == b.message;
+  }
+
+  if (Object.is(a, b)) {
+    return true;
+  } // A strict comparison is necessary because `null == undefined`.
+
+  if (a === null || b === null) {
+    return a === b;
+  }
+
+  var className = Object.prototype.toString.call(a);
+
+  if (className != Object.prototype.toString.call(b)) {
+    return false;
+  }
+
+  switch (className) {
+    case '[object Boolean]':
+    case '[object String]':
+    case '[object Number]':
+      if (typeof a !== typeof b) {
+        // One is a primitive, one a `new Primitive()`
+        return false;
+      } else if (typeof a !== 'object' && typeof b !== 'object') {
+        // both are proper primitives
+        return Object.is(a, b);
+      } else {
+        // both are `new Primitive()`s
+        return Object.is(a.valueOf(), b.valueOf());
+      }
+
+    case '[object Date]':
+      // Coerce dates to numeric primitive values. Dates are compared by their
+      // millisecond representations. Note that invalid dates with millisecond representations
+      // of `NaN` are not equivalent.
+      return +a == +b;
+    // RegExps are compared by their source patterns and flags.
+
+    case '[object RegExp]':
+      return a.source === b.source && a.flags === b.flags;
+  }
+
+  if (typeof a !== 'object' || typeof b !== 'object') {
+    return false;
+  } // Use DOM3 method isEqualNode (IE>=9)
+
+  if (isDomNode(a) && isDomNode(b)) {
+    return a.isEqualNode(b);
+  } // Used to detect circular references.
+
+  var length = aStack.length;
+
+  while (length--) {
+    // Linear search. Performance is inversely proportional to the number of
+    // unique nested structures.
+    // circular references at same depth are equal
+    // circular reference is not equal to non-circular one
+    if (aStack[length] === a) {
+      return bStack[length] === b;
+    } else if (bStack[length] === b) {
+      return false;
+    }
+  } // Add the first object to the stack of traversed objects.
+
+  aStack.push(a);
+  bStack.push(b); // Recursively compare objects and arrays.
+  // Compare array lengths to determine if a deep comparison is necessary.
+
+  if (className == '[object Array]' && a.length !== b.length) {
+    return false;
+  } // Deep compare objects.
+
+  var aKeys = keys(a, hasKey),
+    key;
+  var size = aKeys.length; // Ensure that both objects contain the same number of properties before comparing deep equality.
+
+  if (keys(b, hasKey).length !== size) {
+    return false;
+  }
+
+  while (size--) {
+    key = aKeys[size]; // Deep compare each member
+
+    result =
+      hasKey(b, key) &&
+      eq(a[key], b[key], aStack, bStack, customTesters, hasKey);
+
+    if (!result) {
+      return false;
+    }
+  } // Remove the first object from the stack of traversed objects.
+
+  aStack.pop();
+  bStack.pop();
+  return result;
+}
+
+function keys(obj, hasKey) {
+  var keys = [];
+
+  for (var key in obj) {
+    if (hasKey(obj, key)) {
+      keys.push(key);
+    }
+  }
+
+  return keys.concat(
+    Object.getOwnPropertySymbols(obj).filter(
+      symbol => Object.getOwnPropertyDescriptor(obj, symbol).enumerable
+    )
+  );
+}
+
+function hasDefinedKey(obj, key) {
+  return hasKey(obj, key) && obj[key] !== undefined;
+}
+
+function hasKey(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function isA(typeName, value) {
+  return Object.prototype.toString.apply(value) === '[object ' + typeName + ']';
+}
+
+function isDomNode(obj) {
+  return (
+    obj !== null &&
+    typeof obj === 'object' &&
+    typeof obj.nodeType === 'number' &&
+    typeof obj.nodeName === 'string' &&
+    typeof obj.isEqualNode === 'function'
+  );
+}
+
+function fnNameFor(func) {
+  if (func.name) {
+    return func.name;
+  }
+
+  const matches = functionToString
+    .call(func)
+    .match(/^(?:async)?\s*function\s*\*?\s*([\w$]+)\s*\(/);
+  return matches ? matches[1] : '<anonymous>';
+}
+
+function isUndefined(obj) {
+  return obj === void 0;
+}
+
+function getPrototype(obj) {
+  if (Object.getPrototypeOf) {
+    return Object.getPrototypeOf(obj);
+  }
+
+  if (obj.constructor.prototype == obj) {
+    return null;
+  }
+
+  return obj.constructor.prototype;
+}
+
+function hasProperty(obj, property) {
+  if (!obj) {
+    return false;
+  }
+
+  if (Object.prototype.hasOwnProperty.call(obj, property)) {
+    return true;
+  }
+
+  return hasProperty(getPrototype(obj), property);
+} // SENTINEL constants are from https://github.com/facebook/immutable-js
+
+const IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
+const IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
+const IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
+
+function isImmutableUnorderedKeyed(maybeKeyed) {
+  return !!(
+    maybeKeyed &&
+    maybeKeyed[IS_KEYED_SENTINEL] &&
+    !maybeKeyed[IS_ORDERED_SENTINEL]
+  );
+}
+
+function isImmutableUnorderedSet(maybeSet) {
+  return !!(
+    maybeSet &&
+    maybeSet[IS_SET_SENTINEL] &&
+    !maybeSet[IS_ORDERED_SENTINEL]
+  );
+}

node_modules/expect/build/jestMatchersObject.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { Expect, MatcherState, MatchersObject } from './types';
+export declare const INTERNAL_MATCHER_FLAG: unique symbol;
+export declare const getState: () => MatcherState;
+export declare const setState: (state: Partial<MatcherState>) => void;
+export declare const getMatchers: () => MatchersObject;
+export declare const setMatchers: (matchers: MatchersObject, isInternal: boolean, expect: Expect) => void;

node_modules/expect/build/jestMatchersObject.js

@@ -0,0 +1,112 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.setMatchers =
+  exports.getMatchers =
+  exports.setState =
+  exports.getState =
+  exports.INTERNAL_MATCHER_FLAG =
+    void 0;
+
+var _asymmetricMatchers = require('./asymmetricMatchers');
+
+var global = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global !== 'undefined') {
+    return global;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+// Global matchers object holds the list of available matchers and
+// the state, that can hold matcher specific values that change over time.
+const JEST_MATCHERS_OBJECT = Symbol.for('$$jest-matchers-object'); // Notes a built-in/internal Jest matcher.
+// Jest may override the stack trace of Errors thrown by internal matchers.
+
+const INTERNAL_MATCHER_FLAG = Symbol.for('$$jest-internal-matcher');
+exports.INTERNAL_MATCHER_FLAG = INTERNAL_MATCHER_FLAG;
+
+if (!global.hasOwnProperty(JEST_MATCHERS_OBJECT)) {
+  const defaultState = {
+    assertionCalls: 0,
+    expectedAssertionsNumber: null,
+    isExpectingAssertions: false,
+    suppressedErrors: [] // errors that are not thrown immediately.
+  };
+  Object.defineProperty(global, JEST_MATCHERS_OBJECT, {
+    value: {
+      matchers: Object.create(null),
+      state: defaultState
+    }
+  });
+}
+
+const getState = () => global[JEST_MATCHERS_OBJECT].state;
+
+exports.getState = getState;
+
+const setState = state => {
+  Object.assign(global[JEST_MATCHERS_OBJECT].state, state);
+};
+
+exports.setState = setState;
+
+const getMatchers = () => global[JEST_MATCHERS_OBJECT].matchers;
+
+exports.getMatchers = getMatchers;
+
+const setMatchers = (matchers, isInternal, expect) => {
+  Object.keys(matchers).forEach(key => {
+    const matcher = matchers[key];
+    Object.defineProperty(matcher, INTERNAL_MATCHER_FLAG, {
+      value: isInternal
+    });
+
+    if (!isInternal) {
+      // expect is defined
+      class CustomMatcher extends _asymmetricMatchers.AsymmetricMatcher {
+        constructor(inverse = false, ...sample) {
+          super(sample);
+          this.inverse = inverse;
+        }
+
+        asymmetricMatch(other) {
+          const {pass} = matcher(other, ...this.sample);
+          return this.inverse ? !pass : pass;
+        }
+
+        toString() {
+          return `${this.inverse ? 'not.' : ''}${key}`;
+        }
+
+        getExpectedType() {
+          return 'any';
+        }
+
+        toAsymmetricMatcher() {
+          return `${this.toString()}<${this.sample.map(String).join(', ')}>`;
+        }
+      }
+
+      expect[key] = (...sample) => new CustomMatcher(false, ...sample);
+
+      if (!expect.not) {
+        expect.not = {};
+      }
+
+      expect.not[key] = (...sample) => new CustomMatcher(true, ...sample);
+    }
+  });
+  Object.assign(global[JEST_MATCHERS_OBJECT].matchers, matchers);
+};
+
+exports.setMatchers = setMatchers;

node_modules/expect/build/matchers.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { MatchersObject } from './types';
+declare const matchers: MatchersObject;
+export default matchers;

node_modules/expect/build/print.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+export declare const printReceivedStringContainExpectedSubstring: (received: string, start: number, length: number) => string;
+export declare const printReceivedStringContainExpectedResult: (received: string, result: RegExpExecArray | null) => string;
+export declare const printReceivedArrayContainExpectedItem: (received: Array<unknown>, index: number) => string;
+export declare const printCloseTo: (receivedDiff: number, expectedDiff: number, precision: number, isNot: boolean) => string;
+export declare const printExpectedConstructorName: (label: string, expected: Function) => string;
+export declare const printExpectedConstructorNameNot: (label: string, expected: Function) => string;
+export declare const printReceivedConstructorName: (label: string, received: Function) => string;
+export declare const printReceivedConstructorNameNot: (label: string, received: Function, expected: Function) => string;

node_modules/expect/build/print.js

@@ -0,0 +1,141 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.printReceivedConstructorNameNot =
+  exports.printReceivedConstructorName =
+  exports.printExpectedConstructorNameNot =
+  exports.printExpectedConstructorName =
+  exports.printCloseTo =
+  exports.printReceivedArrayContainExpectedItem =
+  exports.printReceivedStringContainExpectedResult =
+  exports.printReceivedStringContainExpectedSubstring =
+    void 0;
+
+var _jestMatcherUtils = require('jest-matcher-utils');
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/* eslint-disable local/ban-types-eventually */
+// Format substring but do not enclose in double quote marks.
+// The replacement is compatible with pretty-format package.
+const printSubstring = val => val.replace(/"|\\/g, '\\$&');
+
+const printReceivedStringContainExpectedSubstring = (
+  received,
+  start,
+  length // not end
+) =>
+  (0, _jestMatcherUtils.RECEIVED_COLOR)(
+    '"' +
+      printSubstring(received.slice(0, start)) +
+      (0, _jestMatcherUtils.INVERTED_COLOR)(
+        printSubstring(received.slice(start, start + length))
+      ) +
+      printSubstring(received.slice(start + length)) +
+      '"'
+  );
+
+exports.printReceivedStringContainExpectedSubstring =
+  printReceivedStringContainExpectedSubstring;
+
+const printReceivedStringContainExpectedResult = (received, result) =>
+  result === null
+    ? (0, _jestMatcherUtils.printReceived)(received)
+    : printReceivedStringContainExpectedSubstring(
+        received,
+        result.index,
+        result[0].length
+      ); // The serialized array is compatible with pretty-format package min option.
+// However, items have default stringify depth (instead of depth - 1)
+// so expected item looks consistent by itself and enclosed in the array.
+
+exports.printReceivedStringContainExpectedResult =
+  printReceivedStringContainExpectedResult;
+
+const printReceivedArrayContainExpectedItem = (received, index) =>
+  (0, _jestMatcherUtils.RECEIVED_COLOR)(
+    '[' +
+      received
+        .map((item, i) => {
+          const stringified = (0, _jestMatcherUtils.stringify)(item);
+          return i === index
+            ? (0, _jestMatcherUtils.INVERTED_COLOR)(stringified)
+            : stringified;
+        })
+        .join(', ') +
+      ']'
+  );
+
+exports.printReceivedArrayContainExpectedItem =
+  printReceivedArrayContainExpectedItem;
+
+const printCloseTo = (receivedDiff, expectedDiff, precision, isNot) => {
+  const receivedDiffString = (0, _jestMatcherUtils.stringify)(receivedDiff);
+  const expectedDiffString = receivedDiffString.includes('e') // toExponential arg is number of digits after the decimal point.
+    ? expectedDiff.toExponential(0)
+    : 0 <= precision && precision < 20 // toFixed arg is number of digits after the decimal point.
+    ? // It may be a value between 0 and 20 inclusive.
+      // Implementations may optionally support a larger range of values.
+      expectedDiff.toFixed(precision + 1)
+    : (0, _jestMatcherUtils.stringify)(expectedDiff);
+  return (
+    `Expected precision:  ${isNot ? '    ' : ''}  ${(0,
+    _jestMatcherUtils.stringify)(precision)}\n` +
+    `Expected difference: ${isNot ? 'not ' : ''}< ${(0,
+    _jestMatcherUtils.EXPECTED_COLOR)(expectedDiffString)}\n` +
+    `Received difference: ${isNot ? '    ' : ''}  ${(0,
+    _jestMatcherUtils.RECEIVED_COLOR)(receivedDiffString)}`
+  );
+};
+
+exports.printCloseTo = printCloseTo;
+
+const printExpectedConstructorName = (label, expected) =>
+  printConstructorName(label, expected, false, true) + '\n';
+
+exports.printExpectedConstructorName = printExpectedConstructorName;
+
+const printExpectedConstructorNameNot = (label, expected) =>
+  printConstructorName(label, expected, true, true) + '\n';
+
+exports.printExpectedConstructorNameNot = printExpectedConstructorNameNot;
+
+const printReceivedConstructorName = (label, received) =>
+  printConstructorName(label, received, false, false) + '\n'; // Do not call function if received is equal to expected.
+
+exports.printReceivedConstructorName = printReceivedConstructorName;
+
+const printReceivedConstructorNameNot = (label, received, expected) =>
+  typeof expected.name === 'string' &&
+  expected.name.length !== 0 &&
+  typeof received.name === 'string' &&
+  received.name.length !== 0
+    ? printConstructorName(label, received, true, false) +
+      ` ${
+        Object.getPrototypeOf(received) === expected
+          ? 'extends'
+          : 'extends … extends'
+      } ${(0, _jestMatcherUtils.EXPECTED_COLOR)(expected.name)}` +
+      '\n'
+    : printConstructorName(label, received, false, false) + '\n';
+
+exports.printReceivedConstructorNameNot = printReceivedConstructorNameNot;
+
+const printConstructorName = (label, constructor, isNot, isExpected) =>
+  typeof constructor.name !== 'string'
+    ? `${label} name is not a string`
+    : constructor.name.length === 0
+    ? `${label} name is an empty string`
+    : `${label}: ${!isNot ? '' : isExpected ? 'not ' : '    '}${
+        isExpected
+          ? (0, _jestMatcherUtils.EXPECTED_COLOR)(constructor.name)
+          : (0, _jestMatcherUtils.RECEIVED_COLOR)(constructor.name)
+      }`;

node_modules/expect/build/spyMatchers.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { MatchersObject } from './types';
+declare const spyMatchers: MatchersObject;
+export default spyMatchers;

node_modules/expect/build/toThrowMatchers.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { MatchersObject, RawMatcherFn } from './types';
+export declare const createMatcher: (matcherName: string, fromPromise?: boolean | undefined) => RawMatcherFn;
+declare const matchers: MatchersObject;
+export default matchers;

node_modules/expect/build/toThrowMatchers.js

@@ -0,0 +1,464 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = exports.createMatcher = void 0;
+
+var _jestMatcherUtils = require('jest-matcher-utils');
+
+var _jestMessageUtil = require('jest-message-util');
+
+var _print = require('./print');
+
+var _utils = require('./utils');
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/* eslint-disable local/ban-types-eventually */
+const DID_NOT_THROW = 'Received function did not throw';
+
+const getThrown = e => {
+  const hasMessage =
+    e !== null && e !== undefined && typeof e.message === 'string';
+
+  if (hasMessage && typeof e.name === 'string' && typeof e.stack === 'string') {
+    return {
+      hasMessage,
+      isError: true,
+      message: e.message,
+      value: e
+    };
+  }
+
+  return {
+    hasMessage,
+    isError: false,
+    message: hasMessage ? e.message : String(e),
+    value: e
+  };
+};
+
+const createMatcher = (matcherName, fromPromise) =>
+  function (received, expected) {
+    const options = {
+      isNot: this.isNot,
+      promise: this.promise
+    };
+    let thrown = null;
+
+    if (fromPromise && (0, _utils.isError)(received)) {
+      thrown = getThrown(received);
+    } else {
+      if (typeof received !== 'function') {
+        if (!fromPromise) {
+          const placeholder = expected === undefined ? '' : 'expected';
+          throw new Error(
+            (0, _jestMatcherUtils.matcherErrorMessage)(
+              (0, _jestMatcherUtils.matcherHint)(
+                matcherName,
+                undefined,
+                placeholder,
+                options
+              ),
+              `${(0, _jestMatcherUtils.RECEIVED_COLOR)(
+                'received'
+              )} value must be a function`,
+              (0, _jestMatcherUtils.printWithType)(
+                'Received',
+                received,
+                _jestMatcherUtils.printReceived
+              )
+            )
+          );
+        }
+      } else {
+        try {
+          received();
+        } catch (e) {
+          thrown = getThrown(e);
+        }
+      }
+    }
+
+    if (expected === undefined) {
+      return toThrow(matcherName, options, thrown);
+    } else if (typeof expected === 'function') {
+      return toThrowExpectedClass(matcherName, options, thrown, expected);
+    } else if (typeof expected === 'string') {
+      return toThrowExpectedString(matcherName, options, thrown, expected);
+    } else if (expected !== null && typeof expected.test === 'function') {
+      return toThrowExpectedRegExp(matcherName, options, thrown, expected);
+    } else if (
+      expected !== null &&
+      typeof expected.asymmetricMatch === 'function'
+    ) {
+      return toThrowExpectedAsymmetric(matcherName, options, thrown, expected);
+    } else if (expected !== null && typeof expected === 'object') {
+      return toThrowExpectedObject(matcherName, options, thrown, expected);
+    } else {
+      throw new Error(
+        (0, _jestMatcherUtils.matcherErrorMessage)(
+          (0, _jestMatcherUtils.matcherHint)(
+            matcherName,
+            undefined,
+            undefined,
+            options
+          ),
+          `${(0, _jestMatcherUtils.EXPECTED_COLOR)(
+            'expected'
+          )} value must be a string or regular expression or class or error`,
+          (0, _jestMatcherUtils.printWithType)(
+            'Expected',
+            expected,
+            _jestMatcherUtils.printExpected
+          )
+        )
+      );
+    }
+  };
+
+exports.createMatcher = createMatcher;
+const matchers = {
+  toThrow: createMatcher('toThrow'),
+  toThrowError: createMatcher('toThrowError')
+};
+
+const toThrowExpectedRegExp = (matcherName, options, thrown, expected) => {
+  const pass = thrown !== null && expected.test(thrown.message);
+  const message = pass
+    ? () =>
+        (0, _jestMatcherUtils.matcherHint)(
+          matcherName,
+          undefined,
+          undefined,
+          options
+        ) +
+        '\n\n' +
+        formatExpected('Expected pattern: not ', expected) +
+        (thrown !== null && thrown.hasMessage
+          ? formatReceived(
+              'Received message:     ',
+              thrown,
+              'message',
+              expected
+            ) + formatStack(thrown)
+          : formatReceived('Received value:       ', thrown, 'value'))
+    : () =>
+        (0, _jestMatcherUtils.matcherHint)(
+          matcherName,
+          undefined,
+          undefined,
+          options
+        ) +
+        '\n\n' +
+        formatExpected('Expected pattern: ', expected) +
+        (thrown === null
+          ? '\n' + DID_NOT_THROW
+          : thrown.hasMessage
+          ? formatReceived('Received message: ', thrown, 'message') +
+            formatStack(thrown)
+          : formatReceived('Received value:   ', thrown, 'value'));
+  return {
+    message,
+    pass
+  };
+};
+
+const toThrowExpectedAsymmetric = (matcherName, options, thrown, expected) => {
+  const pass = thrown !== null && expected.asymmetricMatch(thrown.value);
+  const message = pass
+    ? () =>
+        (0, _jestMatcherUtils.matcherHint)(
+          matcherName,
+          undefined,
+          undefined,
+          options
+        ) +
+        '\n\n' +
+        formatExpected('Expected asymmetric matcher: not ', expected) +
+        '\n' +
+        (thrown !== null && thrown.hasMessage
+          ? formatReceived('Received name:    ', thrown, 'name') +
+            formatReceived('Received message: ', thrown, 'message') +
+            formatStack(thrown)
+          : formatReceived('Thrown value: ', thrown, 'value'))
+    : () =>
+        (0, _jestMatcherUtils.matcherHint)(
+          matcherName,
+          undefined,
+          undefined,
+          options
+        ) +
+        '\n\n' +
+        formatExpected('Expected asymmetric matcher: ', expected) +
+        '\n' +
+        (thrown === null
+          ? DID_NOT_THROW
+          : thrown.hasMessage
+          ? formatReceived('Received name:    ', thrown, 'name') +
+            formatReceived('Received message: ', thrown, 'message') +
+            formatStack(thrown)
+          : formatReceived('Thrown value: ', thrown, 'value'));
+  return {
+    message,
+    pass
+  };
+};
+
+const toThrowExpectedObject = (matcherName, options, thrown, expected) => {
+  const pass = thrown !== null && thrown.message === expected.message;
+  const message = pass
+    ? () =>
+        (0, _jestMatcherUtils.matcherHint)(
+          matcherName,
+          undefined,
+          undefined,
+          options
+        ) +
+        '\n\n' +
+        formatExpected('Expected message: not ', expected.message) +
+        (thrown !== null && thrown.hasMessage
+          ? formatStack(thrown)
+          : formatReceived('Received value:       ', thrown, 'value'))
+    : () =>
+        (0, _jestMatcherUtils.matcherHint)(
+          matcherName,
+          undefined,
+          undefined,
+          options
+        ) +
+        '\n\n' +
+        (thrown === null
+          ? formatExpected('Expected message: ', expected.message) +
+            '\n' +
+            DID_NOT_THROW
+          : thrown.hasMessage
+          ? (0, _jestMatcherUtils.printDiffOrStringify)(
+              expected.message,
+              thrown.message,
+              'Expected message',
+              'Received message',
+              true
+            ) +
+            '\n' +
+            formatStack(thrown)
+          : formatExpected('Expected message: ', expected.message) +
+            formatReceived('Received value:   ', thrown, 'value'));
+  return {
+    message,
+    pass
+  };
+};
+
+const toThrowExpectedClass = (matcherName, options, thrown, expected) => {
+  const pass = thrown !== null && thrown.value instanceof expected;
+  const message = pass
+    ? () =>
+        (0, _jestMatcherUtils.matcherHint)(
+          matcherName,
+          undefined,
+          undefined,
+          options
+        ) +
+        '\n\n' +
+        (0, _print.printExpectedConstructorNameNot)(
+          'Expected constructor',
+          expected
+        ) +
+        (thrown !== null &&
+        thrown.value != null &&
+        typeof thrown.value.constructor === 'function' &&
+        thrown.value.constructor !== expected
+          ? (0, _print.printReceivedConstructorNameNot)(
+              'Received constructor',
+              thrown.value.constructor,
+              expected
+            )
+          : '') +
+        '\n' +
+        (thrown !== null && thrown.hasMessage
+          ? formatReceived('Received message: ', thrown, 'message') +
+            formatStack(thrown)
+          : formatReceived('Received value: ', thrown, 'value'))
+    : () =>
+        (0, _jestMatcherUtils.matcherHint)(
+          matcherName,
+          undefined,
+          undefined,
+          options
+        ) +
+        '\n\n' +
+        (0, _print.printExpectedConstructorName)(
+          'Expected constructor',
+          expected
+        ) +
+        (thrown === null
+          ? '\n' + DID_NOT_THROW
+          : (thrown.value != null &&
+            typeof thrown.value.constructor === 'function'
+              ? (0, _print.printReceivedConstructorName)(
+                  'Received constructor',
+                  thrown.value.constructor
+                )
+              : '') +
+            '\n' +
+            (thrown.hasMessage
+              ? formatReceived('Received message: ', thrown, 'message') +
+                formatStack(thrown)
+              : formatReceived('Received value: ', thrown, 'value')));
+  return {
+    message,
+    pass
+  };
+};
+
+const toThrowExpectedString = (matcherName, options, thrown, expected) => {
+  const pass = thrown !== null && thrown.message.includes(expected);
+  const message = pass
+    ? () =>
+        (0, _jestMatcherUtils.matcherHint)(
+          matcherName,
+          undefined,
+          undefined,
+          options
+        ) +
+        '\n\n' +
+        formatExpected('Expected substring: not ', expected) +
+        (thrown !== null && thrown.hasMessage
+          ? formatReceived(
+              'Received message:       ',
+              thrown,
+              'message',
+              expected
+            ) + formatStack(thrown)
+          : formatReceived('Received value:         ', thrown, 'value'))
+    : () =>
+        (0, _jestMatcherUtils.matcherHint)(
+          matcherName,
+          undefined,
+          undefined,
+          options
+        ) +
+        '\n\n' +
+        formatExpected('Expected substring: ', expected) +
+        (thrown === null
+          ? '\n' + DID_NOT_THROW
+          : thrown.hasMessage
+          ? formatReceived('Received message:   ', thrown, 'message') +
+            formatStack(thrown)
+          : formatReceived('Received value:     ', thrown, 'value'));
+  return {
+    message,
+    pass
+  };
+};
+
+const toThrow = (matcherName, options, thrown) => {
+  const pass = thrown !== null;
+  const message = pass
+    ? () =>
+        (0, _jestMatcherUtils.matcherHint)(
+          matcherName,
+          undefined,
+          '',
+          options
+        ) +
+        '\n\n' +
+        (thrown !== null && thrown.hasMessage
+          ? formatReceived('Error name:    ', thrown, 'name') +
+            formatReceived('Error message: ', thrown, 'message') +
+            formatStack(thrown)
+          : formatReceived('Thrown value: ', thrown, 'value'))
+    : () =>
+        (0, _jestMatcherUtils.matcherHint)(
+          matcherName,
+          undefined,
+          '',
+          options
+        ) +
+        '\n\n' +
+        DID_NOT_THROW;
+  return {
+    message,
+    pass
+  };
+};
+
+const formatExpected = (label, expected) =>
+  label + (0, _jestMatcherUtils.printExpected)(expected) + '\n';
+
+const formatReceived = (label, thrown, key, expected) => {
+  if (thrown === null) {
+    return '';
+  }
+
+  if (key === 'message') {
+    const message = thrown.message;
+
+    if (typeof expected === 'string') {
+      const index = message.indexOf(expected);
+
+      if (index !== -1) {
+        return (
+          label +
+          (0, _print.printReceivedStringContainExpectedSubstring)(
+            message,
+            index,
+            expected.length
+          ) +
+          '\n'
+        );
+      }
+    } else if (expected instanceof RegExp) {
+      return (
+        label +
+        (0, _print.printReceivedStringContainExpectedResult)(
+          message,
+          typeof expected.exec === 'function' ? expected.exec(message) : null
+        ) +
+        '\n'
+      );
+    }
+
+    return label + (0, _jestMatcherUtils.printReceived)(message) + '\n';
+  }
+
+  if (key === 'name') {
+    return thrown.isError
+      ? label + (0, _jestMatcherUtils.printReceived)(thrown.value.name) + '\n'
+      : '';
+  }
+
+  if (key === 'value') {
+    return thrown.isError
+      ? ''
+      : label + (0, _jestMatcherUtils.printReceived)(thrown.value) + '\n';
+  }
+
+  return '';
+};
+
+const formatStack = thrown =>
+  thrown === null || !thrown.isError
+    ? ''
+    : (0, _jestMessageUtil.formatStackTrace)(
+        (0, _jestMessageUtil.separateMessageFromStack)(thrown.value.stack)
+          .stack,
+        {
+          rootDir: process.cwd(),
+          testMatch: []
+        },
+        {
+          noStackTrace: false
+        }
+      );
+
+var _default = matchers;
+exports.default = _default;

node_modules/expect/build/types.d.ts

@@ -0,0 +1,328 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { Config } from '@jest/types';
+import type * as jestMatcherUtils from 'jest-matcher-utils';
+import { INTERNAL_MATCHER_FLAG } from './jestMatchersObject';
+export declare type SyncExpectationResult = {
+    pass: boolean;
+    message: () => string;
+};
+export declare type AsyncExpectationResult = Promise<SyncExpectationResult>;
+export declare type ExpectationResult = SyncExpectationResult | AsyncExpectationResult;
+export declare type RawMatcherFn = {
+    (received: any, expected: any, options?: any): ExpectationResult;
+    [INTERNAL_MATCHER_FLAG]?: boolean;
+};
+export declare type ThrowingMatcherFn = (actual: any) => void;
+export declare type PromiseMatcherFn = (actual: any) => Promise<void>;
+export declare type Tester = (a: any, b: any) => boolean | undefined;
+export declare type MatcherState = {
+    assertionCalls: number;
+    currentTestName?: string;
+    dontThrow?: () => void;
+    error?: Error;
+    equals: (a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean) => boolean;
+    expand?: boolean;
+    expectedAssertionsNumber?: number | null;
+    expectedAssertionsNumberError?: Error;
+    isExpectingAssertions?: boolean;
+    isExpectingAssertionsError?: Error;
+    isNot: boolean;
+    promise: string;
+    suppressedErrors: Array<Error>;
+    testPath?: Config.Path;
+    utils: typeof jestMatcherUtils & {
+        iterableEquality: Tester;
+        subsetEquality: Tester;
+    };
+};
+export declare type AsymmetricMatcher = Record<string, any>;
+export declare type MatchersObject = {
+    [id: string]: RawMatcherFn;
+};
+export declare type ExpectedAssertionsErrors = Array<{
+    actual: string | number;
+    error: Error;
+    expected: string;
+}>;
+export declare type Expect = {
+    <T = unknown>(actual: T): Matchers<T>;
+    addSnapshotSerializer(arg0: any): void;
+    assertions(arg0: number): void;
+    extend(arg0: any): void;
+    extractExpectedAssertionsErrors: () => ExpectedAssertionsErrors;
+    getState(): MatcherState;
+    hasAssertions(): void;
+    setState(state: Partial<MatcherState>): void;
+    any(expectedObject: any): AsymmetricMatcher;
+    anything(): AsymmetricMatcher;
+    arrayContaining(sample: Array<unknown>): AsymmetricMatcher;
+    objectContaining(sample: Record<string, unknown>): AsymmetricMatcher;
+    stringContaining(expected: string): AsymmetricMatcher;
+    stringMatching(expected: string | RegExp): AsymmetricMatcher;
+    [id: string]: AsymmetricMatcher;
+    not: {
+        [id: string]: AsymmetricMatcher;
+    };
+};
+interface Constructable {
+    new (...args: Array<unknown>): unknown;
+}
+export interface Matchers<R> {
+    /**
+     * Ensures the last call to a mock function was provided specific args.
+     */
+    lastCalledWith(...args: Array<unknown>): R;
+    /**
+     * Ensure that the last call to a mock function has returned a specified value.
+     */
+    lastReturnedWith(value: unknown): R;
+    /**
+     * If you know how to test something, `.not` lets you test its opposite.
+     */
+    not: Matchers<R>;
+    /**
+     * Ensure that a mock function is called with specific arguments on an Nth call.
+     */
+    nthCalledWith(nthCall: number, ...args: Array<unknown>): R;
+    /**
+     * Ensure that the nth call to a mock function has returned a specified value.
+     */
+    nthReturnedWith(n: number, value: unknown): R;
+    /**
+     * Use resolves to unwrap the value of a fulfilled promise so any other
+     * matcher can be chained. If the promise is rejected the assertion fails.
+     */
+    resolves: Matchers<Promise<R>>;
+    /**
+     * Unwraps the reason of a rejected promise so any other matcher can be chained.
+     * If the promise is fulfilled the assertion fails.
+     */
+    rejects: Matchers<Promise<R>>;
+    /**
+     * Checks that a value is what you expect. It uses `===` to check strict equality.
+     * Don't use `toBe` with floating-point numbers.
+     */
+    toBe(expected: unknown): R;
+    /**
+     * Ensures that a mock function is called.
+     */
+    toBeCalled(): R;
+    /**
+     * Ensures that a mock function is called an exact number of times.
+     */
+    toBeCalledTimes(expected: number): R;
+    /**
+     * Ensure that a mock function is called with specific arguments.
+     */
+    toBeCalledWith(...args: Array<unknown>): R;
+    /**
+     * Using exact equality with floating point numbers is a bad idea.
+     * Rounding means that intuitive things fail.
+     * The default for numDigits is 2.
+     */
+    toBeCloseTo(expected: number, numDigits?: number): R;
+    /**
+     * Ensure that a variable is not undefined.
+     */
+    toBeDefined(): R;
+    /**
+     * When you don't care what a value is, you just want to
+     * ensure a value is false in a boolean context.
+     */
+    toBeFalsy(): R;
+    /**
+     * For comparing floating point numbers.
+     */
+    toBeGreaterThan(expected: number | bigint): R;
+    /**
+     * For comparing floating point numbers.
+     */
+    toBeGreaterThanOrEqual(expected: number | bigint): R;
+    /**
+     * Ensure that an object is an instance of a class.
+     * This matcher uses `instanceof` underneath.
+     */
+    toBeInstanceOf(expected: Function): R;
+    /**
+     * For comparing floating point numbers.
+     */
+    toBeLessThan(expected: number | bigint): R;
+    /**
+     * For comparing floating point numbers.
+     */
+    toBeLessThanOrEqual(expected: number | bigint): R;
+    /**
+     * This is the same as `.toBe(null)` but the error messages are a bit nicer.
+     * So use `.toBeNull()` when you want to check that something is null.
+     */
+    toBeNull(): R;
+    /**
+     * Use when you don't care what a value is, you just want to ensure a value
+     * is true in a boolean context. In JavaScript, there are six falsy values:
+     * `false`, `0`, `''`, `null`, `undefined`, and `NaN`. Everything else is truthy.
+     */
+    toBeTruthy(): R;
+    /**
+     * Used to check that a variable is undefined.
+     */
+    toBeUndefined(): R;
+    /**
+     * Used to check that a variable is NaN.
+     */
+    toBeNaN(): R;
+    /**
+     * Used when you want to check that an item is in a list.
+     * For testing the items in the list, this uses `===`, a strict equality check.
+     */
+    toContain(expected: unknown): R;
+    /**
+     * Used when you want to check that an item is in a list.
+     * For testing the items in the list, this  matcher recursively checks the
+     * equality of all fields, rather than checking for object identity.
+     */
+    toContainEqual(expected: unknown): R;
+    /**
+     * Used when you want to check that two objects have the same value.
+     * This matcher recursively checks the equality of all fields, rather than checking for object identity.
+     */
+    toEqual(expected: unknown): R;
+    /**
+     * Ensures that a mock function is called.
+     */
+    toHaveBeenCalled(): R;
+    /**
+     * Ensures that a mock function is called an exact number of times.
+     */
+    toHaveBeenCalledTimes(expected: number): R;
+    /**
+     * Ensure that a mock function is called with specific arguments.
+     */
+    toHaveBeenCalledWith(...args: Array<unknown>): R;
+    /**
+     * Ensure that a mock function is called with specific arguments on an Nth call.
+     */
+    toHaveBeenNthCalledWith(nthCall: number, ...args: Array<unknown>): R;
+    /**
+     * If you have a mock function, you can use `.toHaveBeenLastCalledWith`
+     * to test what arguments it was last called with.
+     */
+    toHaveBeenLastCalledWith(...args: Array<unknown>): R;
+    /**
+     * Use to test the specific value that a mock function last returned.
+     * If the last call to the mock function threw an error, then this matcher will fail
+     * no matter what value you provided as the expected return value.
+     */
+    toHaveLastReturnedWith(expected: unknown): R;
+    /**
+     * Used to check that an object has a `.length` property
+     * and it is set to a certain numeric value.
+     */
+    toHaveLength(expected: number): R;
+    /**
+     * Use to test the specific value that a mock function returned for the nth call.
+     * If the nth call to the mock function threw an error, then this matcher will fail
+     * no matter what value you provided as the expected return value.
+     */
+    toHaveNthReturnedWith(nthCall: number, expected: unknown): R;
+    /**
+     * Use to check if property at provided reference keyPath exists for an object.
+     * For checking deeply nested properties in an object you may use dot notation or an array containing
+     * the keyPath for deep references.
+     *
+     * Optionally, you can provide a value to check if it's equal to the value present at keyPath
+     * on the target object. This matcher uses 'deep equality' (like `toEqual()`) and recursively checks
+     * the equality of all fields.
+     *
+     * @example
+     *
+     * expect(houseForSale).toHaveProperty('kitchen.area', 20);
+     */
+    toHaveProperty(keyPath: string | Array<string>, value?: unknown): R;
+    /**
+     * Use to test that the mock function successfully returned (i.e., did not throw an error) at least one time
+     */
+    toHaveReturned(): R;
+    /**
+     * Use to ensure that a mock function returned successfully (i.e., did not throw an error) an exact number of times.
+     * Any calls to the mock function that throw an error are not counted toward the number of times the function returned.
+     */
+    toHaveReturnedTimes(expected: number): R;
+    /**
+     * Use to ensure that a mock function returned a specific value.
+     */
+    toHaveReturnedWith(expected: unknown): R;
+    /**
+     * Check that a string matches a regular expression.
+     */
+    toMatch(expected: string | RegExp): R;
+    /**
+     * Used to check that a JavaScript object matches a subset of the properties of an object
+     */
+    toMatchObject(expected: Record<string, unknown> | Array<unknown>): R;
+    /**
+     * Ensure that a mock function has returned (as opposed to thrown) at least once.
+     */
+    toReturn(): R;
+    /**
+     * Ensure that a mock function has returned (as opposed to thrown) a specified number of times.
+     */
+    toReturnTimes(count: number): R;
+    /**
+     * Ensure that a mock function has returned a specified value at least once.
+     */
+    toReturnWith(value: unknown): R;
+    /**
+     * Use to test that objects have the same types as well as structure.
+     */
+    toStrictEqual(expected: unknown): R;
+    /**
+     * Used to test that a function throws when it is called.
+     */
+    toThrow(error?: string | Constructable | RegExp | Error): R;
+    /**
+     * If you want to test that a specific error is thrown inside a function.
+     */
+    toThrowError(error?: string | Constructable | RegExp | Error): R;
+    /**
+     * This ensures that a value matches the most recent snapshot with property matchers.
+     * Check out [the Snapshot Testing guide](https://jestjs.io/docs/snapshot-testing) for more information.
+     */
+    toMatchSnapshot<T extends {
+        [P in keyof R]: unknown;
+    }>(propertyMatchers: Partial<T>, snapshotName?: string): R;
+    /**
+     * This ensures that a value matches the most recent snapshot.
+     * Check out [the Snapshot Testing guide](https://jestjs.io/docs/snapshot-testing) for more information.
+     */
+    toMatchSnapshot(snapshotName?: string): R;
+    /**
+     * This ensures that a value matches the most recent snapshot with property matchers.
+     * Instead of writing the snapshot value to a .snap file, it will be written into the source code automatically.
+     * Check out [the Snapshot Testing guide](https://jestjs.io/docs/snapshot-testing) for more information.
+     */
+    toMatchInlineSnapshot<T extends {
+        [P in keyof R]: unknown;
+    }>(propertyMatchers: Partial<T>, snapshot?: string): R;
+    /**
+     * This ensures that a value matches the most recent snapshot with property matchers.
+     * Instead of writing the snapshot value to a .snap file, it will be written into the source code automatically.
+     * Check out [the Snapshot Testing guide](https://jestjs.io/docs/snapshot-testing) for more information.
+     */
+    toMatchInlineSnapshot(snapshot?: string): R;
+    /**
+     * Used to test that a function throws a error matching the most recent snapshot when it is called.
+     */
+    toThrowErrorMatchingSnapshot(): R;
+    /**
+     * Used to test that a function throws a error matching the most recent snapshot when it is called.
+     * Instead of writing the snapshot value to a .snap file, it will be written into the source code automatically.
+     */
+    toThrowErrorMatchingInlineSnapshot(snapshot?: string): R;
+}
+export {};

node_modules/expect/build/types.js

@@ -0,0 +1,3 @@
+'use strict';
+
+var _jestMatchersObject = require('./jestMatchersObject');

node_modules/expect/build/utils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+declare type GetPath = {
+    hasEndProp?: boolean;
+    lastTraversedObject: unknown;
+    traversedPath: Array<string>;
+    value?: unknown;
+};
+export declare const getPath: (object: Record<string, any>, propertyPath: string | Array<string>) => GetPath;
+export declare const getObjectSubset: (object: any, subset: any, seenReferences?: WeakMap<object, boolean>) => any;
+export declare const iterableEquality: (a: any, b: any, aStack?: Array<any>, bStack?: Array<any>) => boolean | undefined;
+export declare const subsetEquality: (object: unknown, subset: unknown) => boolean | undefined;
+export declare const typeEquality: (a: any, b: any) => boolean | undefined;
+export declare const sparseArrayEquality: (a: unknown, b: unknown) => boolean | undefined;
+export declare const partition: <T>(items: T[], predicate: (arg: T) => boolean) => [T[], T[]];
+export declare const isError: (value: unknown) => value is Error;
+export declare function emptyObject(obj: unknown): boolean;
+export declare const isOneline: (expected: unknown, received: unknown) => boolean;
+export {};

node_modules/expect/build/utils.js

@@ -0,0 +1,410 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.emptyObject = emptyObject;
+exports.isOneline =
+  exports.isError =
+  exports.partition =
+  exports.sparseArrayEquality =
+  exports.typeEquality =
+  exports.subsetEquality =
+  exports.iterableEquality =
+  exports.getObjectSubset =
+  exports.getPath =
+    void 0;
+
+var _jestGetType = require('jest-get-type');
+
+var _jasmineUtils = require('./jasmineUtils');
+
+var global = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global !== 'undefined') {
+    return global;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+/**
+ * Checks if `hasOwnProperty(object, key)` up the prototype chain, stopping at `Object.prototype`.
+ */
+const hasPropertyInObject = (object, key) => {
+  const shouldTerminate =
+    !object || typeof object !== 'object' || object === Object.prototype;
+
+  if (shouldTerminate) {
+    return false;
+  }
+
+  return (
+    Object.prototype.hasOwnProperty.call(object, key) ||
+    hasPropertyInObject(Object.getPrototypeOf(object), key)
+  );
+};
+
+const getPath = (object, propertyPath) => {
+  if (!Array.isArray(propertyPath)) {
+    propertyPath = propertyPath.split('.');
+  }
+
+  if (propertyPath.length) {
+    const lastProp = propertyPath.length === 1;
+    const prop = propertyPath[0];
+    const newObject = object[prop];
+
+    if (!lastProp && (newObject === null || newObject === undefined)) {
+      // This is not the last prop in the chain. If we keep recursing it will
+      // hit a `can't access property X of undefined | null`. At this point we
+      // know that the chain has broken and we can return right away.
+      return {
+        hasEndProp: false,
+        lastTraversedObject: object,
+        traversedPath: []
+      };
+    }
+
+    const result = getPath(newObject, propertyPath.slice(1));
+
+    if (result.lastTraversedObject === null) {
+      result.lastTraversedObject = object;
+    }
+
+    result.traversedPath.unshift(prop);
+
+    if (lastProp) {
+      // Does object have the property with an undefined value?
+      // Although primitive values support bracket notation (above)
+      // they would throw TypeError for in operator (below).
+      result.hasEndProp =
+        newObject !== undefined ||
+        (!(0, _jestGetType.isPrimitive)(object) && prop in object);
+
+      if (!result.hasEndProp) {
+        result.traversedPath.shift();
+      }
+    }
+
+    return result;
+  }
+
+  return {
+    lastTraversedObject: null,
+    traversedPath: [],
+    value: object
+  };
+}; // Strip properties from object that are not present in the subset. Useful for
+// printing the diff for toMatchObject() without adding unrelated noise.
+
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+
+exports.getPath = getPath;
+
+const getObjectSubset = (object, subset, seenReferences = new WeakMap()) => {
+  /* eslint-enable @typescript-eslint/explicit-module-boundary-types */
+  if (Array.isArray(object)) {
+    if (Array.isArray(subset) && subset.length === object.length) {
+      // The map method returns correct subclass of subset.
+      return subset.map((sub, i) => getObjectSubset(object[i], sub));
+    }
+  } else if (object instanceof Date) {
+    return object;
+  } else if (isObject(object) && isObject(subset)) {
+    if (
+      (0, _jasmineUtils.equals)(object, subset, [
+        iterableEquality,
+        subsetEquality
+      ])
+    ) {
+      // Avoid unnecessary copy which might return Object instead of subclass.
+      return subset;
+    }
+
+    const trimmed = {};
+    seenReferences.set(object, trimmed);
+    Object.keys(object)
+      .filter(key => hasPropertyInObject(subset, key))
+      .forEach(key => {
+        trimmed[key] = seenReferences.has(object[key])
+          ? seenReferences.get(object[key])
+          : getObjectSubset(object[key], subset[key], seenReferences);
+      });
+
+    if (Object.keys(trimmed).length > 0) {
+      return trimmed;
+    }
+  }
+
+  return object;
+};
+
+exports.getObjectSubset = getObjectSubset;
+const IteratorSymbol = Symbol.iterator;
+
+const hasIterator = object => !!(object != null && object[IteratorSymbol]);
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+
+const iterableEquality = (
+  a,
+  b,
+  /* eslint-enable @typescript-eslint/explicit-module-boundary-types */
+  aStack = [],
+  bStack = []
+) => {
+  if (
+    typeof a !== 'object' ||
+    typeof b !== 'object' ||
+    Array.isArray(a) ||
+    Array.isArray(b) ||
+    !hasIterator(a) ||
+    !hasIterator(b)
+  ) {
+    return undefined;
+  }
+
+  if (a.constructor !== b.constructor) {
+    return false;
+  }
+
+  let length = aStack.length;
+
+  while (length--) {
+    // Linear search. Performance is inversely proportional to the number of
+    // unique nested structures.
+    // circular references at same depth are equal
+    // circular reference is not equal to non-circular one
+    if (aStack[length] === a) {
+      return bStack[length] === b;
+    }
+  }
+
+  aStack.push(a);
+  bStack.push(b);
+
+  const iterableEqualityWithStack = (a, b) =>
+    iterableEquality(a, b, [...aStack], [...bStack]);
+
+  if (a.size !== undefined) {
+    if (a.size !== b.size) {
+      return false;
+    } else if (
+      (0, _jasmineUtils.isA)('Set', a) ||
+      (0, _jasmineUtils.isImmutableUnorderedSet)(a)
+    ) {
+      let allFound = true;
+
+      for (const aValue of a) {
+        if (!b.has(aValue)) {
+          let has = false;
+
+          for (const bValue of b) {
+            const isEqual = (0, _jasmineUtils.equals)(aValue, bValue, [
+              iterableEqualityWithStack
+            ]);
+
+            if (isEqual === true) {
+              has = true;
+            }
+          }
+
+          if (has === false) {
+            allFound = false;
+            break;
+          }
+        }
+      } // Remove the first value from the stack of traversed values.
+
+      aStack.pop();
+      bStack.pop();
+      return allFound;
+    } else if (
+      (0, _jasmineUtils.isA)('Map', a) ||
+      (0, _jasmineUtils.isImmutableUnorderedKeyed)(a)
+    ) {
+      let allFound = true;
+
+      for (const aEntry of a) {
+        if (
+          !b.has(aEntry[0]) ||
+          !(0, _jasmineUtils.equals)(aEntry[1], b.get(aEntry[0]), [
+            iterableEqualityWithStack
+          ])
+        ) {
+          let has = false;
+
+          for (const bEntry of b) {
+            const matchedKey = (0, _jasmineUtils.equals)(aEntry[0], bEntry[0], [
+              iterableEqualityWithStack
+            ]);
+            let matchedValue = false;
+
+            if (matchedKey === true) {
+              matchedValue = (0, _jasmineUtils.equals)(aEntry[1], bEntry[1], [
+                iterableEqualityWithStack
+              ]);
+            }
+
+            if (matchedValue === true) {
+              has = true;
+            }
+          }
+
+          if (has === false) {
+            allFound = false;
+            break;
+          }
+        }
+      } // Remove the first value from the stack of traversed values.
+
+      aStack.pop();
+      bStack.pop();
+      return allFound;
+    }
+  }
+
+  const bIterator = b[IteratorSymbol]();
+
+  for (const aValue of a) {
+    const nextB = bIterator.next();
+
+    if (
+      nextB.done ||
+      !(0, _jasmineUtils.equals)(aValue, nextB.value, [
+        iterableEqualityWithStack
+      ])
+    ) {
+      return false;
+    }
+  }
+
+  if (!bIterator.next().done) {
+    return false;
+  } // Remove the first value from the stack of traversed values.
+
+  aStack.pop();
+  bStack.pop();
+  return true;
+};
+
+exports.iterableEquality = iterableEquality;
+
+const isObject = a => a !== null && typeof a === 'object';
+
+const isObjectWithKeys = a =>
+  isObject(a) &&
+  !(a instanceof Error) &&
+  !(a instanceof Array) &&
+  !(a instanceof Date);
+
+const subsetEquality = (object, subset) => {
+  // subsetEquality needs to keep track of the references
+  // it has already visited to avoid infinite loops in case
+  // there are circular references in the subset passed to it.
+  const subsetEqualityWithContext =
+    (seenReferences = new WeakMap()) =>
+    (object, subset) => {
+      if (!isObjectWithKeys(subset)) {
+        return undefined;
+      }
+
+      return Object.keys(subset).every(key => {
+        if (isObjectWithKeys(subset[key])) {
+          if (seenReferences.has(subset[key])) {
+            return (0, _jasmineUtils.equals)(object[key], subset[key], [
+              iterableEquality
+            ]);
+          }
+
+          seenReferences.set(subset[key], true);
+        }
+
+        const result =
+          object != null &&
+          hasPropertyInObject(object, key) &&
+          (0, _jasmineUtils.equals)(object[key], subset[key], [
+            iterableEquality,
+            subsetEqualityWithContext(seenReferences)
+          ]); // The main goal of using seenReference is to avoid circular node on tree.
+        // It will only happen within a parent and its child, not a node and nodes next to it (same level)
+        // We should keep the reference for a parent and its child only
+        // Thus we should delete the reference immediately so that it doesn't interfere
+        // other nodes within the same level on tree.
+
+        seenReferences.delete(subset[key]);
+        return result;
+      });
+    };
+
+  return subsetEqualityWithContext()(object, subset);
+}; // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+
+exports.subsetEquality = subsetEquality;
+
+const typeEquality = (a, b) => {
+  if (a == null || b == null || a.constructor === b.constructor) {
+    return undefined;
+  }
+
+  return false;
+};
+
+exports.typeEquality = typeEquality;
+
+const sparseArrayEquality = (a, b) => {
+  if (!Array.isArray(a) || !Array.isArray(b)) {
+    return undefined;
+  } // A sparse array [, , 1] will have keys ["2"] whereas [undefined, undefined, 1] will have keys ["0", "1", "2"]
+
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  return (
+    (0, _jasmineUtils.equals)(a, b, [iterableEquality, typeEquality], true) &&
+    (0, _jasmineUtils.equals)(aKeys, bKeys)
+  );
+};
+
+exports.sparseArrayEquality = sparseArrayEquality;
+
+const partition = (items, predicate) => {
+  const result = [[], []];
+  items.forEach(item => result[predicate(item) ? 0 : 1].push(item));
+  return result;
+}; // Copied from https://github.com/graingert/angular.js/blob/a43574052e9775cbc1d7dd8a086752c979b0f020/src/Angular.js#L685-L693
+
+exports.partition = partition;
+
+const isError = value => {
+  switch (Object.prototype.toString.call(value)) {
+    case '[object Error]':
+    case '[object Exception]':
+    case '[object DOMException]':
+      return true;
+
+    default:
+      return value instanceof Error;
+  }
+};
+
+exports.isError = isError;
+
+function emptyObject(obj) {
+  return obj && typeof obj === 'object' ? !Object.keys(obj).length : false;
+}
+
+const MULTILINE_REGEXP = /[\r\n]/;
+
+const isOneline = (expected, received) =>
+  typeof expected === 'string' &&
+  typeof received === 'string' &&
+  (!MULTILINE_REGEXP.test(expected) || !MULTILINE_REGEXP.test(received));
+
+exports.isOneline = isOneline;

node_modules/expect/node_modules/ansi-styles/index.d.ts

@@ -0,0 +1,167 @@
+declare namespace ansiStyles {
+	interface CSPair {
+		/**
+		The ANSI terminal control sequence for starting this style.
+		*/
+		readonly open: string;
+
+		/**
+		The ANSI terminal control sequence for ending this style.
+		*/
+		readonly close: string;
+	}
+
+	interface ColorBase {
+		/**
+		The ANSI terminal control sequence for ending this color.
+		*/
+		readonly close: string;
+
+		ansi256(code: number): string;
+
+		ansi16m(red: number, green: number, blue: number): string;
+	}
+
+	interface Modifier {
+		/**
+		Resets the current color chain.
+		*/
+		readonly reset: CSPair;
+
+		/**
+		Make text bold.
+		*/
+		readonly bold: CSPair;
+
+		/**
+		Emitting only a small amount of light.
+		*/
+		readonly dim: CSPair;
+
+		/**
+		Make text italic. (Not widely supported)
+		*/
+		readonly italic: CSPair;
+
+		/**
+		Make text underline. (Not widely supported)
+		*/
+		readonly underline: CSPair;
+
+		/**
+		Make text overline.
+
+		Supported on VTE-based terminals, the GNOME terminal, mintty, and Git Bash.
+		*/
+		readonly overline: CSPair;
+
+		/**
+		Inverse background and foreground colors.
+		*/
+		readonly inverse: CSPair;
+
+		/**
+		Prints the text, but makes it invisible.
+		*/
+		readonly hidden: CSPair;
+
+		/**
+		Puts a horizontal line through the center of the text. (Not widely supported)
+		*/
+		readonly strikethrough: CSPair;
+	}
+
+	interface ForegroundColor {
+		readonly black: CSPair;
+		readonly red: CSPair;
+		readonly green: CSPair;
+		readonly yellow: CSPair;
+		readonly blue: CSPair;
+		readonly cyan: CSPair;
+		readonly magenta: CSPair;
+		readonly white: CSPair;
+
+		/**
+		Alias for `blackBright`.
+		*/
+		readonly gray: CSPair;
+
+		/**
+		Alias for `blackBright`.
+		*/
+		readonly grey: CSPair;
+
+		readonly blackBright: CSPair;
+		readonly redBright: CSPair;
+		readonly greenBright: CSPair;
+		readonly yellowBright: CSPair;
+		readonly blueBright: CSPair;
+		readonly cyanBright: CSPair;
+		readonly magentaBright: CSPair;
+		readonly whiteBright: CSPair;
+	}
+
+	interface BackgroundColor {
+		readonly bgBlack: CSPair;
+		readonly bgRed: CSPair;
+		readonly bgGreen: CSPair;
+		readonly bgYellow: CSPair;
+		readonly bgBlue: CSPair;
+		readonly bgCyan: CSPair;
+		readonly bgMagenta: CSPair;
+		readonly bgWhite: CSPair;
+
+		/**
+		Alias for `bgBlackBright`.
+		*/
+		readonly bgGray: CSPair;
+
+		/**
+		Alias for `bgBlackBright`.
+		*/
+		readonly bgGrey: CSPair;
+
+		readonly bgBlackBright: CSPair;
+		readonly bgRedBright: CSPair;
+		readonly bgGreenBright: CSPair;
+		readonly bgYellowBright: CSPair;
+		readonly bgBlueBright: CSPair;
+		readonly bgCyanBright: CSPair;
+		readonly bgMagentaBright: CSPair;
+		readonly bgWhiteBright: CSPair;
+	}
+
+	interface ConvertColor {
+		/**
+		Convert from the RGB color space to the ANSI 256 color space.
+
+		@param red - (`0...255`)
+		@param green - (`0...255`)
+		@param blue - (`0...255`)
+		*/
+		rgbToAnsi256(red: number, green: number, blue: number): number;
+
+		/**
+		Convert from the RGB HEX color space to the RGB color space.
+
+		@param hex - A hexadecimal string containing RGB data.
+		*/
+		hexToRgb(hex: string): [red: number, green: number, blue: number];
+
+		/**
+		Convert from the RGB HEX color space to the ANSI 256 color space.
+
+		@param hex - A hexadecimal string containing RGB data.
+		*/
+		hexToAnsi256(hex: string): number;
+	}
+}
+
+declare const ansiStyles: {
+	readonly modifier: ansiStyles.Modifier;
+	readonly color: ansiStyles.ForegroundColor & ansiStyles.ColorBase;
+	readonly bgColor: ansiStyles.BackgroundColor & ansiStyles.ColorBase;
+	readonly codes: ReadonlyMap<number, number>;
+} & ansiStyles.BackgroundColor & ansiStyles.ForegroundColor & ansiStyles.Modifier & ansiStyles.ConvertColor;
+
+export = ansiStyles;

node_modules/expect/node_modules/ansi-styles/index.js

@@ -0,0 +1,164 @@
+'use strict';
+
+const ANSI_BACKGROUND_OFFSET = 10;
+
+const wrapAnsi256 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`;
+
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+
+function assembleStyles() {
+	const codes = new Map();
+	const styles = {
+		modifier: {
+			reset: [0, 0],
+			// 21 isn't widely supported and 22 does the same thing
+			bold: [1, 22],
+			dim: [2, 22],
+			italic: [3, 23],
+			underline: [4, 24],
+			overline: [53, 55],
+			inverse: [7, 27],
+			hidden: [8, 28],
+			strikethrough: [9, 29]
+		},
+		color: {
+			black: [30, 39],
+			red: [31, 39],
+			green: [32, 39],
+			yellow: [33, 39],
+			blue: [34, 39],
+			magenta: [35, 39],
+			cyan: [36, 39],
+			white: [37, 39],
+
+			// Bright color
+			blackBright: [90, 39],
+			redBright: [91, 39],
+			greenBright: [92, 39],
+			yellowBright: [93, 39],
+			blueBright: [94, 39],
+			magentaBright: [95, 39],
+			cyanBright: [96, 39],
+			whiteBright: [97, 39]
+		},
+		bgColor: {
+			bgBlack: [40, 49],
+			bgRed: [41, 49],
+			bgGreen: [42, 49],
+			bgYellow: [43, 49],
+			bgBlue: [44, 49],
+			bgMagenta: [45, 49],
+			bgCyan: [46, 49],
+			bgWhite: [47, 49],
+
+			// Bright color
+			bgBlackBright: [100, 49],
+			bgRedBright: [101, 49],
+			bgGreenBright: [102, 49],
+			bgYellowBright: [103, 49],
+			bgBlueBright: [104, 49],
+			bgMagentaBright: [105, 49],
+			bgCyanBright: [106, 49],
+			bgWhiteBright: [107, 49]
+		}
+	};
+
+	// Alias bright black as gray (and grey)
+	styles.color.gray = styles.color.blackBright;
+	styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+	styles.color.grey = styles.color.blackBright;
+	styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+
+	for (const [groupName, group] of Object.entries(styles)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`
+			};
+
+			group[styleName] = styles[styleName];
+
+			codes.set(style[0], style[1]);
+		}
+
+		Object.defineProperty(styles, groupName, {
+			value: group,
+			enumerable: false
+		});
+	}
+
+	Object.defineProperty(styles, 'codes', {
+		value: codes,
+		enumerable: false
+	});
+
+	styles.color.close = '\u001B[39m';
+	styles.bgColor.close = '\u001B[49m';
+
+	styles.color.ansi256 = wrapAnsi256();
+	styles.color.ansi16m = wrapAnsi16m();
+	styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+	styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+
+	// From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js
+	Object.defineProperties(styles, {
+		rgbToAnsi256: {
+			value: (red, green, blue) => {
+				// We use the extended greyscale palette here, with the exception of
+				// black and white. normal palette only has 4 greyscale shades.
+				if (red === green && green === blue) {
+					if (red < 8) {
+						return 16;
+					}
+
+					if (red > 248) {
+						return 231;
+					}
+
+					return Math.round(((red - 8) / 247) * 24) + 232;
+				}
+
+				return 16 +
+					(36 * Math.round(red / 255 * 5)) +
+					(6 * Math.round(green / 255 * 5)) +
+					Math.round(blue / 255 * 5);
+			},
+			enumerable: false
+		},
+		hexToRgb: {
+			value: hex => {
+				const matches = /(?<colorString>[a-f\d]{6}|[a-f\d]{3})/i.exec(hex.toString(16));
+				if (!matches) {
+					return [0, 0, 0];
+				}
+
+				let {colorString} = matches.groups;
+
+				if (colorString.length === 3) {
+					colorString = colorString.split('').map(character => character + character).join('');
+				}
+
+				const integer = Number.parseInt(colorString, 16);
+
+				return [
+					(integer >> 16) & 0xFF,
+					(integer >> 8) & 0xFF,
+					integer & 0xFF
+				];
+			},
+			enumerable: false
+		},
+		hexToAnsi256: {
+			value: hex => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+			enumerable: false
+		}
+	});
+
+	return styles;
+}
+
+// Make the export immutable
+Object.defineProperty(module, 'exports', {
+	enumerable: true,
+	get: assembleStyles
+});

node_modules/expect/node_modules/ansi-styles/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/expect/node_modules/ansi-styles/package.json

@@ -0,0 +1,88 @@
+{
+  "_args": [
+    [
+      "ansi-styles@5.2.0",
+      "/home/pi/Desktop/smartMirrorTestEnvironment/MagicMirror"
+    ]
+  ],
+  "_development": true,
+  "_from": "ansi-styles@5.2.0",
+  "_id": "ansi-styles@5.2.0",
+  "_inBundle": false,
+  "_integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+  "_location": "/expect/ansi-styles",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "ansi-styles@5.2.0",
+    "name": "ansi-styles",
+    "escapedName": "ansi-styles",
+    "rawSpec": "5.2.0",
+    "saveSpec": null,
+    "fetchSpec": "5.2.0"
+  },
+  "_requiredBy": [
+    "/expect"
+  ],
+  "_resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
+  "_spec": "5.2.0",
+  "_where": "/home/pi/Desktop/smartMirrorTestEnvironment/MagicMirror",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "https://sindresorhus.com"
+  },
+  "bugs": {
+    "url": "https://github.com/chalk/ansi-styles/issues"
+  },
+  "description": "ANSI escape codes for styling strings in the terminal",
+  "devDependencies": {
+    "ava": "^2.4.0",
+    "svg-term-cli": "^2.1.1",
+    "tsd": "^0.14.0",
+    "xo": "^0.37.1"
+  },
+  "engines": {
+    "node": ">=10"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "funding": "https://github.com/chalk/ansi-styles?sponsor=1",
+  "homepage": "https://github.com/chalk/ansi-styles#readme",
+  "keywords": [
+    "ansi",
+    "styles",
+    "color",
+    "colour",
+    "colors",
+    "terminal",
+    "console",
+    "cli",
+    "string",
+    "tty",
+    "escape",
+    "formatting",
+    "rgb",
+    "256",
+    "shell",
+    "xterm",
+    "log",
+    "logging",
+    "command-line",
+    "text"
+  ],
+  "license": "MIT",
+  "name": "ansi-styles",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chalk/ansi-styles.git"
+  },
+  "scripts": {
+    "screenshot": "svg-term --command='node screenshot' --out=screenshot.svg --padding=3 --width=55 --height=3 --at=1000 --no-cursor",
+    "test": "xo && ava && tsd"
+  },
+  "version": "5.2.0"
+}

node_modules/expect/node_modules/ansi-styles/readme.md

@@ -0,0 +1,144 @@
+# ansi-styles
+
+> [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors_and_Styles) for styling strings in the terminal
+
+You probably want the higher-level [chalk](https://github.com/chalk/chalk) module for styling your strings.
+
+<img src="screenshot.svg" width="900">
+
+## Install
+
+```
+$ npm install ansi-styles
+```
+
+## Usage
+
+```js
+const style = require('ansi-styles');
+
+console.log(`${style.green.open}Hello world!${style.green.close}`);
+
+
+// Color conversion between 256/truecolor
+// NOTE: When converting from truecolor to 256 colors, the original color
+//       may be degraded to fit the new color palette. This means terminals
+//       that do not support 16 million colors will best-match the
+//       original color.
+console.log(`${style.color.ansi256(style.rgbToAnsi256(199, 20, 250))}Hello World${style.color.close}`)
+console.log(`${style.color.ansi16m(...style.hexToRgb('#abcdef'))}Hello World${style.color.close}`)
+```
+
+## API
+
+Each style has an `open` and `close` property.
+
+## Styles
+
+### Modifiers
+
+- `reset`
+- `bold`
+- `dim`
+- `italic` *(Not widely supported)*
+- `underline`
+- `overline` *Supported on VTE-based terminals, the GNOME terminal, mintty, and Git Bash.*
+- `inverse`
+- `hidden`
+- `strikethrough` *(Not widely supported)*
+
+### Colors
+
+- `black`
+- `red`
+- `green`
+- `yellow`
+- `blue`
+- `magenta`
+- `cyan`
+- `white`
+- `blackBright` (alias: `gray`, `grey`)
+- `redBright`
+- `greenBright`
+- `yellowBright`
+- `blueBright`
+- `magentaBright`
+- `cyanBright`
+- `whiteBright`
+
+### Background colors
+
+- `bgBlack`
+- `bgRed`
+- `bgGreen`
+- `bgYellow`
+- `bgBlue`
+- `bgMagenta`
+- `bgCyan`
+- `bgWhite`
+- `bgBlackBright` (alias: `bgGray`, `bgGrey`)
+- `bgRedBright`
+- `bgGreenBright`
+- `bgYellowBright`
+- `bgBlueBright`
+- `bgMagentaBright`
+- `bgCyanBright`
+- `bgWhiteBright`
+
+## Advanced usage
+
+By default, you get a map of styles, but the styles are also available as groups. They are non-enumerable so they don't show up unless you access them explicitly. This makes it easier to expose only a subset in a higher-level module.
+
+- `style.modifier`
+- `style.color`
+- `style.bgColor`
+
+###### Example
+
+```js
+console.log(style.color.green.open);
+```
+
+Raw escape codes (i.e. without the CSI escape prefix `\u001B[` and render mode postfix `m`) are available under `style.codes`, which returns a `Map` with the open codes as keys and close codes as values.
+
+###### Example
+
+```js
+console.log(style.codes.get(36));
+//=> 39
+```
+
+## [256 / 16 million (TrueColor) support](https://gist.github.com/XVilka/8346728)
+
+`ansi-styles` allows converting between various color formats and ANSI escapes, with support for 256 and 16 million colors.
+
+The following color spaces from `color-convert` are supported:
+
+- `rgb`
+- `hex`
+- `ansi256`
+
+To use these, call the associated conversion function with the intended output, for example:
+
+```js
+style.color.ansi256(style.rgbToAnsi256(100, 200, 15)); // RGB to 256 color ansi foreground code
+style.bgColor.ansi256(style.hexToAnsi256('#C0FFEE')); // HEX to 256 color ansi foreground code
+
+style.color.ansi16m(100, 200, 15); // RGB to 16 million color foreground code
+style.bgColor.ansi16m(...style.hexToRgb('#C0FFEE')); // Hex (RGB) to 16 million color foreground code
+```
+
+## Related
+
+- [ansi-escapes](https://github.com/sindresorhus/ansi-escapes) - ANSI escape codes for manipulating the terminal
+
+## Maintainers
+
+- [Sindre Sorhus](https://github.com/sindresorhus)
+- [Josh Junon](https://github.com/qix-)
+
+## For enterprise
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of `ansi-styles` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-ansi-styles?utm_source=npm-ansi-styles&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)

node_modules/expect/package.json

@@ -0,0 +1,75 @@
+{
+  "_args": [
+    [
+      "expect@27.2.2",
+      "/home/pi/Desktop/smartMirrorTestEnvironment/MagicMirror"
+    ]
+  ],
+  "_development": true,
+  "_from": "expect@27.2.2",
+  "_id": "expect@27.2.2",
+  "_inBundle": false,
+  "_integrity": "sha512-sjHBeEk47/eshN9oLbvPJZMgHQihOXXQzSMPCJ4MqKShbU9HOVFSNHEEU4dp4ujzxFSiNvPFzB2AMOFmkizhvA==",
+  "_location": "/expect",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "expect@27.2.2",
+    "name": "expect",
+    "escapedName": "expect",
+    "rawSpec": "27.2.2",
+    "saveSpec": null,
+    "fetchSpec": "27.2.2"
+  },
+  "_requiredBy": [
+    "/@jest/globals",
+    "/jest-circus",
+    "/jest-jasmine2",
+    "/jest-snapshot"
+  ],
+  "_resolved": "https://registry.npmjs.org/expect/-/expect-27.2.2.tgz",
+  "_spec": "27.2.2",
+  "_where": "/home/pi/Desktop/smartMirrorTestEnvironment/MagicMirror",
+  "bugs": {
+    "url": "https://github.com/facebook/jest/issues"
+  },
+  "dependencies": {
+    "@jest/types": "^27.1.1",
+    "ansi-styles": "^5.0.0",
+    "jest-get-type": "^27.0.6",
+    "jest-matcher-utils": "^27.2.2",
+    "jest-message-util": "^27.2.2",
+    "jest-regex-util": "^27.0.6"
+  },
+  "description": "This package exports the `expect` function used in [Jest](https://jestjs.io/). You can find its documentation [on Jest's website](https://jestjs.io/docs/expect).",
+  "devDependencies": {
+    "@jest/test-utils": "^27.2.2",
+    "chalk": "^4.0.0",
+    "fast-check": "^2.0.0",
+    "immutable": "^4.0.0-rc.12"
+  },
+  "engines": {
+    "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0"
+  },
+  "exports": {
+    ".": "./build/index.js",
+    "./package.json": "./package.json",
+    "./build/utils": "./build/utils.js"
+  },
+  "gitHead": "f54d96fec55518640b900d6994b2c4153316d1ed",
+  "homepage": "https://github.com/facebook/jest#readme",
+  "license": "MIT",
+  "main": "./build/index.js",
+  "name": "expect",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/facebook/jest.git",
+    "directory": "packages/expect"
+  },
+  "types": "./build/index.d.ts",
+  "version": "27.2.2"
+}