Fixed #1 - Fixed the whatsnew-** script for loading release notes into builds

Added test to ensure that release notes are parsed properly Updated to latest dependencies to fix security vulnerability Updated GH Actions Workflow to run test before updating tag Updated README.md to reflect proper whatsnew documentation.
2020-01-30 11:14:51 -05:00
parent b6496ac4e3
commit bdde081050
2660 changed files with 251487 additions and 213182 deletions
--- a/node_modules/jest-snapshot/LICENSE
+++ b/node_modules/jest-snapshot/LICENSE
@@ -1,8 +1,6 @@
 MIT License

-For Jest software
-
-Copyright (c) 2014-present, Facebook, Inc.
+Copyright (c) Facebook, Inc. and its affiliates.

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/node_modules/jest-snapshot/build/State.d.ts
+++ b/node_modules/jest-snapshot/build/State.d.ts
@@ -24,6 +24,7 @@ export default class SnapshotState {
    private _index;
    private _updateSnapshot;
    private _snapshotData;
+    private _initialData;
    private _snapshotPath;
    private _inlineSnapshots;
    private _uncheckedKeys;
@@ -37,6 +38,7 @@ export default class SnapshotState {
    constructor(snapshotPath: Config.Path, options: SnapshotStateOptions);
    markSnapshotsAsCheckedForTest(testName: string): void;
    private _addSnapshot;
+    clear(): void;
    save(): {
        deleted: boolean;
        saved: boolean;
--- a/node_modules/jest-snapshot/build/State.d.ts.map
+++ b/node_modules/jest-snapshot/build/State.d.ts.map
@@ -1 +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"}
+{"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,YAAY,CAAe;IACnC,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;IAuBpE,6BAA6B,CAAC,QAAQ,EAAE,MAAM;IAQ9C,OAAO,CAAC,YAAY;IAwBpB,KAAK;IAWL,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"}
--- a/node_modules/jest-snapshot/build/State.js
+++ b/node_modules/jest-snapshot/build/State.js
@@ -50,6 +50,8 @@ class SnapshotState {

    _defineProperty(this, '_snapshotData', void 0);

+    _defineProperty(this, '_initialData', void 0);
+
    _defineProperty(this, '_snapshotPath', void 0);

    _defineProperty(this, '_inlineSnapshots', void 0);
@@ -79,6 +81,7 @@ class SnapshotState {
      data = _getSnapshotData.data,
      dirty = _getSnapshotData.dirty;

+    this._initialData = data;
    this._snapshotData = data;
    this._dirty = dirty;
    this._getBabelTraverse = options.getBabelTraverse;
@@ -126,6 +129,17 @@ class SnapshotState {
    }
  }

+  clear() {
+    this._snapshotData = this._initialData;
+    this._inlineSnapshots = [];
+    this._counters = new Map();
+    this._index = 0;
+    this.added = 0;
+    this.matched = 0;
+    this.unmatched = 0;
+    this.updated = 0;
+  }
+
  save() {
    const hasExternalSnapshots = Object.keys(this._snapshotData).length;
    const hasInlineSnapshots = this._inlineSnapshots.length;
--- a/node_modules/jest-snapshot/build/index.d.ts
+++ b/node_modules/jest-snapshot/build/index.d.ts
@@ -17,8 +17,9 @@ declare const JestSnapshot: {
    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) => {
+    cleanup: (hasteFS: import("jest-haste-map/build/HasteFS").default, update: Config.SnapshotUpdateState, snapshotResolver: JestSnapshotResolver, testPathIgnorePatterns?: string[] | undefined) => {
        filesRemoved: number;
+        filesRemovedList: string[];
    };
    getSerializers: () => import("pretty-format/build/types").Plugin[];
    isSnapshotPath: (path: string) => boolean;
--- a/node_modules/jest-snapshot/build/index.d.ts.map
+++ b/node_modules/jest-snapshot/build/index.d.ts.map
@@ -1 +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"}
+{"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;AAQpC,OAAO,EAGL,gBAAgB,IAAI,oBAAoB,EAEzC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,aAAa,MAAM,SAAS,CAAC;AAGpC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AAEjC,aAAK,OAAO,GAAG,YAAY,GAAG;IAC5B,aAAa,EAAE,aAAa,CAAC;CAC9B,CAAC;AAidF,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"}
--- a/node_modules/jest-snapshot/build/index.js
+++ b/node_modules/jest-snapshot/build/index.js
@@ -2,8 +2,6 @@

 var _fs = _interopRequireDefault(require('fs'));

-var _jestDiff = _interopRequireDefault(require('jest-diff'));
-
 var _jestMatcherUtils = require('jest-matcher-utils');

 var _snapshot_resolver = require('./snapshot_resolver');
@@ -12,6 +10,8 @@ var _State = _interopRequireDefault(require('./State'));

 var _plugins = require('./plugins');

+var _print = require('./print');
+
 var utils = _interopRequireWildcard(require('./utils'));

 function _interopRequireWildcard(obj) {
@@ -54,7 +54,8 @@ 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 HINT_ARG = 'hint';
+const HINT_COLOR = _jestMatcherUtils.BOLD_WEIGHT;
 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,
@@ -121,22 +122,35 @@ function stripAddedIndentation(inlineSnapshot) {
 const fileExists = (filePath, hasteFS) =>
  hasteFS.exists(filePath) || jestExistsFile(filePath);

-const cleanup = (hasteFS, update, snapshotResolver) => {
+const cleanup = (hasteFS, update, snapshotResolver, testPathIgnorePatterns) => {
  const pattern = '\\.' + _snapshot_resolver.EXTENSION + '$';
  const files = hasteFS.matchFiles(pattern);
-  const filesRemoved = files.reduce((acc, snapshotFile) => {
-    if (!fileExists(snapshotResolver.resolveTestPath(snapshotFile), hasteFS)) {
+  let testIgnorePatternsRegex = null;
+
+  if (testPathIgnorePatterns && testPathIgnorePatterns.length > 0) {
+    testIgnorePatternsRegex = new RegExp(testPathIgnorePatterns.join('|'));
+  }
+
+  const list = files.filter(snapshotFile => {
+    const testPath = snapshotResolver.resolveTestPath(snapshotFile); // ignore snapshots of ignored tests
+
+    if (testIgnorePatternsRegex && testIgnorePatternsRegex.test(testPath)) {
+      return false;
+    }
+
+    if (!fileExists(testPath, hasteFS)) {
      if (update === 'all') {
        _fs.default.unlinkSync(snapshotFile);
      }

-      return acc + 1;
+      return true;
    }

-    return acc;
-  }, 0);
+    return false;
+  });
  return {
-    filesRemoved
+    filesRemoved: list.length,
+    filesRemovedList: list
  };
 };

@@ -168,6 +182,14 @@ const toMatchSnapshot = function toMatchSnapshot(
    secondArgument
  };

+  if (expectedArgument === HINT_ARG) {
+    options.expectedColor = HINT_COLOR;
+  }
+
+  if (secondArgument === HINT_ARG) {
+    options.secondArgumentColor = HINT_COLOR;
+  }
+
  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")'
@@ -347,19 +369,20 @@ const _toMatchSnapshot = ({
      `${actual}`;
  } else {
    expected = (expected || '').trim();
-    actual = (actual || '').trim();
-    const diffMessage = (0, _jestDiff.default)(expected, actual, {
-      aAnnotation: 'Snapshot',
-      bAnnotation: 'Received',
-      expand: snapshotState.expand
-    });
+    actual = (actual || '').trim(); // Assign to local variable because of declaration let expected:
+    // TypeScript thinks it could change before report function is called.
+
+    const printed = (0, _print.printDiffOrStringified)(
+      expected,
+      actual,
+      received,
+      'Snapshot',
+      'Received',
+      snapshotState.expand
+    );

    report = () =>
-      `Snapshot name: ${printName(currentTestName, hint, count)}\n\n` +
-      (diffMessage ||
-        (0, _jestMatcherUtils.EXPECTED_COLOR)('- ' + (expected || '')) +
-          '\n' +
-          (0, _jestMatcherUtils.RECEIVED_COLOR)('+ ' + actual));
+      `Snapshot name: ${printName(currentTestName, hint, count)}\n\n` + printed;
  } // 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
@@ -391,6 +414,7 @@ const toThrowErrorMatchingSnapshot = function toThrowErrorMatchingSnapshot(
  const expectedArgument =
    typeof hint === 'string' && hint.length !== 0 ? HINT_ARG : '';
  const options = {
+    expectedColor: HINT_COLOR,
    isNot: this.isNot,
    promise: this.promise,
    secondArgument: ''
--- a/node_modules/jest-snapshot/build/inline_snapshots.js
+++ b/node_modules/jest-snapshot/build/inline_snapshots.js
@@ -154,7 +154,15 @@ const groupSnapshotsByFrame = groupSnapshotsBy(({frame: {line, column}}) =>
 const groupSnapshotsByFile = groupSnapshotsBy(({frame: {file}}) => file);

 const indent = (snapshot, numIndents, indentation) => {
-  const lines = snapshot.split('\n');
+  const lines = snapshot.split('\n'); // Prevent re-identation of inline snapshots.
+
+  if (
+    lines.length >= 2 &&
+    lines[1].startsWith(indentation.repeat(numIndents + 1))
+  ) {
+    return snapshot;
+  }
+
  return lines
    .map((line, index) => {
      if (index === 0) {
--- a/node_modules/jest-snapshot/build/print.d.ts
+++ b/node_modules/jest-snapshot/build/print.d.ts
@@ -0,0 +1,8 @@
+/**
+ * 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 printDiffOrStringified: (expectedSerializedTrimmed: string, receivedSerializedTrimmed: string, received: unknown, expectedLabel: string, receivedLabel: string, expand: boolean) => string;
+//# sourceMappingURL=print.d.ts.map
--- a/node_modules/jest-snapshot/build/print.d.ts.map
+++ b/node_modules/jest-snapshot/build/print.d.ts.map
@@ -0,0 +1 @@
+{"version":3,"file":"print.d.ts","sourceRoot":"","sources":["../src/print.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA0CH,eAAO,MAAM,sBAAsB,oKAkFlC,CAAC"}
--- a/node_modules/jest-snapshot/build/print.js
+++ b/node_modules/jest-snapshot/build/print.js
@@ -0,0 +1,174 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.printDiffOrStringified = void 0;
+
+var _jestDiff = _interopRequireWildcard(require('jest-diff'));
+
+var _jestGetType = _interopRequireWildcard(require('jest-get-type'));
+
+var _jestMatcherUtils = require('jest-matcher-utils');
+
+var _prettyFormat = _interopRequireDefault(require('pretty-format'));
+
+var _utils = require('./utils');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+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;
+  }
+}
+
+/**
+ * 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 isLineDiffable = received => {
+  const receivedType = (0, _jestGetType.default)(received);
+
+  if ((0, _jestGetType.isPrimitive)(received)) {
+    return typeof received === 'string' && received.includes('\n');
+  }
+
+  if (
+    receivedType === 'date' ||
+    receivedType === 'function' ||
+    receivedType === 'regexp'
+  ) {
+    return false;
+  }
+
+  if (received instanceof Error) {
+    return false;
+  }
+
+  if (
+    receivedType === 'object' &&
+    typeof received.asymmetricMatch === 'function'
+  ) {
+    return false;
+  }
+
+  return true;
+};
+
+const printDiffOrStringified = (
+  expectedSerializedTrimmed,
+  receivedSerializedTrimmed,
+  received,
+  expectedLabel,
+  receivedLabel,
+  expand
+) => {
+  if (typeof received === 'string') {
+    if (
+      expectedSerializedTrimmed.length >= 2 &&
+      expectedSerializedTrimmed.startsWith('"') &&
+      expectedSerializedTrimmed.endsWith('"') &&
+      receivedSerializedTrimmed ===
+        (0, _utils.unescape)((0, _prettyFormat.default)(received))
+    ) {
+      // The expected snapshot looks like a stringified string.
+      // The received serialization is default stringified string.
+      // Undo default serialization of expected snapshot:
+      // Remove enclosing double quote marks.
+      // Remove backslash escape preceding backslash here,
+      // because unescape replaced it only preceding double quote mark.
+      return (0, _jestMatcherUtils.printDiffOrStringify)(
+        expectedSerializedTrimmed.slice(1, -1).replace(/\\\\/g, '\\'),
+        received,
+        expectedLabel,
+        receivedLabel,
+        expand
+      );
+    } // Display substring highlight even when strings have custom serialization.
+
+    const result = (0, _jestDiff.getStringDiff)(
+      expectedSerializedTrimmed,
+      receivedSerializedTrimmed,
+      {
+        aAnnotation: expectedLabel,
+        bAnnotation: receivedLabel,
+        expand
+      }
+    );
+
+    if (result !== null) {
+      if (result.isMultiline) {
+        return result.annotatedDiff;
+      } // Because not default stringify, call EXPECTED_COLOR and RECEIVED_COLOR
+      // This is reason to call getStringDiff instead of printDiffOrStringify
+      // Because there is no closing double quote mark at end of single lines,
+      // future improvement is to call replaceSpacesAtEnd if it becomes public.
+
+      const printLabel = (0, _jestMatcherUtils.getLabelPrinter)(
+        expectedLabel,
+        receivedLabel
+      );
+      return (
+        printLabel(expectedLabel) +
+        (0, _jestMatcherUtils.EXPECTED_COLOR)(result.a) +
+        '\n' +
+        printLabel(receivedLabel) +
+        (0, _jestMatcherUtils.RECEIVED_COLOR)(result.b)
+      );
+    }
+  }
+
+  if (
+    (expectedSerializedTrimmed.includes('\n') ||
+      receivedSerializedTrimmed.includes('\n')) &&
+    isLineDiffable(received)
+  ) {
+    return (0, _jestDiff.default)(
+      expectedSerializedTrimmed,
+      receivedSerializedTrimmed,
+      {
+        aAnnotation: expectedLabel,
+        bAnnotation: receivedLabel,
+        expand
+      }
+    );
+  }
+
+  const printLabel = (0, _jestMatcherUtils.getLabelPrinter)(
+    expectedLabel,
+    receivedLabel
+  );
+  return (
+    printLabel(expectedLabel) +
+    (0, _jestMatcherUtils.EXPECTED_COLOR)(expectedSerializedTrimmed) +
+    '\n' +
+    printLabel(receivedLabel) +
+    (0, _jestMatcherUtils.RECEIVED_COLOR)(receivedSerializedTrimmed)
+  );
+};
+
+exports.printDiffOrStringified = printDiffOrStringified;
--- a/node_modules/jest-snapshot/build/snapshot_resolver.js
+++ b/node_modules/jest-snapshot/build/snapshot_resolver.js
@@ -110,9 +110,7 @@ function verifyConsistentTransformations(custom) {
  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}`
+        `Custom snapshot resolver functions must transform paths consistently, i.e. expects resolveTestPath(resolveSnapshotPath('${custom.testPathForConsistencyCheck}')) === ${resolvedTestPath}`
      )
    );
  }
--- a/node_modules/jest-snapshot/build/types.d.ts
+++ b/node_modules/jest-snapshot/build/types.d.ts
@@ -4,7 +4,5 @@
 * 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;
-};
+export declare type SnapshotData = Record<string, string>;
 //# sourceMappingURL=types.d.ts.map
--- a/node_modules/jest-snapshot/build/types.d.ts.map
+++ b/node_modules/jest-snapshot/build/types.d.ts.map
@@ -1 +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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,oBAAY,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC"}
--- a/node_modules/jest-snapshot/build/utils.d.ts
+++ b/node_modules/jest-snapshot/build/utils.d.ts
@@ -5,22 +5,19 @@
 * 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;
+    data: Record<string, string>;
    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 saveSnapshotFile: (snapshotData: Record<string, string>, snapshotPath: string) => void;
 export declare const deepMerge: (target: any, source: any) => any;
 //# sourceMappingURL=utils.d.ts.map
--- a/node_modules/jest-snapshot/build/utils.d.ts.map
+++ b/node_modules/jest-snapshot/build/utils.d.ts.map
@@ -1 +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"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,OAAO,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAKnC,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,sEAoB5B,CAAC;AAqBF,eAAO,MAAM,SAAS,mCAerB,CAAC"}
--- a/node_modules/jest-snapshot/build/utils.js
+++ b/node_modules/jest-snapshot/build/utils.js
@@ -253,6 +253,23 @@ const saveSnapshotFile = (snapshotData, snapshotPath) => {

 exports.saveSnapshotFile = saveSnapshotFile;

+const deepMergeArray = (target, source) => {
+  const mergedOutput = Array.from(target);
+  source.forEach((sourceElement, index) => {
+    const targetElement = mergedOutput[index];
+
+    if (Array.isArray(target[index])) {
+      mergedOutput[index] = deepMergeArray(target[index], sourceElement);
+    } else if (isObject(targetElement)) {
+      mergedOutput[index] = deepMerge(target[index], sourceElement);
+    } else {
+      // Source does not exist in target or target is primitive and cannot be deep merged
+      mergedOutput[index] = sourceElement;
+    }
+  });
+  return mergedOutput;
+};
+
 const deepMerge = (target, source) => {
  const mergedOutput = _objectSpread({}, target);

@@ -264,6 +281,8 @@ const deepMerge = (target, source) => {
            [key]: source[key]
          });
        else mergedOutput[key] = deepMerge(target[key], source[key]);
+      } else if (Array.isArray(source[key])) {
+        mergedOutput[key] = deepMergeArray(target[key], source[key]);
      } else {
        Object.assign(mergedOutput, {
          [key]: source[key]
--- a/node_modules/jest-snapshot/node_modules/.bin/semver
+++ b/node_modules/jest-snapshot/node_modules/.bin/semver
@@ -1 +1 @@
-../semver/bin/semver
+../semver/bin/semver.js
--- a/node_modules/jest-snapshot/node_modules/semver/CHANGELOG.md
+++ b/node_modules/jest-snapshot/node_modules/semver/CHANGELOG.md
@@ -1,5 +1,36 @@
 # changes log

+## 6.2.0
+
+* Coerce numbers to strings when passed to semver.coerce()
+* Add `rtl` option to coerce from right to left
+
+## 6.1.3
+
+* Handle X-ranges properly in includePrerelease mode
+
+## 6.1.2
+
+* Do not throw when testing invalid version strings
+
+## 6.1.1
+
+* Add options support for semver.coerce()
+* Handle undefined version passed to Range.test
+
+## 6.1.0
+
+* Add semver.compareBuild function
+* Support `*` in semver.intersects
+
+## 6.0
+
+* Fix `intersects` logic.
+
+    This is technically a bug fix, but since it is also a change to behavior
+    that may require users updating their code, it is marked as a major
+    version increment.
+
 ## 5.7

 * Add `minVersion` method
--- a/node_modules/jest-snapshot/node_modules/semver/README.md
+++ b/node_modules/jest-snapshot/node_modules/semver/README.md
@@ -4,7 +4,7 @@ semver(1) -- The semantic versioner for npm
 ## Install

 ```bash
-npm install --save semver
+npm install semver
 ````

 ## Usage
@@ -60,6 +60,12 @@ Options:
        Coerce a string into SemVer if possible
        (does not imply --loose)

+--rtl
+        Coerce version strings right to left
+
+--ltr
+        Coerce version strings left to right (default)
+
 Program exits successfully if any valid version satisfies
 all supplied ranges, and prints all satisfying versions.

@@ -231,7 +237,7 @@ comparator.  Allows minor-level changes if not.

 #### 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
+Allows changes that do not modify the left-most non-zero element 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`.
@@ -354,6 +360,9 @@ strings that they parse.
  `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()`.
+* `compareBuild(v1, v2)`: The same as `compare` but considers `build` when two versions
+  are equal.  Sorts in ascending order if passed to `Array.sort()`.
+  `v2` is greater.  Sorts in ascending order if 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.
@@ -396,16 +405,39 @@ range, use the `satisfies(version, range)` function.

 ### Coercion

-* `coerce(version)`: Coerces a string to semver if possible
+* `coerce(version, options)`: 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).
+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).
+
+If the `options.rtl` flag is set, then `coerce` will return the right-most
+coercible tuple that does not share an ending index with a longer coercible
+tuple.  For example, `1.2.3.4` will return `2.3.4` in rtl mode, not
+`4.0.0`.  `1.2.3/4` will return `4.0.0`, because the `4` is not a part of
+any other overlapping SemVer tuple.
+
+### Clean
+
+* `clean(version)`: Clean a string to be a valid semver if possible
+
+This will return a cleaned and trimmed semver version. If the provided version is not valid a null will be returned. This does not work for ranges. 
+
+ex.
+* `s.clean(' = v 2.1.5foo')`: `null`
+* `s.clean(' = v 2.1.5foo', { loose: true })`: `'2.1.5-foo'`
+* `s.clean(' = v 2.1.5-foo')`: `null`
+* `s.clean(' = v 2.1.5-foo', { loose: true })`: `'2.1.5-foo'`
+* `s.clean('=v2.1.5')`: `'2.1.5'`
+* `s.clean('  =v2.1.5')`: `2.1.5`
+* `s.clean('      2.1.5   ')`: `'2.1.5'`
+* `s.clean('~1.0.0')`: `null`
--- a/node_modules/jest-snapshot/node_modules/semver/bin/semver.js
+++ b/node_modules/jest-snapshot/node_modules/semver/bin/semver.js
@@ -19,6 +19,8 @@ var includePrerelease = false

 var coerce = false

+var rtl = false
+
 var identifier

 var semver = require('../semver')
@@ -71,6 +73,12 @@ function main () {
      case '-c': case '--coerce':
        coerce = true
        break
+      case '--rtl':
+        rtl = true
+        break
+      case '--ltr':
+        rtl = false
+        break
      case '-h': case '--help': case '-?':
        return help()
      default:
@@ -79,10 +87,10 @@ function main () {
    }
  }

-  var options = { loose: loose, includePrerelease: includePrerelease }
+  var options = { loose: loose, includePrerelease: includePrerelease, rtl: rtl }

  versions = versions.map(function (v) {
-    return coerce ? (semver.coerce(v) || { version: v }).version : v
+    return coerce ? (semver.coerce(v, options) || { version: v }).version : v
  }).filter(function (v) {
    return semver.valid(v)
  })
@@ -149,6 +157,12 @@ function help () {
    '        Coerce a string into SemVer if possible',
    '        (does not imply --loose)',
    '',
+    '--rtl',
+    '        Coerce version strings right to left',
+    '',
+    '--ltr',
+    '        Coerce version strings left to right (default)',
+    '',
    'Program exits successfully if any valid version satisfies',
    'all supplied ranges, and prints all satisfying versions.',
    '',
--- a/node_modules/jest-snapshot/node_modules/semver/package.json
+++ b/node_modules/jest-snapshot/node_modules/semver/package.json
@@ -1,42 +1,38 @@
 {
-  "_args": [
-    [
-      "semver@5.7.0",
-      "/Users/drew.heavner/Documents/Github/upload-google-play"
-    ]
-  ],
-  "_development": true,
-  "_from": "semver@5.7.0",
-  "_id": "semver@5.7.0",
+  "_from": "semver@^6.2.0",
+  "_id": "semver@6.3.0",
  "_inBundle": false,
-  "_integrity": "sha512-Ya52jSX2u7QKghxeoFGpLwCtGlt7j0oY9DYb5apt9nPlJ42ID+ulTXESnt/qAQcoSERyZ5sl3LDIOw0nAn/5DA==",
+  "_integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",
  "_location": "/jest-snapshot/semver",
  "_phantomChildren": {},
  "_requested": {
-    "type": "version",
+    "type": "range",
    "registry": true,
-    "raw": "semver@5.7.0",
+    "raw": "semver@^6.2.0",
    "name": "semver",
    "escapedName": "semver",
-    "rawSpec": "5.7.0",
+    "rawSpec": "^6.2.0",
    "saveSpec": null,
-    "fetchSpec": "5.7.0"
+    "fetchSpec": "^6.2.0"
  },
  "_requiredBy": [
    "/jest-snapshot"
  ],
-  "_resolved": "https://registry.npmjs.org/semver/-/semver-5.7.0.tgz",
-  "_spec": "5.7.0",
-  "_where": "/Users/drew.heavner/Documents/Github/upload-google-play",
+  "_resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
+  "_shasum": "ee0a64c8af5e8ceea67687b133761e1becbd1d3d",
+  "_spec": "semver@^6.2.0",
+  "_where": "/Users/drew.heavner/Documents/Github/upload-google-play/node_modules/jest-snapshot",
  "bin": {
-    "semver": "./bin/semver"
+    "semver": "bin/semver.js"
  },
  "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"
+    "tap": "^14.3.1"
  },
  "files": [
    "bin",
@@ -52,7 +48,7 @@
    "url": "git+https://github.com/npm/node-semver.git"
  },
  "scripts": {
-    "postpublish": "git push origin --all; git push origin --tags",
+    "postpublish": "git push origin --follow-tags",
    "postversion": "npm publish",
    "preversion": "npm test",
    "test": "tap"
@@ -60,5 +56,5 @@
  "tap": {
    "check-coverage": true
  },
-  "version": "5.7.0"
+  "version": "6.3.0"
 }
--- a/node_modules/jest-snapshot/node_modules/semver/semver.js
+++ b/node_modules/jest-snapshot/node_modules/semver/semver.js
@@ -29,75 +29,80 @@ var MAX_SAFE_COMPONENT_LENGTH = 16
 // The actual regexps go on exports.re
 var re = exports.re = []
 var src = exports.src = []
+var t = exports.tokens = {}
 var R = 0

+function tok (n) {
+  t[n] = R++
+}
+
 // The following Regular Expressions can be used for tokenizing,
 // validating, and parsing SemVer version strings.

 // ## Numeric Identifier
 // A single `0`, or a non-zero digit followed by zero or more digits.

-var NUMERICIDENTIFIER = R++
-src[NUMERICIDENTIFIER] = '0|[1-9]\\d*'
-var NUMERICIDENTIFIERLOOSE = R++
-src[NUMERICIDENTIFIERLOOSE] = '[0-9]+'
+tok('NUMERICIDENTIFIER')
+src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*'
+tok('NUMERICIDENTIFIERLOOSE')
+src[t.NUMERICIDENTIFIERLOOSE] = '[0-9]+'

 // ## Non-numeric Identifier
 // Zero or more digits, followed by a letter or hyphen, and then zero or
 // more letters, digits, or hyphens.

-var NONNUMERICIDENTIFIER = R++
-src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'
+tok('NONNUMERICIDENTIFIER')
+src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'

 // ## Main Version
 // Three dot-separated numeric identifiers.

-var MAINVERSION = R++
-src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' +
-                   '(' + src[NUMERICIDENTIFIER] + ')\\.' +
-                   '(' + src[NUMERICIDENTIFIER] + ')'
+tok('MAINVERSION')
+src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' +
+                   '(' + src[t.NUMERICIDENTIFIER] + ')\\.' +
+                   '(' + src[t.NUMERICIDENTIFIER] + ')'

-var MAINVERSIONLOOSE = R++
-src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
-                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
-                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')'
+tok('MAINVERSIONLOOSE')
+src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' +
+                        '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' +
+                        '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')'

 // ## Pre-release Version Identifier
 // A numeric identifier, or a non-numeric identifier.

-var PRERELEASEIDENTIFIER = R++
-src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] +
-                            '|' + src[NONNUMERICIDENTIFIER] + ')'
+tok('PRERELEASEIDENTIFIER')
+src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] +
+                            '|' + src[t.NONNUMERICIDENTIFIER] + ')'

-var PRERELEASEIDENTIFIERLOOSE = R++
-src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] +
-                                 '|' + src[NONNUMERICIDENTIFIER] + ')'
+tok('PRERELEASEIDENTIFIERLOOSE')
+src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] +
+                                 '|' + src[t.NONNUMERICIDENTIFIER] + ')'

 // ## Pre-release Version
 // Hyphen, followed by one or more dot-separated pre-release version
 // identifiers.

-var PRERELEASE = R++
-src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] +
-                  '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))'
+tok('PRERELEASE')
+src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] +
+                  '(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))'

-var PRERELEASELOOSE = R++
-src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] +
-                       '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))'
+tok('PRERELEASELOOSE')
+src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] +
+                       '(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))'

 // ## Build Metadata Identifier
 // Any combination of digits, letters, or hyphens.

-var BUILDIDENTIFIER = R++
-src[BUILDIDENTIFIER] = '[0-9A-Za-z-]+'
+tok('BUILDIDENTIFIER')
+src[t.BUILDIDENTIFIER] = '[0-9A-Za-z-]+'

 // ## Build Metadata
 // Plus sign, followed by one or more period-separated build metadata
 // identifiers.

-var BUILD = R++
-src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] +
-             '(?:\\.' + src[BUILDIDENTIFIER] + ')*))'
+tok('BUILD')
+src[t.BUILD] = '(?:\\+(' + src[t.BUILDIDENTIFIER] +
+             '(?:\\.' + src[t.BUILDIDENTIFIER] + ')*))'

 // ## Full Version String
 // A main version, followed optionally by a pre-release version and
@@ -108,129 +113,133 @@ src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] +
 // capturing group, because it should not ever be used in version
 // comparison.

-var FULL = R++
-var FULLPLAIN = 'v?' + src[MAINVERSION] +
-                src[PRERELEASE] + '?' +
-                src[BUILD] + '?'
+tok('FULL')
+tok('FULLPLAIN')
+src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] +
+                  src[t.PRERELEASE] + '?' +
+                  src[t.BUILD] + '?'

-src[FULL] = '^' + FULLPLAIN + '$'
+src[t.FULL] = '^' + src[t.FULLPLAIN] + '$'

 // like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
 // also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
 // common in the npm registry.
-var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] +
-                 src[PRERELEASELOOSE] + '?' +
-                 src[BUILD] + '?'
+tok('LOOSEPLAIN')
+src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] +
+                  src[t.PRERELEASELOOSE] + '?' +
+                  src[t.BUILD] + '?'

-var LOOSE = R++
-src[LOOSE] = '^' + LOOSEPLAIN + '$'
+tok('LOOSE')
+src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$'

-var GTLT = R++
-src[GTLT] = '((?:<|>)?=?)'
+tok('GTLT')
+src[t.GTLT] = '((?:<|>)?=?)'

 // Something like "2.*" or "1.2.x".
 // Note that "x.x" is a valid xRange identifer, meaning "any version"
 // Only the first item is strictly required.
-var XRANGEIDENTIFIERLOOSE = R++
-src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'
-var XRANGEIDENTIFIER = R++
-src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*'
+tok('XRANGEIDENTIFIERLOOSE')
+src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'
+tok('XRANGEIDENTIFIER')
+src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*'

-var XRANGEPLAIN = R++
-src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' +
-                   '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
-                   '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
-                   '(?:' + src[PRERELEASE] + ')?' +
-                   src[BUILD] + '?' +
+tok('XRANGEPLAIN')
+src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' +
+                   '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' +
+                   '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' +
+                   '(?:' + src[t.PRERELEASE] + ')?' +
+                   src[t.BUILD] + '?' +
                   ')?)?'

-var XRANGEPLAINLOOSE = R++
-src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
-                        '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
-                        '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
-                        '(?:' + src[PRERELEASELOOSE] + ')?' +
-                        src[BUILD] + '?' +
+tok('XRANGEPLAINLOOSE')
+src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
+                        '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
+                        '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
+                        '(?:' + src[t.PRERELEASELOOSE] + ')?' +
+                        src[t.BUILD] + '?' +
                        ')?)?'

-var XRANGE = R++
-src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$'
-var XRANGELOOSE = R++
-src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$'
+tok('XRANGE')
+src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$'
+tok('XRANGELOOSE')
+src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$'

 // Coercion.
 // Extract anything that could conceivably be a part of a valid semver
-var COERCE = R++
-src[COERCE] = '(?:^|[^\\d])' +
+tok('COERCE')
+src[t.COERCE] = '(^|[^\\d])' +
              '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +
              '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
              '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
              '(?:$|[^\\d])'
+tok('COERCERTL')
+re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g')

 // Tilde ranges.
 // Meaning is "reasonably at or greater than"
-var LONETILDE = R++
-src[LONETILDE] = '(?:~>?)'
+tok('LONETILDE')
+src[t.LONETILDE] = '(?:~>?)'

-var TILDETRIM = R++
-src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+'
-re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g')
+tok('TILDETRIM')
+src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+'
+re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g')
 var tildeTrimReplace = '$1~'

-var TILDE = R++
-src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$'
-var TILDELOOSE = R++
-src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$'
+tok('TILDE')
+src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$'
+tok('TILDELOOSE')
+src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$'

 // Caret ranges.
 // Meaning is "at least and backwards compatible with"
-var LONECARET = R++
-src[LONECARET] = '(?:\\^)'
+tok('LONECARET')
+src[t.LONECARET] = '(?:\\^)'

-var CARETTRIM = R++
-src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+'
-re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g')
+tok('CARETTRIM')
+src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+'
+re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g')
 var caretTrimReplace = '$1^'

-var CARET = R++
-src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$'
-var CARETLOOSE = R++
-src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$'
+tok('CARET')
+src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$'
+tok('CARETLOOSE')
+src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$'

 // A simple gt/lt/eq thing, or just "" to indicate "any version"
-var COMPARATORLOOSE = R++
-src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$'
-var COMPARATOR = R++
-src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$'
+tok('COMPARATORLOOSE')
+src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$'
+tok('COMPARATOR')
+src[t.COMPARATOR] = '^' + src[t.GTLT] + '\\s*(' + src[t.FULLPLAIN] + ')$|^$'

 // An expression to strip any whitespace between the gtlt and the thing
 // it modifies, so that `> 1.2.3` ==> `>1.2.3`
-var COMPARATORTRIM = R++
-src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] +
-                      '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')'
+tok('COMPARATORTRIM')
+src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] +
+                      '\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')'

 // this one has to use the /g flag
-re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g')
+re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g')
 var comparatorTrimReplace = '$1$2$3'

 // Something like `1.2.3 - 1.2.4`
 // Note that these all use the loose form, because they'll be
 // checked against either the strict or loose comparator form
 // later.
-var HYPHENRANGE = R++
-src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' +
+tok('HYPHENRANGE')
+src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' +
                   '\\s+-\\s+' +
-                   '(' + src[XRANGEPLAIN] + ')' +
+                   '(' + src[t.XRANGEPLAIN] + ')' +
                   '\\s*$'

-var HYPHENRANGELOOSE = R++
-src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' +
+tok('HYPHENRANGELOOSE')
+src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' +
                        '\\s+-\\s+' +
-                        '(' + src[XRANGEPLAINLOOSE] + ')' +
+                        '(' + src[t.XRANGEPLAINLOOSE] + ')' +
                        '\\s*$'

 // Star ranges basically just allow anything at all.
-var STAR = R++
-src[STAR] = '(<|>)?=?\\s*\\*'
+tok('STAR')
+src[t.STAR] = '(<|>)?=?\\s*\\*'

 // Compile to actual regexp objects.
 // All are flag-free, unless they were created above with a flag.
@@ -262,7 +271,7 @@ function parse (version, options) {
    return null
  }

-  var r = options.loose ? re[LOOSE] : re[FULL]
+  var r = options.loose ? re[t.LOOSE] : re[t.FULL]
  if (!r.test(version)) {
    return null
  }
@@ -317,7 +326,7 @@ function SemVer (version, options) {
  this.options = options
  this.loose = !!options.loose

-  var m = version.trim().match(options.loose ? re[LOOSE] : re[FULL])
+  var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])

  if (!m) {
    throw new TypeError('Invalid Version: ' + version)
@@ -425,6 +434,30 @@ SemVer.prototype.comparePre = function (other) {
  } while (++i)
 }

+SemVer.prototype.compareBuild = function (other) {
+  if (!(other instanceof SemVer)) {
+    other = new SemVer(other, this.options)
+  }
+
+  var i = 0
+  do {
+    var a = this.build[i]
+    var b = other.build[i]
+    debug('prerelease compare', i, a, b)
+    if (a === undefined && b === undefined) {
+      return 0
+    } else if (b === undefined) {
+      return 1
+    } else if (a === undefined) {
+      return -1
+    } else if (a === b) {
+      continue
+    } else {
+      return compareIdentifiers(a, b)
+    }
+  } while (++i)
+}
+
 // preminor will bump the version up to the next minor release, and immediately
 // down to pre-release. premajor and prepatch work the same way.
 SemVer.prototype.inc = function (release, identifier) {
@@ -619,6 +652,13 @@ function compareLoose (a, b) {
  return compare(a, b, true)
 }

+exports.compareBuild = compareBuild
+function compareBuild (a, b, loose) {
+  var versionA = new SemVer(a, loose)
+  var versionB = new SemVer(b, loose)
+  return versionA.compare(versionB) || versionA.compareBuild(versionB)
+}
+
 exports.rcompare = rcompare
 function rcompare (a, b, loose) {
  return compare(b, a, loose)
@@ -627,14 +667,14 @@ function rcompare (a, b, loose) {
 exports.sort = sort
 function sort (list, loose) {
  return list.sort(function (a, b) {
-    return exports.compare(a, b, loose)
+    return exports.compareBuild(a, b, loose)
  })
 }

 exports.rsort = rsort
 function rsort (list, loose) {
  return list.sort(function (a, b) {
-    return exports.rcompare(a, b, loose)
+    return exports.compareBuild(b, a, loose)
  })
 }

@@ -747,14 +787,14 @@ function Comparator (comp, options) {

 var ANY = {}
 Comparator.prototype.parse = function (comp) {
-  var r = this.options.loose ? re[COMPARATORLOOSE] : re[COMPARATOR]
+  var r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
  var m = comp.match(r)

  if (!m) {
    throw new TypeError('Invalid comparator: ' + comp)
  }

-  this.operator = m[1]
+  this.operator = m[1] !== undefined ? m[1] : ''
  if (this.operator === '=') {
    this.operator = ''
  }
@@ -774,12 +814,16 @@ Comparator.prototype.toString = function () {
 Comparator.prototype.test = function (version) {
  debug('Comparator.test', version, this.options.loose)

-  if (this.semver === ANY) {
+  if (this.semver === ANY || version === ANY) {
    return true
  }

  if (typeof version === 'string') {
-    version = new SemVer(version, this.options)
+    try {
+      version = new SemVer(version, this.options)
+    } catch (er) {
+      return false
+    }
  }

  return cmp(version, this.operator, this.semver, this.options)
@@ -800,9 +844,15 @@ Comparator.prototype.intersects = function (comp, options) {
  var rangeTmp

  if (this.operator === '') {
+    if (this.value === '') {
+      return true
+    }
    rangeTmp = new Range(comp.value, options)
    return satisfies(this.value, rangeTmp, options)
  } else if (comp.operator === '') {
+    if (comp.value === '') {
+      return true
+    }
    rangeTmp = new Range(this.value, options)
    return satisfies(comp.semver, rangeTmp, options)
  }
@@ -892,18 +942,18 @@ Range.prototype.parseRange = function (range) {
  var loose = this.options.loose
  range = range.trim()
  // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
-  var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE]
+  var hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]
  range = range.replace(hr, hyphenReplace)
  debug('hyphen replace', range)
  // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
-  range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace)
-  debug('comparator trim', range, re[COMPARATORTRIM])
+  range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)
+  debug('comparator trim', range, re[t.COMPARATORTRIM])

  // `~ 1.2.3` => `~1.2.3`
-  range = range.replace(re[TILDETRIM], tildeTrimReplace)
+  range = range.replace(re[t.TILDETRIM], tildeTrimReplace)

  // `^ 1.2.3` => `^1.2.3`
-  range = range.replace(re[CARETTRIM], caretTrimReplace)
+  range = range.replace(re[t.CARETTRIM], caretTrimReplace)

  // normalize spaces
  range = range.split(/\s+/).join(' ')
@@ -911,7 +961,7 @@ Range.prototype.parseRange = function (range) {
  // At this point, the range is completely trimmed and
  // ready to be split into comparators.

-  var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR]
+  var compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
  var set = range.split(' ').map(function (comp) {
    return parseComparator(comp, this.options)
  }, this).join(' ').split(/\s+/)
@@ -934,16 +984,40 @@ Range.prototype.intersects = function (range, options) {
  }

  return this.set.some(function (thisComparators) {
-    return thisComparators.every(function (thisComparator) {
-      return range.set.some(function (rangeComparators) {
-        return rangeComparators.every(function (rangeComparator) {
-          return thisComparator.intersects(rangeComparator, options)
-        })
+    return (
+      isSatisfiable(thisComparators, options) &&
+      range.set.some(function (rangeComparators) {
+        return (
+          isSatisfiable(rangeComparators, options) &&
+          thisComparators.every(function (thisComparator) {
+            return rangeComparators.every(function (rangeComparator) {
+              return thisComparator.intersects(rangeComparator, options)
+            })
+          })
+        )
      })
-    })
+    )
  })
 }

+// take a set of comparators and determine whether there
+// exists a version which can satisfy it
+function isSatisfiable (comparators, options) {
+  var result = true
+  var remainingComparators = comparators.slice()
+  var testComparator = remainingComparators.pop()
+
+  while (result && remainingComparators.length) {
+    result = remainingComparators.every(function (otherComparator) {
+      return testComparator.intersects(otherComparator, options)
+    })
+
+    testComparator = remainingComparators.pop()
+  }
+
+  return result
+}
+
 // Mostly just for testing and legacy API reasons
 exports.toComparators = toComparators
 function toComparators (range, options) {
@@ -987,7 +1061,7 @@ function replaceTildes (comp, options) {
 }

 function replaceTilde (comp, options) {
-  var r = options.loose ? re[TILDELOOSE] : re[TILDE]
+  var r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
  return comp.replace(r, function (_, M, m, p, pr) {
    debug('tilde', comp, _, M, m, p, pr)
    var ret
@@ -1028,7 +1102,7 @@ function replaceCarets (comp, options) {

 function replaceCaret (comp, options) {
  debug('caret', comp, options)
-  var r = options.loose ? re[CARETLOOSE] : re[CARET]
+  var r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]
  return comp.replace(r, function (_, M, m, p, pr) {
    debug('caret', comp, _, M, m, p, pr)
    var ret
@@ -1087,7 +1161,7 @@ function replaceXRanges (comp, options) {

 function replaceXRange (comp, options) {
  comp = comp.trim()
-  var r = options.loose ? re[XRANGELOOSE] : re[XRANGE]
+  var r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]
  return comp.replace(r, function (ret, gtlt, M, m, p, pr) {
    debug('xRange', comp, ret, gtlt, M, m, p, pr)
    var xM = isX(M)
@@ -1099,10 +1173,14 @@ function replaceXRange (comp, options) {
      gtlt = ''
    }

+    // if we're including prereleases in the match, then we need
+    // to fix this to -0, the lowest possible prerelease value
+    pr = options.includePrerelease ? '-0' : ''
+
    if (xM) {
      if (gtlt === '>' || gtlt === '<') {
        // nothing is allowed
-        ret = '<0.0.0'
+        ret = '<0.0.0-0'
      } else {
        // nothing is forbidden
        ret = '*'
@@ -1139,11 +1217,12 @@ function replaceXRange (comp, options) {
        }
      }

-      ret = gtlt + M + '.' + m + '.' + p
+      ret = gtlt + M + '.' + m + '.' + p + pr
    } else if (xm) {
-      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
+      ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr
    } else if (xp) {
-      ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
+      ret = '>=' + M + '.' + m + '.0' + pr +
+        ' <' + M + '.' + (+m + 1) + '.0' + pr
    }

    debug('xRange return', ret)
@@ -1157,10 +1236,10 @@ function replaceXRange (comp, options) {
 function replaceStars (comp, options) {
  debug('replaceStars', comp, options)
  // Looseness is ignored here.  star is always as loose as it gets!
-  return comp.trim().replace(re[STAR], '')
+  return comp.trim().replace(re[t.STAR], '')
 }

-// This function is passed to string.replace(re[HYPHENRANGE])
+// This function is passed to string.replace(re[t.HYPHENRANGE])
 // M, m, patch, prerelease, build
 // 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
 // 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do
@@ -1200,7 +1279,11 @@ Range.prototype.test = function (version) {
  }

  if (typeof version === 'string') {
-    version = new SemVer(version, this.options)
+    try {
+      version = new SemVer(version, this.options)
+    } catch (er) {
+      return false
+    }
  }

  for (var i = 0; i < this.set.length; i++) {
@@ -1462,22 +1545,52 @@ function intersects (r1, r2, options) {
 }

 exports.coerce = coerce
-function coerce (version) {
+function coerce (version, options) {
  if (version instanceof SemVer) {
    return version
  }

+  if (typeof version === 'number') {
+    version = String(version)
+  }
+
  if (typeof version !== 'string') {
    return null
  }

-  var match = version.match(re[COERCE])
+  options = options || {}

-  if (match == null) {
+  var match = null
+  if (!options.rtl) {
+    match = version.match(re[t.COERCE])
+  } else {
+    // Find the right-most coercible string that does not share
+    // a terminus with a more left-ward coercible string.
+    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
+    //
+    // Walk through the string checking with a /g regexp
+    // Manually set the index so as to pick up overlapping matches.
+    // Stop when we get a match that ends at the string end, since no
+    // coercible string can be more right-ward without the same terminus.
+    var next
+    while ((next = re[t.COERCERTL].exec(version)) &&
+      (!match || match.index + match[0].length !== version.length)
+    ) {
+      if (!match ||
+          next.index + next[0].length !== match.index + match[0].length) {
+        match = next
+      }
+      re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length
+    }
+    // leave it in a clean state
+    re[t.COERCERTL].lastIndex = -1
+  }
+
+  if (match === null) {
    return null
  }

-  return parse(match[1] +
-    '.' + (match[2] || '0') +
-    '.' + (match[3] || '0'))
+  return parse(match[2] +
+    '.' + (match[3] || '0') +
+    '.' + (match[4] || '0'), options)
 }
--- a/node_modules/jest-snapshot/package.json
+++ b/node_modules/jest-snapshot/package.json
@@ -1,26 +1,19 @@
 {
-  "_args": [
-    [
-      "jest-snapshot@24.8.0",
-      "/Users/drew.heavner/Documents/Github/upload-google-play"
-    ]
-  ],
-  "_development": true,
-  "_from": "jest-snapshot@24.8.0",
-  "_id": "jest-snapshot@24.8.0",
+  "_from": "jest-snapshot@^24.9.0",
+  "_id": "jest-snapshot@24.9.0",
  "_inBundle": false,
-  "_integrity": "sha512-5ehtWoc8oU9/cAPe6fez6QofVJLBKyqkY2+TlKTOf0VllBB/mqUNdARdcjlZrs9F1Cv+/HKoCS/BknT0+tmfPg==",
+  "_integrity": "sha512-uI/rszGSs73xCM0l+up7O7a40o90cnrk429LOiK3aeTvfC0HHmldbd81/B7Ix81KSFe1lwkbl7GnBGG4UfuDew==",
  "_location": "/jest-snapshot",
  "_phantomChildren": {},
  "_requested": {
-    "type": "version",
+    "type": "range",
    "registry": true,
-    "raw": "jest-snapshot@24.8.0",
+    "raw": "jest-snapshot@^24.9.0",
    "name": "jest-snapshot",
    "escapedName": "jest-snapshot",
-    "rawSpec": "24.8.0",
+    "rawSpec": "^24.9.0",
    "saveSpec": null,
-    "fetchSpec": "24.8.0"
+    "fetchSpec": "^24.9.0"
  },
  "_requiredBy": [
    "/@jest/core",
@@ -29,39 +22,43 @@
    "/jest-resolve-dependencies",
    "/jest-runtime"
  ],
-  "_resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-24.8.0.tgz",
-  "_spec": "24.8.0",
-  "_where": "/Users/drew.heavner/Documents/Github/upload-google-play",
+  "_resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-24.9.0.tgz",
+  "_shasum": "ec8e9ca4f2ec0c5c87ae8f925cf97497b0e951ba",
+  "_spec": "jest-snapshot@^24.9.0",
+  "_where": "/Users/drew.heavner/Documents/Github/upload-google-play/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",
+    "@jest/types": "^24.9.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",
+    "expect": "^24.9.0",
+    "jest-diff": "^24.9.0",
+    "jest-get-type": "^24.9.0",
+    "jest-matcher-utils": "^24.9.0",
+    "jest-message-util": "^24.9.0",
+    "jest-resolve": "^24.9.0",
    "mkdirp": "^0.5.1",
    "natural-compare": "^1.4.0",
-    "pretty-format": "^24.8.0",
-    "semver": "^5.5.0"
+    "pretty-format": "^24.9.0",
+    "semver": "^6.2.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",
+    "@types/semver": "^6.0.1",
+    "jest-haste-map": "^24.9.0",
    "prettier": "^1.13.4"
  },
  "engines": {
    "node": ">= 6"
  },
-  "gitHead": "845728f24b3ef41e450595c384e9b5c9fdf248a4",
+  "gitHead": "9ad0f4bc6b8bdd94989804226c28c9960d9da7d1",
  "homepage": "https://github.com/facebook/jest#readme",
  "license": "MIT",
  "main": "build/index.js",
@@ -75,5 +72,5 @@
    "directory": "packages/jest-snapshot"
  },
  "types": "build/index.d.ts",
-  "version": "24.8.0"
+  "version": "24.9.0"
 }
--- a/node_modules/jest-snapshot/tsconfig.json
+++ b/node_modules/jest-snapshot/tsconfig.json
@@ -1,17 +0,0 @@
-{
-  "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"}
-  ]
-}
				`@@ -0,0 +1 @@`
				`{"version":3,"file":"print.d.ts","sourceRoot":"","sources":["../src/print.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA0CH,eAAO,MAAM,sBAAsB,oKAkFlC,CAAC"}`