Fix.

node_modules/jest-snapshot/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+For Jest software
+
+Copyright (c) 2014-present, Facebook, Inc.
+
+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/jest-snapshot/build/State.d.ts

@@ -0,0 +1,56 @@
+/**
+ * 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 { Config } from '@jest/types';
+export declare type SnapshotStateOptions = {
+    updateSnapshot: Config.SnapshotUpdateState;
+    getPrettier: () => null | any;
+    getBabelTraverse: () => Function;
+    expand?: boolean;
+};
+export declare type SnapshotMatchOptions = {
+    testName: string;
+    received: any;
+    key?: string;
+    inlineSnapshot?: string;
+    error?: Error;
+};
+export default class SnapshotState {
+    private _counters;
+    private _dirty;
+    private _index;
+    private _updateSnapshot;
+    private _snapshotData;
+    private _snapshotPath;
+    private _inlineSnapshots;
+    private _uncheckedKeys;
+    private _getBabelTraverse;
+    private _getPrettier;
+    added: number;
+    expand: boolean;
+    matched: number;
+    unmatched: number;
+    updated: number;
+    constructor(snapshotPath: Config.Path, options: SnapshotStateOptions);
+    markSnapshotsAsCheckedForTest(testName: string): void;
+    private _addSnapshot;
+    save(): {
+        deleted: boolean;
+        saved: boolean;
+    };
+    getUncheckedCount(): number;
+    getUncheckedKeys(): Array<string>;
+    removeUncheckedKeys(): void;
+    match({ testName, received, key, inlineSnapshot, error, }: SnapshotMatchOptions): {
+        actual: string;
+        count: number;
+        expected: string | null;
+        key: string;
+        pass: boolean;
+    };
+    fail(testName: string, _received: any, key?: string): string;
+}
+//# sourceMappingURL=State.d.ts.map

node_modules/jest-snapshot/build/State.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"State.d.ts","sourceRoot":"","sources":["../src/State.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAcnC,oBAAY,oBAAoB,GAAG;IACjC,cAAc,EAAE,MAAM,CAAC,mBAAmB,CAAC;IAC3C,WAAW,EAAE,MAAM,IAAI,GAAG,GAAG,CAAC;IAC9B,gBAAgB,EAAE,MAAM,QAAQ,CAAC;IACjC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,oBAAY,oBAAoB,GAAG;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,GAAG,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,KAAK,CAAC;CACf,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,aAAa;IAChC,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,MAAM,CAAU;IAExB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,eAAe,CAA6B;IACpD,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,gBAAgB,CAAwB;IAChD,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,iBAAiB,CAAiB;IAC1C,OAAO,CAAC,YAAY,CAAmB;IAEvC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;gBAEJ,YAAY,EAAE,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,oBAAoB;IAsBpE,6BAA6B,CAAC,QAAQ,EAAE,MAAM;IAQ9C,OAAO,CAAC,YAAY;IAwBpB,IAAI;;;;IA8BJ,iBAAiB,IAAI,MAAM;IAI3B,gBAAgB,IAAI,KAAK,CAAC,MAAM,CAAC;IAIjC,mBAAmB,IAAI,IAAI;IAQ3B,KAAK,CAAC,EACJ,QAAQ,EACR,QAAQ,EACR,GAAG,EACH,cAAc,EACd,KAAK,GACN,EAAE,oBAAoB;;;;;;;IA4FvB,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,MAAM;CAYpD"}

node_modules/jest-snapshot/build/State.js

@@ -0,0 +1,302 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+var _fs = _interopRequireDefault(require('fs'));
+
+var _jestMessageUtil = require('jest-message-util');
+
+var _utils = require('./utils');
+
+var _inline_snapshots = require('./inline_snapshots');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+var jestExistsFile =
+  global[Symbol.for('jest-native-exists-file')] || _fs.default.existsSync;
+
+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 SnapshotState {
+  // @ts-ignore
+  constructor(snapshotPath, options) {
+    _defineProperty(this, '_counters', void 0);
+
+    _defineProperty(this, '_dirty', void 0);
+
+    _defineProperty(this, '_index', void 0);
+
+    _defineProperty(this, '_updateSnapshot', void 0);
+
+    _defineProperty(this, '_snapshotData', void 0);
+
+    _defineProperty(this, '_snapshotPath', void 0);
+
+    _defineProperty(this, '_inlineSnapshots', void 0);
+
+    _defineProperty(this, '_uncheckedKeys', void 0);
+
+    _defineProperty(this, '_getBabelTraverse', void 0);
+
+    _defineProperty(this, '_getPrettier', void 0);
+
+    _defineProperty(this, 'added', void 0);
+
+    _defineProperty(this, 'expand', void 0);
+
+    _defineProperty(this, 'matched', void 0);
+
+    _defineProperty(this, 'unmatched', void 0);
+
+    _defineProperty(this, 'updated', void 0);
+
+    this._snapshotPath = snapshotPath;
+
+    const _getSnapshotData = (0, _utils.getSnapshotData)(
+        this._snapshotPath,
+        options.updateSnapshot
+      ),
+      data = _getSnapshotData.data,
+      dirty = _getSnapshotData.dirty;
+
+    this._snapshotData = data;
+    this._dirty = dirty;
+    this._getBabelTraverse = options.getBabelTraverse;
+    this._getPrettier = options.getPrettier;
+    this._inlineSnapshots = [];
+    this._uncheckedKeys = new Set(Object.keys(this._snapshotData));
+    this._counters = new Map();
+    this._index = 0;
+    this.expand = options.expand || false;
+    this.added = 0;
+    this.matched = 0;
+    this.unmatched = 0;
+    this._updateSnapshot = options.updateSnapshot;
+    this.updated = 0;
+  }
+
+  markSnapshotsAsCheckedForTest(testName) {
+    this._uncheckedKeys.forEach(uncheckedKey => {
+      if ((0, _utils.keyToTestName)(uncheckedKey) === testName) {
+        this._uncheckedKeys.delete(uncheckedKey);
+      }
+    });
+  }
+
+  _addSnapshot(key, receivedSerialized, options) {
+    this._dirty = true;
+
+    if (options.isInline) {
+      const error = options.error || new Error();
+      const lines = (0, _jestMessageUtil.getStackTraceLines)(error.stack || '');
+      const frame = (0, _jestMessageUtil.getTopFrame)(lines);
+
+      if (!frame) {
+        throw new Error(
+          "Jest: Couldn't infer stack frame for inline snapshot."
+        );
+      }
+
+      this._inlineSnapshots.push({
+        frame,
+        snapshot: receivedSerialized
+      });
+    } else {
+      this._snapshotData[key] = receivedSerialized;
+    }
+  }
+
+  save() {
+    const hasExternalSnapshots = Object.keys(this._snapshotData).length;
+    const hasInlineSnapshots = this._inlineSnapshots.length;
+    const isEmpty = !hasExternalSnapshots && !hasInlineSnapshots;
+    const status = {
+      deleted: false,
+      saved: false
+    };
+
+    if ((this._dirty || this._uncheckedKeys.size) && !isEmpty) {
+      if (hasExternalSnapshots) {
+        (0, _utils.saveSnapshotFile)(this._snapshotData, this._snapshotPath);
+      }
+
+      if (hasInlineSnapshots) {
+        const prettier = this._getPrettier(); // Load lazily
+
+        const babelTraverse = this._getBabelTraverse(); // Load lazily
+
+        (0, _inline_snapshots.saveInlineSnapshots)(
+          this._inlineSnapshots,
+          prettier,
+          babelTraverse
+        );
+      }
+
+      status.saved = true;
+    } else if (!hasExternalSnapshots && jestExistsFile(this._snapshotPath)) {
+      if (this._updateSnapshot === 'all') {
+        _fs.default.unlinkSync(this._snapshotPath);
+      }
+
+      status.deleted = true;
+    }
+
+    return status;
+  }
+
+  getUncheckedCount() {
+    return this._uncheckedKeys.size || 0;
+  }
+
+  getUncheckedKeys() {
+    return Array.from(this._uncheckedKeys);
+  }
+
+  removeUncheckedKeys() {
+    if (this._updateSnapshot === 'all' && this._uncheckedKeys.size) {
+      this._dirty = true;
+
+      this._uncheckedKeys.forEach(key => delete this._snapshotData[key]);
+
+      this._uncheckedKeys.clear();
+    }
+  }
+
+  match({testName, received, key, inlineSnapshot, error}) {
+    this._counters.set(testName, (this._counters.get(testName) || 0) + 1);
+
+    const count = Number(this._counters.get(testName));
+    const isInline = inlineSnapshot !== undefined;
+
+    if (!key) {
+      key = (0, _utils.testNameToKey)(testName, count);
+    } // Do not mark the snapshot as "checked" if the snapshot is inline and
+    // there's an external snapshot. This way the external snapshot can be
+    // removed with `--updateSnapshot`.
+
+    if (!(isInline && this._snapshotData[key])) {
+      this._uncheckedKeys.delete(key);
+    }
+
+    const receivedSerialized = (0, _utils.serialize)(received);
+    const expected = isInline ? inlineSnapshot : this._snapshotData[key];
+    const pass = expected === receivedSerialized;
+    const hasSnapshot = isInline
+      ? inlineSnapshot !== ''
+      : this._snapshotData[key] !== undefined;
+
+    const snapshotIsPersisted =
+      isInline || _fs.default.existsSync(this._snapshotPath);
+
+    if (pass && !isInline) {
+      // Executing a snapshot file as JavaScript and writing the strings back
+      // when other snapshots have changed loses the proper escaping for some
+      // characters. Since we check every snapshot in every test, use the newly
+      // generated formatted string.
+      // Note that this is only relevant when a snapshot is added and the dirty
+      // flag is set.
+      this._snapshotData[key] = receivedSerialized;
+    } // These are the conditions on when to write snapshots:
+    //  * There's no snapshot file in a non-CI environment.
+    //  * There is a snapshot file and we decided to update the snapshot.
+    //  * There is a snapshot file, but it doesn't have this snaphsot.
+    // These are the conditions on when not to write snapshots:
+    //  * The update flag is set to 'none'.
+    //  * There's no snapshot file or a file without this snapshot on a CI environment.
+
+    if (
+      (hasSnapshot && this._updateSnapshot === 'all') ||
+      ((!hasSnapshot || !snapshotIsPersisted) &&
+        (this._updateSnapshot === 'new' || this._updateSnapshot === 'all'))
+    ) {
+      if (this._updateSnapshot === 'all') {
+        if (!pass) {
+          if (hasSnapshot) {
+            this.updated++;
+          } else {
+            this.added++;
+          }
+
+          this._addSnapshot(key, receivedSerialized, {
+            error,
+            isInline
+          });
+        } else {
+          this.matched++;
+        }
+      } else {
+        this._addSnapshot(key, receivedSerialized, {
+          error,
+          isInline
+        });
+
+        this.added++;
+      }
+
+      return {
+        actual: '',
+        count,
+        expected: '',
+        key,
+        pass: true
+      };
+    } else {
+      if (!pass) {
+        this.unmatched++;
+        return {
+          actual: (0, _utils.unescape)(receivedSerialized),
+          count,
+          expected: expected ? (0, _utils.unescape)(expected) : null,
+          key,
+          pass: false
+        };
+      } else {
+        this.matched++;
+        return {
+          actual: '',
+          count,
+          expected: '',
+          key,
+          pass: true
+        };
+      }
+    }
+  }
+
+  fail(testName, _received, key) {
+    this._counters.set(testName, (this._counters.get(testName) || 0) + 1);
+
+    const count = Number(this._counters.get(testName));
+
+    if (!key) {
+      key = (0, _utils.testNameToKey)(testName, count);
+    }
+
+    this._uncheckedKeys.delete(key);
+
+    this.unmatched++;
+    return key;
+  }
+}
+
+exports.default = SnapshotState;

node_modules/jest-snapshot/build/index.d.ts

@@ -0,0 +1,120 @@
+/**
+ * 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 { Config } from '@jest/types';
+import { MatcherState } from 'expect';
+import { SnapshotResolver as JestSnapshotResolver } from './snapshot_resolver';
+import SnapshotState from './State';
+import * as utils from './utils';
+declare type Context = MatcherState & {
+    snapshotState: SnapshotState;
+};
+declare const JestSnapshot: {
+    EXTENSION: string;
+    SnapshotState: typeof SnapshotState;
+    addSerializer: (plugin: import("pretty-format/build/types").Plugin) => void;
+    buildSnapshotResolver: (config: Config.ProjectConfig) => JestSnapshotResolver;
+    cleanup: (hasteFS: import("../../jest-haste-map/build/HasteFS").default, update: Config.SnapshotUpdateState, snapshotResolver: JestSnapshotResolver) => {
+        filesRemoved: number;
+    };
+    getSerializers: () => import("pretty-format/build/types").Plugin[];
+    isSnapshotPath: (path: string) => boolean;
+    toMatchInlineSnapshot: (this: Context, received: any, propertyMatchersOrInlineSnapshot?: any, inlineSnapshot?: string | undefined) => {
+        message: () => string;
+        name: string;
+        pass: boolean;
+        report: () => string;
+        actual?: undefined;
+        expected?: undefined;
+    } | {
+        message: () => string;
+        pass: boolean;
+        name?: undefined;
+        report?: undefined;
+        actual?: undefined;
+        expected?: undefined;
+    } | {
+        actual: string;
+        expected: string | null;
+        message: () => string;
+        name: string;
+        pass: boolean;
+        report: () => string;
+    };
+    toMatchSnapshot: (this: Context, received: any, propertyMatchers?: any, hint?: string | undefined) => {
+        message: () => string;
+        name: string;
+        pass: boolean;
+        report: () => string;
+        actual?: undefined;
+        expected?: undefined;
+    } | {
+        message: () => string;
+        pass: boolean;
+        name?: undefined;
+        report?: undefined;
+        actual?: undefined;
+        expected?: undefined;
+    } | {
+        actual: string;
+        expected: string | null;
+        message: () => string;
+        name: string;
+        pass: boolean;
+        report: () => string;
+    };
+    toThrowErrorMatchingInlineSnapshot: (this: Context, received: any, inlineSnapshot?: string | undefined, fromPromise?: boolean | undefined) => {
+        message: () => string;
+        name: string;
+        pass: boolean;
+        report: () => string;
+        actual?: undefined;
+        expected?: undefined;
+    } | {
+        message: () => string;
+        pass: boolean;
+        name?: undefined;
+        report?: undefined;
+        actual?: undefined;
+        expected?: undefined;
+    } | {
+        actual: string;
+        expected: string | null;
+        message: () => string;
+        name: string;
+        pass: boolean;
+        report: () => string;
+    };
+    toThrowErrorMatchingSnapshot: (this: Context, received: any, hint: string | undefined, fromPromise: boolean) => {
+        message: () => string;
+        name: string;
+        pass: boolean;
+        report: () => string;
+        actual?: undefined;
+        expected?: undefined;
+    } | {
+        message: () => string;
+        pass: boolean;
+        name?: undefined;
+        report?: undefined;
+        actual?: undefined;
+        expected?: undefined;
+    } | {
+        actual: string;
+        expected: string | null;
+        message: () => string;
+        name: string;
+        pass: boolean;
+        report: () => string;
+    };
+    utils: typeof utils;
+};
+declare namespace JestSnapshot {
+    type SnapshotResolver = JestSnapshotResolver;
+    type SnapshotStateType = SnapshotState;
+}
+export = JestSnapshot;
+//# sourceMappingURL=index.d.ts.map

node_modules/jest-snapshot/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAEnC,OAAO,EAAC,YAAY,EAAC,MAAM,QAAQ,CAAC;AAUpC,OAAO,EAGL,gBAAgB,IAAI,oBAAoB,EAEzC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,aAAa,MAAM,SAAS,CAAC;AAEpC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AAEjC,aAAK,OAAO,GAAG,YAAY,GAAG;IAC5B,aAAa,EAAE,aAAa,CAAC;CAC9B,CAAC;AAobF,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAajB,CAAC;AAEF,kBAAU,YAAY,CAAC;IACrB,KAAY,gBAAgB,GAAG,oBAAoB,CAAC;IACpD,KAAY,iBAAiB,GAAG,aAAa,CAAC;CAC/C;AAED,SAAS,YAAY,CAAC"}

node_modules/jest-snapshot/build/index.js

@@ -0,0 +1,517 @@
+'use strict';
+
+var _fs = _interopRequireDefault(require('fs'));
+
+var _jestDiff = _interopRequireDefault(require('jest-diff'));
+
+var _jestMatcherUtils = require('jest-matcher-utils');
+
+var _snapshot_resolver = require('./snapshot_resolver');
+
+var _State = _interopRequireDefault(require('./State'));
+
+var _plugins = require('./plugins');
+
+var utils = _interopRequireWildcard(require('./utils'));
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  } else {
+    var newObj = {};
+    if (obj != null) {
+      for (var key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc =
+            Object.defineProperty && Object.getOwnPropertyDescriptor
+              ? Object.getOwnPropertyDescriptor(obj, key)
+              : {};
+          if (desc.get || desc.set) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+    }
+    newObj.default = obj;
+    return newObj;
+  }
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+var jestExistsFile =
+  global[Symbol.for('jest-native-exists-file')] || _fs.default.existsSync;
+
+const DID_NOT_THROW = 'Received function did not throw'; // same as toThrow
+
+const NOT_SNAPSHOT_MATCHERS = `.${(0, _jestMatcherUtils.BOLD_WEIGHT)(
+  'not'
+)} cannot be used with snapshot matchers`;
+const HINT_ARG = (0, _jestMatcherUtils.BOLD_WEIGHT)('hint');
+const INLINE_SNAPSHOT_ARG = 'snapshot';
+const PROPERTY_MATCHERS_ARG = 'properties';
+const INDENTATION_REGEX = /^([^\S\n]*)\S/m; // Display name in report when matcher fails same as in snapshot file,
+// but with optional hint argument in bold weight.
+
+const printName = (concatenatedBlockNames = '', hint = '', count) => {
+  const hasNames = concatenatedBlockNames.length !== 0;
+  const hasHint = hint.length !== 0;
+  return (
+    '`' +
+    (hasNames ? utils.escapeBacktickString(concatenatedBlockNames) : '') +
+    (hasNames && hasHint ? ': ' : '') +
+    (hasHint
+      ? (0, _jestMatcherUtils.BOLD_WEIGHT)(utils.escapeBacktickString(hint))
+      : '') +
+    ' ' +
+    count +
+    '`'
+  );
+};
+
+function stripAddedIndentation(inlineSnapshot) {
+  // Find indentation if exists.
+  const match = inlineSnapshot.match(INDENTATION_REGEX);
+
+  if (!match || !match[1]) {
+    // No indentation.
+    return inlineSnapshot;
+  }
+
+  const indentation = match[1];
+  const lines = inlineSnapshot.split('\n');
+
+  if (lines.length <= 2) {
+    // Must be at least 3 lines.
+    return inlineSnapshot;
+  }
+
+  if (lines[0].trim() !== '' || lines[lines.length - 1].trim() !== '') {
+    // If not blank first and last lines, abort.
+    return inlineSnapshot;
+  }
+
+  for (let i = 1; i < lines.length - 1; i++) {
+    if (lines[i] !== '') {
+      if (lines[i].indexOf(indentation) !== 0) {
+        // All lines except first and last should either be blank or have the same
+        // indent as the first line (or more). If this isn't the case we don't
+        // want to touch the snapshot at all.
+        return inlineSnapshot;
+      }
+
+      lines[i] = lines[i].substr(indentation.length);
+    }
+  } // Last line is a special case because it won't have the same indent as others
+  // but may still have been given some indent to line up.
+
+  lines[lines.length - 1] = ''; // Return inline snapshot, now at indent 0.
+
+  inlineSnapshot = lines.join('\n');
+  return inlineSnapshot;
+}
+
+const fileExists = (filePath, hasteFS) =>
+  hasteFS.exists(filePath) || jestExistsFile(filePath);
+
+const cleanup = (hasteFS, update, snapshotResolver) => {
+  const pattern = '\\.' + _snapshot_resolver.EXTENSION + '$';
+  const files = hasteFS.matchFiles(pattern);
+  const filesRemoved = files.reduce((acc, snapshotFile) => {
+    if (!fileExists(snapshotResolver.resolveTestPath(snapshotFile), hasteFS)) {
+      if (update === 'all') {
+        _fs.default.unlinkSync(snapshotFile);
+      }
+
+      return acc + 1;
+    }
+
+    return acc;
+  }, 0);
+  return {
+    filesRemoved
+  };
+};
+
+const toMatchSnapshot = function toMatchSnapshot(
+  received,
+  propertyMatchers,
+  hint
+) {
+  const matcherName = 'toMatchSnapshot';
+  let expectedArgument = '';
+  let secondArgument = '';
+
+  if (typeof propertyMatchers === 'object' && propertyMatchers !== null) {
+    expectedArgument = PROPERTY_MATCHERS_ARG;
+
+    if (typeof hint === 'string' && hint.length !== 0) {
+      secondArgument = HINT_ARG;
+    }
+  } else if (
+    typeof propertyMatchers === 'string' &&
+    propertyMatchers.length !== 0
+  ) {
+    expectedArgument = HINT_ARG;
+  }
+
+  const options = {
+    isNot: this.isNot,
+    promise: this.promise,
+    secondArgument
+  };
+
+  if (arguments.length === 3 && !propertyMatchers) {
+    throw new Error(
+      'Property matchers must be an object.\n\nTo provide a snapshot test name without property matchers, use: toMatchSnapshot("name")'
+    );
+  }
+
+  return _toMatchSnapshot({
+    context: this,
+    expectedArgument,
+    hint,
+    matcherName,
+    options,
+    propertyMatchers,
+    received
+  });
+};
+
+const toMatchInlineSnapshot = function toMatchInlineSnapshot(
+  received,
+  propertyMatchersOrInlineSnapshot,
+  inlineSnapshot
+) {
+  const matcherName = 'toMatchInlineSnapshot';
+  let expectedArgument = '';
+  let secondArgument = '';
+
+  if (typeof propertyMatchersOrInlineSnapshot === 'string') {
+    expectedArgument = INLINE_SNAPSHOT_ARG;
+  } else if (
+    typeof propertyMatchersOrInlineSnapshot === 'object' &&
+    propertyMatchersOrInlineSnapshot !== null
+  ) {
+    expectedArgument = PROPERTY_MATCHERS_ARG;
+
+    if (typeof inlineSnapshot === 'string') {
+      secondArgument = INLINE_SNAPSHOT_ARG;
+    }
+  }
+
+  const options = {
+    isNot: this.isNot,
+    promise: this.promise,
+    secondArgument
+  };
+  let propertyMatchers;
+
+  if (typeof propertyMatchersOrInlineSnapshot === 'string') {
+    inlineSnapshot = propertyMatchersOrInlineSnapshot;
+  } else {
+    propertyMatchers = propertyMatchersOrInlineSnapshot;
+  }
+
+  return _toMatchSnapshot({
+    context: this,
+    expectedArgument,
+    inlineSnapshot: stripAddedIndentation(inlineSnapshot || ''),
+    matcherName,
+    options,
+    propertyMatchers,
+    received
+  });
+};
+
+const _toMatchSnapshot = ({
+  context,
+  expectedArgument,
+  hint,
+  inlineSnapshot,
+  matcherName,
+  options,
+  propertyMatchers,
+  received
+}) => {
+  context.dontThrow && context.dontThrow();
+  hint = typeof propertyMatchers === 'string' ? propertyMatchers : hint;
+  const currentTestName = context.currentTestName,
+    isNot = context.isNot,
+    snapshotState = context.snapshotState;
+
+  if (isNot) {
+    throw new Error(
+      (0, _jestMatcherUtils.matcherHint)(
+        matcherName,
+        undefined,
+        expectedArgument,
+        options
+      ) +
+        '\n\n' +
+        NOT_SNAPSHOT_MATCHERS
+    );
+  }
+
+  if (!snapshotState) {
+    throw new Error(
+      (0, _jestMatcherUtils.matcherHint)(
+        matcherName,
+        undefined,
+        expectedArgument,
+        options
+      ) + '\n\nsnapshot state must be initialized'
+    );
+  }
+
+  const fullTestName =
+    currentTestName && hint
+      ? `${currentTestName}: ${hint}`
+      : currentTestName || ''; // future BREAKING change: || hint
+
+  if (typeof propertyMatchers === 'object') {
+    if (propertyMatchers === null) {
+      throw new Error(`Property matchers must be an object.`);
+    }
+
+    const propertyPass = context.equals(received, propertyMatchers, [
+      context.utils.iterableEquality,
+      context.utils.subsetEquality
+    ]);
+
+    if (!propertyPass) {
+      const key = snapshotState.fail(fullTestName, received);
+      const matched = /(\d+)$/.exec(key);
+      const count = matched === null ? 1 : Number(matched[1]);
+
+      const report = () =>
+        `Snapshot name: ${printName(currentTestName, hint, count)}\n` +
+        '\n' +
+        `Expected properties: ${context.utils.printExpected(
+          propertyMatchers
+        )}\n` +
+        `Received value:      ${context.utils.printReceived(received)}`;
+
+      return {
+        message: () =>
+          (0, _jestMatcherUtils.matcherHint)(
+            matcherName,
+            undefined,
+            expectedArgument,
+            options
+          ) +
+          '\n\n' +
+          report(),
+        name: matcherName,
+        pass: false,
+        report
+      };
+    } else {
+      received = utils.deepMerge(received, propertyMatchers);
+    }
+  }
+
+  const result = snapshotState.match({
+    error: context.error,
+    inlineSnapshot,
+    received,
+    testName: fullTestName
+  });
+  const count = result.count,
+    pass = result.pass;
+  let actual = result.actual,
+    expected = result.expected;
+  let report;
+
+  if (pass) {
+    return {
+      message: () => '',
+      pass: true
+    };
+  } else if (!expected) {
+    report = () =>
+      `New snapshot was ${(0, _jestMatcherUtils.RECEIVED_COLOR)(
+        'not written'
+      )}. The update flag ` +
+      `must be explicitly passed to write a new snapshot.\n\n` +
+      `This is likely because this test is run in a continuous integration ` +
+      `(CI) environment in which snapshots are not written by default.\n\n` +
+      `${(0, _jestMatcherUtils.RECEIVED_COLOR)('Received value')} ` +
+      `${actual}`;
+  } else {
+    expected = (expected || '').trim();
+    actual = (actual || '').trim();
+    const diffMessage = (0, _jestDiff.default)(expected, actual, {
+      aAnnotation: 'Snapshot',
+      bAnnotation: 'Received',
+      expand: snapshotState.expand
+    });
+
+    report = () =>
+      `Snapshot name: ${printName(currentTestName, hint, count)}\n\n` +
+      (diffMessage ||
+        (0, _jestMatcherUtils.EXPECTED_COLOR)('- ' + (expected || '')) +
+          '\n' +
+          (0, _jestMatcherUtils.RECEIVED_COLOR)('+ ' + actual));
+  } // Passing the actual and expected objects so that a custom reporter
+  // could access them, for example in order to display a custom visual diff,
+  // or create a different error message
+
+  return {
+    actual,
+    expected,
+    message: () =>
+      (0, _jestMatcherUtils.matcherHint)(
+        matcherName,
+        undefined,
+        expectedArgument,
+        options
+      ) +
+      '\n\n' +
+      report(),
+    name: matcherName,
+    pass: false,
+    report
+  };
+};
+
+const toThrowErrorMatchingSnapshot = function toThrowErrorMatchingSnapshot(
+  received,
+  hint, // because error TS1016 for hint?: string
+  fromPromise
+) {
+  const matcherName = 'toThrowErrorMatchingSnapshot';
+  const expectedArgument =
+    typeof hint === 'string' && hint.length !== 0 ? HINT_ARG : '';
+  const options = {
+    isNot: this.isNot,
+    promise: this.promise,
+    secondArgument: ''
+  };
+  return _toThrowErrorMatchingSnapshot(
+    {
+      context: this,
+      expectedArgument,
+      hint,
+      matcherName,
+      options,
+      received
+    },
+    fromPromise
+  );
+};
+
+const toThrowErrorMatchingInlineSnapshot = function toThrowErrorMatchingInlineSnapshot(
+  received,
+  inlineSnapshot,
+  fromPromise
+) {
+  const matcherName = 'toThrowErrorMatchingInlineSnapshot';
+  const expectedArgument =
+    typeof inlineSnapshot === 'string' ? INLINE_SNAPSHOT_ARG : '';
+  const options = {
+    isNot: this.isNot,
+    promise: this.promise,
+    secondArgument: ''
+  };
+  return _toThrowErrorMatchingSnapshot(
+    {
+      context: this,
+      expectedArgument,
+      inlineSnapshot: inlineSnapshot || '',
+      matcherName,
+      options,
+      received
+    },
+    fromPromise
+  );
+};
+
+const _toThrowErrorMatchingSnapshot = (
+  {
+    context,
+    expectedArgument,
+    inlineSnapshot,
+    matcherName,
+    options,
+    received,
+    hint
+  },
+  fromPromise
+) => {
+  context.dontThrow && context.dontThrow();
+  const isNot = context.isNot;
+
+  if (isNot) {
+    throw new Error(
+      (0, _jestMatcherUtils.matcherHint)(
+        matcherName,
+        undefined,
+        expectedArgument,
+        options
+      ) +
+        '\n\n' +
+        NOT_SNAPSHOT_MATCHERS
+    );
+  }
+
+  let error;
+
+  if (fromPromise) {
+    error = received;
+  } else {
+    try {
+      received();
+    } catch (e) {
+      error = e;
+    }
+  }
+
+  if (error === undefined) {
+    throw new Error(
+      (0, _jestMatcherUtils.matcherHint)(
+        matcherName,
+        undefined,
+        expectedArgument,
+        options
+      ) +
+        '\n\n' +
+        DID_NOT_THROW
+    );
+  }
+
+  return _toMatchSnapshot({
+    context,
+    expectedArgument,
+    hint,
+    inlineSnapshot,
+    matcherName,
+    options,
+    received: error.message
+  });
+};
+
+const JestSnapshot = {
+  EXTENSION: _snapshot_resolver.EXTENSION,
+  SnapshotState: _State.default,
+  addSerializer: _plugins.addSerializer,
+  buildSnapshotResolver: _snapshot_resolver.buildSnapshotResolver,
+  cleanup,
+  getSerializers: _plugins.getSerializers,
+  isSnapshotPath: _snapshot_resolver.isSnapshotPath,
+  toMatchInlineSnapshot,
+  toMatchSnapshot,
+  toThrowErrorMatchingInlineSnapshot,
+  toThrowErrorMatchingSnapshot,
+  utils
+};
+/* eslint-disable-next-line no-redeclare */
+
+module.exports = JestSnapshot;

node_modules/jest-snapshot/build/inline_snapshots.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 { Frame } from 'jest-message-util';
+export declare type InlineSnapshot = {
+    snapshot: string;
+    frame: Frame;
+};
+export declare const saveInlineSnapshots: (snapshots: InlineSnapshot[], prettier: any, babelTraverse: Function) => void;
+//# sourceMappingURL=inline_snapshots.d.ts.map

node_modules/jest-snapshot/build/inline_snapshots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline_snapshots.d.ts","sourceRoot":"","sources":["../src/inline_snapshots.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAWH,OAAO,EAAC,KAAK,EAAC,MAAM,mBAAmB,CAAC;AAKxC,oBAAY,cAAc,GAAG;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF,eAAO,MAAM,mBAAmB,+EA8B/B,CAAC"}

node_modules/jest-snapshot/build/inline_snapshots.js

@@ -0,0 +1,323 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.saveInlineSnapshots = void 0;
+
+var _fs = _interopRequireDefault(require('fs'));
+
+var _path = _interopRequireDefault(require('path'));
+
+var _semver = _interopRequireDefault(require('semver'));
+
+var _types = require('@babel/types');
+
+var _utils = require('./utils');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+var jestWriteFile =
+  global[Symbol.for('jest-native-write-file')] || _fs.default.writeFileSync;
+
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === 'function') {
+      ownKeys = ownKeys.concat(
+        Object.getOwnPropertySymbols(source).filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        })
+      );
+    }
+    ownKeys.forEach(function(key) {
+      _defineProperty(target, key, source[key]);
+    });
+  }
+  return target;
+}
+
+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;
+}
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+var jestReadFile =
+  global[Symbol.for('jest-native-read-file')] || _fs.default.readFileSync;
+
+const saveInlineSnapshots = (snapshots, prettier, babelTraverse) => {
+  if (!prettier) {
+    throw new Error(
+      `Jest: Inline Snapshots requires Prettier.\n` +
+        `Please ensure "prettier" is installed in your project.`
+    );
+  } // Custom parser API was added in 1.5.0
+
+  if (_semver.default.lt(prettier.version, '1.5.0')) {
+    throw new Error(
+      `Jest: Inline Snapshots require prettier>=1.5.0.\n` +
+        `Please upgrade "prettier".`
+    );
+  }
+
+  const snapshotsByFile = groupSnapshotsByFile(snapshots);
+
+  var _arr = Object.keys(snapshotsByFile);
+
+  for (var _i = 0; _i < _arr.length; _i++) {
+    const sourceFilePath = _arr[_i];
+    saveSnapshotsForFile(
+      snapshotsByFile[sourceFilePath],
+      sourceFilePath,
+      prettier,
+      babelTraverse
+    );
+  }
+};
+
+exports.saveInlineSnapshots = saveInlineSnapshots;
+
+const saveSnapshotsForFile = (
+  snapshots,
+  sourceFilePath,
+  prettier,
+  babelTraverse
+) => {
+  const sourceFile = jestReadFile(sourceFilePath, 'utf8'); // Resolve project configuration.
+  // For older versions of Prettier, do not load configuration.
+
+  const config = prettier.resolveConfig
+    ? prettier.resolveConfig.sync(sourceFilePath, {
+        editorconfig: true
+      })
+    : null; // Detect the parser for the test file.
+  // For older versions of Prettier, fallback to a simple parser detection.
+
+  const inferredParser = prettier.getFileInfo
+    ? prettier.getFileInfo.sync(sourceFilePath).inferredParser
+    : (config && config.parser) || simpleDetectParser(sourceFilePath); // Insert snapshots using the custom parser API. After insertion, the code is
+  // formatted, except snapshot indentation. Snapshots cannot be formatted until
+  // after the initial format because we don't know where the call expression
+  // will be placed (specifically its indentation).
+
+  const newSourceFile = prettier.format(
+    sourceFile,
+    _objectSpread({}, config, {
+      filepath: sourceFilePath,
+      parser: createInsertionParser(snapshots, inferredParser, babelTraverse)
+    })
+  ); // Format the snapshots using the custom parser API.
+
+  const formattedNewSourceFile = prettier.format(
+    newSourceFile,
+    _objectSpread({}, config, {
+      filepath: sourceFilePath,
+      parser: createFormattingParser(inferredParser, babelTraverse)
+    })
+  );
+
+  if (formattedNewSourceFile !== sourceFile) {
+    jestWriteFile(sourceFilePath, formattedNewSourceFile);
+  }
+};
+
+const groupSnapshotsBy = createKey => snapshots =>
+  snapshots.reduce((object, inlineSnapshot) => {
+    const key = createKey(inlineSnapshot);
+    return _objectSpread({}, object, {
+      [key]: (object[key] || []).concat(inlineSnapshot)
+    });
+  }, {});
+
+const groupSnapshotsByFrame = groupSnapshotsBy(({frame: {line, column}}) =>
+  typeof line === 'number' && typeof column === 'number'
+    ? `${line}:${column - 1}`
+    : ''
+);
+const groupSnapshotsByFile = groupSnapshotsBy(({frame: {file}}) => file);
+
+const indent = (snapshot, numIndents, indentation) => {
+  const lines = snapshot.split('\n');
+  return lines
+    .map((line, index) => {
+      if (index === 0) {
+        // First line is either a 1-line snapshot or a blank line.
+        return line;
+      } else if (index !== lines.length - 1) {
+        // Do not indent empty lines.
+        if (line === '') {
+          return line;
+        } // Not last line, indent one level deeper than expect call.
+
+        return indentation.repeat(numIndents + 1) + line;
+      } else {
+        // The last line should be placed on the same level as the expect call.
+        return indentation.repeat(numIndents) + line;
+      }
+    })
+    .join('\n');
+};
+
+const getAst = (parsers, inferredParser, text) => {
+  // Flow uses a 'Program' parent node, babel expects a 'File'.
+  let ast = parsers[inferredParser](text);
+
+  if (ast.type !== 'File') {
+    ast = (0, _types.file)(ast, ast.comments, ast.tokens);
+    delete ast.program.comments;
+  }
+
+  return ast;
+}; // This parser inserts snapshots into the AST.
+
+const createInsertionParser = (snapshots, inferredParser, babelTraverse) => (
+  text,
+  parsers,
+  options
+) => {
+  // Workaround for https://github.com/prettier/prettier/issues/3150
+  options.parser = inferredParser;
+  const groupedSnapshots = groupSnapshotsByFrame(snapshots);
+  const remainingSnapshots = new Set(snapshots.map(({snapshot}) => snapshot));
+  const ast = getAst(parsers, inferredParser, text);
+  babelTraverse(ast, {
+    CallExpression({node: {arguments: args, callee}}) {
+      if (
+        callee.type !== 'MemberExpression' ||
+        callee.property.type !== 'Identifier'
+      ) {
+        return;
+      }
+
+      const _callee$property$loc$ = callee.property.loc.start,
+        line = _callee$property$loc$.line,
+        column = _callee$property$loc$.column;
+      const snapshotsForFrame = groupedSnapshots[`${line}:${column}`];
+
+      if (!snapshotsForFrame) {
+        return;
+      }
+
+      if (snapshotsForFrame.length > 1) {
+        throw new Error(
+          'Jest: Multiple inline snapshots for the same call are not supported.'
+        );
+      }
+
+      const snapshotIndex = args.findIndex(
+        ({type}) => type === 'TemplateLiteral'
+      );
+      const values = snapshotsForFrame.map(({snapshot}) => {
+        remainingSnapshots.delete(snapshot);
+        return (0, _types.templateLiteral)(
+          [
+            (0, _types.templateElement)({
+              raw: (0, _utils.escapeBacktickString)(snapshot)
+            })
+          ],
+          []
+        );
+      });
+      const replacementNode = values[0];
+
+      if (snapshotIndex > -1) {
+        args[snapshotIndex] = replacementNode;
+      } else {
+        args.push(replacementNode);
+      }
+    }
+  });
+
+  if (remainingSnapshots.size) {
+    throw new Error(`Jest: Couldn't locate all inline snapshots.`);
+  }
+
+  return ast;
+}; // This parser formats snapshots to the correct indentation.
+
+const createFormattingParser = (inferredParser, babelTraverse) => (
+  text,
+  parsers,
+  options
+) => {
+  // Workaround for https://github.com/prettier/prettier/issues/3150
+  options.parser = inferredParser;
+  const ast = getAst(parsers, inferredParser, text);
+  babelTraverse(ast, {
+    CallExpression({node: {arguments: args, callee}}) {
+      if (
+        callee.type !== 'MemberExpression' ||
+        callee.property.type !== 'Identifier' ||
+        callee.property.name !== 'toMatchInlineSnapshot' ||
+        !callee.loc ||
+        callee.computed
+      ) {
+        return;
+      }
+
+      let snapshotIndex;
+      let snapshot;
+
+      for (let i = 0; i < args.length; i++) {
+        const node = args[i];
+
+        if (node.type === 'TemplateLiteral') {
+          snapshotIndex = i;
+          snapshot = node.quasis[0].value.raw;
+        }
+      }
+
+      if (snapshot === undefined || snapshotIndex === undefined) {
+        return;
+      }
+
+      const useSpaces = !options.useTabs;
+      snapshot = indent(
+        snapshot,
+        Math.ceil(
+          useSpaces
+            ? callee.loc.start.column / options.tabWidth
+            : callee.loc.start.column / 2 // Each tab is 2 characters.
+        ),
+        useSpaces ? ' '.repeat(options.tabWidth) : '\t'
+      );
+      const replacementNode = (0, _types.templateLiteral)(
+        [
+          (0, _types.templateElement)({
+            raw: snapshot
+          })
+        ],
+        []
+      );
+      args[snapshotIndex] = replacementNode;
+    }
+  });
+  return ast;
+};
+
+const simpleDetectParser = filePath => {
+  const extname = _path.default.extname(filePath);
+
+  if (/tsx?$/.test(extname)) {
+    return 'typescript';
+  }
+
+  return 'babylon';
+};

node_modules/jest-snapshot/build/mock_serializer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 { NewPlugin } from 'pretty-format';
+export declare const serialize: NewPlugin['serialize'];
+export declare const test: NewPlugin['test'];
+declare const plugin: NewPlugin;
+export default plugin;
+//# sourceMappingURL=mock_serializer.d.ts.map

node_modules/jest-snapshot/build/mock_serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock_serializer.d.ts","sourceRoot":"","sources":["../src/mock_serializer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAC,SAAS,EAAC,MAAM,eAAe,CAAC;AAExC,eAAO,MAAM,SAAS,EAAE,SAAS,CAAC,WAAW,CAiC5C,CAAC;AAEF,eAAO,MAAM,IAAI,EAAE,SAAS,CAAC,MAAM,CAAuC,CAAC;AAE3E,QAAA,MAAM,MAAM,EAAE,SAA6B,CAAC;AAE5C,eAAe,MAAM,CAAC"}

node_modules/jest-snapshot/build/mock_serializer.js

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = exports.test = exports.serialize = void 0;
+
+/**
+ * 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 serialize = (val, config, indentation, depth, refs, printer) => {
+  // Serialize a non-default name, even if config.printFunctionName is false.
+  const name = val.getMockName();
+  const nameString = name === 'jest.fn()' ? '' : ' ' + name;
+  let callsString = '';
+
+  if (val.mock.calls.length !== 0) {
+    const indentationNext = indentation + config.indent;
+    callsString =
+      ' {' +
+      config.spacingOuter +
+      indentationNext +
+      '"calls": ' +
+      printer(val.mock.calls, config, indentationNext, depth, refs) +
+      (config.min ? ', ' : ',') +
+      config.spacingOuter +
+      indentationNext +
+      '"results": ' +
+      printer(val.mock.results, config, indentationNext, depth, refs) +
+      (config.min ? '' : ',') +
+      config.spacingOuter +
+      indentation +
+      '}';
+  }
+
+  return '[MockFunction' + nameString + ']' + callsString;
+};
+
+exports.serialize = serialize;
+
+const test = val => val && !!val._isMockFunction;
+
+exports.test = test;
+const plugin = {
+  serialize,
+  test
+};
+var _default = plugin;
+exports.default = _default;

node_modules/jest-snapshot/build/plugins.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.
+ */
+export declare const addSerializer: (plugin: import("pretty-format/build/types").Plugin) => void;
+export declare const getSerializers: () => import("pretty-format/build/types").Plugin[];
+//# sourceMappingURL=plugins.d.ts.map

node_modules/jest-snapshot/build/plugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../src/plugins.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA0BH,eAAO,MAAM,aAAa,8DAEzB,CAAC;AAEF,eAAO,MAAM,cAAc,oDAAgB,CAAC"}

node_modules/jest-snapshot/build/plugins.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.getSerializers = exports.addSerializer = void 0;
+
+var _prettyFormat = _interopRequireDefault(require('pretty-format'));
+
+var _mock_serializer = _interopRequireDefault(require('./mock_serializer'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * 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 _prettyFormat$plugins = _prettyFormat.default.plugins,
+  DOMCollection = _prettyFormat$plugins.DOMCollection,
+  DOMElement = _prettyFormat$plugins.DOMElement,
+  Immutable = _prettyFormat$plugins.Immutable,
+  ReactElement = _prettyFormat$plugins.ReactElement,
+  ReactTestComponent = _prettyFormat$plugins.ReactTestComponent,
+  AsymmetricMatcher = _prettyFormat$plugins.AsymmetricMatcher;
+let PLUGINS = [
+  ReactTestComponent,
+  ReactElement,
+  DOMElement,
+  DOMCollection,
+  Immutable,
+  _mock_serializer.default,
+  AsymmetricMatcher
+]; // Prepend to list so the last added is the first tested.
+
+const addSerializer = plugin => {
+  PLUGINS = [plugin].concat(PLUGINS);
+};
+
+exports.addSerializer = addSerializer;
+
+const getSerializers = () => PLUGINS;
+
+exports.getSerializers = getSerializers;

node_modules/jest-snapshot/build/snapshot_resolver.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 { Config } from '@jest/types';
+export declare type SnapshotResolver = {
+    testPathForConsistencyCheck: string;
+    resolveSnapshotPath(testPath: Config.Path, extension?: string): Config.Path;
+    resolveTestPath(snapshotPath: Config.Path, extension?: string): Config.Path;
+};
+export declare const EXTENSION = "snap";
+export declare const DOT_EXTENSION: string;
+export declare const isSnapshotPath: (path: string) => boolean;
+export declare const buildSnapshotResolver: (config: Config.ProjectConfig) => SnapshotResolver;
+//# sourceMappingURL=snapshot_resolver.d.ts.map

node_modules/jest-snapshot/build/snapshot_resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot_resolver.d.ts","sourceRoot":"","sources":["../src/snapshot_resolver.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAGnC,oBAAY,gBAAgB,GAAG;IAC7B,2BAA2B,EAAE,MAAM,CAAC;IACpC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC;IAC5E,eAAe,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC;CAC7E,CAAC;AAEF,eAAO,MAAM,SAAS,SAAS,CAAC;AAChC,eAAO,MAAM,aAAa,QAAkB,CAAC;AAE7C,eAAO,MAAM,cAAc,2BACG,CAAC;AAG/B,eAAO,MAAM,qBAAqB,oDAQjC,CAAC"}

node_modules/jest-snapshot/build/snapshot_resolver.js

@@ -0,0 +1,119 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.buildSnapshotResolver = exports.isSnapshotPath = exports.DOT_EXTENSION = exports.EXTENSION = void 0;
+
+var _path = _interopRequireDefault(require('path'));
+
+var _chalk = _interopRequireDefault(require('chalk'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * 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 EXTENSION = 'snap';
+exports.EXTENSION = EXTENSION;
+const DOT_EXTENSION = '.' + EXTENSION;
+exports.DOT_EXTENSION = DOT_EXTENSION;
+
+const isSnapshotPath = path => path.endsWith(DOT_EXTENSION);
+
+exports.isSnapshotPath = isSnapshotPath;
+const cache = new Map();
+
+const buildSnapshotResolver = config => {
+  const key = config.rootDir;
+
+  if (!cache.has(key)) {
+    cache.set(key, createSnapshotResolver(config.snapshotResolver));
+  }
+
+  return cache.get(key);
+};
+
+exports.buildSnapshotResolver = buildSnapshotResolver;
+
+function createSnapshotResolver(snapshotResolverPath) {
+  return typeof snapshotResolverPath === 'string'
+    ? createCustomSnapshotResolver(snapshotResolverPath)
+    : createDefaultSnapshotResolver();
+}
+
+function createDefaultSnapshotResolver() {
+  return {
+    resolveSnapshotPath: testPath =>
+      _path.default.join(
+        _path.default.join(_path.default.dirname(testPath), '__snapshots__'),
+        _path.default.basename(testPath) + DOT_EXTENSION
+      ),
+    resolveTestPath: snapshotPath =>
+      _path.default.resolve(
+        _path.default.dirname(snapshotPath),
+        '..',
+        _path.default.basename(snapshotPath, DOT_EXTENSION)
+      ),
+    testPathForConsistencyCheck: _path.default.posix.join(
+      'consistency_check',
+      '__tests__',
+      'example.test.js'
+    )
+  };
+}
+
+function createCustomSnapshotResolver(snapshotResolverPath) {
+  const custom = require(snapshotResolverPath);
+
+  const keys = [
+    ['resolveSnapshotPath', 'function'],
+    ['resolveTestPath', 'function'],
+    ['testPathForConsistencyCheck', 'string']
+  ];
+  keys.forEach(([propName, requiredType]) => {
+    if (typeof custom[propName] !== requiredType) {
+      throw new TypeError(mustImplement(propName, requiredType));
+    }
+  });
+  const customResolver = {
+    resolveSnapshotPath: testPath =>
+      custom.resolveSnapshotPath(testPath, DOT_EXTENSION),
+    resolveTestPath: snapshotPath =>
+      custom.resolveTestPath(snapshotPath, DOT_EXTENSION),
+    testPathForConsistencyCheck: custom.testPathForConsistencyCheck
+  };
+  verifyConsistentTransformations(customResolver);
+  return customResolver;
+}
+
+function mustImplement(propName, requiredType) {
+  return (
+    _chalk.default.bold(
+      `Custom snapshot resolver must implement a \`${propName}\` as a ${requiredType}.`
+    ) +
+    '\nDocumentation: https://facebook.github.io/jest/docs/en/configuration.html#snapshotResolver'
+  );
+}
+
+function verifyConsistentTransformations(custom) {
+  const resolvedSnapshotPath = custom.resolveSnapshotPath(
+    custom.testPathForConsistencyCheck
+  );
+  const resolvedTestPath = custom.resolveTestPath(resolvedSnapshotPath);
+
+  if (resolvedTestPath !== custom.testPathForConsistencyCheck) {
+    throw new Error(
+      _chalk.default.bold(
+        `Custom snapshot resolver functions must transform paths consistently, i.e. expects resolveTestPath(resolveSnapshotPath('${
+          custom.testPathForConsistencyCheck
+        }')) === ${resolvedTestPath}`
+      )
+    );
+  }
+}

node_modules/jest-snapshot/build/types.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.
+ */
+export declare type SnapshotData = {
+    [key: string]: string;
+};
+//# sourceMappingURL=types.d.ts.map

node_modules/jest-snapshot/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,oBAAY,YAAY,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAC,CAAC"}

node_modules/jest-snapshot/build/types.js

@@ -0,0 +1 @@
+'use strict';

node_modules/jest-snapshot/build/utils.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 { Config } from '@jest/types';
+import { SnapshotData } from './types';
+export declare const SNAPSHOT_VERSION = "1";
+export declare const SNAPSHOT_GUIDE_LINK = "https://goo.gl/fbAQLP";
+export declare const SNAPSHOT_VERSION_WARNING: string;
+export declare const testNameToKey: (testName: string, count: number) => string;
+export declare const keyToTestName: (key: string) => string;
+export declare const getSnapshotData: (snapshotPath: string, update: Config.SnapshotUpdateState) => {
+    data: SnapshotData;
+    dirty: boolean;
+};
+export declare const serialize: (data: string) => string;
+export declare const unescape: (data: string) => string;
+export declare const escapeBacktickString: (str: string) => string;
+export declare const ensureDirectoryExists: (filePath: string) => void;
+export declare const saveSnapshotFile: (snapshotData: {
+    [key: string]: string;
+}, snapshotPath: string) => void;
+export declare const deepMerge: (target: any, source: any) => any;
+//# sourceMappingURL=utils.d.ts.map

node_modules/jest-snapshot/build/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,OAAO,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAGnC,OAAO,EAAC,YAAY,EAAC,MAAM,SAAS,CAAC;AAErC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,eAAO,MAAM,mBAAmB,0BAA0B,CAAC;AAC3D,eAAO,MAAM,wBAAwB,QAIpC,CAAC;AAwDF,eAAO,MAAM,aAAa,6CACF,CAAC;AAEzB,eAAO,MAAM,aAAa,yBAMzB,CAAC;AAEF,eAAO,MAAM,eAAe;;;CAgC3B,CAAC;AAOF,eAAO,MAAM,SAAS,0BASnB,CAAC;AAGJ,eAAO,MAAM,QAAQ,0BAAyD,CAAC;AAE/E,eAAO,MAAM,oBAAoB,yBACC,CAAC;AAKnC,eAAO,MAAM,qBAAqB,4BAIjC,CAAC;AAIF,eAAO,MAAM,gBAAgB;;gCAoB5B,CAAC;AAEF,eAAO,MAAM,SAAS,mCAarB,CAAC"}

node_modules/jest-snapshot/build/utils.js

@@ -0,0 +1,278 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.deepMerge = exports.saveSnapshotFile = exports.ensureDirectoryExists = exports.escapeBacktickString = exports.unescape = exports.serialize = exports.getSnapshotData = exports.keyToTestName = exports.testNameToKey = exports.SNAPSHOT_VERSION_WARNING = exports.SNAPSHOT_GUIDE_LINK = exports.SNAPSHOT_VERSION = void 0;
+
+var _fs = _interopRequireDefault(require('fs'));
+
+var _path = _interopRequireDefault(require('path'));
+
+var _mkdirp = _interopRequireDefault(require('mkdirp'));
+
+var _naturalCompare = _interopRequireDefault(require('natural-compare'));
+
+var _chalk = _interopRequireDefault(require('chalk'));
+
+var _prettyFormat = _interopRequireDefault(require('pretty-format'));
+
+var _plugins = require('./plugins');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === 'function') {
+      ownKeys = ownKeys.concat(
+        Object.getOwnPropertySymbols(source).filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        })
+      );
+    }
+    ownKeys.forEach(function(key) {
+      _defineProperty(target, key, source[key]);
+    });
+  }
+  return target;
+}
+
+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;
+}
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+var jestWriteFile =
+  global[Symbol.for('jest-native-write-file')] || _fs.default.writeFileSync;
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+var jestReadFile =
+  global[Symbol.for('jest-native-read-file')] || _fs.default.readFileSync;
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+var jestExistsFile =
+  global[Symbol.for('jest-native-exists-file')] || _fs.default.existsSync;
+
+const SNAPSHOT_VERSION = '1';
+exports.SNAPSHOT_VERSION = SNAPSHOT_VERSION;
+const SNAPSHOT_VERSION_REGEXP = /^\/\/ Jest Snapshot v(.+),/;
+const SNAPSHOT_GUIDE_LINK = 'https://goo.gl/fbAQLP';
+exports.SNAPSHOT_GUIDE_LINK = SNAPSHOT_GUIDE_LINK;
+
+const SNAPSHOT_VERSION_WARNING = _chalk.default.yellow(
+  `${_chalk.default.bold('Warning')}: Before you upgrade snapshots, ` +
+    `we recommend that you revert any local changes to tests or other code, ` +
+    `to ensure that you do not store invalid state.`
+);
+
+exports.SNAPSHOT_VERSION_WARNING = SNAPSHOT_VERSION_WARNING;
+
+const writeSnapshotVersion = () =>
+  `// Jest Snapshot v${SNAPSHOT_VERSION}, ${SNAPSHOT_GUIDE_LINK}`;
+
+const validateSnapshotVersion = snapshotContents => {
+  const versionTest = SNAPSHOT_VERSION_REGEXP.exec(snapshotContents);
+  const version = versionTest && versionTest[1];
+
+  if (!version) {
+    return new Error(
+      _chalk.default.red(
+        `${_chalk.default.bold(
+          'Outdated snapshot'
+        )}: No snapshot header found. ` +
+          `Jest 19 introduced versioned snapshots to ensure all developers ` +
+          `on a project are using the same version of Jest. ` +
+          `Please update all snapshots during this upgrade of Jest.\n\n`
+      ) + SNAPSHOT_VERSION_WARNING
+    );
+  }
+
+  if (version < SNAPSHOT_VERSION) {
+    return new Error(
+      _chalk.default.red(
+        `${_chalk.default.red.bold(
+          'Outdated snapshot'
+        )}: The version of the snapshot ` +
+          `file associated with this test is outdated. The snapshot file ` +
+          `version ensures that all developers on a project are using ` +
+          `the same version of Jest. ` +
+          `Please update all snapshots during this upgrade of Jest.\n\n`
+      ) +
+        `Expected: v${SNAPSHOT_VERSION}\n` +
+        `Received: v${version}\n\n` +
+        SNAPSHOT_VERSION_WARNING
+    );
+  }
+
+  if (version > SNAPSHOT_VERSION) {
+    return new Error(
+      _chalk.default.red(
+        `${_chalk.default.red.bold(
+          'Outdated Jest version'
+        )}: The version of this ` +
+          `snapshot file indicates that this project is meant to be used ` +
+          `with a newer version of Jest. The snapshot file version ensures ` +
+          `that all developers on a project are using the same version of ` +
+          `Jest. Please update your version of Jest and re-run the tests.\n\n`
+      ) +
+        `Expected: v${SNAPSHOT_VERSION}\n` +
+        `Received: v${version}`
+    );
+  }
+
+  return null;
+};
+
+function isObject(item) {
+  return item && typeof item === 'object' && !Array.isArray(item);
+}
+
+const testNameToKey = (testName, count) => testName + ' ' + count;
+
+exports.testNameToKey = testNameToKey;
+
+const keyToTestName = key => {
+  if (!/ \d+$/.test(key)) {
+    throw new Error('Snapshot keys must end with a number.');
+  }
+
+  return key.replace(/ \d+$/, '');
+};
+
+exports.keyToTestName = keyToTestName;
+
+const getSnapshotData = (snapshotPath, update) => {
+  const data = Object.create(null);
+  let snapshotContents = '';
+  let dirty = false;
+
+  if (jestExistsFile(snapshotPath)) {
+    try {
+      snapshotContents = jestReadFile(snapshotPath, 'utf8'); // eslint-disable-next-line no-new-func
+
+      const populate = new Function('exports', snapshotContents);
+      populate(data);
+    } catch (e) {}
+  }
+
+  const validationResult = validateSnapshotVersion(snapshotContents);
+  const isInvalid = snapshotContents && validationResult;
+
+  if (update === 'none' && isInvalid) {
+    throw validationResult;
+  }
+
+  if ((update === 'all' || update === 'new') && isInvalid) {
+    dirty = true;
+  }
+
+  return {
+    data,
+    dirty
+  };
+}; // Extra line breaks at the beginning and at the end of the snapshot are useful
+// to make the content of the snapshot easier to read
+
+exports.getSnapshotData = getSnapshotData;
+
+const addExtraLineBreaks = string =>
+  string.includes('\n') ? `\n${string}\n` : string;
+
+const serialize = data =>
+  addExtraLineBreaks(
+    normalizeNewlines(
+      (0, _prettyFormat.default)(data, {
+        escapeRegex: true,
+        plugins: (0, _plugins.getSerializers)(),
+        printFunctionName: false
+      })
+    )
+  ); // unescape double quotes
+
+exports.serialize = serialize;
+
+const unescape = data => data.replace(/\\(")/g, '$1');
+
+exports.unescape = unescape;
+
+const escapeBacktickString = str => str.replace(/`|\\|\${/g, '\\$&');
+
+exports.escapeBacktickString = escapeBacktickString;
+
+const printBacktickString = str => '`' + escapeBacktickString(str) + '`';
+
+const ensureDirectoryExists = filePath => {
+  try {
+    _mkdirp.default.sync(
+      _path.default.join(_path.default.dirname(filePath)),
+      '777'
+    );
+  } catch (e) {}
+};
+
+exports.ensureDirectoryExists = ensureDirectoryExists;
+
+const normalizeNewlines = string => string.replace(/\r\n|\r/g, '\n');
+
+const saveSnapshotFile = (snapshotData, snapshotPath) => {
+  const snapshots = Object.keys(snapshotData)
+    .sort(_naturalCompare.default)
+    .map(
+      key =>
+        'exports[' +
+        printBacktickString(key) +
+        '] = ' +
+        printBacktickString(normalizeNewlines(snapshotData[key])) +
+        ';'
+    );
+  ensureDirectoryExists(snapshotPath);
+  jestWriteFile(
+    snapshotPath,
+    writeSnapshotVersion() + '\n\n' + snapshots.join('\n\n') + '\n'
+  );
+};
+
+exports.saveSnapshotFile = saveSnapshotFile;
+
+const deepMerge = (target, source) => {
+  const mergedOutput = _objectSpread({}, target);
+
+  if (isObject(target) && isObject(source)) {
+    Object.keys(source).forEach(key => {
+      if (isObject(source[key]) && !source[key].$$typeof) {
+        if (!(key in target))
+          Object.assign(mergedOutput, {
+            [key]: source[key]
+          });
+        else mergedOutput[key] = deepMerge(target[key], source[key]);
+      } else {
+        Object.assign(mergedOutput, {
+          [key]: source[key]
+        });
+      }
+    });
+  }
+
+  return mergedOutput;
+};
+
+exports.deepMerge = deepMerge;

node_modules/jest-snapshot/node_modules/.bin/semver

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../semver/bin/semver" "$@"
+  ret=$?
+else 
+  node  "$basedir/../semver/bin/semver" "$@"
+  ret=$?
+fi
+exit $ret

node_modules/jest-snapshot/node_modules/.bin/semver.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\semver\bin\semver" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\semver\bin\semver" %*
+)

node_modules/jest-snapshot/node_modules/semver/CHANGELOG.md

@@ -0,0 +1,39 @@
+# changes log
+
+## 5.7
+
+* Add `minVersion` method
+
+## 5.6
+
+* Move boolean `loose` param to an options object, with
+  backwards-compatibility protection.
+* Add ability to opt out of special prerelease version handling with
+  the `includePrerelease` option flag.
+
+## 5.5
+
+* Add version coercion capabilities
+
+## 5.4
+
+* Add intersection checking
+
+## 5.3
+
+* Add `minSatisfying` method
+
+## 5.2
+
+* Add `prerelease(v)` that returns prerelease components
+
+## 5.1
+
+* Add Backus-Naur for ranges
+* Remove excessively cute inspection methods
+
+## 5.0
+
+* Remove AMD/Browserified build artifacts
+* Fix ltr and gtr when using the `*` range
+* Fix for range `*` with a prerelease identifier

node_modules/jest-snapshot/node_modules/semver/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

node_modules/jest-snapshot/node_modules/semver/README.md

@@ -0,0 +1,411 @@
+semver(1) -- The semantic versioner for npm
+===========================================
+
+## Install
+
+```bash
+npm install --save semver
+````
+
+## Usage
+
+As a node module:
+
+```js
+const semver = require('semver')
+
+semver.valid('1.2.3') // '1.2.3'
+semver.valid('a.b.c') // null
+semver.clean('  =v1.2.3   ') // '1.2.3'
+semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true
+semver.gt('1.2.3', '9.8.7') // false
+semver.lt('1.2.3', '9.8.7') // true
+semver.minVersion('>=1.0.0') // '1.0.0'
+semver.valid(semver.coerce('v2')) // '2.0.0'
+semver.valid(semver.coerce('42.6.7.9.3-alpha')) // '42.6.7'
+```
+
+As a command-line utility:
+
+```
+$ semver -h
+
+A JavaScript implementation of the https://semver.org/ specification
+Copyright Isaac Z. Schlueter
+
+Usage: semver [options] <version> [<version> [...]]
+Prints valid versions sorted by SemVer precedence
+
+Options:
+-r --range <range>
+        Print versions that match the specified range.
+
+-i --increment [<level>]
+        Increment a version by the specified level.  Level can
+        be one of: major, minor, patch, premajor, preminor,
+        prepatch, or prerelease.  Default level is 'patch'.
+        Only one version may be specified.
+
+--preid <identifier>
+        Identifier to be used to prefix premajor, preminor,
+        prepatch or prerelease version increments.
+
+-l --loose
+        Interpret versions and ranges loosely
+
+-p --include-prerelease
+        Always include prerelease versions in range matching
+
+-c --coerce
+        Coerce a string into SemVer if possible
+        (does not imply --loose)
+
+Program exits successfully if any valid version satisfies
+all supplied ranges, and prints all satisfying versions.
+
+If no satisfying versions are found, then exits failure.
+
+Versions are printed in ascending order, so supplying
+multiple versions to the utility will just sort them.
+```
+
+## Versions
+
+A "version" is described by the `v2.0.0` specification found at
+<https://semver.org/>.
+
+A leading `"="` or `"v"` character is stripped off and ignored.
+
+## Ranges
+
+A `version range` is a set of `comparators` which specify versions
+that satisfy the range.
+
+A `comparator` is composed of an `operator` and a `version`.  The set
+of primitive `operators` is:
+
+* `<` Less than
+* `<=` Less than or equal to
+* `>` Greater than
+* `>=` Greater than or equal to
+* `=` Equal.  If no operator is specified, then equality is assumed,
+  so this operator is optional, but MAY be included.
+
+For example, the comparator `>=1.2.7` would match the versions
+`1.2.7`, `1.2.8`, `2.5.3`, and `1.3.9`, but not the versions `1.2.6`
+or `1.1.0`.
+
+Comparators can be joined by whitespace to form a `comparator set`,
+which is satisfied by the **intersection** of all of the comparators
+it includes.
+
+A range is composed of one or more comparator sets, joined by `||`.  A
+version matches a range if and only if every comparator in at least
+one of the `||`-separated comparator sets is satisfied by the version.
+
+For example, the range `>=1.2.7 <1.3.0` would match the versions
+`1.2.7`, `1.2.8`, and `1.2.99`, but not the versions `1.2.6`, `1.3.0`,
+or `1.1.0`.
+
+The range `1.2.7 || >=1.2.9 <2.0.0` would match the versions `1.2.7`,
+`1.2.9`, and `1.4.6`, but not the versions `1.2.8` or `2.0.0`.
+
+### Prerelease Tags
+
+If a version has a prerelease tag (for example, `1.2.3-alpha.3`) then
+it will only be allowed to satisfy comparator sets if at least one
+comparator with the same `[major, minor, patch]` tuple also has a
+prerelease tag.
+
+For example, the range `>1.2.3-alpha.3` would be allowed to match the
+version `1.2.3-alpha.7`, but it would *not* be satisfied by
+`3.4.5-alpha.9`, even though `3.4.5-alpha.9` is technically "greater
+than" `1.2.3-alpha.3` according to the SemVer sort rules.  The version
+range only accepts prerelease tags on the `1.2.3` version.  The
+version `3.4.5` *would* satisfy the range, because it does not have a
+prerelease flag, and `3.4.5` is greater than `1.2.3-alpha.7`.
+
+The purpose for this behavior is twofold.  First, prerelease versions
+frequently are updated very quickly, and contain many breaking changes
+that are (by the author's design) not yet fit for public consumption.
+Therefore, by default, they are excluded from range matching
+semantics.
+
+Second, a user who has opted into using a prerelease version has
+clearly indicated the intent to use *that specific* set of
+alpha/beta/rc versions.  By including a prerelease tag in the range,
+the user is indicating that they are aware of the risk.  However, it
+is still not appropriate to assume that they have opted into taking a
+similar risk on the *next* set of prerelease versions.
+
+Note that this behavior can be suppressed (treating all prerelease
+versions as if they were normal versions, for the purpose of range
+matching) by setting the `includePrerelease` flag on the options
+object to any
+[functions](https://github.com/npm/node-semver#functions) that do
+range matching.
+
+#### Prerelease Identifiers
+
+The method `.inc` takes an additional `identifier` string argument that
+will append the value of the string as a prerelease identifier:
+
+```javascript
+semver.inc('1.2.3', 'prerelease', 'beta')
+// '1.2.4-beta.0'
+```
+
+command-line example:
+
+```bash
+$ semver 1.2.3 -i prerelease --preid beta
+1.2.4-beta.0
+```
+
+Which then can be used to increment further:
+
+```bash
+$ semver 1.2.4-beta.0 -i prerelease
+1.2.4-beta.1
+```
+
+### Advanced Range Syntax
+
+Advanced range syntax desugars to primitive comparators in
+deterministic ways.
+
+Advanced ranges may be combined in the same way as primitive
+comparators using white space or `||`.
+
+#### Hyphen Ranges `X.Y.Z - A.B.C`
+
+Specifies an inclusive set.
+
+* `1.2.3 - 2.3.4` := `>=1.2.3 <=2.3.4`
+
+If a partial version is provided as the first version in the inclusive
+range, then the missing pieces are replaced with zeroes.
+
+* `1.2 - 2.3.4` := `>=1.2.0 <=2.3.4`
+
+If a partial version is provided as the second version in the
+inclusive range, then all versions that start with the supplied parts
+of the tuple are accepted, but nothing that would be greater than the
+provided tuple parts.
+
+* `1.2.3 - 2.3` := `>=1.2.3 <2.4.0`
+* `1.2.3 - 2` := `>=1.2.3 <3.0.0`
+
+#### X-Ranges `1.2.x` `1.X` `1.2.*` `*`
+
+Any of `X`, `x`, or `*` may be used to "stand in" for one of the
+numeric values in the `[major, minor, patch]` tuple.
+
+* `*` := `>=0.0.0` (Any version satisfies)
+* `1.x` := `>=1.0.0 <2.0.0` (Matching major version)
+* `1.2.x` := `>=1.2.0 <1.3.0` (Matching major and minor versions)
+
+A partial version range is treated as an X-Range, so the special
+character is in fact optional.
+
+* `""` (empty string) := `*` := `>=0.0.0`
+* `1` := `1.x.x` := `>=1.0.0 <2.0.0`
+* `1.2` := `1.2.x` := `>=1.2.0 <1.3.0`
+
+#### Tilde Ranges `~1.2.3` `~1.2` `~1`
+
+Allows patch-level changes if a minor version is specified on the
+comparator.  Allows minor-level changes if not.
+
+* `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0`
+* `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0` (Same as `1.2.x`)
+* `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0` (Same as `1.x`)
+* `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0`
+* `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0` (Same as `0.2.x`)
+* `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0` (Same as `0.x`)
+* `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0` Note that prereleases in
+  the `1.2.3` version will be allowed, if they are greater than or
+  equal to `beta.2`.  So, `1.2.3-beta.4` would be allowed, but
+  `1.2.4-beta.2` would not, because it is a prerelease of a
+  different `[major, minor, patch]` tuple.
+
+#### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4`
+
+Allows changes that do not modify the left-most non-zero digit in the
+`[major, minor, patch]` tuple.  In other words, this allows patch and
+minor updates for versions `1.0.0` and above, patch updates for
+versions `0.X >=0.1.0`, and *no* updates for versions `0.0.X`.
+
+Many authors treat a `0.x` version as if the `x` were the major
+"breaking-change" indicator.
+
+Caret ranges are ideal when an author may make breaking changes
+between `0.2.4` and `0.3.0` releases, which is a common practice.
+However, it presumes that there will *not* be breaking changes between
+`0.2.4` and `0.2.5`.  It allows for changes that are presumed to be
+additive (but non-breaking), according to commonly observed practices.
+
+* `^1.2.3` := `>=1.2.3 <2.0.0`
+* `^0.2.3` := `>=0.2.3 <0.3.0`
+* `^0.0.3` := `>=0.0.3 <0.0.4`
+* `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0` Note that prereleases in
+  the `1.2.3` version will be allowed, if they are greater than or
+  equal to `beta.2`.  So, `1.2.3-beta.4` would be allowed, but
+  `1.2.4-beta.2` would not, because it is a prerelease of a
+  different `[major, minor, patch]` tuple.
+* `^0.0.3-beta` := `>=0.0.3-beta <0.0.4`  Note that prereleases in the
+  `0.0.3` version *only* will be allowed, if they are greater than or
+  equal to `beta`.  So, `0.0.3-pr.2` would be allowed.
+
+When parsing caret ranges, a missing `patch` value desugars to the
+number `0`, but will allow flexibility within that value, even if the
+major and minor versions are both `0`.
+
+* `^1.2.x` := `>=1.2.0 <2.0.0`
+* `^0.0.x` := `>=0.0.0 <0.1.0`
+* `^0.0` := `>=0.0.0 <0.1.0`
+
+A missing `minor` and `patch` values will desugar to zero, but also
+allow flexibility within those values, even if the major version is
+zero.
+
+* `^1.x` := `>=1.0.0 <2.0.0`
+* `^0.x` := `>=0.0.0 <1.0.0`
+
+### Range Grammar
+
+Putting all this together, here is a Backus-Naur grammar for ranges,
+for the benefit of parser authors:
+
+```bnf
+range-set  ::= range ( logical-or range ) *
+logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+range      ::= hyphen | simple ( ' ' simple ) * | ''
+hyphen     ::= partial ' - ' partial
+simple     ::= primitive | partial | tilde | caret
+primitive  ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
+partial    ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
+xr         ::= 'x' | 'X' | '*' | nr
+nr         ::= '0' | ['1'-'9'] ( ['0'-'9'] ) *
+tilde      ::= '~' partial
+caret      ::= '^' partial
+qualifier  ::= ( '-' pre )? ( '+' build )?
+pre        ::= parts
+build      ::= parts
+parts      ::= part ( '.' part ) *
+part       ::= nr | [-0-9A-Za-z]+
+```
+
+## Functions
+
+All methods and classes take a final `options` object argument.  All
+options in this object are `false` by default.  The options supported
+are:
+
+- `loose`  Be more forgiving about not-quite-valid semver strings.
+  (Any resulting output will always be 100% strict compliant, of
+  course.)  For backwards compatibility reasons, if the `options`
+  argument is a boolean value instead of an object, it is interpreted
+  to be the `loose` param.
+- `includePrerelease`  Set to suppress the [default
+  behavior](https://github.com/npm/node-semver#prerelease-tags) of
+  excluding prerelease tagged versions from ranges unless they are
+  explicitly opted into.
+
+Strict-mode Comparators and Ranges will be strict about the SemVer
+strings that they parse.
+
+* `valid(v)`: Return the parsed version, or null if it's not valid.
+* `inc(v, release)`: Return the version incremented by the release
+  type (`major`,   `premajor`, `minor`, `preminor`, `patch`,
+  `prepatch`, or `prerelease`), or null if it's not valid
+  * `premajor` in one call will bump the version up to the next major
+    version and down to a prerelease of that major version.
+    `preminor`, and `prepatch` work the same way.
+  * If called from a non-prerelease version, the `prerelease` will work the
+    same as `prepatch`. It increments the patch version, then makes a
+    prerelease. If the input version is already a prerelease it simply
+    increments it.
+* `prerelease(v)`: Returns an array of prerelease components, or null
+  if none exist. Example: `prerelease('1.2.3-alpha.1') -> ['alpha', 1]`
+* `major(v)`: Return the major version number.
+* `minor(v)`: Return the minor version number.
+* `patch(v)`: Return the patch version number.
+* `intersects(r1, r2, loose)`: Return true if the two supplied ranges
+  or comparators intersect.
+* `parse(v)`: Attempt to parse a string as a semantic version, returning either
+  a `SemVer` object or `null`.
+
+### Comparison
+
+* `gt(v1, v2)`: `v1 > v2`
+* `gte(v1, v2)`: `v1 >= v2`
+* `lt(v1, v2)`: `v1 < v2`
+* `lte(v1, v2)`: `v1 <= v2`
+* `eq(v1, v2)`: `v1 == v2` This is true if they're logically equivalent,
+  even if they're not the exact same string.  You already know how to
+  compare strings.
+* `neq(v1, v2)`: `v1 != v2` The opposite of `eq`.
+* `cmp(v1, comparator, v2)`: Pass in a comparison string, and it'll call
+  the corresponding function above.  `"==="` and `"!=="` do simple
+  string comparison, but are included for completeness.  Throws if an
+  invalid comparison string is provided.
+* `compare(v1, v2)`: Return `0` if `v1 == v2`, or `1` if `v1` is greater, or `-1` if
+  `v2` is greater.  Sorts in ascending order if passed to `Array.sort()`.
+* `rcompare(v1, v2)`: The reverse of compare.  Sorts an array of versions
+  in descending order when passed to `Array.sort()`.
+* `diff(v1, v2)`: Returns difference between two versions by the release type
+  (`major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, or `prerelease`),
+  or null if the versions are the same.
+
+### Comparators
+
+* `intersects(comparator)`: Return true if the comparators intersect
+
+### Ranges
+
+* `validRange(range)`: Return the valid range or null if it's not valid
+* `satisfies(version, range)`: Return true if the version satisfies the
+  range.
+* `maxSatisfying(versions, range)`: Return the highest version in the list
+  that satisfies the range, or `null` if none of them do.
+* `minSatisfying(versions, range)`: Return the lowest version in the list
+  that satisfies the range, or `null` if none of them do.
+* `minVersion(range)`: Return the lowest version that can possibly match
+  the given range.
+* `gtr(version, range)`: Return `true` if version is greater than all the
+  versions possible in the range.
+* `ltr(version, range)`: Return `true` if version is less than all the
+  versions possible in the range.
+* `outside(version, range, hilo)`: Return true if the version is outside
+  the bounds of the range in either the high or low direction.  The
+  `hilo` argument must be either the string `'>'` or `'<'`.  (This is
+  the function called by `gtr` and `ltr`.)
+* `intersects(range)`: Return true if any of the ranges comparators intersect
+
+Note that, since ranges may be non-contiguous, a version might not be
+greater than a range, less than a range, *or* satisfy a range!  For
+example, the range `1.2 <1.2.9 || >2.0.0` would have a hole from `1.2.9`
+until `2.0.0`, so the version `1.2.10` would not be greater than the
+range (because `2.0.1` satisfies, which is higher), nor less than the
+range (since `1.2.8` satisfies, which is lower), and it also does not
+satisfy the range.
+
+If you want to know if a version satisfies or does not satisfy a
+range, use the `satisfies(version, range)` function.
+
+### Coercion
+
+* `coerce(version)`: Coerces a string to semver if possible
+
+This aims to provide a very forgiving translation of a non-semver
+string to semver. It looks for the first digit in a string, and
+consumes all remaining characters which satisfy at least a partial semver
+(e.g., `1`, `1.2`, `1.2.3`) up to the max permitted length (256 characters).
+Longer versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`).
+All surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes `3.4.0`).
+Only text which lacks digits will fail coercion (`version one` is not valid).
+The maximum  length for any semver component considered for coercion is 16 characters;
+longer components will be ignored (`10000000000000000.4.7.4` becomes `4.7.4`).
+The maximum value for any semver component is `Integer.MAX_SAFE_INTEGER || (2**53 - 1)`;
+higher value components are invalid (`9999999999999999.4.7.4` is likely invalid).

node_modules/jest-snapshot/node_modules/semver/bin/semver

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+// Standalone semver comparison program.
+// Exits successfully and prints matching version(s) if
+// any supplied version is valid and passes all tests.
+
+var argv = process.argv.slice(2)
+
+var versions = []
+
+var range = []
+
+var inc = null
+
+var version = require('../package.json').version
+
+var loose = false
+
+var includePrerelease = false
+
+var coerce = false
+
+var identifier
+
+var semver = require('../semver')
+
+var reverse = false
+
+var options = {}
+
+main()
+
+function main () {
+  if (!argv.length) return help()
+  while (argv.length) {
+    var a = argv.shift()
+    var indexOfEqualSign = a.indexOf('=')
+    if (indexOfEqualSign !== -1) {
+      a = a.slice(0, indexOfEqualSign)
+      argv.unshift(a.slice(indexOfEqualSign + 1))
+    }
+    switch (a) {
+      case '-rv': case '-rev': case '--rev': case '--reverse':
+        reverse = true
+        break
+      case '-l': case '--loose':
+        loose = true
+        break
+      case '-p': case '--include-prerelease':
+        includePrerelease = true
+        break
+      case '-v': case '--version':
+        versions.push(argv.shift())
+        break
+      case '-i': case '--inc': case '--increment':
+        switch (argv[0]) {
+          case 'major': case 'minor': case 'patch': case 'prerelease':
+          case 'premajor': case 'preminor': case 'prepatch':
+            inc = argv.shift()
+            break
+          default:
+            inc = 'patch'
+            break
+        }
+        break
+      case '--preid':
+        identifier = argv.shift()
+        break
+      case '-r': case '--range':
+        range.push(argv.shift())
+        break
+      case '-c': case '--coerce':
+        coerce = true
+        break
+      case '-h': case '--help': case '-?':
+        return help()
+      default:
+        versions.push(a)
+        break
+    }
+  }
+
+  var options = { loose: loose, includePrerelease: includePrerelease }
+
+  versions = versions.map(function (v) {
+    return coerce ? (semver.coerce(v) || { version: v }).version : v
+  }).filter(function (v) {
+    return semver.valid(v)
+  })
+  if (!versions.length) return fail()
+  if (inc && (versions.length !== 1 || range.length)) { return failInc() }
+
+  for (var i = 0, l = range.length; i < l; i++) {
+    versions = versions.filter(function (v) {
+      return semver.satisfies(v, range[i], options)
+    })
+    if (!versions.length) return fail()
+  }
+  return success(versions)
+}
+
+function failInc () {
+  console.error('--inc can only be used on a single version with no range')
+  fail()
+}
+
+function fail () { process.exit(1) }
+
+function success () {
+  var compare = reverse ? 'rcompare' : 'compare'
+  versions.sort(function (a, b) {
+    return semver[compare](a, b, options)
+  }).map(function (v) {
+    return semver.clean(v, options)
+  }).map(function (v) {
+    return inc ? semver.inc(v, inc, options, identifier) : v
+  }).forEach(function (v, i, _) { console.log(v) })
+}
+
+function help () {
+  console.log(['SemVer ' + version,
+    '',
+    'A JavaScript implementation of the https://semver.org/ specification',
+    'Copyright Isaac Z. Schlueter',
+    '',
+    'Usage: semver [options] <version> [<version> [...]]',
+    'Prints valid versions sorted by SemVer precedence',
+    '',
+    'Options:',
+    '-r --range <range>',
+    '        Print versions that match the specified range.',
+    '',
+    '-i --increment [<level>]',
+    '        Increment a version by the specified level.  Level can',
+    '        be one of: major, minor, patch, premajor, preminor,',
+    "        prepatch, or prerelease.  Default level is 'patch'.",
+    '        Only one version may be specified.',
+    '',
+    '--preid <identifier>',
+    '        Identifier to be used to prefix premajor, preminor,',
+    '        prepatch or prerelease version increments.',
+    '',
+    '-l --loose',
+    '        Interpret versions and ranges loosely',
+    '',
+    '-p --include-prerelease',
+    '        Always include prerelease versions in range matching',
+    '',
+    '-c --coerce',
+    '        Coerce a string into SemVer if possible',
+    '        (does not imply --loose)',
+    '',
+    'Program exits successfully if any valid version satisfies',
+    'all supplied ranges, and prints all satisfying versions.',
+    '',
+    'If no satisfying versions are found, then exits failure.',
+    '',
+    'Versions are printed in ascending order, so supplying',
+    'multiple versions to the utility will just sort them.'
+  ].join('\n'))
+}

node_modules/jest-snapshot/node_modules/semver/package.json

@@ -0,0 +1,60 @@
+{
+  "_from": "semver@^5.5.0",
+  "_id": "semver@5.7.0",
+  "_inBundle": false,
+  "_integrity": "sha512-Ya52jSX2u7QKghxeoFGpLwCtGlt7j0oY9DYb5apt9nPlJ42ID+ulTXESnt/qAQcoSERyZ5sl3LDIOw0nAn/5DA==",
+  "_location": "/jest-snapshot/semver",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "semver@^5.5.0",
+    "name": "semver",
+    "escapedName": "semver",
+    "rawSpec": "^5.5.0",
+    "saveSpec": null,
+    "fetchSpec": "^5.5.0"
+  },
+  "_requiredBy": [
+    "/jest-snapshot"
+  ],
+  "_resolved": "https://registry.npmjs.org/semver/-/semver-5.7.0.tgz",
+  "_shasum": "790a7cf6fea5459bac96110b29b60412dc8ff96b",
+  "_spec": "semver@^5.5.0",
+  "_where": "E:\\github\\setup-java\\node_modules\\jest-snapshot",
+  "bin": {
+    "semver": "./bin/semver"
+  },
+  "bugs": {
+    "url": "https://github.com/npm/node-semver/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "The semantic version parser used by npm.",
+  "devDependencies": {
+    "tap": "^13.0.0-rc.18"
+  },
+  "files": [
+    "bin",
+    "range.bnf",
+    "semver.js"
+  ],
+  "homepage": "https://github.com/npm/node-semver#readme",
+  "license": "ISC",
+  "main": "semver.js",
+  "name": "semver",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/node-semver.git"
+  },
+  "scripts": {
+    "postpublish": "git push origin --all; git push origin --tags",
+    "postversion": "npm publish",
+    "preversion": "npm test",
+    "test": "tap"
+  },
+  "tap": {
+    "check-coverage": true
+  },
+  "version": "5.7.0"
+}

node_modules/jest-snapshot/node_modules/semver/range.bnf

@@ -0,0 +1,16 @@
+range-set  ::= range ( logical-or range ) *
+logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+range      ::= hyphen | simple ( ' ' simple ) * | ''
+hyphen     ::= partial ' - ' partial
+simple     ::= primitive | partial | tilde | caret
+primitive  ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
+partial    ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
+xr         ::= 'x' | 'X' | '*' | nr
+nr         ::= '0' | [1-9] ( [0-9] ) *
+tilde      ::= '~' partial
+caret      ::= '^' partial
+qualifier  ::= ( '-' pre )? ( '+' build )?
+pre        ::= parts
+build      ::= parts
+parts      ::= part ( '.' part ) *
+part       ::= nr | [-0-9A-Za-z]+

node_modules/jest-snapshot/package.json

@@ -0,0 +1,75 @@
+{
+  "_from": "jest-snapshot@^24.8.0",
+  "_id": "jest-snapshot@24.8.0",
+  "_inBundle": false,
+  "_integrity": "sha512-5ehtWoc8oU9/cAPe6fez6QofVJLBKyqkY2+TlKTOf0VllBB/mqUNdARdcjlZrs9F1Cv+/HKoCS/BknT0+tmfPg==",
+  "_location": "/jest-snapshot",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "jest-snapshot@^24.8.0",
+    "name": "jest-snapshot",
+    "escapedName": "jest-snapshot",
+    "rawSpec": "^24.8.0",
+    "saveSpec": null,
+    "fetchSpec": "^24.8.0"
+  },
+  "_requiredBy": [
+    "/@jest/core",
+    "/jest-circus",
+    "/jest-jasmine2",
+    "/jest-resolve-dependencies",
+    "/jest-runtime"
+  ],
+  "_resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-24.8.0.tgz",
+  "_shasum": "3bec6a59da2ff7bc7d097a853fb67f9d415cb7c6",
+  "_spec": "jest-snapshot@^24.8.0",
+  "_where": "E:\\github\\setup-java\\node_modules\\@jest\\core",
+  "bugs": {
+    "url": "https://github.com/facebook/jest/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "@babel/types": "^7.0.0",
+    "@jest/types": "^24.8.0",
+    "chalk": "^2.0.1",
+    "expect": "^24.8.0",
+    "jest-diff": "^24.8.0",
+    "jest-matcher-utils": "^24.8.0",
+    "jest-message-util": "^24.8.0",
+    "jest-resolve": "^24.8.0",
+    "mkdirp": "^0.5.1",
+    "natural-compare": "^1.4.0",
+    "pretty-format": "^24.8.0",
+    "semver": "^5.5.0"
+  },
+  "deprecated": false,
+  "devDependencies": {
+    "@babel/traverse": "^7.3.4",
+    "@types/mkdirp": "^0.5.2",
+    "@types/natural-compare": "^1.4.0",
+    "@types/prettier": "^1.16.1",
+    "@types/semver": "^5.5.0",
+    "jest-haste-map": "^24.8.0",
+    "prettier": "^1.13.4"
+  },
+  "engines": {
+    "node": ">= 6"
+  },
+  "gitHead": "845728f24b3ef41e450595c384e9b5c9fdf248a4",
+  "homepage": "https://github.com/facebook/jest#readme",
+  "license": "MIT",
+  "main": "build/index.js",
+  "name": "jest-snapshot",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/facebook/jest.git",
+    "directory": "packages/jest-snapshot"
+  },
+  "types": "build/index.d.ts",
+  "version": "24.8.0"
+}

node_modules/jest-snapshot/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "build"
+  },
+  "references": [
+    {"path": "../expect"},
+    {"path": "../jest-diff"},
+    {"path": "../jest-haste-map"},
+    {"path": "../jest-matcher-utils"},
+    {"path": "../jest-message-util"},
+    {"path": "../jest-resolve"},
+    {"path": "../jest-types"},
+    {"path": "../pretty-format"}
+  ]
+}