Skip to content

Instantly share code, notes, and snippets.

@zhenyanghua

zhenyanghua/semver.js

Last active January 19, 2021 00:23
Show Gist options
  • Save zhenyanghua/fe68ac271380004f0376c827c986f9ae to your computer and use it in GitHub Desktop.
Save zhenyanghua/fe68ac271380004f0376c827c986f9ae to your computer and use it in GitHub Desktop.
Download ZIP
semver browser port
Raw
semver.js
window.SemVer = (function () {
'use strict';
function createCommonjsModule(fn) {
var module = { exports: {} };
return fn(module, module.exports), module.exports;
}
// Note: this is the semver.org version of the spec that it implements
// Not necessarily the package version of this code.
const SEMVER_SPEC_VERSION = '2.0.0';
const MAX_LENGTH = 256;
const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
/* istanbul ignore next */
9007199254740991; // Max safe segment length for coercion.
const MAX_SAFE_COMPONENT_LENGTH = 16;
var constants = {
SEMVER_SPEC_VERSION,
MAX_LENGTH,
MAX_SAFE_INTEGER,
MAX_SAFE_COMPONENT_LENGTH
};
const debug = typeof process === 'object' && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error('SEMVER', ...args) : () => {};
var debug_1 = debug;
var re_1 = createCommonjsModule(function (module, exports) {
const {
MAX_SAFE_COMPONENT_LENGTH
} = constants;
exports = module.exports = {}; // The actual regexps go on exports.re
const re = exports.re = [];
const src = exports.src = [];
const t = exports.t = {};
let R = 0;
const createToken = (name, value, isGlobal) => {
const index = R++;
debug_1(index, value);
t[name] = index;
src[index] = value;
re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
}; // The following Regular Expressions can be used for tokenizing,
// validating, and parsing SemVer version strings.
// ## Numeric Identifier
// A single `0`, or a non-zero digit followed by zero or more digits.
createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
createToken('NUMERICIDENTIFIERLOOSE', '[0-9]+'); // ## Non-numeric Identifier
// Zero or more digits, followed by a letter or hyphen, and then zero or
// more letters, digits, or hyphens.
createToken('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*'); // ## Main Version
// Three dot-separated numeric identifiers.
createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` + `(${src[t.NUMERICIDENTIFIER]})\\.` + `(${src[t.NUMERICIDENTIFIER]})`);
createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})`); // ## Pre-release Version Identifier
// A numeric identifier, or a non-numeric identifier.
createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`);
createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`); // ## Pre-release Version
// Hyphen, followed by one or more dot-separated pre-release version
// identifiers.
createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`); // ## Build Metadata Identifier
// Any combination of digits, letters, or hyphens.
createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+'); // ## Build Metadata
// Plus sign, followed by one or more period-separated build metadata
// identifiers.
createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`); // ## Full Version String
// A main version, followed optionally by a pre-release version and
// build metadata.
// Note that the only major, minor, patch, and pre-release sections of
// the version string are capturing groups. The build metadata is not a
// capturing group, because it should not ever be used in version
// comparison.
createToken('FULLPLAIN', `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
createToken('FULL', `^${src[t.FULLPLAIN]}$`); // like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
// common in the npm registry.
createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`);
createToken('GTLT', '((?:<|>)?=?)'); // Something like "2.*" or "1.2.x".
// Note that "x.x" is a valid xRange identifer, meaning "any version"
// Only the first item is strictly required.
createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + `(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?` + `)?)?`);
createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?` + `)?)?`);
createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`); // Coercion.
// Extract anything that could conceivably be a part of a valid semver
createToken('COERCE', `${'(^|[^\\d])' + '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:$|[^\\d])`);
createToken('COERCERTL', src[t.COERCE], true); // Tilde ranges.
// Meaning is "reasonably at or greater than"
createToken('LONETILDE', '(?:~>?)');
createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true);
exports.tildeTrimReplace = '$1~';
createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`); // Caret ranges.
// Meaning is "at least and backwards compatible with"
createToken('LONECARET', '(?:\\^)');
createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true);
exports.caretTrimReplace = '$1^';
createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`); // A simple gt/lt/eq thing, or just "" to indicate "any version"
createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`); // An expression to strip any whitespace between the gtlt and the thing
// it modifies, so that `> 1.2.3` ==> `>1.2.3`
createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
exports.comparatorTrimReplace = '$1$2$3'; // Something like `1.2.3 - 1.2.4`
// Note that these all use the loose form, because they'll be
// checked against either the strict or loose comparator form
// later.
createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` + `\\s+-\\s+` + `(${src[t.XRANGEPLAIN]})` + `\\s*$`);
createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` + `\\s+-\\s+` + `(${src[t.XRANGEPLAINLOOSE]})` + `\\s*$`); // Star ranges basically just allow anything at all.
createToken('STAR', '(<|>)?=?\\s*\\*'); // >=0.0.0 is like a star
createToken('GTE0', '^\\s*>=\\s*0\.0\.0\\s*$');
createToken('GTE0PRE', '^\\s*>=\\s*0\.0\.0-0\\s*$');
});
// parse out just the options we care about so we always get a consistent
// obj with keys in a consistent order.
const opts = ['includePrerelease', 'loose', 'rtl'];
const parseOptions = options => !options ? {} : typeof options !== 'object' ? {
loose: true
} : opts.filter(k => options[k]).reduce((options, k) => {
options[k] = true;
return options;
}, {});
var parseOptions_1 = parseOptions;
const numeric = /^[0-9]+$/;
const compareIdentifiers = (a, b) => {
const anum = numeric.test(a);
const bnum = numeric.test(b);
if (anum && bnum) {
a = +a;
b = +b;
}
return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
};
const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
var identifiers = {
compareIdentifiers,
rcompareIdentifiers
};
const {
MAX_LENGTH: MAX_LENGTH$1,
MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1
} = constants;
const {
re,
t
} = re_1;
const {
compareIdentifiers: compareIdentifiers$1
} = identifiers;
class SemVer {
constructor(version, options) {
options = parseOptions_1(options);
if (version instanceof SemVer) {
if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
return version;
} else {
version = version.version;
}
} else if (typeof version !== 'string') {
throw new TypeError(`Invalid Version: ${version}`);
}
if (version.length > MAX_LENGTH$1) {
throw new TypeError(`version is longer than ${MAX_LENGTH$1} characters`);
}
debug_1('SemVer', version, options);
this.options = options;
this.loose = !!options.loose; // this isn't actually relevant for versions, but keep it so that we
// don't run into trouble passing this.options around.
this.includePrerelease = !!options.includePrerelease;
const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
if (!m) {
throw new TypeError(`Invalid Version: ${version}`);
}
this.raw = version; // these are actually numbers
this.major = +m[1];
this.minor = +m[2];
this.patch = +m[3];
if (this.major > MAX_SAFE_INTEGER$1 || this.major < 0) {
throw new TypeError('Invalid major version');
}
if (this.minor > MAX_SAFE_INTEGER$1 || this.minor < 0) {
throw new TypeError('Invalid minor version');
}
if (this.patch > MAX_SAFE_INTEGER$1 || this.patch < 0) {
throw new TypeError('Invalid patch version');
} // numberify any prerelease numeric ids
if (!m[4]) {
this.prerelease = [];
} else {
this.prerelease = m[4].split('.').map(id => {
if (/^[0-9]+$/.test(id)) {
const num = +id;
if (num >= 0 && num < MAX_SAFE_INTEGER$1) {
return num;
}
}
return id;
});
}
this.build = m[5] ? m[5].split('.') : [];
this.format();
}
format() {
this.version = `${this.major}.${this.minor}.${this.patch}`;
if (this.prerelease.length) {
this.version += `-${this.prerelease.join('.')}`;
}
return this.version;
}
toString() {
return this.version;
}
compare(other) {
debug_1('SemVer.compare', this.version, this.options, other);
if (!(other instanceof SemVer)) {
if (typeof other === 'string' && other === this.version) {
return 0;
}
other = new SemVer(other, this.options);
}
if (other.version === this.version) {
return 0;
}
return this.compareMain(other) || this.comparePre(other);
}
compareMain(other) {
if (!(other instanceof SemVer)) {
other = new SemVer(other, this.options);
}
return compareIdentifiers$1(this.major, other.major) || compareIdentifiers$1(this.minor, other.minor) || compareIdentifiers$1(this.patch, other.patch);
}
comparePre(other) {
if (!(other instanceof SemVer)) {
other = new SemVer(other, this.options);
} // NOT having a prerelease is > having one
if (this.prerelease.length && !other.prerelease.length) {
return -1;
} else if (!this.prerelease.length && other.prerelease.length) {
return 1;
} else if (!this.prerelease.length && !other.prerelease.length) {
return 0;
}
let i = 0;
do {
const a = this.prerelease[i];
const b = other.prerelease[i];
debug_1('prerelease compare', i, a, b);
if (a === undefined && b === undefined) {
return 0;
} else if (b === undefined) {
return 1;
} else if (a === undefined) {
return -1;
} else if (a === b) {
continue;
} else {
return compareIdentifiers$1(a, b);
}
} while (++i);
}
compareBuild(other) {
if (!(other instanceof SemVer)) {
other = new SemVer(other, this.options);
}
let i = 0;
do {
const a = this.build[i];
const b = other.build[i];
debug_1('prerelease compare', i, a, b);
if (a === undefined && b === undefined) {
return 0;
} else if (b === undefined) {
return 1;
} else if (a === undefined) {
return -1;
} else if (a === b) {
continue;
} else {
return compareIdentifiers$1(a, b);
}
} while (++i);
} // preminor will bump the version up to the next minor release, and immediately
// down to pre-release. premajor and prepatch work the same way.
inc(release, identifier) {
switch (release) {
case 'premajor':
this.prerelease.length = 0;
this.patch = 0;
this.minor = 0;
this.major++;
this.inc('pre', identifier);
break;
case 'preminor':
this.prerelease.length = 0;
this.patch = 0;
this.minor++;
this.inc('pre', identifier);
break;
case 'prepatch':
// If this is already a prerelease, it will bump to the next version
// drop any prereleases that might already exist, since they are not
// relevant at this point.
this.prerelease.length = 0;
this.inc('patch', identifier);
this.inc('pre', identifier);
break;
// If the input is a non-prerelease version, this acts the same as
// prepatch.
case 'prerelease':
if (this.prerelease.length === 0) {
this.inc('patch', identifier);
}
this.inc('pre', identifier);
break;
case 'major':
// If this is a pre-major version, bump up to the same major version.
// Otherwise increment major.
// 1.0.0-5 bumps to 1.0.0
// 1.1.0 bumps to 2.0.0
if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
this.major++;
}
this.minor = 0;
this.patch = 0;
this.prerelease = [];
break;
case 'minor':
// If this is a pre-minor version, bump up to the same minor version.
// Otherwise increment minor.
// 1.2.0-5 bumps to 1.2.0
// 1.2.1 bumps to 1.3.0
if (this.patch !== 0 || this.prerelease.length === 0) {
this.minor++;
}
this.patch = 0;
this.prerelease = [];
break;
case 'patch':
// If this is not a pre-release version, it will increment the patch.
// If it is a pre-release it will bump up to the same patch version.
// 1.2.0-5 patches to 1.2.0
// 1.2.0 patches to 1.2.1
if (this.prerelease.length === 0) {
this.patch++;
}
this.prerelease = [];
break;
// This probably shouldn't be used publicly.
// 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
case 'pre':
if (this.prerelease.length === 0) {
this.prerelease = [0];
} else {
let i = this.prerelease.length;
while (--i >= 0) {
if (typeof this.prerelease[i] === 'number') {
this.prerelease[i]++;
i = -2;
}
}
if (i === -1) {
// didn't increment anything
this.prerelease.push(0);
}
}
if (identifier) {
// 1.2.0-beta.1 bumps to 1.2.0-beta.2,
// 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
if (this.prerelease[0] === identifier) {
if (isNaN(this.prerelease[1])) {
this.prerelease = [identifier, 0];
}
} else {
this.prerelease = [identifier, 0];
}
}
break;
default:
throw new Error(`invalid increment argument: ${release}`);
}
this.format();
this.raw = this.version;
return this;
}
}
var semver = SemVer;
const {
MAX_LENGTH: MAX_LENGTH$2
} = constants;
const {
re: re$1,
t: t$1
} = re_1;
const parse = (version, options) => {
options = parseOptions_1(options);
if (version instanceof semver) {
return version;
}
if (typeof version !== 'string') {
return null;
}
if (version.length > MAX_LENGTH$2) {
return null;
}
const r = options.loose ? re$1[t$1.LOOSE] : re$1[t$1.FULL];
if (!r.test(version)) {
return null;
}
try {
return new semver(version, options);
} catch (er) {
return null;
}
};
var parse_1 = parse;
const valid = (version, options) => {
const v = parse_1(version, options);
return v ? v.version : null;
};
var valid_1 = valid;
const clean = (version, options) => {
const s = parse_1(version.trim().replace(/^[=v]+/, ''), options);
return s ? s.version : null;
};
var clean_1 = clean;
const inc = (version, release, options, identifier) => {
if (typeof options === 'string') {
identifier = options;
options = undefined;
}
try {
return new semver(version, options).inc(release, identifier).version;
} catch (er) {
return null;
}
};
var inc_1 = inc;
const compare = (a, b, loose) => new semver(a, loose).compare(new semver(b, loose));
var compare_1 = compare;
const eq = (a, b, loose) => compare_1(a, b, loose) === 0;
var eq_1 = eq;
const diff = (version1, version2) => {
if (eq_1(version1, version2)) {
return null;
} else {
const v1 = parse_1(version1);
const v2 = parse_1(version2);
const hasPre = v1.prerelease.length || v2.prerelease.length;
const prefix = hasPre ? 'pre' : '';
const defaultResult = hasPre ? 'prerelease' : '';
for (const key in v1) {
if (key === 'major' || key === 'minor' || key === 'patch') {
if (v1[key] !== v2[key]) {
return prefix + key;
}
}
}
return defaultResult; // may be undefined
}
};
var diff_1 = diff;
const major = (a, loose) => new semver(a, loose).major;
var major_1 = major;
const minor = (a, loose) => new semver(a, loose).minor;
var minor_1 = minor;
const patch = (a, loose) => new semver(a, loose).patch;
var patch_1 = patch;
const prerelease = (version, options) => {
const parsed = parse_1(version, options);
return parsed && parsed.prerelease.length ? parsed.prerelease : null;
};
var prerelease_1 = prerelease;
const rcompare = (a, b, loose) => compare_1(b, a, loose);
var rcompare_1 = rcompare;
const compareLoose = (a, b) => compare_1(a, b, true);
var compareLoose_1 = compareLoose;
const compareBuild = (a, b, loose) => {
const versionA = new semver(a, loose);
const versionB = new semver(b, loose);
return versionA.compare(versionB) || versionA.compareBuild(versionB);
};
var compareBuild_1 = compareBuild;
const sort = (list, loose) => list.sort((a, b) => compareBuild_1(a, b, loose));
var sort_1 = sort;
const rsort = (list, loose) => list.sort((a, b) => compareBuild_1(b, a, loose));
var rsort_1 = rsort;
const gt = (a, b, loose) => compare_1(a, b, loose) > 0;
var gt_1 = gt;
const lt = (a, b, loose) => compare_1(a, b, loose) < 0;
var lt_1 = lt;
const neq = (a, b, loose) => compare_1(a, b, loose) !== 0;
var neq_1 = neq;
const gte = (a, b, loose) => compare_1(a, b, loose) >= 0;
var gte_1 = gte;
const lte = (a, b, loose) => compare_1(a, b, loose) <= 0;
var lte_1 = lte;
const cmp = (a, op, b, loose) => {
switch (op) {
case '===':
if (typeof a === 'object') a = a.version;
if (typeof b === 'object') b = b.version;
return a === b;
case '!==':
if (typeof a === 'object') a = a.version;
if (typeof b === 'object') b = b.version;
return a !== b;
case '':
case '=':
case '==':
return eq_1(a, b, loose);
case '!=':
return neq_1(a, b, loose);
case '>':
return gt_1(a, b, loose);
case '>=':
return gte_1(a, b, loose);
case '<':
return lt_1(a, b, loose);
case '<=':
return lte_1(a, b, loose);
default:
throw new TypeError(`Invalid operator: ${op}`);
}
};
var cmp_1 = cmp;
const {
re: re$2,
t: t$2
} = re_1;
const coerce = (version, options) => {
if (version instanceof semver) {
return version;
}
if (typeof version === 'number') {
version = String(version);
}
if (typeof version !== 'string') {
return null;
}
options = options || {};
let match = null;
if (!options.rtl) {
match = version.match(re$2[t$2.COERCE]);
} else {
// Find the right-most coercible string that does not share
// a terminus with a more left-ward coercible string.
// Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
//
// Walk through the string checking with a /g regexp
// Manually set the index so as to pick up overlapping matches.
// Stop when we get a match that ends at the string end, since no
// coercible string can be more right-ward without the same terminus.
let next;
while ((next = re$2[t$2.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length)) {
if (!match || next.index + next[0].length !== match.index + match[0].length) {
match = next;
}
re$2[t$2.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
} // leave it in a clean state
re$2[t$2.COERCERTL].lastIndex = -1;
}
if (match === null) return null;
return parse_1(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options);
};
var coerce_1 = coerce;
var iterator = function (Yallist) {
Yallist.prototype[Symbol.iterator] = function* () {
for (let walker = this.head; walker; walker = walker.next) {
yield walker.value;
}
};
};
var yallist = Yallist;
Yallist.Node = Node;
Yallist.create = Yallist;
function Yallist (list) {
var self = this;
if (!(self instanceof Yallist)) {
self = new Yallist();
}
self.tail = null;
self.head = null;
self.length = 0;
if (list && typeof list.forEach === 'function') {
list.forEach(function (item) {
self.push(item);
});
} else if (arguments.length > 0) {
for (var i = 0, l = arguments.length; i < l; i++) {
self.push(arguments[i]);
}
}
return self
}
Yallist.prototype.removeNode = function (node) {
if (node.list !== this) {
throw new Error('removing node which does not belong to this list')
}
var next = node.next;
var prev = node.prev;
if (next) {
next.prev = prev;
}
if (prev) {
prev.next = next;
}
if (node === this.head) {
this.head = next;
}
if (node === this.tail) {
this.tail = prev;
}
node.list.length--;
node.next = null;
node.prev = null;
node.list = null;
return next
};
Yallist.prototype.unshiftNode = function (node) {
if (node === this.head) {
return
}
if (node.list) {
node.list.removeNode(node);
}
var head = this.head;
node.list = this;
node.next = head;
if (head) {
head.prev = node;
}
this.head = node;
if (!this.tail) {
this.tail = node;
}
this.length++;
};
Yallist.prototype.pushNode = function (node) {
if (node === this.tail) {
return
}
if (node.list) {
node.list.removeNode(node);
}
var tail = this.tail;
node.list = this;
node.prev = tail;
if (tail) {
tail.next = node;
}
this.tail = node;
if (!this.head) {
this.head = node;
}
this.length++;
};
Yallist.prototype.push = function () {
for (var i = 0, l = arguments.length; i < l; i++) {
push(this, arguments[i]);
}
return this.length
};
Yallist.prototype.unshift = function () {
for (var i = 0, l = arguments.length; i < l; i++) {
unshift(this, arguments[i]);
}
return this.length
};
Yallist.prototype.pop = function () {
if (!this.tail) {
return undefined
}
var res = this.tail.value;
this.tail = this.tail.prev;
if (this.tail) {
this.tail.next = null;
} else {
this.head = null;
}
this.length--;
return res
};
Yallist.prototype.shift = function () {
if (!this.head) {
return undefined
}
var res = this.head.value;
this.head = this.head.next;
if (this.head) {
this.head.prev = null;
} else {
this.tail = null;
}
this.length--;
return res
};
Yallist.prototype.forEach = function (fn, thisp) {
thisp = thisp || this;
for (var walker = this.head, i = 0; walker !== null; i++) {
fn.call(thisp, walker.value, i, this);
walker = walker.next;
}
};
Yallist.prototype.forEachReverse = function (fn, thisp) {
thisp = thisp || this;
for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
fn.call(thisp, walker.value, i, this);
walker = walker.prev;
}
};
Yallist.prototype.get = function (n) {
for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
// abort out of the list early if we hit a cycle
walker = walker.next;
}
if (i === n && walker !== null) {
return walker.value
}
};
Yallist.prototype.getReverse = function (n) {
for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
// abort out of the list early if we hit a cycle
walker = walker.prev;
}
if (i === n && walker !== null) {
return walker.value
}
};
Yallist.prototype.map = function (fn, thisp) {
thisp = thisp || this;
var res = new Yallist();
for (var walker = this.head; walker !== null;) {
res.push(fn.call(thisp, walker.value, this));
walker = walker.next;
}
return res
};
Yallist.prototype.mapReverse = function (fn, thisp) {
thisp = thisp || this;
var res = new Yallist();
for (var walker = this.tail; walker !== null;) {
res.push(fn.call(thisp, walker.value, this));
walker = walker.prev;
}
return res
};
Yallist.prototype.reduce = function (fn, initial) {
var acc;
var walker = this.head;
if (arguments.length > 1) {
acc = initial;
} else if (this.head) {
walker = this.head.next;
acc = this.head.value;
} else {
throw new TypeError('Reduce of empty list with no initial value')
}
for (var i = 0; walker !== null; i++) {
acc = fn(acc, walker.value, i);
walker = walker.next;
}
return acc
};
Yallist.prototype.reduceReverse = function (fn, initial) {
var acc;
var walker = this.tail;
if (arguments.length > 1) {
acc = initial;
} else if (this.tail) {
walker = this.tail.prev;
acc = this.tail.value;
} else {
throw new TypeError('Reduce of empty list with no initial value')
}
for (var i = this.length - 1; walker !== null; i--) {
acc = fn(acc, walker.value, i);
walker = walker.prev;
}
return acc
};
Yallist.prototype.toArray = function () {
var arr = new Array(this.length);
for (var i = 0, walker = this.head; walker !== null; i++) {
arr[i] = walker.value;
walker = walker.next;
}
return arr
};
Yallist.prototype.toArrayReverse = function () {
var arr = new Array(this.length);
for (var i = 0, walker = this.tail; walker !== null; i++) {
arr[i] = walker.value;
walker = walker.prev;
}
return arr
};
Yallist.prototype.slice = function (from, to) {
to = to || this.length;
if (to < 0) {
to += this.length;
}
from = from || 0;
if (from < 0) {
from += this.length;
}
var ret = new Yallist();
if (to < from || to < 0) {
return ret
}
if (from < 0) {
from = 0;
}
if (to > this.length) {
to = this.length;
}
for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
walker = walker.next;
}
for (; walker !== null && i < to; i++, walker = walker.next) {
ret.push(walker.value);
}
return ret
};
Yallist.prototype.sliceReverse = function (from, to) {
to = to || this.length;
if (to < 0) {
to += this.length;
}
from = from || 0;
if (from < 0) {
from += this.length;
}
var ret = new Yallist();
if (to < from || to < 0) {
return ret
}
if (from < 0) {
from = 0;
}
if (to > this.length) {
to = this.length;
}
for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
walker = walker.prev;
}
for (; walker !== null && i > from; i--, walker = walker.prev) {
ret.push(walker.value);
}
return ret
};
Yallist.prototype.splice = function (start, deleteCount, ...nodes) {
if (start > this.length) {
start = this.length - 1;
}
if (start < 0) {
start = this.length + start;
}
for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
walker = walker.next;
}
var ret = [];
for (var i = 0; walker && i < deleteCount; i++) {
ret.push(walker.value);
walker = this.removeNode(walker);
}
if (walker === null) {
walker = this.tail;
}
if (walker !== this.head && walker !== this.tail) {
walker = walker.prev;
}
for (var i = 0; i < nodes.length; i++) {
walker = insert(this, walker, nodes[i]);
}
return ret;
};
Yallist.prototype.reverse = function () {
var head = this.head;
var tail = this.tail;
for (var walker = head; walker !== null; walker = walker.prev) {
var p = walker.prev;
walker.prev = walker.next;
walker.next = p;
}
this.head = tail;
this.tail = head;
return this
};
function insert (self, node, value) {
var inserted = node === self.head ?
new Node(value, null, node, self) :
new Node(value, node, node.next, self);
if (inserted.next === null) {
self.tail = inserted;
}
if (inserted.prev === null) {
self.head = inserted;
}
self.length++;
return inserted
}
function push (self, item) {
self.tail = new Node(item, self.tail, null, self);
if (!self.head) {
self.head = self.tail;
}
self.length++;
}
function unshift (self, item) {
self.head = new Node(item, null, self.head, self);
if (!self.tail) {
self.tail = self.head;
}
self.length++;
}
function Node (value, prev, next, list) {
if (!(this instanceof Node)) {
return new Node(value, prev, next, list)
}
this.list = list;
this.value = value;
if (prev) {
prev.next = this;
this.prev = prev;
} else {
this.prev = null;
}
if (next) {
next.prev = this;
this.next = next;
} else {
this.next = null;
}
}
try {
// add if support for Symbol.iterator is present
iterator(Yallist);
} catch (er) {}
// A linked list to keep track of recently-used-ness
const MAX = Symbol('max');
const LENGTH = Symbol('length');
const LENGTH_CALCULATOR = Symbol('lengthCalculator');
const ALLOW_STALE = Symbol('allowStale');
const MAX_AGE = Symbol('maxAge');
const DISPOSE = Symbol('dispose');
const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet');
const LRU_LIST = Symbol('lruList');
const CACHE = Symbol('cache');
const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet');
const naiveLength = () => 1;
// lruList is a yallist where the head is the youngest
// item, and the tail is the oldest. the list contains the Hit
// objects as the entries.
// Each Hit object has a reference to its Yallist.Node. This
// never changes.
//
// cache is a Map (or PseudoMap) that matches the keys to
// the Yallist.Node object.
class LRUCache {
constructor (options) {
if (typeof options === 'number')
options = { max: options };
if (!options)
options = {};
if (options.max && (typeof options.max !== 'number' || options.max < 0))
throw new TypeError('max must be a non-negative number')
// Kind of weird to have a default max of Infinity, but oh well.
const max = this[MAX] = options.max || Infinity;
const lc = options.length || naiveLength;
this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc;
this[ALLOW_STALE] = options.stale || false;
if (options.maxAge && typeof options.maxAge !== 'number')
throw new TypeError('maxAge must be a number')
this[MAX_AGE] = options.maxAge || 0;
this[DISPOSE] = options.dispose;
this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
this.reset();
}
// resize the cache when the max changes.
set max (mL) {
if (typeof mL !== 'number' || mL < 0)
throw new TypeError('max must be a non-negative number')
this[MAX] = mL || Infinity;
trim(this);
}
get max () {
return this[MAX]
}
set allowStale (allowStale) {
this[ALLOW_STALE] = !!allowStale;
}
get allowStale () {
return this[ALLOW_STALE]
}
set maxAge (mA) {
if (typeof mA !== 'number')
throw new TypeError('maxAge must be a non-negative number')
this[MAX_AGE] = mA;
trim(this);
}
get maxAge () {
return this[MAX_AGE]
}
// resize the cache when the lengthCalculator changes.
set lengthCalculator (lC) {
if (typeof lC !== 'function')
lC = naiveLength;
if (lC !== this[LENGTH_CALCULATOR]) {
this[LENGTH_CALCULATOR] = lC;
this[LENGTH] = 0;
this[LRU_LIST].forEach(hit => {
hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
this[LENGTH] += hit.length;
});
}
trim(this);
}
get lengthCalculator () { return this[LENGTH_CALCULATOR] }
get length () { return this[LENGTH] }
get itemCount () { return this[LRU_LIST].length }
rforEach (fn, thisp) {
thisp = thisp || this;
for (let walker = this[LRU_LIST].tail; walker !== null;) {
const prev = walker.prev;
forEachStep(this, fn, walker, thisp);
walker = prev;
}
}
forEach (fn, thisp) {
thisp = thisp || this;
for (let walker = this[LRU_LIST].head; walker !== null;) {
const next = walker.next;
forEachStep(this, fn, walker, thisp);
walker = next;
}
}
keys () {
return this[LRU_LIST].toArray().map(k => k.key)
}
values () {
return this[LRU_LIST].toArray().map(k => k.value)
}
reset () {
if (this[DISPOSE] &&
this[LRU_LIST] &&
this[LRU_LIST].length) {
this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value));
}
this[CACHE] = new Map(); // hash of items by key
this[LRU_LIST] = new yallist(); // list of items in order of use recency
this[LENGTH] = 0; // length of items in the list
}
dump () {
return this[LRU_LIST].map(hit =>
isStale(this, hit) ? false : {
k: hit.key,
v: hit.value,
e: hit.now + (hit.maxAge || 0)
}).toArray().filter(h => h)
}
dumpLru () {
return this[LRU_LIST]
}
set (key, value, maxAge) {
maxAge = maxAge || this[MAX_AGE];
if (maxAge && typeof maxAge !== 'number')
throw new TypeError('maxAge must be a number')
const now = maxAge ? Date.now() : 0;
const len = this[LENGTH_CALCULATOR](value, key);
if (this[CACHE].has(key)) {
if (len > this[MAX]) {
del(this, this[CACHE].get(key));
return false
}
const node = this[CACHE].get(key);
const item = node.value;
// dispose of the old one before overwriting
// split out into 2 ifs for better coverage tracking
if (this[DISPOSE]) {
if (!this[NO_DISPOSE_ON_SET])
this[DISPOSE](key, item.value);
}
item.now = now;
item.maxAge = maxAge;
item.value = value;
this[LENGTH] += len - item.length;
item.length = len;
this.get(key);
trim(this);
return true
}
const hit = new Entry(key, value, len, now, maxAge);
// oversized objects fall out of cache automatically.
if (hit.length > this[MAX]) {
if (this[DISPOSE])
this[DISPOSE](key, value);
return false
}
this[LENGTH] += hit.length;
this[LRU_LIST].unshift(hit);
this[CACHE].set(key, this[LRU_LIST].head);
trim(this);
return true
}
has (key) {
if (!this[CACHE].has(key)) return false
const hit = this[CACHE].get(key).value;
return !isStale(this, hit)
}
get (key) {
return get(this, key, true)
}
peek (key) {
return get(this, key, false)
}
pop () {
const node = this[LRU_LIST].tail;
if (!node)
return null
del(this, node);
return node.value
}
del (key) {
del(this, this[CACHE].get(key));
}
load (arr) {
// reset the cache
this.reset();
const now = Date.now();
// A previous serialized cache has the most recent items first
for (let l = arr.length - 1; l >= 0; l--) {
const hit = arr[l];
const expiresAt = hit.e || 0;
if (expiresAt === 0)
// the item was created without expiration in a non aged cache
this.set(hit.k, hit.v);
else {
const maxAge = expiresAt - now;
// dont add already expired items
if (maxAge > 0) {
this.set(hit.k, hit.v, maxAge);
}
}
}
}
prune () {
this[CACHE].forEach((value, key) => get(this, key, false));
}
}
const get = (self, key, doUse) => {
const node = self[CACHE].get(key);
if (node) {
const hit = node.value;
if (isStale(self, hit)) {
del(self, node);
if (!self[ALLOW_STALE])
return undefined
} else {
if (doUse) {
if (self[UPDATE_AGE_ON_GET])
node.value.now = Date.now();
self[LRU_LIST].unshiftNode(node);
}
}
return hit.value
}
};
const isStale = (self, hit) => {
if (!hit || (!hit.maxAge && !self[MAX_AGE]))
return false
const diff = Date.now() - hit.now;
return hit.maxAge ? diff > hit.maxAge
: self[MAX_AGE] && (diff > self[MAX_AGE])
};
const trim = self => {
if (self[LENGTH] > self[MAX]) {
for (let walker = self[LRU_LIST].tail;
self[LENGTH] > self[MAX] && walker !== null;) {
// We know that we're about to delete this one, and also
// what the next least recently used key will be, so just
// go ahead and set it now.
const prev = walker.prev;
del(self, walker);
walker = prev;
}
}
};
const del = (self, node) => {
if (node) {
const hit = node.value;
if (self[DISPOSE])
self[DISPOSE](hit.key, hit.value);
self[LENGTH] -= hit.length;
self[CACHE].delete(hit.key);
self[LRU_LIST].removeNode(node);
}
};
class Entry {
constructor (key, value, length, now, maxAge) {
this.key = key;
this.value = value;
this.length = length;
this.now = now;
this.maxAge = maxAge || 0;
}
}
const forEachStep = (self, fn, node, thisp) => {
let hit = node.value;
if (isStale(self, hit)) {
del(self, node);
if (!self[ALLOW_STALE])
hit = undefined;
}
if (hit)
fn.call(thisp, hit.value, hit.key, self);
};
var lruCache = LRUCache;
class Range {
constructor(range, options) {
options = parseOptions_1(options);
if (range instanceof Range) {
if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
return range;
} else {
return new Range(range.raw, options);
}
}
if (range instanceof comparator) {
// just put it in the set and return
this.raw = range.value;
this.set = [[range]];
this.format();
return this;
}
this.options = options;
this.loose = !!options.loose;
this.includePrerelease = !!options.includePrerelease; // First, split based on boolean or ||
this.raw = range;
this.set = range.split(/\s*\|\|\s*/) // map the range to a 2d array of comparators
.map(range => this.parseRange(range.trim())) // throw out any comparator lists that are empty
// this generally means that it was not a valid range, which is allowed
// in loose mode, but will still throw if the WHOLE range is invalid.
.filter(c => c.length);
if (!this.set.length) {
throw new TypeError(`Invalid SemVer Range: ${range}`);
} // if we have any that are not the null set, throw out null sets.
if (this.set.length > 1) {
// keep the first one, in case they're all null sets
const first = this.set[0];
this.set = this.set.filter(c => !isNullSet(c[0]));
if (this.set.length === 0) this.set = [first];else if (this.set.length > 1) {
// if we have any that are *, then the range is just *
for (const c of this.set) {
if (c.length === 1 && isAny(c[0])) {
this.set = [c];
break;
}
}
}
}
this.format();
}
format() {
this.range = this.set.map(comps => {
return comps.join(' ').trim();
}).join('||').trim();
return this.range;
}
toString() {
return this.range;
}
parseRange(range) {
range = range.trim(); // memoize range parsing for performance.
// this is a very hot path, and fully deterministic.
const memoOpts = Object.keys(this.options).join(',');
const memoKey = `parseRange:${memoOpts}:${range}`;
const cached = cache.get(memoKey);
if (cached) return cached;
const loose = this.options.loose; // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
const hr = loose ? re$3[t$3.HYPHENRANGELOOSE] : re$3[t$3.HYPHENRANGE];
range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
debug_1('hyphen replace', range); // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
range = range.replace(re$3[t$3.COMPARATORTRIM], comparatorTrimReplace);
debug_1('comparator trim', range, re$3[t$3.COMPARATORTRIM]); // `~ 1.2.3` => `~1.2.3`
range = range.replace(re$3[t$3.TILDETRIM], tildeTrimReplace); // `^ 1.2.3` => `^1.2.3`
range = range.replace(re$3[t$3.CARETTRIM], caretTrimReplace); // normalize spaces
range = range.split(/\s+/).join(' '); // At this point, the range is completely trimmed and
// ready to be split into comparators.
const compRe = loose ? re$3[t$3.COMPARATORLOOSE] : re$3[t$3.COMPARATOR];
const rangeList = range.split(' ').map(comp => parseComparator(comp, this.options)).join(' ').split(/\s+/) // >=0.0.0 is equivalent to *
.map(comp => replaceGTE0(comp, this.options)) // in loose mode, throw out any that are not valid comparators
.filter(this.options.loose ? comp => !!comp.match(compRe) : () => true).map(comp => new comparator(comp, this.options)); // if any comparators are the null set, then replace with JUST null set
// if more than one comparator, remove any * comparators
// also, don't include the same comparator more than once
const l = rangeList.length;
const rangeMap = new Map();
for (const comp of rangeList) {
if (isNullSet(comp)) return [comp];
rangeMap.set(comp.value, comp);
}
if (rangeMap.size > 1 && rangeMap.has('')) rangeMap.delete('');
const result = [...rangeMap.values()];
cache.set(memoKey, result);
return result;
}
intersects(range, options) {
if (!(range instanceof Range)) {
throw new TypeError('a Range is required');
}
return this.set.some(thisComparators => {
return isSatisfiable(thisComparators, options) && range.set.some(rangeComparators => {
return isSatisfiable(rangeComparators, options) && thisComparators.every(thisComparator => {
return rangeComparators.every(rangeComparator => {
return thisComparator.intersects(rangeComparator, options);
});
});
});
});
} // if ANY of the sets match ALL of its comparators, then pass
test(version) {
if (!version) {
return false;
}
if (typeof version === 'string') {
try {
version = new semver(version, this.options);
} catch (er) {
return false;
}
}
for (let i = 0; i < this.set.length; i++) {
if (testSet(this.set[i], version, this.options)) {
return true;
}
}
return false;
}
}
var range = Range;
const cache = new lruCache({
max: 1000
});
const {
re: re$3,
t: t$3,
comparatorTrimReplace,
tildeTrimReplace,
caretTrimReplace
} = re_1;
const isNullSet = c => c.value === '<0.0.0-0';
const isAny = c => c.value === ''; // take a set of comparators and determine whether there
// exists a version which can satisfy it
const isSatisfiable = (comparators, options) => {
let result = true;
const remainingComparators = comparators.slice();
let testComparator = remainingComparators.pop();
while (result && remainingComparators.length) {
result = remainingComparators.every(otherComparator => {
return testComparator.intersects(otherComparator, options);
});
testComparator = remainingComparators.pop();
}
return result;
}; // comprised of xranges, tildes, stars, and gtlt's at this point.
// already replaced the hyphen ranges
// turn into a set of JUST comparators.
const parseComparator = (comp, options) => {
debug_1('comp', comp, options);
comp = replaceCarets(comp, options);
debug_1('caret', comp);
comp = replaceTildes(comp, options);
debug_1('tildes', comp);
comp = replaceXRanges(comp, options);
debug_1('xrange', comp);
comp = replaceStars(comp, options);
debug_1('stars', comp);
return comp;
};
const isX = id => !id || id.toLowerCase() === 'x' || id === '*'; // ~, ~> --> * (any, kinda silly)
// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
const replaceTildes = (comp, options) => comp.trim().split(/\s+/).map(comp => {
return replaceTilde(comp, options);
}).join(' ');
const replaceTilde = (comp, options) => {
const r = options.loose ? re$3[t$3.TILDELOOSE] : re$3[t$3.TILDE];
return comp.replace(r, (_, M, m, p, pr) => {
debug_1('tilde', comp, _, M, m, p, pr);
let ret;
if (isX(M)) {
ret = '';
} else if (isX(m)) {
ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
} else if (isX(p)) {
// ~1.2 == >=1.2.0 <1.3.0-0
ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
} else if (pr) {
debug_1('replaceTilde pr', pr);
ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
} else {
// ~1.2.3 == >=1.2.3 <1.3.0-0
ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
}
debug_1('tilde return', ret);
return ret;
});
}; // ^ --> * (any, kinda silly)
// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
// ^1.2.3 --> >=1.2.3 <2.0.0-0
// ^1.2.0 --> >=1.2.0 <2.0.0-0
const replaceCarets = (comp, options) => comp.trim().split(/\s+/).map(comp => {
return replaceCaret(comp, options);
}).join(' ');
const replaceCaret = (comp, options) => {
debug_1('caret', comp, options);
const r = options.loose ? re$3[t$3.CARETLOOSE] : re$3[t$3.CARET];
const z = options.includePrerelease ? '-0' : '';
return comp.replace(r, (_, M, m, p, pr) => {
debug_1('caret', comp, _, M, m, p, pr);
let ret;
if (isX(M)) {
ret = '';
} else if (isX(m)) {
ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
} else if (isX(p)) {
if (M === '0') {
ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
} else {
ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
}
} else if (pr) {
debug_1('replaceCaret pr', pr);
if (M === '0') {
if (m === '0') {
ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
} else {
ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
}
} else {
ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
}
} else {
debug_1('no pr');
if (M === '0') {
if (m === '0') {
ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
} else {
ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
}
} else {
ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
}
}
debug_1('caret return', ret);
return ret;
});
};
const replaceXRanges = (comp, options) => {
debug_1('replaceXRanges', comp, options);
return comp.split(/\s+/).map(comp => {
return replaceXRange(comp, options);
}).join(' ');
};
const replaceXRange = (comp, options) => {
comp = comp.trim();
const r = options.loose ? re$3[t$3.XRANGELOOSE] : re$3[t$3.XRANGE];
return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
debug_1('xRange', comp, ret, gtlt, M, m, p, pr);
const xM = isX(M);
const xm = xM || isX(m);
const xp = xm || isX(p);
const anyX = xp;
if (gtlt === '=' && anyX) {
gtlt = '';
} // if we're including prereleases in the match, then we need
// to fix this to -0, the lowest possible prerelease value
pr = options.includePrerelease ? '-0' : '';
if (xM) {
if (gtlt === '>' || gtlt === '<') {
// nothing is allowed
ret = '<0.0.0-0';
} else {
// nothing is forbidden
ret = '*';
}
} else if (gtlt && anyX) {
// we know patch is an x, because we have any x at all.
// replace X with 0
if (xm) {
m = 0;
}
p = 0;
if (gtlt === '>') {
// >1 => >=2.0.0
// >1.2 => >=1.3.0
gtlt = '>=';
if (xm) {
M = +M + 1;
m = 0;
p = 0;
} else {
m = +m + 1;
p = 0;
}
} else if (gtlt === '<=') {
// <=0.7.x is actually <0.8.0, since any 0.7.x should
// pass. Similarly, <=7.x is actually <8.0.0, etc.
gtlt = '<';
if (xm) {
M = +M + 1;
} else {
m = +m + 1;
}
}
if (gtlt === '<') pr = '-0';
ret = `${gtlt + M}.${m}.${p}${pr}`;
} else if (xm) {
ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
} else if (xp) {
ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
}
debug_1('xRange return', ret);
return ret;
});
}; // Because * is AND-ed with everything else in the comparator,
// and '' means "any version", just remove the *s entirely.
const replaceStars = (comp, options) => {
debug_1('replaceStars', comp, options); // Looseness is ignored here. star is always as loose as it gets!
return comp.trim().replace(re$3[t$3.STAR], '');
};
const replaceGTE0 = (comp, options) => {
debug_1('replaceGTE0', comp, options);
return comp.trim().replace(re$3[options.includePrerelease ? t$3.GTE0PRE : t$3.GTE0], '');
}; // This function is passed to string.replace(re[t.HYPHENRANGE])
// M, m, patch, prerelease, build
// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
// 1.2 - 3.4 => >=1.2.0 <3.5.0-0
const hyphenReplace = incPr => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) => {
if (isX(fM)) {
from = '';
} else if (isX(fm)) {
from = `>=${fM}.0.0${incPr ? '-0' : ''}`;
} else if (isX(fp)) {
from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`;
} else if (fpr) {
from = `>=${from}`;
} else {
from = `>=${from}${incPr ? '-0' : ''}`;
}
if (isX(tM)) {
to = '';
} else if (isX(tm)) {
to = `<${+tM + 1}.0.0-0`;
} else if (isX(tp)) {
to = `<${tM}.${+tm + 1}.0-0`;
} else if (tpr) {
to = `<=${tM}.${tm}.${tp}-${tpr}`;
} else if (incPr) {
to = `<${tM}.${tm}.${+tp + 1}-0`;
} else {
to = `<=${to}`;
}
return `${from} ${to}`.trim();
};
const testSet = (set, version, options) => {
for (let i = 0; i < set.length; i++) {
if (!set[i].test(version)) {
return false;
}
}
if (version.prerelease.length && !options.includePrerelease) {
// Find the set of versions that are allowed to have prereleases
// For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
// That should allow `1.2.3-pr.2` to pass.
// However, `1.2.4-alpha.notready` should NOT be allowed,
// even though it's within the range set by the comparators.
for (let i = 0; i < set.length; i++) {
debug_1(set[i].semver);
if (set[i].semver === comparator.ANY) {
continue;
}
if (set[i].semver.prerelease.length > 0) {
const allowed = set[i].semver;
if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
return true;
}
}
} // Version has a -pre, but it's not one of the ones we like.
return false;
}
return true;
};
const ANY = Symbol('SemVer ANY'); // hoisted class for cyclic dependency
class Comparator {
static get ANY() {
return ANY;
}
constructor(comp, options) {
options = parseOptions_1(options);
if (comp instanceof Comparator) {
if (comp.loose === !!options.loose) {
return comp;
} else {
comp = comp.value;
}
}
debug_1('comparator', comp, options);
this.options = options;
this.loose = !!options.loose;
this.parse(comp);
if (this.semver === ANY) {
this.value = '';
} else {
this.value = this.operator + this.semver.version;
}
debug_1('comp', this);
}
parse(comp) {
const r = this.options.loose ? re$4[t$4.COMPARATORLOOSE] : re$4[t$4.COMPARATOR];
const m = comp.match(r);
if (!m) {
throw new TypeError(`Invalid comparator: ${comp}`);
}
this.operator = m[1] !== undefined ? m[1] : '';
if (this.operator === '=') {
this.operator = '';
} // if it literally is just '>' or '' then allow anything.
if (!m[2]) {
this.semver = ANY;
} else {
this.semver = new semver(m[2], this.options.loose);
}
}
toString() {
return this.value;
}
test(version) {
debug_1('Comparator.test', version, this.options.loose);
if (this.semver === ANY || version === ANY) {
return true;
}
if (typeof version === 'string') {
try {
version = new semver(version, this.options);
} catch (er) {
return false;
}
}
return cmp_1(version, this.operator, this.semver, this.options);
}
intersects(comp, options) {
if (!(comp instanceof Comparator)) {
throw new TypeError('a Comparator is required');
}
if (!options || typeof options !== 'object') {
options = {
loose: !!options,
includePrerelease: false
};
}
if (this.operator === '') {
if (this.value === '') {
return true;
}
return new range(comp.value, options).test(this.value);
} else if (comp.operator === '') {
if (comp.value === '') {
return true;
}
return new range(this.value, options).test(comp.semver);
}
const sameDirectionIncreasing = (this.operator === '>=' || this.operator === '>') && (comp.operator === '>=' || comp.operator === '>');
const sameDirectionDecreasing = (this.operator === '<=' || this.operator === '<') && (comp.operator === '<=' || comp.operator === '<');
const sameSemVer = this.semver.version === comp.semver.version;
const differentDirectionsInclusive = (this.operator === '>=' || this.operator === '<=') && (comp.operator === '>=' || comp.operator === '<=');
const oppositeDirectionsLessThan = cmp_1(this.semver, '<', comp.semver, options) && (this.operator === '>=' || this.operator === '>') && (comp.operator === '<=' || comp.operator === '<');
const oppositeDirectionsGreaterThan = cmp_1(this.semver, '>', comp.semver, options) && (this.operator === '<=' || this.operator === '<') && (comp.operator === '>=' || comp.operator === '>');
return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
}
}
var comparator = Comparator;
const {
re: re$4,
t: t$4
} = re_1;
const satisfies = (version, range$1, options) => {
try {
range$1 = new range(range$1, options);
} catch (er) {
return false;
}
return range$1.test(version);
};
var satisfies_1 = satisfies;
const toComparators = (range$1, options) => new range(range$1, options).set.map(comp => comp.map(c => c.value).join(' ').trim().split(' '));
var toComparators_1 = toComparators;
const maxSatisfying = (versions, range$1, options) => {
let max = null;
let maxSV = null;
let rangeObj = null;
try {
rangeObj = new range(range$1, options);
} catch (er) {
return null;
}
versions.forEach(v => {
if (rangeObj.test(v)) {
// satisfies(v, range, options)
if (!max || maxSV.compare(v) === -1) {
// compare(max, v, true)
max = v;
maxSV = new semver(max, options);
}
}
});
return max;
};
var maxSatisfying_1 = maxSatisfying;
const minSatisfying = (versions, range$1, options) => {
let min = null;
let minSV = null;
let rangeObj = null;
try {
rangeObj = new range(range$1, options);
} catch (er) {
return null;
}
versions.forEach(v => {
if (rangeObj.test(v)) {
// satisfies(v, range, options)
if (!min || minSV.compare(v) === 1) {
// compare(min, v, true)
min = v;
minSV = new semver(min, options);
}
}
});
return min;
};
var minSatisfying_1 = minSatisfying;
const minVersion = (range$1, loose) => {
range$1 = new range(range$1, loose);
let minver = new semver('0.0.0');
if (range$1.test(minver)) {
return minver;
}
minver = new semver('0.0.0-0');
if (range$1.test(minver)) {
return minver;
}
minver = null;
for (let i = 0; i < range$1.set.length; ++i) {
const comparators = range$1.set[i];
let setMin = null;
comparators.forEach(comparator => {
// Clone to avoid manipulating the comparator's semver object.
const compver = new semver(comparator.semver.version);
switch (comparator.operator) {
case '>':
if (compver.prerelease.length === 0) {
compver.patch++;
} else {
compver.prerelease.push(0);
}
compver.raw = compver.format();
/* fallthrough */
case '':
case '>=':
if (!setMin || gt_1(compver, setMin)) {
setMin = compver;
}
break;
case '<':
case '<=':
/* Ignore maximum versions */
break;
/* istanbul ignore next */
default:
throw new Error(`Unexpected operation: ${comparator.operator}`);
}
});
if (setMin && (!minver || gt_1(minver, setMin))) minver = setMin;
}
if (minver && range$1.test(minver)) {
return minver;
}
return null;
};
var minVersion_1 = minVersion;
const validRange = (range$1, options) => {
try {
// Return '*' instead of '' so that truthiness works.
// This will throw if it's invalid anyway
return new range(range$1, options).range || '*';
} catch (er) {
return null;
}
};
var valid$1 = validRange;
const {
ANY: ANY$1
} = comparator;
const outside = (version, range$1, hilo, options) => {
version = new semver(version, options);
range$1 = new range(range$1, options);
let gtfn, ltefn, ltfn, comp, ecomp;
switch (hilo) {
case '>':
gtfn = gt_1;
ltefn = lte_1;
ltfn = lt_1;
comp = '>';
ecomp = '>=';
break;
case '<':
gtfn = lt_1;
ltefn = gte_1;
ltfn = gt_1;
comp = '<';
ecomp = '<=';
break;
default:
throw new TypeError('Must provide a hilo val of "<" or ">"');
} // If it satisfies the range it is not outside
if (satisfies_1(version, range$1, options)) {
return false;
} // From now on, variable terms are as if we're in "gtr" mode.
// but note that everything is flipped for the "ltr" function.
for (let i = 0; i < range$1.set.length; ++i) {
const comparators = range$1.set[i];
let high = null;
let low = null;
comparators.forEach(comparator$1 => {
if (comparator$1.semver === ANY$1) {
comparator$1 = new comparator('>=0.0.0');
}
high = high || comparator$1;
low = low || comparator$1;
if (gtfn(comparator$1.semver, high.semver, options)) {
high = comparator$1;
} else if (ltfn(comparator$1.semver, low.semver, options)) {
low = comparator$1;
}
}); // If the edge version comparator has a operator then our version
// isn't outside it
if (high.operator === comp || high.operator === ecomp) {
return false;
} // If the lowest version comparator has an operator and our version
// is less than it then it isn't higher than the range
if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
return false;
} else if (low.operator === ecomp && ltfn(version, low.semver)) {
return false;
}
}
return true;
};
var outside_1 = outside;
const gtr = (version, range, options) => outside_1(version, range, '>', options);
var gtr_1 = gtr;
const ltr = (version, range, options) => outside_1(version, range, '<', options);
var ltr_1 = ltr;
const intersects = (r1, r2, options) => {
r1 = new range(r1, options);
r2 = new range(r2, options);
return r1.intersects(r2);
};
var intersects_1 = intersects;
// that includes the same versions that the original range does
// If the original range is shorter than the simplified one, return that.
var simplify = (versions, range, options) => {
const set = [];
let min = null;
let prev = null;
const v = versions.sort((a, b) => compare_1(a, b, options));
for (const version of v) {
const included = satisfies_1(version, range, options);
if (included) {
prev = version;
if (!min) min = version;
} else {
if (prev) {
set.push([min, prev]);
}
prev = null;
min = null;
}
}
if (min) set.push([min, null]);
const ranges = [];
for (const [min, max] of set) {
if (min === max) ranges.push(min);else if (!max && min === v[0]) ranges.push('*');else if (!max) ranges.push(`>=${min}`);else if (min === v[0]) ranges.push(`<=${max}`);else ranges.push(`${min} - ${max}`);
}
const simplified = ranges.join(' || ');
const original = typeof range.raw === 'string' ? range.raw : String(range);
return simplified.length < original.length ? simplified : range;
};
const {
ANY: ANY$2
} = comparator; // Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:
// - Every simple range `r1, r2, ...` is a subset of some `R1, R2, ...`
//
// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:
// - If c is only the ANY comparator
// - If C is only the ANY comparator, return true
// - Else return false
// - Let EQ be the set of = comparators in c
// - If EQ is more than one, return true (null set)
// - Let GT be the highest > or >= comparator in c
// - Let LT be the lowest < or <= comparator in c
// - If GT and LT, and GT.semver > LT.semver, return true (null set)
// - If EQ
// - If GT, and EQ does not satisfy GT, return true (null set)
// - If LT, and EQ does not satisfy LT, return true (null set)
// - If EQ satisfies every C, return true
// - Else return false
// - If GT
// - If GT.semver is lower than any > or >= comp in C, return false
// - If GT is >=, and GT.semver does not satisfy every C, return false
// - If LT
// - If LT.semver is greater than any < or <= comp in C, return false
// - If LT is <=, and LT.semver does not satisfy every C, return false
// - If any C is a = range, and GT or LT are set, return false
// - Else return true
const subset = (sub, dom, options) => {
if (sub === dom) return true;
sub = new range(sub, options);
dom = new range(dom, options);
let sawNonNull = false;
OUTER: for (const simpleSub of sub.set) {
for (const simpleDom of dom.set) {
const isSub = simpleSubset(simpleSub, simpleDom, options);
sawNonNull = sawNonNull || isSub !== null;
if (isSub) continue OUTER;
} // the null set is a subset of everything, but null simple ranges in
// a complex range should be ignored. so if we saw a non-null range,
// then we know this isn't a subset, but if EVERY simple range was null,
// then it is a subset.
if (sawNonNull) return false;
}
return true;
};
const simpleSubset = (sub, dom, options) => {
if (sub === dom) return true;
if (sub.length === 1 && sub[0].semver === ANY$2) return dom.length === 1 && dom[0].semver === ANY$2;
const eqSet = new Set();
let gt, lt;
for (const c of sub) {
if (c.operator === '>' || c.operator === '>=') gt = higherGT(gt, c, options);else if (c.operator === '<' || c.operator === '<=') lt = lowerLT(lt, c, options);else eqSet.add(c.semver);
}
if (eqSet.size > 1) return null;
let gtltComp;
if (gt && lt) {
gtltComp = compare_1(gt.semver, lt.semver, options);
if (gtltComp > 0) return null;else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) return null;
} // will iterate one or zero times
for (const eq of eqSet) {
if (gt && !satisfies_1(eq, String(gt), options)) return null;
if (lt && !satisfies_1(eq, String(lt), options)) return null;
for (const c of dom) {
if (!satisfies_1(eq, String(c), options)) return false;
}
return true;
}
let higher, lower;
let hasDomLT, hasDomGT;
for (const c of dom) {
hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>=';
hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<=';
if (gt) {
if (c.operator === '>' || c.operator === '>=') {
higher = higherGT(gt, c, options);
if (higher === c && higher !== gt) return false;
} else if (gt.operator === '>=' && !satisfies_1(gt.semver, String(c), options)) return false;
}
if (lt) {
if (c.operator === '<' || c.operator === '<=') {
lower = lowerLT(lt, c, options);
if (lower === c && lower !== lt) return false;
} else if (lt.operator === '<=' && !satisfies_1(lt.semver, String(c), options)) return false;
}
if (!c.operator && (lt || gt) && gtltComp !== 0) return false;
} // if there was a < or >, and nothing in the dom, then must be false
// UNLESS it was limited by another range in the other direction.
// Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0
if (gt && hasDomLT && !lt && gtltComp !== 0) return false;
if (lt && hasDomGT && !gt && gtltComp !== 0) return false;
return true;
}; // >=1.2.3 is lower than >1.2.3
const higherGT = (a, b, options) => {
if (!a) return b;
const comp = compare_1(a.semver, b.semver, options);
return comp > 0 ? a : comp < 0 ? b : b.operator === '>' && a.operator === '>=' ? b : a;
}; // <=1.2.3 is higher than <1.2.3
const lowerLT = (a, b, options) => {
if (!a) return b;
const comp = compare_1(a.semver, b.semver, options);
return comp < 0 ? a : comp > 0 ? b : b.operator === '<' && a.operator === '<=' ? b : a;
};
var subset_1 = subset;
var nodeSemver = {
re: re_1.re,
src: re_1.src,
tokens: re_1.t,
SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
SemVer: semver,
compareIdentifiers: identifiers.compareIdentifiers,
rcompareIdentifiers: identifiers.rcompareIdentifiers,
parse: parse_1,
valid: valid_1,
clean: clean_1,
inc: inc_1,
diff: diff_1,
major: major_1,
minor: minor_1,
patch: patch_1,
prerelease: prerelease_1,
compare: compare_1,
rcompare: rcompare_1,
compareLoose: compareLoose_1,
compareBuild: compareBuild_1,
sort: sort_1,
rsort: rsort_1,
gt: gt_1,
lt: lt_1,
eq: eq_1,
neq: neq_1,
gte: gte_1,
lte: lte_1,
cmp: cmp_1,
coerce: coerce_1,
Comparator: comparator,
Range: range,
satisfies: satisfies_1,
toComparators: toComparators_1,
maxSatisfying: maxSatisfying_1,
minSatisfying: minSatisfying_1,
minVersion: minVersion_1,
validRange: valid$1,
outside: outside_1,
gtr: gtr_1,
ltr: ltr_1,
intersects: intersects_1,
simplifyRange: simplify,
subset: subset_1
};
return nodeSemver;
}());
Raw
semver.min.js
!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).SemVer=t()}(this,(function(){"use strict";var e={SEMVER_SPEC_VERSION:"2.0.0",MAX_LENGTH:256,MAX_SAFE_INTEGER:Number.MAX_SAFE_INTEGER||9007199254740991,MAX_SAFE_COMPONENT_LENGTH:16};var t="object"==typeof process&&process.env&&process.env.NODE_DEBUG&&/\bsemver\b/i.test(process.env.NODE_DEBUG)?(...e)=>console.error("SEMVER",...e):()=>{},r=function(e){var t={exports:{}};return e(t,t.exports),t.exports}((function(r,s){const{MAX_SAFE_COMPONENT_LENGTH:n}=e,i=(s=r.exports={}).re=[],o=s.src=[],a=s.t={};let l=0;const h=(e,r,s)=>{const n=l++;t(n,r),a[e]=n,o[n]=r,i[n]=new RegExp(r,s?"g":void 0)};h("NUMERICIDENTIFIER","0|[1-9]\\d*"),h("NUMERICIDENTIFIERLOOSE","[0-9]+"),h("NONNUMERICIDENTIFIER","\\d*[a-zA-Z-][a-zA-Z0-9-]*"),h("MAINVERSION",`(${o[a.NUMERICIDENTIFIER]})\\.(${o[a.NUMERICIDENTIFIER]})\\.(${o[a.NUMERICIDENTIFIER]})`),h("MAINVERSIONLOOSE",`(${o[a.NUMERICIDENTIFIERLOOSE]})\\.(${o[a.NUMERICIDENTIFIERLOOSE]})\\.(${o[a.NUMERICIDENTIFIERLOOSE]})`),h("PRERELEASEIDENTIFIER",`(?:${o[a.NUMERICIDENTIFIER]}|${o[a.NONNUMERICIDENTIFIER]})`),h("PRERELEASEIDENTIFIERLOOSE",`(?:${o[a.NUMERICIDENTIFIERLOOSE]}|${o[a.NONNUMERICIDENTIFIER]})`),h("PRERELEASE",`(?:-(${o[a.PRERELEASEIDENTIFIER]}(?:\\.${o[a.PRERELEASEIDENTIFIER]})*))`),h("PRERELEASELOOSE",`(?:-?(${o[a.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${o[a.PRERELEASEIDENTIFIERLOOSE]})*))`),h("BUILDIDENTIFIER","[0-9A-Za-z-]+"),h("BUILD",`(?:\\+(${o[a.BUILDIDENTIFIER]}(?:\\.${o[a.BUILDIDENTIFIER]})*))`),h("FULLPLAIN",`v?${o[a.MAINVERSION]}${o[a.PRERELEASE]}?${o[a.BUILD]}?`),h("FULL",`^${o[a.FULLPLAIN]}$`),h("LOOSEPLAIN",`[v=\\s]*${o[a.MAINVERSIONLOOSE]}${o[a.PRERELEASELOOSE]}?${o[a.BUILD]}?`),h("LOOSE",`^${o[a.LOOSEPLAIN]}$`),h("GTLT","((?:<|>)?=?)"),h("XRANGEIDENTIFIERLOOSE",`${o[a.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`),h("XRANGEIDENTIFIER",`${o[a.NUMERICIDENTIFIER]}|x|X|\\*`),h("XRANGEPLAIN",`[v=\\s]*(${o[a.XRANGEIDENTIFIER]})(?:\\.(${o[a.XRANGEIDENTIFIER]})(?:\\.(${o[a.XRANGEIDENTIFIER]})(?:${o[a.PRERELEASE]})?${o[a.BUILD]}?)?)?`),h("XRANGEPLAINLOOSE",`[v=\\s]*(${o[a.XRANGEIDENTIFIERLOOSE]})(?:\\.(${o[a.XRANGEIDENTIFIERLOOSE]})(?:\\.(${o[a.XRANGEIDENTIFIERLOOSE]})(?:${o[a.PRERELEASELOOSE]})?${o[a.BUILD]}?)?)?`),h("XRANGE",`^${o[a.GTLT]}\\s*${o[a.XRANGEPLAIN]}$`),h("XRANGELOOSE",`^${o[a.GTLT]}\\s*${o[a.XRANGEPLAINLOOSE]}$`),h("COERCE",`(^|[^\\d])(\\d{1,${n}})(?:\\.(\\d{1,${n}}))?(?:\\.(\\d{1,${n}}))?(?:$|[^\\d])`),h("COERCERTL",o[a.COERCE],!0),h("LONETILDE","(?:~>?)"),h("TILDETRIM",`(\\s*)${o[a.LONETILDE]}\\s+`,!0),s.tildeTrimReplace="$1~",h("TILDE",`^${o[a.LONETILDE]}${o[a.XRANGEPLAIN]}$`),h("TILDELOOSE",`^${o[a.LONETILDE]}${o[a.XRANGEPLAINLOOSE]}$`),h("LONECARET","(?:\\^)"),h("CARETTRIM",`(\\s*)${o[a.LONECARET]}\\s+`,!0),s.caretTrimReplace="$1^",h("CARET",`^${o[a.LONECARET]}${o[a.XRANGEPLAIN]}$`),h("CARETLOOSE",`^${o[a.LONECARET]}${o[a.XRANGEPLAINLOOSE]}$`),h("COMPARATORLOOSE",`^${o[a.GTLT]}\\s*(${o[a.LOOSEPLAIN]})$|^$`),h("COMPARATOR",`^${o[a.GTLT]}\\s*(${o[a.FULLPLAIN]})$|^$`),h("COMPARATORTRIM",`(\\s*)${o[a.GTLT]}\\s*(${o[a.LOOSEPLAIN]}|${o[a.XRANGEPLAIN]})`,!0),s.comparatorTrimReplace="$1$2$3",h("HYPHENRANGE",`^\\s*(${o[a.XRANGEPLAIN]})\\s+-\\s+(${o[a.XRANGEPLAIN]})\\s*$`),h("HYPHENRANGELOOSE",`^\\s*(${o[a.XRANGEPLAINLOOSE]})\\s+-\\s+(${o[a.XRANGEPLAINLOOSE]})\\s*$`),h("STAR","(<|>)?=?\\s*\\*"),h("GTE0","^\\s*>=\\s*0.0.0\\s*$"),h("GTE0PRE","^\\s*>=\\s*0.0.0-0\\s*$")}));const s=["includePrerelease","loose","rtl"];var n=e=>e?"object"!=typeof e?{loose:!0}:s.filter((t=>e[t])).reduce(((e,t)=>(e[t]=!0,e)),{}):{};const i=/^[0-9]+$/,o=(e,t)=>{const r=i.test(e),s=i.test(t);return r&&s&&(e=+e,t=+t),e===t?0:r&&!s?-1:s&&!r?1:e<t?-1:1};var a={compareIdentifiers:o,rcompareIdentifiers:(e,t)=>o(t,e)};const{MAX_LENGTH:l,MAX_SAFE_INTEGER:h}=e,{re:u,t:p}=r,{compareIdentifiers:c}=a;class E{constructor(e,r){if(r=n(r),e instanceof E){if(e.loose===!!r.loose&&e.includePrerelease===!!r.includePrerelease)return e;e=e.version}else if("string"!=typeof e)throw new TypeError(`Invalid Version: ${e}`);if(e.length>l)throw new TypeError(`version is longer than ${l} characters`);t("SemVer",e,r),this.options=r,this.loose=!!r.loose,this.includePrerelease=!!r.includePrerelease;const s=e.trim().match(r.loose?u[p.LOOSE]:u[p.FULL]);if(!s)throw new TypeError(`Invalid Version: ${e}`);if(this.raw=e,this.major=+s[1],this.minor=+s[2],this.patch=+s[3],this.major>h||this.major<0)throw new TypeError("Invalid major version");if(this.minor>h||this.minor<0)throw new TypeError("Invalid minor version");if(this.patch>h||this.patch<0)throw new TypeError("Invalid patch version");s[4]?this.prerelease=s[4].split(".").map((e=>{if(/^[0-9]+$/.test(e)){const t=+e;if(t>=0&&t<h)return t}return e})):this.prerelease=[],this.build=s[5]?s[5].split("."):[],this.format()}format(){return this.version=`${this.major}.${this.minor}.${this.patch}`,this.prerelease.length&&(this.version+=`-${this.prerelease.join(".")}`),this.version}toString(){return this.version}compare(e){if(t("SemVer.compare",this.version,this.options,e),!(e instanceof E)){if("string"==typeof e&&e===this.version)return 0;e=new E(e,this.options)}return e.version===this.version?0:this.compareMain(e)||this.comparePre(e)}compareMain(e){return e instanceof E||(e=new E(e,this.options)),c(this.major,e.major)||c(this.minor,e.minor)||c(this.patch,e.patch)}comparePre(e){if(e instanceof E||(e=new E(e,this.options)),this.prerelease.length&&!e.prerelease.length)return-1;if(!this.prerelease.length&&e.prerelease.length)return 1;if(!this.prerelease.length&&!e.prerelease.length)return 0;let r=0;do{const s=this.prerelease[r],n=e.prerelease[r];if(t("prerelease compare",r,s,n),void 0===s&&void 0===n)return 0;if(void 0===n)return 1;if(void 0===s)return-1;if(s!==n)return c(s,n)}while(++r)}compareBuild(e){e instanceof E||(e=new E(e,this.options));let r=0;do{const s=this.build[r],n=e.build[r];if(t("prerelease compare",r,s,n),void 0===s&&void 0===n)return 0;if(void 0===n)return 1;if(void 0===s)return-1;if(s!==n)return c(s,n)}while(++r)}inc(e,t){switch(e){case"premajor":this.prerelease.length=0,this.patch=0,this.minor=0,this.major++,this.inc("pre",t);break;case"preminor":this.prerelease.length=0,this.patch=0,this.minor++,this.inc("pre",t);break;case"prepatch":this.prerelease.length=0,this.inc("patch",t),this.inc("pre",t);break;case"prerelease":0===this.prerelease.length&&this.inc("patch",t),this.inc("pre",t);break;case"major":0===this.minor&&0===this.patch&&0!==this.prerelease.length||this.major++,this.minor=0,this.patch=0,this.prerelease=[];break;case"minor":0===this.patch&&0!==this.prerelease.length||this.minor++,this.patch=0,this.prerelease=[];break;case"patch":0===this.prerelease.length&&this.patch++,this.prerelease=[];break;case"pre":if(0===this.prerelease.length)this.prerelease=[0];else{let e=this.prerelease.length;for(;--e>=0;)"number"==typeof this.prerelease[e]&&(this.prerelease[e]++,e=-2);-1===e&&this.prerelease.push(0)}t&&(this.prerelease[0]===t?isNaN(this.prerelease[1])&&(this.prerelease=[t,0]):this.prerelease=[t,0]);break;default:throw new Error(`invalid increment argument: ${e}`)}return this.format(),this.raw=this.version,this}}var f=E;const{MAX_LENGTH:v}=e,{re:m,t:$}=r;var R=(e,t)=>{if(t=n(t),e instanceof f)return e;if("string"!=typeof e)return null;if(e.length>v)return null;if(!(t.loose?m[$.LOOSE]:m[$.FULL]).test(e))return null;try{return new f(e,t)}catch(e){return null}};var I=(e,t)=>{const r=R(e,t);return r?r.version:null};var g=(e,t)=>{const r=R(e.trim().replace(/^[=v]+/,""),t);return r?r.version:null};var d=(e,t,r,s)=>{"string"==typeof r&&(s=r,r=void 0);try{return new f(e,r).inc(t,s).version}catch(e){return null}};var N=(e,t,r)=>new f(e,r).compare(new f(t,r));var A=(e,t,r)=>0===N(e,t,r);var O=(e,t)=>{if(A(e,t))return null;{const r=R(e),s=R(t),n=r.prerelease.length||s.prerelease.length,i=n?"pre":"",o=n?"prerelease":"";for(const e in r)if(("major"===e||"minor"===e||"patch"===e)&&r[e]!==s[e])return i+e;return o}};var w=(e,t)=>new f(e,t).major;var L=(e,t)=>new f(e,t).minor;var T=(e,t)=>new f(e,t).patch;var y=(e,t)=>{const r=R(e,t);return r&&r.prerelease.length?r.prerelease:null};var S=(e,t,r)=>N(t,e,r);var x=(e,t)=>N(e,t,!0);var P=(e,t,r)=>{const s=new f(e,r),n=new f(t,r);return s.compare(n)||s.compareBuild(n)};var C=(e,t)=>e.sort(((e,r)=>P(e,r,t)));var b=(e,t)=>e.sort(((e,r)=>P(r,e,t)));var D=(e,t,r)=>N(e,t,r)>0;var M=(e,t,r)=>N(e,t,r)<0;var G=(e,t,r)=>0!==N(e,t,r);var F=(e,t,r)=>N(e,t,r)>=0;var j=(e,t,r)=>N(e,t,r)<=0;var X=(e,t,r,s)=>{switch(t){case"===":return"object"==typeof e&&(e=e.version),"object"==typeof r&&(r=r.version),e===r;case"!==":return"object"==typeof e&&(e=e.version),"object"==typeof r&&(r=r.version),e!==r;case"":case"=":case"==":return A(e,r,s);case"!=":return G(e,r,s);case">":return D(e,r,s);case">=":return F(e,r,s);case"<":return M(e,r,s);case"<=":return j(e,r,s);default:throw new TypeError(`Invalid operator: ${t}`)}};const{re:U,t:k}=r;var _=(e,t)=>{if(e instanceof f)return e;if("number"==typeof e&&(e=String(e)),"string"!=typeof e)return null;let r=null;if((t=t||{}).rtl){let t;for(;(t=U[k.COERCERTL].exec(e))&&(!r||r.index+r[0].length!==e.length);)r&&t.index+t[0].length===r.index+r[0].length||(r=t),U[k.COERCERTL].lastIndex=t.index+t[1].length+t[2].length;U[k.COERCERTL].lastIndex=-1}else r=e.match(U[k.COERCE]);return null===r?null:R(`${r[2]}.${r[3]||"0"}.${r[4]||"0"}`,t)},V=B;function B(e){var t=this;if(t instanceof B||(t=new B),t.tail=null,t.head=null,t.length=0,e&&"function"==typeof e.forEach)e.forEach((function(e){t.push(e)}));else if(arguments.length>0)for(var r=0,s=arguments.length;r<s;r++)t.push(arguments[r]);return t}function H(e,t,r){var s=t===e.head?new q(r,null,t,e):new q(r,t,t.next,e);return null===s.next&&(e.tail=s),null===s.prev&&(e.head=s),e.length++,s}function Y(e,t){e.tail=new q(t,e.tail,null,e),e.head||(e.head=e.tail),e.length++}function z(e,t){e.head=new q(t,null,e.head,e),e.tail||(e.tail=e.head),e.length++}function q(e,t,r,s){if(!(this instanceof q))return new q(e,t,r,s);this.list=s,this.value=e,t?(t.next=this,this.prev=t):this.prev=null,r?(r.prev=this,this.next=r):this.next=null}B.Node=q,B.create=B,B.prototype.removeNode=function(e){if(e.list!==this)throw new Error("removing node which does not belong to this list");var t=e.next,r=e.prev;return t&&(t.prev=r),r&&(r.next=t),e===this.head&&(this.head=t),e===this.tail&&(this.tail=r),e.list.length--,e.next=null,e.prev=null,e.list=null,t},B.prototype.unshiftNode=function(e){if(e!==this.head){e.list&&e.list.removeNode(e);var t=this.head;e.list=this,e.next=t,t&&(t.prev=e),this.head=e,this.tail||(this.tail=e),this.length++}},B.prototype.pushNode=function(e){if(e!==this.tail){e.list&&e.list.removeNode(e);var t=this.tail;e.list=this,e.prev=t,t&&(t.next=e),this.tail=e,this.head||(this.head=e),this.length++}},B.prototype.push=function(){for(var e=0,t=arguments.length;e<t;e++)Y(this,arguments[e]);return this.length},B.prototype.unshift=function(){for(var e=0,t=arguments.length;e<t;e++)z(this,arguments[e]);return this.length},B.prototype.pop=function(){if(this.tail){var e=this.tail.value;return this.tail=this.tail.prev,this.tail?this.tail.next=null:this.head=null,this.length--,e}},B.prototype.shift=function(){if(this.head){var e=this.head.value;return this.head=this.head.next,this.head?this.head.prev=null:this.tail=null,this.length--,e}},B.prototype.forEach=function(e,t){t=t||this;for(var r=this.head,s=0;null!==r;s++)e.call(t,r.value,s,this),r=r.next},B.prototype.forEachReverse=function(e,t){t=t||this;for(var r=this.tail,s=this.length-1;null!==r;s--)e.call(t,r.value,s,this),r=r.prev},B.prototype.get=function(e){for(var t=0,r=this.head;null!==r&&t<e;t++)r=r.next;if(t===e&&null!==r)return r.value},B.prototype.getReverse=function(e){for(var t=0,r=this.tail;null!==r&&t<e;t++)r=r.prev;if(t===e&&null!==r)return r.value},B.prototype.map=function(e,t){t=t||this;for(var r=new B,s=this.head;null!==s;)r.push(e.call(t,s.value,this)),s=s.next;return r},B.prototype.mapReverse=function(e,t){t=t||this;for(var r=new B,s=this.tail;null!==s;)r.push(e.call(t,s.value,this)),s=s.prev;return r},B.prototype.reduce=function(e,t){var r,s=this.head;if(arguments.length>1)r=t;else{if(!this.head)throw new TypeError("Reduce of empty list with no initial value");s=this.head.next,r=this.head.value}for(var n=0;null!==s;n++)r=e(r,s.value,n),s=s.next;return r},B.prototype.reduceReverse=function(e,t){var r,s=this.tail;if(arguments.length>1)r=t;else{if(!this.tail)throw new TypeError("Reduce of empty list with no initial value");s=this.tail.prev,r=this.tail.value}for(var n=this.length-1;null!==s;n--)r=e(r,s.value,n),s=s.prev;return r},B.prototype.toArray=function(){for(var e=new Array(this.length),t=0,r=this.head;null!==r;t++)e[t]=r.value,r=r.next;return e},B.prototype.toArrayReverse=function(){for(var e=new Array(this.length),t=0,r=this.tail;null!==r;t++)e[t]=r.value,r=r.prev;return e},B.prototype.slice=function(e,t){(t=t||this.length)<0&&(t+=this.length),(e=e||0)<0&&(e+=this.length);var r=new B;if(t<e||t<0)return r;e<0&&(e=0),t>this.length&&(t=this.length);for(var s=0,n=this.head;null!==n&&s<e;s++)n=n.next;for(;null!==n&&s<t;s++,n=n.next)r.push(n.value);return r},B.prototype.sliceReverse=function(e,t){(t=t||this.length)<0&&(t+=this.length),(e=e||0)<0&&(e+=this.length);var r=new B;if(t<e||t<0)return r;e<0&&(e=0),t>this.length&&(t=this.length);for(var s=this.length,n=this.tail;null!==n&&s>t;s--)n=n.prev;for(;null!==n&&s>e;s--,n=n.prev)r.push(n.value);return r},B.prototype.splice=function(e,t,...r){e>this.length&&(e=this.length-1),e<0&&(e=this.length+e);for(var s=0,n=this.head;null!==n&&s<e;s++)n=n.next;var i=[];for(s=0;n&&s<t;s++)i.push(n.value),n=this.removeNode(n);null===n&&(n=this.tail),n!==this.head&&n!==this.tail&&(n=n.prev);for(s=0;s<r.length;s++)n=H(this,n,r[s]);return i},B.prototype.reverse=function(){for(var e=this.head,t=this.tail,r=e;null!==r;r=r.prev){var s=r.prev;r.prev=r.next,r.next=s}return this.head=t,this.tail=e,this};try{!function(e){e.prototype[Symbol.iterator]=function*(){for(let e=this.head;e;e=e.next)yield e.value}}(B)}catch(e){}const Z=Symbol("max"),J=Symbol("length"),K=Symbol("lengthCalculator"),Q=Symbol("allowStale"),W=Symbol("maxAge"),ee=Symbol("dispose"),te=Symbol("noDisposeOnSet"),re=Symbol("lruList"),se=Symbol("cache"),ne=Symbol("updateAgeOnGet"),ie=()=>1;const oe=(e,t,r)=>{const s=e[se].get(t);if(s){const t=s.value;if(ae(e,t)){if(he(e,s),!e[Q])return}else r&&(e[ne]&&(s.value.now=Date.now()),e[re].unshiftNode(s));return t.value}},ae=(e,t)=>{if(!t||!t.maxAge&&!e[W])return!1;const r=Date.now()-t.now;return t.maxAge?r>t.maxAge:e[W]&&r>e[W]},le=e=>{if(e[J]>e[Z])for(let t=e[re].tail;e[J]>e[Z]&&null!==t;){const r=t.prev;he(e,t),t=r}},he=(e,t)=>{if(t){const r=t.value;e[ee]&&e[ee](r.key,r.value),e[J]-=r.length,e[se].delete(r.key),e[re].removeNode(t)}};class ue{constructor(e,t,r,s,n){this.key=e,this.value=t,this.length=r,this.now=s,this.maxAge=n||0}}const pe=(e,t,r,s)=>{let n=r.value;ae(e,n)&&(he(e,r),e[Q]||(n=void 0)),n&&t.call(s,n.value,n.key,e)};var ce=class{constructor(e){if("number"==typeof e&&(e={max:e}),e||(e={}),e.max&&("number"!=typeof e.max||e.max<0))throw new TypeError("max must be a non-negative number");this[Z]=e.max||1/0;const t=e.length||ie;if(this[K]="function"!=typeof t?ie:t,this[Q]=e.stale||!1,e.maxAge&&"number"!=typeof e.maxAge)throw new TypeError("maxAge must be a number");this[W]=e.maxAge||0,this[ee]=e.dispose,this[te]=e.noDisposeOnSet||!1,this[ne]=e.updateAgeOnGet||!1,this.reset()}set max(e){if("number"!=typeof e||e<0)throw new TypeError("max must be a non-negative number");this[Z]=e||1/0,le(this)}get max(){return this[Z]}set allowStale(e){this[Q]=!!e}get allowStale(){return this[Q]}set maxAge(e){if("number"!=typeof e)throw new TypeError("maxAge must be a non-negative number");this[W]=e,le(this)}get maxAge(){return this[W]}set lengthCalculator(e){"function"!=typeof e&&(e=ie),e!==this[K]&&(this[K]=e,this[J]=0,this[re].forEach((e=>{e.length=this[K](e.value,e.key),this[J]+=e.length}))),le(this)}get lengthCalculator(){return this[K]}get length(){return this[J]}get itemCount(){return this[re].length}rforEach(e,t){t=t||this;for(let r=this[re].tail;null!==r;){const s=r.prev;pe(this,e,r,t),r=s}}forEach(e,t){t=t||this;for(let r=this[re].head;null!==r;){const s=r.next;pe(this,e,r,t),r=s}}keys(){return this[re].toArray().map((e=>e.key))}values(){return this[re].toArray().map((e=>e.value))}reset(){this[ee]&&this[re]&&this[re].length&&this[re].forEach((e=>this[ee](e.key,e.value))),this[se]=new Map,this[re]=new V,this[J]=0}dump(){return this[re].map((e=>!ae(this,e)&&{k:e.key,v:e.value,e:e.now+(e.maxAge||0)})).toArray().filter((e=>e))}dumpLru(){return this[re]}set(e,t,r){if((r=r||this[W])&&"number"!=typeof r)throw new TypeError("maxAge must be a number");const s=r?Date.now():0,n=this[K](t,e);if(this[se].has(e)){if(n>this[Z])return he(this,this[se].get(e)),!1;const i=this[se].get(e).value;return this[ee]&&(this[te]||this[ee](e,i.value)),i.now=s,i.maxAge=r,i.value=t,this[J]+=n-i.length,i.length=n,this.get(e),le(this),!0}const i=new ue(e,t,n,s,r);return i.length>this[Z]?(this[ee]&&this[ee](e,t),!1):(this[J]+=i.length,this[re].unshift(i),this[se].set(e,this[re].head),le(this),!0)}has(e){if(!this[se].has(e))return!1;const t=this[se].get(e).value;return!ae(this,t)}get(e){return oe(this,e,!0)}peek(e){return oe(this,e,!1)}pop(){const e=this[re].tail;return e?(he(this,e),e.value):null}del(e){he(this,this[se].get(e))}load(e){this.reset();const t=Date.now();for(let r=e.length-1;r>=0;r--){const s=e[r],n=s.e||0;if(0===n)this.set(s.k,s.v);else{const e=n-t;e>0&&this.set(s.k,s.v,e)}}}prune(){this[se].forEach(((e,t)=>oe(this,t,!1)))}};class Ee{constructor(e,t){if(t=n(t),e instanceof Ee)return e.loose===!!t.loose&&e.includePrerelease===!!t.includePrerelease?e:new Ee(e.raw,t);if(e instanceof je)return this.raw=e.value,this.set=[[e]],this.format(),this;if(this.options=t,this.loose=!!t.loose,this.includePrerelease=!!t.includePrerelease,this.raw=e,this.set=e.split(/\s*\|\|\s*/).map((e=>this.parseRange(e.trim()))).filter((e=>e.length)),!this.set.length)throw new TypeError(`Invalid SemVer Range: ${e}`);if(this.set.length>1){const e=this.set[0];if(this.set=this.set.filter((e=>!de(e[0]))),0===this.set.length)this.set=[e];else if(this.set.length>1)for(const e of this.set)if(1===e.length&&Ne(e[0])){this.set=[e];break}}this.format()}format(){return this.range=this.set.map((e=>e.join(" ").trim())).join("||").trim(),this.range}toString(){return this.range}parseRange(e){e=e.trim();const r=`parseRange:${Object.keys(this.options).join(",")}:${e}`,s=ve.get(r);if(s)return s;const n=this.options.loose,i=n?me[$e.HYPHENRANGELOOSE]:me[$e.HYPHENRANGE];e=e.replace(i,De(this.options.includePrerelease)),t("hyphen replace",e),e=e.replace(me[$e.COMPARATORTRIM],Re),t("comparator trim",e,me[$e.COMPARATORTRIM]),e=(e=(e=e.replace(me[$e.TILDETRIM],Ie)).replace(me[$e.CARETTRIM],ge)).split(/\s+/).join(" ");const o=n?me[$e.COMPARATORLOOSE]:me[$e.COMPARATOR],a=e.split(" ").map((e=>Oe(e,this.options))).join(" ").split(/\s+/).map((e=>be(e,this.options))).filter(this.options.loose?e=>!!e.match(o):()=>!0).map((e=>new je(e,this.options))),l=(a.length,new Map);for(const e of a){if(de(e))return[e];l.set(e.value,e)}l.size>1&&l.has("")&&l.delete("");const h=[...l.values()];return ve.set(r,h),h}intersects(e,t){if(!(e instanceof Ee))throw new TypeError("a Range is required");return this.set.some((r=>Ae(r,t)&&e.set.some((e=>Ae(e,t)&&r.every((r=>e.every((e=>r.intersects(e,t)))))))))}test(e){if(!e)return!1;if("string"==typeof e)try{e=new f(e,this.options)}catch(e){return!1}for(let t=0;t<this.set.length;t++)if(Me(this.set[t],e,this.options))return!0;return!1}}var fe=Ee;const ve=new ce({max:1e3}),{re:me,t:$e,comparatorTrimReplace:Re,tildeTrimReplace:Ie,caretTrimReplace:ge}=r,de=e=>"<0.0.0-0"===e.value,Ne=e=>""===e.value,Ae=(e,t)=>{let r=!0;const s=e.slice();let n=s.pop();for(;r&&s.length;)r=s.every((e=>n.intersects(e,t))),n=s.pop();return r},Oe=(e,r)=>(t("comp",e,r),e=ye(e,r),t("caret",e),e=Le(e,r),t("tildes",e),e=xe(e,r),t("xrange",e),e=Ce(e,r),t("stars",e),e),we=e=>!e||"x"===e.toLowerCase()||"*"===e,Le=(e,t)=>e.trim().split(/\s+/).map((e=>Te(e,t))).join(" "),Te=(e,r)=>{const s=r.loose?me[$e.TILDELOOSE]:me[$e.TILDE];return e.replace(s,((r,s,n,i,o)=>{let a;return t("tilde",e,r,s,n,i,o),we(s)?a="":we(n)?a=`>=${s}.0.0 <${+s+1}.0.0-0`:we(i)?a=`>=${s}.${n}.0 <${s}.${+n+1}.0-0`:o?(t("replaceTilde pr",o),a=`>=${s}.${n}.${i}-${o} <${s}.${+n+1}.0-0`):a=`>=${s}.${n}.${i} <${s}.${+n+1}.0-0`,t("tilde return",a),a}))},ye=(e,t)=>e.trim().split(/\s+/).map((e=>Se(e,t))).join(" "),Se=(e,r)=>{t("caret",e,r);const s=r.loose?me[$e.CARETLOOSE]:me[$e.CARET],n=r.includePrerelease?"-0":"";return e.replace(s,((r,s,i,o,a)=>{let l;return t("caret",e,r,s,i,o,a),we(s)?l="":we(i)?l=`>=${s}.0.0${n} <${+s+1}.0.0-0`:we(o)?l="0"===s?`>=${s}.${i}.0${n} <${s}.${+i+1}.0-0`:`>=${s}.${i}.0${n} <${+s+1}.0.0-0`:a?(t("replaceCaret pr",a),l="0"===s?"0"===i?`>=${s}.${i}.${o}-${a} <${s}.${i}.${+o+1}-0`:`>=${s}.${i}.${o}-${a} <${s}.${+i+1}.0-0`:`>=${s}.${i}.${o}-${a} <${+s+1}.0.0-0`):(t("no pr"),l="0"===s?"0"===i?`>=${s}.${i}.${o}${n} <${s}.${i}.${+o+1}-0`:`>=${s}.${i}.${o}${n} <${s}.${+i+1}.0-0`:`>=${s}.${i}.${o} <${+s+1}.0.0-0`),t("caret return",l),l}))},xe=(e,r)=>(t("replaceXRanges",e,r),e.split(/\s+/).map((e=>Pe(e,r))).join(" ")),Pe=(e,r)=>{e=e.trim();const s=r.loose?me[$e.XRANGELOOSE]:me[$e.XRANGE];return e.replace(s,((s,n,i,o,a,l)=>{t("xRange",e,s,n,i,o,a,l);const h=we(i),u=h||we(o),p=u||we(a),c=p;return"="===n&&c&&(n=""),l=r.includePrerelease?"-0":"",h?s=">"===n||"<"===n?"<0.0.0-0":"*":n&&c?(u&&(o=0),a=0,">"===n?(n=">=",u?(i=+i+1,o=0,a=0):(o=+o+1,a=0)):"<="===n&&(n="<",u?i=+i+1:o=+o+1),"<"===n&&(l="-0"),s=`${n+i}.${o}.${a}${l}`):u?s=`>=${i}.0.0${l} <${+i+1}.0.0-0`:p&&(s=`>=${i}.${o}.0${l} <${i}.${+o+1}.0-0`),t("xRange return",s),s}))},Ce=(e,r)=>(t("replaceStars",e,r),e.trim().replace(me[$e.STAR],"")),be=(e,r)=>(t("replaceGTE0",e,r),e.trim().replace(me[r.includePrerelease?$e.GTE0PRE:$e.GTE0],"")),De=e=>(t,r,s,n,i,o,a,l,h,u,p,c,E)=>`${r=we(s)?"":we(n)?`>=${s}.0.0${e?"-0":""}`:we(i)?`>=${s}.${n}.0${e?"-0":""}`:o?`>=${r}`:`>=${r}${e?"-0":""}`} ${l=we(h)?"":we(u)?`<${+h+1}.0.0-0`:we(p)?`<${h}.${+u+1}.0-0`:c?`<=${h}.${u}.${p}-${c}`:e?`<${h}.${u}.${+p+1}-0`:`<=${l}`}`.trim(),Me=(e,r,s)=>{for(let t=0;t<e.length;t++)if(!e[t].test(r))return!1;if(r.prerelease.length&&!s.includePrerelease){for(let s=0;s<e.length;s++)if(t(e[s].semver),e[s].semver!==je.ANY&&e[s].semver.prerelease.length>0){const t=e[s].semver;if(t.major===r.major&&t.minor===r.minor&&t.patch===r.patch)return!0}return!1}return!0},Ge=Symbol("SemVer ANY");class Fe{static get ANY(){return Ge}constructor(e,r){if(r=n(r),e instanceof Fe){if(e.loose===!!r.loose)return e;e=e.value}t("comparator",e,r),this.options=r,this.loose=!!r.loose,this.parse(e),this.semver===Ge?this.value="":this.value=this.operator+this.semver.version,t("comp",this)}parse(e){const t=this.options.loose?Xe[Ue.COMPARATORLOOSE]:Xe[Ue.COMPARATOR],r=e.match(t);if(!r)throw new TypeError(`Invalid comparator: ${e}`);this.operator=void 0!==r[1]?r[1]:"","="===this.operator&&(this.operator=""),r[2]?this.semver=new f(r[2],this.options.loose):this.semver=Ge}toString(){return this.value}test(e){if(t("Comparator.test",e,this.options.loose),this.semver===Ge||e===Ge)return!0;if("string"==typeof e)try{e=new f(e,this.options)}catch(e){return!1}return X(e,this.operator,this.semver,this.options)}intersects(e,t){if(!(e instanceof Fe))throw new TypeError("a Comparator is required");if(t&&"object"==typeof t||(t={loose:!!t,includePrerelease:!1}),""===this.operator)return""===this.value||new fe(e.value,t).test(this.value);if(""===e.operator)return""===e.value||new fe(this.value,t).test(e.semver);const r=!(">="!==this.operator&&">"!==this.operator||">="!==e.operator&&">"!==e.operator),s=!("<="!==this.operator&&"<"!==this.operator||"<="!==e.operator&&"<"!==e.operator),n=this.semver.version===e.semver.version,i=!(">="!==this.operator&&"<="!==this.operator||">="!==e.operator&&"<="!==e.operator),o=X(this.semver,"<",e.semver,t)&&(">="===this.operator||">"===this.operator)&&("<="===e.operator||"<"===e.operator),a=X(this.semver,">",e.semver,t)&&("<="===this.operator||"<"===this.operator)&&(">="===e.operator||">"===e.operator);return r||s||n&&i||o||a}}var je=Fe;const{re:Xe,t:Ue}=r;var ke=(e,t,r)=>{try{t=new fe(t,r)}catch(e){return!1}return t.test(e)};var _e=(e,t)=>new fe(e,t).set.map((e=>e.map((e=>e.value)).join(" ").trim().split(" ")));var Ve=(e,t,r)=>{let s=null,n=null,i=null;try{i=new fe(t,r)}catch(e){return null}return e.forEach((e=>{i.test(e)&&(s&&-1!==n.compare(e)||(s=e,n=new f(s,r)))})),s};var Be=(e,t,r)=>{let s=null,n=null,i=null;try{i=new fe(t,r)}catch(e){return null}return e.forEach((e=>{i.test(e)&&(s&&1!==n.compare(e)||(s=e,n=new f(s,r)))})),s};var He=(e,t)=>{e=new fe(e,t);let r=new f("0.0.0");if(e.test(r))return r;if(r=new f("0.0.0-0"),e.test(r))return r;r=null;for(let t=0;t<e.set.length;++t){const s=e.set[t];let n=null;s.forEach((e=>{const t=new f(e.semver.version);switch(e.operator){case">":0===t.prerelease.length?t.patch++:t.prerelease.push(0),t.raw=t.format();case"":case">=":n&&!D(t,n)||(n=t);break;case"<":case"<=":break;default:throw new Error(`Unexpected operation: ${e.operator}`)}})),!n||r&&!D(r,n)||(r=n)}return r&&e.test(r)?r:null};var Ye=(e,t)=>{try{return new fe(e,t).range||"*"}catch(e){return null}};const{ANY:ze}=je;var qe=(e,t,r,s)=>{let n,i,o,a,l;switch(e=new f(e,s),t=new fe(t,s),r){case">":n=D,i=j,o=M,a=">",l=">=";break;case"<":n=M,i=F,o=D,a="<",l="<=";break;default:throw new TypeError('Must provide a hilo val of "<" or ">"')}if(ke(e,t,s))return!1;for(let r=0;r<t.set.length;++r){const h=t.set[r];let u=null,p=null;if(h.forEach((e=>{e.semver===ze&&(e=new je(">=0.0.0")),u=u||e,p=p||e,n(e.semver,u.semver,s)?u=e:o(e.semver,p.semver,s)&&(p=e)})),u.operator===a||u.operator===l)return!1;if((!p.operator||p.operator===a)&&i(e,p.semver))return!1;if(p.operator===l&&o(e,p.semver))return!1}return!0};var Ze=(e,t,r)=>qe(e,t,">",r);var Je=(e,t,r)=>qe(e,t,"<",r);var Ke=(e,t,r)=>(e=new fe(e,r),t=new fe(t,r),e.intersects(t));const{ANY:Qe}=je,We=(e,t,r)=>{if(e===t)return!0;if(1===e.length&&e[0].semver===Qe)return 1===t.length&&t[0].semver===Qe;const s=new Set;let n,i,o,a,l,h,u;for(const t of e)">"===t.operator||">="===t.operator?n=et(n,t,r):"<"===t.operator||"<="===t.operator?i=tt(i,t,r):s.add(t.semver);if(s.size>1)return null;if(n&&i){if(o=N(n.semver,i.semver,r),o>0)return null;if(0===o&&(">="!==n.operator||"<="!==i.operator))return null}for(const e of s){if(n&&!ke(e,String(n),r))return null;if(i&&!ke(e,String(i),r))return null;for(const s of t)if(!ke(e,String(s),r))return!1;return!0}for(const e of t){if(u=u||">"===e.operator||">="===e.operator,h=h||"<"===e.operator||"<="===e.operator,n)if(">"===e.operator||">="===e.operator){if(a=et(n,e,r),a===e&&a!==n)return!1}else if(">="===n.operator&&!ke(n.semver,String(e),r))return!1;if(i)if("<"===e.operator||"<="===e.operator){if(l=tt(i,e,r),l===e&&l!==i)return!1}else if("<="===i.operator&&!ke(i.semver,String(e),r))return!1;if(!e.operator&&(i||n)&&0!==o)return!1}return!(n&&h&&!i&&0!==o)&&!(i&&u&&!n&&0!==o)},et=(e,t,r)=>{if(!e)return t;const s=N(e.semver,t.semver,r);return s>0?e:s<0||">"===t.operator&&">="===e.operator?t:e},tt=(e,t,r)=>{if(!e)return t;const s=N(e.semver,t.semver,r);return s<0?e:s>0||"<"===t.operator&&"<="===e.operator?t:e};var rt=(e,t,r)=>{if(e===t)return!0;e=new fe(e,r),t=new fe(t,r);let s=!1;e:for(const n of e.set){for(const e of t.set){const t=We(n,e,r);if(s=s||null!==t,t)continue e}if(s)return!1}return!0};return{re:r.re,src:r.src,tokens:r.t,SEMVER_SPEC_VERSION:e.SEMVER_SPEC_VERSION,SemVer:f,compareIdentifiers:a.compareIdentifiers,rcompareIdentifiers:a.rcompareIdentifiers,parse:R,valid:I,clean:g,inc:d,diff:O,major:w,minor:L,patch:T,prerelease:y,compare:N,rcompare:S,compareLoose:x,compareBuild:P,sort:C,rsort:b,gt:D,lt:M,eq:A,neq:G,gte:F,lte:j,cmp:X,coerce:_,Comparator:je,Range:fe,satisfies:ke,toComparators:_e,maxSatisfying:Ve,minSatisfying:Be,minVersion:He,validRange:Ye,outside:qe,gtr:Ze,ltr:Je,intersects:Ke,simplifyRange:(e,t,r)=>{const s=[];let n=null,i=null;const o=e.sort(((e,t)=>N(e,t,r)));for(const e of o){ke(e,t,r)?(i=e,n||(n=e)):(i&&s.push([n,i]),i=null,n=null)}n&&s.push([n,null]);const a=[];for(const[e,t]of s)e===t?a.push(e):t||e!==o[0]?t?e===o[0]?a.push(`<=${t}`):a.push(`${e} - ${t}`):a.push(`>=${e}`):a.push("*");const l=a.join(" || "),h="string"==typeof t.raw?t.raw:String(t);return l.length<h.length?l:t},subset:rt}}));
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment