LCSOGthb / Tools

exports = module.exports = SemVer

var debug

/* istanbul ignore next */

if (typeof process === 'object' &&

    process.env &&

    process.env.NODE_DEBUG &&

    /\bsemver\b/i.test(process.env.NODE_DEBUG)) {

  debug = function () {

    var args = Array.prototype.slice.call(arguments, 0)

    args.unshift('SEMVER')

    console.log.apply(console, args)

  }

} else {

  debug = function () {}

}

// Note: this is the semver.org version of the spec that it implements

// Not necessarily the package version of this code.

exports.SEMVER_SPEC_VERSION = '2.0.0'

var MAX_LENGTH = 256

var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||

  /* istanbul ignore next */ 9007199254740991

// Max safe segment length for coercion.

var MAX_SAFE_COMPONENT_LENGTH = 16

var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6

// The actual regexps go on exports.re

var re = exports.re = []

var safeRe = exports.safeRe = []

var src = exports.src = []

var R = 0

var LETTERDASHNUMBER = '[a-zA-Z0-9-]'

// Replace some greedy regex tokens to prevent regex dos issues. These regex are

// used internally via the safeRe object since all inputs in this library get

// normalized first to trim and collapse all extra whitespace. The original

// regexes are exported for userland consumption and lower level usage. A

// future breaking change could export the safer regex only with a note that

// all input should have extra whitespace removed.

var safeRegexReplacements = [

  ['\\s', 1],

  ['\\d', MAX_LENGTH],

  [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],

]

function makeSafeRe (value) {

  for (var i = 0; i < safeRegexReplacements.length; i++) {

    var token = safeRegexReplacements[i][0]

    var max = safeRegexReplacements[i][1]

    value = value

      .split(token + '*').join(token + '{0,' + max + '}')

      .split(token + '+').join(token + '{1,' + max + '}')

  }

  return value

}

// The following Regular Expressions can be used for tokenizing,

// validating, and parsing SemVer version strings.

// ## Numeric Identifier

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

var NUMERICIDENTIFIER = R++

src[NUMERICIDENTIFIER] = '0|[1-9]\\d*'

var NUMERICIDENTIFIERLOOSE = R++

src[NUMERICIDENTIFIERLOOSE] = '\\d+'

// ## Non-numeric Identifier

// Zero or more digits, followed by a letter or hyphen, and then zero or

// more letters, digits, or hyphens.

var NONNUMERICIDENTIFIER = R++

src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-]' + LETTERDASHNUMBER + '*'

// ## Main Version

// Three dot-separated numeric identifiers.

var MAINVERSION = R++

src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' +

                   '(' + src[NUMERICIDENTIFIER] + ')\\.' +

                   '(' + src[NUMERICIDENTIFIER] + ')'

var MAINVERSIONLOOSE = R++

src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +

                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +

                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')'

// ## Pre-release Version Identifier

// A numeric identifier, or a non-numeric identifier.

var PRERELEASEIDENTIFIER = R++

src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] +

                            '|' + src[NONNUMERICIDENTIFIER] + ')'

var PRERELEASEIDENTIFIERLOOSE = R++

src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] +

                                 '|' + src[NONNUMERICIDENTIFIER] + ')'

// ## Pre-release Version

// Hyphen, followed by one or more dot-separated pre-release version

// identifiers.

var PRERELEASE = R++

src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] +

                  '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))'

var PRERELEASELOOSE = R++

src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] +

                       '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))'

// ## Build Metadata Identifier

// Any combination of digits, letters, or hyphens.

var BUILDIDENTIFIER = R++

src[BUILDIDENTIFIER] = LETTERDASHNUMBER + '+'

// ## Build Metadata

// Plus sign, followed by one or more period-separated build metadata

// identifiers.

var BUILD = R++

src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] +

             '(?:\\.' + src[BUILDIDENTIFIER] + ')*))'

// ## Full Version String

// A main version, followed optionally by a pre-release version and

// build metadata.

// Note that the only major, minor, patch, and pre-release sections of

// the version string are capturing groups.  The build metadata is not a

// capturing group, because it should not ever be used in version

// comparison.

var FULL = R++

var FULLPLAIN = 'v?' + src[MAINVERSION] +

                src[PRERELEASE] + '?' +

                src[BUILD] + '?'

src[FULL] = '^' + FULLPLAIN + '$'

// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.

// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty

// common in the npm registry.

var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] +

                 src[PRERELEASELOOSE] + '?' +

                 src[BUILD] + '?'

var LOOSE = R++

src[LOOSE] = '^' + LOOSEPLAIN + '$'

var GTLT = R++

src[GTLT] = '((?:<|>)?=?)'

// Something like "2.*" or "1.2.x".

// Note that "x.x" is a valid xRange identifer, meaning "any version"

// Only the first item is strictly required.

var XRANGEIDENTIFIERLOOSE = R++

src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'

var XRANGEIDENTIFIER = R++

src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*'

var XRANGEPLAIN = R++

src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' +

                   '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +

                   '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +

                   '(?:' + src[PRERELEASE] + ')?' +

                   src[BUILD] + '?' +

                   ')?)?'

var XRANGEPLAINLOOSE = R++

src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +

                        '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +

                        '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +

                        '(?:' + src[PRERELEASELOOSE] + ')?' +

                        src[BUILD] + '?' +

                        ')?)?'

var XRANGE = R++

src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$'

var XRANGELOOSE = R++

src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$'

// Coercion.

// Extract anything that could conceivably be a part of a valid semver

var COERCE = R++

src[COERCE] = '(?:^|[^\\d])' +

              '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +

              '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +

              '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +

              '(?:$|[^\\d])'

// Tilde ranges.

// Meaning is "reasonably at or greater than"

var LONETILDE = R++

src[LONETILDE] = '(?:~>?)'

var TILDETRIM = R++

src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+'

re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g')

safeRe[TILDETRIM] = new RegExp(makeSafeRe(src[TILDETRIM]), 'g')

var tildeTrimReplace = '$1~'

var TILDE = R++

src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$'

var TILDELOOSE = R++

src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$'

// Caret ranges.

// Meaning is "at least and backwards compatible with"

var LONECARET = R++

src[LONECARET] = '(?:\\^)'

var CARETTRIM = R++

src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+'

re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g')

safeRe[CARETTRIM] = new RegExp(makeSafeRe(src[CARETTRIM]), 'g')

var caretTrimReplace = '$1^'

var CARET = R++

src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$'

var CARETLOOSE = R++

src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$'

// A simple gt/lt/eq thing, or just "" to indicate "any version"

var COMPARATORLOOSE = R++

src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$'

var COMPARATOR = R++

src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$'

// An expression to strip any whitespace between the gtlt and the thing

// it modifies, so that `> 1.2.3` ==> `>1.2.3`

var COMPARATORTRIM = R++

src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] +

                      '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')'

// this one has to use the /g flag

re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g')

safeRe[COMPARATORTRIM] = new RegExp(makeSafeRe(src[COMPARATORTRIM]), 'g')

var comparatorTrimReplace = '$1$2$3'

// Something like `1.2.3 - 1.2.4`

// Note that these all use the loose form, because they'll be

// checked against either the strict or loose comparator form

// later.

var HYPHENRANGE = R++

src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' +

                   '\\s+-\\s+' +

                   '(' + src[XRANGEPLAIN] + ')' +

                   '\\s*$'

var HYPHENRANGELOOSE = R++

src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' +

                        '\\s+-\\s+' +

                        '(' + src[XRANGEPLAINLOOSE] + ')' +

                        '\\s*$'

// Star ranges basically just allow anything at all.

var STAR = R++

src[STAR] = '(<|>)?=?\\s*\\*'

// Compile to actual regexp objects.

// All are flag-free, unless they were created above with a flag.

for (var i = 0; i < R; i++) {

  debug(i, src[i])

  if (!re[i]) {

    re[i] = new RegExp(src[i])

    // Replace all greedy whitespace to prevent regex dos issues. These regex are

    // used internally via the safeRe object since all inputs in this library get

    // normalized first to trim and collapse all extra whitespace. The original

    // regexes are exported for userland consumption and lower level usage. A

    // future breaking change could export the safer regex only with a note that

    // all input should have extra whitespace removed.

    safeRe[i] = new RegExp(makeSafeRe(src[i]))

  }

}

exports.parse = parse

function parse (version, options) {

  if (!options || typeof options !== 'object') {

    options = {

      loose: !!options,

      includePrerelease: false

    }

  }

  if (version instanceof SemVer) {

    return version

  }

  if (typeof version !== 'string') {

    return null

  }

  if (version.length > MAX_LENGTH) {

    return null

  }

  var r = options.loose ? safeRe[LOOSE] : safeRe[FULL]

  if (!r.test(version)) {

    return null

  }

  try {

    return new SemVer(version, options)

  } catch (er) {

    return null

  }

}

exports.valid = valid

function valid (version, options) {

  var v = parse(version, options)

  return v ? v.version : null

}

exports.clean = clean

function clean (version, options) {

  var s = parse(version.trim().replace(/^[=v]+/, ''), options)

  return s ? s.version : null

}

exports.SemVer = SemVer

function SemVer (version, options) {

  if (!options || typeof options !== 'object') {

    options = {

      loose: !!options,

      includePrerelease: false

    }

  }

  if (version instanceof SemVer) {

    if (version.loose === options.loose) {

      return version

    } else {

      version = version.version

    }

  } else if (typeof version !== 'string') {

    throw new TypeError('Invalid Version: ' + version)

  }

  if (version.length > MAX_LENGTH) {

    throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')

  }

  if (!(this instanceof SemVer)) {

    return new SemVer(version, options)

  }

  debug('SemVer', version, options)

  this.options = options

  this.loose = !!options.loose

  var m = version.trim().match(options.loose ? safeRe[LOOSE] : safeRe[FULL])

  if (!m) {

    throw new TypeError('Invalid Version: ' + version)

  }

  this.raw = version

  // these are actually numbers

  this.major = +m[1]

  this.minor = +m[2]

  this.patch = +m[3]

  if (this.major > MAX_SAFE_INTEGER || this.major < 0) {

    throw new TypeError('Invalid major version')

  }

  if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {

    throw new TypeError('Invalid minor version')

  }

  if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {

    throw new TypeError('Invalid patch version')

  }

  // numberify any prerelease numeric ids

  if (!m[4]) {

    this.prerelease = []

  } else {

    this.prerelease = m[4].split('.').map(function (id) {

      if (/^[0-9]+$/.test(id)) {

        var num = +id

        if (num >= 0 && num < MAX_SAFE_INTEGER) {

          return num

        }

      }

      return id

    })

  }

  this.build = m[5] ? m[5].split('.') : []

  this.format()

}

SemVer.prototype.format = function () {

  this.version = this.major + '.' + this.minor + '.' + this.patch

  if (this.prerelease.length) {

    this.version += '-' + this.prerelease.join('.')

  }

  return this.version

}

SemVer.prototype.toString = function () {

  return this.version

}

SemVer.prototype.compare = function (other) {

  debug('SemVer.compare', this.version, this.options, other)

  if (!(other instanceof SemVer)) {

    other = new SemVer(other, this.options)

  }

  return this.compareMain(other) || this.comparePre(other)

}

SemVer.prototype.compareMain = function (other) {

  if (!(other instanceof SemVer)) {

    other = new SemVer(other, this.options)

  }

  return compareIdentifiers(this.major, other.major) ||

         compareIdentifiers(this.minor, other.minor) ||

         compareIdentifiers(this.patch, other.patch)

}

SemVer.prototype.comparePre = function (other) {

  if (!(other instanceof SemVer)) {

    other = new SemVer(other, this.options)

  }

  // NOT having a prerelease is > having one

  if (this.prerelease.length && !other.prerelease.length) {

    return -1

  } else if (!this.prerelease.length && other.prerelease.length) {

    return 1

  } else if (!this.prerelease.length && !other.prerelease.length) {

    return 0

  }

  var i = 0

  do {

    var a = this.prerelease[i]

    var b = other.prerelease[i]

    debug('prerelease compare', i, a, b)

    if (a === undefined && b === undefined) {

      return 0

    } else if (b === undefined) {

      return 1

    } else if (a === undefined) {

      return -1

    } else if (a === b) {

      continue

    } else {

      return compareIdentifiers(a, b)

    }

  } while (++i)

}

// preminor will bump the version up to the next minor release, and immediately

// down to pre-release. premajor and prepatch work the same way.

SemVer.prototype.inc = function (release, identifier) {

  switch (release) {

    case 'premajor':

      this.prerelease.length = 0

      this.patch = 0

      this.minor = 0

      this.major++

      this.inc('pre', identifier)

      break

    case 'preminor':

      this.prerelease.length = 0

      this.patch = 0

      this.minor++

      this.inc('pre', identifier)

      break

    case 'prepatch':

      // If this is already a prerelease, it will bump to the next version

      // drop any prereleases that might already exist, since they are not

      // relevant at this point.

      this.prerelease.length = 0

      this.inc('patch', identifier)

      this.inc('pre', identifier)

      break

    // If the input is a non-prerelease version, this acts the same as

    // prepatch.

    case 'prerelease':

      if (this.prerelease.length === 0) {

        this.inc('patch', identifier)

      }

      this.inc('pre', identifier)

      break

    case 'major':

      // If this is a pre-major version, bump up to the same major version.

      // Otherwise increment major.

      // 1.0.0-5 bumps to 1.0.0

      // 1.1.0 bumps to 2.0.0

      if (this.minor !== 0 ||

          this.patch !== 0 ||

          this.prerelease.length === 0) {

        this.major++

      }

      this.minor = 0

      this.patch = 0

      this.prerelease = []

      break

    case 'minor':

      // If this is a pre-minor version, bump up to the same minor version.

      // Otherwise increment minor.

      // 1.2.0-5 bumps to 1.2.0

      // 1.2.1 bumps to 1.3.0

      if (this.patch !== 0 || this.prerelease.length === 0) {

        this.minor++

      }

      this.patch = 0

      this.prerelease = []

      break

    case 'patch':

      // If this is not a pre-release version, it will increment the patch.

      // If it is a pre-release it will bump up to the same patch version.

      // 1.2.0-5 patches to 1.2.0

      // 1.2.0 patches to 1.2.1

      if (this.prerelease.length === 0) {

        this.patch++

      }

      this.prerelease = []

      break

    // This probably shouldn't be used publicly.

    // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction.

    case 'pre':

      if (this.prerelease.length === 0) {

        this.prerelease = [0]

      } else {

        var i = this.prerelease.length

        while (--i >= 0) {

          if (typeof this.prerelease[i] === 'number') {

            this.prerelease[i]++

            i = -2

          }

        }

        if (i === -1) {

          // didn't increment anything

          this.prerelease.push(0)

        }

      }

      if (identifier) {

        // 1.2.0-beta.1 bumps to 1.2.0-beta.2,

        // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0

        if (this.prerelease[0] === identifier) {

          if (isNaN(this.prerelease[1])) {

            this.prerelease = [identifier, 0]

          }

        } else {

          this.prerelease = [identifier, 0]

        }

      }

      break

    default:

      throw new Error('invalid increment argument: ' + release)

  }

  this.format()

  this.raw = this.version

  return this

}

exports.inc = inc

function inc (version, release, loose, identifier) {

  if (typeof (loose) === 'string') {

    identifier = loose

    loose = undefined

  }

  try {

    return new SemVer(version, loose).inc(release, identifier).version

  } catch (er) {

    return null

  }

}

exports.diff = diff

function diff (version1, version2) {

  if (eq(version1, version2)) {

    return null

  } else {

    var v1 = parse(version1)

    var v2 = parse(version2)

    var prefix = ''

    if (v1.prerelease.length || v2.prerelease.length) {

      prefix = 'pre'

      var defaultResult = 'prerelease'

    }

    for (var key in v1) {

      if (key === 'major' || key === 'minor' || key === 'patch') {

        if (v1[key] !== v2[key]) {

          return prefix + key

        }

      }

    }

    return defaultResult // may be undefined

  }

}

exports.compareIdentifiers = compareIdentifiers

var numeric = /^[0-9]+$/

function compareIdentifiers (a, b) {

  var anum = numeric.test(a)

  var bnum = numeric.test(b)

  if (anum && bnum) {

    a = +a

    b = +b

  }

  return a === b ? 0

    : (anum && !bnum) ? -1

    : (bnum && !anum) ? 1

    : a < b ? -1

    : 1

}

exports.rcompareIdentifiers = rcompareIdentifiers

function rcompareIdentifiers (a, b) {

  return compareIdentifiers(b, a)

}

exports.major = major

function major (a, loose) {

  return new SemVer(a, loose).major

}

exports.minor = minor

function minor (a, loose) {

  return new SemVer(a, loose).minor

}

exports.patch = patch

function patch (a, loose) {

  return new SemVer(a, loose).patch

}

exports.compare = compare

function compare (a, b, loose) {

  return new SemVer(a, loose).compare(new SemVer(b, loose))

}

exports.compareLoose = compareLoose

function compareLoose (a, b) {

  return compare(a, b, true)

}

exports.rcompare = rcompare

function rcompare (a, b, loose) {

  return compare(b, a, loose)

}

exports.sort = sort

function sort (list, loose) {

  return list.sort(function (a, b) {

    return exports.compare(a, b, loose)

  })

}

exports.rsort = rsort

function rsort (list, loose) {

  return list.sort(function (a, b) {

    return exports.rcompare(a, b, loose)

  })

}

exports.gt = gt

function gt (a, b, loose) {

  return compare(a, b, loose) > 0

}

exports.lt = lt

function lt (a, b, loose) {

  return compare(a, b, loose) < 0

}

exports.eq = eq

function eq (a, b, loose) {

  return compare(a, b, loose) === 0

}

exports.neq = neq

function neq (a, b, loose) {

  return compare(a, b, loose) !== 0

}

exports.gte = gte

function gte (a, b, loose) {

  return compare(a, b, loose) >= 0

}

exports.lte = lte

function lte (a, b, loose) {

  return compare(a, b, loose) <= 0

}

exports.cmp = cmp

function cmp (a, op, b, loose) {

  switch (op) {

    case '===':

      if (typeof a === 'object')

        a = a.version

      if (typeof b === 'object')

        b = b.version

      return a === b

    case '!==':

      if (typeof a === 'object')

        a = a.version

      if (typeof b === 'object')

        b = b.version

      return a !== b

    case '':

    case '=':

    case '==':

      return eq(a, b, loose)

    case '!=':

      return neq(a, b, loose)

    case '>':

      return gt(a, b, loose)

    case '>=':

      return gte(a, b, loose)

    case '<':

      return lt(a, b, loose)

    case '<=':

      return lte(a, b, loose)

    default:

      throw new TypeError('Invalid operator: ' + op)

  }

}

exports.Comparator = Comparator

function Comparator (comp, options) {

  if (!options || typeof options !== 'object') {

    options = {

      loose: !!options,

      includePrerelease: false

    }

  }

  if (comp instanceof Comparator) {

    if (comp.loose === !!options.loose) {

      return comp

    } else {

      comp = comp.value

    }

  }

  if (!(this instanceof Comparator)) {

    return new Comparator(comp, options)

  }

  comp = comp.trim().split(/\s+/).join(' ')

  debug('comparator', comp, options)

  this.options = options

  this.loose = !!options.loose

  this.parse(comp)

  if (this.semver === ANY) {

    this.value = ''

  } else {

    this.value = this.operator + this.semver.version

  }

  debug('comp', this)

}

var ANY = {}

Comparator.prototype.parse = function (comp) {

  var r = this.options.loose ? safeRe[COMPARATORLOOSE] : safeRe[COMPARATOR]

  var m = comp.match(r)

  if (!m) {

    throw new TypeError('Invalid comparator: ' + comp)

  }

  this.operator = m[1]

  if (this.operator === '=') {

    this.operator = ''

  }

  // if it literally is just '>' or '' then allow anything.

  if (!m[2]) {

    this.semver = ANY

  } else {

    this.semver = new SemVer(m[2], this.options.loose)

  }

}

Comparator.prototype.toString = function () {

  return this.value

}

Comparator.prototype.test = function (version) {

  debug('Comparator.test', version, this.options.loose)

  if (this.semver === ANY) {

    return true

  }

  if (typeof version === 'string') {

    version = new SemVer(version, this.options)

  }

  return cmp(version, this.operator, this.semver, this.options)

}

Comparator.prototype.intersects = function (comp, options) {

  if (!(comp instanceof Comparator)) {

    throw new TypeError('a Comparator is required')

  }

  if (!options || typeof options !== 'object') {

    options = {

      loose: !!options,

      includePrerelease: false

    }

  }

  var rangeTmp

  if (this.operator === '') {

    rangeTmp = new Range(comp.value, options)

    return satisfies(this.value, rangeTmp, options)

  } else if (comp.operator === '') {

    rangeTmp = new Range(this.value, options)

    return satisfies(comp.semver, rangeTmp, options)

  }

  var sameDirectionIncreasing =

    (this.operator === '>=' || this.operator === '>') &&

    (comp.operator === '>=' || comp.operator === '>')

  var sameDirectionDecreasing =

    (this.operator === '<=' || this.operator === '<') &&

    (comp.operator === '<=' || comp.operator === '<')

  var sameSemVer = this.semver.version === comp.semver.version

  var differentDirectionsInclusive =

    (this.operator === '>=' || this.operator === '<=') &&

    (comp.operator === '>=' || comp.operator === '<=')

  var oppositeDirectionsLessThan =

    cmp(this.semver, '<', comp.semver, options) &&

    ((this.operator === '>=' || this.operator === '>') &&

    (comp.operator === '<=' || comp.operator === '<'))

  var oppositeDirectionsGreaterThan =

    cmp(this.semver, '>', comp.semver, options) &&

    ((this.operator === '<=' || this.operator === '<') &&

    (comp.operator === '>=' || comp.operator === '>'))

  return sameDirectionIncreasing || sameDirectionDecreasing ||

    (sameSemVer && differentDirectionsInclusive) ||

    oppositeDirectionsLessThan || oppositeDirectionsGreaterThan

}

exports.Range = Range

function Range (range, options) {

  if (!options || typeof options !== 'object') {

    options = {

      loose: !!options,

      includePrerelease: false

    }

  }

  if (range instanceof Range) {

    if (range.loose === !!options.loose &&

        range.includePrerelease === !!options.includePrerelease) {

      return range

    } else {

      return new Range(range.raw, options)

    }

  }

  if (range instanceof Comparator) {

    return new Range(range.value, options)

  }

  if (!(this instanceof Range)) {

    return new Range(range, options)

  }

  this.options = options

  this.loose = !!options.loose

  this.includePrerelease = !!options.includePrerelease

  // First reduce all whitespace as much as possible so we do not have to rely

  // on potentially slow regexes like \s*. This is then stored and used for

  // future error messages as well.

  this.raw = range

    .trim()

    .split(/\s+/)

    .join(' ')

  // First, split based on boolean or ||

  this.set = this.raw.split('||').map(function (range) {

    return this.parseRange(range.trim())

  }, this).filter(function (c) {

    // throw out any that are not relevant for whatever reason

    return c.length

  })

  if (!this.set.length) {

    throw new TypeError('Invalid SemVer Range: ' + this.raw)

  }

  this.format()

}

Range.prototype.format = function () {

  this.range = this.set.map(function (comps) {

    return comps.join(' ').trim()

  }).join('||').trim()

  return this.range

}

Range.prototype.toString = function () {

  return this.range

}

Range.prototype.parseRange = function (range) {

  var loose = this.options.loose

  // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`

  var hr = loose ? safeRe[HYPHENRANGELOOSE] : safeRe[HYPHENRANGE]

  range = range.replace(hr, hyphenReplace)

  debug('hyphen replace', range)

  // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`

  range = range.replace(safeRe[COMPARATORTRIM], comparatorTrimReplace)

  debug('comparator trim', range, safeRe[COMPARATORTRIM])

  // `~ 1.2.3` => `~1.2.3`

  range = range.replace(safeRe[TILDETRIM], tildeTrimReplace)

  // `^ 1.2.3` => `^1.2.3`

  range = range.replace(safeRe[CARETTRIM], caretTrimReplace)

  // At this point, the range is completely trimmed and

  // ready to be split into comparators.

  var compRe = loose ? safeRe[COMPARATORLOOSE] : safeRe[COMPARATOR]

  var set = range.split(' ').map(function (comp) {

    return parseComparator(comp, this.options)

  }, this).join(' ').split(/\s+/)

  if (this.options.loose) {

    // in loose mode, throw out any that are not valid comparators

    set = set.filter(function (comp) {

      return !!comp.match(compRe)

    })

  }

  set = set.map(function (comp) {

    return new Comparator(comp, this.options)

  }, this)

  return set

}

Range.prototype.intersects = function (range, options) {

  if (!(range instanceof Range)) {

    throw new TypeError('a Range is required')

  }

  return this.set.some(function (thisComparators) {

    return thisComparators.every(function (thisComparator) {

      return range.set.some(function (rangeComparators) {

        return rangeComparators.every(function (rangeComparator) {

          return thisComparator.intersects(rangeComparator, options)

        })

      })

    })

  })

}

// Mostly just for testing and legacy API reasons

exports.toComparators = toComparators

function toComparators (range, options) {

  return new Range(range, options).set.map(function (comp) {

    return comp.map(function (c) {

      return c.value

    }).join(' ').trim().split(' ')

  })

}

// comprised of xranges, tildes, stars, and gtlt's at this point.

// already replaced the hyphen ranges

// turn into a set of JUST comparators.

function parseComparator (comp, options) {

  debug('comp', comp, options)

  comp = replaceCarets(comp, options)

  debug('caret', comp)

  comp = replaceTildes(comp, options)

  debug('tildes', comp)

  comp = replaceXRanges(comp, options)

  debug('xrange', comp)

  comp = replaceStars(comp, options)

  debug('stars', comp)

  return comp

}

function isX (id) {

  return !id || id.toLowerCase() === 'x' || id === '*'

}

// ~, ~> --> * (any, kinda silly)

// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0

// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0

// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0

// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0

// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0

function replaceTildes (comp, options) {

  return comp.trim().split(/\s+/).map(function (comp) {

    return replaceTilde(comp, options)

  }).join(' ')

}

function replaceTilde (comp, options) {

  var r = options.loose ? safeRe[TILDELOOSE] : safeRe[TILDE]

  return comp.replace(r, function (_, M, m, p, pr) {

    debug('tilde', comp, _, M, m, p, pr)

    var ret

    if (isX(M)) {

      ret = ''

    } else if (isX(m)) {

      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'

    } else if (isX(p)) {

      // ~1.2 == >=1.2.0 <1.3.0

      ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'

    } else if (pr) {

      debug('replaceTilde pr', pr)

      ret = '>=' + M + '.' + m + '.' + p + '-' + pr +

            ' <' + M + '.' + (+m + 1) + '.0'

    } else {

      // ~1.2.3 == >=1.2.3 <1.3.0

      ret = '>=' + M + '.' + m + '.' + p +

            ' <' + M + '.' + (+m + 1) + '.0'

    }

    debug('tilde return', ret)

    return ret

  })

}

// ^ --> * (any, kinda silly)

// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0

// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0

// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0

// ^1.2.3 --> >=1.2.3 <2.0.0

// ^1.2.0 --> >=1.2.0 <2.0.0

function replaceCarets (comp, options) {

  return comp.trim().split(/\s+/).map(function (comp) {

    return replaceCaret(comp, options)

  }).join(' ')

}

function replaceCaret (comp, options) {

  debug('caret', comp, options)

  var r = options.loose ? safeRe[CARETLOOSE] : safeRe[CARET]

  return comp.replace(r, function (_, M, m, p, pr) {

    debug('caret', comp, _, M, m, p, pr)

    var ret

    if (isX(M)) {

      ret = ''

    } else if (isX(m)) {

      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'

    } else if (isX(p)) {

      if (M === '0') {

        ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'

      } else {

        ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0'

      }

    } else if (pr) {

      debug('replaceCaret pr', pr)

      if (M === '0') {

        if (m === '0') {

          ret = '>=' + M + '.' + m + '.' + p + '-' + pr +

                ' <' + M + '.' + m + '.' + (+p + 1)

        } else {

          ret = '>=' + M + '.' + m + '.' + p + '-' + pr +

                ' <' + M + '.' + (+m + 1) + '.0'

        }

      } else {

        ret = '>=' + M + '.' + m + '.' + p + '-' + pr +

              ' <' + (+M + 1) + '.0.0'

      }

    } else {

      debug('no pr')

      if (M === '0') {

        if (m === '0') {