@platform/react.ssr/src.sample/ui/.cache/f6/bfa9949c06dd622dbf1bf993b48607.json

A lightweight SSR (server-side-rendering) system for react apps bundled with ParcelJS and hosted on S3.

{"id":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","dependencies":[{"name":"/Users/phil/code/@platform/code/react.ssr/sample/ui/.uiharness/package.json","includedInParent":true,"mtime":1566550465515},{"name":"/Users/phil/code/@platform/code/react.ssr/sample/ui/node_modules/@platform/util.value/node_modules/semver/package.json","includedInParent":true,"mtime":1564041359023},{"name":"process","parent":"/Users/phil/code/@platform/code/react.ssr/sample/ui/node_modules/@platform/util.value/node_modules/semver/semver.js","resolved":"/Users/phil/code/@platform/code/react.ssr/sample/ui/node_modules/process/browser.js"}],"generated":{"js":"var process = require(\"process\");\nexports = module.exports = SemVer;\nvar debug;\n/* istanbul ignore next */\n\nif (typeof process === 'object' && process.env && undefined && /\\bsemver\\b/i.test(undefined)) {\n  debug = function () {\n    var args = Array.prototype.slice.call(arguments, 0);\n    args.unshift('SEMVER');\n    console.log.apply(console, args);\n  };\n} else {\n  debug = function () {};\n} // Note: this is the semver.org version of the spec that it implements\n// Not necessarily the package version of this code.\n\n\nexports.SEMVER_SPEC_VERSION = '2.0.0';\nvar MAX_LENGTH = 256;\nvar MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||\n/* istanbul ignore next */\n9007199254740991; // Max safe segment length for coercion.\n\nvar MAX_SAFE_COMPONENT_LENGTH = 16; // The actual regexps go on exports.re\n\nvar re = exports.re = [];\nvar src = exports.src = [];\nvar t = exports.tokens = {};\nvar R = 0;\n\nfunction tok(n) {\n  t[n] = R++;\n} // The following Regular Expressions can be used for tokenizing,\n// validating, and parsing SemVer version strings.\n// ## Numeric Identifier\n// A single `0`, or a non-zero digit followed by zero or more digits.\n\n\ntok('NUMERICIDENTIFIER');\nsrc[t.NUMERICIDENTIFIER] = '0|[1-9]\\\\d*';\ntok('NUMERICIDENTIFIERLOOSE');\nsrc[t.NUMERICIDENTIFIERLOOSE] = '[0-9]+'; // ## Non-numeric Identifier\n// Zero or more digits, followed by a letter or hyphen, and then zero or\n// more letters, digits, or hyphens.\n\ntok('NONNUMERICIDENTIFIER');\nsrc[t.NONNUMERICIDENTIFIER] = '\\\\d*[a-zA-Z-][a-zA-Z0-9-]*'; // ## Main Version\n// Three dot-separated numeric identifiers.\n\ntok('MAINVERSION');\nsrc[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\\\.' + '(' + src[t.NUMERICIDENTIFIER] + ')\\\\.' + '(' + src[t.NUMERICIDENTIFIER] + ')';\ntok('MAINVERSIONLOOSE');\nsrc[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\\\.' + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\\\.' + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')'; // ## Pre-release Version Identifier\n// A numeric identifier, or a non-numeric identifier.\n\ntok('PRERELEASEIDENTIFIER');\nsrc[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] + '|' + src[t.NONNUMERICIDENTIFIER] + ')';\ntok('PRERELEASEIDENTIFIERLOOSE');\nsrc[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] + '|' + src[t.NONNUMERICIDENTIFIER] + ')'; // ## Pre-release Version\n// Hyphen, followed by one or more dot-separated pre-release version\n// identifiers.\n\ntok('PRERELEASE');\nsrc[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] + '(?:\\\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))';\ntok('PRERELEASELOOSE');\nsrc[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] + '(?:\\\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))'; // ## Build Metadata Identifier\n// Any combination of digits, letters, or hyphens.\n\ntok('BUILDIDENTIFIER');\nsrc[t.BUILDIDENTIFIER] = '[0-9A-Za-z-]+'; // ## Build Metadata\n// Plus sign, followed by one or more period-separated build metadata\n// identifiers.\n\ntok('BUILD');\nsrc[t.BUILD] = '(?:\\\\+(' + src[t.BUILDIDENTIFIER] + '(?:\\\\.' + src[t.BUILDIDENTIFIER] + ')*))'; // ## Full Version String\n// A main version, followed optionally by a pre-release version and\n// build metadata.\n// Note that the only major, minor, patch, and pre-release sections of\n// the version string are capturing groups.  The build metadata is not a\n// capturing group, because it should not ever be used in version\n// comparison.\n\ntok('FULL');\ntok('FULLPLAIN');\nsrc[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] + src[t.PRERELEASE] + '?' + src[t.BUILD] + '?';\nsrc[t.FULL] = '^' + src[t.FULLPLAIN] + '$'; // like full, but allows v1.2.3 and =1.2.3, which people do sometimes.\n// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty\n// common in the npm registry.\n\ntok('LOOSEPLAIN');\nsrc[t.LOOSEPLAIN] = '[v=\\\\s]*' + src[t.MAINVERSIONLOOSE] + src[t.PRERELEASELOOSE] + '?' + src[t.BUILD] + '?';\ntok('LOOSE');\nsrc[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$';\ntok('GTLT');\nsrc[t.GTLT] = '((?:<|>)?=?)'; // Something like \"2.*\" or \"1.2.x\".\n// Note that \"x.x\" is a valid xRange identifer, meaning \"any version\"\n// Only the first item is strictly required.\n\ntok('XRANGEIDENTIFIERLOOSE');\nsrc[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\\\*';\ntok('XRANGEIDENTIFIER');\nsrc[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\\\*';\ntok('XRANGEPLAIN');\nsrc[t.XRANGEPLAIN] = '[v=\\\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:\\\\.(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:\\\\.(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:' + src[t.PRERELEASE] + ')?' + src[t.BUILD] + '?' + ')?)?';\ntok('XRANGEPLAINLOOSE');\nsrc[t.XRANGEPLAINLOOSE] = '[v=\\\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:' + src[t.PRERELEASELOOSE] + ')?' + src[t.BUILD] + '?' + ')?)?';\ntok('XRANGE');\nsrc[t.XRANGE] = '^' + src[t.GTLT] + '\\\\s*' + src[t.XRANGEPLAIN] + '$';\ntok('XRANGELOOSE');\nsrc[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\\\s*' + src[t.XRANGEPLAINLOOSE] + '$'; // Coercion.\n// Extract anything that could conceivably be a part of a valid semver\n\ntok('COERCE');\nsrc[t.COERCE] = '(^|[^\\\\d])' + '(\\\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' + '(?:\\\\.(\\\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + '(?:\\\\.(\\\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + '(?:$|[^\\\\d])';\ntok('COERCERTL');\nre[t.COERCERTL] = new RegExp(src[t.COERCE], 'g'); // Tilde ranges.\n// Meaning is \"reasonably at or greater than\"\n\ntok('LONETILDE');\nsrc[t.LONETILDE] = '(?:~>?)';\ntok('TILDETRIM');\nsrc[t.TILDETRIM] = '(\\\\s*)' + src[t.LONETILDE] + '\\\\s+';\nre[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g');\nvar tildeTrimReplace = '$1~';\ntok('TILDE');\nsrc[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$';\ntok('TILDELOOSE');\nsrc[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$'; // Caret ranges.\n// Meaning is \"at least and backwards compatible with\"\n\ntok('LONECARET');\nsrc[t.LONECARET] = '(?:\\\\^)';\ntok('CARETTRIM');\nsrc[t.CARETTRIM] = '(\\\\s*)' + src[t.LONECARET] + '\\\\s+';\nre[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g');\nvar caretTrimReplace = '$1^';\ntok('CARET');\nsrc[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$';\ntok('CARETLOOSE');\nsrc[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$'; // A simple gt/lt/eq thing, or just \"\" to indicate \"any version\"\n\ntok('COMPARATORLOOSE');\nsrc[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\\\s*(' + src[t.LOOSEPLAIN] + ')$|^$';\ntok('COMPARATOR');\nsrc[t.COMPARATOR] = '^' + src[t.GTLT] + '\\\\s*(' + src[t.FULLPLAIN] + ')$|^$'; // An expression to strip any whitespace between the gtlt and the thing\n// it modifies, so that `> 1.2.3` ==> `>1.2.3`\n\ntok('COMPARATORTRIM');\nsrc[t.COMPARATORTRIM] = '(\\\\s*)' + src[t.GTLT] + '\\\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')'; // this one has to use the /g flag\n\nre[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g');\nvar comparatorTrimReplace = '$1$2$3'; // Something like `1.2.3 - 1.2.4`\n// Note that these all use the loose form, because they'll be\n// checked against either the strict or loose comparator form\n// later.\n\ntok('HYPHENRANGE');\nsrc[t.HYPHENRANGE] = '^\\\\s*(' + src[t.XRANGEPLAIN] + ')' + '\\\\s+-\\\\s+' + '(' + src[t.XRANGEPLAIN] + ')' + '\\\\s*$';\ntok('HYPHENRANGELOOSE');\nsrc[t.HYPHENRANGELOOSE] = '^\\\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' + '\\\\s+-\\\\s+' + '(' + src[t.XRANGEPLAINLOOSE] + ')' + '\\\\s*$'; // Star ranges basically just allow anything at all.\n\ntok('STAR');\nsrc[t.STAR] = '(<|>)?=?\\\\s*\\\\*'; // Compile to actual regexp objects.\n// All are flag-free, unless they were created above with a flag.\n\nfor (var i = 0; i < R; i++) {\n  debug(i, src[i]);\n\n  if (!re[i]) {\n    re[i] = new RegExp(src[i]);\n  }\n}\n\nexports.parse = parse;\n\nfunction parse(version, options) {\n  if (!options || typeof options !== 'object') {\n    options = {\n      loose: !!options,\n      includePrerelease: false\n    };\n  }\n\n  if (version instanceof SemVer) {\n    return version;\n  }\n\n  if (typeof version !== 'string') {\n    return null;\n  }\n\n  if (version.length > MAX_LENGTH) {\n    return null;\n  }\n\n  var r = options.loose ? re[t.LOOSE] : re[t.FULL];\n\n  if (!r.test(version)) {\n    return null;\n  }\n\n  try {\n    return new SemVer(version, options);\n  } catch (er) {\n    return null;\n  }\n}\n\nexports.valid = valid;\n\nfunction valid(version, options) {\n  var v = parse(version, options);\n  return v ? v.version : null;\n}\n\nexports.clean = clean;\n\nfunction clean(version, options) {\n  var s = parse(version.trim().replace(/^[=v]+/, ''), options);\n  return s ? s.version : null;\n}\n\nexports.SemVer = SemVer;\n\nfunction SemVer(version, options) {\n  if (!options || typeof options !== 'object') {\n    options = {\n      loose: !!options,\n      includePrerelease: false\n    };\n  }\n\n  if (version instanceof SemVer) {\n    if (version.loose === options.loose) {\n      return version;\n    } else {\n      version = version.version;\n    }\n  } else if (typeof version !== 'string') {\n    throw new TypeError('Invalid Version: ' + version);\n  }\n\n  if (version.length > MAX_LENGTH) {\n    throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters');\n  }\n\n  if (!(this instanceof SemVer)) {\n    return new SemVer(version, options);\n  }\n\n  debug('SemVer', version, options);\n  this.options = options;\n  this.loose = !!options.loose;\n  var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);\n\n  if (!m) {\n    throw new TypeError('Invalid Version: ' + version);\n  }\n\n  this.raw = version; // these are actually numbers\n\n  this.major = +m[1];\n  this.minor = +m[2];\n  this.patch = +m[3];\n\n  if (this.major > MAX_SAFE_INTEGER || this.major < 0) {\n    throw new TypeError('Invalid major version');\n  }\n\n  if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {\n    throw new TypeError('Invalid minor version');\n  }\n\n  if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {\n    throw new TypeError('Invalid patch version');\n  } // numberify any prerelease numeric ids\n\n\n  if (!m[4]) {\n    this.prerelease = [];\n  } else {\n    this.prerelease = m[4].split('.').map(function (id) {\n      if (/^[0-9]+$/.test(id)) {\n        var num = +id;\n\n        if (num >= 0 && num < MAX_SAFE_INTEGER) {\n          return num;\n        }\n      }\n\n      return id;\n    });\n  }\n\n  this.build = m[5] ? m[5].split('.') : [];\n  this.format();\n}\n\nSemVer.prototype.format = function () {\n  this.version = this.major + '.' + this.minor + '.' + this.patch;\n\n  if (this.prerelease.length) {\n    this.version += '-' + this.prerelease.join('.');\n  }\n\n  return this.version;\n};\n\nSemVer.prototype.toString = function () {\n  return this.version;\n};\n\nSemVer.prototype.compare = function (other) {\n  debug('SemVer.compare', this.version, this.options, other);\n\n  if (!(other instanceof SemVer)) {\n    other = new SemVer(other, this.options);\n  }\n\n  return this.compareMain(other) || this.comparePre(other);\n};\n\nSemVer.prototype.compareMain = function (other) {\n  if (!(other instanceof SemVer)) {\n    other = new SemVer(other, this.options);\n  }\n\n  return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);\n};\n\nSemVer.prototype.comparePre = function (other) {\n  if (!(other instanceof SemVer)) {\n    other = new SemVer(other, this.options);\n  } // NOT having a prerelease is > having one\n\n\n  if (this.prerelease.length && !other.prerelease.length) {\n    return -1;\n  } else if (!this.prerelease.length && other.prerelease.length) {\n    return 1;\n  } else if (!this.prerelease.length && !other.prerelease.length) {\n    return 0;\n  }\n\n  var i = 0;\n\n  do {\n    var a = this.prerelease[i];\n    var b = other.prerelease[i];\n    debug('prerelease compare', i, a, b);\n\n    if (a === undefined && b === undefined) {\n      return 0;\n    } else if (b === undefined) {\n      return 1;\n    } else if (a === undefined) {\n      return -1;\n    } else if (a === b) {\n      continue;\n    } else {\n      return compareIdentifiers(a, b);\n    }\n  } while (++i);\n};\n\nSemVer.prototype.compareBuild = function (other) {\n  if (!(other instanceof SemVer)) {\n    other = new SemVer(other, this.options);\n  }\n\n  var i = 0;\n\n  do {\n    var a = this.build[i];\n    var b = other.build[i];\n    debug('prerelease compare', i, a, b);\n\n    if (a === undefined && b === undefined) {\n      return 0;\n    } else if (b === undefined) {\n      return 1;\n    } else if (a === undefined) {\n      return -1;\n    } else if (a === b) {\n      continue;\n    } else {\n      return compareIdentifiers(a, b);\n    }\n  } while (++i);\n}; // preminor will bump the version up to the next minor release, and immediately\n// down to pre-release. premajor and prepatch work the same way.\n\n\nSemVer.prototype.inc = function (release, identifier) {\n  switch (release) {\n    case 'premajor':\n      this.prerelease.length = 0;\n      this.patch = 0;\n      this.minor = 0;\n      this.major++;\n      this.inc('pre', identifier);\n      break;\n\n    case 'preminor':\n      this.prerelease.length = 0;\n      this.patch = 0;\n      this.minor++;\n      this.inc('pre', identifier);\n      break;\n\n    case 'prepatch':\n      // If this is already a prerelease, it will bump to the next version\n      // drop any prereleases that might already exist, since they are not\n      // relevant at this point.\n      this.prerelease.length = 0;\n      this.inc('patch', identifier);\n      this.inc('pre', identifier);\n      break;\n    // If the input is a non-prerelease version, this acts the same as\n    // prepatch.\n\n    case 'prerelease':\n      if (this.prerelease.length === 0) {\n        this.inc('patch', identifier);\n      }\n\n      this.inc('pre', identifier);\n      break;\n\n    case 'major':\n      // If this is a pre-major version, bump up to the same major version.\n      // Otherwise increment major.\n      // 1.0.0-5 bumps to 1.0.0\n      // 1.1.0 bumps to 2.0.0\n      if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {\n        this.major++;\n      }\n\n      this.minor = 0;\n      this.patch = 0;\n      this.prerelease = [];\n      break;\n\n    case 'minor':\n      // If this is a pre-minor version, bump up to the same minor version.\n      // Otherwise increment minor.\n      // 1.2.0-5 bumps to 1.2.0\n      // 1.2.1 bumps to 1.3.0\n      if (this.patch !== 0 || this.prerelease.length === 0) {\n        this.minor++;\n      }\n\n      this.patch = 0;\n      this.prerelease = [];\n      break;\n\n    case 'patch':\n      // If this is not a pre-release version, it will increment the patch.\n      // If it is a pre-release it will bump up to the same patch version.\n      // 1.2.0-5 patches to 1.2.0\n      // 1.2.0 patches to 1.2.1\n      if (this.prerelease.length === 0) {\n        this.patch++;\n      }\n\n      this.prerelease = [];\n      break;\n    // This probably shouldn't be used publicly.\n    // 1.0.0 \"pre\" would become 1.0.0-0 which is the wrong direction.\n\n    case 'pre':\n      if (this.prerelease.length === 0) {\n        this.prerelease = [0];\n      } else {\n        var i = this.prerelease.length;\n\n        while (--i >= 0) {\n          if (typeof this.prerelease[i] === 'number') {\n            this.prerelease[i]++;\n            i = -2;\n          }\n        }\n\n        if (i === -1) {\n          // didn't increment anything\n          this.prerelease.push(0);\n        }\n      }\n\n      if (identifier) {\n        // 1.2.0-beta.1 bumps to 1.2.0-beta.2,\n        // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0\n        if (this.prerelease[0] === identifier) {\n          if (isNaN(this.prerelease[1])) {\n            this.prerelease = [identifier, 0];\n          }\n        } else {\n          this.prerelease = [identifier, 0];\n        }\n      }\n\n      break;\n\n    default:\n      throw new Error('invalid increment argument: ' + release);\n  }\n\n  this.format();\n  this.raw = this.version;\n  return this;\n};\n\nexports.inc = inc;\n\nfunction inc(version, release, loose, identifier) {\n  if (typeof loose === 'string') {\n    identifier = loose;\n    loose = undefined;\n  }\n\n  try {\n    return new SemVer(version, loose).inc(release, identifier).version;\n  } catch (er) {\n    return null;\n  }\n}\n\nexports.diff = diff;\n\nfunction diff(version1, version2) {\n  if (eq(version1, version2)) {\n    return null;\n  } else {\n    var v1 = parse(version1);\n    var v2 = parse(version2);\n    var prefix = '';\n\n    if (v1.prerelease.length || v2.prerelease.length) {\n      prefix = 'pre';\n      var defaultResult = 'prerelease';\n    }\n\n    for (var key in v1) {\n      if (key === 'major' || key === 'minor' || key === 'patch') {\n        if (v1[key] !== v2[key]) {\n          return prefix + key;\n        }\n      }\n    }\n\n    return defaultResult; // may be undefined\n  }\n}\n\nexports.compareIdentifiers = compareIdentifiers;\nvar numeric = /^[0-9]+$/;\n\nfunction compareIdentifiers(a, b) {\n  var anum = numeric.test(a);\n  var bnum = numeric.test(b);\n\n  if (anum && bnum) {\n    a = +a;\n    b = +b;\n  }\n\n  return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;\n}\n\nexports.rcompareIdentifiers = rcompareIdentifiers;\n\nfunction rcompareIdentifiers(a, b) {\n  return compareIdentifiers(b, a);\n}\n\nexports.major = major;\n\nfunction major(a, loose) {\n  return new SemVer(a, loose).major;\n}\n\nexports.minor = minor;\n\nfunction minor(a, loose) {\n  return new SemVer(a, loose).minor;\n}\n\nexports.patch = patch;\n\nfunction patch(a, loose) {\n  return new SemVer(a, loose).patch;\n}\n\nexports.compare = compare;\n\nfunction compare(a, b, loose) {\n  return new SemVer(a, loose).compare(new SemVer(b, loose));\n}\n\nexports.compareLoose = compareLoose;\n\nfunction compareLoose(a, b) {\n  return compare(a, b, true);\n}\n\nexports.compareBuild = compareBuild;\n\nfunction compareBuild(a, b, loose) {\n  var versionA = new SemVer(a, loose);\n  var versionB = new SemVer(b, loose);\n  return versionA.compare(versionB) || versionA.compareBuild(versionB);\n}\n\nexports.rcompare = rcompare;\n\nfunction rcompare(a, b, loose) {\n  return compare(b, a, loose);\n}\n\nexports.sort = sort;\n\nfunction sort(list, loose) {\n  return list.sort(function (a, b) {\n    return exports.compareBuild(a, b, loose);\n  });\n}\n\nexports.rsort = rsort;\n\nfunction rsort(list, loose) {\n  return list.sort(function (a, b) {\n    return exports.compareBuild(b, a, loose);\n  });\n}\n\nexports.gt = gt;\n\nfunction gt(a, b, loose) {\n  return compare(a, b, loose) > 0;\n}\n\nexports.lt = lt;\n\nfunction lt(a, b, loose) {\n  return compare(a, b, loose) < 0;\n}\n\nexports.eq = eq;\n\nfunction eq(a, b, loose) {\n  return compare(a, b, loose) === 0;\n}\n\nexports.neq = neq;\n\nfunction neq(a, b, loose) {\n  return compare(a, b, loose) !== 0;\n}\n\nexports.gte = gte;\n\nfunction gte(a, b, loose) {\n  return compare(a, b, loose) >= 0;\n}\n\nexports.lte = lte;\n\nfunction lte(a, b, loose) {\n  return compare(a, b, loose) <= 0;\n}\n\nexports.cmp = cmp;\n\nfunction cmp(a, op, b, loose) {\n  switch (op) {\n    case '===':\n      if (typeof a === 'object') a = a.version;\n      if (typeof b === 'object') b = b.version;\n      return a === b;\n\n    case '!==':\n      if (typeof a === 'object') a = a.version;\n      if (typeof b === 'object') b = b.version;\n      return a !== b;\n\n    case '':\n    case '=':\n    case '==':\n      return eq(a, b, loose);\n\n    case '!=':\n      return neq(a, b, loose);\n\n    case '>':\n      return gt(a, b, loose);\n\n    case '>=':\n      return gte(a, b, loose);\n\n    case '<':\n      return lt(a, b, loose);\n\n    case '<=':\n      return lte(a, b, loose);\n\n    default:\n      throw new TypeError('Invalid operator: ' + op);\n  }\n}\n\nexports.Comparator = Comparator;\n\nfunction Comparator(comp, options) {\n  if (!options || typeof options !== 'object') {\n    options = {\n      loose: !!options,\n      includePrerelease: false\n    };\n  }\n\n  if (comp instanceof Comparator) {\n    if (comp.loose === !!options.loose) {\n      return comp;\n    } else {\n      comp = comp.value;\n    }\n  }\n\n  if (!(this instanceof Comparator)) {\n    return new Comparator(comp, options);\n  }\n\n  debug('comparator', comp, options);\n  this.options = options;\n  this.loose = !!options.loose;\n  this.parse(comp);\n\n  if (this.semver === ANY) {\n    this.value = '';\n  } else {\n    this.value = this.operator + this.semver.version;\n  }\n\n  debug('comp', this);\n}\n\nvar ANY = {};\n\nComparator.prototype.parse = function (comp) {\n  var r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];\n  var m = comp.match(r);\n\n  if (!m) {\n    throw new TypeError('Invalid comparator: ' + comp);\n  }\n\n  this.operator = m[1] !== undefined ? m[1] : '';\n\n  if (this.operator === '=') {\n    this.operator = '';\n  } // if it literally is just '>' or '' then allow anything.\n\n\n  if (!m[2]) {\n    this.semver = ANY;\n  } else {\n    this.semver = new SemVer(m[2], this.options.loose);\n  }\n};\n\nComparator.prototype.toString = function () {\n  return this.value;\n};\n\nComparator.prototype.test = function (version) {\n  debug('Comparator.test', version, this.options.loose);\n\n  if (this.semver === ANY || version === ANY) {\n    return true;\n  }\n\n  if (typeof version === 'string') {\n    try {\n      version = new SemVer(version, this.options);\n    } catch (er) {\n      return false;\n    }\n  }\n\n  return cmp(version, this.operator, this.semver, this.options);\n};\n\nComparator.prototype.intersects = function (comp, options) {\n  if (!(comp instanceof Comparator)) {\n    throw new TypeError('a Comparator is required');\n  }\n\n  if (!options || typeof options !== 'object') {\n    options = {\n      loose: !!options,\n      includePrerelease: false\n    };\n  }\n\n  var rangeTmp;\n\n  if (this.operator === '') {\n    if (this.value === '') {\n      return true;\n    }\n\n    rangeTmp = new Range(comp.value, options);\n    return satisfies(this.value, rangeTmp, options);\n  } else if (comp.operator === '') {\n    if (comp.value === '') {\n      return true;\n    }\n\n    rangeTmp = new Range(this.value, options);\n    return satisfies(comp.semver, rangeTmp, options);\n  }\n\n  var sameDirectionIncreasing = (this.operator === '>=' || this.operator === '>') && (comp.operator === '>=' || comp.operator === '>');\n  var sameDirectionDecreasing = (this.operator === '<=' || this.operator === '<') && (comp.operator === '<=' || comp.operator === '<');\n  var sameSemVer = this.semver.version === comp.semver.version;\n  var differentDirectionsInclusive = (this.operator === '>=' || this.operator === '<=') && (comp.operator === '>=' || comp.operator === '<=');\n  var oppositeDirectionsLessThan = cmp(this.semver, '<', comp.semver, options) && (this.operator === '>=' || this.operator === '>') && (comp.operator === '<=' || comp.operator === '<');\n  var oppositeDirectionsGreaterThan = cmp(this.semver, '>', comp.semver, options) && (this.operator === '<=' || this.operator === '<') && (comp.operator === '>=' || comp.operator === '>');\n  return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;\n};\n\nexports.Range = Range;\n\nfunction Range(range, options) {\n  if (!options || typeof options !== 'object') {\n    options = {\n      loose: !!options,\n      includePrerelease: false\n    };\n  }\n\n  if (range instanceof Range) {\n    if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {\n      return range;\n    } else {\n      return new Range(range.raw, options);\n    }\n  }\n\n  if (range instanceof Comparator) {\n    return new Range(range.value, options);\n  }\n\n  if (!(this instanceof Range)) {\n    return new Range(range, options);\n  }\n\n  this.options = options;\n  this.loose = !!options.loose;\n  this.includePrerelease = !!options.includePrerelease; // First, split based on boolean or ||\n\n  this.raw = range;\n  this.set = range.split(/\\s*\\|\\|\\s*/).map(function (range) {\n    return this.parseRange(range.trim());\n  }, this).filter(function (c) {\n    // throw out any that are not relevant for whatever reason\n    return c.length;\n  });\n\n  if (!this.set.length) {\n    throw new TypeError('Invalid SemVer Range: ' + range);\n  }\n\n  this.format();\n}\n\nRange.prototype.format = function () {\n  this.range = this.set.map(function (comps) {\n    return comps.join(' ').trim();\n  }).join('||').trim();\n  return this.range;\n};\n\nRange.prototype.toString = function () {\n  return this.range;\n};\n\nRange.prototype.parseRange = function (range) {\n  var loose = this.options.loose;\n  range = range.trim(); // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`\n\n  var hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];\n  range = range.replace(hr, hyphenReplace);\n  debug('hyphen replace', range); // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`\n\n  range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);\n  debug('comparator trim', range, re[t.COMPARATORTRIM]); // `~ 1.2.3` => `~1.2.3`\n\n  range = range.replace(re[t.TILDETRIM], tildeTrimReplace); // `^ 1.2.3` => `^1.2.3`\n\n  range = range.replace(re[t.CARETTRIM], caretTrimReplace); // normalize spaces\n\n  range = range.split(/\\s+/).join(' '); // At this point, the range is completely trimmed and\n  // ready to be split into comparators.\n\n  var compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];\n  var set = range.split(' ').map(function (comp) {\n    return parseComparator(comp, this.options);\n  }, this).join(' ').split(/\\s+/);\n\n  if (this.options.loose) {\n    // in loose mode, throw out any that are not valid comparators\n    set = set.filter(function (comp) {\n      return !!comp.match(compRe);\n    });\n  }\n\n  set = set.map(function (comp) {\n    return new Comparator(comp, this.options);\n  }, this);\n  return set;\n};\n\nRange.prototype.intersects = function (range, options) {\n  if (!(range instanceof Range)) {\n    throw new TypeError('a Range is required');\n  }\n\n  return this.set.some(function (thisComparators) {\n    return isSatisfiable(thisComparators, options) && range.set.some(function (rangeComparators) {\n      return isSatisfiable(rangeComparators, options) && thisComparators.every(function (thisComparator) {\n        return rangeComparators.every(function (rangeComparator) {\n          return thisComparator.intersects(rangeComparator, options);\n        });\n      });\n    });\n  });\n}; // take a set of comparators and determine whether there\n// exists a version which can satisfy it\n\n\nfunction isSatisfiable(comparators, options) {\n  var result = true;\n  var remainingComparators = comparators.slice();\n  var testComparator = remainingComparators.pop();\n\n  while (result && remainingComparators.length) {\n    result = remainingComparators.every(function (otherComparator) {\n      return testComparator.intersects(otherComparator, options);\n    });\n    testComparator = remainingComparators.pop();\n  }\n\n  return result;\n} // Mostly just for testing and legacy API reasons\n\n\nexports.toComparators = toComparators;\n\nfunction toComparators(range, options) {\n  return new Range(range, options).set.map(function (comp) {\n    return comp.map(function (c) {\n      return c.value;\n    }).join(' ').trim().split(' ');\n  });\n} // comprised of xranges, tildes, stars, and gtlt's at this point.\n// already replaced the hyphen ranges\n// turn into a set of JUST comparators.\n\n\nfunction parseComparator(comp, options) {\n  debug('comp', comp, options);\n  comp = replaceCarets(comp, options);\n  debug('caret', comp);\n  comp = replaceTildes(comp, options);\n  debug('tildes', comp);\n  comp = replaceXRanges(comp, options);\n  debug('xrange', comp);\n  comp = replaceStars(comp, options);\n  debug('stars', comp);\n  return comp;\n}\n\nfunction isX(id) {\n  return !id || id.toLowerCase() === 'x' || id === '*';\n} // ~, ~> --> * (any, kinda silly)\n// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0\n// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0\n// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0\n// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0\n// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0\n\n\nfunction replaceTildes(comp, options) {\n  return comp.trim().split(/\\s+/).map(function (comp) {\n    return replaceTilde(comp, options);\n  }).join(' ');\n}\n\nfunction replaceTilde(comp, options) {\n  var r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];\n  return comp.replace(r, function (_, M, m, p, pr) {\n    debug('tilde', comp, _, M, m, p, pr);\n    var ret;\n\n    if (isX(M)) {\n      ret = '';\n    } else if (isX(m)) {\n      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';\n    } else if (isX(p)) {\n      // ~1.2 == >=1.2.0 <1.3.0\n      ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';\n    } else if (pr) {\n      debug('replaceTilde pr', pr);\n      ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + M + '.' + (+m + 1) + '.0';\n    } else {\n      // ~1.2.3 == >=1.2.3 <1.3.0\n      ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + (+m + 1) + '.0';\n    }\n\n    debug('tilde return', ret);\n    return ret;\n  });\n} // ^ --> * (any, kinda silly)\n// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0\n// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0\n// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0\n// ^1.2.3 --> >=1.2.3 <2.0.0\n// ^1.2.0 --> >=1.2.0 <2.0.0\n\n\nfunction replaceCarets(comp, options) {\n  return comp.trim().split(/\\s+/).map(function (comp) {\n    return replaceCaret(comp, options);\n  }).join(' ');\n}\n\nfunction replaceCaret(comp, options) {\n  debug('caret', comp, options);\n  var r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];\n  return comp.replace(r, function (_, M, m, p, pr) {\n    debug('caret', comp, _, M, m, p, pr);\n    var ret;\n\n    if (isX(M)) {\n      ret = '';\n    } else if (isX(m)) {\n      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';\n    } else if (isX(p)) {\n      if (M === '0') {\n        ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';\n      } else {\n        ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0';\n      }\n    } else if (pr) {\n      debug('replaceCaret pr', pr);\n\n      if (M === '0') {\n        if (m === '0') {\n          ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + M + '.' + m + '.' + (+p + 1);\n        } else {\n          ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + M + '.' + (+m + 1) + '.0';\n        }\n      } else {\n        ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + (+M + 1) + '.0.0';\n      }\n    } else {\n      debug('no pr');\n\n      if (M === '0') {\n        if (m === '0') {\n          ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + m + '.' + (+p + 1);\n        } else {\n          ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + (+m + 1) + '.0';\n        }\n      } else {\n        ret = '>=' + M + '.' + m + '.' + p + ' <' + (+M + 1) + '.0.0';\n      }\n    }\n\n    debug('caret return', ret);\n    return ret;\n  });\n}\n\nfunction replaceXRanges(comp, options) {\n  debug('replaceXRanges', comp, options);\n  return comp.split(/\\s+/).map(function (comp) {\n    return replaceXRange(comp, options);\n  }).join(' ');\n}\n\nfunction replaceXRange(comp, options) {\n  comp = comp.trim();\n  var r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];\n  return comp.replace(r, function (ret, gtlt, M, m, p, pr) {\n    debug('xRange', comp, ret, gtlt, M, m, p, pr);\n    var xM = isX(M);\n    var xm = xM || isX(m);\n    var xp = xm || isX(p);\n    var anyX = xp;\n\n    if (gtlt === '=' && anyX) {\n      gtlt = '';\n    } // if we're including prereleases in the match, then we need\n    // to fix this to -0, the lowest possible prerelease value\n\n\n    pr = options.includePrerelease ? '-0' : '';\n\n    if (xM) {\n      if (gtlt === '>' || gtlt === '<') {\n        // nothing is allowed\n        ret = '<0.0.0-0';\n      } else {\n        // nothing is forbidden\n        ret = '*';\n      }\n    } else if (gtlt && anyX) {\n      // we know patch is an x, because we have any x at all.\n      // replace X with 0\n      if (xm) {\n        m = 0;\n      }\n\n      p = 0;\n\n      if (gtlt === '>') {\n        // >1 => >=2.0.0\n        // >1.2 => >=1.3.0\n        // >1.2.3 => >= 1.2.4\n        gtlt = '>=';\n\n        if (xm) {\n          M = +M + 1;\n          m = 0;\n          p = 0;\n        } else {\n          m = +m + 1;\n          p = 0;\n        }\n      } else if (gtlt === '<=') {\n        // <=0.7.x is actually <0.8.0, since any 0.7.x should\n        // pass.  Similarly, <=7.x is actually <8.0.0, etc.\n        gtlt = '<';\n\n        if (xm) {\n          M = +M + 1;\n        } else {\n          m = +m + 1;\n        }\n      }\n\n      ret = gtlt + M + '.' + m + '.' + p + pr;\n    } else if (xm) {\n      ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr;\n    } else if (xp) {\n      ret = '>=' + M + '.' + m + '.0' + pr + ' <' + M + '.' + (+m + 1) + '.0' + pr;\n    }\n\n    debug('xRange return', ret);\n    return ret;\n  });\n} // Because * is AND-ed with everything else in the comparator,\n// and '' means \"any version\", just remove the *s entirely.\n\n\nfunction replaceStars(comp, options) {\n  debug('replaceStars', comp, options); // Looseness is ignored here.  star is always as loose as it gets!\n\n  return comp.trim().replace(re[t.STAR], '');\n} // This function is passed to string.replace(re[t.HYPHENRANGE])\n// M, m, patch, prerelease, build\n// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5\n// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do\n// 1.2 - 3.4 => >=1.2.0 <3.5.0\n\n\nfunction hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {\n  if (isX(fM)) {\n    from = '';\n  } else if (isX(fm)) {\n    from = '>=' + fM + '.0.0';\n  } else if (isX(fp)) {\n    from = '>=' + fM + '.' + fm + '.0';\n  } else {\n    from = '>=' + from;\n  }\n\n  if (isX(tM)) {\n    to = '';\n  } else if (isX(tm)) {\n    to = '<' + (+tM + 1) + '.0.0';\n  } else if (isX(tp)) {\n    to = '<' + tM + '.' + (+tm + 1) + '.0';\n  } else if (tpr) {\n    to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr;\n  } else {\n    to = '<=' + to;\n  }\n\n  return (from + ' ' + to).trim();\n} // if ANY of the sets match ALL of its comparators, then pass\n\n\nRange.prototype.test = function (version) {\n  if (!version) {\n    return false;\n  }\n\n  if (typeof version === 'string') {\n    try {\n      version = new SemVer(version, this.options);\n    } catch (er) {\n      return false;\n    }\n  }\n\n  for (var i = 0; i < this.set.length; i++) {\n    if (testSet(this.set[i], version, this.options)) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\nfunction testSet(set, version, options) {\n  for (var i = 0; i < set.length; i++) {\n    if (!set[i].test(version)) {\n      return false;\n    }\n  }\n\n  if (version.prerelease.length && !options.includePrerelease) {\n    // Find the set of versions that are allowed to have prereleases\n    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0\n    // That should allow `1.2.3-pr.2` to pass.\n    // However, `1.2.4-alpha.notready` should NOT be allowed,\n    // even though it's within the range set by the comparators.\n    for (i = 0; i < set.length; i++) {\n      debug(set[i].semver);\n\n      if (set[i].semver === ANY) {\n        continue;\n      }\n\n      if (set[i].semver.prerelease.length > 0) {\n        var allowed = set[i].semver;\n\n        if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {\n          return true;\n        }\n      }\n    } // Version has a -pre, but it's not one of the ones we like.\n\n\n    return false;\n  }\n\n  return true;\n}\n\nexports.satisfies = satisfies;\n\nfunction satisfies(version, range, options) {\n  try {\n    range = new Range(range, options);\n  } catch (er) {\n    return false;\n  }\n\n  return range.test(version);\n}\n\nexports.maxSatisfying = maxSatisfying;\n\nfunction maxSatisfying(versions, range, options) {\n  var max = null;\n  var maxSV = null;\n\n  try {\n    var rangeObj = new Range(range, options);\n  } catch (er) {\n    return null;\n  }\n\n  versions.forEach(function (v) {\n    if (rangeObj.test(v)) {\n      // satisfies(v, range, options)\n      if (!max || maxSV.compare(v) === -1) {\n        // compare(max, v, true)\n        max = v;\n        maxSV = new SemVer(max, options);\n      }\n    }\n  });\n  return max;\n}\n\nexports.minSatisfying = minSatisfying;\n\nfunction minSatisfying(versions, range, options) {\n  var min = null;\n  var minSV = null;\n\n  try {\n    var rangeObj = new Range(range, options);\n  } catch (er) {\n    return null;\n  }\n\n  versions.forEach(function (v) {\n    if (rangeObj.test(v)) {\n      // satisfies(v, range, options)\n      if (!min || minSV.compare(v) === 1) {\n        // compare(min, v, true)\n        min = v;\n        minSV = new SemVer(min, options);\n      }\n    }\n  });\n  return min;\n}\n\nexports.minVersion = minVersion;\n\nfunction minVersion(range, loose) {\n  range = new Range(range, loose);\n  var minver = new SemVer('0.0.0');\n\n  if (range.test(minver)) {\n    return minver;\n  }\n\n  minver = new SemVer('0.0.0-0');\n\n  if (range.test(minver)) {\n    return minver;\n  }\n\n  minver = null;\n\n  for (var i = 0; i < range.set.length; ++i) {\n    var comparators = range.set[i];\n    comparators.forEach(function (comparator) {\n      // Clone to avoid manipulating the comparator's semver object.\n      var compver = new SemVer(comparator.semver.version);\n\n      switch (comparator.operator) {\n        case '>':\n          if (compver.prerelease.length === 0) {\n            compver.patch++;\n          } else {\n            compver.prerelease.push(0);\n          }\n\n          compver.raw = compver.format();\n\n        /* fallthrough */\n\n        case '':\n        case '>=':\n          if (!minver || gt(minver, compver)) {\n            minver = compver;\n          }\n\n          break;\n\n        case '<':\n        case '<=':\n          /* Ignore maximum versions */\n          break;\n\n        /* istanbul ignore next */\n\n        default:\n          throw new Error('Unexpected operation: ' + comparator.operator);\n      }\n    });\n  }\n\n  if (minver && range.test(minver)) {\n    return minver;\n  }\n\n  return null;\n}\n\nexports.validRange = validRange;\n\nfunction validRange(range, options) {\n  try {\n    // Return '*' instead of '' so that truthiness works.\n    // This will throw if it's invalid anyway\n    return new Range(range, options).range || '*';\n  } catch (er) {\n    return null;\n  }\n} // Determine if version is less than all the versions possible in the range\n\n\nexports.ltr = ltr;\n\nfunction ltr(version, range, options) {\n  return outside(version, range, '<', options);\n} // Determine if version is greater than all the versions possible in the range.\n\n\nexports.gtr = gtr;\n\nfunction gtr(version, range, options) {\n  return outside(version, range, '>', options);\n}\n\nexports.outside = outside;\n\nfunction outside(version, range, hilo, options) {\n  version = new SemVer(version, options);\n  range = new Range(range, options);\n  var gtfn, ltefn, ltfn, comp, ecomp;\n\n  switch (hilo) {\n    case '>':\n      gtfn = gt;\n      ltefn = lte;\n      ltfn = lt;\n      comp = '>';\n      ecomp = '>=';\n      break;\n\n    case '<':\n      gtfn = lt;\n      ltefn = gte;\n      ltfn = gt;\n      comp = '<';\n      ecomp = '<=';\n      break;\n\n    default:\n      throw new TypeError('Must provide a hilo val of \"<\" or \">\"');\n  } // If it satisifes the range it is not outside\n\n\n  if (satisfies(version, range, options)) {\n    return false;\n  } // From now on, variable terms are as if we're in \"gtr\" mode.\n  // but note that everything is flipped for the \"ltr\" function.\n\n\n  for (var i = 0; i < range.set.length; ++i) {\n    var comparators = range.set[i];\n    var high = null;\n    var low = null;\n    comparators.forEach(function (comparator) {\n      if (comparator.semver === ANY) {\n        comparator = new Comparator('>=0.0.0');\n      }\n\n      high = high || comparator;\n      low = low || comparator;\n\n      if (gtfn(comparator.semver, high.semver, options)) {\n        high = comparator;\n      } else if (ltfn(comparator.semver, low.semver, options)) {\n        low = comparator;\n      }\n    }); // If the edge version comparator has a operator then our version\n    // isn't outside it\n\n    if (high.operator === comp || high.operator === ecomp) {\n      return false;\n    } // If the lowest version comparator has an operator and our version\n    // is less than it then it isn't higher than the range\n\n\n    if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {\n      return false;\n    } else if (low.operator === ecomp && ltfn(version, low.semver)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nexports.prerelease = prerelease;\n\nfunction prerelease(version, options) {\n  var parsed = parse(version, options);\n  return parsed && parsed.prerelease.length ? parsed.prerelease : null;\n}\n\nexports.intersects = intersects;\n\nfunction intersects(r1, r2, options) {\n  r1 = new Range(r1, options);\n  r2 = new Range(r2, options);\n  return r1.intersects(r2);\n}\n\nexports.coerce = coerce;\n\nfunction coerce(version, options) {\n  if (version instanceof SemVer) {\n    return version;\n  }\n\n  if (typeof version === 'number') {\n    version = String(version);\n  }\n\n  if (typeof version !== 'string') {\n    return null;\n  }\n\n  options = options || {};\n  var match = null;\n\n  if (!options.rtl) {\n    match = version.match(re[t.COERCE]);\n  } else {\n    // Find the right-most coercible string that does not share\n    // a terminus with a more left-ward coercible string.\n    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'\n    //\n    // Walk through the string checking with a /g regexp\n    // Manually set the index so as to pick up overlapping matches.\n    // Stop when we get a match that ends at the string end, since no\n    // coercible string can be more right-ward without the same terminus.\n    var next;\n\n    while ((next = re[t.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length)) {\n      if (!match || next.index + next[0].length !== match.index + match[0].length) {\n        match = next;\n      }\n\n      re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;\n    } // leave it in a clean state\n\n\n    re[t.COERCERTL].lastIndex = -1;\n  }\n\n  if (match === null) {\n    return null;\n  }\n\n  return parse(match[2] + '.' + (match[3] || '0') + '.' + (match[4] || '0'), options);\n}"},"sourceMaps":{"js":{"mappings":[{"name":"exports","generated":{"line":2,"column":0},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":1,"column":0}},{"generated":{"line":2,"column":7},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":1,"column":7}},{"name":"module","generated":{"line":2,"column":10},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":1,"column":10}},{"generated":{"line":2,"column":16},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":1,"column":16}},{"name":"exports","generated":{"line":2,"column":17},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":1,"column":17}},{"generated":{"line":2,"column":24},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":1,"column":10}},{"name":"SemVer","generated":{"line":2,"column":27},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":1,"column":27}},{"generated":{"line":2,"column":33},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":1,"column":0}},{"generated":{"line":3,"column":0},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":3,"column":0}},{"name":"debug","generated":{"line":3,"column":4},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":3,"column":4}},{"generated":{"line":3,"column":9},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":3,"column":0}},{"generated":{"line":4,"column":0},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":4,"column":0}},{"generated":{"line":6,"column":0},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":5,"column":0}},{"generated":{"line":6,"column":4},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":5,"column":4}},{"name":"process","generated":{"line":6,"column":11},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":5,"column":11}},{"generated":{"line":6,"column":18},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":5,"column":4}},{"generated":{"line":6,"column":23},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":5,"column":23}},{"generated":{"line":6,"column":31},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":5,"column":4}},{"name":"process","generated":{"line":6,"column":35},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":6,"column":4}},{"generated":{"line":6,"column":42},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":6,"column":11}},{"name":"env","generated":{"line":6,"column":43},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":6,"column":12}},{"generated":{"line":6,"column":46},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":5,"column":4}},{"generated":{"line":6,"column":63},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":8,"column":4}},{"name":"test","generated":{"line":6,"column":77},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":8,"column":18}},{"generated":{"line":6,"column":81},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":8,"column":4}},{"generated":{"line":6,"column":92},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":5,"column":0}},{"generated":{"line":6,"column":94},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":8,"column":48}},{"name":"debug","generated":{"line":7,"column":0},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":9,"column":2}},{"name":"debug","generated":{"line":7,"column":2},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":9,"column":2}},{"generated":{"line":7,"column":7},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":9,"column":7}},{"generated":{"line":7,"column":10},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":9,"column":10}},{"generated":{"line":7,"column":22},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":9,"column":22}},{"generated":{"line":8,"column":0},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":10,"column":4}},{"name":"args","generated":{"line":8,"column":8},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":10,"column":8}},{"generated":{"line":8,"column":12},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":10,"column":12}},{"name":"Array","generated":{"line":8,"column":15},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":10,"column":15}},{"generated":{"line":8,"column":20},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":10,"column":20}},{"name":"prototype","generated":{"line":8,"column":21},"source":"../../node_modules/@platform/util.value/node_modules/semver/semver.js","original":{"line":10,"column":21}},{"generated":{"line":8,"column":30},"source":"../../