{"version":3,"sources":["../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/isarray/index.js","../node_modules/jsonwebtoken/node_modules/semver/classes/semver.js","../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"],"names":["module","exports","decode","require","verify","sign","JsonWebTokenError","NotBeforeError","TokenExpiredError","timespan","validateAsymmetricKey","PS_SUPPORTED","jws","KeyObject","createSecretKey","createPublicKey","PUB_KEY_ALGS","EC_KEY_ALGS","RSA_KEY_ALGS","HS_ALGS","splice","length","jwtString","secretOrPublicKey","options","callback","done","Object","assign","err","data","clockTimestamp","undefined","nonce","trim","allowInvalidAsymmetricKeyTypes","Math","floor","Date","now","parts","split","decodedToken","complete","header","getSecret","secretCallback","message","hasSignature","algorithms","_","Buffer","from","type","includes","asymmetricKeyType","indexOf","alg","startsWith","test","e","valid","payload","nbf","ignoreNotBefore","clockTolerance","exp","ignoreExpiration","audience","audiences","Array","isArray","aud","some","targetAudience","RegExp","join","issuer","iss","subject","sub","jwtid","jti","maxAge","iat","maxAgeTimestamp","signature","semver","satisfies","process","version","parse","v","clean","s","replace","SemVer","inc","release","identifier","identifierBase","er","diff","version1","version2","v1","v2","comparison","compare","v1Higher","highVersion","lowVersion","highHasPre","prerelease","patch","minor","prefix","major","a","loose","parsed","rcompare","b","compareLoose","compareBuild","sort","list","rsort","safeRe","re","t","coerce","String","match","rtl","coerceRtlRegex","includePrerelease","COERCERTLFULL","COERCERTL","next","exec","index","lastIndex","COERCEFULL","COERCE","build","constructor","this","max","map","Map","get","key","value","delete","set","size","firstKey","keys","Range","toComparators","range","comp","c","maxSatisfying","versions","maxSV","rangeObj","forEach","minSatisfying","min","minSV","gt","minVersion","minver","i","comparators","setMin","comparator","compver","operator","push","raw","format","Error","validRange","outside","gtr","ltr","intersects","r1","r2","first","prev","ranges","simplified","original","Comparator","ANY","minimumVersionWithPreRelease","minimumVersion","simpleSubset","dom","eqSet","Set","lt","gtltComp","higher","lower","hasDomLT","hasDomGT","higherGT","lowerLT","add","eq","needDomLTPre","needDomGTPre","arguments","sawNonNull","OUTER","simpleSub","simpleDom","isSub","isBoolean","isInteger","isNumber","isPlainObject","isString","once","createPrivateKey","SUPPORTED_ALGS","sign_options_schema","expiresIn","isValid","notBefore","algorithm","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","asymmetricKeyDetails","modulusLength","validatePayload","error","invalid_options","filter","opt","validateOptions","timestamp","claim","secret","createSign","privateKey","arr","prototype","toString","call","debug","MAX_LENGTH","MAX_SAFE_INTEGER","parseOptions","compareIdentifiers","TypeError","m","LOOSE","FULL","id","num","other","compareMain","comparePre","base","Number","isNaN","SPACE_CHARACTERS","formatted","r","parseRange","isNullSet","isAny","comps","k","memoKey","FLAG_INCLUDE_PRERELEASE","FLAG_LOOSE","cached","cache","hr","HYPHENRANGELOOSE","HYPHENRANGE","hyphenReplace","COMPARATORTRIM","comparatorTrimReplace","TILDETRIM","tildeTrimReplace","CARETTRIM","caretTrimReplace","rangeList","parseComparator","replaceGTE0","COMPARATORLOOSE","rangeMap","has","result","values","thisComparators","isSatisfiable","rangeComparators","every","thisComparator","rangeComparator","testSet","remainingComparators","slice","testComparator","pop","otherComparator","replaceCarets","replaceTildes","replaceXRanges","replaceStars","isX","toLowerCase","replaceTilde","TILDELOOSE","TILDE","M","p","pr","ret","replaceCaret","CARETLOOSE","CARET","z","replaceXRange","XRANGELOOSE","XRANGE","gtlt","xM","xm","xp","anyX","STAR","GTE0PRE","GTE0","incPr","$0","fM","fm","fp","fpr","fb","to","tM","tm","tp","tpr","allowed","throwErrors","MAX_SAFE_COMPONENT_LENGTH","MAX_SAFE_BUILD_LENGTH","src","R","LETTERDASHNUMBER","safeRegexReplacements","createToken","name","isGlobal","safe","token","makeSafeRegex","NUMERICIDENTIFIER","NUMERICIDENTIFIERLOOSE","NONNUMERICIDENTIFIER","PRERELEASEIDENTIFIER","PRERELEASEIDENTIFIERLOOSE","BUILDIDENTIFIER","MAINVERSION","PRERELEASE","BUILD","FULLPLAIN","MAINVERSIONLOOSE","PRERELEASELOOSE","LOOSEPLAIN","XRANGEIDENTIFIER","XRANGEIDENTIFIERLOOSE","GTLT","XRANGEPLAIN","XRANGEPLAINLOOSE","COERCEPLAIN","LONETILDE","LONECARET","captureStackTrace","inner","create","RELEASE_TYPES","SEMVER_SPEC_VERSION","NODE_DEBUG","_len","args","_key","Symbol","COMPARATOR","cmp","internalRe","constants","identifiers","neq","gte","lte","simplifyRange","subset","tokens","rcompareIdentifiers","looseOption","freeze","emptyOpts","versionA","versionB","hilo","gtfn","ltefn","ltfn","ecomp","high","low","jwt","decoded","obj","JSON","date","expiredAt","ms","time","milliseconds","ASYMMETRIC_KEY_DETAILS_SUPPORTED","RSA_PSS_KEY_DETAILS_SUPPORTED","allowedAlgorithmsForKeys","allowedCurves","ES256","ES384","ES512","keyType","allowedAlgorithms","keyCurve","namedCurve","allowedCurve","parseInt","hashAlgorithm","mgf1HashAlgorithm","saltLength","numeric","anum","bnum","op"],"mappings":"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","file":"static/js/main~7d359b94.ceec9141.chunk.js","sourcesContent":["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","module.exports = Array.isArray || function (arr) {\n  return Object.prototype.toString.call(arr) == '[object Array]';\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","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"],"sourceRoot":""}