@modern-js/utils
Version:
A Progressive React Framework for modern web development.
1,183 lines • 73.6 kB
JavaScript
(()=>{
var e = {
844: (e, t, r)=>{
"use strict";
const s = r(605);
const n = Symbol("max");
const i = Symbol("length");
const o = Symbol("lengthCalculator");
const l = Symbol("allowStale");
const a = Symbol("maxAge");
const h = Symbol("dispose");
const c = Symbol("noDisposeOnSet");
const u = Symbol("lruList");
const f = Symbol("cache");
const p = Symbol("updateAgeOnGet");
const naiveLength = ()=>1;
class LRUCache {
constructor(e){
if ("number" == typeof e) e = {
max: e
};
if (!e) e = {};
if (e.max && ("number" != typeof e.max || e.max < 0)) throw new TypeError("max must be a non-negative number");
this[n] = e.max || 1 / 0;
const r = e.length || naiveLength;
this[o] = "function" != typeof r ? naiveLength : r;
this[l] = e.stale || false;
if (e.maxAge && "number" != typeof e.maxAge) throw new TypeError("maxAge must be a number");
this[a] = e.maxAge || 0;
this[h] = e.dispose;
this[c] = e.noDisposeOnSet || false;
this[p] = e.updateAgeOnGet || false;
this.reset();
}
set max(e) {
if ("number" != typeof e || e < 0) throw new TypeError("max must be a non-negative number");
this[n] = e || 1 / 0;
trim(this);
}
get max() {
return this[n];
}
set allowStale(e) {
this[l] = !!e;
}
get allowStale() {
return this[l];
}
set maxAge(e) {
if ("number" != typeof e) throw new TypeError("maxAge must be a non-negative number");
this[a] = e;
trim(this);
}
get maxAge() {
return this[a];
}
set lengthCalculator(e) {
if ("function" != typeof e) e = naiveLength;
if (e !== this[o]) {
this[o] = e;
this[i] = 0;
this[u].forEach((e)=>{
e.length = this[o](e.value, e.key);
this[i] += e.length;
});
}
trim(this);
}
get lengthCalculator() {
return this[o];
}
get length() {
return this[i];
}
get itemCount() {
return this[u].length;
}
rforEach(e, t) {
t = t || this;
for(let r = this[u].tail; null !== r;){
const s = r.prev;
forEachStep(this, e, r, t);
r = s;
}
}
forEach(e, t) {
t = t || this;
for(let r = this[u].head; null !== r;){
const s = r.next;
forEachStep(this, e, r, t);
r = s;
}
}
keys() {
return this[u].toArray().map((e)=>e.key);
}
values() {
return this[u].toArray().map((e)=>e.value);
}
reset() {
if (this[h] && this[u] && this[u].length) this[u].forEach((e)=>this[h](e.key, e.value));
this[f] = new Map;
this[u] = new s;
this[i] = 0;
}
dump() {
return this[u].map((e)=>isStale(this, e) ? false : {
k: e.key,
v: e.value,
e: e.now + (e.maxAge || 0)
}).toArray().filter((e)=>e);
}
dumpLru() {
return this[u];
}
set(e, t, r) {
r = r || this[a];
if (r && "number" != typeof r) throw new TypeError("maxAge must be a number");
const s = r ? Date.now() : 0;
const l = this[o](t, e);
if (this[f].has(e)) {
if (l > this[n]) {
del(this, this[f].get(e));
return false;
}
const o = this[f].get(e);
const a = o.value;
if (this[h]) {
if (!this[c]) this[h](e, a.value);
}
a.now = s;
a.maxAge = r;
a.value = t;
this[i] += l - a.length;
a.length = l;
this.get(e);
trim(this);
return true;
}
const p = new Entry(e, t, l, s, r);
if (p.length > this[n]) {
if (this[h]) this[h](e, t);
return false;
}
this[i] += p.length;
this[u].unshift(p);
this[f].set(e, this[u].head);
trim(this);
return true;
}
has(e) {
if (!this[f].has(e)) return false;
const t = this[f].get(e).value;
return !isStale(this, t);
}
get(e) {
return get(this, e, true);
}
peek(e) {
return get(this, e, false);
}
pop() {
const e = this[u].tail;
if (!e) return null;
del(this, e);
return e.value;
}
del(e) {
del(this, this[f].get(e));
}
load(e) {
this.reset();
const t = Date.now();
for(let r = e.length - 1; r >= 0; r--){
const s = e[r];
const n = s.e || 0;
if (0 === n) this.set(s.k, s.v);
else {
const e = n - t;
if (e > 0) this.set(s.k, s.v, e);
}
}
}
prune() {
this[f].forEach((e, t)=>get(this, t, false));
}
}
const get = (e, t, r)=>{
const s = e[f].get(t);
if (s) {
const t = s.value;
if (isStale(e, t)) {
del(e, s);
if (!e[l]) return;
} else if (r) {
if (e[p]) s.value.now = Date.now();
e[u].unshiftNode(s);
}
return t.value;
}
};
const isStale = (e, t)=>{
if (!t || !t.maxAge && !e[a]) return false;
const r = Date.now() - t.now;
return t.maxAge ? r > t.maxAge : e[a] && r > e[a];
};
const trim = (e)=>{
if (e[i] > e[n]) for(let t = e[u].tail; e[i] > e[n] && null !== t;){
const r = t.prev;
del(e, t);
t = r;
}
};
const del = (e, t)=>{
if (t) {
const r = t.value;
if (e[h]) e[h](r.key, r.value);
e[i] -= r.length;
e[f].delete(r.key);
e[u].removeNode(t);
}
};
class Entry {
constructor(e, t, r, s, n){
this.key = e;
this.value = t;
this.length = r;
this.now = s;
this.maxAge = n || 0;
}
}
const forEachStep = (e, t, r, s)=>{
let n = r.value;
if (isStale(e, n)) {
del(e, r);
if (!e[l]) n = void 0;
}
if (n) t.call(s, n.value, n.key, e);
};
e.exports = LRUCache;
},
584: (e, t, r)=>{
const s = Symbol("SemVer ANY");
class Comparator {
static get ANY() {
return s;
}
constructor(e, t){
t = n(t);
if (e instanceof Comparator) if (!!t.loose === e.loose) return e;
else e = e.value;
e = e.trim().split(/\s+/).join(" ");
a("comparator", e, t);
this.options = t;
this.loose = !!t.loose;
this.parse(e);
if (this.semver === s) this.value = "";
else this.value = this.operator + this.semver.version;
a("comp", this);
}
parse(e) {
const t = this.options.loose ? i[o.COMPARATORLOOSE] : i[o.COMPARATOR];
const r = e.match(t);
if (!r) throw new TypeError(`Invalid comparator: ${e}`);
this.operator = void 0 !== r[1] ? r[1] : "";
if ("=" === this.operator) this.operator = "";
if (r[2]) this.semver = new h(r[2], this.options.loose);
else this.semver = s;
}
toString() {
return this.value;
}
test(e) {
a("Comparator.test", e, this.options.loose);
if (this.semver === s || e === s) return true;
if ("string" == typeof e) try {
e = new h(e, this.options);
} catch (e) {
return false;
}
return l(e, this.operator, this.semver, this.options);
}
intersects(e, t) {
if (!(e instanceof Comparator)) throw new TypeError("a Comparator is required");
if ("" === this.operator) {
if ("" === this.value) return true;
return new c(e.value, t).test(this.value);
}
if ("" === e.operator) {
if ("" === e.value) return true;
return new c(this.value, t).test(e.semver);
}
t = n(t);
if (t.includePrerelease && ("<0.0.0-0" === this.value || "<0.0.0-0" === e.value)) return false;
if (!t.includePrerelease && (this.value.startsWith("<0.0.0") || e.value.startsWith("<0.0.0"))) return false;
if (this.operator.startsWith(">") && e.operator.startsWith(">")) return true;
if (this.operator.startsWith("<") && e.operator.startsWith("<")) return true;
if (this.semver.version === e.semver.version && this.operator.includes("=") && e.operator.includes("=")) return true;
if (l(this.semver, "<", e.semver, t) && this.operator.startsWith(">") && e.operator.startsWith("<")) return true;
if (l(this.semver, ">", e.semver, t) && this.operator.startsWith("<") && e.operator.startsWith(">")) return true;
return false;
}
}
e.exports = Comparator;
const n = r(110);
const { safeRe: i, t: o } = r(258);
const l = r(159);
const a = r(935);
const h = r(649);
const c = r(530);
},
530: (e, t, r)=>{
class Range {
constructor(e, t){
t = i(t);
if (e instanceof Range) if (!!t.loose === e.loose && !!t.includePrerelease === e.includePrerelease) return e;
else return new Range(e.raw, t);
if (e instanceof o) {
this.raw = e.value;
this.set = [
[
e
]
];
this.format();
return this;
}
this.options = t;
this.loose = !!t.loose;
this.includePrerelease = !!t.includePrerelease;
this.raw = e.trim().split(/\s+/).join(" ");
this.set = this.raw.split("||").map((e)=>this.parseRange(e.trim())).filter((e)=>e.length);
if (!this.set.length) throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
if (this.set.length > 1) {
const e = this.set[0];
this.set = this.set.filter((e)=>!isNullSet(e[0]));
if (0 === this.set.length) this.set = [
e
];
else if (this.set.length > 1) {
for (const e of this.set)if (1 === e.length && isAny(e[0])) {
this.set = [
e
];
break;
}
}
}
this.format();
}
format() {
this.range = this.set.map((e)=>e.join(" ").trim()).join("||").trim();
return this.range;
}
toString() {
return this.range;
}
parseRange(e) {
const t = (this.options.includePrerelease && E) | (this.options.loose && m);
const r = t + ":" + e;
const s = n.get(r);
if (s) return s;
const i = this.options.loose;
const a = i ? h[c.HYPHENRANGELOOSE] : h[c.HYPHENRANGE];
e = e.replace(a, hyphenReplace(this.options.includePrerelease));
l("hyphen replace", e);
e = e.replace(h[c.COMPARATORTRIM], u);
l("comparator trim", e);
e = e.replace(h[c.TILDETRIM], f);
l("tilde trim", e);
e = e.replace(h[c.CARETTRIM], p);
l("caret trim", e);
let v = e.split(" ").map((e)=>parseComparator(e, this.options)).join(" ").split(/\s+/).map((e)=>replaceGTE0(e, this.options));
if (i) v = v.filter((e)=>{
l("loose invalid filter", e, this.options);
return !!e.match(h[c.COMPARATORLOOSE]);
});
l("range list", v);
const $ = new Map;
const R = v.map((e)=>new o(e, this.options));
for (const e of R){
if (isNullSet(e)) return [
e
];
$.set(e.value, e);
}
if ($.size > 1 && $.has("")) $.delete("");
const d = [
...$.values()
];
n.set(r, d);
return d;
}
intersects(e, t) {
if (!(e instanceof Range)) throw new TypeError("a Range is required");
return this.set.some((r)=>isSatisfiable(r, t) && e.set.some((e)=>isSatisfiable(e, t) && r.every((r)=>e.every((e)=>r.intersects(e, t)))));
}
test(e) {
if (!e) return false;
if ("string" == typeof e) try {
e = new a(e, this.options);
} catch (e) {
return false;
}
for(let t = 0; t < this.set.length; t++)if (testSet(this.set[t], e, this.options)) return true;
return false;
}
}
e.exports = Range;
const s = r(844);
const n = new s({
max: 1e3
});
const i = r(110);
const o = r(584);
const l = r(935);
const a = r(649);
const { safeRe: h, t: c, comparatorTrimReplace: u, tildeTrimReplace: f, caretTrimReplace: p } = r(258);
const { FLAG_INCLUDE_PRERELEASE: E, FLAG_LOOSE: m } = r(745);
const isNullSet = (e)=>"<0.0.0-0" === e.value;
const isAny = (e)=>"" === e.value;
const isSatisfiable = (e, t)=>{
let r = true;
const s = e.slice();
let n = s.pop();
while(r && s.length){
r = s.every((e)=>n.intersects(e, t));
n = s.pop();
}
return r;
};
const parseComparator = (e, t)=>{
l("comp", e, t);
e = replaceCarets(e, t);
l("caret", e);
e = replaceTildes(e, t);
l("tildes", e);
e = replaceXRanges(e, t);
l("xrange", e);
e = replaceStars(e, t);
l("stars", e);
return e;
};
const isX = (e)=>!e || "x" === e.toLowerCase() || "*" === e;
const replaceTildes = (e, t)=>e.trim().split(/\s+/).map((e)=>replaceTilde(e, t)).join(" ");
const replaceTilde = (e, t)=>{
const r = t.loose ? h[c.TILDELOOSE] : h[c.TILDE];
return e.replace(r, (t, r, s, n, i)=>{
l("tilde", e, t, r, s, n, i);
let o;
if (isX(r)) o = "";
else if (isX(s)) o = `>=${r}.0.0 <${+r + 1}.0.0-0`;
else if (isX(n)) o = `>=${r}.${s}.0 <${r}.${+s + 1}.0-0`;
else if (i) {
l("replaceTilde pr", i);
o = `>=${r}.${s}.${n}-${i} <${r}.${+s + 1}.0-0`;
} else o = `>=${r}.${s}.${n} <${r}.${+s + 1}.0-0`;
l("tilde return", o);
return o;
});
};
const replaceCarets = (e, t)=>e.trim().split(/\s+/).map((e)=>replaceCaret(e, t)).join(" ");
const replaceCaret = (e, t)=>{
l("caret", e, t);
const r = t.loose ? h[c.CARETLOOSE] : h[c.CARET];
const s = t.includePrerelease ? "-0" : "";
return e.replace(r, (t, r, n, i, o)=>{
l("caret", e, t, r, n, i, o);
let a;
if (isX(r)) a = "";
else if (isX(n)) a = `>=${r}.0.0${s} <${+r + 1}.0.0-0`;
else if (isX(i)) a = "0" === r ? `>=${r}.${n}.0${s} <${r}.${+n + 1}.0-0` : `>=${r}.${n}.0${s} <${+r + 1}.0.0-0`;
else if (o) {
l("replaceCaret pr", o);
a = "0" === r ? "0" === n ? `>=${r}.${n}.${i}-${o} <${r}.${n}.${+i + 1}-0` : `>=${r}.${n}.${i}-${o} <${r}.${+n + 1}.0-0` : `>=${r}.${n}.${i}-${o} <${+r + 1}.0.0-0`;
} else {
l("no pr");
a = "0" === r ? "0" === n ? `>=${r}.${n}.${i}${s} <${r}.${n}.${+i + 1}-0` : `>=${r}.${n}.${i}${s} <${r}.${+n + 1}.0-0` : `>=${r}.${n}.${i} <${+r + 1}.0.0-0`;
}
l("caret return", a);
return a;
});
};
const replaceXRanges = (e, t)=>{
l("replaceXRanges", e, t);
return e.split(/\s+/).map((e)=>replaceXRange(e, t)).join(" ");
};
const replaceXRange = (e, t)=>{
e = e.trim();
const r = t.loose ? h[c.XRANGELOOSE] : h[c.XRANGE];
return e.replace(r, (r, s, n, i, o, a)=>{
l("xRange", e, r, s, n, i, o, a);
const h = isX(n);
const c = h || isX(i);
const u = c || isX(o);
const f = u;
if ("=" === s && f) s = "";
a = t.includePrerelease ? "-0" : "";
if (h) r = ">" === s || "<" === s ? "<0.0.0-0" : "*";
else if (s && f) {
if (c) i = 0;
o = 0;
if (">" === s) {
s = ">=";
if (c) {
n = +n + 1;
i = 0;
o = 0;
} else {
i = +i + 1;
o = 0;
}
} else if ("<=" === s) {
s = "<";
if (c) n = +n + 1;
else i = +i + 1;
}
if ("<" === s) a = "-0";
r = `${s + n}.${i}.${o}${a}`;
} else if (c) r = `>=${n}.0.0${a} <${+n + 1}.0.0-0`;
else if (u) r = `>=${n}.${i}.0${a} <${n}.${+i + 1}.0-0`;
l("xRange return", r);
return r;
});
};
const replaceStars = (e, t)=>{
l("replaceStars", e, t);
return e.trim().replace(h[c.STAR], "");
};
const replaceGTE0 = (e, t)=>{
l("replaceGTE0", e, t);
return e.trim().replace(h[t.includePrerelease ? c.GTE0PRE : c.GTE0], "");
};
const hyphenReplace = (e)=>(t, r, s, n, i, o, l, a, h, c, u, f, p)=>{
r = isX(s) ? "" : isX(n) ? `>=${s}.0.0${e ? "-0" : ""}` : isX(i) ? `>=${s}.${n}.0${e ? "-0" : ""}` : o ? `>=${r}` : `>=${r}${e ? "-0" : ""}`;
a = isX(h) ? "" : isX(c) ? `<${+h + 1}.0.0-0` : isX(u) ? `<${h}.${+c + 1}.0-0` : f ? `<=${h}.${c}.${u}-${f}` : e ? `<${h}.${c}.${+u + 1}-0` : `<=${a}`;
return `${r} ${a}`.trim();
};
const testSet = (e, t, r)=>{
for(let r = 0; r < e.length; r++)if (!e[r].test(t)) return false;
if (t.prerelease.length && !r.includePrerelease) {
for(let r = 0; r < e.length; r++){
l(e[r].semver);
if (e[r].semver !== o.ANY) {
if (e[r].semver.prerelease.length > 0) {
const s = e[r].semver;
if (s.major === t.major && s.minor === t.minor && s.patch === t.patch) return true;
}
}
}
return false;
}
return true;
};
},
649: (e, t, r)=>{
const s = r(935);
const { MAX_LENGTH: n, MAX_SAFE_INTEGER: i } = r(745);
const { safeRe: o, t: l } = r(258);
const a = r(110);
const { compareIdentifiers: h } = r(74);
class SemVer {
constructor(e, t){
t = a(t);
if (e instanceof SemVer) if (!!t.loose === e.loose && !!t.includePrerelease === e.includePrerelease) return e;
else e = e.version;
else if ("string" != typeof e) throw new TypeError(`Invalid version. Must be a string. Got type "${typeof e}".`);
if (e.length > n) throw new TypeError(`version is longer than ${n} characters`);
s("SemVer", e, t);
this.options = t;
this.loose = !!t.loose;
this.includePrerelease = !!t.includePrerelease;
const r = e.trim().match(t.loose ? o[l.LOOSE] : o[l.FULL]);
if (!r) throw new TypeError(`Invalid Version: ${e}`);
this.raw = e;
this.major = +r[1];
this.minor = +r[2];
this.patch = +r[3];
if (this.major > i || this.major < 0) throw new TypeError("Invalid major version");
if (this.minor > i || this.minor < 0) throw new TypeError("Invalid minor version");
if (this.patch > i || this.patch < 0) throw new TypeError("Invalid patch version");
if (r[4]) this.prerelease = r[4].split(".").map((e)=>{
if (/^[0-9]+$/.test(e)) {
const t = +e;
if (t >= 0 && t < i) return t;
}
return e;
});
else this.prerelease = [];
this.build = r[5] ? r[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(e) {
s("SemVer.compare", this.version, this.options, e);
if (!(e instanceof SemVer)) {
if ("string" == typeof e && e === this.version) return 0;
e = new SemVer(e, this.options);
}
if (e.version === this.version) return 0;
return this.compareMain(e) || this.comparePre(e);
}
compareMain(e) {
if (!(e instanceof SemVer)) e = new SemVer(e, this.options);
return h(this.major, e.major) || h(this.minor, e.minor) || h(this.patch, e.patch);
}
comparePre(e) {
if (!(e instanceof SemVer)) e = new SemVer(e, this.options);
if (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 t = 0;
do {
const r = this.prerelease[t];
const n = e.prerelease[t];
s("prerelease compare", t, r, n);
if (void 0 === r && void 0 === n) return 0;
if (void 0 === n) return 1;
if (void 0 === r) return -1;
else if (r === n) continue;
else return h(r, n);
}while (++t);
}
compareBuild(e) {
if (!(e instanceof SemVer)) e = new SemVer(e, this.options);
let t = 0;
do {
const r = this.build[t];
const n = e.build[t];
s("prerelease compare", t, r, n);
if (void 0 === r && void 0 === n) return 0;
if (void 0 === n) return 1;
if (void 0 === r) return -1;
else if (r === n) continue;
else return h(r, n);
}while (++t);
}
inc(e, t, r) {
switch(e){
case "premajor":
this.prerelease.length = 0;
this.patch = 0;
this.minor = 0;
this.major++;
this.inc("pre", t, r);
break;
case "preminor":
this.prerelease.length = 0;
this.patch = 0;
this.minor++;
this.inc("pre", t, r);
break;
case "prepatch":
this.prerelease.length = 0;
this.inc("patch", t, r);
this.inc("pre", t, r);
break;
case "prerelease":
if (0 === this.prerelease.length) this.inc("patch", t, r);
this.inc("pre", t, r);
break;
case "major":
if (0 !== this.minor || 0 !== this.patch || 0 === this.prerelease.length) this.major++;
this.minor = 0;
this.patch = 0;
this.prerelease = [];
break;
case "minor":
if (0 !== this.patch || 0 === this.prerelease.length) this.minor++;
this.patch = 0;
this.prerelease = [];
break;
case "patch":
if (0 === this.prerelease.length) this.patch++;
this.prerelease = [];
break;
case "pre":
{
const e = Number(r) ? 1 : 0;
if (!t && false === r) throw new Error("invalid increment argument: identifier is empty");
if (0 === this.prerelease.length) this.prerelease = [
e
];
else {
let s = this.prerelease.length;
while(--s >= 0)if ("number" == typeof this.prerelease[s]) {
this.prerelease[s]++;
s = -2;
}
if (-1 === s) {
if (t === this.prerelease.join(".") && false === r) throw new Error("invalid increment argument: identifier already exists");
this.prerelease.push(e);
}
}
if (t) {
let s = [
t,
e
];
if (false === r) s = [
t
];
if (0 === h(this.prerelease[0], t)) {
if (isNaN(this.prerelease[1])) this.prerelease = s;
} else this.prerelease = s;
}
break;
}
default:
throw new Error(`invalid increment argument: ${e}`);
}
this.raw = this.format();
if (this.build.length) this.raw += `+${this.build.join(".")}`;
return this;
}
}
e.exports = SemVer;
},
640: (e, t, r)=>{
const s = r(447);
const clean = (e, t)=>{
const r = s(e.trim().replace(/^[=v]+/, ""), t);
return r ? r.version : null;
};
e.exports = clean;
},
159: (e, t, r)=>{
const s = r(164);
const n = r(196);
const i = r(478);
const o = r(528);
const l = r(654);
const a = r(355);
const cmp = (e, t, r, h)=>{
switch(t){
case "===":
if ("object" == typeof e) e = e.version;
if ("object" == typeof r) r = r.version;
return e === r;
case "!==":
if ("object" == typeof e) e = e.version;
if ("object" == typeof r) r = r.version;
return e !== r;
case "":
case "=":
case "==":
return s(e, r, h);
case "!=":
return n(e, r, h);
case ">":
return i(e, r, h);
case ">=":
return o(e, r, h);
case "<":
return l(e, r, h);
case "<=":
return a(e, r, h);
default:
throw new TypeError(`Invalid operator: ${t}`);
}
};
e.exports = cmp;
},
732: (e, t, r)=>{
const s = r(649);
const n = r(447);
const { safeRe: i, t: o } = r(258);
const coerce = (e, t)=>{
if (e instanceof s) return e;
if ("number" == typeof e) e = String(e);
if ("string" != typeof e) return null;
t = t || {};
let r = null;
if (t.rtl) {
const s = t.includePrerelease ? i[o.COERCERTLFULL] : i[o.COERCERTL];
let n;
while((n = s.exec(e)) && (!r || r.index + r[0].length !== e.length)){
if (!r || n.index + n[0].length !== r.index + r[0].length) r = n;
s.lastIndex = n.index + n[1].length + n[2].length;
}
s.lastIndex = -1;
} else r = e.match(t.includePrerelease ? i[o.COERCEFULL] : i[o.COERCE]);
if (null === r) return null;
const l = r[2];
const a = r[3] || "0";
const h = r[4] || "0";
const c = t.includePrerelease && r[5] ? `-${r[5]}` : "";
const u = t.includePrerelease && r[6] ? `+${r[6]}` : "";
return n(`${l}.${a}.${h}${c}${u}`, t);
};
e.exports = coerce;
},
425: (e, t, r)=>{
const s = r(649);
const compareBuild = (e, t, r)=>{
const n = new s(e, r);
const i = new s(t, r);
return n.compare(i) || n.compareBuild(i);
};
e.exports = compareBuild;
},
59: (e, t, r)=>{
const s = r(936);
const compareLoose = (e, t)=>s(e, t, true);
e.exports = compareLoose;
},
936: (e, t, r)=>{
const s = r(649);
const compare = (e, t, r)=>new s(e, r).compare(new s(t, r));
e.exports = compare;
},
163: (e, t, r)=>{
const s = r(447);
const diff = (e, t)=>{
const r = s(e, null, true);
const n = s(t, null, true);
const i = r.compare(n);
if (0 === i) return null;
const o = i > 0;
const l = o ? r : n;
const a = o ? n : r;
const h = !!l.prerelease.length;
const c = !!a.prerelease.length;
if (c && !h) {
if (!a.patch && !a.minor) return "major";
if (l.patch) return "patch";
if (l.minor) return "minor";
return "major";
}
const u = h ? "pre" : "";
if (r.major !== n.major) return u + "major";
if (r.minor !== n.minor) return u + "minor";
if (r.patch !== n.patch) return u + "patch";
return "prerelease";
};
e.exports = diff;
},
164: (e, t, r)=>{
const s = r(936);
const eq = (e, t, r)=>0 === s(e, t, r);
e.exports = eq;
},
478: (e, t, r)=>{
const s = r(936);
const gt = (e, t, r)=>s(e, t, r) > 0;
e.exports = gt;
},
528: (e, t, r)=>{
const s = r(936);
const gte = (e, t, r)=>s(e, t, r) >= 0;
e.exports = gte;
},
53: (e, t, r)=>{
const s = r(649);
const inc = (e, t, r, n, i)=>{
if ("string" == typeof r) {
i = n;
n = r;
r = void 0;
}
try {
return new s(e instanceof s ? e.version : e, r).inc(t, n, i).version;
} catch (e) {
return null;
}
};
e.exports = inc;
},
654: (e, t, r)=>{
const s = r(936);
const lt = (e, t, r)=>s(e, t, r) < 0;
e.exports = lt;
},
355: (e, t, r)=>{
const s = r(936);
const lte = (e, t, r)=>s(e, t, r) <= 0;
e.exports = lte;
},
86: (e, t, r)=>{
const s = r(649);
const major = (e, t)=>new s(e, t).major;
e.exports = major;
},
753: (e, t, r)=>{
const s = r(649);
const minor = (e, t)=>new s(e, t).minor;
e.exports = minor;
},
196: (e, t, r)=>{
const s = r(936);
const neq = (e, t, r)=>0 !== s(e, t, r);
e.exports = neq;
},
447: (e, t, r)=>{
const s = r(649);
const parse = (e, t, r = false)=>{
if (e instanceof s) return e;
try {
return new s(e, t);
} catch (e) {
if (!r) return null;
throw e;
}
};
e.exports = parse;
},
772: (e, t, r)=>{
const s = r(649);
const patch = (e, t)=>new s(e, t).patch;
e.exports = patch;
},
973: (e, t, r)=>{
const s = r(447);
const prerelease = (e, t)=>{
const r = s(e, t);
return r && r.prerelease.length ? r.prerelease : null;
};
e.exports = prerelease;
},
580: (e, t, r)=>{
const s = r(936);
const rcompare = (e, t, r)=>s(t, e, r);
e.exports = rcompare;
},
573: (e, t, r)=>{
const s = r(425);
const rsort = (e, t)=>e.sort((e, r)=>s(r, e, t));
e.exports = rsort;
},
727: (e, t, r)=>{
const s = r(530);
const satisfies = (e, t, r)=>{
try {
t = new s(t, r);
} catch (e) {
return false;
}
return t.test(e);
};
e.exports = satisfies;
},
318: (e, t, r)=>{
const s = r(425);
const sort = (e, t)=>e.sort((e, r)=>s(e, r, t));
e.exports = sort;
},
458: (e, t, r)=>{
const s = r(447);
const valid = (e, t)=>{
const r = s(e, t);
return r ? r.version : null;
};
e.exports = valid;
},
921: (e, t, r)=>{
const s = r(258);
const n = r(745);
const i = r(649);
const o = r(74);
const l = r(447);
const a = r(458);
const h = r(640);
const c = r(53);
const u = r(163);
const f = r(86);
const p = r(753);
const E = r(772);
const m = r(973);
const v = r(936);
const $ = r(580);
const R = r(59);
const d = r(425);
const g = r(318);
const I = r(573);
const N = r(478);
const L = r(654);
const A = r(164);
const w = r(196);
const O = r(528);
const S = r(355);
const T = r(159);
const y = r(732);
const x = r(584);
const P = r(530);
const C = r(727);
const b = r(857);
const D = r(754);
const _ = r(786);
const G = r(200);
const M = r(115);
const F = r(443);
const j = r(490);
const Y = r(987);
const U = r(219);
const X = r(333);
const k = r(958);
e.exports = {
parse: l,
valid: a,
clean: h,
inc: c,
diff: u,
major: f,
minor: p,
patch: E,
prerelease: m,
compare: v,
rcompare: $,
compareLoose: R,
compareBuild: d,
sort: g,
rsort: I,
gt: N,
lt: L,
eq: A,
neq: w,
gte: O,
lte: S,
cmp: T,
coerce: y,
Comparator: x,
Range: P,
satisfies: C,
toComparators: b,
maxSatisfying: D,
minSatisfying: _,
minVersion: G,
validRange: M,
outside: F,
gtr: j,
ltr: Y,
intersects: U,
simplifyRange: X,
subset: k,
SemVer: i,
re: s.re,
src: s.src,
tokens: s.t,
SEMVER_SPEC_VERSION: n.SEMVER_SPEC_VERSION,
RELEASE_TYPES: n.RELEASE_TYPES,
compareIdentifiers: o.compareIdentifiers,
rcompareIdentifiers: o.rcompareIdentifiers
};
},
745: (e)=>{
const t = "2.0.0";
const r = 256;
const s = Number.MAX_SAFE_INTEGER || 9007199254740991;
const n = 16;
const i = r - 6;
const o = [
"major",
"premajor",
"minor",
"preminor",
"patch",
"prepatch",
"prerelease"
];
e.exports = {
MAX_LENGTH: r,
MAX_SAFE_COMPONENT_LENGTH: n,
MAX_SAFE_BUILD_LENGTH: i,
MAX_SAFE_INTEGER: s,
RELEASE_TYPES: o,
SEMVER_SPEC_VERSION: t,
FLAG_INCLUDE_PRERELEASE: 1,
FLAG_LOOSE: 2
};
},
935: (e)=>{
const t = "object" == typeof process && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...e)=>console.error("SEMVER", ...e) : ()=>{};
e.exports = t;
},
74: (e)=>{
const t = /^[0-9]+$/;
const compareIdentifiers = (e, r)=>{
const s = t.test(e);
const n = t.test(r);
if (s && n) {
e *= 1;
r *= 1;
}
return e === r ? 0 : s && !n ? -1 : n && !s ? 1 : e < r ? -1 : 1;
};
const rcompareIdentifiers = (e, t)=>compareIdentifiers(t, e);
e.exports = {
compareIdentifiers: compareIdentifiers,
rcompareIdentifiers: rcompareIdentifiers
};
},
110: (e)=>{
const t = Object.freeze({
loose: true
});
const r = Object.freeze({});
const parseOptions = (e)=>{
if (!e) return r;
if ("object" != typeof e) return t;
return e;
};
e.exports = parseOptions;
},
258: (e, t, r)=>{
const { MAX_SAFE_COMPONENT_LENGTH: s, MAX_SAFE_BUILD_LENGTH: n, MAX_LENGTH: i } = r(745);
const o = r(935);
t = e.exports = {};
const l = t.re = [];
const a = t.safeRe = [];
const h = t.src = [];
const c = t.t = {};
let u = 0;
const f = "[a-zA-Z0-9-]";
const p = [
[
"\\s",
1
],
[
"\\d",
i
],
[
f,
n
]
];
const makeSafeRegex = (e)=>{
for (const [t, r] of p)e = e.split(`${t}*`).join(`${t}{0,${r}}`).split(`${t}+`).join(`${t}{1,${r}}`);
return e;
};
const createToken = (e, t, r)=>{
const s = makeSafeRegex(t);
const n = u++;
o(e, n, t);
c[e] = n;
h[n] = t;
l[n] = new RegExp(t, r ? "g" : void 0);
a[n] = new RegExp(s, r ? "g" : void 0);
};
createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${f}*`);
createToken("MAINVERSION", `(${h[c.NUMERICIDENTIFIER]})\\.(${h[c.NUMERICIDENTIFIER]})\\.(${h[c.NUMERICIDENTIFIER]})`);
createToken("MAINVERSIONLOOSE", `(${h[c.NUMERICIDENTIFIERLOOSE]})\\.(${h[c.NUMERICIDENTIFIERLOOSE]})\\.(${h[c.NUMERICIDENTIFIERLOOSE]})`);
createToken("PRERELEASEIDENTIFIER", `(?:${h[c.NUMERICIDENTIFIER]}|${h[c.NONNUMERICIDENTIFIER]})`);
createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${h[c.NUMERICIDENTIFIERLOOSE]}|${h[c.NONNUMERICIDENTIFIER]})`);
createToken("PRERELEASE", `(?:-(${h[c.PRERELEASEIDENTIFIER]}(?:\\.${h[c.PRERELEASEIDENTIFIER]})*))`);
createToken("PRERELEASELOOSE", `(?:-?(${h[c.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${h[c.PRERELEASEIDENTIFIERLOOSE]})*))`);
createToken("BUILDIDENTIFIER", `${f}+`);
createToken("BUILD", `(?:\\+(${h[c.BUILDIDENTIFIER]}(?:\\.${h[c.BUILDIDENTIFIER]})*))`);
createToken("FULLPLAIN", `v?${h[c.MAINVERSION]}${h[c.PRERELEASE]}?${h[c.BUILD]}?`);
createToken("FULL", `^${h[c.FULLPLAIN]}$`);
createToken("LOOSEPLAIN", `[v=\\s]*${h[c.MAINVERSIONLOOSE]}${h[c.PRERELEASELOOSE]}?${h[c.BUILD]}?`);
createToken("LOOSE", `^${h[c.LOOSEPLAIN]}$`);
createToken("GTLT", "((?:<|>)?=?)");
createToken("XRANGEIDENTIFIERLOOSE", `${h[c.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
createToken("XRANGEIDENTIFIER", `${h[c.NUMERICIDENTIFIER]}|x|X|\\*`);
createToken("XRANGEPLAIN", `[v=\\s]*(${h[c.XRANGEIDENTIFIER]})(?:\\.(${h[c.XRANGEIDENTIFIER]})(?:\\.(${h[c.XRANGEIDENTIFIER]})(?:${h[c.PRERELEASE]})?${h[c.BUILD]}?)?)?`);
createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${h[c.XRANGEIDENTIFIERLOOSE]})(?:\\.(${h[c.XRANGEIDENTIFIERLOOSE]})(?:\\.(${h[c.XRANGEIDENTIFIERLOOSE]})(?:${h[c.PRERELEASELOOSE]})?${h[c.BUILD]}?)?)?`);
createToken("XRANGE", `^${h[c.GTLT]}\\s*${h[c.XRANGEPLAIN]}$`);
createToken("XRANGELOOSE", `^${h[c.GTLT]}\\s*${h[c.XRANGEPLAINLOOSE]}$`);
createToken("COERCEPLAIN", `(^|[^\\d])(\\d{1,${s}})(?:\\.(\\d{1,${s}}))?(?:\\.(\\d{1,${s}}))?`);
createToken("COERCE", `${h[c.COERCEPLAIN]}(?:$|[^\\d])`);
createToken("COERCEFULL", h[c.COERCEPLAIN] + `(?:${h[c.PRERELEASE]})?` + `(?:${h[c.BUILD]})?` + "(?:$|[^\\d])");
createToken("COERCERTL", h[c.COERCE], true);
createToken("COERCERTLFULL", h[c.COERCEFULL], true);
createToken("LONETILDE", "(?:~>?)");
createToken("TILDETRIM", `(\\s*)${h[c.LONETILDE]}\\s+`, true);
t.tildeTrimReplace = "$1~";
createToken("TILDE", `^${h[c.LONETILDE]}${h[c.XRANGEPLAIN]}$`);
createToken("TILDELOOSE", `^${h[c.LONETILDE]}${h[c.XRANGEPLAINLOOSE]}$`);
createToken("LONECARET", "(?:\\^)");
createToken("CARETTRIM", `(\\s*)${h[c.LONECARET]}\\s+`, true);
t.caretTrimReplace = "$1^";
crea