@nebula.js/stardust 6.0.0-alpha.0 → 6.0.0-alpha.2

package/core/esm/dev.js

@@ -1,5 +1,5 @@
 /*
-* @nebula.js/stardust v6.0.0-alpha.0
+* @nebula.js/stardust v6.0.0-alpha.2
 * Copyright (c) 2025 QlikTech International AB
 * Released under the MIT license.
 */
@@ -7736,8 +7736,8 @@ var compat = function compat(element) {
     return;
   }
 
-  var value = element.value;
-  var parent = element.parent;
+  var value = element.value,
+      parent = element.parent;
   var isImplicitRule = element.column === parent.column && element.line === parent.line;
 
   while (parent.type !== 'rule') {
@@ -7997,7 +7997,11 @@ var prefixer = function prefixer(element, index, children, callback) {
 
 var defaultStylisPlugins = [prefixer];
 
-var createCache = function createCache(options) {
+var createCache = function
+  /*: EmotionCache */
+createCache(options
+/*: Options */
+) {
   var key = options.key;
 
   if (key === 'css') {
@@ -8006,7 +8010,9 @@ var createCache = function createCache(options) {
     // note this very very intentionally targets all style elements regardless of the key to ensure
     // that creating a cache works inside of render of a React component
 
-    Array.prototype.forEach.call(ssrStyles, function (node) {
+    Array.prototype.forEach.call(ssrStyles, function (node
+    /*: HTMLStyleElement */
+    ) {
       // we want to only move elements which have a space in the data-emotion attribute value
       // because that indicates that it is an Emotion 11 server-side rendered style elements
       // while we will already ignore Emotion 11 client-side inserted styles because of the :not([data-s]) part in the selector
@@ -8028,13 +8034,17 @@ var createCache = function createCache(options) {
 
   var inserted = {};
   var container;
+  /* : Node */
+
   var nodesToHydrate = [];
 
   {
     container = options.container || document.head;
     Array.prototype.forEach.call( // this means we will ignore elements which don't have a space in them which
     // means that the style elements we're looking at are only Emotion 11 server-rendered style elements
-    document.querySelectorAll("style[data-emotion^=\"" + key + " \"]"), function (node) {
+    document.querySelectorAll("style[data-emotion^=\"" + key + " \"]"), function (node
+    /*: HTMLStyleElement */
+    ) {
       var attrib = node.getAttribute("data-emotion").split(' ');
 
       for (var i = 1; i < attrib.length; i++) {
@@ -8046,6 +8056,13 @@ var createCache = function createCache(options) {
   }
 
   var _insert;
+  /*: (
+  selector: string,
+  serialized: SerializedStyles,
+  sheet: StyleSheet,
+  shouldCache: boolean
+  ) => string | void */
+
 
   var omnipresentPlugins = [compat, removeLabel];
 
@@ -8060,7 +8077,17 @@ var createCache = function createCache(options) {
       return serialize(compile(styles), serializer);
     };
 
-    _insert = function insert(selector, serialized, sheet, shouldCache) {
+    _insert = function
+      /*: void */
+    insert(selector
+    /*: string */
+    , serialized
+    /*: SerializedStyles */
+    , sheet
+    /*: StyleSheet */
+    , shouldCache
+    /*: boolean */
+    ) {
       currentSheet = sheet;
 
       stylis(selector ? selector + "{" + serialized.styles + "}" : serialized.styles);
@@ -8071,7 +8098,9 @@ var createCache = function createCache(options) {
     };
   }
 
-  var cache = {
+  var cache
+  /*: EmotionCache */
+  = {
     key: key,
     sheet: new StyleSheet({
       key: key,
@@ -12012,7 +12041,7 @@ function create$3(definition) {
   return cache$1[key];
 }
 
-const NEBULA_VERSION_HASH = "c3a7";
+const NEBULA_VERSION_HASH = "3efc";
 ClassNameGenerator.configure(componentName => {
   return "njs-".concat(NEBULA_VERSION_HASH, "-").concat(componentName.replace('Mui', ''));
 });
@@ -12256,7 +12285,7 @@ function boot(_ref2) {
   const appRef = React__default.createRef();
   const element = document.createElement('div');
   element.style.display = 'none';
-  element.setAttribute('data-nebulajs-version', "6.0.0-alpha.0");
+  element.setAttribute('data-nebulajs-version', "6.0.0-alpha.2");
   element.setAttribute('data-app-id', app.id);
   document.body.appendChild(element);
   if (context) {
@@ -30667,1625 +30696,1357 @@ async function getObject(_ref, halo, store) {
 
 var lrucache;
 var hasRequiredLrucache;
-
-function requireLrucache () {
-	if (hasRequiredLrucache) return lrucache;
-	hasRequiredLrucache = 1;
-
-	class LRUCache {
-	  constructor () {
-	    this.max = 1000;
-	    this.map = new Map();
-	  }
-
-	  get (key) {
-	    const value = this.map.get(key);
-	    if (value === undefined) {
-	      return undefined
-	    } else {
-	      // Remove the key from the map and add it to the end
-	      this.map.delete(key);
-	      this.map.set(key, value);
-	      return value
-	    }
-	  }
-
-	  delete (key) {
-	    return this.map.delete(key)
-	  }
-
-	  set (key, value) {
-	    const deleted = this.delete(key);
-
-	    if (!deleted && value !== undefined) {
-	      // If cache is full, delete the least recently used item
-	      if (this.map.size >= this.max) {
-	        const firstKey = this.map.keys().next().value;
-	        this.delete(firstKey);
-	      }
-
-	      this.map.set(key, value);
-	    }
-
-	    return this
-	  }
-	}
-
-	lrucache = LRUCache;
-	return lrucache;
+function requireLrucache() {
+  if (hasRequiredLrucache) return lrucache;
+  hasRequiredLrucache = 1;
+  class LRUCache {
+    constructor() {
+      this.max = 1000;
+      this.map = new Map();
+    }
+    get(key) {
+      const value = this.map.get(key);
+      if (value === undefined) {
+        return undefined;
+      } else {
+        // Remove the key from the map and add it to the end
+        this.map.delete(key);
+        this.map.set(key, value);
+        return value;
+      }
+    }
+    delete(key) {
+      return this.map.delete(key);
+    }
+    set(key, value) {
+      const deleted = this.delete(key);
+      if (!deleted && value !== undefined) {
+        // If cache is full, delete the least recently used item
+        if (this.map.size >= this.max) {
+          const firstKey = this.map.keys().next().value;
+          this.delete(firstKey);
+        }
+        this.map.set(key, value);
+      }
+      return this;
+    }
+  }
+  lrucache = LRUCache;
+  return lrucache;
 }
 
 var parseOptions_1;
 var hasRequiredParseOptions;
+function requireParseOptions() {
+  if (hasRequiredParseOptions) return parseOptions_1;
+  hasRequiredParseOptions = 1;
 
-function requireParseOptions () {
-	if (hasRequiredParseOptions) return parseOptions_1;
-	hasRequiredParseOptions = 1;
-
-	// parse out just the options we care about
-	const looseOption = Object.freeze({ loose: true });
-	const emptyOpts = Object.freeze({ });
-	const parseOptions = options => {
-	  if (!options) {
-	    return emptyOpts
-	  }
-
-	  if (typeof options !== 'object') {
-	    return looseOption
-	  }
-
-	  return options
-	};
-	parseOptions_1 = parseOptions;
-	return parseOptions_1;
+  // parse out just the options we care about
+  const looseOption = Object.freeze({
+    loose: true
+  });
+  const emptyOpts = Object.freeze({});
+  const parseOptions = options => {
+    if (!options) {
+      return emptyOpts;
+    }
+    if (typeof options !== 'object') {
+      return looseOption;
+    }
+    return options;
+  };
+  parseOptions_1 = parseOptions;
+  return parseOptions_1;
 }
 
 var re = {exports: {}};
 
 var constants;
 var hasRequiredConstants;
-
-function requireConstants () {
-	if (hasRequiredConstants) return constants;
-	hasRequiredConstants = 1;
-
-	// Note: this is the semver.org version of the spec that it implements
-	// Not necessarily the package version of this code.
-	const SEMVER_SPEC_VERSION = '2.0.0';
-
-	const MAX_LENGTH = 256;
-	const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
-	/* istanbul ignore next */ 9007199254740991;
-
-	// Max safe segment length for coercion.
-	const MAX_SAFE_COMPONENT_LENGTH = 16;
-
-	// Max safe length for a build identifier. The max length minus 6 characters for
-	// the shortest version with a build 0.0.0+BUILD.
-	const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
-
-	const RELEASE_TYPES = [
-	  'major',
-	  'premajor',
-	  'minor',
-	  'preminor',
-	  'patch',
-	  'prepatch',
-	  'prerelease',
-	];
-
-	constants = {
-	  MAX_LENGTH,
-	  MAX_SAFE_COMPONENT_LENGTH,
-	  MAX_SAFE_BUILD_LENGTH,
-	  MAX_SAFE_INTEGER,
-	  RELEASE_TYPES,
-	  SEMVER_SPEC_VERSION,
-	  FLAG_INCLUDE_PRERELEASE: 0b001,
-	  FLAG_LOOSE: 0b010,
-	};
-	return constants;
+function requireConstants() {
+  if (hasRequiredConstants) return constants;
+  hasRequiredConstants = 1;
+
+  // Note: this is the semver.org version of the spec that it implements
+  // Not necessarily the package version of this code.
+  const SEMVER_SPEC_VERSION = '2.0.0';
+  const MAX_LENGTH = 256;
+  const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */9007199254740991;
+
+  // Max safe segment length for coercion.
+  const MAX_SAFE_COMPONENT_LENGTH = 16;
+
+  // Max safe length for a build identifier. The max length minus 6 characters for
+  // the shortest version with a build 0.0.0+BUILD.
+  const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+  const RELEASE_TYPES = ['major', 'premajor', 'minor', 'preminor', 'patch', 'prepatch', 'prerelease'];
+  constants = {
+    MAX_LENGTH,
+    MAX_SAFE_COMPONENT_LENGTH,
+    MAX_SAFE_BUILD_LENGTH,
+    MAX_SAFE_INTEGER,
+    RELEASE_TYPES,
+    SEMVER_SPEC_VERSION,
+    FLAG_INCLUDE_PRERELEASE: 0b001,
+    FLAG_LOOSE: 0b010
+  };
+  return constants;
 }
 
 var debug_1;
 var hasRequiredDebug;
-
-function requireDebug () {
-	if (hasRequiredDebug) return debug_1;
-	hasRequiredDebug = 1;
-
-	const debug = (
-	  typeof process === 'object' &&
-	  process.env &&
-	  process.env.NODE_DEBUG &&
-	  /\bsemver\b/i.test(process.env.NODE_DEBUG)
-	) ? (...args) => console.error('SEMVER', ...args)
-	  : () => {};
-
-	debug_1 = debug;
-	return debug_1;
+function requireDebug() {
+  if (hasRequiredDebug) return debug_1;
+  hasRequiredDebug = 1;
+  const debug = typeof process === 'object' && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return console.error('SEMVER', ...args);
+  } : () => {};
+  debug_1 = debug;
+  return debug_1;
 }
 
 var hasRequiredRe;
+function requireRe() {
+  if (hasRequiredRe) return re.exports;
+  hasRequiredRe = 1;
+  (function (module, exports) {
 
-function requireRe () {
-	if (hasRequiredRe) return re.exports;
-	hasRequiredRe = 1;
-	(function (module, exports) {
-
-		const {
-		  MAX_SAFE_COMPONENT_LENGTH,
-		  MAX_SAFE_BUILD_LENGTH,
-		  MAX_LENGTH,
-		} = requireConstants();
-		const debug = requireDebug();
-		exports = module.exports = {};
-
-		// The actual regexps go on exports.re
-		const re = exports.re = [];
-		const safeRe = exports.safeRe = [];
-		const src = exports.src = [];
-		const safeSrc = exports.safeSrc = [];
-		const t = exports.t = {};
-		let R = 0;
-
-		const LETTERDASHNUMBER = '[a-zA-Z0-9-]';
-
-		// Replace some greedy regex tokens to prevent regex dos issues. These regex are
-		// used internally via the safeRe object since all inputs in this library get
-		// normalized first to trim and collapse all extra whitespace. The original
-		// regexes are exported for userland consumption and lower level usage. A
-		// future breaking change could export the safer regex only with a note that
-		// all input should have extra whitespace removed.
-		const safeRegexReplacements = [
-		  ['\\s', 1],
-		  ['\\d', MAX_LENGTH],
-		  [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],
-		];
-
-		const makeSafeRegex = (value) => {
-		  for (const [token, max] of safeRegexReplacements) {
-		    value = value
-		      .split(`${token}*`).join(`${token}{0,${max}}`)
-		      .split(`${token}+`).join(`${token}{1,${max}}`);
-		  }
-		  return value
-		};
-
-		const createToken = (name, value, isGlobal) => {
-		  const safe = makeSafeRegex(value);
-		  const index = R++;
-		  debug(name, index, value);
-		  t[name] = index;
-		  src[index] = value;
-		  safeSrc[index] = safe;
-		  re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
-		  safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined);
-		};
-
-		// 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.
-
-		createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
-		createToken('NUMERICIDENTIFIERLOOSE', '\\d+');
-
-		// ## Non-numeric Identifier
-		// Zero or more digits, followed by a letter or hyphen, and then zero or
-		// more letters, digits, or hyphens.
-
-		createToken('NONNUMERICIDENTIFIER', `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
-
-		// ## Main Version
-		// Three dot-separated numeric identifiers.
-
-		createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` +
-		                   `(${src[t.NUMERICIDENTIFIER]})\\.` +
-		                   `(${src[t.NUMERICIDENTIFIER]})`);
-
-		createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
-		                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
-		                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`);
-
-		// ## Pre-release Version Identifier
-		// A numeric identifier, or a non-numeric identifier.
-		// Non-numberic identifiers include numberic identifiers but can be longer.
-		// Therefore non-numberic identifiers must go first.
-
-		createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NONNUMERICIDENTIFIER]
-		}|${src[t.NUMERICIDENTIFIER]})`);
-
-		createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NONNUMERICIDENTIFIER]
-		}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
-
-		// ## Pre-release Version
-		// Hyphen, followed by one or more dot-separated pre-release version
-		// identifiers.
-
-		createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
-		}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
-
-		createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
-		}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
-
-		// ## Build Metadata Identifier
-		// Any combination of digits, letters, or hyphens.
-
-		createToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`);
-
-		// ## Build Metadata
-		// Plus sign, followed by one or more period-separated build metadata
-		// identifiers.
+    const {
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_LENGTH
+    } = requireConstants();
+    const debug = requireDebug();
+    exports = module.exports = {};
+
+    // The actual regexps go on exports.re
+    const re = exports.re = [];
+    const safeRe = exports.safeRe = [];
+    const src = exports.src = [];
+    const safeSrc = exports.safeSrc = [];
+    const t = exports.t = {};
+    let R = 0;
+    const LETTERDASHNUMBER = '[a-zA-Z0-9-]';
+
+    // Replace some greedy regex tokens to prevent regex dos issues. These regex are
+    // used internally via the safeRe object since all inputs in this library get
+    // normalized first to trim and collapse all extra whitespace. The original
+    // regexes are exported for userland consumption and lower level usage. A
+    // future breaking change could export the safer regex only with a note that
+    // all input should have extra whitespace removed.
+    const safeRegexReplacements = [['\\s', 1], ['\\d', MAX_LENGTH], [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]];
+    const makeSafeRegex = value => {
+      for (const [token, max] of safeRegexReplacements) {
+        value = value.split("".concat(token, "*")).join("".concat(token, "{0,").concat(max, "}")).split("".concat(token, "+")).join("".concat(token, "{1,").concat(max, "}"));
+      }
+      return value;
+    };
+    const createToken = (name, value, isGlobal) => {
+      const safe = makeSafeRegex(value);
+      const index = R++;
+      debug(name, index, value);
+      t[name] = index;
+      src[index] = value;
+      safeSrc[index] = safe;
+      re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
+      safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined);
+    };
 
-		createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]
-		}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
-
-		// ## Full Version String
-		// A main version, followed optionally by a pre-release version and
-		// build metadata.
-
-		// Note that the only major, minor, patch, and pre-release sections of
-		// the version string are capturing groups.  The build metadata is not a
-		// capturing group, because it should not ever be used in version
-		// comparison.
-
-		createToken('FULLPLAIN', `v?${src[t.MAINVERSION]
-		}${src[t.PRERELEASE]}?${
-		  src[t.BUILD]}?`);
-
-		createToken('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.
-		createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]
-		}${src[t.PRERELEASELOOSE]}?${
-		  src[t.BUILD]}?`);
-
-		createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`);
-
-		createToken('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.
-		createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
-		createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
-
-		createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` +
-		                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
-		                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
-		                   `(?:${src[t.PRERELEASE]})?${
-		                     src[t.BUILD]}?` +
-		                   `)?)?`);
-
-		createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +
-		                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
-		                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
-		                        `(?:${src[t.PRERELEASELOOSE]})?${
-		                          src[t.BUILD]}?` +
-		                        `)?)?`);
-
-		createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
-		createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
-
-		// Coercion.
-		// Extract anything that could conceivably be a part of a valid semver
-		createToken('COERCEPLAIN', `${'(^|[^\\d])' +
-		              '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
-		              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
-		              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
-		createToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
-		createToken('COERCEFULL', src[t.COERCEPLAIN] +
-		              `(?:${src[t.PRERELEASE]})?` +
-		              `(?:${src[t.BUILD]})?` +
-		              `(?:$|[^\\d])`);
-		createToken('COERCERTL', src[t.COERCE], true);
-		createToken('COERCERTLFULL', src[t.COERCEFULL], true);
-
-		// Tilde ranges.
-		// Meaning is "reasonably at or greater than"
-		createToken('LONETILDE', '(?:~>?)');
-
-		createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true);
-		exports.tildeTrimReplace = '$1~';
-
-		createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
-		createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
-
-		// Caret ranges.
-		// Meaning is "at least and backwards compatible with"
-		createToken('LONECARET', '(?:\\^)');
-
-		createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true);
-		exports.caretTrimReplace = '$1^';
-
-		createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
-		createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
-
-		// A simple gt/lt/eq thing, or just "" to indicate "any version"
-		createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
-		createToken('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`
-		createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
-		}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
-		exports.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.
-		createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
-		                   `\\s+-\\s+` +
-		                   `(${src[t.XRANGEPLAIN]})` +
-		                   `\\s*$`);
-
-		createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
-		                        `\\s+-\\s+` +
-		                        `(${src[t.XRANGEPLAINLOOSE]})` +
-		                        `\\s*$`);
-
-		// Star ranges basically just allow anything at all.
-		createToken('STAR', '(<|>)?=?\\s*\\*');
-		// >=0.0.0 is like a star
-		createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$');
-		createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$'); 
-	} (re, re.exports));
-	return re.exports;
+    // 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.
+
+    createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
+    createToken('NUMERICIDENTIFIERLOOSE', '\\d+');
+
+    // ## Non-numeric Identifier
+    // Zero or more digits, followed by a letter or hyphen, and then zero or
+    // more letters, digits, or hyphens.
+
+    createToken('NONNUMERICIDENTIFIER', "\\d*[a-zA-Z-]".concat(LETTERDASHNUMBER, "*"));
+
+    // ## Main Version
+    // Three dot-separated numeric identifiers.
+
+    createToken('MAINVERSION', "(".concat(src[t.NUMERICIDENTIFIER], ")\\.") + "(".concat(src[t.NUMERICIDENTIFIER], ")\\.") + "(".concat(src[t.NUMERICIDENTIFIER], ")"));
+    createToken('MAINVERSIONLOOSE', "(".concat(src[t.NUMERICIDENTIFIERLOOSE], ")\\.") + "(".concat(src[t.NUMERICIDENTIFIERLOOSE], ")\\.") + "(".concat(src[t.NUMERICIDENTIFIERLOOSE], ")"));
+
+    // ## Pre-release Version Identifier
+    // A numeric identifier, or a non-numeric identifier.
+    // Non-numberic identifiers include numberic identifiers but can be longer.
+    // Therefore non-numberic identifiers must go first.
+
+    createToken('PRERELEASEIDENTIFIER', "(?:".concat(src[t.NONNUMERICIDENTIFIER], "|").concat(src[t.NUMERICIDENTIFIER], ")"));
+    createToken('PRERELEASEIDENTIFIERLOOSE', "(?:".concat(src[t.NONNUMERICIDENTIFIER], "|").concat(src[t.NUMERICIDENTIFIERLOOSE], ")"));
+
+    // ## Pre-release Version
+    // Hyphen, followed by one or more dot-separated pre-release version
+    // identifiers.
+
+    createToken('PRERELEASE', "(?:-(".concat(src[t.PRERELEASEIDENTIFIER], "(?:\\.").concat(src[t.PRERELEASEIDENTIFIER], ")*))"));
+    createToken('PRERELEASELOOSE', "(?:-?(".concat(src[t.PRERELEASEIDENTIFIERLOOSE], "(?:\\.").concat(src[t.PRERELEASEIDENTIFIERLOOSE], ")*))"));
+
+    // ## Build Metadata Identifier
+    // Any combination of digits, letters, or hyphens.
+
+    createToken('BUILDIDENTIFIER', "".concat(LETTERDASHNUMBER, "+"));
+
+    // ## Build Metadata
+    // Plus sign, followed by one or more period-separated build metadata
+    // identifiers.
+
+    createToken('BUILD', "(?:\\+(".concat(src[t.BUILDIDENTIFIER], "(?:\\.").concat(src[t.BUILDIDENTIFIER], ")*))"));
+
+    // ## Full Version String
+    // A main version, followed optionally by a pre-release version and
+    // build metadata.
+
+    // Note that the only major, minor, patch, and pre-release sections of
+    // the version string are capturing groups.  The build metadata is not a
+    // capturing group, because it should not ever be used in version
+    // comparison.
+
+    createToken('FULLPLAIN', "v?".concat(src[t.MAINVERSION]).concat(src[t.PRERELEASE], "?").concat(src[t.BUILD], "?"));
+    createToken('FULL', "^".concat(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.
+    createToken('LOOSEPLAIN', "[v=\\s]*".concat(src[t.MAINVERSIONLOOSE]).concat(src[t.PRERELEASELOOSE], "?").concat(src[t.BUILD], "?"));
+    createToken('LOOSE', "^".concat(src[t.LOOSEPLAIN], "$"));
+    createToken('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.
+    createToken('XRANGEIDENTIFIERLOOSE', "".concat(src[t.NUMERICIDENTIFIERLOOSE], "|x|X|\\*"));
+    createToken('XRANGEIDENTIFIER', "".concat(src[t.NUMERICIDENTIFIER], "|x|X|\\*"));
+    createToken('XRANGEPLAIN', "[v=\\s]*(".concat(src[t.XRANGEIDENTIFIER], ")") + "(?:\\.(".concat(src[t.XRANGEIDENTIFIER], ")") + "(?:\\.(".concat(src[t.XRANGEIDENTIFIER], ")") + "(?:".concat(src[t.PRERELEASE], ")?").concat(src[t.BUILD], "?") + ")?)?");
+    createToken('XRANGEPLAINLOOSE', "[v=\\s]*(".concat(src[t.XRANGEIDENTIFIERLOOSE], ")") + "(?:\\.(".concat(src[t.XRANGEIDENTIFIERLOOSE], ")") + "(?:\\.(".concat(src[t.XRANGEIDENTIFIERLOOSE], ")") + "(?:".concat(src[t.PRERELEASELOOSE], ")?").concat(src[t.BUILD], "?") + ")?)?");
+    createToken('XRANGE', "^".concat(src[t.GTLT], "\\s*").concat(src[t.XRANGEPLAIN], "$"));
+    createToken('XRANGELOOSE', "^".concat(src[t.GTLT], "\\s*").concat(src[t.XRANGEPLAINLOOSE], "$"));
+
+    // Coercion.
+    // Extract anything that could conceivably be a part of a valid semver
+    createToken('COERCEPLAIN', "".concat('(^|[^\\d])' + '(\\d{1,').concat(MAX_SAFE_COMPONENT_LENGTH, "})") + "(?:\\.(\\d{1,".concat(MAX_SAFE_COMPONENT_LENGTH, "}))?") + "(?:\\.(\\d{1,".concat(MAX_SAFE_COMPONENT_LENGTH, "}))?"));
+    createToken('COERCE', "".concat(src[t.COERCEPLAIN], "(?:$|[^\\d])"));
+    createToken('COERCEFULL', src[t.COERCEPLAIN] + "(?:".concat(src[t.PRERELEASE], ")?") + "(?:".concat(src[t.BUILD], ")?") + "(?:$|[^\\d])");
+    createToken('COERCERTL', src[t.COERCE], true);
+    createToken('COERCERTLFULL', src[t.COERCEFULL], true);
+
+    // Tilde ranges.
+    // Meaning is "reasonably at or greater than"
+    createToken('LONETILDE', '(?:~>?)');
+    createToken('TILDETRIM', "(\\s*)".concat(src[t.LONETILDE], "\\s+"), true);
+    exports.tildeTrimReplace = '$1~';
+    createToken('TILDE', "^".concat(src[t.LONETILDE]).concat(src[t.XRANGEPLAIN], "$"));
+    createToken('TILDELOOSE', "^".concat(src[t.LONETILDE]).concat(src[t.XRANGEPLAINLOOSE], "$"));
+
+    // Caret ranges.
+    // Meaning is "at least and backwards compatible with"
+    createToken('LONECARET', '(?:\\^)');
+    createToken('CARETTRIM', "(\\s*)".concat(src[t.LONECARET], "\\s+"), true);
+    exports.caretTrimReplace = '$1^';
+    createToken('CARET', "^".concat(src[t.LONECARET]).concat(src[t.XRANGEPLAIN], "$"));
+    createToken('CARETLOOSE', "^".concat(src[t.LONECARET]).concat(src[t.XRANGEPLAINLOOSE], "$"));
+
+    // A simple gt/lt/eq thing, or just "" to indicate "any version"
+    createToken('COMPARATORLOOSE', "^".concat(src[t.GTLT], "\\s*(").concat(src[t.LOOSEPLAIN], ")$|^$"));
+    createToken('COMPARATOR', "^".concat(src[t.GTLT], "\\s*(").concat(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`
+    createToken('COMPARATORTRIM', "(\\s*)".concat(src[t.GTLT], "\\s*(").concat(src[t.LOOSEPLAIN], "|").concat(src[t.XRANGEPLAIN], ")"), true);
+    exports.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.
+    createToken('HYPHENRANGE', "^\\s*(".concat(src[t.XRANGEPLAIN], ")") + "\\s+-\\s+" + "(".concat(src[t.XRANGEPLAIN], ")") + "\\s*$");
+    createToken('HYPHENRANGELOOSE', "^\\s*(".concat(src[t.XRANGEPLAINLOOSE], ")") + "\\s+-\\s+" + "(".concat(src[t.XRANGEPLAINLOOSE], ")") + "\\s*$");
+
+    // Star ranges basically just allow anything at all.
+    createToken('STAR', '(<|>)?=?\\s*\\*');
+    // >=0.0.0 is like a star
+    createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$');
+    createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$');
+  })(re, re.exports);
+  return re.exports;
 }
 
 var identifiers;
 var hasRequiredIdentifiers;
-
-function requireIdentifiers () {
-	if (hasRequiredIdentifiers) return identifiers;
-	hasRequiredIdentifiers = 1;
-
-	const numeric = /^[0-9]+$/;
-	const compareIdentifiers = (a, b) => {
-	  const anum = numeric.test(a);
-	  const bnum = numeric.test(b);
-
-	  if (anum && bnum) {
-	    a = +a;
-	    b = +b;
-	  }
-
-	  return a === b ? 0
-	    : (anum && !bnum) ? -1
-	    : (bnum && !anum) ? 1
-	    : a < b ? -1
-	    : 1
-	};
-
-	const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
-
-	identifiers = {
-	  compareIdentifiers,
-	  rcompareIdentifiers,
-	};
-	return identifiers;
+function requireIdentifiers() {
+  if (hasRequiredIdentifiers) return identifiers;
+  hasRequiredIdentifiers = 1;
+  const numeric = /^[0-9]+$/;
+  const compareIdentifiers = (a, b) => {
+    const anum = numeric.test(a);
+    const bnum = numeric.test(b);
+    if (anum && bnum) {
+      a = +a;
+      b = +b;
+    }
+    return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+  };
+  const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+  identifiers = {
+    compareIdentifiers,
+    rcompareIdentifiers
+  };
+  return identifiers;
 }
 
 var semver;
 var hasRequiredSemver;
+function requireSemver() {
+  if (hasRequiredSemver) return semver;
+  hasRequiredSemver = 1;
+  const debug = requireDebug();
+  const {
+    MAX_LENGTH,
+    MAX_SAFE_INTEGER
+  } = requireConstants();
+  const {
+    safeRe: re,
+    t
+  } = requireRe();
+  const parseOptions = requireParseOptions();
+  const {
+    compareIdentifiers
+  } = requireIdentifiers();
+  class SemVer {
+    constructor(version, options) {
+      options = parseOptions(options);
+      if (version instanceof SemVer) {
+        if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
+          return version;
+        } else {
+          version = version.version;
+        }
+      } else if (typeof version !== 'string') {
+        throw new TypeError("Invalid version. Must be a string. Got type \"".concat(typeof version, "\"."));
+      }
+      if (version.length > MAX_LENGTH) {
+        throw new TypeError("version is longer than ".concat(MAX_LENGTH, " characters"));
+      }
+      debug('SemVer', version, options);
+      this.options = options;
+      this.loose = !!options.loose;
+      // this isn't actually relevant for versions, but keep it so that we
+      // don't run into trouble passing this.options around.
+      this.includePrerelease = !!options.includePrerelease;
+      const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+      if (!m) {
+        throw new TypeError("Invalid Version: ".concat(version));
+      }
+      this.raw = version;
 
-function requireSemver () {
-	if (hasRequiredSemver) return semver;
-	hasRequiredSemver = 1;
-
-	const debug = requireDebug();
-	const { MAX_LENGTH, MAX_SAFE_INTEGER } = requireConstants();
-	const { safeRe: re, t } = requireRe();
-
-	const parseOptions = requireParseOptions();
-	const { compareIdentifiers } = requireIdentifiers();
-	class SemVer {
-	  constructor (version, options) {
-	    options = parseOptions(options);
-
-	    if (version instanceof SemVer) {
-	      if (version.loose === !!options.loose &&
-	        version.includePrerelease === !!options.includePrerelease) {
-	        return version
-	      } else {
-	        version = version.version;
-	      }
-	    } else if (typeof version !== 'string') {
-	      throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`)
-	    }
-
-	    if (version.length > MAX_LENGTH) {
-	      throw new TypeError(
-	        `version is longer than ${MAX_LENGTH} characters`
-	      )
-	    }
-
-	    debug('SemVer', version, options);
-	    this.options = options;
-	    this.loose = !!options.loose;
-	    // this isn't actually relevant for versions, but keep it so that we
-	    // don't run into trouble passing this.options around.
-	    this.includePrerelease = !!options.includePrerelease;
-
-	    const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
-
-	    if (!m) {
-	      throw new TypeError(`Invalid Version: ${version}`)
-	    }
-
-	    this.raw = version;
-
-	    // these are actually numbers
-	    this.major = +m[1];
-	    this.minor = +m[2];
-	    this.patch = +m[3];
-
-	    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
-	      throw new TypeError('Invalid major version')
-	    }
-
-	    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
-	      throw new TypeError('Invalid minor version')
-	    }
-
-	    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
-	      throw new TypeError('Invalid patch version')
-	    }
-
-	    // numberify any prerelease numeric ids
-	    if (!m[4]) {
-	      this.prerelease = [];
-	    } else {
-	      this.prerelease = m[4].split('.').map((id) => {
-	        if (/^[0-9]+$/.test(id)) {
-	          const num = +id;
-	          if (num >= 0 && num < MAX_SAFE_INTEGER) {
-	            return num
-	          }
-	        }
-	        return id
-	      });
-	    }
-
-	    this.build = m[5] ? m[5].split('.') : [];
-	    this.format();
-	  }
-
-	  format () {
-	    this.version = `${this.major}.${this.minor}.${this.patch}`;
-	    if (this.prerelease.length) {
-	      this.version += `-${this.prerelease.join('.')}`;
-	    }
-	    return this.version
-	  }
-
-	  toString () {
-	    return this.version
-	  }
-
-	  compare (other) {
-	    debug('SemVer.compare', this.version, this.options, other);
-	    if (!(other instanceof SemVer)) {
-	      if (typeof other === 'string' && other === this.version) {
-	        return 0
-	      }
-	      other = new SemVer(other, this.options);
-	    }
-
-	    if (other.version === this.version) {
-	      return 0
-	    }
-
-	    return this.compareMain(other) || this.comparePre(other)
-	  }
-
-	  compareMain (other) {
-	    if (!(other instanceof SemVer)) {
-	      other = new SemVer(other, this.options);
-	    }
-
-	    return (
-	      compareIdentifiers(this.major, other.major) ||
-	      compareIdentifiers(this.minor, other.minor) ||
-	      compareIdentifiers(this.patch, other.patch)
-	    )
-	  }
-
-	  comparePre (other) {
-	    if (!(other instanceof SemVer)) {
-	      other = new SemVer(other, this.options);
-	    }
-
-	    // NOT having a prerelease is > having one
-	    if (this.prerelease.length && !other.prerelease.length) {
-	      return -1
-	    } else if (!this.prerelease.length && other.prerelease.length) {
-	      return 1
-	    } else if (!this.prerelease.length && !other.prerelease.length) {
-	      return 0
-	    }
-
-	    let i = 0;
-	    do {
-	      const a = this.prerelease[i];
-	      const b = other.prerelease[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)
-	  }
-
-	  compareBuild (other) {
-	    if (!(other instanceof SemVer)) {
-	      other = new SemVer(other, this.options);
-	    }
-
-	    let i = 0;
-	    do {
-	      const a = this.build[i];
-	      const b = other.build[i];
-	      debug('build 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.
-	  inc (release, identifier, identifierBase) {
-	    if (release.startsWith('pre')) {
-	      if (!identifier && identifierBase === false) {
-	        throw new Error('invalid increment argument: identifier is empty')
-	      }
-	      // Avoid an invalid semver results
-	      if (identifier) {
-	        const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
-	        if (!match || match[1] !== identifier) {
-	          throw new Error(`invalid identifier: ${identifier}`)
-	        }
-	      }
-	    }
+      // these are actually numbers
+      this.major = +m[1];
+      this.minor = +m[2];
+      this.patch = +m[3];
+      if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+        throw new TypeError('Invalid major version');
+      }
+      if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+        throw new TypeError('Invalid minor version');
+      }
+      if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+        throw new TypeError('Invalid patch version');
+      }
 
-	    switch (release) {
-	      case 'premajor':
-	        this.prerelease.length = 0;
-	        this.patch = 0;
-	        this.minor = 0;
-	        this.major++;
-	        this.inc('pre', identifier, identifierBase);
-	        break
-	      case 'preminor':
-	        this.prerelease.length = 0;
-	        this.patch = 0;
-	        this.minor++;
-	        this.inc('pre', identifier, identifierBase);
-	        break
-	      case 'prepatch':
-	        // If this is already a prerelease, it will bump to the next version
-	        // drop any prereleases that might already exist, since they are not
-	        // relevant at this point.
-	        this.prerelease.length = 0;
-	        this.inc('patch', identifier, identifierBase);
-	        this.inc('pre', identifier, identifierBase);
-	        break
-	      // If the input is a non-prerelease version, this acts the same as
-	      // prepatch.
-	      case 'prerelease':
-	        if (this.prerelease.length === 0) {
-	          this.inc('patch', identifier, identifierBase);
-	        }
-	        this.inc('pre', identifier, identifierBase);
-	        break
-	      case 'release':
-	        if (this.prerelease.length === 0) {
-	          throw new Error(`version ${this.raw} is not a prerelease`)
-	        }
-	        this.prerelease.length = 0;
-	        break
-
-	      case 'major':
-	        // If this is a pre-major version, bump up to the same major version.
-	        // Otherwise increment major.
-	        // 1.0.0-5 bumps to 1.0.0
-	        // 1.1.0 bumps to 2.0.0
-	        if (
-	          this.minor !== 0 ||
-	          this.patch !== 0 ||
-	          this.prerelease.length === 0
-	        ) {
-	          this.major++;
-	        }
-	        this.minor = 0;
-	        this.patch = 0;
-	        this.prerelease = [];
-	        break
-	      case 'minor':
-	        // If this is a pre-minor version, bump up to the same minor version.
-	        // Otherwise increment minor.
-	        // 1.2.0-5 bumps to 1.2.0
-	        // 1.2.1 bumps to 1.3.0
-	        if (this.patch !== 0 || this.prerelease.length === 0) {
-	          this.minor++;
-	        }
-	        this.patch = 0;
-	        this.prerelease = [];
-	        break
-	      case 'patch':
-	        // If this is not a pre-release version, it will increment the patch.
-	        // If it is a pre-release it will bump up to the same patch version.
-	        // 1.2.0-5 patches to 1.2.0
-	        // 1.2.0 patches to 1.2.1
-	        if (this.prerelease.length === 0) {
-	          this.patch++;
-	        }
-	        this.prerelease = [];
-	        break
-	      // This probably shouldn't be used publicly.
-	      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
-	      case 'pre': {
-	        const base = Number(identifierBase) ? 1 : 0;
-
-	        if (this.prerelease.length === 0) {
-	          this.prerelease = [base];
-	        } else {
-	          let i = this.prerelease.length;
-	          while (--i >= 0) {
-	            if (typeof this.prerelease[i] === 'number') {
-	              this.prerelease[i]++;
-	              i = -2;
-	            }
-	          }
-	          if (i === -1) {
-	            // didn't increment anything
-	            if (identifier === this.prerelease.join('.') && identifierBase === false) {
-	              throw new Error('invalid increment argument: identifier already exists')
-	            }
-	            this.prerelease.push(base);
-	          }
-	        }
-	        if (identifier) {
-	          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
-	          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
-	          let prerelease = [identifier, base];
-	          if (identifierBase === false) {
-	            prerelease = [identifier];
-	          }
-	          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
-	            if (isNaN(this.prerelease[1])) {
-	              this.prerelease = prerelease;
-	            }
-	          } else {
-	            this.prerelease = prerelease;
-	          }
-	        }
-	        break
-	      }
-	      default:
-	        throw new Error(`invalid increment argument: ${release}`)
-	    }
-	    this.raw = this.format();
-	    if (this.build.length) {
-	      this.raw += `+${this.build.join('.')}`;
-	    }
-	    return this
-	  }
-	}
+      // numberify any prerelease numeric ids
+      if (!m[4]) {
+        this.prerelease = [];
+      } else {
+        this.prerelease = m[4].split('.').map(id => {
+          if (/^[0-9]+$/.test(id)) {
+            const num = +id;
+            if (num >= 0 && num < MAX_SAFE_INTEGER) {
+              return num;
+            }
+          }
+          return id;
+        });
+      }
+      this.build = m[5] ? m[5].split('.') : [];
+      this.format();
+    }
+    format() {
+      this.version = "".concat(this.major, ".").concat(this.minor, ".").concat(this.patch);
+      if (this.prerelease.length) {
+        this.version += "-".concat(this.prerelease.join('.'));
+      }
+      return this.version;
+    }
+    toString() {
+      return this.version;
+    }
+    compare(other) {
+      debug('SemVer.compare', this.version, this.options, other);
+      if (!(other instanceof SemVer)) {
+        if (typeof other === 'string' && other === this.version) {
+          return 0;
+        }
+        other = new SemVer(other, this.options);
+      }
+      if (other.version === this.version) {
+        return 0;
+      }
+      return this.compareMain(other) || this.comparePre(other);
+    }
+    compareMain(other) {
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+      return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
+    }
+    comparePre(other) {
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+
+      // NOT having a prerelease is > having one
+      if (this.prerelease.length && !other.prerelease.length) {
+        return -1;
+      } else if (!this.prerelease.length && other.prerelease.length) {
+        return 1;
+      } else if (!this.prerelease.length && !other.prerelease.length) {
+        return 0;
+      }
+      let i = 0;
+      do {
+        const a = this.prerelease[i];
+        const b = other.prerelease[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);
+    }
+    compareBuild(other) {
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+      let i = 0;
+      do {
+        const a = this.build[i];
+        const b = other.build[i];
+        debug('build 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);
+    }
 
-	semver = SemVer;
-	return semver;
+    // preminor will bump the version up to the next minor release, and immediately
+    // down to pre-release. premajor and prepatch work the same way.
+    inc(release, identifier, identifierBase) {
+      if (release.startsWith('pre')) {
+        if (!identifier && identifierBase === false) {
+          throw new Error('invalid increment argument: identifier is empty');
+        }
+        // Avoid an invalid semver results
+        if (identifier) {
+          const match = "-".concat(identifier).match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
+          if (!match || match[1] !== identifier) {
+            throw new Error("invalid identifier: ".concat(identifier));
+          }
+        }
+      }
+      switch (release) {
+        case 'premajor':
+          this.prerelease.length = 0;
+          this.patch = 0;
+          this.minor = 0;
+          this.major++;
+          this.inc('pre', identifier, identifierBase);
+          break;
+        case 'preminor':
+          this.prerelease.length = 0;
+          this.patch = 0;
+          this.minor++;
+          this.inc('pre', identifier, identifierBase);
+          break;
+        case 'prepatch':
+          // If this is already a prerelease, it will bump to the next version
+          // drop any prereleases that might already exist, since they are not
+          // relevant at this point.
+          this.prerelease.length = 0;
+          this.inc('patch', identifier, identifierBase);
+          this.inc('pre', identifier, identifierBase);
+          break;
+        // If the input is a non-prerelease version, this acts the same as
+        // prepatch.
+        case 'prerelease':
+          if (this.prerelease.length === 0) {
+            this.inc('patch', identifier, identifierBase);
+          }
+          this.inc('pre', identifier, identifierBase);
+          break;
+        case 'release':
+          if (this.prerelease.length === 0) {
+            throw new Error("version ".concat(this.raw, " is not a prerelease"));
+          }
+          this.prerelease.length = 0;
+          break;
+        case 'major':
+          // If this is a pre-major version, bump up to the same major version.
+          // Otherwise increment major.
+          // 1.0.0-5 bumps to 1.0.0
+          // 1.1.0 bumps to 2.0.0
+          if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+            this.major++;
+          }
+          this.minor = 0;
+          this.patch = 0;
+          this.prerelease = [];
+          break;
+        case 'minor':
+          // If this is a pre-minor version, bump up to the same minor version.
+          // Otherwise increment minor.
+          // 1.2.0-5 bumps to 1.2.0
+          // 1.2.1 bumps to 1.3.0
+          if (this.patch !== 0 || this.prerelease.length === 0) {
+            this.minor++;
+          }
+          this.patch = 0;
+          this.prerelease = [];
+          break;
+        case 'patch':
+          // If this is not a pre-release version, it will increment the patch.
+          // If it is a pre-release it will bump up to the same patch version.
+          // 1.2.0-5 patches to 1.2.0
+          // 1.2.0 patches to 1.2.1
+          if (this.prerelease.length === 0) {
+            this.patch++;
+          }
+          this.prerelease = [];
+          break;
+        // This probably shouldn't be used publicly.
+        // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+        case 'pre':
+          {
+            const base = Number(identifierBase) ? 1 : 0;
+            if (this.prerelease.length === 0) {
+              this.prerelease = [base];
+            } else {
+              let i = this.prerelease.length;
+              while (--i >= 0) {
+                if (typeof this.prerelease[i] === 'number') {
+                  this.prerelease[i]++;
+                  i = -2;
+                }
+              }
+              if (i === -1) {
+                // didn't increment anything
+                if (identifier === this.prerelease.join('.') && identifierBase === false) {
+                  throw new Error('invalid increment argument: identifier already exists');
+                }
+                this.prerelease.push(base);
+              }
+            }
+            if (identifier) {
+              // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+              // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+              let prerelease = [identifier, base];
+              if (identifierBase === false) {
+                prerelease = [identifier];
+              }
+              if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+                if (isNaN(this.prerelease[1])) {
+                  this.prerelease = prerelease;
+                }
+              } else {
+                this.prerelease = prerelease;
+              }
+            }
+            break;
+          }
+        default:
+          throw new Error("invalid increment argument: ".concat(release));
+      }
+      this.raw = this.format();
+      if (this.build.length) {
+        this.raw += "+".concat(this.build.join('.'));
+      }
+      return this;
+    }
+  }
+  semver = SemVer;
+  return semver;
 }
 
 var compare_1;
 var hasRequiredCompare;
-
-function requireCompare () {
-	if (hasRequiredCompare) return compare_1;
-	hasRequiredCompare = 1;
-
-	const SemVer = requireSemver();
-	const compare = (a, b, loose) =>
-	  new SemVer(a, loose).compare(new SemVer(b, loose));
-
-	compare_1 = compare;
-	return compare_1;
+function requireCompare() {
+  if (hasRequiredCompare) return compare_1;
+  hasRequiredCompare = 1;
+  const SemVer = requireSemver();
+  const compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+  compare_1 = compare;
+  return compare_1;
 }
 
 var eq_1;
 var hasRequiredEq;
-
-function requireEq () {
-	if (hasRequiredEq) return eq_1;
-	hasRequiredEq = 1;
-
-	const compare = requireCompare();
-	const eq = (a, b, loose) => compare(a, b, loose) === 0;
-	eq_1 = eq;
-	return eq_1;
+function requireEq() {
+  if (hasRequiredEq) return eq_1;
+  hasRequiredEq = 1;
+  const compare = requireCompare();
+  const eq = (a, b, loose) => compare(a, b, loose) === 0;
+  eq_1 = eq;
+  return eq_1;
 }
 
 var neq_1;
 var hasRequiredNeq;
-
-function requireNeq () {
-	if (hasRequiredNeq) return neq_1;
-	hasRequiredNeq = 1;
-
-	const compare = requireCompare();
-	const neq = (a, b, loose) => compare(a, b, loose) !== 0;
-	neq_1 = neq;
-	return neq_1;
+function requireNeq() {
+  if (hasRequiredNeq) return neq_1;
+  hasRequiredNeq = 1;
+  const compare = requireCompare();
+  const neq = (a, b, loose) => compare(a, b, loose) !== 0;
+  neq_1 = neq;
+  return neq_1;
 }
 
 var gt_1;
 var hasRequiredGt;
-
-function requireGt () {
-	if (hasRequiredGt) return gt_1;
-	hasRequiredGt = 1;
-
-	const compare = requireCompare();
-	const gt = (a, b, loose) => compare(a, b, loose) > 0;
-	gt_1 = gt;
-	return gt_1;
+function requireGt() {
+  if (hasRequiredGt) return gt_1;
+  hasRequiredGt = 1;
+  const compare = requireCompare();
+  const gt = (a, b, loose) => compare(a, b, loose) > 0;
+  gt_1 = gt;
+  return gt_1;
 }
 
 var gte_1;
 var hasRequiredGte;
-
-function requireGte () {
-	if (hasRequiredGte) return gte_1;
-	hasRequiredGte = 1;
-
-	const compare = requireCompare();
-	const gte = (a, b, loose) => compare(a, b, loose) >= 0;
-	gte_1 = gte;
-	return gte_1;
+function requireGte() {
+  if (hasRequiredGte) return gte_1;
+  hasRequiredGte = 1;
+  const compare = requireCompare();
+  const gte = (a, b, loose) => compare(a, b, loose) >= 0;
+  gte_1 = gte;
+  return gte_1;
 }
 
 var lt_1;
 var hasRequiredLt;
-
-function requireLt () {
-	if (hasRequiredLt) return lt_1;
-	hasRequiredLt = 1;
-
-	const compare = requireCompare();
-	const lt = (a, b, loose) => compare(a, b, loose) < 0;
-	lt_1 = lt;
-	return lt_1;
+function requireLt() {
+  if (hasRequiredLt) return lt_1;
+  hasRequiredLt = 1;
+  const compare = requireCompare();
+  const lt = (a, b, loose) => compare(a, b, loose) < 0;
+  lt_1 = lt;
+  return lt_1;
 }
 
 var lte_1;
 var hasRequiredLte;
-
-function requireLte () {
-	if (hasRequiredLte) return lte_1;
-	hasRequiredLte = 1;
-
-	const compare = requireCompare();
-	const lte = (a, b, loose) => compare(a, b, loose) <= 0;
-	lte_1 = lte;
-	return lte_1;
+function requireLte() {
+  if (hasRequiredLte) return lte_1;
+  hasRequiredLte = 1;
+  const compare = requireCompare();
+  const lte = (a, b, loose) => compare(a, b, loose) <= 0;
+  lte_1 = lte;
+  return lte_1;
 }
 
 var cmp_1;
 var hasRequiredCmp;
-
-function requireCmp () {
-	if (hasRequiredCmp) return cmp_1;
-	hasRequiredCmp = 1;
-
-	const eq = requireEq();
-	const neq = requireNeq();
-	const gt = requireGt();
-	const gte = requireGte();
-	const lt = requireLt();
-	const lte = requireLte();
-
-	const cmp = (a, op, b, loose) => {
-	  switch (op) {
-	    case '===':
-	      if (typeof a === 'object') {
-	        a = a.version;
-	      }
-	      if (typeof b === 'object') {
-	        b = b.version;
-	      }
-	      return a === b
-
-	    case '!==':
-	      if (typeof a === 'object') {
-	        a = a.version;
-	      }
-	      if (typeof b === 'object') {
-	        b = b.version;
-	      }
-	      return a !== b
-
-	    case '':
-	    case '=':
-	    case '==':
-	      return eq(a, b, loose)
-
-	    case '!=':
-	      return neq(a, b, loose)
-
-	    case '>':
-	      return gt(a, b, loose)
-
-	    case '>=':
-	      return gte(a, b, loose)
-
-	    case '<':
-	      return lt(a, b, loose)
-
-	    case '<=':
-	      return lte(a, b, loose)
-
-	    default:
-	      throw new TypeError(`Invalid operator: ${op}`)
-	  }
-	};
-	cmp_1 = cmp;
-	return cmp_1;
-}
+function requireCmp() {
+  if (hasRequiredCmp) return cmp_1;
+  hasRequiredCmp = 1;
+  const eq = requireEq();
+  const neq = requireNeq();
+  const gt = requireGt();
+  const gte = requireGte();
+  const lt = requireLt();
+  const lte = requireLte();
+  const cmp = (a, op, b, loose) => {
+    switch (op) {
+      case '===':
+        if (typeof a === 'object') {
+          a = a.version;
+        }
+        if (typeof b === 'object') {
+          b = b.version;
+        }
+        return a === b;
+      case '!==':
+        if (typeof a === 'object') {
+          a = a.version;
+        }
+        if (typeof b === 'object') {
+          b = b.version;
+        }
+        return a !== b;
+      case '':
+      case '=':
+      case '==':
+        return eq(a, b, loose);
+      case '!=':
+        return neq(a, b, loose);
+      case '>':
+        return gt(a, b, loose);
+      case '>=':
+        return gte(a, b, loose);
+      case '<':
+        return lt(a, b, loose);
+      case '<=':
+        return lte(a, b, loose);
+      default:
+        throw new TypeError("Invalid operator: ".concat(op));
+    }
+  };
+  cmp_1 = cmp;
+  return cmp_1;
+}
 
 var comparator;
 var hasRequiredComparator;
+function requireComparator() {
+  if (hasRequiredComparator) return comparator;
+  hasRequiredComparator = 1;
+  const ANY = Symbol('SemVer ANY');
+  // hoisted class for cyclic dependency
+  class Comparator {
+    static get ANY() {
+      return ANY;
+    }
+    constructor(comp, options) {
+      options = parseOptions(options);
+      if (comp instanceof Comparator) {
+        if (comp.loose === !!options.loose) {
+          return comp;
+        } else {
+          comp = comp.value;
+        }
+      }
+      comp = comp.trim().split(/\s+/).join(' ');
+      debug('comparator', comp, options);
+      this.options = options;
+      this.loose = !!options.loose;
+      this.parse(comp);
+      if (this.semver === ANY) {
+        this.value = '';
+      } else {
+        this.value = this.operator + this.semver.version;
+      }
+      debug('comp', this);
+    }
+    parse(comp) {
+      const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+      const m = comp.match(r);
+      if (!m) {
+        throw new TypeError("Invalid comparator: ".concat(comp));
+      }
+      this.operator = m[1] !== undefined ? m[1] : '';
+      if (this.operator === '=') {
+        this.operator = '';
+      }
 
-function requireComparator () {
-	if (hasRequiredComparator) return comparator;
-	hasRequiredComparator = 1;
-
-	const ANY = Symbol('SemVer ANY');
-	// hoisted class for cyclic dependency
-	class Comparator {
-	  static get ANY () {
-	    return ANY
-	  }
-
-	  constructor (comp, options) {
-	    options = parseOptions(options);
-
-	    if (comp instanceof Comparator) {
-	      if (comp.loose === !!options.loose) {
-	        return comp
-	      } else {
-	        comp = comp.value;
-	      }
-	    }
-
-	    comp = comp.trim().split(/\s+/).join(' ');
-	    debug('comparator', comp, options);
-	    this.options = options;
-	    this.loose = !!options.loose;
-	    this.parse(comp);
-
-	    if (this.semver === ANY) {
-	      this.value = '';
-	    } else {
-	      this.value = this.operator + this.semver.version;
-	    }
-
-	    debug('comp', this);
-	  }
-
-	  parse (comp) {
-	    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
-	    const m = comp.match(r);
-
-	    if (!m) {
-	      throw new TypeError(`Invalid comparator: ${comp}`)
-	    }
-
-	    this.operator = m[1] !== undefined ? m[1] : '';
-	    if (this.operator === '=') {
-	      this.operator = '';
-	    }
-
-	    // if it literally is just '>' or '' then allow anything.
-	    if (!m[2]) {
-	      this.semver = ANY;
-	    } else {
-	      this.semver = new SemVer(m[2], this.options.loose);
-	    }
-	  }
-
-	  toString () {
-	    return this.value
-	  }
-
-	  test (version) {
-	    debug('Comparator.test', version, this.options.loose);
-
-	    if (this.semver === ANY || version === ANY) {
-	      return true
-	    }
-
-	    if (typeof version === 'string') {
-	      try {
-	        version = new SemVer(version, this.options);
-	      } catch (er) {
-	        return false
-	      }
-	    }
-
-	    return cmp(version, this.operator, this.semver, this.options)
-	  }
-
-	  intersects (comp, options) {
-	    if (!(comp instanceof Comparator)) {
-	      throw new TypeError('a Comparator is required')
-	    }
-
-	    if (this.operator === '') {
-	      if (this.value === '') {
-	        return true
-	      }
-	      return new Range(comp.value, options).test(this.value)
-	    } else if (comp.operator === '') {
-	      if (comp.value === '') {
-	        return true
-	      }
-	      return new Range(this.value, options).test(comp.semver)
-	    }
-
-	    options = parseOptions(options);
-
-	    // Special cases where nothing can possibly be lower
-	    if (options.includePrerelease &&
-	      (this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {
-	      return false
-	    }
-	    if (!options.includePrerelease &&
-	      (this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {
-	      return false
-	    }
-
-	    // Same direction increasing (> or >=)
-	    if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {
-	      return true
-	    }
-	    // Same direction decreasing (< or <=)
-	    if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {
-	      return true
-	    }
-	    // same SemVer and both sides are inclusive (<= or >=)
-	    if (
-	      (this.semver.version === comp.semver.version) &&
-	      this.operator.includes('=') && comp.operator.includes('=')) {
-	      return true
-	    }
-	    // opposite directions less than
-	    if (cmp(this.semver, '<', comp.semver, options) &&
-	      this.operator.startsWith('>') && comp.operator.startsWith('<')) {
-	      return true
-	    }
-	    // opposite directions greater than
-	    if (cmp(this.semver, '>', comp.semver, options) &&
-	      this.operator.startsWith('<') && comp.operator.startsWith('>')) {
-	      return true
-	    }
-	    return false
-	  }
-	}
+      // if it literally is just '>' or '' then allow anything.
+      if (!m[2]) {
+        this.semver = ANY;
+      } else {
+        this.semver = new SemVer(m[2], this.options.loose);
+      }
+    }
+    toString() {
+      return this.value;
+    }
+    test(version) {
+      debug('Comparator.test', version, this.options.loose);
+      if (this.semver === ANY || version === ANY) {
+        return true;
+      }
+      if (typeof version === 'string') {
+        try {
+          version = new SemVer(version, this.options);
+        } catch (er) {
+          return false;
+        }
+      }
+      return cmp(version, this.operator, this.semver, this.options);
+    }
+    intersects(comp, options) {
+      if (!(comp instanceof Comparator)) {
+        throw new TypeError('a Comparator is required');
+      }
+      if (this.operator === '') {
+        if (this.value === '') {
+          return true;
+        }
+        return new Range(comp.value, options).test(this.value);
+      } else if (comp.operator === '') {
+        if (comp.value === '') {
+          return true;
+        }
+        return new Range(this.value, options).test(comp.semver);
+      }
+      options = parseOptions(options);
 
-	comparator = Comparator;
+      // Special cases where nothing can possibly be lower
+      if (options.includePrerelease && (this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {
+        return false;
+      }
+      if (!options.includePrerelease && (this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {
+        return false;
+      }
 
-	const parseOptions = requireParseOptions();
-	const { safeRe: re, t } = requireRe();
-	const cmp = requireCmp();
-	const debug = requireDebug();
-	const SemVer = requireSemver();
-	const Range = requireRange();
-	return comparator;
+      // Same direction increasing (> or >=)
+      if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {
+        return true;
+      }
+      // Same direction decreasing (< or <=)
+      if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {
+        return true;
+      }
+      // same SemVer and both sides are inclusive (<= or >=)
+      if (this.semver.version === comp.semver.version && this.operator.includes('=') && comp.operator.includes('=')) {
+        return true;
+      }
+      // opposite directions less than
+      if (cmp(this.semver, '<', comp.semver, options) && this.operator.startsWith('>') && comp.operator.startsWith('<')) {
+        return true;
+      }
+      // opposite directions greater than
+      if (cmp(this.semver, '>', comp.semver, options) && this.operator.startsWith('<') && comp.operator.startsWith('>')) {
+        return true;
+      }
+      return false;
+    }
+  }
+  comparator = Comparator;
+  const parseOptions = requireParseOptions();
+  const {
+    safeRe: re,
+    t
+  } = requireRe();
+  const cmp = requireCmp();
+  const debug = requireDebug();
+  const SemVer = requireSemver();
+  const Range = requireRange();
+  return comparator;
 }
 
 var range;
 var hasRequiredRange;
+function requireRange() {
+  if (hasRequiredRange) return range;
+  hasRequiredRange = 1;
+  const SPACE_CHARACTERS = /\s+/g;
+
+  // hoisted class for cyclic dependency
+  class Range {
+    constructor(range, options) {
+      options = parseOptions(options);
+      if (range instanceof Range) {
+        if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+          return range;
+        } else {
+          return new Range(range.raw, options);
+        }
+      }
+      if (range instanceof Comparator) {
+        // just put it in the set and return
+        this.raw = range.value;
+        this.set = [[range]];
+        this.formatted = undefined;
+        return this;
+      }
+      this.options = options;
+      this.loose = !!options.loose;
+      this.includePrerelease = !!options.includePrerelease;
+
+      // First reduce all whitespace as much as possible so we do not have to rely
+      // on potentially slow regexes like \s*. This is then stored and used for
+      // future error messages as well.
+      this.raw = range.trim().replace(SPACE_CHARACTERS, ' ');
+
+      // First, split on ||
+      this.set = this.raw.split('||')
+      // map the range to a 2d array of comparators
+      .map(r => this.parseRange(r.trim()))
+      // throw out any comparator lists that are empty
+      // this generally means that it was not a valid range, which is allowed
+      // in loose mode, but will still throw if the WHOLE range is invalid.
+      .filter(c => c.length);
+      if (!this.set.length) {
+        throw new TypeError("Invalid SemVer Range: ".concat(this.raw));
+      }
+
+      // if we have any that are not the null set, throw out null sets.
+      if (this.set.length > 1) {
+        // keep the first one, in case they're all null sets
+        const first = this.set[0];
+        this.set = this.set.filter(c => !isNullSet(c[0]));
+        if (this.set.length === 0) {
+          this.set = [first];
+        } else if (this.set.length > 1) {
+          // if we have any that are *, then the range is just *
+          for (const c of this.set) {
+            if (c.length === 1 && isAny(c[0])) {
+              this.set = [c];
+              break;
+            }
+          }
+        }
+      }
+      this.formatted = undefined;
+    }
+    get range() {
+      if (this.formatted === undefined) {
+        this.formatted = '';
+        for (let i = 0; i < this.set.length; i++) {
+          if (i > 0) {
+            this.formatted += '||';
+          }
+          const comps = this.set[i];
+          for (let k = 0; k < comps.length; k++) {
+            if (k > 0) {
+              this.formatted += ' ';
+            }
+            this.formatted += comps[k].toString().trim();
+          }
+        }
+      }
+      return this.formatted;
+    }
+    format() {
+      return this.range;
+    }
+    toString() {
+      return this.range;
+    }
+    parseRange(range) {
+      // memoize range parsing for performance.
+      // this is a very hot path, and fully deterministic.
+      const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+      const memoKey = memoOpts + ':' + range;
+      const cached = cache.get(memoKey);
+      if (cached) {
+        return cached;
+      }
+      const loose = this.options.loose;
+      // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+      const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+      range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+      debug('hyphen replace', range);
+
+      // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+      range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+      debug('comparator trim', range);
+
+      // `~ 1.2.3` => `~1.2.3`
+      range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+      debug('tilde trim', range);
+
+      // `^ 1.2.3` => `^1.2.3`
+      range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+      debug('caret trim', range);
+
+      // At this point, the range is completely trimmed and
+      // ready to be split into comparators.
+
+      let rangeList = range.split(' ').map(comp => parseComparator(comp, this.options)).join(' ').split(/\s+/)
+      // >=0.0.0 is equivalent to *
+      .map(comp => replaceGTE0(comp, this.options));
+      if (loose) {
+        // in loose mode, throw out any that are not valid comparators
+        rangeList = rangeList.filter(comp => {
+          debug('loose invalid filter', comp, this.options);
+          return !!comp.match(re[t.COMPARATORLOOSE]);
+        });
+      }
+      debug('range list', rangeList);
 
-function requireRange () {
-	if (hasRequiredRange) return range;
-	hasRequiredRange = 1;
-
-	const SPACE_CHARACTERS = /\s+/g;
-
-	// hoisted class for cyclic dependency
-	class Range {
-	  constructor (range, options) {
-	    options = parseOptions(options);
-
-	    if (range instanceof Range) {
-	      if (
-	        range.loose === !!options.loose &&
-	        range.includePrerelease === !!options.includePrerelease
-	      ) {
-	        return range
-	      } else {
-	        return new Range(range.raw, options)
-	      }
-	    }
-
-	    if (range instanceof Comparator) {
-	      // just put it in the set and return
-	      this.raw = range.value;
-	      this.set = [[range]];
-	      this.formatted = undefined;
-	      return this
-	    }
-
-	    this.options = options;
-	    this.loose = !!options.loose;
-	    this.includePrerelease = !!options.includePrerelease;
-
-	    // First reduce all whitespace as much as possible so we do not have to rely
-	    // on potentially slow regexes like \s*. This is then stored and used for
-	    // future error messages as well.
-	    this.raw = range.trim().replace(SPACE_CHARACTERS, ' ');
-
-	    // First, split on ||
-	    this.set = this.raw
-	      .split('||')
-	      // map the range to a 2d array of comparators
-	      .map(r => this.parseRange(r.trim()))
-	      // throw out any comparator lists that are empty
-	      // this generally means that it was not a valid range, which is allowed
-	      // in loose mode, but will still throw if the WHOLE range is invalid.
-	      .filter(c => c.length);
-
-	    if (!this.set.length) {
-	      throw new TypeError(`Invalid SemVer Range: ${this.raw}`)
-	    }
-
-	    // if we have any that are not the null set, throw out null sets.
-	    if (this.set.length > 1) {
-	      // keep the first one, in case they're all null sets
-	      const first = this.set[0];
-	      this.set = this.set.filter(c => !isNullSet(c[0]));
-	      if (this.set.length === 0) {
-	        this.set = [first];
-	      } else if (this.set.length > 1) {
-	        // if we have any that are *, then the range is just *
-	        for (const c of this.set) {
-	          if (c.length === 1 && isAny(c[0])) {
-	            this.set = [c];
-	            break
-	          }
-	        }
-	      }
-	    }
-
-	    this.formatted = undefined;
-	  }
-
-	  get range () {
-	    if (this.formatted === undefined) {
-	      this.formatted = '';
-	      for (let i = 0; i < this.set.length; i++) {
-	        if (i > 0) {
-	          this.formatted += '||';
-	        }
-	        const comps = this.set[i];
-	        for (let k = 0; k < comps.length; k++) {
-	          if (k > 0) {
-	            this.formatted += ' ';
-	          }
-	          this.formatted += comps[k].toString().trim();
-	        }
-	      }
-	    }
-	    return this.formatted
-	  }
-
-	  format () {
-	    return this.range
-	  }
-
-	  toString () {
-	    return this.range
-	  }
-
-	  parseRange (range) {
-	    // memoize range parsing for performance.
-	    // this is a very hot path, and fully deterministic.
-	    const memoOpts =
-	      (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) |
-	      (this.options.loose && FLAG_LOOSE);
-	    const memoKey = memoOpts + ':' + range;
-	    const cached = cache.get(memoKey);
-	    if (cached) {
-	      return cached
-	    }
-
-	    const loose = this.options.loose;
-	    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
-	    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
-	    range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
-	    debug('hyphen replace', range);
-
-	    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
-	    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
-	    debug('comparator trim', range);
-
-	    // `~ 1.2.3` => `~1.2.3`
-	    range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
-	    debug('tilde trim', range);
-
-	    // `^ 1.2.3` => `^1.2.3`
-	    range = range.replace(re[t.CARETTRIM], caretTrimReplace);
-	    debug('caret trim', range);
-
-	    // At this point, the range is completely trimmed and
-	    // ready to be split into comparators.
-
-	    let rangeList = range
-	      .split(' ')
-	      .map(comp => parseComparator(comp, this.options))
-	      .join(' ')
-	      .split(/\s+/)
-	      // >=0.0.0 is equivalent to *
-	      .map(comp => replaceGTE0(comp, this.options));
-
-	    if (loose) {
-	      // in loose mode, throw out any that are not valid comparators
-	      rangeList = rangeList.filter(comp => {
-	        debug('loose invalid filter', comp, this.options);
-	        return !!comp.match(re[t.COMPARATORLOOSE])
-	      });
-	    }
-	    debug('range list', rangeList);
-
-	    // if any comparators are the null set, then replace with JUST null set
-	    // if more than one comparator, remove any * comparators
-	    // also, don't include the same comparator more than once
-	    const rangeMap = new Map();
-	    const comparators = rangeList.map(comp => new Comparator(comp, this.options));
-	    for (const comp of comparators) {
-	      if (isNullSet(comp)) {
-	        return [comp]
-	      }
-	      rangeMap.set(comp.value, comp);
-	    }
-	    if (rangeMap.size > 1 && rangeMap.has('')) {
-	      rangeMap.delete('');
-	    }
-
-	    const result = [...rangeMap.values()];
-	    cache.set(memoKey, result);
-	    return result
-	  }
-
-	  intersects (range, options) {
-	    if (!(range instanceof Range)) {
-	      throw new TypeError('a Range is required')
-	    }
-
-	    return this.set.some((thisComparators) => {
-	      return (
-	        isSatisfiable(thisComparators, options) &&
-	        range.set.some((rangeComparators) => {
-	          return (
-	            isSatisfiable(rangeComparators, options) &&
-	            thisComparators.every((thisComparator) => {
-	              return rangeComparators.every((rangeComparator) => {
-	                return thisComparator.intersects(rangeComparator, options)
-	              })
-	            })
-	          )
-	        })
-	      )
-	    })
-	  }
-
-	  // if ANY of the sets match ALL of its comparators, then pass
-	  test (version) {
-	    if (!version) {
-	      return false
-	    }
-
-	    if (typeof version === 'string') {
-	      try {
-	        version = new SemVer(version, this.options);
-	      } catch (er) {
-	        return false
-	      }
-	    }
-
-	    for (let i = 0; i < this.set.length; i++) {
-	      if (testSet(this.set[i], version, this.options)) {
-	        return true
-	      }
-	    }
-	    return false
-	  }
-	}
-
-	range = Range;
-
-	const LRU = requireLrucache();
-	const cache = new LRU();
-
-	const parseOptions = requireParseOptions();
-	const Comparator = requireComparator();
-	const debug = requireDebug();
-	const SemVer = requireSemver();
-	const {
-	  safeRe: re,
-	  t,
-	  comparatorTrimReplace,
-	  tildeTrimReplace,
-	  caretTrimReplace,
-	} = requireRe();
-	const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = requireConstants();
-
-	const isNullSet = c => c.value === '<0.0.0-0';
-	const isAny = c => c.value === '';
-
-	// take a set of comparators and determine whether there
-	// exists a version which can satisfy it
-	const isSatisfiable = (comparators, options) => {
-	  let result = true;
-	  const remainingComparators = comparators.slice();
-	  let testComparator = remainingComparators.pop();
-
-	  while (result && remainingComparators.length) {
-	    result = remainingComparators.every((otherComparator) => {
-	      return testComparator.intersects(otherComparator, options)
-	    });
-
-	    testComparator = remainingComparators.pop();
-	  }
-
-	  return result
-	};
-
-	// comprised of xranges, tildes, stars, and gtlt's at this point.
-	// already replaced the hyphen ranges
-	// turn into a set of JUST comparators.
-	const parseComparator = (comp, options) => {
-	  debug('comp', comp, options);
-	  comp = replaceCarets(comp, options);
-	  debug('caret', comp);
-	  comp = replaceTildes(comp, options);
-	  debug('tildes', comp);
-	  comp = replaceXRanges(comp, options);
-	  debug('xrange', comp);
-	  comp = replaceStars(comp, options);
-	  debug('stars', comp);
-	  return comp
-	};
-
-	const isX = id => !id || id.toLowerCase() === 'x' || id === '*';
-
-	// ~, ~> --> * (any, kinda silly)
-	// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
-	// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
-	// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
-	// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
-	// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
-	// ~0.0.1 --> >=0.0.1 <0.1.0-0
-	const replaceTildes = (comp, options) => {
-	  return comp
-	    .trim()
-	    .split(/\s+/)
-	    .map((c) => replaceTilde(c, options))
-	    .join(' ')
-	};
-
-	const replaceTilde = (comp, options) => {
-	  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
-	  return comp.replace(r, (_, M, m, p, pr) => {
-	    debug('tilde', comp, _, M, m, p, pr);
-	    let ret;
-
-	    if (isX(M)) {
-	      ret = '';
-	    } else if (isX(m)) {
-	      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
-	    } else if (isX(p)) {
-	      // ~1.2 == >=1.2.0 <1.3.0-0
-	      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
-	    } else if (pr) {
-	      debug('replaceTilde pr', pr);
-	      ret = `>=${M}.${m}.${p}-${pr
-	      } <${M}.${+m + 1}.0-0`;
-	    } else {
-	      // ~1.2.3 == >=1.2.3 <1.3.0-0
-	      ret = `>=${M}.${m}.${p
-	      } <${M}.${+m + 1}.0-0`;
-	    }
-
-	    debug('tilde return', ret);
-	    return ret
-	  })
-	};
-
-	// ^ --> * (any, kinda silly)
-	// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
-	// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
-	// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
-	// ^1.2.3 --> >=1.2.3 <2.0.0-0
-	// ^1.2.0 --> >=1.2.0 <2.0.0-0
-	// ^0.0.1 --> >=0.0.1 <0.0.2-0
-	// ^0.1.0 --> >=0.1.0 <0.2.0-0
-	const replaceCarets = (comp, options) => {
-	  return comp
-	    .trim()
-	    .split(/\s+/)
-	    .map((c) => replaceCaret(c, options))
-	    .join(' ')
-	};
-
-	const replaceCaret = (comp, options) => {
-	  debug('caret', comp, options);
-	  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
-	  const z = options.includePrerelease ? '-0' : '';
-	  return comp.replace(r, (_, M, m, p, pr) => {
-	    debug('caret', comp, _, M, m, p, pr);
-	    let ret;
-
-	    if (isX(M)) {
-	      ret = '';
-	    } else if (isX(m)) {
-	      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
-	    } else if (isX(p)) {
-	      if (M === '0') {
-	        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
-	      } else {
-	        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
-	      }
-	    } else if (pr) {
-	      debug('replaceCaret pr', pr);
-	      if (M === '0') {
-	        if (m === '0') {
-	          ret = `>=${M}.${m}.${p}-${pr
-	          } <${M}.${m}.${+p + 1}-0`;
-	        } else {
-	          ret = `>=${M}.${m}.${p}-${pr
-	          } <${M}.${+m + 1}.0-0`;
-	        }
-	      } else {
-	        ret = `>=${M}.${m}.${p}-${pr
-	        } <${+M + 1}.0.0-0`;
-	      }
-	    } else {
-	      debug('no pr');
-	      if (M === '0') {
-	        if (m === '0') {
-	          ret = `>=${M}.${m}.${p
-	          }${z} <${M}.${m}.${+p + 1}-0`;
-	        } else {
-	          ret = `>=${M}.${m}.${p
-	          }${z} <${M}.${+m + 1}.0-0`;
-	        }
-	      } else {
-	        ret = `>=${M}.${m}.${p
-	        } <${+M + 1}.0.0-0`;
-	      }
-	    }
-
-	    debug('caret return', ret);
-	    return ret
-	  })
-	};
-
-	const replaceXRanges = (comp, options) => {
-	  debug('replaceXRanges', comp, options);
-	  return comp
-	    .split(/\s+/)
-	    .map((c) => replaceXRange(c, options))
-	    .join(' ')
-	};
-
-	const replaceXRange = (comp, options) => {
-	  comp = comp.trim();
-	  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
-	  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
-	    debug('xRange', comp, ret, gtlt, M, m, p, pr);
-	    const xM = isX(M);
-	    const xm = xM || isX(m);
-	    const xp = xm || isX(p);
-	    const anyX = xp;
-
-	    if (gtlt === '=' && anyX) {
-	      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-0';
-	      } else {
-	        // nothing is forbidden
-	        ret = '*';
-	      }
-	    } else if (gtlt && anyX) {
-	      // we know patch is an x, because we have any x at all.
-	      // replace X with 0
-	      if (xm) {
-	        m = 0;
-	      }
-	      p = 0;
-
-	      if (gtlt === '>') {
-	        // >1 => >=2.0.0
-	        // >1.2 => >=1.3.0
-	        gtlt = '>=';
-	        if (xm) {
-	          M = +M + 1;
-	          m = 0;
-	          p = 0;
-	        } else {
-	          m = +m + 1;
-	          p = 0;
-	        }
-	      } else if (gtlt === '<=') {
-	        // <=0.7.x is actually <0.8.0, since any 0.7.x should
-	        // pass.  Similarly, <=7.x is actually <8.0.0, etc.
-	        gtlt = '<';
-	        if (xm) {
-	          M = +M + 1;
-	        } else {
-	          m = +m + 1;
-	        }
-	      }
-
-	      if (gtlt === '<') {
-	        pr = '-0';
-	      }
-
-	      ret = `${gtlt + M}.${m}.${p}${pr}`;
-	    } else if (xm) {
-	      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
-	    } else if (xp) {
-	      ret = `>=${M}.${m}.0${pr
-	      } <${M}.${+m + 1}.0-0`;
-	    }
-
-	    debug('xRange return', ret);
-
-	    return ret
-	  })
-	};
-
-	// Because * is AND-ed with everything else in the comparator,
-	// and '' means "any version", just remove the *s entirely.
-	const replaceStars = (comp, options) => {
-	  debug('replaceStars', comp, options);
-	  // Looseness is ignored here.  star is always as loose as it gets!
-	  return comp
-	    .trim()
-	    .replace(re[t.STAR], '')
-	};
-
-	const replaceGTE0 = (comp, options) => {
-	  debug('replaceGTE0', comp, options);
-	  return comp
-	    .trim()
-	    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')
-	};
-
-	// 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-0 Any 3.4.x will do
-	// 1.2 - 3.4 => >=1.2.0 <3.5.0-0
-	// TODO build?
-	const hyphenReplace = incPr => ($0,
-	  from, fM, fm, fp, fpr, fb,
-	  to, tM, tm, tp, tpr) => {
-	  if (isX(fM)) {
-	    from = '';
-	  } else if (isX(fm)) {
-	    from = `>=${fM}.0.0${incPr ? '-0' : ''}`;
-	  } else if (isX(fp)) {
-	    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`;
-	  } else if (fpr) {
-	    from = `>=${from}`;
-	  } else {
-	    from = `>=${from}${incPr ? '-0' : ''}`;
-	  }
-
-	  if (isX(tM)) {
-	    to = '';
-	  } else if (isX(tm)) {
-	    to = `<${+tM + 1}.0.0-0`;
-	  } else if (isX(tp)) {
-	    to = `<${tM}.${+tm + 1}.0-0`;
-	  } else if (tpr) {
-	    to = `<=${tM}.${tm}.${tp}-${tpr}`;
-	  } else if (incPr) {
-	    to = `<${tM}.${tm}.${+tp + 1}-0`;
-	  } else {
-	    to = `<=${to}`;
-	  }
+      // if any comparators are the null set, then replace with JUST null set
+      // if more than one comparator, remove any * comparators
+      // also, don't include the same comparator more than once
+      const rangeMap = new Map();
+      const comparators = rangeList.map(comp => new Comparator(comp, this.options));
+      for (const comp of comparators) {
+        if (isNullSet(comp)) {
+          return [comp];
+        }
+        rangeMap.set(comp.value, comp);
+      }
+      if (rangeMap.size > 1 && rangeMap.has('')) {
+        rangeMap.delete('');
+      }
+      const result = [...rangeMap.values()];
+      cache.set(memoKey, result);
+      return result;
+    }
+    intersects(range, options) {
+      if (!(range instanceof Range)) {
+        throw new TypeError('a Range is required');
+      }
+      return this.set.some(thisComparators => {
+        return isSatisfiable(thisComparators, options) && range.set.some(rangeComparators => {
+          return isSatisfiable(rangeComparators, options) && thisComparators.every(thisComparator => {
+            return rangeComparators.every(rangeComparator => {
+              return thisComparator.intersects(rangeComparator, options);
+            });
+          });
+        });
+      });
+    }
 
-	  return `${from} ${to}`.trim()
-	};
+    // if ANY of the sets match ALL of its comparators, then pass
+    test(version) {
+      if (!version) {
+        return false;
+      }
+      if (typeof version === 'string') {
+        try {
+          version = new SemVer(version, this.options);
+        } catch (er) {
+          return false;
+        }
+      }
+      for (let i = 0; i < this.set.length; i++) {
+        if (testSet(this.set[i], version, this.options)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+  range = Range;
+  const LRU = requireLrucache();
+  const cache = new LRU();
+  const parseOptions = requireParseOptions();
+  const Comparator = requireComparator();
+  const debug = requireDebug();
+  const SemVer = requireSemver();
+  const {
+    safeRe: re,
+    t,
+    comparatorTrimReplace,
+    tildeTrimReplace,
+    caretTrimReplace
+  } = requireRe();
+  const {
+    FLAG_INCLUDE_PRERELEASE,
+    FLAG_LOOSE
+  } = requireConstants();
+  const isNullSet = c => c.value === '<0.0.0-0';
+  const isAny = c => c.value === '';
+
+  // take a set of comparators and determine whether there
+  // exists a version which can satisfy it
+  const isSatisfiable = (comparators, options) => {
+    let result = true;
+    const remainingComparators = comparators.slice();
+    let testComparator = remainingComparators.pop();
+    while (result && remainingComparators.length) {
+      result = remainingComparators.every(otherComparator => {
+        return testComparator.intersects(otherComparator, options);
+      });
+      testComparator = remainingComparators.pop();
+    }
+    return result;
+  };
 
-	const testSet = (set, version, options) => {
-	  for (let i = 0; i < set.length; i++) {
-	    if (!set[i].test(version)) {
-	      return false
-	    }
-	  }
+  // comprised of xranges, tildes, stars, and gtlt's at this point.
+  // already replaced the hyphen ranges
+  // turn into a set of JUST comparators.
+  const parseComparator = (comp, options) => {
+    debug('comp', comp, options);
+    comp = replaceCarets(comp, options);
+    debug('caret', comp);
+    comp = replaceTildes(comp, options);
+    debug('tildes', comp);
+    comp = replaceXRanges(comp, options);
+    debug('xrange', comp);
+    comp = replaceStars(comp, options);
+    debug('stars', comp);
+    return comp;
+  };
+  const isX = id => !id || id.toLowerCase() === 'x' || id === '*';
+
+  // ~, ~> --> * (any, kinda silly)
+  // ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
+  // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
+  // ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
+  // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
+  // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
+  // ~0.0.1 --> >=0.0.1 <0.1.0-0
+  const replaceTildes = (comp, options) => {
+    return comp.trim().split(/\s+/).map(c => replaceTilde(c, options)).join(' ');
+  };
+  const replaceTilde = (comp, options) => {
+    const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+    return comp.replace(r, (_, M, m, p, pr) => {
+      debug('tilde', comp, _, M, m, p, pr);
+      let ret;
+      if (isX(M)) {
+        ret = '';
+      } else if (isX(m)) {
+        ret = ">=".concat(M, ".0.0 <").concat(+M + 1, ".0.0-0");
+      } else if (isX(p)) {
+        // ~1.2 == >=1.2.0 <1.3.0-0
+        ret = ">=".concat(M, ".").concat(m, ".0 <").concat(M, ".").concat(+m + 1, ".0-0");
+      } else if (pr) {
+        debug('replaceTilde pr', pr);
+        ret = ">=".concat(M, ".").concat(m, ".").concat(p, "-").concat(pr, " <").concat(M, ".").concat(+m + 1, ".0-0");
+      } else {
+        // ~1.2.3 == >=1.2.3 <1.3.0-0
+        ret = ">=".concat(M, ".").concat(m, ".").concat(p, " <").concat(M, ".").concat(+m + 1, ".0-0");
+      }
+      debug('tilde return', ret);
+      return ret;
+    });
+  };
 
-	  if (version.prerelease.length && !options.includePrerelease) {
-	    // Find the set of versions that are allowed to have prereleases
-	    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
-	    // That should allow `1.2.3-pr.2` to pass.
-	    // However, `1.2.4-alpha.notready` should NOT be allowed,
-	    // even though it's within the range set by the comparators.
-	    for (let i = 0; i < set.length; i++) {
-	      debug(set[i].semver);
-	      if (set[i].semver === Comparator.ANY) {
-	        continue
-	      }
+  // ^ --> * (any, kinda silly)
+  // ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
+  // ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
+  // ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
+  // ^1.2.3 --> >=1.2.3 <2.0.0-0
+  // ^1.2.0 --> >=1.2.0 <2.0.0-0
+  // ^0.0.1 --> >=0.0.1 <0.0.2-0
+  // ^0.1.0 --> >=0.1.0 <0.2.0-0
+  const replaceCarets = (comp, options) => {
+    return comp.trim().split(/\s+/).map(c => replaceCaret(c, options)).join(' ');
+  };
+  const replaceCaret = (comp, options) => {
+    debug('caret', comp, options);
+    const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+    const z = options.includePrerelease ? '-0' : '';
+    return comp.replace(r, (_, M, m, p, pr) => {
+      debug('caret', comp, _, M, m, p, pr);
+      let ret;
+      if (isX(M)) {
+        ret = '';
+      } else if (isX(m)) {
+        ret = ">=".concat(M, ".0.0").concat(z, " <").concat(+M + 1, ".0.0-0");
+      } else if (isX(p)) {
+        if (M === '0') {
+          ret = ">=".concat(M, ".").concat(m, ".0").concat(z, " <").concat(M, ".").concat(+m + 1, ".0-0");
+        } else {
+          ret = ">=".concat(M, ".").concat(m, ".0").concat(z, " <").concat(+M + 1, ".0.0-0");
+        }
+      } else if (pr) {
+        debug('replaceCaret pr', pr);
+        if (M === '0') {
+          if (m === '0') {
+            ret = ">=".concat(M, ".").concat(m, ".").concat(p, "-").concat(pr, " <").concat(M, ".").concat(m, ".").concat(+p + 1, "-0");
+          } else {
+            ret = ">=".concat(M, ".").concat(m, ".").concat(p, "-").concat(pr, " <").concat(M, ".").concat(+m + 1, ".0-0");
+          }
+        } else {
+          ret = ">=".concat(M, ".").concat(m, ".").concat(p, "-").concat(pr, " <").concat(+M + 1, ".0.0-0");
+        }
+      } else {
+        debug('no pr');
+        if (M === '0') {
+          if (m === '0') {
+            ret = ">=".concat(M, ".").concat(m, ".").concat(p).concat(z, " <").concat(M, ".").concat(m, ".").concat(+p + 1, "-0");
+          } else {
+            ret = ">=".concat(M, ".").concat(m, ".").concat(p).concat(z, " <").concat(M, ".").concat(+m + 1, ".0-0");
+          }
+        } else {
+          ret = ">=".concat(M, ".").concat(m, ".").concat(p, " <").concat(+M + 1, ".0.0-0");
+        }
+      }
+      debug('caret return', ret);
+      return ret;
+    });
+  };
+  const replaceXRanges = (comp, options) => {
+    debug('replaceXRanges', comp, options);
+    return comp.split(/\s+/).map(c => replaceXRange(c, options)).join(' ');
+  };
+  const replaceXRange = (comp, options) => {
+    comp = comp.trim();
+    const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+    return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+      debug('xRange', comp, ret, gtlt, M, m, p, pr);
+      const xM = isX(M);
+      const xm = xM || isX(m);
+      const xp = xm || isX(p);
+      const anyX = xp;
+      if (gtlt === '=' && anyX) {
+        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-0';
+        } else {
+          // nothing is forbidden
+          ret = '*';
+        }
+      } else if (gtlt && anyX) {
+        // we know patch is an x, because we have any x at all.
+        // replace X with 0
+        if (xm) {
+          m = 0;
+        }
+        p = 0;
+        if (gtlt === '>') {
+          // >1 => >=2.0.0
+          // >1.2 => >=1.3.0
+          gtlt = '>=';
+          if (xm) {
+            M = +M + 1;
+            m = 0;
+            p = 0;
+          } else {
+            m = +m + 1;
+            p = 0;
+          }
+        } else if (gtlt === '<=') {
+          // <=0.7.x is actually <0.8.0, since any 0.7.x should
+          // pass.  Similarly, <=7.x is actually <8.0.0, etc.
+          gtlt = '<';
+          if (xm) {
+            M = +M + 1;
+          } else {
+            m = +m + 1;
+          }
+        }
+        if (gtlt === '<') {
+          pr = '-0';
+        }
+        ret = "".concat(gtlt + M, ".").concat(m, ".").concat(p).concat(pr);
+      } else if (xm) {
+        ret = ">=".concat(M, ".0.0").concat(pr, " <").concat(+M + 1, ".0.0-0");
+      } else if (xp) {
+        ret = ">=".concat(M, ".").concat(m, ".0").concat(pr, " <").concat(M, ".").concat(+m + 1, ".0-0");
+      }
+      debug('xRange return', ret);
+      return ret;
+    });
+  };
 
-	      if (set[i].semver.prerelease.length > 0) {
-	        const allowed = set[i].semver;
-	        if (allowed.major === version.major &&
-	            allowed.minor === version.minor &&
-	            allowed.patch === version.patch) {
-	          return true
-	        }
-	      }
-	    }
+  // Because * is AND-ed with everything else in the comparator,
+  // and '' means "any version", just remove the *s entirely.
+  const replaceStars = (comp, options) => {
+    debug('replaceStars', comp, options);
+    // Looseness is ignored here.  star is always as loose as it gets!
+    return comp.trim().replace(re[t.STAR], '');
+  };
+  const replaceGTE0 = (comp, options) => {
+    debug('replaceGTE0', comp, options);
+    return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '');
+  };
 
-	    // Version has a -pre, but it's not one of the ones we like.
-	    return false
-	  }
+  // 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-0 Any 3.4.x will do
+  // 1.2 - 3.4 => >=1.2.0 <3.5.0-0
+  // TODO build?
+  const hyphenReplace = incPr => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+    if (isX(fM)) {
+      from = '';
+    } else if (isX(fm)) {
+      from = ">=".concat(fM, ".0.0").concat(incPr ? '-0' : '');
+    } else if (isX(fp)) {
+      from = ">=".concat(fM, ".").concat(fm, ".0").concat(incPr ? '-0' : '');
+    } else if (fpr) {
+      from = ">=".concat(from);
+    } else {
+      from = ">=".concat(from).concat(incPr ? '-0' : '');
+    }
+    if (isX(tM)) {
+      to = '';
+    } else if (isX(tm)) {
+      to = "<".concat(+tM + 1, ".0.0-0");
+    } else if (isX(tp)) {
+      to = "<".concat(tM, ".").concat(+tm + 1, ".0-0");
+    } else if (tpr) {
+      to = "<=".concat(tM, ".").concat(tm, ".").concat(tp, "-").concat(tpr);
+    } else if (incPr) {
+      to = "<".concat(tM, ".").concat(tm, ".").concat(+tp + 1, "-0");
+    } else {
+      to = "<=".concat(to);
+    }
+    return "".concat(from, " ").concat(to).trim();
+  };
+  const testSet = (set, version, options) => {
+    for (let i = 0; i < set.length; i++) {
+      if (!set[i].test(version)) {
+        return false;
+      }
+    }
+    if (version.prerelease.length && !options.includePrerelease) {
+      // Find the set of versions that are allowed to have prereleases
+      // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+      // That should allow `1.2.3-pr.2` to pass.
+      // However, `1.2.4-alpha.notready` should NOT be allowed,
+      // even though it's within the range set by the comparators.
+      for (let i = 0; i < set.length; i++) {
+        debug(set[i].semver);
+        if (set[i].semver === Comparator.ANY) {
+          continue;
+        }
+        if (set[i].semver.prerelease.length > 0) {
+          const allowed = set[i].semver;
+          if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
+            return true;
+          }
+        }
+      }
 
-	  return true
-	};
-	return range;
+      // Version has a -pre, but it's not one of the ones we like.
+      return false;
+    }
+    return true;
+  };
+  return range;
 }
 
 var satisfies_1;
 var hasRequiredSatisfies;
-
-function requireSatisfies () {
-	if (hasRequiredSatisfies) return satisfies_1;
-	hasRequiredSatisfies = 1;
-
-	const Range = requireRange();
-	const satisfies = (version, range, options) => {
-	  try {
-	    range = new Range(range, options);
-	  } catch (er) {
-	    return false
-	  }
-	  return range.test(version)
-	};
-	satisfies_1 = satisfies;
-	return satisfies_1;
+function requireSatisfies() {
+  if (hasRequiredSatisfies) return satisfies_1;
+  hasRequiredSatisfies = 1;
+  const Range = requireRange();
+  const satisfies = (version, range, options) => {
+    try {
+      range = new Range(range, options);
+    } catch (er) {
+      return false;
+    }
+    return range.test(version);
+  };
+  satisfies_1 = satisfies;
+  return satisfies_1;
 }
 
 var satisfiesExports = requireSatisfies();