{"ast":null,"code":"// hoisted class for cyclic dependency\nclass Range {\n  constructor(range, options) {\n    options = parseOptions(options);\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    if (range instanceof Comparator) {\n      // just put it in the set and return\n      this.raw = range.value;\n      this.set = [[range]];\n      this.format();\n      return this;\n    }\n    this.options = options;\n    this.loose = !!options.loose;\n    this.includePrerelease = !!options.includePrerelease;\n\n    // First, split based on boolean or ||\n    this.raw = range;\n    this.set = range.split('||')\n    // map the range to a 2d array of comparators\n    .map(r => this.parseRange(r.trim()))\n    // throw out any comparator lists that are empty\n    // this generally means that it was not a valid range, which is allowed\n    // in loose mode, but will still throw if the WHOLE range is invalid.\n    .filter(c => c.length);\n    if (!this.set.length) {\n      throw new TypeError(`Invalid SemVer Range: ${range}`);\n    }\n\n    // if we have any that are not the null set, throw out null sets.\n    if (this.set.length > 1) {\n      // keep the first one, in case they're all null sets\n      const first = this.set[0];\n      this.set = this.set.filter(c => !isNullSet(c[0]));\n      if (this.set.length === 0) {\n        this.set = [first];\n      } else if (this.set.length > 1) {\n        // if we have any that are *, then the range is just *\n        for (const c of this.set) {\n          if (c.length === 1 && isAny(c[0])) {\n            this.set = [c];\n            break;\n          }\n        }\n      }\n    }\n    this.format();\n  }\n  format() {\n    this.range = this.set.map(comps => {\n      return comps.join(' ').trim();\n    }).join('||').trim();\n    return this.range;\n  }\n  toString() {\n    return this.range;\n  }\n  parseRange(range) {\n    range = range.trim();\n\n    // memoize range parsing for performance.\n    // this is a very hot path, and fully deterministic.\n    const memoOpts = Object.keys(this.options).join(',');\n    const memoKey = `parseRange:${memoOpts}:${range}`;\n    const cached = cache.get(memoKey);\n    if (cached) {\n      return cached;\n    }\n    const loose = this.options.loose;\n    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`\n    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];\n    range = range.replace(hr, hyphenReplace(this.options.includePrerelease));\n    debug('hyphen replace', range);\n    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`\n    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);\n    debug('comparator trim', range);\n\n    // `~ 1.2.3` => `~1.2.3`\n    range = range.replace(re[t.TILDETRIM], tildeTrimReplace);\n\n    // `^ 1.2.3` => `^1.2.3`\n    range = range.replace(re[t.CARETTRIM], caretTrimReplace);\n\n    // normalize spaces\n    range = range.split(/\\s+/).join(' ');\n\n    // At this point, the range is completely trimmed and\n    // ready to be split into comparators.\n\n    let rangeList = range.split(' ').map(comp => parseComparator(comp, this.options)).join(' ').split(/\\s+/)\n    // >=0.0.0 is equivalent to *\n    .map(comp => replaceGTE0(comp, this.options));\n    if (loose) {\n      // in loose mode, throw out any that are not valid comparators\n      rangeList = rangeList.filter(comp => {\n        debug('loose invalid filter', comp, this.options);\n        return !!comp.match(re[t.COMPARATORLOOSE]);\n      });\n    }\n    debug('range list', rangeList);\n\n    // if any comparators are the null set, then replace with JUST null set\n    // if more than one comparator, remove any * comparators\n    // also, don't include the same comparator more than once\n    const rangeMap = new Map();\n    const comparators = rangeList.map(comp => new Comparator(comp, this.options));\n    for (const comp of comparators) {\n      if (isNullSet(comp)) {\n        return [comp];\n      }\n      rangeMap.set(comp.value, comp);\n    }\n    if (rangeMap.size > 1 && rangeMap.has('')) {\n      rangeMap.delete('');\n    }\n    const result = [...rangeMap.values()];\n    cache.set(memoKey, result);\n    return result;\n  }\n  intersects(range, options) {\n    if (!(range instanceof Range)) {\n      throw new TypeError('a Range is required');\n    }\n    return this.set.some(thisComparators => {\n      return isSatisfiable(thisComparators, options) && range.set.some(rangeComparators => {\n        return isSatisfiable(rangeComparators, options) && thisComparators.every(thisComparator => {\n          return rangeComparators.every(rangeComparator => {\n            return thisComparator.intersects(rangeComparator, options);\n          });\n        });\n      });\n    });\n  }\n\n  // if ANY of the sets match ALL of its comparators, then pass\n  test(version) {\n    if (!version) {\n      return false;\n    }\n    if (typeof version === 'string') {\n      try {\n        version = new SemVer(version, this.options);\n      } catch (er) {\n        return false;\n      }\n    }\n    for (let i = 0; i < this.set.length; i++) {\n      if (testSet(this.set[i], version, this.options)) {\n        return true;\n      }\n    }\n    return false;\n  }\n}\nmodule.exports = Range;\nconst LRU = require('lru-cache');\nconst cache = new LRU({\n  max: 1000\n});\nconst parseOptions = require('../internal/parse-options');\nconst Comparator = require('./comparator');\nconst debug = require('../internal/debug');\nconst SemVer = require('./semver');\nconst {\n  re,\n  t,\n  comparatorTrimReplace,\n  tildeTrimReplace,\n  caretTrimReplace\n} = require('../internal/re');\nconst isNullSet = c => c.value === '<0.0.0-0';\nconst isAny = c => c.value === '';\n\n// take a set of comparators and determine whether there\n// exists a version which can satisfy it\nconst isSatisfiable = (comparators, options) => {\n  let result = true;\n  const remainingComparators = comparators.slice();\n  let testComparator = remainingComparators.pop();\n  while (result && remainingComparators.length) {\n    result = remainingComparators.every(otherComparator => {\n      return testComparator.intersects(otherComparator, options);\n    });\n    testComparator = remainingComparators.pop();\n  }\n  return result;\n};\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.\nconst 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};\nconst isX = id => !id || id.toLowerCase() === 'x' || id === '*';\n\n// ~, ~> --> * (any, kinda silly)\n// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0\n// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0\n// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0\n// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0\n// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0\n// ~0.0.1 --> >=0.0.1 <0.1.0-0\nconst replaceTildes = (comp, options) => comp.trim().split(/\\s+/).map(c => {\n  return replaceTilde(c, options);\n}).join(' ');\nconst replaceTilde = (comp, options) => {\n  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];\n  return comp.replace(r, (_, M, m, p, pr) => {\n    debug('tilde', comp, _, M, m, p, pr);\n    let ret;\n    if (isX(M)) {\n      ret = '';\n    } else if (isX(m)) {\n      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;\n    } else if (isX(p)) {\n      // ~1.2 == >=1.2.0 <1.3.0-0\n      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;\n    } else if (pr) {\n      debug('replaceTilde pr', pr);\n      ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;\n    } else {\n      // ~1.2.3 == >=1.2.3 <1.3.0-0\n      ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;\n    }\n    debug('tilde return', ret);\n    return ret;\n  });\n};\n\n// ^ --> * (any, kinda silly)\n// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0\n// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0\n// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0\n// ^1.2.3 --> >=1.2.3 <2.0.0-0\n// ^1.2.0 --> >=1.2.0 <2.0.0-0\n// ^0.0.1 --> >=0.0.1 <0.0.2-0\n// ^0.1.0 --> >=0.1.0 <0.2.0-0\nconst replaceCarets = (comp, options) => comp.trim().split(/\\s+/).map(c => {\n  return replaceCaret(c, options);\n}).join(' ');\nconst replaceCaret = (comp, options) => {\n  debug('caret', comp, options);\n  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];\n  const z = options.includePrerelease ? '-0' : '';\n  return comp.replace(r, (_, M, m, p, pr) => {\n    debug('caret', comp, _, M, m, p, pr);\n    let ret;\n    if (isX(M)) {\n      ret = '';\n    } else if (isX(m)) {\n      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;\n    } else if (isX(p)) {\n      if (M === '0') {\n        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;\n      } else {\n        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;\n      }\n    } else if (pr) {\n      debug('replaceCaret pr', pr);\n      if (M === '0') {\n        if (m === '0') {\n          ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;\n        } else {\n          ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;\n        }\n      } else {\n        ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;\n      }\n    } else {\n      debug('no pr');\n      if (M === '0') {\n        if (m === '0') {\n          ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;\n        } else {\n          ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;\n        }\n      } else {\n        ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;\n      }\n    }\n    debug('caret return', ret);\n    return ret;\n  });\n};\nconst replaceXRanges = (comp, options) => {\n  debug('replaceXRanges', comp, options);\n  return comp.split(/\\s+/).map(c => {\n    return replaceXRange(c, options);\n  }).join(' ');\n};\nconst replaceXRange = (comp, options) => {\n  comp = comp.trim();\n  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];\n  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {\n    debug('xRange', comp, ret, gtlt, M, m, p, pr);\n    const xM = isX(M);\n    const xm = xM || isX(m);\n    const xp = xm || isX(p);\n    const anyX = xp;\n    if (gtlt === '=' && anyX) {\n      gtlt = '';\n    }\n\n    // if we're including prereleases in the match, then we need\n    // to fix this to -0, the lowest possible prerelease value\n    pr = options.includePrerelease ? '-0' : '';\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      p = 0;\n      if (gtlt === '>') {\n        // >1 => >=2.0.0\n        // >1.2 => >=1.3.0\n        gtlt = '>=';\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        if (xm) {\n          M = +M + 1;\n        } else {\n          m = +m + 1;\n        }\n      }\n      if (gtlt === '<') {\n        pr = '-0';\n      }\n      ret = `${gtlt + M}.${m}.${p}${pr}`;\n    } else if (xm) {\n      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;\n    } else if (xp) {\n      ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;\n    }\n    debug('xRange return', ret);\n    return ret;\n  });\n};\n\n// Because * is AND-ed with everything else in the comparator,\n// and '' means \"any version\", just remove the *s entirely.\nconst replaceStars = (comp, options) => {\n  debug('replaceStars', comp, options);\n  // Looseness is ignored here.  star is always as loose as it gets!\n  return comp.trim().replace(re[t.STAR], '');\n};\nconst replaceGTE0 = (comp, options) => {\n  debug('replaceGTE0', comp, options);\n  return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '');\n};\n\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-0 Any 3.4.x will do\n// 1.2 - 3.4 => >=1.2.0 <3.5.0-0\nconst hyphenReplace = incPr => ($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${incPr ? '-0' : ''}`;\n  } else if (isX(fp)) {\n    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`;\n  } else if (fpr) {\n    from = `>=${from}`;\n  } else {\n    from = `>=${from}${incPr ? '-0' : ''}`;\n  }\n  if (isX(tM)) {\n    to = '';\n  } else if (isX(tm)) {\n    to = `<${+tM + 1}.0.0-0`;\n  } else if (isX(tp)) {\n    to = `<${tM}.${+tm + 1}.0-0`;\n  } else if (tpr) {\n    to = `<=${tM}.${tm}.${tp}-${tpr}`;\n  } else if (incPr) {\n    to = `<${tM}.${tm}.${+tp + 1}-0`;\n  } else {\n    to = `<=${to}`;\n  }\n  return `${from} ${to}`.trim();\n};\nconst testSet = (set, version, options) => {\n  for (let i = 0; i < set.length; i++) {\n    if (!set[i].test(version)) {\n      return false;\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 (let i = 0; i < set.length; i++) {\n      debug(set[i].semver);\n      if (set[i].semver === Comparator.ANY) {\n        continue;\n      }\n      if (set[i].semver.prerelease.length > 0) {\n        const allowed = set[i].semver;\n        if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {\n          return true;\n        }\n      }\n    }\n\n    // Version has a -pre, but it's not one of the ones we like.\n    return false;\n  }\n  return true;\n};","map":{"version":3,"names":["Range","constructor","range","options","parseOptions","loose","includePrerelease","raw","Comparator","value","set","format","split","map","r","parseRange","trim","filter","c","length","TypeError","first","isNullSet","isAny","comps","join","toString","memoOpts","Object","keys","memoKey","cached","cache","get","hr","re","t","HYPHENRANGELOOSE","HYPHENRANGE","replace","hyphenReplace","debug","COMPARATORTRIM","comparatorTrimReplace","TILDETRIM","tildeTrimReplace","CARETTRIM","caretTrimReplace","rangeList","comp","parseComparator","replaceGTE0","match","COMPARATORLOOSE","rangeMap","Map","comparators","size","has","delete","result","values","intersects","some","thisComparators","isSatisfiable","rangeComparators","every","thisComparator","rangeComparator","test","version","SemVer","er","i","testSet","module","exports","LRU","require","max","remainingComparators","slice","testComparator","pop","otherComparator","replaceCarets","replaceTildes","replaceXRanges","replaceStars","isX","id","toLowerCase","replaceTilde","TILDELOOSE","TILDE","_","M","m","p","pr","ret","replaceCaret","CARETLOOSE","CARET","z","replaceXRange","XRANGELOOSE","XRANGE","gtlt","xM","xm","xp","anyX","STAR","GTE0PRE","GTE0","incPr","$0","from","fM","fm","fp","fpr","fb","to","tM","tm","tp","tpr","tb","prerelease","semver","ANY","allowed","major","minor","patch"],"sources":["C:/Users/user/Desktop/05mediaSocial/node_modules/jsonwebtoken/node_modules/semver/classes/range.js"],"sourcesContent":["// hoisted class for cyclic dependency\nclass Range {\n  constructor (range, options) {\n    options = parseOptions(options)\n\n    if (range instanceof Range) {\n      if (\n        range.loose === !!options.loose &&\n        range.includePrerelease === !!options.includePrerelease\n      ) {\n        return range\n      } else {\n        return new Range(range.raw, options)\n      }\n    }\n\n    if (range instanceof Comparator) {\n      // just put it in the set and return\n      this.raw = range.value\n      this.set = [[range]]\n      this.format()\n      return this\n    }\n\n    this.options = options\n    this.loose = !!options.loose\n    this.includePrerelease = !!options.includePrerelease\n\n    // First, split based on boolean or ||\n    this.raw = range\n    this.set = range\n      .split('||')\n      // map the range to a 2d array of comparators\n      .map(r => this.parseRange(r.trim()))\n      // throw out any comparator lists that are empty\n      // this generally means that it was not a valid range, which is allowed\n      // in loose mode, but will still throw if the WHOLE range is invalid.\n      .filter(c => c.length)\n\n    if (!this.set.length) {\n      throw new TypeError(`Invalid SemVer Range: ${range}`)\n    }\n\n    // if we have any that are not the null set, throw out null sets.\n    if (this.set.length > 1) {\n      // keep the first one, in case they're all null sets\n      const first = this.set[0]\n      this.set = this.set.filter(c => !isNullSet(c[0]))\n      if (this.set.length === 0) {\n        this.set = [first]\n      } else if (this.set.length > 1) {\n        // if we have any that are *, then the range is just *\n        for (const c of this.set) {\n          if (c.length === 1 && isAny(c[0])) {\n            this.set = [c]\n            break\n          }\n        }\n      }\n    }\n\n    this.format()\n  }\n\n  format () {\n    this.range = this.set\n      .map((comps) => {\n        return comps.join(' ').trim()\n      })\n      .join('||')\n      .trim()\n    return this.range\n  }\n\n  toString () {\n    return this.range\n  }\n\n  parseRange (range) {\n    range = range.trim()\n\n    // memoize range parsing for performance.\n    // this is a very hot path, and fully deterministic.\n    const memoOpts = Object.keys(this.options).join(',')\n    const memoKey = `parseRange:${memoOpts}:${range}`\n    const cached = cache.get(memoKey)\n    if (cached) {\n      return cached\n    }\n\n    const loose = this.options.loose\n    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`\n    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]\n    range = range.replace(hr, hyphenReplace(this.options.includePrerelease))\n    debug('hyphen replace', range)\n    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`\n    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)\n    debug('comparator trim', range)\n\n    // `~ 1.2.3` => `~1.2.3`\n    range = range.replace(re[t.TILDETRIM], tildeTrimReplace)\n\n    // `^ 1.2.3` => `^1.2.3`\n    range = range.replace(re[t.CARETTRIM], caretTrimReplace)\n\n    // normalize spaces\n    range = range.split(/\\s+/).join(' ')\n\n    // At this point, the range is completely trimmed and\n    // ready to be split into comparators.\n\n    let rangeList = range\n      .split(' ')\n      .map(comp => parseComparator(comp, this.options))\n      .join(' ')\n      .split(/\\s+/)\n      // >=0.0.0 is equivalent to *\n      .map(comp => replaceGTE0(comp, this.options))\n\n    if (loose) {\n      // in loose mode, throw out any that are not valid comparators\n      rangeList = rangeList.filter(comp => {\n        debug('loose invalid filter', comp, this.options)\n        return !!comp.match(re[t.COMPARATORLOOSE])\n      })\n    }\n    debug('range list', rangeList)\n\n    // if any comparators are the null set, then replace with JUST null set\n    // if more than one comparator, remove any * comparators\n    // also, don't include the same comparator more than once\n    const rangeMap = new Map()\n    const comparators = rangeList.map(comp => new Comparator(comp, this.options))\n    for (const comp of comparators) {\n      if (isNullSet(comp)) {\n        return [comp]\n      }\n      rangeMap.set(comp.value, comp)\n    }\n    if (rangeMap.size > 1 && rangeMap.has('')) {\n      rangeMap.delete('')\n    }\n\n    const result = [...rangeMap.values()]\n    cache.set(memoKey, result)\n    return result\n  }\n\n  intersects (range, options) {\n    if (!(range instanceof Range)) {\n      throw new TypeError('a Range is required')\n    }\n\n    return this.set.some((thisComparators) => {\n      return (\n        isSatisfiable(thisComparators, options) &&\n        range.set.some((rangeComparators) => {\n          return (\n            isSatisfiable(rangeComparators, options) &&\n            thisComparators.every((thisComparator) => {\n              return rangeComparators.every((rangeComparator) => {\n                return thisComparator.intersects(rangeComparator, options)\n              })\n            })\n          )\n        })\n      )\n    })\n  }\n\n  // if ANY of the sets match ALL of its comparators, then pass\n  test (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 (let i = 0; i < this.set.length; i++) {\n      if (testSet(this.set[i], version, this.options)) {\n        return true\n      }\n    }\n    return false\n  }\n}\nmodule.exports = Range\n\nconst LRU = require('lru-cache')\nconst cache = new LRU({ max: 1000 })\n\nconst parseOptions = require('../internal/parse-options')\nconst Comparator = require('./comparator')\nconst debug = require('../internal/debug')\nconst SemVer = require('./semver')\nconst {\n  re,\n  t,\n  comparatorTrimReplace,\n  tildeTrimReplace,\n  caretTrimReplace,\n} = require('../internal/re')\n\nconst isNullSet = c => c.value === '<0.0.0-0'\nconst isAny = c => c.value === ''\n\n// take a set of comparators and determine whether there\n// exists a version which can satisfy it\nconst isSatisfiable = (comparators, options) => {\n  let result = true\n  const remainingComparators = comparators.slice()\n  let testComparator = remainingComparators.pop()\n\n  while (result && remainingComparators.length) {\n    result = remainingComparators.every((otherComparator) => {\n      return testComparator.intersects(otherComparator, options)\n    })\n\n    testComparator = remainingComparators.pop()\n  }\n\n  return result\n}\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.\nconst 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\nconst isX = id => !id || id.toLowerCase() === 'x' || id === '*'\n\n// ~, ~> --> * (any, kinda silly)\n// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0\n// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0\n// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0\n// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0\n// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0\n// ~0.0.1 --> >=0.0.1 <0.1.0-0\nconst replaceTildes = (comp, options) =>\n  comp.trim().split(/\\s+/).map((c) => {\n    return replaceTilde(c, options)\n  }).join(' ')\n\nconst replaceTilde = (comp, options) => {\n  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]\n  return comp.replace(r, (_, M, m, p, pr) => {\n    debug('tilde', comp, _, M, m, p, pr)\n    let ret\n\n    if (isX(M)) {\n      ret = ''\n    } else if (isX(m)) {\n      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`\n    } else if (isX(p)) {\n      // ~1.2 == >=1.2.0 <1.3.0-0\n      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`\n    } else if (pr) {\n      debug('replaceTilde pr', pr)\n      ret = `>=${M}.${m}.${p}-${pr\n      } <${M}.${+m + 1}.0-0`\n    } else {\n      // ~1.2.3 == >=1.2.3 <1.3.0-0\n      ret = `>=${M}.${m}.${p\n      } <${M}.${+m + 1}.0-0`\n    }\n\n    debug('tilde return', ret)\n    return ret\n  })\n}\n\n// ^ --> * (any, kinda silly)\n// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0\n// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0\n// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0\n// ^1.2.3 --> >=1.2.3 <2.0.0-0\n// ^1.2.0 --> >=1.2.0 <2.0.0-0\n// ^0.0.1 --> >=0.0.1 <0.0.2-0\n// ^0.1.0 --> >=0.1.0 <0.2.0-0\nconst replaceCarets = (comp, options) =>\n  comp.trim().split(/\\s+/).map((c) => {\n    return replaceCaret(c, options)\n  }).join(' ')\n\nconst replaceCaret = (comp, options) => {\n  debug('caret', comp, options)\n  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]\n  const z = options.includePrerelease ? '-0' : ''\n  return comp.replace(r, (_, M, m, p, pr) => {\n    debug('caret', comp, _, M, m, p, pr)\n    let ret\n\n    if (isX(M)) {\n      ret = ''\n    } else if (isX(m)) {\n      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`\n    } else if (isX(p)) {\n      if (M === '0') {\n        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`\n      } else {\n        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`\n      }\n    } else if (pr) {\n      debug('replaceCaret pr', pr)\n      if (M === '0') {\n        if (m === '0') {\n          ret = `>=${M}.${m}.${p}-${pr\n          } <${M}.${m}.${+p + 1}-0`\n        } else {\n          ret = `>=${M}.${m}.${p}-${pr\n          } <${M}.${+m + 1}.0-0`\n        }\n      } else {\n        ret = `>=${M}.${m}.${p}-${pr\n        } <${+M + 1}.0.0-0`\n      }\n    } else {\n      debug('no pr')\n      if (M === '0') {\n        if (m === '0') {\n          ret = `>=${M}.${m}.${p\n          }${z} <${M}.${m}.${+p + 1}-0`\n        } else {\n          ret = `>=${M}.${m}.${p\n          }${z} <${M}.${+m + 1}.0-0`\n        }\n      } else {\n        ret = `>=${M}.${m}.${p\n        } <${+M + 1}.0.0-0`\n      }\n    }\n\n    debug('caret return', ret)\n    return ret\n  })\n}\n\nconst replaceXRanges = (comp, options) => {\n  debug('replaceXRanges', comp, options)\n  return comp.split(/\\s+/).map((c) => {\n    return replaceXRange(c, options)\n  }).join(' ')\n}\n\nconst replaceXRange = (comp, options) => {\n  comp = comp.trim()\n  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]\n  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {\n    debug('xRange', comp, ret, gtlt, M, m, p, pr)\n    const xM = isX(M)\n    const xm = xM || isX(m)\n    const xp = xm || isX(p)\n    const anyX = xp\n\n    if (gtlt === '=' && anyX) {\n      gtlt = ''\n    }\n\n    // if we're including prereleases in the match, then we need\n    // to fix this to -0, the lowest possible prerelease value\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      p = 0\n\n      if (gtlt === '>') {\n        // >1 => >=2.0.0\n        // >1.2 => >=1.3.0\n        gtlt = '>='\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        if (xm) {\n          M = +M + 1\n        } else {\n          m = +m + 1\n        }\n      }\n\n      if (gtlt === '<') {\n        pr = '-0'\n      }\n\n      ret = `${gtlt + M}.${m}.${p}${pr}`\n    } else if (xm) {\n      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`\n    } else if (xp) {\n      ret = `>=${M}.${m}.0${pr\n      } <${M}.${+m + 1}.0-0`\n    }\n\n    debug('xRange return', ret)\n\n    return ret\n  })\n}\n\n// Because * is AND-ed with everything else in the comparator,\n// and '' means \"any version\", just remove the *s entirely.\nconst replaceStars = (comp, options) => {\n  debug('replaceStars', comp, options)\n  // Looseness is ignored here.  star is always as loose as it gets!\n  return comp.trim().replace(re[t.STAR], '')\n}\n\nconst replaceGTE0 = (comp, options) => {\n  debug('replaceGTE0', comp, options)\n  return comp.trim()\n    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')\n}\n\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-0 Any 3.4.x will do\n// 1.2 - 3.4 => >=1.2.0 <3.5.0-0\nconst hyphenReplace = incPr => ($0,\n  from, fM, fm, fp, fpr, fb,\n  to, tM, tm, tp, tpr, tb) => {\n  if (isX(fM)) {\n    from = ''\n  } else if (isX(fm)) {\n    from = `>=${fM}.0.0${incPr ? '-0' : ''}`\n  } else if (isX(fp)) {\n    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`\n  } else if (fpr) {\n    from = `>=${from}`\n  } else {\n    from = `>=${from}${incPr ? '-0' : ''}`\n  }\n\n  if (isX(tM)) {\n    to = ''\n  } else if (isX(tm)) {\n    to = `<${+tM + 1}.0.0-0`\n  } else if (isX(tp)) {\n    to = `<${tM}.${+tm + 1}.0-0`\n  } else if (tpr) {\n    to = `<=${tM}.${tm}.${tp}-${tpr}`\n  } else if (incPr) {\n    to = `<${tM}.${tm}.${+tp + 1}-0`\n  } else {\n    to = `<=${to}`\n  }\n\n  return (`${from} ${to}`).trim()\n}\n\nconst testSet = (set, version, options) => {\n  for (let 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 (let i = 0; i < set.length; i++) {\n      debug(set[i].semver)\n      if (set[i].semver === Comparator.ANY) {\n        continue\n      }\n\n      if (set[i].semver.prerelease.length > 0) {\n        const allowed = set[i].semver\n        if (allowed.major === version.major &&\n            allowed.minor === version.minor &&\n            allowed.patch === version.patch) {\n          return true\n        }\n      }\n    }\n\n    // Version has a -pre, but it's not one of the ones we like.\n    return false\n  }\n\n  return true\n}\n"],"mappings":"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"},"metadata":{},"sourceType":"script","externalDependencies":[]}