.

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;