1  exports = module.exports = SemVer
   2  
   3  var debug
   4  /* istanbul ignore next */
   5  if (typeof process === 'object' &&
   6      process.env &&
   7      process.env.NODE_DEBUG &&
   8      /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
   9    debug = function () {
  10      var args = Array.prototype.slice.call(arguments, 0)
  11      args.unshift('SEMVER')
  12      console.log.apply(console, args)
  13    }
  14  } else {
  15    debug = function () {}
  16  }
  17  
  18  // Note: this is the semver.org version of the spec that it implements
  19  // Not necessarily the package version of this code.
  20  exports.SEMVER_SPEC_VERSION = '2.0.0'
  21  
  22  var MAX_LENGTH = 256
  23  var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
  24    /* istanbul ignore next */ 9007199254740991
  25  
  26  // Max safe segment length for coercion.
  27  var MAX_SAFE_COMPONENT_LENGTH = 16
  28  
  29  // The actual regexps go on exports.re
  30  var re = exports.re = []
  31  var src = exports.src = []
  32  var R = 0
  33  
  34  // The following Regular Expressions can be used for tokenizing,
  35  // validating, and parsing SemVer version strings.
  36  
  37  // ## Numeric Identifier
  38  // A single `0`, or a non-zero digit followed by zero or more digits.
  39  
  40  var NUMERICIDENTIFIER = R++
  41  src[NUMERICIDENTIFIER] = '0|[1-9]\\d*'
  42  var NUMERICIDENTIFIERLOOSE = R++
  43  src[NUMERICIDENTIFIERLOOSE] = '[0-9]+'
  44  
  45  // ## Non-numeric Identifier
  46  // Zero or more digits, followed by a letter or hyphen, and then zero or
  47  // more letters, digits, or hyphens.
  48  
  49  var NONNUMERICIDENTIFIER = R++
  50  src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'
  51  
  52  // ## Main Version
  53  // Three dot-separated numeric identifiers.
  54  
  55  var MAINVERSION = R++
  56  src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' +
  57                     '(' + src[NUMERICIDENTIFIER] + ')\\.' +
  58                     '(' + src[NUMERICIDENTIFIER] + ')'
  59  
  60  var MAINVERSIONLOOSE = R++
  61  src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
  62                          '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
  63                          '(' + src[NUMERICIDENTIFIERLOOSE] + ')'
  64  
  65  // ## Pre-release Version Identifier
  66  // A numeric identifier, or a non-numeric identifier.
  67  
  68  var PRERELEASEIDENTIFIER = R++
  69  src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] +
  70                              '|' + src[NONNUMERICIDENTIFIER] + ')'
  71  
  72  var PRERELEASEIDENTIFIERLOOSE = R++
  73  src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] +
  74                                   '|' + src[NONNUMERICIDENTIFIER] + ')'
  75  
  76  // ## Pre-release Version
  77  // Hyphen, followed by one or more dot-separated pre-release version
  78  // identifiers.
  79  
  80  var PRERELEASE = R++
  81  src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] +
  82                    '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))'
  83  
  84  var PRERELEASELOOSE = R++
  85  src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] +
  86                         '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))'
  87  
  88  // ## Build Metadata Identifier
  89  // Any combination of digits, letters, or hyphens.
  90  
  91  var BUILDIDENTIFIER = R++
  92  src[BUILDIDENTIFIER] = '[0-9A-Za-z-]+'
  93  
  94  // ## Build Metadata
  95  // Plus sign, followed by one or more period-separated build metadata
  96  // identifiers.
  97  
  98  var BUILD = R++
  99  src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] +
 100               '(?:\\.' + src[BUILDIDENTIFIER] + ')*))'
 101  
 102  // ## Full Version String
 103  // A main version, followed optionally by a pre-release version and
 104  // build metadata.
 105  
 106  // Note that the only major, minor, patch, and pre-release sections of
 107  // the version string are capturing groups.  The build metadata is not a
 108  // capturing group, because it should not ever be used in version
 109  // comparison.
 110  
 111  var FULL = R++
 112  var FULLPLAIN = 'v?' + src[MAINVERSION] +
 113                  src[PRERELEASE] + '?' +
 114                  src[BUILD] + '?'
 115  
 116  src[FULL] = '^' + FULLPLAIN + '$'
 117  
 118  // like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
 119  // also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
 120  // common in the npm registry.
 121  var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] +
 122                   src[PRERELEASELOOSE] + '?' +
 123                   src[BUILD] + '?'
 124  
 125  var LOOSE = R++
 126  src[LOOSE] = '^' + LOOSEPLAIN + '$'
 127  
 128  var GTLT = R++
 129  src[GTLT] = '((?:<|>)?=?)'
 130  
 131  // Something like "2.*" or "1.2.x".
 132  // Note that "x.x" is a valid xRange identifer, meaning "any version"
 133  // Only the first item is strictly required.
 134  var XRANGEIDENTIFIERLOOSE = R++
 135  src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'
 136  var XRANGEIDENTIFIER = R++
 137  src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*'
 138  
 139  var XRANGEPLAIN = R++
 140  src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' +
 141                     '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
 142                     '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
 143                     '(?:' + src[PRERELEASE] + ')?' +
 144                     src[BUILD] + '?' +
 145                     ')?)?'
 146  
 147  var XRANGEPLAINLOOSE = R++
 148  src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
 149                          '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
 150                          '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
 151                          '(?:' + src[PRERELEASELOOSE] + ')?' +
 152                          src[BUILD] + '?' +
 153                          ')?)?'
 154  
 155  var XRANGE = R++
 156  src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$'
 157  var XRANGELOOSE = R++
 158  src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$'
 159  
 160  // Coercion.
 161  // Extract anything that could conceivably be a part of a valid semver
 162  var COERCE = R++
 163  src[COERCE] = '(?:^|[^\\d])' +
 164                '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +
 165                '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
 166                '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
 167                '(?:$|[^\\d])'
 168  
 169  // Tilde ranges.
 170  // Meaning is "reasonably at or greater than"
 171  var LONETILDE = R++
 172  src[LONETILDE] = '(?:~>?)'
 173  
 174  var TILDETRIM = R++
 175  src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+'
 176  re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g')
 177  var tildeTrimReplace = '$1~'
 178  
 179  var TILDE = R++
 180  src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$'
 181  var TILDELOOSE = R++
 182  src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$'
 183  
 184  // Caret ranges.
 185  // Meaning is "at least and backwards compatible with"
 186  var LONECARET = R++
 187  src[LONECARET] = '(?:\\^)'
 188  
 189  var CARETTRIM = R++
 190  src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+'
 191  re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g')
 192  var caretTrimReplace = '$1^'
 193  
 194  var CARET = R++
 195  src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$'
 196  var CARETLOOSE = R++
 197  src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$'
 198  
 199  // A simple gt/lt/eq thing, or just "" to indicate "any version"
 200  var COMPARATORLOOSE = R++
 201  src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$'
 202  var COMPARATOR = R++
 203  src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$'
 204  
 205  // An expression to strip any whitespace between the gtlt and the thing
 206  // it modifies, so that `> 1.2.3` ==> `>1.2.3`
 207  var COMPARATORTRIM = R++
 208  src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] +
 209                        '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')'
 210  
 211  // this one has to use the /g flag
 212  re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g')
 213  var comparatorTrimReplace = '$1$2$3'
 214  
 215  // Something like `1.2.3 - 1.2.4`
 216  // Note that these all use the loose form, because they'll be
 217  // checked against either the strict or loose comparator form
 218  // later.
 219  var HYPHENRANGE = R++
 220  src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' +
 221                     '\\s+-\\s+' +
 222                     '(' + src[XRANGEPLAIN] + ')' +
 223                     '\\s*$'
 224  
 225  var HYPHENRANGELOOSE = R++
 226  src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' +
 227                          '\\s+-\\s+' +
 228                          '(' + src[XRANGEPLAINLOOSE] + ')' +
 229                          '\\s*$'
 230  
 231  // Star ranges basically just allow anything at all.
 232  var STAR = R++
 233  src[STAR] = '(<|>)?=?\\s*\\*'
 234  
 235  // Compile to actual regexp objects.
 236  // All are flag-free, unless they were created above with a flag.
 237  for (var i = 0; i < R; i++) {
 238    debug(i, src[i])
 239    if (!re[i]) {
 240      re[i] = new RegExp(src[i])
 241    }
 242  }
 243  
 244  exports.parse = parse
 245  function parse (version, options) {
 246    if (!options || typeof options !== 'object') {
 247      options = {
 248        loose: !!options,
 249        includePrerelease: false
 250      }
 251    }
 252  
 253    if (version instanceof SemVer) {
 254      return version
 255    }
 256  
 257    if (typeof version !== 'string') {
 258      return null
 259    }
 260  
 261    if (version.length > MAX_LENGTH) {
 262      return null
 263    }
 264  
 265    var r = options.loose ? re[LOOSE] : re[FULL]
 266    if (!r.test(version)) {
 267      return null
 268    }
 269  
 270    try {
 271      return new SemVer(version, options)
 272    } catch (er) {
 273      return null
 274    }
 275  }
 276  
 277  exports.valid = valid
 278  function valid (version, options) {
 279    var v = parse(version, options)
 280    return v ? v.version : null
 281  }
 282  
 283  exports.clean = clean
 284  function clean (version, options) {
 285    var s = parse(version.trim().replace(/^[=v]+/, ''), options)
 286    return s ? s.version : null
 287  }
 288  
 289  exports.SemVer = SemVer
 290  
 291  function SemVer (version, options) {
 292    if (!options || typeof options !== 'object') {
 293      options = {
 294        loose: !!options,
 295        includePrerelease: false
 296      }
 297    }
 298    if (version instanceof SemVer) {
 299      if (version.loose === options.loose) {
 300        return version
 301      } else {
 302        version = version.version
 303      }
 304    } else if (typeof version !== 'string') {
 305      throw new TypeError('Invalid Version: ' + version)
 306    }
 307  
 308    if (version.length > MAX_LENGTH) {
 309      throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')
 310    }
 311  
 312    if (!(this instanceof SemVer)) {
 313      return new SemVer(version, options)
 314    }
 315  
 316    debug('SemVer', version, options)
 317    this.options = options
 318    this.loose = !!options.loose
 319  
 320    var m = version.trim().match(options.loose ? re[LOOSE] : re[FULL])
 321  
 322    if (!m) {
 323      throw new TypeError('Invalid Version: ' + version)
 324    }
 325  
 326    this.raw = version
 327  
 328    // these are actually numbers
 329    this.major = +m[1]
 330    this.minor = +m[2]
 331    this.patch = +m[3]
 332  
 333    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
 334      throw new TypeError('Invalid major version')
 335    }
 336  
 337    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
 338      throw new TypeError('Invalid minor version')
 339    }
 340  
 341    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
 342      throw new TypeError('Invalid patch version')
 343    }
 344  
 345    // numberify any prerelease numeric ids
 346    if (!m[4]) {
 347      this.prerelease = []
 348    } else {
 349      this.prerelease = m[4].split('.').map(function (id) {
 350        if (/^[0-9]+$/.test(id)) {
 351          var num = +id
 352          if (num >= 0 && num < MAX_SAFE_INTEGER) {
 353            return num
 354          }
 355        }
 356        return id
 357      })
 358    }
 359  
 360    this.build = m[5] ? m[5].split('.') : []
 361    this.format()
 362  }
 363  
 364  SemVer.prototype.format = function () {
 365    this.version = this.major + '.' + this.minor + '.' + this.patch
 366    if (this.prerelease.length) {
 367      this.version += '-' + this.prerelease.join('.')
 368    }
 369    return this.version
 370  }
 371  
 372  SemVer.prototype.toString = function () {
 373    return this.version
 374  }
 375  
 376  SemVer.prototype.compare = function (other) {
 377    debug('SemVer.compare', this.version, this.options, other)
 378    if (!(other instanceof SemVer)) {
 379      other = new SemVer(other, this.options)
 380    }
 381  
 382    return this.compareMain(other) || this.comparePre(other)
 383  }
 384  
 385  SemVer.prototype.compareMain = function (other) {
 386    if (!(other instanceof SemVer)) {
 387      other = new SemVer(other, this.options)
 388    }
 389  
 390    return compareIdentifiers(this.major, other.major) ||
 391           compareIdentifiers(this.minor, other.minor) ||
 392           compareIdentifiers(this.patch, other.patch)
 393  }
 394  
 395  SemVer.prototype.comparePre = function (other) {
 396    if (!(other instanceof SemVer)) {
 397      other = new SemVer(other, this.options)
 398    }
 399  
 400    // NOT having a prerelease is > having one
 401    if (this.prerelease.length && !other.prerelease.length) {
 402      return -1
 403    } else if (!this.prerelease.length && other.prerelease.length) {
 404      return 1
 405    } else if (!this.prerelease.length && !other.prerelease.length) {
 406      return 0
 407    }
 408  
 409    var i = 0
 410    do {
 411      var a = this.prerelease[i]
 412      var b = other.prerelease[i]
 413      debug('prerelease compare', i, a, b)
 414      if (a === undefined && b === undefined) {
 415        return 0
 416      } else if (b === undefined) {
 417        return 1
 418      } else if (a === undefined) {
 419        return -1
 420      } else if (a === b) {
 421        continue
 422      } else {
 423        return compareIdentifiers(a, b)
 424      }
 425    } while (++i)
 426  }
 427  
 428  // preminor will bump the version up to the next minor release, and immediately
 429  // down to pre-release. premajor and prepatch work the same way.
 430  SemVer.prototype.inc = function (release, identifier) {
 431    switch (release) {
 432      case 'premajor':
 433        this.prerelease.length = 0
 434        this.patch = 0
 435        this.minor = 0
 436        this.major++
 437        this.inc('pre', identifier)
 438        break
 439      case 'preminor':
 440        this.prerelease.length = 0
 441        this.patch = 0
 442        this.minor++
 443        this.inc('pre', identifier)
 444        break
 445      case 'prepatch':
 446        // If this is already a prerelease, it will bump to the next version
 447        // drop any prereleases that might already exist, since they are not
 448        // relevant at this point.
 449        this.prerelease.length = 0
 450        this.inc('patch', identifier)
 451        this.inc('pre', identifier)
 452        break
 453      // If the input is a non-prerelease version, this acts the same as
 454      // prepatch.
 455      case 'prerelease':
 456        if (this.prerelease.length === 0) {
 457          this.inc('patch', identifier)
 458        }
 459        this.inc('pre', identifier)
 460        break
 461  
 462      case 'major':
 463        // If this is a pre-major version, bump up to the same major version.
 464        // Otherwise increment major.
 465        // 1.0.0-5 bumps to 1.0.0
 466        // 1.1.0 bumps to 2.0.0
 467        if (this.minor !== 0 ||
 468            this.patch !== 0 ||
 469            this.prerelease.length === 0) {
 470          this.major++
 471        }
 472        this.minor = 0
 473        this.patch = 0
 474        this.prerelease = []
 475        break
 476      case 'minor':
 477        // If this is a pre-minor version, bump up to the same minor version.
 478        // Otherwise increment minor.
 479        // 1.2.0-5 bumps to 1.2.0
 480        // 1.2.1 bumps to 1.3.0
 481        if (this.patch !== 0 || this.prerelease.length === 0) {
 482          this.minor++
 483        }
 484        this.patch = 0
 485        this.prerelease = []
 486        break
 487      case 'patch':
 488        // If this is not a pre-release version, it will increment the patch.
 489        // If it is a pre-release it will bump up to the same patch version.
 490        // 1.2.0-5 patches to 1.2.0
 491        // 1.2.0 patches to 1.2.1
 492        if (this.prerelease.length === 0) {
 493          this.patch++
 494        }
 495        this.prerelease = []
 496        break
 497      // This probably shouldn't be used publicly.
 498      // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction.
 499      case 'pre':
 500        if (this.prerelease.length === 0) {
 501          this.prerelease = [0]
 502        } else {
 503          var i = this.prerelease.length
 504          while (--i >= 0) {
 505            if (typeof this.prerelease[i] === 'number') {
 506              this.prerelease[i]++
 507              i = -2
 508            }
 509          }
 510          if (i === -1) {
 511            // didn't increment anything
 512            this.prerelease.push(0)
 513          }
 514        }
 515        if (identifier) {
 516          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
 517          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
 518          if (this.prerelease[0] === identifier) {
 519            if (isNaN(this.prerelease[1])) {
 520              this.prerelease = [identifier, 0]
 521            }
 522          } else {
 523            this.prerelease = [identifier, 0]
 524          }
 525        }
 526        break
 527  
 528      default:
 529        throw new Error('invalid increment argument: ' + release)
 530    }
 531    this.format()
 532    this.raw = this.version
 533    return this
 534  }
 535  
 536  exports.inc = inc
 537  function inc (version, release, loose, identifier) {
 538    if (typeof (loose) === 'string') {
 539      identifier = loose
 540      loose = undefined
 541    }
 542  
 543    try {
 544      return new SemVer(version, loose).inc(release, identifier).version
 545    } catch (er) {
 546      return null
 547    }
 548  }
 549  
 550  exports.diff = diff
 551  function diff (version1, version2) {
 552    if (eq(version1, version2)) {
 553      return null
 554    } else {
 555      var v1 = parse(version1)
 556      var v2 = parse(version2)
 557      var prefix = ''
 558      if (v1.prerelease.length || v2.prerelease.length) {
 559        prefix = 'pre'
 560        var defaultResult = 'prerelease'
 561      }
 562      for (var key in v1) {
 563        if (key === 'major' || key === 'minor' || key === 'patch') {
 564          if (v1[key] !== v2[key]) {
 565            return prefix + key
 566          }
 567        }
 568      }
 569      return defaultResult // may be undefined
 570    }
 571  }
 572  
 573  exports.compareIdentifiers = compareIdentifiers
 574  
 575  var numeric = /^[0-9]+$/
 576  function compareIdentifiers (a, b) {
 577    var anum = numeric.test(a)
 578    var bnum = numeric.test(b)
 579  
 580    if (anum && bnum) {
 581      a = +a
 582      b = +b
 583    }
 584  
 585    return a === b ? 0
 586      : (anum && !bnum) ? -1
 587      : (bnum && !anum) ? 1
 588      : a < b ? -1
 589      : 1
 590  }
 591  
 592  exports.rcompareIdentifiers = rcompareIdentifiers
 593  function rcompareIdentifiers (a, b) {
 594    return compareIdentifiers(b, a)
 595  }
 596  
 597  exports.major = major
 598  function major (a, loose) {
 599    return new SemVer(a, loose).major
 600  }
 601  
 602  exports.minor = minor
 603  function minor (a, loose) {
 604    return new SemVer(a, loose).minor
 605  }
 606  
 607  exports.patch = patch
 608  function patch (a, loose) {
 609    return new SemVer(a, loose).patch
 610  }
 611  
 612  exports.compare = compare
 613  function compare (a, b, loose) {
 614    return new SemVer(a, loose).compare(new SemVer(b, loose))
 615  }
 616  
 617  exports.compareLoose = compareLoose
 618  function compareLoose (a, b) {
 619    return compare(a, b, true)
 620  }
 621  
 622  exports.rcompare = rcompare
 623  function rcompare (a, b, loose) {
 624    return compare(b, a, loose)
 625  }
 626  
 627  exports.sort = sort
 628  function sort (list, loose) {
 629    return list.sort(function (a, b) {
 630      return exports.compare(a, b, loose)
 631    })
 632  }
 633  
 634  exports.rsort = rsort
 635  function rsort (list, loose) {
 636    return list.sort(function (a, b) {
 637      return exports.rcompare(a, b, loose)
 638    })
 639  }
 640  
 641  exports.gt = gt
 642  function gt (a, b, loose) {
 643    return compare(a, b, loose) > 0
 644  }
 645  
 646  exports.lt = lt
 647  function lt (a, b, loose) {
 648    return compare(a, b, loose) < 0
 649  }
 650  
 651  exports.eq = eq
 652  function eq (a, b, loose) {
 653    return compare(a, b, loose) === 0
 654  }
 655  
 656  exports.neq = neq
 657  function neq (a, b, loose) {
 658    return compare(a, b, loose) !== 0
 659  }
 660  
 661  exports.gte = gte
 662  function gte (a, b, loose) {
 663    return compare(a, b, loose) >= 0
 664  }
 665  
 666  exports.lte = lte
 667  function lte (a, b, loose) {
 668    return compare(a, b, loose) <= 0
 669  }
 670  
 671  exports.cmp = cmp
 672  function cmp (a, op, b, loose) {
 673    switch (op) {
 674      case '===':
 675        if (typeof a === 'object')
 676          a = a.version
 677        if (typeof b === 'object')
 678          b = b.version
 679        return a === b
 680  
 681      case '!==':
 682        if (typeof a === 'object')
 683          a = a.version
 684        if (typeof b === 'object')
 685          b = b.version
 686        return a !== b
 687  
 688      case '':
 689      case '=':
 690      case '==':
 691        return eq(a, b, loose)
 692  
 693      case '!=':
 694        return neq(a, b, loose)
 695  
 696      case '>':
 697        return gt(a, b, loose)
 698  
 699      case '>=':
 700        return gte(a, b, loose)
 701  
 702      case '<':
 703        return lt(a, b, loose)
 704  
 705      case '<=':
 706        return lte(a, b, loose)
 707  
 708      default:
 709        throw new TypeError('Invalid operator: ' + op)
 710    }
 711  }
 712  
 713  exports.Comparator = Comparator
 714  function Comparator (comp, options) {
 715    if (!options || typeof options !== 'object') {
 716      options = {
 717        loose: !!options,
 718        includePrerelease: false
 719      }
 720    }
 721  
 722    if (comp instanceof Comparator) {
 723      if (comp.loose === !!options.loose) {
 724        return comp
 725      } else {
 726        comp = comp.value
 727      }
 728    }
 729  
 730    if (!(this instanceof Comparator)) {
 731      return new Comparator(comp, options)
 732    }
 733  
 734    debug('comparator', comp, options)
 735    this.options = options
 736    this.loose = !!options.loose
 737    this.parse(comp)
 738  
 739    if (this.semver === ANY) {
 740      this.value = ''
 741    } else {
 742      this.value = this.operator + this.semver.version
 743    }
 744  
 745    debug('comp', this)
 746  }
 747  
 748  var ANY = {}
 749  Comparator.prototype.parse = function (comp) {
 750    var r = this.options.loose ? re[COMPARATORLOOSE] : re[COMPARATOR]
 751    var m = comp.match(r)
 752  
 753    if (!m) {
 754      throw new TypeError('Invalid comparator: ' + comp)
 755    }
 756  
 757    this.operator = m[1]
 758    if (this.operator === '=') {
 759      this.operator = ''
 760    }
 761  
 762    // if it literally is just '>' or '' then allow anything.
 763    if (!m[2]) {
 764      this.semver = ANY
 765    } else {
 766      this.semver = new SemVer(m[2], this.options.loose)
 767    }
 768  }
 769  
 770  Comparator.prototype.toString = function () {
 771    return this.value
 772  }
 773  
 774  Comparator.prototype.test = function (version) {
 775    debug('Comparator.test', version, this.options.loose)
 776  
 777    if (this.semver === ANY) {
 778      return true
 779    }
 780  
 781    if (typeof version === 'string') {
 782      version = new SemVer(version, this.options)
 783    }
 784  
 785    return cmp(version, this.operator, this.semver, this.options)
 786  }
 787  
 788  Comparator.prototype.intersects = function (comp, options) {
 789    if (!(comp instanceof Comparator)) {
 790      throw new TypeError('a Comparator is required')
 791    }
 792  
 793    if (!options || typeof options !== 'object') {
 794      options = {
 795        loose: !!options,
 796        includePrerelease: false
 797      }
 798    }
 799  
 800    var rangeTmp
 801  
 802    if (this.operator === '') {
 803      rangeTmp = new Range(comp.value, options)
 804      return satisfies(this.value, rangeTmp, options)
 805    } else if (comp.operator === '') {
 806      rangeTmp = new Range(this.value, options)
 807      return satisfies(comp.semver, rangeTmp, options)
 808    }
 809  
 810    var sameDirectionIncreasing =
 811      (this.operator === '>=' || this.operator === '>') &&
 812      (comp.operator === '>=' || comp.operator === '>')
 813    var sameDirectionDecreasing =
 814      (this.operator === '<=' || this.operator === '<') &&
 815      (comp.operator === '<=' || comp.operator === '<')
 816    var sameSemVer = this.semver.version === comp.semver.version
 817    var differentDirectionsInclusive =
 818      (this.operator === '>=' || this.operator === '<=') &&
 819      (comp.operator === '>=' || comp.operator === '<=')
 820    var oppositeDirectionsLessThan =
 821      cmp(this.semver, '<', comp.semver, options) &&
 822      ((this.operator === '>=' || this.operator === '>') &&
 823      (comp.operator === '<=' || comp.operator === '<'))
 824    var oppositeDirectionsGreaterThan =
 825      cmp(this.semver, '>', comp.semver, options) &&
 826      ((this.operator === '<=' || this.operator === '<') &&
 827      (comp.operator === '>=' || comp.operator === '>'))
 828  
 829    return sameDirectionIncreasing || sameDirectionDecreasing ||
 830      (sameSemVer && differentDirectionsInclusive) ||
 831      oppositeDirectionsLessThan || oppositeDirectionsGreaterThan
 832  }
 833  
 834  exports.Range = Range
 835  function Range (range, options) {
 836    if (!options || typeof options !== 'object') {
 837      options = {
 838        loose: !!options,
 839        includePrerelease: false
 840      }
 841    }
 842  
 843    if (range instanceof Range) {
 844      if (range.loose === !!options.loose &&
 845          range.includePrerelease === !!options.includePrerelease) {
 846        return range
 847      } else {
 848        return new Range(range.raw, options)
 849      }
 850    }
 851  
 852    if (range instanceof Comparator) {
 853      return new Range(range.value, options)
 854    }
 855  
 856    if (!(this instanceof Range)) {
 857      return new Range(range, options)
 858    }
 859  
 860    this.options = options
 861    this.loose = !!options.loose
 862    this.includePrerelease = !!options.includePrerelease
 863  
 864    // First, split based on boolean or ||
 865    this.raw = range
 866    this.set = range.split(/\s*\|\|\s*/).map(function (range) {
 867      return this.parseRange(range.trim())
 868    }, this).filter(function (c) {
 869      // throw out any that are not relevant for whatever reason
 870      return c.length
 871    })
 872  
 873    if (!this.set.length) {
 874      throw new TypeError('Invalid SemVer Range: ' + range)
 875    }
 876  
 877    this.format()
 878  }
 879  
 880  Range.prototype.format = function () {
 881    this.range = this.set.map(function (comps) {
 882      return comps.join(' ').trim()
 883    }).join('||').trim()
 884    return this.range
 885  }
 886  
 887  Range.prototype.toString = function () {
 888    return this.range
 889  }
 890  
 891  Range.prototype.parseRange = function (range) {
 892    var loose = this.options.loose
 893    range = range.trim()
 894    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
 895    var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE]
 896    range = range.replace(hr, hyphenReplace)
 897    debug('hyphen replace', range)
 898    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
 899    range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace)
 900    debug('comparator trim', range, re[COMPARATORTRIM])
 901  
 902    // `~ 1.2.3` => `~1.2.3`
 903    range = range.replace(re[TILDETRIM], tildeTrimReplace)
 904  
 905    // `^ 1.2.3` => `^1.2.3`
 906    range = range.replace(re[CARETTRIM], caretTrimReplace)
 907  
 908    // normalize spaces
 909    range = range.split(/\s+/).join(' ')
 910  
 911    // At this point, the range is completely trimmed and
 912    // ready to be split into comparators.
 913  
 914    var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR]
 915    var set = range.split(' ').map(function (comp) {
 916      return parseComparator(comp, this.options)
 917    }, this).join(' ').split(/\s+/)
 918    if (this.options.loose) {
 919      // in loose mode, throw out any that are not valid comparators
 920      set = set.filter(function (comp) {
 921        return !!comp.match(compRe)
 922      })
 923    }
 924    set = set.map(function (comp) {
 925      return new Comparator(comp, this.options)
 926    }, this)
 927  
 928    return set
 929  }
 930  
 931  Range.prototype.intersects = function (range, options) {
 932    if (!(range instanceof Range)) {
 933      throw new TypeError('a Range is required')
 934    }
 935  
 936    return this.set.some(function (thisComparators) {
 937      return thisComparators.every(function (thisComparator) {
 938        return range.set.some(function (rangeComparators) {
 939          return rangeComparators.every(function (rangeComparator) {
 940            return thisComparator.intersects(rangeComparator, options)
 941          })
 942        })
 943      })
 944    })
 945  }
 946  
 947  // Mostly just for testing and legacy API reasons
 948  exports.toComparators = toComparators
 949  function toComparators (range, options) {
 950    return new Range(range, options).set.map(function (comp) {
 951      return comp.map(function (c) {
 952        return c.value
 953      }).join(' ').trim().split(' ')
 954    })
 955  }
 956  
 957  // comprised of xranges, tildes, stars, and gtlt's at this point.
 958  // already replaced the hyphen ranges
 959  // turn into a set of JUST comparators.
 960  function parseComparator (comp, options) {
 961    debug('comp', comp, options)
 962    comp = replaceCarets(comp, options)
 963    debug('caret', comp)
 964    comp = replaceTildes(comp, options)
 965    debug('tildes', comp)
 966    comp = replaceXRanges(comp, options)
 967    debug('xrange', comp)
 968    comp = replaceStars(comp, options)
 969    debug('stars', comp)
 970    return comp
 971  }
 972  
 973  function isX (id) {
 974    return !id || id.toLowerCase() === 'x' || id === '*'
 975  }
 976  
 977  // ~, ~> --> * (any, kinda silly)
 978  // ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
 979  // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
 980  // ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
 981  // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
 982  // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
 983  function replaceTildes (comp, options) {
 984    return comp.trim().split(/\s+/).map(function (comp) {
 985      return replaceTilde(comp, options)
 986    }).join(' ')
 987  }
 988  
 989  function replaceTilde (comp, options) {
 990    var r = options.loose ? re[TILDELOOSE] : re[TILDE]
 991    return comp.replace(r, function (_, M, m, p, pr) {
 992      debug('tilde', comp, _, M, m, p, pr)
 993      var ret
 994  
 995      if (isX(M)) {
 996        ret = ''
 997      } else if (isX(m)) {
 998        ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
 999      } else if (isX(p)) {
1000        // ~1.2 == >=1.2.0 <1.3.0
1001        ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
1002      } else if (pr) {
1003        debug('replaceTilde pr', pr)
1004        ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
1005              ' <' + M + '.' + (+m + 1) + '.0'
1006      } else {
1007        // ~1.2.3 == >=1.2.3 <1.3.0
1008        ret = '>=' + M + '.' + m + '.' + p +
1009              ' <' + M + '.' + (+m + 1) + '.0'
1010      }
1011  
1012      debug('tilde return', ret)
1013      return ret
1014    })
1015  }
1016  
1017  // ^ --> * (any, kinda silly)
1018  // ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
1019  // ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
1020  // ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
1021  // ^1.2.3 --> >=1.2.3 <2.0.0
1022  // ^1.2.0 --> >=1.2.0 <2.0.0
1023  function replaceCarets (comp, options) {
1024    return comp.trim().split(/\s+/).map(function (comp) {
1025      return replaceCaret(comp, options)
1026    }).join(' ')
1027  }
1028  
1029  function replaceCaret (comp, options) {
1030    debug('caret', comp, options)
1031    var r = options.loose ? re[CARETLOOSE] : re[CARET]
1032    return comp.replace(r, function (_, M, m, p, pr) {
1033      debug('caret', comp, _, M, m, p, pr)
1034      var ret
1035  
1036      if (isX(M)) {
1037        ret = ''
1038      } else if (isX(m)) {
1039        ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
1040      } else if (isX(p)) {
1041        if (M === '0') {
1042          ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
1043        } else {
1044          ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0'
1045        }
1046      } else if (pr) {
1047        debug('replaceCaret pr', pr)
1048        if (M === '0') {
1049          if (m === '0') {
1050            ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
1051                  ' <' + M + '.' + m + '.' + (+p + 1)
1052          } else {
1053            ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
1054                  ' <' + M + '.' + (+m + 1) + '.0'
1055          }
1056        } else {
1057          ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
1058                ' <' + (+M + 1) + '.0.0'
1059        }
1060      } else {
1061        debug('no pr')
1062        if (M === '0') {
1063          if (m === '0') {
1064            ret = '>=' + M + '.' + m + '.' + p +
1065                  ' <' + M + '.' + m + '.' + (+p + 1)
1066          } else {
1067            ret = '>=' + M + '.' + m + '.' + p +
1068                  ' <' + M + '.' + (+m + 1) + '.0'
1069          }
1070        } else {
1071          ret = '>=' + M + '.' + m + '.' + p +
1072                ' <' + (+M + 1) + '.0.0'
1073        }
1074      }
1075  
1076      debug('caret return', ret)
1077      return ret
1078    })
1079  }
1080  
1081  function replaceXRanges (comp, options) {
1082    debug('replaceXRanges', comp, options)
1083    return comp.split(/\s+/).map(function (comp) {
1084      return replaceXRange(comp, options)
1085    }).join(' ')
1086  }
1087  
1088  function replaceXRange (comp, options) {
1089    comp = comp.trim()
1090    var r = options.loose ? re[XRANGELOOSE] : re[XRANGE]
1091    return comp.replace(r, function (ret, gtlt, M, m, p, pr) {
1092      debug('xRange', comp, ret, gtlt, M, m, p, pr)
1093      var xM = isX(M)
1094      var xm = xM || isX(m)
1095      var xp = xm || isX(p)
1096      var anyX = xp
1097  
1098      if (gtlt === '=' && anyX) {
1099        gtlt = ''
1100      }
1101  
1102      if (xM) {
1103        if (gtlt === '>' || gtlt === '<') {
1104          // nothing is allowed
1105          ret = '<0.0.0'
1106        } else {
1107          // nothing is forbidden
1108          ret = '*'
1109        }
1110      } else if (gtlt && anyX) {
1111        // we know patch is an x, because we have any x at all.
1112        // replace X with 0
1113        if (xm) {
1114          m = 0
1115        }
1116        p = 0
1117  
1118        if (gtlt === '>') {
1119          // >1 => >=2.0.0
1120          // >1.2 => >=1.3.0
1121          // >1.2.3 => >= 1.2.4
1122          gtlt = '>='
1123          if (xm) {
1124            M = +M + 1
1125            m = 0
1126            p = 0
1127          } else {
1128            m = +m + 1
1129            p = 0
1130          }
1131        } else if (gtlt === '<=') {
1132          // <=0.7.x is actually <0.8.0, since any 0.7.x should
1133          // pass.  Similarly, <=7.x is actually <8.0.0, etc.
1134          gtlt = '<'
1135          if (xm) {
1136            M = +M + 1
1137          } else {
1138            m = +m + 1
1139          }
1140        }
1141  
1142        ret = gtlt + M + '.' + m + '.' + p
1143      } else if (xm) {
1144        ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
1145      } else if (xp) {
1146        ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
1147      }
1148  
1149      debug('xRange return', ret)
1150  
1151      return ret
1152    })
1153  }
1154  
1155  // Because * is AND-ed with everything else in the comparator,
1156  // and '' means "any version", just remove the *s entirely.
1157  function replaceStars (comp, options) {
1158    debug('replaceStars', comp, options)
1159    // Looseness is ignored here.  star is always as loose as it gets!
1160    return comp.trim().replace(re[STAR], '')
1161  }
1162  
1163  // This function is passed to string.replace(re[HYPHENRANGE])
1164  // M, m, patch, prerelease, build
1165  // 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
1166  // 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do
1167  // 1.2 - 3.4 => >=1.2.0 <3.5.0
1168  function hyphenReplace ($0,
1169    from, fM, fm, fp, fpr, fb,
1170    to, tM, tm, tp, tpr, tb) {
1171    if (isX(fM)) {
1172      from = ''
1173    } else if (isX(fm)) {
1174      from = '>=' + fM + '.0.0'
1175    } else if (isX(fp)) {
1176      from = '>=' + fM + '.' + fm + '.0'
1177    } else {
1178      from = '>=' + from
1179    }
1180  
1181    if (isX(tM)) {
1182      to = ''
1183    } else if (isX(tm)) {
1184      to = '<' + (+tM + 1) + '.0.0'
1185    } else if (isX(tp)) {
1186      to = '<' + tM + '.' + (+tm + 1) + '.0'
1187    } else if (tpr) {
1188      to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr
1189    } else {
1190      to = '<=' + to
1191    }
1192  
1193    return (from + ' ' + to).trim()
1194  }
1195  
1196  // if ANY of the sets match ALL of its comparators, then pass
1197  Range.prototype.test = function (version) {
1198    if (!version) {
1199      return false
1200    }
1201  
1202    if (typeof version === 'string') {
1203      version = new SemVer(version, this.options)
1204    }
1205  
1206    for (var i = 0; i < this.set.length; i++) {
1207      if (testSet(this.set[i], version, this.options)) {
1208        return true
1209      }
1210    }
1211    return false
1212  }
1213  
1214  function testSet (set, version, options) {
1215    for (var i = 0; i < set.length; i++) {
1216      if (!set[i].test(version)) {
1217        return false
1218      }
1219    }
1220  
1221    if (version.prerelease.length && !options.includePrerelease) {
1222      // Find the set of versions that are allowed to have prereleases
1223      // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
1224      // That should allow `1.2.3-pr.2` to pass.
1225      // However, `1.2.4-alpha.notready` should NOT be allowed,
1226      // even though it's within the range set by the comparators.
1227      for (i = 0; i < set.length; i++) {
1228        debug(set[i].semver)
1229        if (set[i].semver === ANY) {
1230          continue
1231        }
1232  
1233        if (set[i].semver.prerelease.length > 0) {
1234          var allowed = set[i].semver
1235          if (allowed.major === version.major &&
1236              allowed.minor === version.minor &&
1237              allowed.patch === version.patch) {
1238            return true
1239          }
1240        }
1241      }
1242  
1243      // Version has a -pre, but it's not one of the ones we like.
1244      return false
1245    }
1246  
1247    return true
1248  }
1249  
1250  exports.satisfies = satisfies
1251  function satisfies (version, range, options) {
1252    try {
1253      range = new Range(range, options)
1254    } catch (er) {
1255      return false
1256    }
1257    return range.test(version)
1258  }
1259  
1260  exports.maxSatisfying = maxSatisfying
1261  function maxSatisfying (versions, range, options) {
1262    var max = null
1263    var maxSV = null
1264    try {
1265      var rangeObj = new Range(range, options)
1266    } catch (er) {
1267      return null
1268    }
1269    versions.forEach(function (v) {
1270      if (rangeObj.test(v)) {
1271        // satisfies(v, range, options)
1272        if (!max || maxSV.compare(v) === -1) {
1273          // compare(max, v, true)
1274          max = v
1275          maxSV = new SemVer(max, options)
1276        }
1277      }
1278    })
1279    return max
1280  }
1281  
1282  exports.minSatisfying = minSatisfying
1283  function minSatisfying (versions, range, options) {
1284    var min = null
1285    var minSV = null
1286    try {
1287      var rangeObj = new Range(range, options)
1288    } catch (er) {
1289      return null
1290    }
1291    versions.forEach(function (v) {
1292      if (rangeObj.test(v)) {
1293        // satisfies(v, range, options)
1294        if (!min || minSV.compare(v) === 1) {
1295          // compare(min, v, true)
1296          min = v
1297          minSV = new SemVer(min, options)
1298        }
1299      }
1300    })
1301    return min
1302  }
1303  
1304  exports.minVersion = minVersion
1305  function minVersion (range, loose) {
1306    range = new Range(range, loose)
1307  
1308    var minver = new SemVer('0.0.0')
1309    if (range.test(minver)) {
1310      return minver
1311    }
1312  
1313    minver = new SemVer('0.0.0-0')
1314    if (range.test(minver)) {
1315      return minver
1316    }
1317  
1318    minver = null
1319    for (var i = 0; i < range.set.length; ++i) {
1320      var comparators = range.set[i]
1321  
1322      comparators.forEach(function (comparator) {
1323        // Clone to avoid manipulating the comparator's semver object.
1324        var compver = new SemVer(comparator.semver.version)
1325        switch (comparator.operator) {
1326          case '>':
1327            if (compver.prerelease.length === 0) {
1328              compver.patch++
1329            } else {
1330              compver.prerelease.push(0)
1331            }
1332            compver.raw = compver.format()
1333            /* fallthrough */
1334          case '':
1335          case '>=':
1336            if (!minver || gt(minver, compver)) {
1337              minver = compver
1338            }
1339            break
1340          case '<':
1341          case '<=':
1342            /* Ignore maximum versions */
1343            break
1344          /* istanbul ignore next */
1345          default:
1346            throw new Error('Unexpected operation: ' + comparator.operator)
1347        }
1348      })
1349    }
1350  
1351    if (minver && range.test(minver)) {
1352      return minver
1353    }
1354  
1355    return null
1356  }
1357  
1358  exports.validRange = validRange
1359  function validRange (range, options) {
1360    try {
1361      // Return '*' instead of '' so that truthiness works.
1362      // This will throw if it's invalid anyway
1363      return new Range(range, options).range || '*'
1364    } catch (er) {
1365      return null
1366    }
1367  }
1368  
1369  // Determine if version is less than all the versions possible in the range
1370  exports.ltr = ltr
1371  function ltr (version, range, options) {
1372    return outside(version, range, '<', options)
1373  }
1374  
1375  // Determine if version is greater than all the versions possible in the range.
1376  exports.gtr = gtr
1377  function gtr (version, range, options) {
1378    return outside(version, range, '>', options)
1379  }
1380  
1381  exports.outside = outside
1382  function outside (version, range, hilo, options) {
1383    version = new SemVer(version, options)
1384    range = new Range(range, options)
1385  
1386    var gtfn, ltefn, ltfn, comp, ecomp
1387    switch (hilo) {
1388      case '>':
1389        gtfn = gt
1390        ltefn = lte
1391        ltfn = lt
1392        comp = '>'
1393        ecomp = '>='
1394        break
1395      case '<':
1396        gtfn = lt
1397        ltefn = gte
1398        ltfn = gt
1399        comp = '<'
1400        ecomp = '<='
1401        break
1402      default:
1403        throw new TypeError('Must provide a hilo val of "<" or ">"')
1404    }
1405  
1406    // If it satisifes the range it is not outside
1407    if (satisfies(version, range, options)) {
1408      return false
1409    }
1410  
1411    // From now on, variable terms are as if we're in "gtr" mode.
1412    // but note that everything is flipped for the "ltr" function.
1413  
1414    for (var i = 0; i < range.set.length; ++i) {
1415      var comparators = range.set[i]
1416  
1417      var high = null
1418      var low = null
1419  
1420      comparators.forEach(function (comparator) {
1421        if (comparator.semver === ANY) {
1422          comparator = new Comparator('>=0.0.0')
1423        }
1424        high = high || comparator
1425        low = low || comparator
1426        if (gtfn(comparator.semver, high.semver, options)) {
1427          high = comparator
1428        } else if (ltfn(comparator.semver, low.semver, options)) {
1429          low = comparator
1430        }
1431      })
1432  
1433      // If the edge version comparator has a operator then our version
1434      // isn't outside it
1435      if (high.operator === comp || high.operator === ecomp) {
1436        return false
1437      }
1438  
1439      // If the lowest version comparator has an operator and our version
1440      // is less than it then it isn't higher than the range
1441      if ((!low.operator || low.operator === comp) &&
1442          ltefn(version, low.semver)) {
1443        return false
1444      } else if (low.operator === ecomp && ltfn(version, low.semver)) {
1445        return false
1446      }
1447    }
1448    return true
1449  }
1450  
1451  exports.prerelease = prerelease
1452  function prerelease (version, options) {
1453    var parsed = parse(version, options)
1454    return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
1455  }
1456  
1457  exports.intersects = intersects
1458  function intersects (r1, r2, options) {
1459    r1 = new Range(r1, options)
1460    r2 = new Range(r2, options)
1461    return r1.intersects(r2)
1462  }
1463  
1464  exports.coerce = coerce
1465  function coerce (version) {
1466    if (version instanceof SemVer) {
1467      return version
1468    }
1469  
1470    if (typeof version !== 'string') {
1471      return null
1472    }
1473  
1474    var match = version.match(re[COERCE])
1475  
1476    if (match == null) {
1477      return null
1478    }
1479  
1480    return parse(match[1] +
1481      '.' + (match[2] || '0') +
1482      '.' + (match[3] || '0'))
1483  }