applying transfer to react app

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/en/expect.html).

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,310 @@
+'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 _utils = require('./utils');
+
+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 +
+          "'."
+      );
+    }
+
+    if (this.inverse) {
+      for (const property in this.sample) {
+        if (
+          (0, _jasmineUtils.hasProperty)(other, property) &&
+          (0, _jasmineUtils.equals)(this.sample[property], other[property]) &&
+          !(0, _utils.emptyObject)(this.sample[property]) &&
+          !(0, _utils.emptyObject)(other[property])
+        ) {
+          return false;
+        }
+      }
+
+      return true;
+    } else {
+      for (const property in this.sample) {
+        if (
+          !(0, _jasmineUtils.hasProperty)(other, property) ||
+          !(0, _jasmineUtils.equals)(this.sample[property], other[property])
+        ) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+  }
+
+  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,435 @@
+'use strict';
+
+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() {
+  if (typeof WeakMap !== 'function') return null;
+  var cache = new WeakMap();
+  _getRequireWildcardCache = function () {
+    return cache;
+  };
+  return cache;
+}
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache();
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (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 Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+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;
+
+        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,312 @@
+'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);
+  var size = 0; // Recursively compare objects and arrays.
+  // Compare array lengths to determine if a deep comparison is necessary.
+
+  if (className == '[object Array]') {
+    size = a.length;
+
+    if (size !== b.length) {
+      return false;
+    }
+
+    while (size--) {
+      result = eq(a[size], b[size], aStack, bStack, customTesters, hasKey);
+
+      if (!result) {
+        return false;
+      }
+    }
+  } // Deep compare objects.
+
+  var aKeys = keys(a, className == '[object Array]', hasKey),
+    key;
+  size = aKeys.length; // Ensure that both objects contain the same number of properties before comparing deep equality.
+
+  if (keys(b, className == '[object Array]', 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, isArray, hasKey) {
+  var allKeys = (function (o) {
+    var keys = [];
+
+    for (var key in o) {
+      if (hasKey(o, key)) {
+        keys.push(key);
+      }
+    }
+
+    return keys.concat(
+      Object.getOwnPropertySymbols(o).filter(
+        symbol => Object.getOwnPropertyDescriptor(o, symbol).enumerable
+      )
+    );
+  })(obj);
+
+  if (!isArray) {
+    return allKeys;
+  }
+
+  var extraKeys = [];
+
+  if (allKeys.length === 0) {
+    return allKeys;
+  }
+
+  for (var x = 0; x < allKeys.length; x++) {
+    if (typeof allKeys[x] === 'symbol' || !allKeys[x].match(/^[0-9]+$/)) {
+      extraKeys.push(allKeys[x]);
+    }
+  }
+
+  return extraKeys;
+}
+
+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,93 @@
+'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 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,126 @@
+'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) =>
+  (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/en/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/en/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/en/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/en/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,392 @@
+'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 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]':
+      return true;
+
+    case '[object Exception]':
+      return true;
+
+    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,345 @@
+declare type CSSColor =
+	| 'aliceblue'
+	| 'antiquewhite'
+	| 'aqua'
+	| 'aquamarine'
+	| 'azure'
+	| 'beige'
+	| 'bisque'
+	| 'black'
+	| 'blanchedalmond'
+	| 'blue'
+	| 'blueviolet'
+	| 'brown'
+	| 'burlywood'
+	| 'cadetblue'
+	| 'chartreuse'
+	| 'chocolate'
+	| 'coral'
+	| 'cornflowerblue'
+	| 'cornsilk'
+	| 'crimson'
+	| 'cyan'
+	| 'darkblue'
+	| 'darkcyan'
+	| 'darkgoldenrod'
+	| 'darkgray'
+	| 'darkgreen'
+	| 'darkgrey'
+	| 'darkkhaki'
+	| 'darkmagenta'
+	| 'darkolivegreen'
+	| 'darkorange'
+	| 'darkorchid'
+	| 'darkred'
+	| 'darksalmon'
+	| 'darkseagreen'
+	| 'darkslateblue'
+	| 'darkslategray'
+	| 'darkslategrey'
+	| 'darkturquoise'
+	| 'darkviolet'
+	| 'deeppink'
+	| 'deepskyblue'
+	| 'dimgray'
+	| 'dimgrey'
+	| 'dodgerblue'
+	| 'firebrick'
+	| 'floralwhite'
+	| 'forestgreen'
+	| 'fuchsia'
+	| 'gainsboro'
+	| 'ghostwhite'
+	| 'gold'
+	| 'goldenrod'
+	| 'gray'
+	| 'green'
+	| 'greenyellow'
+	| 'grey'
+	| 'honeydew'
+	| 'hotpink'
+	| 'indianred'
+	| 'indigo'
+	| 'ivory'
+	| 'khaki'
+	| 'lavender'
+	| 'lavenderblush'
+	| 'lawngreen'
+	| 'lemonchiffon'
+	| 'lightblue'
+	| 'lightcoral'
+	| 'lightcyan'
+	| 'lightgoldenrodyellow'
+	| 'lightgray'
+	| 'lightgreen'
+	| 'lightgrey'
+	| 'lightpink'
+	| 'lightsalmon'
+	| 'lightseagreen'
+	| 'lightskyblue'
+	| 'lightslategray'
+	| 'lightslategrey'
+	| 'lightsteelblue'
+	| 'lightyellow'
+	| 'lime'
+	| 'limegreen'
+	| 'linen'
+	| 'magenta'
+	| 'maroon'
+	| 'mediumaquamarine'
+	| 'mediumblue'
+	| 'mediumorchid'
+	| 'mediumpurple'
+	| 'mediumseagreen'
+	| 'mediumslateblue'
+	| 'mediumspringgreen'
+	| 'mediumturquoise'
+	| 'mediumvioletred'
+	| 'midnightblue'
+	| 'mintcream'
+	| 'mistyrose'
+	| 'moccasin'
+	| 'navajowhite'
+	| 'navy'
+	| 'oldlace'
+	| 'olive'
+	| 'olivedrab'
+	| 'orange'
+	| 'orangered'
+	| 'orchid'
+	| 'palegoldenrod'
+	| 'palegreen'
+	| 'paleturquoise'
+	| 'palevioletred'
+	| 'papayawhip'
+	| 'peachpuff'
+	| 'peru'
+	| 'pink'
+	| 'plum'
+	| 'powderblue'
+	| 'purple'
+	| 'rebeccapurple'
+	| 'red'
+	| 'rosybrown'
+	| 'royalblue'
+	| 'saddlebrown'
+	| 'salmon'
+	| 'sandybrown'
+	| 'seagreen'
+	| 'seashell'
+	| 'sienna'
+	| 'silver'
+	| 'skyblue'
+	| 'slateblue'
+	| 'slategray'
+	| 'slategrey'
+	| 'snow'
+	| 'springgreen'
+	| 'steelblue'
+	| 'tan'
+	| 'teal'
+	| 'thistle'
+	| 'tomato'
+	| 'turquoise'
+	| 'violet'
+	| 'wheat'
+	| 'white'
+	| 'whitesmoke'
+	| 'yellow'
+	| 'yellowgreen';
+
+declare namespace ansiStyles {
+	interface ColorConvert {
+		/**
+		The RGB color space.
+
+		@param red - (`0`-`255`)
+		@param green - (`0`-`255`)
+		@param blue - (`0`-`255`)
+		*/
+		rgb(red: number, green: number, blue: number): string;
+
+		/**
+		The RGB HEX color space.
+
+		@param hex - A hexadecimal string containing RGB data.
+		*/
+		hex(hex: string): string;
+
+		/**
+		@param keyword - A CSS color name.
+		*/
+		keyword(keyword: CSSColor): string;
+
+		/**
+		The HSL color space.
+
+		@param hue - (`0`-`360`)
+		@param saturation - (`0`-`100`)
+		@param lightness - (`0`-`100`)
+		*/
+		hsl(hue: number, saturation: number, lightness: number): string;
+
+		/**
+		The HSV color space.
+
+		@param hue - (`0`-`360`)
+		@param saturation - (`0`-`100`)
+		@param value - (`0`-`100`)
+		*/
+		hsv(hue: number, saturation: number, value: number): string;
+
+		/**
+		The HSV color space.
+
+		@param hue - (`0`-`360`)
+		@param whiteness - (`0`-`100`)
+		@param blackness - (`0`-`100`)
+		*/
+		hwb(hue: number, whiteness: number, blackness: number): string;
+
+		/**
+		Use a [4-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#3/4-bit) to set text color.
+		*/
+		ansi(ansi: number): string;
+
+		/**
+		Use an [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set text color.
+		*/
+		ansi256(ansi: number): string;
+	}
+
+	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 {
+		readonly ansi: ColorConvert;
+		readonly ansi256: ColorConvert;
+		readonly ansi16m: ColorConvert;
+
+		/**
+		The ANSI terminal control sequence for ending this color.
+		*/
+		readonly close: 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;
+
+		/**
+		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;
+	}
+}
+
+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;
+
+export = ansiStyles;

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

@@ -0,0 +1,163 @@
+'use strict';
+
+const wrapAnsi16 = (fn, offset) => (...args) => {
+	const code = fn(...args);
+	return `\u001B[${code + offset}m`;
+};
+
+const wrapAnsi256 = (fn, offset) => (...args) => {
+	const code = fn(...args);
+	return `\u001B[${38 + offset};5;${code}m`;
+};
+
+const wrapAnsi16m = (fn, offset) => (...args) => {
+	const rgb = fn(...args);
+	return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+};
+
+const ansi2ansi = n => n;
+const rgb2rgb = (r, g, b) => [r, g, b];
+
+const setLazyProperty = (object, property, get) => {
+	Object.defineProperty(object, property, {
+		get: () => {
+			const value = get();
+
+			Object.defineProperty(object, property, {
+				value,
+				enumerable: true,
+				configurable: true
+			});
+
+			return value;
+		},
+		enumerable: true,
+		configurable: true
+	});
+};
+
+/** @type {typeof import('color-convert')} */
+let colorConvert;
+const makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
+	if (colorConvert === undefined) {
+		colorConvert = require('color-convert');
+	}
+
+	const offset = isBackground ? 10 : 0;
+	const styles = {};
+
+	for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
+		const name = sourceSpace === 'ansi16' ? 'ansi' : sourceSpace;
+		if (sourceSpace === targetSpace) {
+			styles[name] = wrap(identity, offset);
+		} else if (typeof suite === 'object') {
+			styles[name] = wrap(suite[targetSpace], offset);
+		}
+	}
+
+	return styles;
+};
+
+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],
+			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';
+
+	setLazyProperty(styles.color, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, false));
+	setLazyProperty(styles.color, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, false));
+	setLazyProperty(styles.color, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, false));
+	setLazyProperty(styles.bgColor, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, true));
+	setLazyProperty(styles.bgColor, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, true));
+	setLazyProperty(styles.bgColor, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, true));
+
+	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 @@
+{
+  "_from": "ansi-styles@^4.0.0",
+  "_id": "ansi-styles@4.3.0",
+  "_inBundle": false,
+  "_integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+  "_location": "/expect/ansi-styles",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "ansi-styles@^4.0.0",
+    "name": "ansi-styles",
+    "escapedName": "ansi-styles",
+    "rawSpec": "^4.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^4.0.0"
+  },
+  "_requiredBy": [
+    "/expect"
+  ],
+  "_resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+  "_shasum": "edd803628ae71c04c85ae7a0906edad34b648937",
+  "_spec": "ansi-styles@^4.0.0",
+  "_where": "/Users/tylerkoenig/Code/personal/react-scss2/node_modules/expect",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "sindresorhus.com"
+  },
+  "bugs": {
+    "url": "https://github.com/chalk/ansi-styles/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "color-convert": "^2.0.1"
+  },
+  "deprecated": false,
+  "description": "ANSI escape codes for styling strings in the terminal",
+  "devDependencies": {
+    "@types/color-convert": "^1.9.0",
+    "ava": "^2.3.0",
+    "svg-term-cli": "^2.1.1",
+    "tsd": "^0.11.0",
+    "xo": "^0.25.3"
+  },
+  "engines": {
+    "node": ">=8"
+  },
+  "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": "4.3.0"
+}

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

@@ -0,0 +1,152 @@
+# ansi-styles [![Build Status](https://travis-ci.org/chalk/ansi-styles.svg?branch=master)](https://travis-ci.org/chalk/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 16/256/truecolor
+// NOTE: If conversion goes to 16 colors or 256 colors, the original color
+//       may be degraded to fit that color palette. This means terminals
+//       that do not support 16 million colors will best-match the
+//       original color.
+console.log(style.bgColor.ansi.hsl(120, 80, 72) + 'Hello world!' + style.bgColor.close);
+console.log(style.color.ansi256.rgb(199, 20, 250) + 'Hello world!' + style.color.close);
+console.log(style.color.ansi16m.hex('#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`
+- `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` uses the [`color-convert`](https://github.com/Qix-/color-convert) package to allow for converting between various colors and ANSI escapes, with support for 256 and 16 million colors.
+
+The following color spaces from `color-convert` are supported:
+
+- `rgb`
+- `hex`
+- `keyword`
+- `hsl`
+- `hsv`
+- `hwb`
+- `ansi`
+- `ansi256`
+
+To use these, call the associated conversion function with the intended output, for example:
+
+```js
+style.color.ansi.rgb(100, 200, 15); // RGB to 16 color ansi foreground code
+style.bgColor.ansi.rgb(100, 200, 15); // RGB to 16 color ansi background code
+
+style.color.ansi256.hsl(120, 100, 60); // HSL to 256 color ansi foreground code
+style.bgColor.ansi256.hsl(120, 100, 60); // HSL to 256 color ansi foreground code
+
+style.color.ansi16m.hex('#C0FFEE'); // Hex (RGB) to 16 million color foreground code
+style.bgColor.ansi16m.hex('#C0FFEE'); // Hex (RGB) to 16 million color background 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/node_modules/color-convert/CHANGELOG.md

@@ -0,0 +1,54 @@
+# 1.0.0 - 2016-01-07
+
+- Removed: unused speed test
+- Added: Automatic routing between previously unsupported conversions
+([#27](https://github.com/Qix-/color-convert/pull/27))
+- Removed: `xxx2xxx()` and `xxx2xxxRaw()` functions
+([#27](https://github.com/Qix-/color-convert/pull/27))
+- Removed: `convert()` class
+([#27](https://github.com/Qix-/color-convert/pull/27))
+- Changed: all functions to lookup dictionary
+([#27](https://github.com/Qix-/color-convert/pull/27))
+- Changed: `ansi` to `ansi256`
+([#27](https://github.com/Qix-/color-convert/pull/27))
+- Fixed: argument grouping for functions requiring only one argument
+([#27](https://github.com/Qix-/color-convert/pull/27))
+
+# 0.6.0 - 2015-07-23
+
+- Added: methods to handle
+[ANSI](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors) 16/256 colors:
+  - rgb2ansi16
+  - rgb2ansi
+  - hsl2ansi16
+  - hsl2ansi
+  - hsv2ansi16
+  - hsv2ansi
+  - hwb2ansi16
+  - hwb2ansi
+  - cmyk2ansi16
+  - cmyk2ansi
+  - keyword2ansi16
+  - keyword2ansi
+  - ansi162rgb
+  - ansi162hsl
+  - ansi162hsv
+  - ansi162hwb
+  - ansi162cmyk
+  - ansi162keyword
+  - ansi2rgb
+  - ansi2hsl
+  - ansi2hsv
+  - ansi2hwb
+  - ansi2cmyk
+  - ansi2keyword
+([#18](https://github.com/harthur/color-convert/pull/18))
+
+# 0.5.3 - 2015-06-02
+
+- Fixed: hsl2hsv does not return `NaN` anymore when using `[0,0,0]`
+([#15](https://github.com/harthur/color-convert/issues/15))
+
+---
+
+Check out commit logs for older releases

node_modules/expect/node_modules/color-convert/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2011-2016 Heather Arthur <fayearthur@gmail.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/color-convert/README.md

@@ -0,0 +1,68 @@
+# color-convert
+
+[![Build Status](https://travis-ci.org/Qix-/color-convert.svg?branch=master)](https://travis-ci.org/Qix-/color-convert)
+
+Color-convert is a color conversion library for JavaScript and node.
+It converts all ways between `rgb`, `hsl`, `hsv`, `hwb`, `cmyk`, `ansi`, `ansi16`, `hex` strings, and CSS `keyword`s (will round to closest):
+
+```js
+var convert = require('color-convert');
+
+convert.rgb.hsl(140, 200, 100);             // [96, 48, 59]
+convert.keyword.rgb('blue');                // [0, 0, 255]
+
+var rgbChannels = convert.rgb.channels;     // 3
+var cmykChannels = convert.cmyk.channels;   // 4
+var ansiChannels = convert.ansi16.channels; // 1
+```
+
+# Install
+
+```console
+$ npm install color-convert
+```
+
+# API
+
+Simply get the property of the _from_ and _to_ conversion that you're looking for.
+
+All functions have a rounded and unrounded variant. By default, return values are rounded. To get the unrounded (raw) results, simply tack on `.raw` to the function.
+
+All 'from' functions have a hidden property called `.channels` that indicates the number of channels the function expects (not including alpha).
+
+```js
+var convert = require('color-convert');
+
+// Hex to LAB
+convert.hex.lab('DEADBF');         // [ 76, 21, -2 ]
+convert.hex.lab.raw('DEADBF');     // [ 75.56213190997677, 20.653827952644754, -2.290532499330533 ]
+
+// RGB to CMYK
+convert.rgb.cmyk(167, 255, 4);     // [ 35, 0, 98, 0 ]
+convert.rgb.cmyk.raw(167, 255, 4); // [ 34.509803921568626, 0, 98.43137254901961, 0 ]
+```
+
+### Arrays
+All functions that accept multiple arguments also support passing an array.
+
+Note that this does **not** apply to functions that convert from a color that only requires one value (e.g. `keyword`, `ansi256`, `hex`, etc.)
+
+```js
+var convert = require('color-convert');
+
+convert.rgb.hex(123, 45, 67);      // '7B2D43'
+convert.rgb.hex([123, 45, 67]);    // '7B2D43'
+```
+
+## Routing
+
+Conversions that don't have an _explicitly_ defined conversion (in [conversions.js](conversions.js)), but can be converted by means of sub-conversions (e.g. XYZ -> **RGB** -> CMYK), are automatically routed together. This allows just about any color model supported by `color-convert` to be converted to any other model, so long as a sub-conversion path exists. This is also true for conversions requiring more than one step in between (e.g. LCH -> **LAB** -> **XYZ** -> **RGB** -> Hex).
+
+Keep in mind that extensive conversions _may_ result in a loss of precision, and exist only to be complete. For a list of "direct" (single-step) conversions, see [conversions.js](conversions.js).
+
+# Contribute
+
+If there is a new model you would like to support, or want to add a direct conversion between two existing models, please send us a pull request.
+
+# License
+Copyright © 2011-2016, Heather Arthur and Josh Junon. Licensed under the [MIT License](LICENSE).

node_modules/expect/node_modules/color-convert/conversions.js

@@ -0,0 +1,839 @@
+/* MIT license */
+/* eslint-disable no-mixed-operators */
+const cssKeywords = require('color-name');
+
+// NOTE: conversions should only return primitive values (i.e. arrays, or
+//       values that give correct `typeof` results).
+//       do not use box values types (i.e. Number(), String(), etc.)
+
+const reverseKeywords = {};
+for (const key of Object.keys(cssKeywords)) {
+	reverseKeywords[cssKeywords[key]] = key;
+}
+
+const convert = {
+	rgb: {channels: 3, labels: 'rgb'},
+	hsl: {channels: 3, labels: 'hsl'},
+	hsv: {channels: 3, labels: 'hsv'},
+	hwb: {channels: 3, labels: 'hwb'},
+	cmyk: {channels: 4, labels: 'cmyk'},
+	xyz: {channels: 3, labels: 'xyz'},
+	lab: {channels: 3, labels: 'lab'},
+	lch: {channels: 3, labels: 'lch'},
+	hex: {channels: 1, labels: ['hex']},
+	keyword: {channels: 1, labels: ['keyword']},
+	ansi16: {channels: 1, labels: ['ansi16']},
+	ansi256: {channels: 1, labels: ['ansi256']},
+	hcg: {channels: 3, labels: ['h', 'c', 'g']},
+	apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
+	gray: {channels: 1, labels: ['gray']}
+};
+
+module.exports = convert;
+
+// Hide .channels and .labels properties
+for (const model of Object.keys(convert)) {
+	if (!('channels' in convert[model])) {
+		throw new Error('missing channels property: ' + model);
+	}
+
+	if (!('labels' in convert[model])) {
+		throw new Error('missing channel labels property: ' + model);
+	}
+
+	if (convert[model].labels.length !== convert[model].channels) {
+		throw new Error('channel and label counts mismatch: ' + model);
+	}
+
+	const {channels, labels} = convert[model];
+	delete convert[model].channels;
+	delete convert[model].labels;
+	Object.defineProperty(convert[model], 'channels', {value: channels});
+	Object.defineProperty(convert[model], 'labels', {value: labels});
+}
+
+convert.rgb.hsl = function (rgb) {
+	const r = rgb[0] / 255;
+	const g = rgb[1] / 255;
+	const b = rgb[2] / 255;
+	const min = Math.min(r, g, b);
+	const max = Math.max(r, g, b);
+	const delta = max - min;
+	let h;
+	let s;
+
+	if (max === min) {
+		h = 0;
+	} else if (r === max) {
+		h = (g - b) / delta;
+	} else if (g === max) {
+		h = 2 + (b - r) / delta;
+	} else if (b === max) {
+		h = 4 + (r - g) / delta;
+	}
+
+	h = Math.min(h * 60, 360);
+
+	if (h < 0) {
+		h += 360;
+	}
+
+	const l = (min + max) / 2;
+
+	if (max === min) {
+		s = 0;
+	} else if (l <= 0.5) {
+		s = delta / (max + min);
+	} else {
+		s = delta / (2 - max - min);
+	}
+
+	return [h, s * 100, l * 100];
+};
+
+convert.rgb.hsv = function (rgb) {
+	let rdif;
+	let gdif;
+	let bdif;
+	let h;
+	let s;
+
+	const r = rgb[0] / 255;
+	const g = rgb[1] / 255;
+	const b = rgb[2] / 255;
+	const v = Math.max(r, g, b);
+	const diff = v - Math.min(r, g, b);
+	const diffc = function (c) {
+		return (v - c) / 6 / diff + 1 / 2;
+	};
+
+	if (diff === 0) {
+		h = 0;
+		s = 0;
+	} else {
+		s = diff / v;
+		rdif = diffc(r);
+		gdif = diffc(g);
+		bdif = diffc(b);
+
+		if (r === v) {
+			h = bdif - gdif;
+		} else if (g === v) {
+			h = (1 / 3) + rdif - bdif;
+		} else if (b === v) {
+			h = (2 / 3) + gdif - rdif;
+		}
+
+		if (h < 0) {
+			h += 1;
+		} else if (h > 1) {
+			h -= 1;
+		}
+	}
+
+	return [
+		h * 360,
+		s * 100,
+		v * 100
+	];
+};
+
+convert.rgb.hwb = function (rgb) {
+	const r = rgb[0];
+	const g = rgb[1];
+	let b = rgb[2];
+	const h = convert.rgb.hsl(rgb)[0];
+	const w = 1 / 255 * Math.min(r, Math.min(g, b));
+
+	b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+
+	return [h, w * 100, b * 100];
+};
+
+convert.rgb.cmyk = function (rgb) {
+	const r = rgb[0] / 255;
+	const g = rgb[1] / 255;
+	const b = rgb[2] / 255;
+
+	const k = Math.min(1 - r, 1 - g, 1 - b);
+	const c = (1 - r - k) / (1 - k) || 0;
+	const m = (1 - g - k) / (1 - k) || 0;
+	const y = (1 - b - k) / (1 - k) || 0;
+
+	return [c * 100, m * 100, y * 100, k * 100];
+};
+
+function comparativeDistance(x, y) {
+	/*
+		See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
+	*/
+	return (
+		((x[0] - y[0]) ** 2) +
+		((x[1] - y[1]) ** 2) +
+		((x[2] - y[2]) ** 2)
+	);
+}
+
+convert.rgb.keyword = function (rgb) {
+	const reversed = reverseKeywords[rgb];
+	if (reversed) {
+		return reversed;
+	}
+
+	let currentClosestDistance = Infinity;
+	let currentClosestKeyword;
+
+	for (const keyword of Object.keys(cssKeywords)) {
+		const value = cssKeywords[keyword];
+
+		// Compute comparative distance
+		const distance = comparativeDistance(rgb, value);
+
+		// Check if its less, if so set as closest
+		if (distance < currentClosestDistance) {
+			currentClosestDistance = distance;
+			currentClosestKeyword = keyword;
+		}
+	}
+
+	return currentClosestKeyword;
+};
+
+convert.keyword.rgb = function (keyword) {
+	return cssKeywords[keyword];
+};
+
+convert.rgb.xyz = function (rgb) {
+	let r = rgb[0] / 255;
+	let g = rgb[1] / 255;
+	let b = rgb[2] / 255;
+
+	// Assume sRGB
+	r = r > 0.04045 ? (((r + 0.055) / 1.055) ** 2.4) : (r / 12.92);
+	g = g > 0.04045 ? (((g + 0.055) / 1.055) ** 2.4) : (g / 12.92);
+	b = b > 0.04045 ? (((b + 0.055) / 1.055) ** 2.4) : (b / 12.92);
+
+	const x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
+	const y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
+	const z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
+
+	return [x * 100, y * 100, z * 100];
+};
+
+convert.rgb.lab = function (rgb) {
+	const xyz = convert.rgb.xyz(rgb);
+	let x = xyz[0];
+	let y = xyz[1];
+	let z = xyz[2];
+
+	x /= 95.047;
+	y /= 100;
+	z /= 108.883;
+
+	x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
+	y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
+	z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
+
+	const l = (116 * y) - 16;
+	const a = 500 * (x - y);
+	const b = 200 * (y - z);
+
+	return [l, a, b];
+};
+
+convert.hsl.rgb = function (hsl) {
+	const h = hsl[0] / 360;
+	const s = hsl[1] / 100;
+	const l = hsl[2] / 100;
+	let t2;
+	let t3;
+	let val;
+
+	if (s === 0) {
+		val = l * 255;
+		return [val, val, val];
+	}
+
+	if (l < 0.5) {
+		t2 = l * (1 + s);
+	} else {
+		t2 = l + s - l * s;
+	}
+
+	const t1 = 2 * l - t2;
+
+	const rgb = [0, 0, 0];
+	for (let i = 0; i < 3; i++) {
+		t3 = h + 1 / 3 * -(i - 1);
+		if (t3 < 0) {
+			t3++;
+		}
+
+		if (t3 > 1) {
+			t3--;
+		}
+
+		if (6 * t3 < 1) {
+			val = t1 + (t2 - t1) * 6 * t3;
+		} else if (2 * t3 < 1) {
+			val = t2;
+		} else if (3 * t3 < 2) {
+			val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+		} else {
+			val = t1;
+		}
+
+		rgb[i] = val * 255;
+	}
+
+	return rgb;
+};
+
+convert.hsl.hsv = function (hsl) {
+	const h = hsl[0];
+	let s = hsl[1] / 100;
+	let l = hsl[2] / 100;
+	let smin = s;
+	const lmin = Math.max(l, 0.01);
+
+	l *= 2;
+	s *= (l <= 1) ? l : 2 - l;
+	smin *= lmin <= 1 ? lmin : 2 - lmin;
+	const v = (l + s) / 2;
+	const sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);
+
+	return [h, sv * 100, v * 100];
+};
+
+convert.hsv.rgb = function (hsv) {
+	const h = hsv[0] / 60;
+	const s = hsv[1] / 100;
+	let v = hsv[2] / 100;
+	const hi = Math.floor(h) % 6;
+
+	const f = h - Math.floor(h);
+	const p = 255 * v * (1 - s);
+	const q = 255 * v * (1 - (s * f));
+	const t = 255 * v * (1 - (s * (1 - f)));
+	v *= 255;
+
+	switch (hi) {
+		case 0:
+			return [v, t, p];
+		case 1:
+			return [q, v, p];
+		case 2:
+			return [p, v, t];
+		case 3:
+			return [p, q, v];
+		case 4:
+			return [t, p, v];
+		case 5:
+			return [v, p, q];
+	}
+};
+
+convert.hsv.hsl = function (hsv) {
+	const h = hsv[0];
+	const s = hsv[1] / 100;
+	const v = hsv[2] / 100;
+	const vmin = Math.max(v, 0.01);
+	let sl;
+	let l;
+
+	l = (2 - s) * v;
+	const lmin = (2 - s) * vmin;
+	sl = s * vmin;
+	sl /= (lmin <= 1) ? lmin : 2 - lmin;
+	sl = sl || 0;
+	l /= 2;
+
+	return [h, sl * 100, l * 100];
+};
+
+// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
+convert.hwb.rgb = function (hwb) {
+	const h = hwb[0] / 360;
+	let wh = hwb[1] / 100;
+	let bl = hwb[2] / 100;
+	const ratio = wh + bl;
+	let f;
+
+	// Wh + bl cant be > 1
+	if (ratio > 1) {
+		wh /= ratio;
+		bl /= ratio;
+	}
+
+	const i = Math.floor(6 * h);
+	const v = 1 - bl;
+	f = 6 * h - i;
+
+	if ((i & 0x01) !== 0) {
+		f = 1 - f;
+	}
+
+	const n = wh + f * (v - wh); // Linear interpolation
+
+	let r;
+	let g;
+	let b;
+	/* eslint-disable max-statements-per-line,no-multi-spaces */
+	switch (i) {
+		default:
+		case 6:
+		case 0: r = v;  g = n;  b = wh; break;
+		case 1: r = n;  g = v;  b = wh; break;
+		case 2: r = wh; g = v;  b = n; break;
+		case 3: r = wh; g = n;  b = v; break;
+		case 4: r = n;  g = wh; b = v; break;
+		case 5: r = v;  g = wh; b = n; break;
+	}
+	/* eslint-enable max-statements-per-line,no-multi-spaces */
+
+	return [r * 255, g * 255, b * 255];
+};
+
+convert.cmyk.rgb = function (cmyk) {
+	const c = cmyk[0] / 100;
+	const m = cmyk[1] / 100;
+	const y = cmyk[2] / 100;
+	const k = cmyk[3] / 100;
+
+	const r = 1 - Math.min(1, c * (1 - k) + k);
+	const g = 1 - Math.min(1, m * (1 - k) + k);
+	const b = 1 - Math.min(1, y * (1 - k) + k);
+
+	return [r * 255, g * 255, b * 255];
+};
+
+convert.xyz.rgb = function (xyz) {
+	const x = xyz[0] / 100;
+	const y = xyz[1] / 100;
+	const z = xyz[2] / 100;
+	let r;
+	let g;
+	let b;
+
+	r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
+	g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
+	b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
+
+	// Assume sRGB
+	r = r > 0.0031308
+		? ((1.055 * (r ** (1.0 / 2.4))) - 0.055)
+		: r * 12.92;
+
+	g = g > 0.0031308
+		? ((1.055 * (g ** (1.0 / 2.4))) - 0.055)
+		: g * 12.92;
+
+	b = b > 0.0031308
+		? ((1.055 * (b ** (1.0 / 2.4))) - 0.055)
+		: b * 12.92;
+
+	r = Math.min(Math.max(0, r), 1);
+	g = Math.min(Math.max(0, g), 1);
+	b = Math.min(Math.max(0, b), 1);
+
+	return [r * 255, g * 255, b * 255];
+};
+
+convert.xyz.lab = function (xyz) {
+	let x = xyz[0];
+	let y = xyz[1];
+	let z = xyz[2];
+
+	x /= 95.047;
+	y /= 100;
+	z /= 108.883;
+
+	x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
+	y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
+	z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
+
+	const l = (116 * y) - 16;
+	const a = 500 * (x - y);
+	const b = 200 * (y - z);
+
+	return [l, a, b];
+};
+
+convert.lab.xyz = function (lab) {
+	const l = lab[0];
+	const a = lab[1];
+	const b = lab[2];
+	let x;
+	let y;
+	let z;
+
+	y = (l + 16) / 116;
+	x = a / 500 + y;
+	z = y - b / 200;
+
+	const y2 = y ** 3;
+	const x2 = x ** 3;
+	const z2 = z ** 3;
+	y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
+	x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
+	z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
+
+	x *= 95.047;
+	y *= 100;
+	z *= 108.883;
+
+	return [x, y, z];
+};
+
+convert.lab.lch = function (lab) {
+	const l = lab[0];
+	const a = lab[1];
+	const b = lab[2];
+	let h;
+
+	const hr = Math.atan2(b, a);
+	h = hr * 360 / 2 / Math.PI;
+
+	if (h < 0) {
+		h += 360;
+	}
+
+	const c = Math.sqrt(a * a + b * b);
+
+	return [l, c, h];
+};
+
+convert.lch.lab = function (lch) {
+	const l = lch[0];
+	const c = lch[1];
+	const h = lch[2];
+
+	const hr = h / 360 * 2 * Math.PI;
+	const a = c * Math.cos(hr);
+	const b = c * Math.sin(hr);
+
+	return [l, a, b];
+};
+
+convert.rgb.ansi16 = function (args, saturation = null) {
+	const [r, g, b] = args;
+	let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation; // Hsv -> ansi16 optimization
+
+	value = Math.round(value / 50);
+
+	if (value === 0) {
+		return 30;
+	}
+
+	let ansi = 30
+		+ ((Math.round(b / 255) << 2)
+		| (Math.round(g / 255) << 1)
+		| Math.round(r / 255));
+
+	if (value === 2) {
+		ansi += 60;
+	}
+
+	return ansi;
+};
+
+convert.hsv.ansi16 = function (args) {
+	// Optimization here; we already know the value and don't need to get
+	// it converted for us.
+	return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
+};
+
+convert.rgb.ansi256 = function (args) {
+	const r = args[0];
+	const g = args[1];
+	const b = args[2];
+
+	// We use the extended greyscale palette here, with the exception of
+	// black and white. normal palette only has 4 greyscale shades.
+	if (r === g && g === b) {
+		if (r < 8) {
+			return 16;
+		}
+
+		if (r > 248) {
+			return 231;
+		}
+
+		return Math.round(((r - 8) / 247) * 24) + 232;
+	}
+
+	const ansi = 16
+		+ (36 * Math.round(r / 255 * 5))
+		+ (6 * Math.round(g / 255 * 5))
+		+ Math.round(b / 255 * 5);
+
+	return ansi;
+};
+
+convert.ansi16.rgb = function (args) {
+	let color = args % 10;
+
+	// Handle greyscale
+	if (color === 0 || color === 7) {
+		if (args > 50) {
+			color += 3.5;
+		}
+
+		color = color / 10.5 * 255;
+
+		return [color, color, color];
+	}
+
+	const mult = (~~(args > 50) + 1) * 0.5;
+	const r = ((color & 1) * mult) * 255;
+	const g = (((color >> 1) & 1) * mult) * 255;
+	const b = (((color >> 2) & 1) * mult) * 255;
+
+	return [r, g, b];
+};
+
+convert.ansi256.rgb = function (args) {
+	// Handle greyscale
+	if (args >= 232) {
+		const c = (args - 232) * 10 + 8;
+		return [c, c, c];
+	}
+
+	args -= 16;
+
+	let rem;
+	const r = Math.floor(args / 36) / 5 * 255;
+	const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+	const b = (rem % 6) / 5 * 255;
+
+	return [r, g, b];
+};
+
+convert.rgb.hex = function (args) {
+	const integer = ((Math.round(args[0]) & 0xFF) << 16)
+		+ ((Math.round(args[1]) & 0xFF) << 8)
+		+ (Math.round(args[2]) & 0xFF);
+
+	const string = integer.toString(16).toUpperCase();
+	return '000000'.substring(string.length) + string;
+};
+
+convert.hex.rgb = function (args) {
+	const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+	if (!match) {
+		return [0, 0, 0];
+	}
+
+	let colorString = match[0];
+
+	if (match[0].length === 3) {
+		colorString = colorString.split('').map(char => {
+			return char + char;
+		}).join('');
+	}
+
+	const integer = parseInt(colorString, 16);
+	const r = (integer >> 16) & 0xFF;
+	const g = (integer >> 8) & 0xFF;
+	const b = integer & 0xFF;
+
+	return [r, g, b];
+};
+
+convert.rgb.hcg = function (rgb) {
+	const r = rgb[0] / 255;
+	const g = rgb[1] / 255;
+	const b = rgb[2] / 255;
+	const max = Math.max(Math.max(r, g), b);
+	const min = Math.min(Math.min(r, g), b);
+	const chroma = (max - min);
+	let grayscale;
+	let hue;
+
+	if (chroma < 1) {
+		grayscale = min / (1 - chroma);
+	} else {
+		grayscale = 0;
+	}
+
+	if (chroma <= 0) {
+		hue = 0;
+	} else
+	if (max === r) {
+		hue = ((g - b) / chroma) % 6;
+	} else
+	if (max === g) {
+		hue = 2 + (b - r) / chroma;
+	} else {
+		hue = 4 + (r - g) / chroma;
+	}
+
+	hue /= 6;
+	hue %= 1;
+
+	return [hue * 360, chroma * 100, grayscale * 100];
+};
+
+convert.hsl.hcg = function (hsl) {
+	const s = hsl[1] / 100;
+	const l = hsl[2] / 100;
+
+	const c = l < 0.5 ? (2.0 * s * l) : (2.0 * s * (1.0 - l));
+
+	let f = 0;
+	if (c < 1.0) {
+		f = (l - 0.5 * c) / (1.0 - c);
+	}
+
+	return [hsl[0], c * 100, f * 100];
+};
+
+convert.hsv.hcg = function (hsv) {
+	const s = hsv[1] / 100;
+	const v = hsv[2] / 100;
+
+	const c = s * v;
+	let f = 0;
+
+	if (c < 1.0) {
+		f = (v - c) / (1 - c);
+	}
+
+	return [hsv[0], c * 100, f * 100];
+};
+
+convert.hcg.rgb = function (hcg) {
+	const h = hcg[0] / 360;
+	const c = hcg[1] / 100;
+	const g = hcg[2] / 100;
+
+	if (c === 0.0) {
+		return [g * 255, g * 255, g * 255];
+	}
+
+	const pure = [0, 0, 0];
+	const hi = (h % 1) * 6;
+	const v = hi % 1;
+	const w = 1 - v;
+	let mg = 0;
+
+	/* eslint-disable max-statements-per-line */
+	switch (Math.floor(hi)) {
+		case 0:
+			pure[0] = 1; pure[1] = v; pure[2] = 0; break;
+		case 1:
+			pure[0] = w; pure[1] = 1; pure[2] = 0; break;
+		case 2:
+			pure[0] = 0; pure[1] = 1; pure[2] = v; break;
+		case 3:
+			pure[0] = 0; pure[1] = w; pure[2] = 1; break;
+		case 4:
+			pure[0] = v; pure[1] = 0; pure[2] = 1; break;
+		default:
+			pure[0] = 1; pure[1] = 0; pure[2] = w;
+	}
+	/* eslint-enable max-statements-per-line */
+
+	mg = (1.0 - c) * g;
+
+	return [
+		(c * pure[0] + mg) * 255,
+		(c * pure[1] + mg) * 255,
+		(c * pure[2] + mg) * 255
+	];
+};
+
+convert.hcg.hsv = function (hcg) {
+	const c = hcg[1] / 100;
+	const g = hcg[2] / 100;
+
+	const v = c + g * (1.0 - c);
+	let f = 0;
+
+	if (v > 0.0) {
+		f = c / v;
+	}
+
+	return [hcg[0], f * 100, v * 100];
+};
+
+convert.hcg.hsl = function (hcg) {
+	const c = hcg[1] / 100;
+	const g = hcg[2] / 100;
+
+	const l = g * (1.0 - c) + 0.5 * c;
+	let s = 0;
+
+	if (l > 0.0 && l < 0.5) {
+		s = c / (2 * l);
+	} else
+	if (l >= 0.5 && l < 1.0) {
+		s = c / (2 * (1 - l));
+	}
+
+	return [hcg[0], s * 100, l * 100];
+};
+
+convert.hcg.hwb = function (hcg) {
+	const c = hcg[1] / 100;
+	const g = hcg[2] / 100;
+	const v = c + g * (1.0 - c);
+	return [hcg[0], (v - c) * 100, (1 - v) * 100];
+};
+
+convert.hwb.hcg = function (hwb) {
+	const w = hwb[1] / 100;
+	const b = hwb[2] / 100;
+	const v = 1 - b;
+	const c = v - w;
+	let g = 0;
+
+	if (c < 1) {
+		g = (v - c) / (1 - c);
+	}
+
+	return [hwb[0], c * 100, g * 100];
+};
+
+convert.apple.rgb = function (apple) {
+	return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
+};
+
+convert.rgb.apple = function (rgb) {
+	return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
+};
+
+convert.gray.rgb = function (args) {
+	return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
+};
+
+convert.gray.hsl = function (args) {
+	return [0, 0, args[0]];
+};
+
+convert.gray.hsv = convert.gray.hsl;
+
+convert.gray.hwb = function (gray) {
+	return [0, 100, gray[0]];
+};
+
+convert.gray.cmyk = function (gray) {
+	return [0, 0, 0, gray[0]];
+};
+
+convert.gray.lab = function (gray) {
+	return [gray[0], 0, 0];
+};
+
+convert.gray.hex = function (gray) {
+	const val = Math.round(gray[0] / 100 * 255) & 0xFF;
+	const integer = (val << 16) + (val << 8) + val;
+
+	const string = integer.toString(16).toUpperCase();
+	return '000000'.substring(string.length) + string;
+};
+
+convert.rgb.gray = function (rgb) {
+	const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+	return [val / 255 * 100];
+};

node_modules/expect/node_modules/color-convert/index.js

@@ -0,0 +1,81 @@
+const conversions = require('./conversions');
+const route = require('./route');
+
+const convert = {};
+
+const models = Object.keys(conversions);
+
+function wrapRaw(fn) {
+	const wrappedFn = function (...args) {
+		const arg0 = args[0];
+		if (arg0 === undefined || arg0 === null) {
+			return arg0;
+		}
+
+		if (arg0.length > 1) {
+			args = arg0;
+		}
+
+		return fn(args);
+	};
+
+	// Preserve .conversion property if there is one
+	if ('conversion' in fn) {
+		wrappedFn.conversion = fn.conversion;
+	}
+
+	return wrappedFn;
+}
+
+function wrapRounded(fn) {
+	const wrappedFn = function (...args) {
+		const arg0 = args[0];
+
+		if (arg0 === undefined || arg0 === null) {
+			return arg0;
+		}
+
+		if (arg0.length > 1) {
+			args = arg0;
+		}
+
+		const result = fn(args);
+
+		// We're assuming the result is an array here.
+		// see notice in conversions.js; don't use box types
+		// in conversion functions.
+		if (typeof result === 'object') {
+			for (let len = result.length, i = 0; i < len; i++) {
+				result[i] = Math.round(result[i]);
+			}
+		}
+
+		return result;
+	};
+
+	// Preserve .conversion property if there is one
+	if ('conversion' in fn) {
+		wrappedFn.conversion = fn.conversion;
+	}
+
+	return wrappedFn;
+}
+
+models.forEach(fromModel => {
+	convert[fromModel] = {};
+
+	Object.defineProperty(convert[fromModel], 'channels', {value: conversions[fromModel].channels});
+	Object.defineProperty(convert[fromModel], 'labels', {value: conversions[fromModel].labels});
+
+	const routes = route(fromModel);
+	const routeModels = Object.keys(routes);
+
+	routeModels.forEach(toModel => {
+		const fn = routes[toModel];
+
+		convert[fromModel][toModel] = wrapRounded(fn);
+		convert[fromModel][toModel].raw = wrapRaw(fn);
+	});
+});
+
+module.exports = convert;

node_modules/expect/node_modules/color-convert/package.json

@@ -0,0 +1,83 @@
+{
+  "_from": "color-convert@^2.0.1",
+  "_id": "color-convert@2.0.1",
+  "_inBundle": false,
+  "_integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+  "_location": "/expect/color-convert",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "color-convert@^2.0.1",
+    "name": "color-convert",
+    "escapedName": "color-convert",
+    "rawSpec": "^2.0.1",
+    "saveSpec": null,
+    "fetchSpec": "^2.0.1"
+  },
+  "_requiredBy": [
+    "/expect/ansi-styles"
+  ],
+  "_resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+  "_shasum": "72d3a68d598c9bdb3af2ad1e84f21d896abd4de3",
+  "_spec": "color-convert@^2.0.1",
+  "_where": "/Users/tylerkoenig/Code/personal/react-scss2/node_modules/expect/node_modules/ansi-styles",
+  "author": {
+    "name": "Heather Arthur",
+    "email": "fayearthur@gmail.com"
+  },
+  "bugs": {
+    "url": "https://github.com/Qix-/color-convert/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "color-name": "~1.1.4"
+  },
+  "deprecated": false,
+  "description": "Plain color conversion functions",
+  "devDependencies": {
+    "chalk": "^2.4.2",
+    "xo": "^0.24.0"
+  },
+  "engines": {
+    "node": ">=7.0.0"
+  },
+  "files": [
+    "index.js",
+    "conversions.js",
+    "route.js"
+  ],
+  "homepage": "https://github.com/Qix-/color-convert#readme",
+  "keywords": [
+    "color",
+    "colour",
+    "convert",
+    "converter",
+    "conversion",
+    "rgb",
+    "hsl",
+    "hsv",
+    "hwb",
+    "cmyk",
+    "ansi",
+    "ansi16"
+  ],
+  "license": "MIT",
+  "name": "color-convert",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Qix-/color-convert.git"
+  },
+  "scripts": {
+    "pretest": "xo",
+    "test": "node test/basic.js"
+  },
+  "version": "2.0.1",
+  "xo": {
+    "rules": {
+      "default-case": 0,
+      "no-inline-comments": 0,
+      "operator-linebreak": 0
+    }
+  }
+}

node_modules/expect/node_modules/color-convert/route.js

@@ -0,0 +1,97 @@
+const conversions = require('./conversions');
+
+/*
+	This function routes a model to all other models.
+
+	all functions that are routed have a property `.conversion` attached
+	to the returned synthetic function. This property is an array
+	of strings, each with the steps in between the 'from' and 'to'
+	color models (inclusive).
+
+	conversions that are not possible simply are not included.
+*/
+
+function buildGraph() {
+	const graph = {};
+	// https://jsperf.com/object-keys-vs-for-in-with-closure/3
+	const models = Object.keys(conversions);
+
+	for (let len = models.length, i = 0; i < len; i++) {
+		graph[models[i]] = {
+			// http://jsperf.com/1-vs-infinity
+			// micro-opt, but this is simple.
+			distance: -1,
+			parent: null
+		};
+	}
+
+	return graph;
+}
+
+// https://en.wikipedia.org/wiki/Breadth-first_search
+function deriveBFS(fromModel) {
+	const graph = buildGraph();
+	const queue = [fromModel]; // Unshift -> queue -> pop
+
+	graph[fromModel].distance = 0;
+
+	while (queue.length) {
+		const current = queue.pop();
+		const adjacents = Object.keys(conversions[current]);
+
+		for (let len = adjacents.length, i = 0; i < len; i++) {
+			const adjacent = adjacents[i];
+			const node = graph[adjacent];
+
+			if (node.distance === -1) {
+				node.distance = graph[current].distance + 1;
+				node.parent = current;
+				queue.unshift(adjacent);
+			}
+		}
+	}
+
+	return graph;
+}
+
+function link(from, to) {
+	return function (args) {
+		return to(from(args));
+	};
+}
+
+function wrapConversion(toModel, graph) {
+	const path = [graph[toModel].parent, toModel];
+	let fn = conversions[graph[toModel].parent][toModel];
+
+	let cur = graph[toModel].parent;
+	while (graph[cur].parent) {
+		path.unshift(graph[cur].parent);
+		fn = link(conversions[graph[cur].parent][cur], fn);
+		cur = graph[cur].parent;
+	}
+
+	fn.conversion = path;
+	return fn;
+}
+
+module.exports = function (fromModel) {
+	const graph = deriveBFS(fromModel);
+	const conversion = {};
+
+	const models = Object.keys(graph);
+	for (let len = models.length, i = 0; i < len; i++) {
+		const toModel = models[i];
+		const node = graph[toModel];
+
+		if (node.parent === null) {
+			// No possible conversion, or this node is the source model.
+			continue;
+		}
+
+		conversion[toModel] = wrapConversion(toModel, graph);
+	}
+
+	return conversion;
+};
+

node_modules/expect/node_modules/color-name/LICENSE

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright (c) 2015 Dmitry Ivanov
+
+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/color-name/README.md

@@ -0,0 +1,11 @@
+A JSON with color names and its values. Based on http://dev.w3.org/csswg/css-color/#named-colors.
+
+[![NPM](https://nodei.co/npm/color-name.png?mini=true)](https://nodei.co/npm/color-name/)
+
+
+```js
+var colors = require('color-name');
+colors.red //[255,0,0]
+```
+
+<a href="LICENSE"><img src="https://upload.wikimedia.org/wikipedia/commons/0/0c/MIT_logo.svg" width="120"/></a>

node_modules/expect/node_modules/color-name/index.js

@@ -0,0 +1,152 @@
+'use strict'
+
+module.exports = {
+	"aliceblue": [240, 248, 255],
+	"antiquewhite": [250, 235, 215],
+	"aqua": [0, 255, 255],
+	"aquamarine": [127, 255, 212],
+	"azure": [240, 255, 255],
+	"beige": [245, 245, 220],
+	"bisque": [255, 228, 196],
+	"black": [0, 0, 0],
+	"blanchedalmond": [255, 235, 205],
+	"blue": [0, 0, 255],
+	"blueviolet": [138, 43, 226],
+	"brown": [165, 42, 42],
+	"burlywood": [222, 184, 135],
+	"cadetblue": [95, 158, 160],
+	"chartreuse": [127, 255, 0],
+	"chocolate": [210, 105, 30],
+	"coral": [255, 127, 80],
+	"cornflowerblue": [100, 149, 237],
+	"cornsilk": [255, 248, 220],
+	"crimson": [220, 20, 60],
+	"cyan": [0, 255, 255],
+	"darkblue": [0, 0, 139],
+	"darkcyan": [0, 139, 139],
+	"darkgoldenrod": [184, 134, 11],
+	"darkgray": [169, 169, 169],
+	"darkgreen": [0, 100, 0],
+	"darkgrey": [169, 169, 169],
+	"darkkhaki": [189, 183, 107],
+	"darkmagenta": [139, 0, 139],
+	"darkolivegreen": [85, 107, 47],
+	"darkorange": [255, 140, 0],
+	"darkorchid": [153, 50, 204],
+	"darkred": [139, 0, 0],
+	"darksalmon": [233, 150, 122],
+	"darkseagreen": [143, 188, 143],
+	"darkslateblue": [72, 61, 139],
+	"darkslategray": [47, 79, 79],
+	"darkslategrey": [47, 79, 79],
+	"darkturquoise": [0, 206, 209],
+	"darkviolet": [148, 0, 211],
+	"deeppink": [255, 20, 147],
+	"deepskyblue": [0, 191, 255],
+	"dimgray": [105, 105, 105],
+	"dimgrey": [105, 105, 105],
+	"dodgerblue": [30, 144, 255],
+	"firebrick": [178, 34, 34],
+	"floralwhite": [255, 250, 240],
+	"forestgreen": [34, 139, 34],
+	"fuchsia": [255, 0, 255],
+	"gainsboro": [220, 220, 220],
+	"ghostwhite": [248, 248, 255],
+	"gold": [255, 215, 0],
+	"goldenrod": [218, 165, 32],
+	"gray": [128, 128, 128],
+	"green": [0, 128, 0],
+	"greenyellow": [173, 255, 47],
+	"grey": [128, 128, 128],
+	"honeydew": [240, 255, 240],
+	"hotpink": [255, 105, 180],
+	"indianred": [205, 92, 92],
+	"indigo": [75, 0, 130],
+	"ivory": [255, 255, 240],
+	"khaki": [240, 230, 140],
+	"lavender": [230, 230, 250],
+	"lavenderblush": [255, 240, 245],
+	"lawngreen": [124, 252, 0],
+	"lemonchiffon": [255, 250, 205],
+	"lightblue": [173, 216, 230],
+	"lightcoral": [240, 128, 128],
+	"lightcyan": [224, 255, 255],
+	"lightgoldenrodyellow": [250, 250, 210],
+	"lightgray": [211, 211, 211],
+	"lightgreen": [144, 238, 144],
+	"lightgrey": [211, 211, 211],
+	"lightpink": [255, 182, 193],
+	"lightsalmon": [255, 160, 122],
+	"lightseagreen": [32, 178, 170],
+	"lightskyblue": [135, 206, 250],
+	"lightslategray": [119, 136, 153],
+	"lightslategrey": [119, 136, 153],
+	"lightsteelblue": [176, 196, 222],
+	"lightyellow": [255, 255, 224],
+	"lime": [0, 255, 0],
+	"limegreen": [50, 205, 50],
+	"linen": [250, 240, 230],
+	"magenta": [255, 0, 255],
+	"maroon": [128, 0, 0],
+	"mediumaquamarine": [102, 205, 170],
+	"mediumblue": [0, 0, 205],
+	"mediumorchid": [186, 85, 211],
+	"mediumpurple": [147, 112, 219],
+	"mediumseagreen": [60, 179, 113],
+	"mediumslateblue": [123, 104, 238],
+	"mediumspringgreen": [0, 250, 154],
+	"mediumturquoise": [72, 209, 204],
+	"mediumvioletred": [199, 21, 133],
+	"midnightblue": [25, 25, 112],
+	"mintcream": [245, 255, 250],
+	"mistyrose": [255, 228, 225],
+	"moccasin": [255, 228, 181],
+	"navajowhite": [255, 222, 173],
+	"navy": [0, 0, 128],
+	"oldlace": [253, 245, 230],
+	"olive": [128, 128, 0],
+	"olivedrab": [107, 142, 35],
+	"orange": [255, 165, 0],
+	"orangered": [255, 69, 0],
+	"orchid": [218, 112, 214],
+	"palegoldenrod": [238, 232, 170],
+	"palegreen": [152, 251, 152],
+	"paleturquoise": [175, 238, 238],
+	"palevioletred": [219, 112, 147],
+	"papayawhip": [255, 239, 213],
+	"peachpuff": [255, 218, 185],
+	"peru": [205, 133, 63],
+	"pink": [255, 192, 203],
+	"plum": [221, 160, 221],
+	"powderblue": [176, 224, 230],
+	"purple": [128, 0, 128],
+	"rebeccapurple": [102, 51, 153],
+	"red": [255, 0, 0],
+	"rosybrown": [188, 143, 143],
+	"royalblue": [65, 105, 225],
+	"saddlebrown": [139, 69, 19],
+	"salmon": [250, 128, 114],
+	"sandybrown": [244, 164, 96],
+	"seagreen": [46, 139, 87],
+	"seashell": [255, 245, 238],
+	"sienna": [160, 82, 45],
+	"silver": [192, 192, 192],
+	"skyblue": [135, 206, 235],
+	"slateblue": [106, 90, 205],
+	"slategray": [112, 128, 144],
+	"slategrey": [112, 128, 144],
+	"snow": [255, 250, 250],
+	"springgreen": [0, 255, 127],
+	"steelblue": [70, 130, 180],
+	"tan": [210, 180, 140],
+	"teal": [0, 128, 128],
+	"thistle": [216, 191, 216],
+	"tomato": [255, 99, 71],
+	"turquoise": [64, 224, 208],
+	"violet": [238, 130, 238],
+	"wheat": [245, 222, 179],
+	"white": [255, 255, 255],
+	"whitesmoke": [245, 245, 245],
+	"yellow": [255, 255, 0],
+	"yellowgreen": [154, 205, 50]
+};

node_modules/expect/node_modules/color-name/package.json

@@ -0,0 +1,56 @@
+{
+  "_from": "color-name@~1.1.4",
+  "_id": "color-name@1.1.4",
+  "_inBundle": false,
+  "_integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+  "_location": "/expect/color-name",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "color-name@~1.1.4",
+    "name": "color-name",
+    "escapedName": "color-name",
+    "rawSpec": "~1.1.4",
+    "saveSpec": null,
+    "fetchSpec": "~1.1.4"
+  },
+  "_requiredBy": [
+    "/expect/color-convert"
+  ],
+  "_resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+  "_shasum": "c2a09a87acbde69543de6f63fa3995c826c536a2",
+  "_spec": "color-name@~1.1.4",
+  "_where": "/Users/tylerkoenig/Code/personal/react-scss2/node_modules/expect/node_modules/color-convert",
+  "author": {
+    "name": "DY",
+    "email": "dfcreative@gmail.com"
+  },
+  "bugs": {
+    "url": "https://github.com/colorjs/color-name/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "A list of color names and its values",
+  "files": [
+    "index.js"
+  ],
+  "homepage": "https://github.com/colorjs/color-name",
+  "keywords": [
+    "color-name",
+    "color",
+    "color-keyword",
+    "keyword"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "color-name",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/colorjs/color-name.git"
+  },
+  "scripts": {
+    "test": "node test.js"
+  },
+  "version": "1.1.4"
+}

node_modules/expect/package.json

@@ -0,0 +1,66 @@
+{
+  "_from": "expect@^26.6.2",
+  "_id": "expect@26.6.2",
+  "_inBundle": false,
+  "_integrity": "sha512-9/hlOBkQl2l/PLHJx6JjoDF6xPKcJEsUlWKb23rKE7KzeDqUZKXKNMW27KIue5JMdBV9HgmoJPcc8HtO85t9IA==",
+  "_location": "/expect",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "expect@^26.6.2",
+    "name": "expect",
+    "escapedName": "expect",
+    "rawSpec": "^26.6.2",
+    "saveSpec": null,
+    "fetchSpec": "^26.6.2"
+  },
+  "_requiredBy": [
+    "/@jest/globals",
+    "/jest-circus",
+    "/jest-jasmine2",
+    "/jest-snapshot"
+  ],
+  "_resolved": "https://registry.npmjs.org/expect/-/expect-26.6.2.tgz",
+  "_shasum": "c6b996bf26bf3fe18b67b2d0f51fc981ba934417",
+  "_spec": "expect@^26.6.2",
+  "_where": "/Users/tylerkoenig/Code/personal/react-scss2/node_modules/@jest/globals",
+  "bugs": {
+    "url": "https://github.com/facebook/jest/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "@jest/types": "^26.6.2",
+    "ansi-styles": "^4.0.0",
+    "jest-get-type": "^26.3.0",
+    "jest-matcher-utils": "^26.6.2",
+    "jest-message-util": "^26.6.2",
+    "jest-regex-util": "^26.0.0"
+  },
+  "deprecated": false,
+  "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/en/expect.html).",
+  "devDependencies": {
+    "@jest/test-utils": "^26.6.2",
+    "chalk": "^4.0.0",
+    "fast-check": "^2.0.0",
+    "immutable": "^4.0.0-rc.12"
+  },
+  "engines": {
+    "node": ">= 10.14.2"
+  },
+  "gitHead": "4c46930615602cbf983fb7e8e82884c282a624d5",
+  "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": "26.6.2"
+}