{"version":3,"sources":["../node_modules/jsonwebtoken/node_modules/semver/functions/compare.js","../node_modules/jsonwebtoken/node_modules/semver/classes/range.js","../node_modules/jsonwebtoken/node_modules/semver/functions/parse.js","../node_modules/jsonwebtoken/node_modules/semver/internal/re.js","../node_modules/jsonwebtoken/lib/JsonWebTokenError.js","../node_modules/jsonwebtoken/node_modules/semver/internal/constants.js","../node_modules/jsonwebtoken/node_modules/semver/internal/debug.js","../node_modules/jsonwebtoken/node_modules/semver/functions/gt.js","../node_modules/jsonwebtoken/node_modules/semver/classes/comparator.js","../node_modules/jsonwebtoken/node_modules/semver/functions/satisfies.js","../node_modules/jsonwebtoken/node_modules/semver/index.js","../node_modules/jsonwebtoken/node_modules/semver/internal/parse-options.js","../node_modules/jsonwebtoken/node_modules/semver/functions/compare-build.js","../node_modules/jsonwebtoken/node_modules/semver/functions/lt.js","../node_modules/jsonwebtoken/node_modules/semver/functions/gte.js","../node_modules/jsonwebtoken/node_modules/semver/functions/lte.js","../node_modules/jsonwebtoken/node_modules/semver/ranges/outside.js","../node_modules/jsonwebtoken/decode.js","../node_modules/jsonwebtoken/lib/NotBeforeError.js","../node_modules/jsonwebtoken/lib/TokenExpiredError.js","../node_modules/jsonwebtoken/lib/timespan.js","../node_modules/jsonwebtoken/lib/validateAsymmetricKey.js","../node_modules/jsonwebtoken/node_modules/semver/internal/identifiers.js","../node_modules/jsonwebtoken/node_modules/semver/functions/eq.js","../node_modules/jsonwebtoken/node_modules/semver/functions/neq.js","../node_modules/jsonwebtoken/node_modules/semver/functions/cmp.js","../node_modules/jsonwebtoken/lib/psSupported.js","../node_modules/jsonwebtoken/index.js","../node_modules/jsonwebtoken/verify.js","../node_modules/jsonwebtoken/lib/asymmetricKeyDetailsSupported.js","../node_modules/jsonwebtoken/node_modules/semver/functions/valid.js","../node_modules/jsonwebtoken/node_modules/semver/functions/clean.js","../node_modules/jsonwebtoken/node_modules/semver/functions/inc.js","../node_modules/jsonwebtoken/node_modules/semver/functions/diff.js","../node_modules/jsonwebtoken/node_modules/semver/functions/major.js","../node_modules/jsonwebtoken/node_modules/semver/functions/minor.js","../node_modules/jsonwebtoken/node_modules/semver/functions/patch.js","../node_modules/jsonwebtoken/node_modules/semver/functions/prerelease.js","../node_modules/jsonwebtoken/node_modules/semver/functions/rcompare.js","../node_modules/jsonwebtoken/node_modules/semver/functions/compare-loose.js","../node_modules/jsonwebtoken/node_modules/semver/functions/sort.js","../node_modules/jsonwebtoken/node_modules/semver/functions/rsort.js","../node_modules/jsonwebtoken/node_modules/semver/functions/coerce.js","../node_modules/jsonwebtoken/node_modules/semver/internal/lrucache.js","../node_modules/jsonwebtoken/node_modules/semver/ranges/to-comparators.js","../node_modules/jsonwebtoken/node_modules/semver/ranges/max-satisfying.js","../node_modules/jsonwebtoken/node_modules/semver/ranges/min-satisfying.js","../node_modules/jsonwebtoken/node_modules/semver/ranges/min-version.js","../node_modules/jsonwebtoken/node_modules/semver/ranges/valid.js","../node_modules/jsonwebtoken/node_modules/semver/ranges/gtr.js","../node_modules/jsonwebtoken/node_modules/semver/ranges/ltr.js","../node_modules/jsonwebtoken/node_modules/semver/ranges/intersects.js","../node_modules/jsonwebtoken/node_modules/semver/ranges/simplify.js","../node_modules/jsonwebtoken/node_modules/semver/ranges/subset.js","../node_modules/jsonwebtoken/lib/rsaPssKeyDetailsSupported.js","../node_modules/jsonwebtoken/sign.js","../node_modules/jsonwebtoken/node_modules/semver/classes/semver.js","../node_modules/isarray/index.js"],"names":["SemVer","require","module","exports","compare","a","b","loose","SPACE_CHARACTERS","Range","constructor","range","options","parseOptions","includePrerelease","raw","Comparator","this","value","set","formatted","undefined","trim","replace","split","map","r","parseRange","filter","c","length","TypeError","first","isNullSet","isAny","i","comps","k","toString","format","memoKey","FLAG_INCLUDE_PRERELEASE","FLAG_LOOSE","cached","cache","get","hr","re","t","HYPHENRANGELOOSE","HYPHENRANGE","hyphenReplace","debug","COMPARATORTRIM","comparatorTrimReplace","TILDETRIM","tildeTrimReplace","CARETTRIM","caretTrimReplace","rangeList","comp","parseComparator","join","replaceGTE0","match","COMPARATORLOOSE","rangeMap","Map","comparators","size","has","delete","result","values","intersects","some","thisComparators","isSatisfiable","rangeComparators","every","thisComparator","rangeComparator","test","version","er","testSet","safeRe","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","prerelease","semver","ANY","allowed","major","minor","patch","throwErrors","arguments","MAX_SAFE_COMPONENT_LENGTH","MAX_SAFE_BUILD_LENGTH","MAX_LENGTH","src","R","LETTERDASHNUMBER","safeRegexReplacements","createToken","name","isGlobal","safe","token","max","makeSafeRegex","index","RegExp","NUMERICIDENTIFIER","NUMERICIDENTIFIERLOOSE","NONNUMERICIDENTIFIER","PRERELEASEIDENTIFIER","PRERELEASEIDENTIFIERLOOSE","BUILDIDENTIFIER","MAINVERSION","PRERELEASE","BUILD","FULLPLAIN","MAINVERSIONLOOSE","PRERELEASELOOSE","LOOSEPLAIN","XRANGEIDENTIFIER","XRANGEIDENTIFIERLOOSE","GTLT","XRANGEPLAIN","XRANGEPLAINLOOSE","COERCEPLAIN","COERCE","COERCEFULL","LONETILDE","LONECARET","JsonWebTokenError","message","error","Error","call","captureStackTrace","inner","prototype","Object","create","MAX_SAFE_INTEGER","Number","RELEASE_TYPES","SEMVER_SPEC_VERSION","process","NODE_DEBUG","_len","args","Array","_key","gt","Symbol","parse","operator","COMPARATOR","cmp","startsWith","includes","satisfies","internalRe","constants","identifiers","valid","clean","inc","diff","rcompare","compareLoose","compareBuild","sort","rsort","lt","eq","neq","gte","lte","coerce","toComparators","maxSatisfying","minSatisfying","minVersion","validRange","outside","gtr","ltr","simplifyRange","subset","tokens","compareIdentifiers","rcompareIdentifiers","looseOption","freeze","emptyOpts","versionA","versionB","hilo","gtfn","ltefn","ltfn","ecomp","high","low","forEach","comparator","jws","jwt","decoded","decode","payload","obj","JSON","e","complete","header","signature","NotBeforeError","date","TokenExpiredError","expiredAt","ms","time","iat","timestamp","Math","floor","Date","now","milliseconds","ASYMMETRIC_KEY_DETAILS_SUPPORTED","RSA_PSS_KEY_DETAILS_SUPPORTED","allowedAlgorithmsForKeys","allowedCurves","ES256","ES384","ES512","algorithm","key","keyType","asymmetricKeyType","allowedAlgorithms","keyCurve","asymmetricKeyDetails","namedCurve","allowedCurve","parseInt","hashAlgorithm","mgf1HashAlgorithm","saltLength","numeric","anum","bnum","op","verify","sign","timespan","validateAsymmetricKey","PS_SUPPORTED","KeyObject","createSecretKey","createPublicKey","PUB_KEY_ALGS","EC_KEY_ALGS","RSA_KEY_ALGS","HS_ALGS","splice","jwtString","secretOrPublicKey","callback","done","assign","err","data","clockTimestamp","nonce","allowInvalidAsymmetricKeyTypes","parts","decodedToken","getSecret","secretCallback","hasSignature","algorithms","Buffer","type","indexOf","alg","nbf","ignoreNotBefore","clockTolerance","exp","ignoreExpiration","audience","audiences","isArray","aud","targetAudience","issuer","iss","subject","sub","jwtid","jti","maxAge","maxAgeTimestamp","v","s","release","identifier","identifierBase","version1","version2","v1","v2","comparison","v1Higher","highVersion","lowVersion","highHasPre","prefix","parsed","list","String","rtl","coerceRtlRegex","COERCERTLFULL","COERCERTL","next","exec","lastIndex","build","firstKey","keys","versions","maxSV","rangeObj","min","minSV","minver","setMin","compver","push","r1","r2","prev","ranges","simplified","original","minimumVersionWithPreRelease","minimumVersion","simpleSubset","dom","eqSet","Set","gtltComp","higher","lower","hasDomLT","hasDomGT","higherGT","lowerLT","add","needDomLTPre","needDomGTPre","sawNonNull","OUTER","simpleSub","simpleDom","isSub","isBoolean","isInteger","isNumber","isPlainObject","isString","once","createPrivateKey","SUPPORTED_ALGS","sign_options_schema","expiresIn","isValid","notBefore","bind","encoding","noTimestamp","keyid","mutatePayload","allowInsecureKeySizes","registered_claims_schema","validate","schema","allowUnknown","object","parameterName","validator","options_to_payload","options_for_objects","secretOrPrivateKey","isObjectPayload","isBuffer","typ","kid","failure","modulusLength","validatePayload","invalid_options","opt","validateOptions","claim","secret","createSign","privateKey","LOOSE","FULL","num","other","compareMain","comparePre","base","isNaN","arr"],"mappings":"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","file":"static/js/main~7d359b94.3bc27921.chunk.js","sourcesContent":["const SemVer = require('../classes/semver')\nconst compare = (a, b, loose) =>\n  new SemVer(a, loose).compare(new SemVer(b, loose))\n\nmodule.exports = compare\n","const SPACE_CHARACTERS = /\\s+/g\n\n// 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.formatted = undefined\n      return this\n    }\n\n    this.options = options\n    this.loose = !!options.loose\n    this.includePrerelease = !!options.includePrerelease\n\n    // First reduce all whitespace as much as possible so we do not have to rely\n    // on potentially slow regexes like \\s*. This is then stored and used for\n    // future error messages as well.\n    this.raw = range.trim().replace(SPACE_CHARACTERS, ' ')\n\n    // First, split on ||\n    this.set = this.raw\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: ${this.raw}`)\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.formatted = undefined\n  }\n\n  get range () {\n    if (this.formatted === undefined) {\n      this.formatted = ''\n      for (let i = 0; i < this.set.length; i++) {\n        if (i > 0) {\n          this.formatted += '||'\n        }\n        const comps = this.set[i]\n        for (let k = 0; k < comps.length; k++) {\n          if (k > 0) {\n            this.formatted += ' '\n          }\n          this.formatted += comps[k].toString().trim()\n        }\n      }\n    }\n    return this.formatted\n  }\n\n  format () {\n    return this.range\n  }\n\n  toString () {\n    return this.range\n  }\n\n  parseRange (range) {\n    // memoize range parsing for performance.\n    // this is a very hot path, and fully deterministic.\n    const memoOpts =\n      (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) |\n      (this.options.loose && FLAG_LOOSE)\n    const memoKey = 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\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    debug('tilde trim', range)\n\n    // `^ 1.2.3` => `^1.2.3`\n    range = range.replace(re[t.CARETTRIM], caretTrimReplace)\n    debug('caret trim', range)\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}\n\nmodule.exports = Range\n\nconst LRU = require('../internal/lrucache')\nconst cache = new LRU()\n\nconst parseOptions = require('../internal/parse-options')\nconst Comparator = require('./comparator')\nconst debug = require('../internal/debug')\nconst SemVer = require('./semver')\nconst {\n  safeRe: re,\n  t,\n  comparatorTrimReplace,\n  tildeTrimReplace,\n  caretTrimReplace,\n} = require('../internal/re')\nconst { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require('../internal/constants')\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  return comp\n    .trim()\n    .split(/\\s+/)\n    .map((c) => replaceTilde(c, options))\n    .join(' ')\n}\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  return comp\n    .trim()\n    .split(/\\s+/)\n    .map((c) => replaceCaret(c, options))\n    .join(' ')\n}\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\n    .split(/\\s+/)\n    .map((c) => 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\n    .trim()\n    .replace(re[t.STAR], '')\n}\n\nconst replaceGTE0 = (comp, options) => {\n  debug('replaceGTE0', comp, options)\n  return comp\n    .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\n// TODO build?\nconst hyphenReplace = incPr => ($0,\n  from, fM, fm, fp, fpr, fb,\n  to, tM, tm, tp, tpr) => {\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","const SemVer = require('../classes/semver')\nconst parse = (version, options, throwErrors = false) => {\n  if (version instanceof SemVer) {\n    return version\n  }\n  try {\n    return new SemVer(version, options)\n  } catch (er) {\n    if (!throwErrors) {\n      return null\n    }\n    throw er\n  }\n}\n\nmodule.exports = parse\n","const {\n  MAX_SAFE_COMPONENT_LENGTH,\n  MAX_SAFE_BUILD_LENGTH,\n  MAX_LENGTH,\n} = require('./constants')\nconst debug = require('./debug')\nexports = module.exports = {}\n\n// The actual regexps go on exports.re\nconst re = exports.re = []\nconst safeRe = exports.safeRe = []\nconst src = exports.src = []\nconst t = exports.t = {}\nlet R = 0\n\nconst LETTERDASHNUMBER = '[a-zA-Z0-9-]'\n\n// Replace some greedy regex tokens to prevent regex dos issues. These regex are\n// used internally via the safeRe object since all inputs in this library get\n// normalized first to trim and collapse all extra whitespace. The original\n// regexes are exported for userland consumption and lower level usage. A\n// future breaking change could export the safer regex only with a note that\n// all input should have extra whitespace removed.\nconst safeRegexReplacements = [\n  ['\\\\s', 1],\n  ['\\\\d', MAX_LENGTH],\n  [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],\n]\n\nconst makeSafeRegex = (value) => {\n  for (const [token, max] of safeRegexReplacements) {\n    value = value\n      .split(`${token}*`).join(`${token}{0,${max}}`)\n      .split(`${token}+`).join(`${token}{1,${max}}`)\n  }\n  return value\n}\n\nconst createToken = (name, value, isGlobal) => {\n  const safe = makeSafeRegex(value)\n  const index = R++\n  debug(name, index, value)\n  t[name] = index\n  src[index] = value\n  re[index] = new RegExp(value, isGlobal ? 'g' : undefined)\n  safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined)\n}\n\n// The following Regular Expressions can be used for tokenizing,\n// validating, and parsing SemVer version strings.\n\n// ## Numeric Identifier\n// A single `0`, or a non-zero digit followed by zero or more digits.\n\ncreateToken('NUMERICIDENTIFIER', '0|[1-9]\\\\d*')\ncreateToken('NUMERICIDENTIFIERLOOSE', '\\\\d+')\n\n// ## Non-numeric Identifier\n// Zero or more digits, followed by a letter or hyphen, and then zero or\n// more letters, digits, or hyphens.\n\ncreateToken('NONNUMERICIDENTIFIER', `\\\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`)\n\n// ## Main Version\n// Three dot-separated numeric identifiers.\n\ncreateToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\\\.` +\n                   `(${src[t.NUMERICIDENTIFIER]})\\\\.` +\n                   `(${src[t.NUMERICIDENTIFIER]})`)\n\ncreateToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\\\.` +\n                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\\\.` +\n                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`)\n\n// ## Pre-release Version Identifier\n// A numeric identifier, or a non-numeric identifier.\n\ncreateToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]\n}|${src[t.NONNUMERICIDENTIFIER]})`)\n\ncreateToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]\n}|${src[t.NONNUMERICIDENTIFIER]})`)\n\n// ## Pre-release Version\n// Hyphen, followed by one or more dot-separated pre-release version\n// identifiers.\n\ncreateToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]\n}(?:\\\\.${src[t.PRERELEASEIDENTIFIER]})*))`)\n\ncreateToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]\n}(?:\\\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`)\n\n// ## Build Metadata Identifier\n// Any combination of digits, letters, or hyphens.\n\ncreateToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`)\n\n// ## Build Metadata\n// Plus sign, followed by one or more period-separated build metadata\n// identifiers.\n\ncreateToken('BUILD', `(?:\\\\+(${src[t.BUILDIDENTIFIER]\n}(?:\\\\.${src[t.BUILDIDENTIFIER]})*))`)\n\n// ## Full Version String\n// A main version, followed optionally by a pre-release version and\n// build metadata.\n\n// Note that the only major, minor, patch, and pre-release sections of\n// the version string are capturing groups.  The build metadata is not a\n// capturing group, because it should not ever be used in version\n// comparison.\n\ncreateToken('FULLPLAIN', `v?${src[t.MAINVERSION]\n}${src[t.PRERELEASE]}?${\n  src[t.BUILD]}?`)\n\ncreateToken('FULL', `^${src[t.FULLPLAIN]}$`)\n\n// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.\n// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty\n// common in the npm registry.\ncreateToken('LOOSEPLAIN', `[v=\\\\s]*${src[t.MAINVERSIONLOOSE]\n}${src[t.PRERELEASELOOSE]}?${\n  src[t.BUILD]}?`)\n\ncreateToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`)\n\ncreateToken('GTLT', '((?:<|>)?=?)')\n\n// Something like \"2.*\" or \"1.2.x\".\n// Note that \"x.x\" is a valid xRange identifer, meaning \"any version\"\n// Only the first item is strictly required.\ncreateToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\\\*`)\ncreateToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\\\*`)\n\ncreateToken('XRANGEPLAIN', `[v=\\\\s]*(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:\\\\.(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:\\\\.(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:${src[t.PRERELEASE]})?${\n                     src[t.BUILD]}?` +\n                   `)?)?`)\n\ncreateToken('XRANGEPLAINLOOSE', `[v=\\\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:\\\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:\\\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:${src[t.PRERELEASELOOSE]})?${\n                          src[t.BUILD]}?` +\n                        `)?)?`)\n\ncreateToken('XRANGE', `^${src[t.GTLT]}\\\\s*${src[t.XRANGEPLAIN]}$`)\ncreateToken('XRANGELOOSE', `^${src[t.GTLT]}\\\\s*${src[t.XRANGEPLAINLOOSE]}$`)\n\n// Coercion.\n// Extract anything that could conceivably be a part of a valid semver\ncreateToken('COERCEPLAIN', `${'(^|[^\\\\d])' +\n              '(\\\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +\n              `(?:\\\\.(\\\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +\n              `(?:\\\\.(\\\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`)\ncreateToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\\\d])`)\ncreateToken('COERCEFULL', src[t.COERCEPLAIN] +\n              `(?:${src[t.PRERELEASE]})?` +\n              `(?:${src[t.BUILD]})?` +\n              `(?:$|[^\\\\d])`)\ncreateToken('COERCERTL', src[t.COERCE], true)\ncreateToken('COERCERTLFULL', src[t.COERCEFULL], true)\n\n// Tilde ranges.\n// Meaning is \"reasonably at or greater than\"\ncreateToken('LONETILDE', '(?:~>?)')\n\ncreateToken('TILDETRIM', `(\\\\s*)${src[t.LONETILDE]}\\\\s+`, true)\nexports.tildeTrimReplace = '$1~'\n\ncreateToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`)\ncreateToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`)\n\n// Caret ranges.\n// Meaning is \"at least and backwards compatible with\"\ncreateToken('LONECARET', '(?:\\\\^)')\n\ncreateToken('CARETTRIM', `(\\\\s*)${src[t.LONECARET]}\\\\s+`, true)\nexports.caretTrimReplace = '$1^'\n\ncreateToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`)\ncreateToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`)\n\n// A simple gt/lt/eq thing, or just \"\" to indicate \"any version\"\ncreateToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\\\s*(${src[t.LOOSEPLAIN]})$|^$`)\ncreateToken('COMPARATOR', `^${src[t.GTLT]}\\\\s*(${src[t.FULLPLAIN]})$|^$`)\n\n// An expression to strip any whitespace between the gtlt and the thing\n// it modifies, so that `> 1.2.3` ==> `>1.2.3`\ncreateToken('COMPARATORTRIM', `(\\\\s*)${src[t.GTLT]\n}\\\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true)\nexports.comparatorTrimReplace = '$1$2$3'\n\n// Something like `1.2.3 - 1.2.4`\n// Note that these all use the loose form, because they'll be\n// checked against either the strict or loose comparator form\n// later.\ncreateToken('HYPHENRANGE', `^\\\\s*(${src[t.XRANGEPLAIN]})` +\n                   `\\\\s+-\\\\s+` +\n                   `(${src[t.XRANGEPLAIN]})` +\n                   `\\\\s*$`)\n\ncreateToken('HYPHENRANGELOOSE', `^\\\\s*(${src[t.XRANGEPLAINLOOSE]})` +\n                        `\\\\s+-\\\\s+` +\n                        `(${src[t.XRANGEPLAINLOOSE]})` +\n                        `\\\\s*$`)\n\n// Star ranges basically just allow anything at all.\ncreateToken('STAR', '(<|>)?=?\\\\s*\\\\*')\n// >=0.0.0 is like a star\ncreateToken('GTE0', '^\\\\s*>=\\\\s*0\\\\.0\\\\.0\\\\s*$')\ncreateToken('GTE0PRE', '^\\\\s*>=\\\\s*0\\\\.0\\\\.0-0\\\\s*$')\n","var JsonWebTokenError = function (message, error) {\n  Error.call(this, message);\n  if(Error.captureStackTrace) {\n    Error.captureStackTrace(this, this.constructor);\n  }\n  this.name = 'JsonWebTokenError';\n  this.message = message;\n  if (error) this.inner = error;\n};\n\nJsonWebTokenError.prototype = Object.create(Error.prototype);\nJsonWebTokenError.prototype.constructor = JsonWebTokenError;\n\nmodule.exports = JsonWebTokenError;\n","// Note: this is the semver.org version of the spec that it implements\n// Not necessarily the package version of this code.\nconst SEMVER_SPEC_VERSION = '2.0.0'\n\nconst MAX_LENGTH = 256\nconst MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||\n/* istanbul ignore next */ 9007199254740991\n\n// Max safe segment length for coercion.\nconst MAX_SAFE_COMPONENT_LENGTH = 16\n\n// Max safe length for a build identifier. The max length minus 6 characters for\n// the shortest version with a build 0.0.0+BUILD.\nconst MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6\n\nconst RELEASE_TYPES = [\n  'major',\n  'premajor',\n  'minor',\n  'preminor',\n  'patch',\n  'prepatch',\n  'prerelease',\n]\n\nmodule.exports = {\n  MAX_LENGTH,\n  MAX_SAFE_COMPONENT_LENGTH,\n  MAX_SAFE_BUILD_LENGTH,\n  MAX_SAFE_INTEGER,\n  RELEASE_TYPES,\n  SEMVER_SPEC_VERSION,\n  FLAG_INCLUDE_PRERELEASE: 0b001,\n  FLAG_LOOSE: 0b010,\n}\n","const debug = (\n  typeof process === 'object' &&\n  process.env &&\n  process.env.NODE_DEBUG &&\n  /\\bsemver\\b/i.test(process.env.NODE_DEBUG)\n) ? (...args) => console.error('SEMVER', ...args)\n  : () => {}\n\nmodule.exports = debug\n","const compare = require('./compare')\nconst gt = (a, b, loose) => compare(a, b, loose) > 0\nmodule.exports = gt\n","const ANY = Symbol('SemVer ANY')\n// hoisted class for cyclic dependency\nclass Comparator {\n  static get ANY () {\n    return ANY\n  }\n\n  constructor (comp, options) {\n    options = parseOptions(options)\n\n    if (comp instanceof Comparator) {\n      if (comp.loose === !!options.loose) {\n        return comp\n      } else {\n        comp = comp.value\n      }\n    }\n\n    comp = comp.trim().split(/\\s+/).join(' ')\n    debug('comparator', comp, options)\n    this.options = options\n    this.loose = !!options.loose\n    this.parse(comp)\n\n    if (this.semver === ANY) {\n      this.value = ''\n    } else {\n      this.value = this.operator + this.semver.version\n    }\n\n    debug('comp', this)\n  }\n\n  parse (comp) {\n    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]\n    const m = comp.match(r)\n\n    if (!m) {\n      throw new TypeError(`Invalid comparator: ${comp}`)\n    }\n\n    this.operator = m[1] !== undefined ? m[1] : ''\n    if (this.operator === '=') {\n      this.operator = ''\n    }\n\n    // if it literally is just '>' or '' then allow anything.\n    if (!m[2]) {\n      this.semver = ANY\n    } else {\n      this.semver = new SemVer(m[2], this.options.loose)\n    }\n  }\n\n  toString () {\n    return this.value\n  }\n\n  test (version) {\n    debug('Comparator.test', version, this.options.loose)\n\n    if (this.semver === ANY || version === ANY) {\n      return true\n    }\n\n    if (typeof version === 'string') {\n      try {\n        version = new SemVer(version, this.options)\n      } catch (er) {\n        return false\n      }\n    }\n\n    return cmp(version, this.operator, this.semver, this.options)\n  }\n\n  intersects (comp, options) {\n    if (!(comp instanceof Comparator)) {\n      throw new TypeError('a Comparator is required')\n    }\n\n    if (this.operator === '') {\n      if (this.value === '') {\n        return true\n      }\n      return new Range(comp.value, options).test(this.value)\n    } else if (comp.operator === '') {\n      if (comp.value === '') {\n        return true\n      }\n      return new Range(this.value, options).test(comp.semver)\n    }\n\n    options = parseOptions(options)\n\n    // Special cases where nothing can possibly be lower\n    if (options.includePrerelease &&\n      (this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {\n      return false\n    }\n    if (!options.includePrerelease &&\n      (this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {\n      return false\n    }\n\n    // Same direction increasing (> or >=)\n    if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {\n      return true\n    }\n    // Same direction decreasing (< or <=)\n    if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {\n      return true\n    }\n    // same SemVer and both sides are inclusive (<= or >=)\n    if (\n      (this.semver.version === comp.semver.version) &&\n      this.operator.includes('=') && comp.operator.includes('=')) {\n      return true\n    }\n    // opposite directions less than\n    if (cmp(this.semver, '<', comp.semver, options) &&\n      this.operator.startsWith('>') && comp.operator.startsWith('<')) {\n      return true\n    }\n    // opposite directions greater than\n    if (cmp(this.semver, '>', comp.semver, options) &&\n      this.operator.startsWith('<') && comp.operator.startsWith('>')) {\n      return true\n    }\n    return false\n  }\n}\n\nmodule.exports = Comparator\n\nconst parseOptions = require('../internal/parse-options')\nconst { safeRe: re, t } = require('../internal/re')\nconst cmp = require('../functions/cmp')\nconst debug = require('../internal/debug')\nconst SemVer = require('./semver')\nconst Range = require('./range')\n","const Range = require('../classes/range')\nconst satisfies = (version, range, options) => {\n  try {\n    range = new Range(range, options)\n  } catch (er) {\n    return false\n  }\n  return range.test(version)\n}\nmodule.exports = satisfies\n","// just pre-load all the stuff that index.js lazily exports\nconst internalRe = require('./internal/re')\nconst constants = require('./internal/constants')\nconst SemVer = require('./classes/semver')\nconst identifiers = require('./internal/identifiers')\nconst parse = require('./functions/parse')\nconst valid = require('./functions/valid')\nconst clean = require('./functions/clean')\nconst inc = require('./functions/inc')\nconst diff = require('./functions/diff')\nconst major = require('./functions/major')\nconst minor = require('./functions/minor')\nconst patch = require('./functions/patch')\nconst prerelease = require('./functions/prerelease')\nconst compare = require('./functions/compare')\nconst rcompare = require('./functions/rcompare')\nconst compareLoose = require('./functions/compare-loose')\nconst compareBuild = require('./functions/compare-build')\nconst sort = require('./functions/sort')\nconst rsort = require('./functions/rsort')\nconst gt = require('./functions/gt')\nconst lt = require('./functions/lt')\nconst eq = require('./functions/eq')\nconst neq = require('./functions/neq')\nconst gte = require('./functions/gte')\nconst lte = require('./functions/lte')\nconst cmp = require('./functions/cmp')\nconst coerce = require('./functions/coerce')\nconst Comparator = require('./classes/comparator')\nconst Range = require('./classes/range')\nconst satisfies = require('./functions/satisfies')\nconst toComparators = require('./ranges/to-comparators')\nconst maxSatisfying = require('./ranges/max-satisfying')\nconst minSatisfying = require('./ranges/min-satisfying')\nconst minVersion = require('./ranges/min-version')\nconst validRange = require('./ranges/valid')\nconst outside = require('./ranges/outside')\nconst gtr = require('./ranges/gtr')\nconst ltr = require('./ranges/ltr')\nconst intersects = require('./ranges/intersects')\nconst simplifyRange = require('./ranges/simplify')\nconst subset = require('./ranges/subset')\nmodule.exports = {\n  parse,\n  valid,\n  clean,\n  inc,\n  diff,\n  major,\n  minor,\n  patch,\n  prerelease,\n  compare,\n  rcompare,\n  compareLoose,\n  compareBuild,\n  sort,\n  rsort,\n  gt,\n  lt,\n  eq,\n  neq,\n  gte,\n  lte,\n  cmp,\n  coerce,\n  Comparator,\n  Range,\n  satisfies,\n  toComparators,\n  maxSatisfying,\n  minSatisfying,\n  minVersion,\n  validRange,\n  outside,\n  gtr,\n  ltr,\n  intersects,\n  simplifyRange,\n  subset,\n  SemVer,\n  re: internalRe.re,\n  src: internalRe.src,\n  tokens: internalRe.t,\n  SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,\n  RELEASE_TYPES: constants.RELEASE_TYPES,\n  compareIdentifiers: identifiers.compareIdentifiers,\n  rcompareIdentifiers: identifiers.rcompareIdentifiers,\n}\n","// parse out just the options we care about\nconst looseOption = Object.freeze({ loose: true })\nconst emptyOpts = Object.freeze({ })\nconst parseOptions = options => {\n  if (!options) {\n    return emptyOpts\n  }\n\n  if (typeof options !== 'object') {\n    return looseOption\n  }\n\n  return options\n}\nmodule.exports = parseOptions\n","const SemVer = require('../classes/semver')\nconst compareBuild = (a, b, loose) => {\n  const versionA = new SemVer(a, loose)\n  const versionB = new SemVer(b, loose)\n  return versionA.compare(versionB) || versionA.compareBuild(versionB)\n}\nmodule.exports = compareBuild\n","const compare = require('./compare')\nconst lt = (a, b, loose) => compare(a, b, loose) < 0\nmodule.exports = lt\n","const compare = require('./compare')\nconst gte = (a, b, loose) => compare(a, b, loose) >= 0\nmodule.exports = gte\n","const compare = require('./compare')\nconst lte = (a, b, loose) => compare(a, b, loose) <= 0\nmodule.exports = lte\n","const SemVer = require('../classes/semver')\nconst Comparator = require('../classes/comparator')\nconst { ANY } = Comparator\nconst Range = require('../classes/range')\nconst satisfies = require('../functions/satisfies')\nconst gt = require('../functions/gt')\nconst lt = require('../functions/lt')\nconst lte = require('../functions/lte')\nconst gte = require('../functions/gte')\n\nconst outside = (version, range, hilo, options) => {\n  version = new SemVer(version, options)\n  range = new Range(range, options)\n\n  let gtfn, ltefn, ltfn, comp, ecomp\n  switch (hilo) {\n    case '>':\n      gtfn = gt\n      ltefn = lte\n      ltfn = lt\n      comp = '>'\n      ecomp = '>='\n      break\n    case '<':\n      gtfn = lt\n      ltefn = gte\n      ltfn = gt\n      comp = '<'\n      ecomp = '<='\n      break\n    default:\n      throw new TypeError('Must provide a hilo val of \"<\" or \">\"')\n  }\n\n  // If it satisfies the range it is not outside\n  if (satisfies(version, range, options)) {\n    return false\n  }\n\n  // From now on, variable terms are as if we're in \"gtr\" mode.\n  // but note that everything is flipped for the \"ltr\" function.\n\n  for (let i = 0; i < range.set.length; ++i) {\n    const comparators = range.set[i]\n\n    let high = null\n    let low = null\n\n    comparators.forEach((comparator) => {\n      if (comparator.semver === ANY) {\n        comparator = new Comparator('>=0.0.0')\n      }\n      high = high || comparator\n      low = low || comparator\n      if (gtfn(comparator.semver, high.semver, options)) {\n        high = comparator\n      } else if (ltfn(comparator.semver, low.semver, options)) {\n        low = comparator\n      }\n    })\n\n    // If the edge version comparator has a operator then our version\n    // isn't outside it\n    if (high.operator === comp || high.operator === ecomp) {\n      return false\n    }\n\n    // If the lowest version comparator has an operator and our version\n    // is less than it then it isn't higher than the range\n    if ((!low.operator || low.operator === comp) &&\n        ltefn(version, low.semver)) {\n      return false\n    } else if (low.operator === ecomp && ltfn(version, low.semver)) {\n      return false\n    }\n  }\n  return true\n}\n\nmodule.exports = outside\n","var jws = require('jws');\n\nmodule.exports = function (jwt, options) {\n  options = options || {};\n  var decoded = jws.decode(jwt, options);\n  if (!decoded) { return null; }\n  var payload = decoded.payload;\n\n  //try parse the payload\n  if(typeof payload === 'string') {\n    try {\n      var obj = JSON.parse(payload);\n      if(obj !== null && typeof obj === 'object') {\n        payload = obj;\n      }\n    } catch (e) { }\n  }\n\n  //return header if `complete` option is enabled.  header includes claims\n  //such as `kid` and `alg` used to select the key within a JWKS needed to\n  //verify the signature\n  if (options.complete === true) {\n    return {\n      header: decoded.header,\n      payload: payload,\n      signature: decoded.signature\n    };\n  }\n  return payload;\n};\n","var JsonWebTokenError = require('./JsonWebTokenError');\n\nvar NotBeforeError = function (message, date) {\n  JsonWebTokenError.call(this, message);\n  this.name = 'NotBeforeError';\n  this.date = date;\n};\n\nNotBeforeError.prototype = Object.create(JsonWebTokenError.prototype);\n\nNotBeforeError.prototype.constructor = NotBeforeError;\n\nmodule.exports = NotBeforeError;","var JsonWebTokenError = require('./JsonWebTokenError');\n\nvar TokenExpiredError = function (message, expiredAt) {\n  JsonWebTokenError.call(this, message);\n  this.name = 'TokenExpiredError';\n  this.expiredAt = expiredAt;\n};\n\nTokenExpiredError.prototype = Object.create(JsonWebTokenError.prototype);\n\nTokenExpiredError.prototype.constructor = TokenExpiredError;\n\nmodule.exports = TokenExpiredError;","var ms = require('ms');\n\nmodule.exports = function (time, iat) {\n  var timestamp = iat || Math.floor(Date.now() / 1000);\n\n  if (typeof time === 'string') {\n    var milliseconds = ms(time);\n    if (typeof milliseconds === 'undefined') {\n      return;\n    }\n    return Math.floor(timestamp + milliseconds / 1000);\n  } else if (typeof time === 'number') {\n    return timestamp + time;\n  } else {\n    return;\n  }\n\n};","const ASYMMETRIC_KEY_DETAILS_SUPPORTED = require('./asymmetricKeyDetailsSupported');\nconst RSA_PSS_KEY_DETAILS_SUPPORTED = require('./rsaPssKeyDetailsSupported');\n\nconst allowedAlgorithmsForKeys = {\n  'ec': ['ES256', 'ES384', 'ES512'],\n  'rsa': ['RS256', 'PS256', 'RS384', 'PS384', 'RS512', 'PS512'],\n  'rsa-pss': ['PS256', 'PS384', 'PS512']\n};\n\nconst allowedCurves = {\n  ES256: 'prime256v1',\n  ES384: 'secp384r1',\n  ES512: 'secp521r1',\n};\n\nmodule.exports = function(algorithm, key) {\n  if (!algorithm || !key) return;\n\n  const keyType = key.asymmetricKeyType;\n  if (!keyType) return;\n\n  const allowedAlgorithms = allowedAlgorithmsForKeys[keyType];\n\n  if (!allowedAlgorithms) {\n    throw new Error(`Unknown key type \"${keyType}\".`);\n  }\n\n  if (!allowedAlgorithms.includes(algorithm)) {\n    throw new Error(`\"alg\" parameter for \"${keyType}\" key type must be one of: ${allowedAlgorithms.join(', ')}.`)\n  }\n\n  /*\n   * Ignore the next block from test coverage because it gets executed\n   * conditionally depending on the Node version. Not ignoring it would\n   * prevent us from reaching the target % of coverage for versions of\n   * Node under 15.7.0.\n   */\n  /* istanbul ignore next */\n  if (ASYMMETRIC_KEY_DETAILS_SUPPORTED) {\n    switch (keyType) {\n    case 'ec':\n      const keyCurve = key.asymmetricKeyDetails.namedCurve;\n      const allowedCurve = allowedCurves[algorithm];\n\n      if (keyCurve !== allowedCurve) {\n        throw new Error(`\"alg\" parameter \"${algorithm}\" requires curve \"${allowedCurve}\".`);\n      }\n      break;\n\n    case 'rsa-pss':\n      if (RSA_PSS_KEY_DETAILS_SUPPORTED) {\n        const length = parseInt(algorithm.slice(-3), 10);\n        const { hashAlgorithm, mgf1HashAlgorithm, saltLength } = key.asymmetricKeyDetails;\n\n        if (hashAlgorithm !== `sha${length}` || mgf1HashAlgorithm !== hashAlgorithm) {\n          throw new Error(`Invalid key for this operation, its RSA-PSS parameters do not meet the requirements of \"alg\" ${algorithm}.`);\n        }\n\n        if (saltLength !== undefined && saltLength > length >> 3) {\n          throw new Error(`Invalid key for this operation, its RSA-PSS parameter saltLength does not meet the requirements of \"alg\" ${algorithm}.`)\n        }\n      }\n      break;\n    }\n  }\n}\n","const numeric = /^[0-9]+$/\nconst compareIdentifiers = (a, b) => {\n  const anum = numeric.test(a)\n  const bnum = numeric.test(b)\n\n  if (anum && bnum) {\n    a = +a\n    b = +b\n  }\n\n  return a === b ? 0\n    : (anum && !bnum) ? -1\n    : (bnum && !anum) ? 1\n    : a < b ? -1\n    : 1\n}\n\nconst rcompareIdentifiers = (a, b) => compareIdentifiers(b, a)\n\nmodule.exports = {\n  compareIdentifiers,\n  rcompareIdentifiers,\n}\n","const compare = require('./compare')\nconst eq = (a, b, loose) => compare(a, b, loose) === 0\nmodule.exports = eq\n","const compare = require('./compare')\nconst neq = (a, b, loose) => compare(a, b, loose) !== 0\nmodule.exports = neq\n","const eq = require('./eq')\nconst neq = require('./neq')\nconst gt = require('./gt')\nconst gte = require('./gte')\nconst lt = require('./lt')\nconst lte = require('./lte')\n\nconst cmp = (a, op, b, loose) => {\n  switch (op) {\n    case '===':\n      if (typeof a === 'object') {\n        a = a.version\n      }\n      if (typeof b === 'object') {\n        b = b.version\n      }\n      return a === b\n\n    case '!==':\n      if (typeof a === 'object') {\n        a = a.version\n      }\n      if (typeof b === 'object') {\n        b = b.version\n      }\n      return a !== b\n\n    case '':\n    case '=':\n    case '==':\n      return eq(a, b, loose)\n\n    case '!=':\n      return neq(a, b, loose)\n\n    case '>':\n      return gt(a, b, loose)\n\n    case '>=':\n      return gte(a, b, loose)\n\n    case '<':\n      return lt(a, b, loose)\n\n    case '<=':\n      return lte(a, b, loose)\n\n    default:\n      throw new TypeError(`Invalid operator: ${op}`)\n  }\n}\nmodule.exports = cmp\n","var semver = require('semver');\n\nmodule.exports = semver.satisfies(process.version, '^6.12.0 || >=8.0.0');\n","module.exports = {\n  decode: require('./decode'),\n  verify: require('./verify'),\n  sign: require('./sign'),\n  JsonWebTokenError: require('./lib/JsonWebTokenError'),\n  NotBeforeError: require('./lib/NotBeforeError'),\n  TokenExpiredError: require('./lib/TokenExpiredError'),\n};\n","const JsonWebTokenError = require('./lib/JsonWebTokenError');\nconst NotBeforeError = require('./lib/NotBeforeError');\nconst TokenExpiredError = require('./lib/TokenExpiredError');\nconst decode = require('./decode');\nconst timespan = require('./lib/timespan');\nconst validateAsymmetricKey = require('./lib/validateAsymmetricKey');\nconst PS_SUPPORTED = require('./lib/psSupported');\nconst jws = require('jws');\nconst {KeyObject, createSecretKey, createPublicKey} = require(\"crypto\");\n\nconst PUB_KEY_ALGS = ['RS256', 'RS384', 'RS512'];\nconst EC_KEY_ALGS = ['ES256', 'ES384', 'ES512'];\nconst RSA_KEY_ALGS = ['RS256', 'RS384', 'RS512'];\nconst HS_ALGS = ['HS256', 'HS384', 'HS512'];\n\nif (PS_SUPPORTED) {\n  PUB_KEY_ALGS.splice(PUB_KEY_ALGS.length, 0, 'PS256', 'PS384', 'PS512');\n  RSA_KEY_ALGS.splice(RSA_KEY_ALGS.length, 0, 'PS256', 'PS384', 'PS512');\n}\n\nmodule.exports = function (jwtString, secretOrPublicKey, options, callback) {\n  if ((typeof options === 'function') && !callback) {\n    callback = options;\n    options = {};\n  }\n\n  if (!options) {\n    options = {};\n  }\n\n  //clone this object since we are going to mutate it.\n  options = Object.assign({}, options);\n\n  let done;\n\n  if (callback) {\n    done = callback;\n  } else {\n    done = function(err, data) {\n      if (err) throw err;\n      return data;\n    };\n  }\n\n  if (options.clockTimestamp && typeof options.clockTimestamp !== 'number') {\n    return done(new JsonWebTokenError('clockTimestamp must be a number'));\n  }\n\n  if (options.nonce !== undefined && (typeof options.nonce !== 'string' || options.nonce.trim() === '')) {\n    return done(new JsonWebTokenError('nonce must be a non-empty string'));\n  }\n\n  if (options.allowInvalidAsymmetricKeyTypes !== undefined && typeof options.allowInvalidAsymmetricKeyTypes !== 'boolean') {\n    return done(new JsonWebTokenError('allowInvalidAsymmetricKeyTypes must be a boolean'));\n  }\n\n  const clockTimestamp = options.clockTimestamp || Math.floor(Date.now() / 1000);\n\n  if (!jwtString){\n    return done(new JsonWebTokenError('jwt must be provided'));\n  }\n\n  if (typeof jwtString !== 'string') {\n    return done(new JsonWebTokenError('jwt must be a string'));\n  }\n\n  const parts = jwtString.split('.');\n\n  if (parts.length !== 3){\n    return done(new JsonWebTokenError('jwt malformed'));\n  }\n\n  let decodedToken;\n\n  try {\n    decodedToken = decode(jwtString, { complete: true });\n  } catch(err) {\n    return done(err);\n  }\n\n  if (!decodedToken) {\n    return done(new JsonWebTokenError('invalid token'));\n  }\n\n  const header = decodedToken.header;\n  let getSecret;\n\n  if(typeof secretOrPublicKey === 'function') {\n    if(!callback) {\n      return done(new JsonWebTokenError('verify must be called asynchronous if secret or public key is provided as a callback'));\n    }\n\n    getSecret = secretOrPublicKey;\n  }\n  else {\n    getSecret = function(header, secretCallback) {\n      return secretCallback(null, secretOrPublicKey);\n    };\n  }\n\n  return getSecret(header, function(err, secretOrPublicKey) {\n    if(err) {\n      return done(new JsonWebTokenError('error in secret or public key callback: ' + err.message));\n    }\n\n    const hasSignature = parts[2].trim() !== '';\n\n    if (!hasSignature && secretOrPublicKey){\n      return done(new JsonWebTokenError('jwt signature is required'));\n    }\n\n    if (hasSignature && !secretOrPublicKey) {\n      return done(new JsonWebTokenError('secret or public key must be provided'));\n    }\n\n    if (!hasSignature && !options.algorithms) {\n      return done(new JsonWebTokenError('please specify \"none\" in \"algorithms\" to verify unsigned tokens'));\n    }\n\n    if (secretOrPublicKey != null && !(secretOrPublicKey instanceof KeyObject)) {\n      try {\n        secretOrPublicKey = createPublicKey(secretOrPublicKey);\n      } catch (_) {\n        try {\n          secretOrPublicKey = createSecretKey(typeof secretOrPublicKey === 'string' ? Buffer.from(secretOrPublicKey) : secretOrPublicKey);\n        } catch (_) {\n          return done(new JsonWebTokenError('secretOrPublicKey is not valid key material'))\n        }\n      }\n    }\n\n    if (!options.algorithms) {\n      if (secretOrPublicKey.type === 'secret') {\n        options.algorithms = HS_ALGS;\n      } else if (['rsa', 'rsa-pss'].includes(secretOrPublicKey.asymmetricKeyType)) {\n        options.algorithms = RSA_KEY_ALGS\n      } else if (secretOrPublicKey.asymmetricKeyType === 'ec') {\n        options.algorithms = EC_KEY_ALGS\n      } else {\n        options.algorithms = PUB_KEY_ALGS\n      }\n    }\n\n    if (options.algorithms.indexOf(decodedToken.header.alg) === -1) {\n      return done(new JsonWebTokenError('invalid algorithm'));\n    }\n\n    if (header.alg.startsWith('HS') && secretOrPublicKey.type !== 'secret') {\n      return done(new JsonWebTokenError((`secretOrPublicKey must be a symmetric key when using ${header.alg}`)))\n    } else if (/^(?:RS|PS|ES)/.test(header.alg) && secretOrPublicKey.type !== 'public') {\n      return done(new JsonWebTokenError((`secretOrPublicKey must be an asymmetric key when using ${header.alg}`)))\n    }\n\n    if (!options.allowInvalidAsymmetricKeyTypes) {\n      try {\n        validateAsymmetricKey(header.alg, secretOrPublicKey);\n      } catch (e) {\n        return done(e);\n      }\n    }\n\n    let valid;\n\n    try {\n      valid = jws.verify(jwtString, decodedToken.header.alg, secretOrPublicKey);\n    } catch (e) {\n      return done(e);\n    }\n\n    if (!valid) {\n      return done(new JsonWebTokenError('invalid signature'));\n    }\n\n    const payload = decodedToken.payload;\n\n    if (typeof payload.nbf !== 'undefined' && !options.ignoreNotBefore) {\n      if (typeof payload.nbf !== 'number') {\n        return done(new JsonWebTokenError('invalid nbf value'));\n      }\n      if (payload.nbf > clockTimestamp + (options.clockTolerance || 0)) {\n        return done(new NotBeforeError('jwt not active', new Date(payload.nbf * 1000)));\n      }\n    }\n\n    if (typeof payload.exp !== 'undefined' && !options.ignoreExpiration) {\n      if (typeof payload.exp !== 'number') {\n        return done(new JsonWebTokenError('invalid exp value'));\n      }\n      if (clockTimestamp >= payload.exp + (options.clockTolerance || 0)) {\n        return done(new TokenExpiredError('jwt expired', new Date(payload.exp * 1000)));\n      }\n    }\n\n    if (options.audience) {\n      const audiences = Array.isArray(options.audience) ? options.audience : [options.audience];\n      const target = Array.isArray(payload.aud) ? payload.aud : [payload.aud];\n\n      const match = target.some(function (targetAudience) {\n        return audiences.some(function (audience) {\n          return audience instanceof RegExp ? audience.test(targetAudience) : audience === targetAudience;\n        });\n      });\n\n      if (!match) {\n        return done(new JsonWebTokenError('jwt audience invalid. expected: ' + audiences.join(' or ')));\n      }\n    }\n\n    if (options.issuer) {\n      const invalid_issuer =\n              (typeof options.issuer === 'string' && payload.iss !== options.issuer) ||\n              (Array.isArray(options.issuer) && options.issuer.indexOf(payload.iss) === -1);\n\n      if (invalid_issuer) {\n        return done(new JsonWebTokenError('jwt issuer invalid. expected: ' + options.issuer));\n      }\n    }\n\n    if (options.subject) {\n      if (payload.sub !== options.subject) {\n        return done(new JsonWebTokenError('jwt subject invalid. expected: ' + options.subject));\n      }\n    }\n\n    if (options.jwtid) {\n      if (payload.jti !== options.jwtid) {\n        return done(new JsonWebTokenError('jwt jwtid invalid. expected: ' + options.jwtid));\n      }\n    }\n\n    if (options.nonce) {\n      if (payload.nonce !== options.nonce) {\n        return done(new JsonWebTokenError('jwt nonce invalid. expected: ' + options.nonce));\n      }\n    }\n\n    if (options.maxAge) {\n      if (typeof payload.iat !== 'number') {\n        return done(new JsonWebTokenError('iat required when maxAge is specified'));\n      }\n\n      const maxAgeTimestamp = timespan(options.maxAge, payload.iat);\n      if (typeof maxAgeTimestamp === 'undefined') {\n        return done(new JsonWebTokenError('\"maxAge\" should be a number of seconds or string representing a timespan eg: \"1d\", \"20h\", 60'));\n      }\n      if (clockTimestamp >= maxAgeTimestamp + (options.clockTolerance || 0)) {\n        return done(new TokenExpiredError('maxAge exceeded', new Date(maxAgeTimestamp * 1000)));\n      }\n    }\n\n    if (options.complete === true) {\n      const signature = decodedToken.signature;\n\n      return done(null, {\n        header: header,\n        payload: payload,\n        signature: signature\n      });\n    }\n\n    return done(null, payload);\n  });\n};\n","const semver = require('semver');\n\nmodule.exports = semver.satisfies(process.version, '>=15.7.0');\n","const parse = require('./parse')\nconst valid = (version, options) => {\n  const v = parse(version, options)\n  return v ? v.version : null\n}\nmodule.exports = valid\n","const parse = require('./parse')\nconst clean = (version, options) => {\n  const s = parse(version.trim().replace(/^[=v]+/, ''), options)\n  return s ? s.version : null\n}\nmodule.exports = clean\n","const SemVer = require('../classes/semver')\n\nconst inc = (version, release, options, identifier, identifierBase) => {\n  if (typeof (options) === 'string') {\n    identifierBase = identifier\n    identifier = options\n    options = undefined\n  }\n\n  try {\n    return new SemVer(\n      version instanceof SemVer ? version.version : version,\n      options\n    ).inc(release, identifier, identifierBase).version\n  } catch (er) {\n    return null\n  }\n}\nmodule.exports = inc\n","const parse = require('./parse.js')\n\nconst diff = (version1, version2) => {\n  const v1 = parse(version1, null, true)\n  const v2 = parse(version2, null, true)\n  const comparison = v1.compare(v2)\n\n  if (comparison === 0) {\n    return null\n  }\n\n  const v1Higher = comparison > 0\n  const highVersion = v1Higher ? v1 : v2\n  const lowVersion = v1Higher ? v2 : v1\n  const highHasPre = !!highVersion.prerelease.length\n  const lowHasPre = !!lowVersion.prerelease.length\n\n  if (lowHasPre && !highHasPre) {\n    // Going from prerelease -> no prerelease requires some special casing\n\n    // If the low version has only a major, then it will always be a major\n    // Some examples:\n    // 1.0.0-1 -> 1.0.0\n    // 1.0.0-1 -> 1.1.1\n    // 1.0.0-1 -> 2.0.0\n    if (!lowVersion.patch && !lowVersion.minor) {\n      return 'major'\n    }\n\n    // Otherwise it can be determined by checking the high version\n\n    if (highVersion.patch) {\n      // anything higher than a patch bump would result in the wrong version\n      return 'patch'\n    }\n\n    if (highVersion.minor) {\n      // anything higher than a minor bump would result in the wrong version\n      return 'minor'\n    }\n\n    // bumping major/minor/patch all have same result\n    return 'major'\n  }\n\n  // add the `pre` prefix if we are going to a prerelease version\n  const prefix = highHasPre ? 'pre' : ''\n\n  if (v1.major !== v2.major) {\n    return prefix + 'major'\n  }\n\n  if (v1.minor !== v2.minor) {\n    return prefix + 'minor'\n  }\n\n  if (v1.patch !== v2.patch) {\n    return prefix + 'patch'\n  }\n\n  // high and low are preleases\n  return 'prerelease'\n}\n\nmodule.exports = diff\n","const SemVer = require('../classes/semver')\nconst major = (a, loose) => new SemVer(a, loose).major\nmodule.exports = major\n","const SemVer = require('../classes/semver')\nconst minor = (a, loose) => new SemVer(a, loose).minor\nmodule.exports = minor\n","const SemVer = require('../classes/semver')\nconst patch = (a, loose) => new SemVer(a, loose).patch\nmodule.exports = patch\n","const parse = require('./parse')\nconst prerelease = (version, options) => {\n  const parsed = parse(version, options)\n  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null\n}\nmodule.exports = prerelease\n","const compare = require('./compare')\nconst rcompare = (a, b, loose) => compare(b, a, loose)\nmodule.exports = rcompare\n","const compare = require('./compare')\nconst compareLoose = (a, b) => compare(a, b, true)\nmodule.exports = compareLoose\n","const compareBuild = require('./compare-build')\nconst sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose))\nmodule.exports = sort\n","const compareBuild = require('./compare-build')\nconst rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose))\nmodule.exports = rsort\n","const SemVer = require('../classes/semver')\nconst parse = require('./parse')\nconst { safeRe: re, t } = require('../internal/re')\n\nconst coerce = (version, options) => {\n  if (version instanceof SemVer) {\n    return version\n  }\n\n  if (typeof version === 'number') {\n    version = String(version)\n  }\n\n  if (typeof version !== 'string') {\n    return null\n  }\n\n  options = options || {}\n\n  let match = null\n  if (!options.rtl) {\n    match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE])\n  } else {\n    // Find the right-most coercible string that does not share\n    // a terminus with a more left-ward coercible string.\n    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'\n    // With includePrerelease option set, '1.2.3.4-rc' wants to coerce '2.3.4-rc', not '2.3.4'\n    //\n    // Walk through the string checking with a /g regexp\n    // Manually set the index so as to pick up overlapping matches.\n    // Stop when we get a match that ends at the string end, since no\n    // coercible string can be more right-ward without the same terminus.\n    const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL]\n    let next\n    while ((next = coerceRtlRegex.exec(version)) &&\n        (!match || match.index + match[0].length !== version.length)\n    ) {\n      if (!match ||\n            next.index + next[0].length !== match.index + match[0].length) {\n        match = next\n      }\n      coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length\n    }\n    // leave it in a clean state\n    coerceRtlRegex.lastIndex = -1\n  }\n\n  if (match === null) {\n    return null\n  }\n\n  const major = match[2]\n  const minor = match[3] || '0'\n  const patch = match[4] || '0'\n  const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : ''\n  const build = options.includePrerelease && match[6] ? `+${match[6]}` : ''\n\n  return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options)\n}\nmodule.exports = coerce\n","class LRUCache {\n  constructor () {\n    this.max = 1000\n    this.map = new Map()\n  }\n\n  get (key) {\n    const value = this.map.get(key)\n    if (value === undefined) {\n      return undefined\n    } else {\n      // Remove the key from the map and add it to the end\n      this.map.delete(key)\n      this.map.set(key, value)\n      return value\n    }\n  }\n\n  delete (key) {\n    return this.map.delete(key)\n  }\n\n  set (key, value) {\n    const deleted = this.delete(key)\n\n    if (!deleted && value !== undefined) {\n      // If cache is full, delete the least recently used item\n      if (this.map.size >= this.max) {\n        const firstKey = this.map.keys().next().value\n        this.delete(firstKey)\n      }\n\n      this.map.set(key, value)\n    }\n\n    return this\n  }\n}\n\nmodule.exports = LRUCache\n","const Range = require('../classes/range')\n\n// Mostly just for testing and legacy API reasons\nconst toComparators = (range, options) =>\n  new Range(range, options).set\n    .map(comp => comp.map(c => c.value).join(' ').trim().split(' '))\n\nmodule.exports = toComparators\n","const SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\n\nconst maxSatisfying = (versions, range, options) => {\n  let max = null\n  let maxSV = null\n  let rangeObj = null\n  try {\n    rangeObj = new Range(range, options)\n  } catch (er) {\n    return null\n  }\n  versions.forEach((v) => {\n    if (rangeObj.test(v)) {\n      // satisfies(v, range, options)\n      if (!max || maxSV.compare(v) === -1) {\n        // compare(max, v, true)\n        max = v\n        maxSV = new SemVer(max, options)\n      }\n    }\n  })\n  return max\n}\nmodule.exports = maxSatisfying\n","const SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\nconst minSatisfying = (versions, range, options) => {\n  let min = null\n  let minSV = null\n  let rangeObj = null\n  try {\n    rangeObj = new Range(range, options)\n  } catch (er) {\n    return null\n  }\n  versions.forEach((v) => {\n    if (rangeObj.test(v)) {\n      // satisfies(v, range, options)\n      if (!min || minSV.compare(v) === 1) {\n        // compare(min, v, true)\n        min = v\n        minSV = new SemVer(min, options)\n      }\n    }\n  })\n  return min\n}\nmodule.exports = minSatisfying\n","const SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\nconst gt = require('../functions/gt')\n\nconst minVersion = (range, loose) => {\n  range = new Range(range, loose)\n\n  let minver = new SemVer('0.0.0')\n  if (range.test(minver)) {\n    return minver\n  }\n\n  minver = new SemVer('0.0.0-0')\n  if (range.test(minver)) {\n    return minver\n  }\n\n  minver = null\n  for (let i = 0; i < range.set.length; ++i) {\n    const comparators = range.set[i]\n\n    let setMin = null\n    comparators.forEach((comparator) => {\n      // Clone to avoid manipulating the comparator's semver object.\n      const compver = new SemVer(comparator.semver.version)\n      switch (comparator.operator) {\n        case '>':\n          if (compver.prerelease.length === 0) {\n            compver.patch++\n          } else {\n            compver.prerelease.push(0)\n          }\n          compver.raw = compver.format()\n          /* fallthrough */\n        case '':\n        case '>=':\n          if (!setMin || gt(compver, setMin)) {\n            setMin = compver\n          }\n          break\n        case '<':\n        case '<=':\n          /* Ignore maximum versions */\n          break\n        /* istanbul ignore next */\n        default:\n          throw new Error(`Unexpected operation: ${comparator.operator}`)\n      }\n    })\n    if (setMin && (!minver || gt(minver, setMin))) {\n      minver = setMin\n    }\n  }\n\n  if (minver && range.test(minver)) {\n    return minver\n  }\n\n  return null\n}\nmodule.exports = minVersion\n","const Range = require('../classes/range')\nconst validRange = (range, options) => {\n  try {\n    // Return '*' instead of '' so that truthiness works.\n    // This will throw if it's invalid anyway\n    return new Range(range, options).range || '*'\n  } catch (er) {\n    return null\n  }\n}\nmodule.exports = validRange\n","// Determine if version is greater than all the versions possible in the range.\nconst outside = require('./outside')\nconst gtr = (version, range, options) => outside(version, range, '>', options)\nmodule.exports = gtr\n","const outside = require('./outside')\n// Determine if version is less than all the versions possible in the range\nconst ltr = (version, range, options) => outside(version, range, '<', options)\nmodule.exports = ltr\n","const Range = require('../classes/range')\nconst intersects = (r1, r2, options) => {\n  r1 = new Range(r1, options)\n  r2 = new Range(r2, options)\n  return r1.intersects(r2, options)\n}\nmodule.exports = intersects\n","// given a set of versions and a range, create a \"simplified\" range\n// that includes the same versions that the original range does\n// If the original range is shorter than the simplified one, return that.\nconst satisfies = require('../functions/satisfies.js')\nconst compare = require('../functions/compare.js')\nmodule.exports = (versions, range, options) => {\n  const set = []\n  let first = null\n  let prev = null\n  const v = versions.sort((a, b) => compare(a, b, options))\n  for (const version of v) {\n    const included = satisfies(version, range, options)\n    if (included) {\n      prev = version\n      if (!first) {\n        first = version\n      }\n    } else {\n      if (prev) {\n        set.push([first, prev])\n      }\n      prev = null\n      first = null\n    }\n  }\n  if (first) {\n    set.push([first, null])\n  }\n\n  const ranges = []\n  for (const [min, max] of set) {\n    if (min === max) {\n      ranges.push(min)\n    } else if (!max && min === v[0]) {\n      ranges.push('*')\n    } else if (!max) {\n      ranges.push(`>=${min}`)\n    } else if (min === v[0]) {\n      ranges.push(`<=${max}`)\n    } else {\n      ranges.push(`${min} - ${max}`)\n    }\n  }\n  const simplified = ranges.join(' || ')\n  const original = typeof range.raw === 'string' ? range.raw : String(range)\n  return simplified.length < original.length ? simplified : range\n}\n","const Range = require('../classes/range.js')\nconst Comparator = require('../classes/comparator.js')\nconst { ANY } = Comparator\nconst satisfies = require('../functions/satisfies.js')\nconst compare = require('../functions/compare.js')\n\n// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:\n// - Every simple range `r1, r2, ...` is a null set, OR\n// - Every simple range `r1, r2, ...` which is not a null set is a subset of\n//   some `R1, R2, ...`\n//\n// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:\n// - If c is only the ANY comparator\n//   - If C is only the ANY comparator, return true\n//   - Else if in prerelease mode, return false\n//   - else replace c with `[>=0.0.0]`\n// - If C is only the ANY comparator\n//   - if in prerelease mode, return true\n//   - else replace C with `[>=0.0.0]`\n// - Let EQ be the set of = comparators in c\n// - If EQ is more than one, return true (null set)\n// - Let GT be the highest > or >= comparator in c\n// - Let LT be the lowest < or <= comparator in c\n// - If GT and LT, and GT.semver > LT.semver, return true (null set)\n// - If any C is a = range, and GT or LT are set, return false\n// - If EQ\n//   - If GT, and EQ does not satisfy GT, return true (null set)\n//   - If LT, and EQ does not satisfy LT, return true (null set)\n//   - If EQ satisfies every C, return true\n//   - Else return false\n// - If GT\n//   - If GT.semver is lower than any > or >= comp in C, return false\n//   - If GT is >=, and GT.semver does not satisfy every C, return false\n//   - If GT.semver has a prerelease, and not in prerelease mode\n//     - If no C has a prerelease and the GT.semver tuple, return false\n// - If LT\n//   - If LT.semver is greater than any < or <= comp in C, return false\n//   - If LT is <=, and LT.semver does not satisfy every C, return false\n//   - If GT.semver has a prerelease, and not in prerelease mode\n//     - If no C has a prerelease and the LT.semver tuple, return false\n// - Else return true\n\nconst subset = (sub, dom, options = {}) => {\n  if (sub === dom) {\n    return true\n  }\n\n  sub = new Range(sub, options)\n  dom = new Range(dom, options)\n  let sawNonNull = false\n\n  OUTER: for (const simpleSub of sub.set) {\n    for (const simpleDom of dom.set) {\n      const isSub = simpleSubset(simpleSub, simpleDom, options)\n      sawNonNull = sawNonNull || isSub !== null\n      if (isSub) {\n        continue OUTER\n      }\n    }\n    // the null set is a subset of everything, but null simple ranges in\n    // a complex range should be ignored.  so if we saw a non-null range,\n    // then we know this isn't a subset, but if EVERY simple range was null,\n    // then it is a subset.\n    if (sawNonNull) {\n      return false\n    }\n  }\n  return true\n}\n\nconst minimumVersionWithPreRelease = [new Comparator('>=0.0.0-0')]\nconst minimumVersion = [new Comparator('>=0.0.0')]\n\nconst simpleSubset = (sub, dom, options) => {\n  if (sub === dom) {\n    return true\n  }\n\n  if (sub.length === 1 && sub[0].semver === ANY) {\n    if (dom.length === 1 && dom[0].semver === ANY) {\n      return true\n    } else if (options.includePrerelease) {\n      sub = minimumVersionWithPreRelease\n    } else {\n      sub = minimumVersion\n    }\n  }\n\n  if (dom.length === 1 && dom[0].semver === ANY) {\n    if (options.includePrerelease) {\n      return true\n    } else {\n      dom = minimumVersion\n    }\n  }\n\n  const eqSet = new Set()\n  let gt, lt\n  for (const c of sub) {\n    if (c.operator === '>' || c.operator === '>=') {\n      gt = higherGT(gt, c, options)\n    } else if (c.operator === '<' || c.operator === '<=') {\n      lt = lowerLT(lt, c, options)\n    } else {\n      eqSet.add(c.semver)\n    }\n  }\n\n  if (eqSet.size > 1) {\n    return null\n  }\n\n  let gtltComp\n  if (gt && lt) {\n    gtltComp = compare(gt.semver, lt.semver, options)\n    if (gtltComp > 0) {\n      return null\n    } else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {\n      return null\n    }\n  }\n\n  // will iterate one or zero times\n  for (const eq of eqSet) {\n    if (gt && !satisfies(eq, String(gt), options)) {\n      return null\n    }\n\n    if (lt && !satisfies(eq, String(lt), options)) {\n      return null\n    }\n\n    for (const c of dom) {\n      if (!satisfies(eq, String(c), options)) {\n        return false\n      }\n    }\n\n    return true\n  }\n\n  let higher, lower\n  let hasDomLT, hasDomGT\n  // if the subset has a prerelease, we need a comparator in the superset\n  // with the same tuple and a prerelease, or it's not a subset\n  let needDomLTPre = lt &&\n    !options.includePrerelease &&\n    lt.semver.prerelease.length ? lt.semver : false\n  let needDomGTPre = gt &&\n    !options.includePrerelease &&\n    gt.semver.prerelease.length ? gt.semver : false\n  // exception: <1.2.3-0 is the same as <1.2.3\n  if (needDomLTPre && needDomLTPre.prerelease.length === 1 &&\n      lt.operator === '<' && needDomLTPre.prerelease[0] === 0) {\n    needDomLTPre = false\n  }\n\n  for (const c of dom) {\n    hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>='\n    hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<='\n    if (gt) {\n      if (needDomGTPre) {\n        if (c.semver.prerelease && c.semver.prerelease.length &&\n            c.semver.major === needDomGTPre.major &&\n            c.semver.minor === needDomGTPre.minor &&\n            c.semver.patch === needDomGTPre.patch) {\n          needDomGTPre = false\n        }\n      }\n      if (c.operator === '>' || c.operator === '>=') {\n        higher = higherGT(gt, c, options)\n        if (higher === c && higher !== gt) {\n          return false\n        }\n      } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options)) {\n        return false\n      }\n    }\n    if (lt) {\n      if (needDomLTPre) {\n        if (c.semver.prerelease && c.semver.prerelease.length &&\n            c.semver.major === needDomLTPre.major &&\n            c.semver.minor === needDomLTPre.minor &&\n            c.semver.patch === needDomLTPre.patch) {\n          needDomLTPre = false\n        }\n      }\n      if (c.operator === '<' || c.operator === '<=') {\n        lower = lowerLT(lt, c, options)\n        if (lower === c && lower !== lt) {\n          return false\n        }\n      } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options)) {\n        return false\n      }\n    }\n    if (!c.operator && (lt || gt) && gtltComp !== 0) {\n      return false\n    }\n  }\n\n  // if there was a < or >, and nothing in the dom, then must be false\n  // UNLESS it was limited by another range in the other direction.\n  // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0\n  if (gt && hasDomLT && !lt && gtltComp !== 0) {\n    return false\n  }\n\n  if (lt && hasDomGT && !gt && gtltComp !== 0) {\n    return false\n  }\n\n  // we needed a prerelease range in a specific tuple, but didn't get one\n  // then this isn't a subset.  eg >=1.2.3-pre is not a subset of >=1.0.0,\n  // because it includes prereleases in the 1.2.3 tuple\n  if (needDomGTPre || needDomLTPre) {\n    return false\n  }\n\n  return true\n}\n\n// >=1.2.3 is lower than >1.2.3\nconst higherGT = (a, b, options) => {\n  if (!a) {\n    return b\n  }\n  const comp = compare(a.semver, b.semver, options)\n  return comp > 0 ? a\n    : comp < 0 ? b\n    : b.operator === '>' && a.operator === '>=' ? b\n    : a\n}\n\n// <=1.2.3 is higher than <1.2.3\nconst lowerLT = (a, b, options) => {\n  if (!a) {\n    return b\n  }\n  const comp = compare(a.semver, b.semver, options)\n  return comp < 0 ? a\n    : comp > 0 ? b\n    : b.operator === '<' && a.operator === '<=' ? b\n    : a\n}\n\nmodule.exports = subset\n","const semver = require('semver');\n\nmodule.exports = semver.satisfies(process.version, '>=16.9.0');\n","const timespan = require('./lib/timespan');\nconst PS_SUPPORTED = require('./lib/psSupported');\nconst validateAsymmetricKey = require('./lib/validateAsymmetricKey');\nconst jws = require('jws');\nconst includes = require('lodash.includes');\nconst isBoolean = require('lodash.isboolean');\nconst isInteger = require('lodash.isinteger');\nconst isNumber = require('lodash.isnumber');\nconst isPlainObject = require('lodash.isplainobject');\nconst isString = require('lodash.isstring');\nconst once = require('lodash.once');\nconst { KeyObject, createSecretKey, createPrivateKey } = require('crypto')\n\nconst SUPPORTED_ALGS = ['RS256', 'RS384', 'RS512', 'ES256', 'ES384', 'ES512', 'HS256', 'HS384', 'HS512', 'none'];\nif (PS_SUPPORTED) {\n  SUPPORTED_ALGS.splice(3, 0, 'PS256', 'PS384', 'PS512');\n}\n\nconst sign_options_schema = {\n  expiresIn: { isValid: function(value) { return isInteger(value) || (isString(value) && value); }, message: '\"expiresIn\" should be a number of seconds or string representing a timespan' },\n  notBefore: { isValid: function(value) { return isInteger(value) || (isString(value) && value); }, message: '\"notBefore\" should be a number of seconds or string representing a timespan' },\n  audience: { isValid: function(value) { return isString(value) || Array.isArray(value); }, message: '\"audience\" must be a string or array' },\n  algorithm: { isValid: includes.bind(null, SUPPORTED_ALGS), message: '\"algorithm\" must be a valid string enum value' },\n  header: { isValid: isPlainObject, message: '\"header\" must be an object' },\n  encoding: { isValid: isString, message: '\"encoding\" must be a string' },\n  issuer: { isValid: isString, message: '\"issuer\" must be a string' },\n  subject: { isValid: isString, message: '\"subject\" must be a string' },\n  jwtid: { isValid: isString, message: '\"jwtid\" must be a string' },\n  noTimestamp: { isValid: isBoolean, message: '\"noTimestamp\" must be a boolean' },\n  keyid: { isValid: isString, message: '\"keyid\" must be a string' },\n  mutatePayload: { isValid: isBoolean, message: '\"mutatePayload\" must be a boolean' },\n  allowInsecureKeySizes: { isValid: isBoolean, message: '\"allowInsecureKeySizes\" must be a boolean'},\n  allowInvalidAsymmetricKeyTypes: { isValid: isBoolean, message: '\"allowInvalidAsymmetricKeyTypes\" must be a boolean'}\n};\n\nconst registered_claims_schema = {\n  iat: { isValid: isNumber, message: '\"iat\" should be a number of seconds' },\n  exp: { isValid: isNumber, message: '\"exp\" should be a number of seconds' },\n  nbf: { isValid: isNumber, message: '\"nbf\" should be a number of seconds' }\n};\n\nfunction validate(schema, allowUnknown, object, parameterName) {\n  if (!isPlainObject(object)) {\n    throw new Error('Expected \"' + parameterName + '\" to be a plain object.');\n  }\n  Object.keys(object)\n    .forEach(function(key) {\n      const validator = schema[key];\n      if (!validator) {\n        if (!allowUnknown) {\n          throw new Error('\"' + key + '\" is not allowed in \"' + parameterName + '\"');\n        }\n        return;\n      }\n      if (!validator.isValid(object[key])) {\n        throw new Error(validator.message);\n      }\n    });\n}\n\nfunction validateOptions(options) {\n  return validate(sign_options_schema, false, options, 'options');\n}\n\nfunction validatePayload(payload) {\n  return validate(registered_claims_schema, true, payload, 'payload');\n}\n\nconst options_to_payload = {\n  'audience': 'aud',\n  'issuer': 'iss',\n  'subject': 'sub',\n  'jwtid': 'jti'\n};\n\nconst options_for_objects = [\n  'expiresIn',\n  'notBefore',\n  'noTimestamp',\n  'audience',\n  'issuer',\n  'subject',\n  'jwtid',\n];\n\nmodule.exports = function (payload, secretOrPrivateKey, options, callback) {\n  if (typeof options === 'function') {\n    callback = options;\n    options = {};\n  } else {\n    options = options || {};\n  }\n\n  const isObjectPayload = typeof payload === 'object' &&\n                        !Buffer.isBuffer(payload);\n\n  const header = Object.assign({\n    alg: options.algorithm || 'HS256',\n    typ: isObjectPayload ? 'JWT' : undefined,\n    kid: options.keyid\n  }, options.header);\n\n  function failure(err) {\n    if (callback) {\n      return callback(err);\n    }\n    throw err;\n  }\n\n  if (!secretOrPrivateKey && options.algorithm !== 'none') {\n    return failure(new Error('secretOrPrivateKey must have a value'));\n  }\n\n  if (secretOrPrivateKey != null && !(secretOrPrivateKey instanceof KeyObject)) {\n    try {\n      secretOrPrivateKey = createPrivateKey(secretOrPrivateKey)\n    } catch (_) {\n      try {\n        secretOrPrivateKey = createSecretKey(typeof secretOrPrivateKey === 'string' ? Buffer.from(secretOrPrivateKey) : secretOrPrivateKey)\n      } catch (_) {\n        return failure(new Error('secretOrPrivateKey is not valid key material'));\n      }\n    }\n  }\n\n  if (header.alg.startsWith('HS') && secretOrPrivateKey.type !== 'secret') {\n    return failure(new Error((`secretOrPrivateKey must be a symmetric key when using ${header.alg}`)))\n  } else if (/^(?:RS|PS|ES)/.test(header.alg)) {\n    if (secretOrPrivateKey.type !== 'private') {\n      return failure(new Error((`secretOrPrivateKey must be an asymmetric key when using ${header.alg}`)))\n    }\n    if (!options.allowInsecureKeySizes &&\n      !header.alg.startsWith('ES') &&\n      secretOrPrivateKey.asymmetricKeyDetails !== undefined && //KeyObject.asymmetricKeyDetails is supported in Node 15+\n      secretOrPrivateKey.asymmetricKeyDetails.modulusLength < 2048) {\n      return failure(new Error(`secretOrPrivateKey has a minimum key size of 2048 bits for ${header.alg}`));\n    }\n  }\n\n  if (typeof payload === 'undefined') {\n    return failure(new Error('payload is required'));\n  } else if (isObjectPayload) {\n    try {\n      validatePayload(payload);\n    }\n    catch (error) {\n      return failure(error);\n    }\n    if (!options.mutatePayload) {\n      payload = Object.assign({},payload);\n    }\n  } else {\n    const invalid_options = options_for_objects.filter(function (opt) {\n      return typeof options[opt] !== 'undefined';\n    });\n\n    if (invalid_options.length > 0) {\n      return failure(new Error('invalid ' + invalid_options.join(',') + ' option for ' + (typeof payload ) + ' payload'));\n    }\n  }\n\n  if (typeof payload.exp !== 'undefined' && typeof options.expiresIn !== 'undefined') {\n    return failure(new Error('Bad \"options.expiresIn\" option the payload already has an \"exp\" property.'));\n  }\n\n  if (typeof payload.nbf !== 'undefined' && typeof options.notBefore !== 'undefined') {\n    return failure(new Error('Bad \"options.notBefore\" option the payload already has an \"nbf\" property.'));\n  }\n\n  try {\n    validateOptions(options);\n  }\n  catch (error) {\n    return failure(error);\n  }\n\n  if (!options.allowInvalidAsymmetricKeyTypes) {\n    try {\n      validateAsymmetricKey(header.alg, secretOrPrivateKey);\n    } catch (error) {\n      return failure(error);\n    }\n  }\n\n  const timestamp = payload.iat || Math.floor(Date.now() / 1000);\n\n  if (options.noTimestamp) {\n    delete payload.iat;\n  } else if (isObjectPayload) {\n    payload.iat = timestamp;\n  }\n\n  if (typeof options.notBefore !== 'undefined') {\n    try {\n      payload.nbf = timespan(options.notBefore, timestamp);\n    }\n    catch (err) {\n      return failure(err);\n    }\n    if (typeof payload.nbf === 'undefined') {\n      return failure(new Error('\"notBefore\" should be a number of seconds or string representing a timespan eg: \"1d\", \"20h\", 60'));\n    }\n  }\n\n  if (typeof options.expiresIn !== 'undefined' && typeof payload === 'object') {\n    try {\n      payload.exp = timespan(options.expiresIn, timestamp);\n    }\n    catch (err) {\n      return failure(err);\n    }\n    if (typeof payload.exp === 'undefined') {\n      return failure(new Error('\"expiresIn\" should be a number of seconds or string representing a timespan eg: \"1d\", \"20h\", 60'));\n    }\n  }\n\n  Object.keys(options_to_payload).forEach(function (key) {\n    const claim = options_to_payload[key];\n    if (typeof options[key] !== 'undefined') {\n      if (typeof payload[claim] !== 'undefined') {\n        return failure(new Error('Bad \"options.' + key + '\" option. The payload already has an \"' + claim + '\" property.'));\n      }\n      payload[claim] = options[key];\n    }\n  });\n\n  const encoding = options.encoding || 'utf8';\n\n  if (typeof callback === 'function') {\n    callback = callback && once(callback);\n\n    jws.createSign({\n      header: header,\n      privateKey: secretOrPrivateKey,\n      payload: payload,\n      encoding: encoding\n    }).once('error', callback)\n      .once('done', function (signature) {\n        // TODO: Remove in favor of the modulus length check before signing once node 15+ is the minimum supported version\n        if(!options.allowInsecureKeySizes && /^(?:RS|PS)/.test(header.alg) && signature.length < 256) {\n          return callback(new Error(`secretOrPrivateKey has a minimum key size of 2048 bits for ${header.alg}`))\n        }\n        callback(null, signature);\n      });\n  } else {\n    let signature = jws.sign({header: header, payload: payload, secret: secretOrPrivateKey, encoding: encoding});\n    // TODO: Remove in favor of the modulus length check before signing once node 15+ is the minimum supported version\n    if(!options.allowInsecureKeySizes && /^(?:RS|PS)/.test(header.alg) && signature.length < 256) {\n      throw new Error(`secretOrPrivateKey has a minimum key size of 2048 bits for ${header.alg}`)\n    }\n    return signature\n  }\n};\n","const debug = require('../internal/debug')\nconst { MAX_LENGTH, MAX_SAFE_INTEGER } = require('../internal/constants')\nconst { safeRe: re, t } = require('../internal/re')\n\nconst parseOptions = require('../internal/parse-options')\nconst { compareIdentifiers } = require('../internal/identifiers')\nclass SemVer {\n  constructor (version, options) {\n    options = parseOptions(options)\n\n    if (version instanceof SemVer) {\n      if (version.loose === !!options.loose &&\n          version.includePrerelease === !!options.includePrerelease) {\n        return version\n      } else {\n        version = version.version\n      }\n    } else if (typeof version !== 'string') {\n      throw new TypeError(`Invalid version. Must be a string. Got type \"${typeof version}\".`)\n    }\n\n    if (version.length > MAX_LENGTH) {\n      throw new TypeError(\n        `version is longer than ${MAX_LENGTH} characters`\n      )\n    }\n\n    debug('SemVer', version, options)\n    this.options = options\n    this.loose = !!options.loose\n    // this isn't actually relevant for versions, but keep it so that we\n    // don't run into trouble passing this.options around.\n    this.includePrerelease = !!options.includePrerelease\n\n    const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])\n\n    if (!m) {\n      throw new TypeError(`Invalid Version: ${version}`)\n    }\n\n    this.raw = version\n\n    // these are actually numbers\n    this.major = +m[1]\n    this.minor = +m[2]\n    this.patch = +m[3]\n\n    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {\n      throw new TypeError('Invalid major version')\n    }\n\n    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {\n      throw new TypeError('Invalid minor version')\n    }\n\n    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {\n      throw new TypeError('Invalid patch version')\n    }\n\n    // numberify any prerelease numeric ids\n    if (!m[4]) {\n      this.prerelease = []\n    } else {\n      this.prerelease = m[4].split('.').map((id) => {\n        if (/^[0-9]+$/.test(id)) {\n          const num = +id\n          if (num >= 0 && num < MAX_SAFE_INTEGER) {\n            return num\n          }\n        }\n        return id\n      })\n    }\n\n    this.build = m[5] ? m[5].split('.') : []\n    this.format()\n  }\n\n  format () {\n    this.version = `${this.major}.${this.minor}.${this.patch}`\n    if (this.prerelease.length) {\n      this.version += `-${this.prerelease.join('.')}`\n    }\n    return this.version\n  }\n\n  toString () {\n    return this.version\n  }\n\n  compare (other) {\n    debug('SemVer.compare', this.version, this.options, other)\n    if (!(other instanceof SemVer)) {\n      if (typeof other === 'string' && other === this.version) {\n        return 0\n      }\n      other = new SemVer(other, this.options)\n    }\n\n    if (other.version === this.version) {\n      return 0\n    }\n\n    return this.compareMain(other) || this.comparePre(other)\n  }\n\n  compareMain (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    return (\n      compareIdentifiers(this.major, other.major) ||\n      compareIdentifiers(this.minor, other.minor) ||\n      compareIdentifiers(this.patch, other.patch)\n    )\n  }\n\n  comparePre (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    // NOT having a prerelease is > having one\n    if (this.prerelease.length && !other.prerelease.length) {\n      return -1\n    } else if (!this.prerelease.length && other.prerelease.length) {\n      return 1\n    } else if (!this.prerelease.length && !other.prerelease.length) {\n      return 0\n    }\n\n    let i = 0\n    do {\n      const a = this.prerelease[i]\n      const b = other.prerelease[i]\n      debug('prerelease compare', i, a, b)\n      if (a === undefined && b === undefined) {\n        return 0\n      } else if (b === undefined) {\n        return 1\n      } else if (a === undefined) {\n        return -1\n      } else if (a === b) {\n        continue\n      } else {\n        return compareIdentifiers(a, b)\n      }\n    } while (++i)\n  }\n\n  compareBuild (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    let i = 0\n    do {\n      const a = this.build[i]\n      const b = other.build[i]\n      debug('build compare', i, a, b)\n      if (a === undefined && b === undefined) {\n        return 0\n      } else if (b === undefined) {\n        return 1\n      } else if (a === undefined) {\n        return -1\n      } else if (a === b) {\n        continue\n      } else {\n        return compareIdentifiers(a, b)\n      }\n    } while (++i)\n  }\n\n  // preminor will bump the version up to the next minor release, and immediately\n  // down to pre-release. premajor and prepatch work the same way.\n  inc (release, identifier, identifierBase) {\n    switch (release) {\n      case 'premajor':\n        this.prerelease.length = 0\n        this.patch = 0\n        this.minor = 0\n        this.major++\n        this.inc('pre', identifier, identifierBase)\n        break\n      case 'preminor':\n        this.prerelease.length = 0\n        this.patch = 0\n        this.minor++\n        this.inc('pre', identifier, identifierBase)\n        break\n      case 'prepatch':\n        // If this is already a prerelease, it will bump to the next version\n        // drop any prereleases that might already exist, since they are not\n        // relevant at this point.\n        this.prerelease.length = 0\n        this.inc('patch', identifier, identifierBase)\n        this.inc('pre', identifier, identifierBase)\n        break\n      // If the input is a non-prerelease version, this acts the same as\n      // prepatch.\n      case 'prerelease':\n        if (this.prerelease.length === 0) {\n          this.inc('patch', identifier, identifierBase)\n        }\n        this.inc('pre', identifier, identifierBase)\n        break\n\n      case 'major':\n        // If this is a pre-major version, bump up to the same major version.\n        // Otherwise increment major.\n        // 1.0.0-5 bumps to 1.0.0\n        // 1.1.0 bumps to 2.0.0\n        if (\n          this.minor !== 0 ||\n          this.patch !== 0 ||\n          this.prerelease.length === 0\n        ) {\n          this.major++\n        }\n        this.minor = 0\n        this.patch = 0\n        this.prerelease = []\n        break\n      case 'minor':\n        // If this is a pre-minor version, bump up to the same minor version.\n        // Otherwise increment minor.\n        // 1.2.0-5 bumps to 1.2.0\n        // 1.2.1 bumps to 1.3.0\n        if (this.patch !== 0 || this.prerelease.length === 0) {\n          this.minor++\n        }\n        this.patch = 0\n        this.prerelease = []\n        break\n      case 'patch':\n        // If this is not a pre-release version, it will increment the patch.\n        // If it is a pre-release it will bump up to the same patch version.\n        // 1.2.0-5 patches to 1.2.0\n        // 1.2.0 patches to 1.2.1\n        if (this.prerelease.length === 0) {\n          this.patch++\n        }\n        this.prerelease = []\n        break\n      // This probably shouldn't be used publicly.\n      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.\n      case 'pre': {\n        const base = Number(identifierBase) ? 1 : 0\n\n        if (!identifier && identifierBase === false) {\n          throw new Error('invalid increment argument: identifier is empty')\n        }\n\n        if (this.prerelease.length === 0) {\n          this.prerelease = [base]\n        } else {\n          let i = this.prerelease.length\n          while (--i >= 0) {\n            if (typeof this.prerelease[i] === 'number') {\n              this.prerelease[i]++\n              i = -2\n            }\n          }\n          if (i === -1) {\n            // didn't increment anything\n            if (identifier === this.prerelease.join('.') && identifierBase === false) {\n              throw new Error('invalid increment argument: identifier already exists')\n            }\n            this.prerelease.push(base)\n          }\n        }\n        if (identifier) {\n          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,\n          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0\n          let prerelease = [identifier, base]\n          if (identifierBase === false) {\n            prerelease = [identifier]\n          }\n          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {\n            if (isNaN(this.prerelease[1])) {\n              this.prerelease = prerelease\n            }\n          } else {\n            this.prerelease = prerelease\n          }\n        }\n        break\n      }\n      default:\n        throw new Error(`invalid increment argument: ${release}`)\n    }\n    this.raw = this.format()\n    if (this.build.length) {\n      this.raw += `+${this.build.join('.')}`\n    }\n    return this\n  }\n}\n\nmodule.exports = SemVer\n","module.exports = Array.isArray || function (arr) {\n  return Object.prototype.toString.call(arr) == '[object Array]';\n};\n"],"sourceRoot":""}