Updated dependencies and fixed audit

2026-10-02 17:41:35 +00:00 · 2020-11-12 18:00:41 -05:00
1 parent ac7314fa18
commit ff34f681c1
@@ -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
@@ -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;
@@ -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"}
@@ -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;
@@ -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;
@@ -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"}
@@ -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: ''
@@ -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) {
@@ -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}`
      )
    );
  }
@@ -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
@@ -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"}
@@ -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
@@ -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"}
@@ -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]
@@ -1 +1 @@
-../semver/bin/semver
+../semver/bin/semver.js
@@ -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
@@ -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`
@@ -1,160 +0,0 @@
-#!/usr/bin/env node
-// Standalone semver comparison program.
-// Exits successfully and prints matching version(s) if
-// any supplied version is valid and passes all tests.
-
-var argv = process.argv.slice(2)
-
-var versions = []
-
-var range = []
-
-var inc = null
-
-var version = require('../package.json').version
-
-var loose = false
-
-var includePrerelease = false
-
-var coerce = false
-
-var identifier
-
-var semver = require('../semver')
-
-var reverse = false
-
-var options = {}
-
-main()
-
-function main () {
-  if (!argv.length) return help()
-  while (argv.length) {
-    var a = argv.shift()
-    var indexOfEqualSign = a.indexOf('=')
-    if (indexOfEqualSign !== -1) {
-      a = a.slice(0, indexOfEqualSign)
-      argv.unshift(a.slice(indexOfEqualSign + 1))
-    }
-    switch (a) {
-      case '-rv': case '-rev': case '--rev': case '--reverse':
-        reverse = true
-        break
-      case '-l': case '--loose':
-        loose = true
-        break
-      case '-p': case '--include-prerelease':
-        includePrerelease = true
-        break
-      case '-v': case '--version':
-        versions.push(argv.shift())
-        break
-      case '-i': case '--inc': case '--increment':
-        switch (argv[0]) {
-          case 'major': case 'minor': case 'patch': case 'prerelease':
-          case 'premajor': case 'preminor': case 'prepatch':
-            inc = argv.shift()
-            break
-          default:
-            inc = 'patch'
-            break
-        }
-        break
-      case '--preid':
-        identifier = argv.shift()
-        break
-      case '-r': case '--range':
-        range.push(argv.shift())
-        break
-      case '-c': case '--coerce':
-        coerce = true
-        break
-      case '-h': case '--help': case '-?':
-        return help()
-      default:
-        versions.push(a)
-        break
-    }
-  }
-
-  var options = { loose: loose, includePrerelease: includePrerelease }
-
-  versions = versions.map(function (v) {
-    return coerce ? (semver.coerce(v) || { version: v }).version : v
-  }).filter(function (v) {
-    return semver.valid(v)
-  })
-  if (!versions.length) return fail()
-  if (inc && (versions.length !== 1 || range.length)) { return failInc() }
-
-  for (var i = 0, l = range.length; i < l; i++) {
-    versions = versions.filter(function (v) {
-      return semver.satisfies(v, range[i], options)
-    })
-    if (!versions.length) return fail()
-  }
-  return success(versions)
-}
-
-function failInc () {
-  console.error('--inc can only be used on a single version with no range')
-  fail()
-}
-
-function fail () { process.exit(1) }
-
-function success () {
-  var compare = reverse ? 'rcompare' : 'compare'
-  versions.sort(function (a, b) {
-    return semver[compare](a, b, options)
-  }).map(function (v) {
-    return semver.clean(v, options)
-  }).map(function (v) {
-    return inc ? semver.inc(v, inc, options, identifier) : v
-  }).forEach(function (v, i, _) { console.log(v) })
-}
-
-function help () {
-  console.log(['SemVer ' + version,
-    '',
-    'A JavaScript implementation of the https://semver.org/ specification',
-    'Copyright Isaac Z. Schlueter',
-    '',
-    'Usage: semver [options] <version> [<version> [...]]',
-    'Prints valid versions sorted by SemVer precedence',
-    '',
-    'Options:',
-    '-r --range <range>',
-    '        Print versions that match the specified range.',
-    '',
-    '-i --increment [<level>]',
-    '        Increment a version by the specified level.  Level can',
-    '        be one of: major, minor, patch, premajor, preminor,',
-    "        prepatch, or prerelease.  Default level is 'patch'.",
-    '        Only one version may be specified.',
-    '',
-    '--preid <identifier>',
-    '        Identifier to be used to prefix premajor, preminor,',
-    '        prepatch or prerelease version increments.',
-    '',
-    '-l --loose',
-    '        Interpret versions and ranges loosely',
-    '',
-    '-p --include-prerelease',
-    '        Always include prerelease versions in range matching',
-    '',
-    '-c --coerce',
-    '        Coerce a string into SemVer if possible',
-    '        (does not imply --loose)',
-    '',
-    'Program exits successfully if any valid version satisfies',
-    'all supplied ranges, and prints all satisfying versions.',
-    '',
-    'If no satisfying versions are found, then exits failure.',
-    '',
-    'Versions are printed in ascending order, so supplying',
-    'multiple versions to the utility will just sort them.'
-  ].join('\n'))
-}
@@ -1,42 +1,38 @@
 {
-  "_args": [
-    [
-      "semver@5.7.0",
-      "/Users/drew.heavner/Documents/Github/sign-android-release"
-    ]
-  ],
-  "_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/sign-android-release",
+  "_resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
+  "_shasum": "ee0a64c8af5e8ceea67687b133761e1becbd1d3d",
+  "_spec": "semver@^6.2.0",
+  "_where": "/Users/drew.heavner/Documents/Github/sign-android-release/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"
 }
@@ -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)
 }
@@ -1,67 +1,80 @@
 {
-  "_args": [
-    [
-      "jest-snapshot@24.8.0",
-      "/Users/drew.heavner/Documents/Github/sign-android-release"
-    ]
-  ],
-  "_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": {},
+  "_phantomChildren": {
+    "@babel/code-frame": "7.5.5",
+    "@types/istanbul-lib-coverage": "2.0.1",
+    "@types/istanbul-reports": "1.1.1",
+    "@types/stack-utils": "1.0.1",
+    "@types/yargs-parser": "15.0.0",
+    "ansi-regex": "4.1.0",
+    "ansi-styles": "3.2.1",
+    "callsites": "3.1.0",
+    "chalk": "2.4.2",
+    "graceful-fs": "4.2.0",
+    "micromatch": "3.1.10",
+    "react-is": "16.8.6",
+    "slash": "2.0.0",
+    "source-map": "0.6.1",
+    "stack-utils": "1.0.2"
+  },
  "_requested": {
    "type": "version",
    "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",
    "/jest-circus",
    "/jest-jasmine2",
    "/jest-resolve-dependencies",
-    "/jest-runtime"
+    "/jest-runtime",
+    "/jest/jest-cli/@jest/core"
  ],
-  "_resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-24.8.0.tgz",
-  "_spec": "24.8.0",
-  "_where": "/Users/drew.heavner/Documents/Github/sign-android-release",
+  "_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/sign-android-release/node_modules/jest/node_modules/jest-cli/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 +88,5 @@
    "directory": "packages/jest-snapshot"
  },
  "types": "build/index.d.ts",
-  "version": "24.8.0"
+  "version": "24.9.0"
 }
@@ -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"}
-  ]
-}