@vc-shell/framework 1.1.75 → 1.1.77

package/dist/vendor-semver-FuwqpOls.js

@@ -0,0 +1,1021 @@
+var H = { exports: {} }, ee, Ke;
+function k() {
+  if (Ke) return ee;
+  Ke = 1;
+  const a = "2.0.0", u = 256, i = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+  9007199254740991, r = 16, n = u - 6;
+  return ee = {
+    MAX_LENGTH: u,
+    MAX_SAFE_COMPONENT_LENGTH: r,
+    MAX_SAFE_BUILD_LENGTH: n,
+    MAX_SAFE_INTEGER: i,
+    RELEASE_TYPES: [
+      "major",
+      "premajor",
+      "minor",
+      "preminor",
+      "patch",
+      "prepatch",
+      "prerelease"
+    ],
+    SEMVER_SPEC_VERSION: a,
+    FLAG_INCLUDE_PRERELEASE: 1,
+    FLAG_LOOSE: 2
+  }, ee;
+}
+var re, Ze;
+function B() {
+  return Ze || (Ze = 1, re = typeof process == "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...u) => console.error("SEMVER", ...u) : () => {
+  }), re;
+}
+var Je;
+function M() {
+  return Je || (Je = 1, function(a, u) {
+    const {
+      MAX_SAFE_COMPONENT_LENGTH: i,
+      MAX_SAFE_BUILD_LENGTH: r,
+      MAX_LENGTH: n
+    } = k(), p = B();
+    u = a.exports = {};
+    const c = u.re = [], f = u.safeRe = [], s = u.src = [], t = u.safeSrc = [], e = u.t = {};
+    let o = 0;
+    const l = "[a-zA-Z0-9-]", m = [
+      ["\\s", 1],
+      ["\\d", n],
+      [l, r]
+    ], A = (S) => {
+      for (const [g, G] of m)
+        S = S.split(`${g}*`).join(`${g}{0,${G}}`).split(`${g}+`).join(`${g}{1,${G}}`);
+      return S;
+    }, E = (S, g, G) => {
+      const w = A(g), y = o++;
+      p(S, y, g), e[S] = y, s[y] = g, t[y] = w, c[y] = new RegExp(g, G ? "g" : void 0), f[y] = new RegExp(w, G ? "g" : void 0);
+    };
+    E("NUMERICIDENTIFIER", "0|[1-9]\\d*"), E("NUMERICIDENTIFIERLOOSE", "\\d+"), E("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${l}*`), E("MAINVERSION", `(${s[e.NUMERICIDENTIFIER]})\\.(${s[e.NUMERICIDENTIFIER]})\\.(${s[e.NUMERICIDENTIFIER]})`), E("MAINVERSIONLOOSE", `(${s[e.NUMERICIDENTIFIERLOOSE]})\\.(${s[e.NUMERICIDENTIFIERLOOSE]})\\.(${s[e.NUMERICIDENTIFIERLOOSE]})`), E("PRERELEASEIDENTIFIER", `(?:${s[e.NONNUMERICIDENTIFIER]}|${s[e.NUMERICIDENTIFIER]})`), E("PRERELEASEIDENTIFIERLOOSE", `(?:${s[e.NONNUMERICIDENTIFIER]}|${s[e.NUMERICIDENTIFIERLOOSE]})`), E("PRERELEASE", `(?:-(${s[e.PRERELEASEIDENTIFIER]}(?:\\.${s[e.PRERELEASEIDENTIFIER]})*))`), E("PRERELEASELOOSE", `(?:-?(${s[e.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${s[e.PRERELEASEIDENTIFIERLOOSE]})*))`), E("BUILDIDENTIFIER", `${l}+`), E("BUILD", `(?:\\+(${s[e.BUILDIDENTIFIER]}(?:\\.${s[e.BUILDIDENTIFIER]})*))`), E("FULLPLAIN", `v?${s[e.MAINVERSION]}${s[e.PRERELEASE]}?${s[e.BUILD]}?`), E("FULL", `^${s[e.FULLPLAIN]}$`), E("LOOSEPLAIN", `[v=\\s]*${s[e.MAINVERSIONLOOSE]}${s[e.PRERELEASELOOSE]}?${s[e.BUILD]}?`), E("LOOSE", `^${s[e.LOOSEPLAIN]}$`), E("GTLT", "((?:<|>)?=?)"), E("XRANGEIDENTIFIERLOOSE", `${s[e.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`), E("XRANGEIDENTIFIER", `${s[e.NUMERICIDENTIFIER]}|x|X|\\*`), E("XRANGEPLAIN", `[v=\\s]*(${s[e.XRANGEIDENTIFIER]})(?:\\.(${s[e.XRANGEIDENTIFIER]})(?:\\.(${s[e.XRANGEIDENTIFIER]})(?:${s[e.PRERELEASE]})?${s[e.BUILD]}?)?)?`), E("XRANGEPLAINLOOSE", `[v=\\s]*(${s[e.XRANGEIDENTIFIERLOOSE]})(?:\\.(${s[e.XRANGEIDENTIFIERLOOSE]})(?:\\.(${s[e.XRANGEIDENTIFIERLOOSE]})(?:${s[e.PRERELEASELOOSE]})?${s[e.BUILD]}?)?)?`), E("XRANGE", `^${s[e.GTLT]}\\s*${s[e.XRANGEPLAIN]}$`), E("XRANGELOOSE", `^${s[e.GTLT]}\\s*${s[e.XRANGEPLAINLOOSE]}$`), E("COERCEPLAIN", `(^|[^\\d])(\\d{1,${i}})(?:\\.(\\d{1,${i}}))?(?:\\.(\\d{1,${i}}))?`), E("COERCE", `${s[e.COERCEPLAIN]}(?:$|[^\\d])`), E("COERCEFULL", s[e.COERCEPLAIN] + `(?:${s[e.PRERELEASE]})?(?:${s[e.BUILD]})?(?:$|[^\\d])`), E("COERCERTL", s[e.COERCE], !0), E("COERCERTLFULL", s[e.COERCEFULL], !0), E("LONETILDE", "(?:~>?)"), E("TILDETRIM", `(\\s*)${s[e.LONETILDE]}\\s+`, !0), u.tildeTrimReplace = "$1~", E("TILDE", `^${s[e.LONETILDE]}${s[e.XRANGEPLAIN]}$`), E("TILDELOOSE", `^${s[e.LONETILDE]}${s[e.XRANGEPLAINLOOSE]}$`), E("LONECARET", "(?:\\^)"), E("CARETTRIM", `(\\s*)${s[e.LONECARET]}\\s+`, !0), u.caretTrimReplace = "$1^", E("CARET", `^${s[e.LONECARET]}${s[e.XRANGEPLAIN]}$`), E("CARETLOOSE", `^${s[e.LONECARET]}${s[e.XRANGEPLAINLOOSE]}$`), E("COMPARATORLOOSE", `^${s[e.GTLT]}\\s*(${s[e.LOOSEPLAIN]})$|^$`), E("COMPARATOR", `^${s[e.GTLT]}\\s*(${s[e.FULLPLAIN]})$|^$`), E("COMPARATORTRIM", `(\\s*)${s[e.GTLT]}\\s*(${s[e.LOOSEPLAIN]}|${s[e.XRANGEPLAIN]})`, !0), u.comparatorTrimReplace = "$1$2$3", E("HYPHENRANGE", `^\\s*(${s[e.XRANGEPLAIN]})\\s+-\\s+(${s[e.XRANGEPLAIN]})\\s*$`), E("HYPHENRANGELOOSE", `^\\s*(${s[e.XRANGEPLAINLOOSE]})\\s+-\\s+(${s[e.XRANGEPLAINLOOSE]})\\s*$`), E("STAR", "(<|>)?=?\\s*\\*"), E("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"), E("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  }(H, H.exports)), H.exports;
+}
+var te, Qe;
+function He() {
+  if (Qe) return te;
+  Qe = 1;
+  const a = Object.freeze({ loose: !0 }), u = Object.freeze({});
+  return te = (r) => r ? typeof r != "object" ? a : r : u, te;
+}
+var se, er;
+function xr() {
+  if (er) return se;
+  er = 1;
+  const a = /^[0-9]+$/, u = (r, n) => {
+    const p = a.test(r), c = a.test(n);
+    return p && c && (r = +r, n = +n), r === n ? 0 : p && !c ? -1 : c && !p ? 1 : r < n ? -1 : 1;
+  };
+  return se = {
+    compareIdentifiers: u,
+    rcompareIdentifiers: (r, n) => u(n, r)
+  }, se;
+}
+var ne, rr;
+function j() {
+  if (rr) return ne;
+  rr = 1;
+  const a = B(), { MAX_LENGTH: u, MAX_SAFE_INTEGER: i } = k(), { safeRe: r, t: n } = M(), p = He(), { compareIdentifiers: c } = xr();
+  class f {
+    constructor(t, e) {
+      if (e = p(e), t instanceof f) {
+        if (t.loose === !!e.loose && t.includePrerelease === !!e.includePrerelease)
+          return t;
+        t = t.version;
+      } else if (typeof t != "string")
+        throw new TypeError(`Invalid version. Must be a string. Got type "${typeof t}".`);
+      if (t.length > u)
+        throw new TypeError(
+          `version is longer than ${u} characters`
+        );
+      a("SemVer", t, e), this.options = e, this.loose = !!e.loose, this.includePrerelease = !!e.includePrerelease;
+      const o = t.trim().match(e.loose ? r[n.LOOSE] : r[n.FULL]);
+      if (!o)
+        throw new TypeError(`Invalid Version: ${t}`);
+      if (this.raw = t, this.major = +o[1], this.minor = +o[2], this.patch = +o[3], 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");
+      o[4] ? this.prerelease = o[4].split(".").map((l) => {
+        if (/^[0-9]+$/.test(l)) {
+          const m = +l;
+          if (m >= 0 && m < i)
+            return m;
+        }
+        return l;
+      }) : this.prerelease = [], this.build = o[5] ? o[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(t) {
+      if (a("SemVer.compare", this.version, this.options, t), !(t instanceof f)) {
+        if (typeof t == "string" && t === this.version)
+          return 0;
+        t = new f(t, this.options);
+      }
+      return t.version === this.version ? 0 : this.compareMain(t) || this.comparePre(t);
+    }
+    compareMain(t) {
+      return t instanceof f || (t = new f(t, this.options)), c(this.major, t.major) || c(this.minor, t.minor) || c(this.patch, t.patch);
+    }
+    comparePre(t) {
+      if (t instanceof f || (t = new f(t, this.options)), this.prerelease.length && !t.prerelease.length)
+        return -1;
+      if (!this.prerelease.length && t.prerelease.length)
+        return 1;
+      if (!this.prerelease.length && !t.prerelease.length)
+        return 0;
+      let e = 0;
+      do {
+        const o = this.prerelease[e], l = t.prerelease[e];
+        if (a("prerelease compare", e, o, l), o === void 0 && l === void 0)
+          return 0;
+        if (l === void 0)
+          return 1;
+        if (o === void 0)
+          return -1;
+        if (o === l)
+          continue;
+        return c(o, l);
+      } while (++e);
+    }
+    compareBuild(t) {
+      t instanceof f || (t = new f(t, this.options));
+      let e = 0;
+      do {
+        const o = this.build[e], l = t.build[e];
+        if (a("build compare", e, o, l), o === void 0 && l === void 0)
+          return 0;
+        if (l === void 0)
+          return 1;
+        if (o === void 0)
+          return -1;
+        if (o === l)
+          continue;
+        return c(o, l);
+      } while (++e);
+    }
+    // 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(t, e, o) {
+      if (t.startsWith("pre")) {
+        if (!e && o === !1)
+          throw new Error("invalid increment argument: identifier is empty");
+        if (e) {
+          const l = `-${e}`.match(this.options.loose ? r[n.PRERELEASELOOSE] : r[n.PRERELEASE]);
+          if (!l || l[1] !== e)
+            throw new Error(`invalid identifier: ${e}`);
+        }
+      }
+      switch (t) {
+        case "premajor":
+          this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", e, o);
+          break;
+        case "preminor":
+          this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", e, o);
+          break;
+        case "prepatch":
+          this.prerelease.length = 0, this.inc("patch", e, o), this.inc("pre", e, o);
+          break;
+        // If the input is a non-prerelease version, this acts the same as
+        // prepatch.
+        case "prerelease":
+          this.prerelease.length === 0 && this.inc("patch", e, o), this.inc("pre", e, o);
+          break;
+        case "release":
+          if (this.prerelease.length === 0)
+            throw new Error(`version ${this.raw} is not a prerelease`);
+          this.prerelease.length = 0;
+          break;
+        case "major":
+          (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) && this.major++, this.minor = 0, this.patch = 0, this.prerelease = [];
+          break;
+        case "minor":
+          (this.patch !== 0 || this.prerelease.length === 0) && this.minor++, this.patch = 0, this.prerelease = [];
+          break;
+        case "patch":
+          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": {
+          const l = Number(o) ? 1 : 0;
+          if (this.prerelease.length === 0)
+            this.prerelease = [l];
+          else {
+            let m = this.prerelease.length;
+            for (; --m >= 0; )
+              typeof this.prerelease[m] == "number" && (this.prerelease[m]++, m = -2);
+            if (m === -1) {
+              if (e === this.prerelease.join(".") && o === !1)
+                throw new Error("invalid increment argument: identifier already exists");
+              this.prerelease.push(l);
+            }
+          }
+          if (e) {
+            let m = [e, l];
+            o === !1 && (m = [e]), c(this.prerelease[0], e) === 0 ? isNaN(this.prerelease[1]) && (this.prerelease = m) : this.prerelease = m;
+          }
+          break;
+        }
+        default:
+          throw new Error(`invalid increment argument: ${t}`);
+      }
+      return this.raw = this.format(), this.build.length && (this.raw += `+${this.build.join(".")}`), this;
+    }
+  }
+  return ne = f, ne;
+}
+var ie, tr;
+function V() {
+  if (tr) return ie;
+  tr = 1;
+  const a = j();
+  return ie = (i, r, n = !1) => {
+    if (i instanceof a)
+      return i;
+    try {
+      return new a(i, r);
+    } catch (p) {
+      if (!n)
+        return null;
+      throw p;
+    }
+  }, ie;
+}
+var ae, sr;
+function kr() {
+  if (sr) return ae;
+  sr = 1;
+  const a = V();
+  return ae = (i, r) => {
+    const n = a(i, r);
+    return n ? n.version : null;
+  }, ae;
+}
+var oe, nr;
+function Br() {
+  if (nr) return oe;
+  nr = 1;
+  const a = V();
+  return oe = (i, r) => {
+    const n = a(i.trim().replace(/^[=v]+/, ""), r);
+    return n ? n.version : null;
+  }, oe;
+}
+var ce, ir;
+function Yr() {
+  if (ir) return ce;
+  ir = 1;
+  const a = j();
+  return ce = (i, r, n, p, c) => {
+    typeof n == "string" && (c = p, p = n, n = void 0);
+    try {
+      return new a(
+        i instanceof a ? i.version : i,
+        n
+      ).inc(r, p, c).version;
+    } catch {
+      return null;
+    }
+  }, ce;
+}
+var ue, ar;
+function Wr() {
+  if (ar) return ue;
+  ar = 1;
+  const a = V();
+  return ue = (i, r) => {
+    const n = a(i, null, !0), p = a(r, null, !0), c = n.compare(p);
+    if (c === 0)
+      return null;
+    const f = c > 0, s = f ? n : p, t = f ? p : n, e = !!s.prerelease.length;
+    if (!!t.prerelease.length && !e) {
+      if (!t.patch && !t.minor)
+        return "major";
+      if (t.compareMain(s) === 0)
+        return t.minor && !t.patch ? "minor" : "patch";
+    }
+    const l = e ? "pre" : "";
+    return n.major !== p.major ? l + "major" : n.minor !== p.minor ? l + "minor" : n.patch !== p.patch ? l + "patch" : "prerelease";
+  }, ue;
+}
+var le, or;
+function zr() {
+  if (or) return le;
+  or = 1;
+  const a = j();
+  return le = (i, r) => new a(i, r).major, le;
+}
+var fe, cr;
+function Kr() {
+  if (cr) return fe;
+  cr = 1;
+  const a = j();
+  return fe = (i, r) => new a(i, r).minor, fe;
+}
+var he, ur;
+function Zr() {
+  if (ur) return he;
+  ur = 1;
+  const a = j();
+  return he = (i, r) => new a(i, r).patch, he;
+}
+var Ee, lr;
+function Jr() {
+  if (lr) return Ee;
+  lr = 1;
+  const a = V();
+  return Ee = (i, r) => {
+    const n = a(i, r);
+    return n && n.prerelease.length ? n.prerelease : null;
+  }, Ee;
+}
+var pe, fr;
+function U() {
+  if (fr) return pe;
+  fr = 1;
+  const a = j();
+  return pe = (i, r, n) => new a(i, n).compare(new a(r, n)), pe;
+}
+var Re, hr;
+function Qr() {
+  if (hr) return Re;
+  hr = 1;
+  const a = U();
+  return Re = (i, r, n) => a(r, i, n), Re;
+}
+var me, Er;
+function et() {
+  if (Er) return me;
+  Er = 1;
+  const a = U();
+  return me = (i, r) => a(i, r, !0), me;
+}
+var $e, pr;
+function ke() {
+  if (pr) return $e;
+  pr = 1;
+  const a = j();
+  return $e = (i, r, n) => {
+    const p = new a(i, n), c = new a(r, n);
+    return p.compare(c) || p.compareBuild(c);
+  }, $e;
+}
+var de, Rr;
+function rt() {
+  if (Rr) return de;
+  Rr = 1;
+  const a = ke();
+  return de = (i, r) => i.sort((n, p) => a(n, p, r)), de;
+}
+var Ie, mr;
+function tt() {
+  if (mr) return Ie;
+  mr = 1;
+  const a = ke();
+  return Ie = (i, r) => i.sort((n, p) => a(p, n, r)), Ie;
+}
+var ve, $r;
+function Y() {
+  if ($r) return ve;
+  $r = 1;
+  const a = U();
+  return ve = (i, r, n) => a(i, r, n) > 0, ve;
+}
+var Le, dr;
+function Be() {
+  if (dr) return Le;
+  dr = 1;
+  const a = U();
+  return Le = (i, r, n) => a(i, r, n) < 0, Le;
+}
+var Ne, Ir;
+function br() {
+  if (Ir) return Ne;
+  Ir = 1;
+  const a = U();
+  return Ne = (i, r, n) => a(i, r, n) === 0, Ne;
+}
+var Oe, vr;
+function Mr() {
+  if (vr) return Oe;
+  vr = 1;
+  const a = U();
+  return Oe = (i, r, n) => a(i, r, n) !== 0, Oe;
+}
+var Se, Lr;
+function Ye() {
+  if (Lr) return Se;
+  Lr = 1;
+  const a = U();
+  return Se = (i, r, n) => a(i, r, n) >= 0, Se;
+}
+var Ae, Nr;
+function We() {
+  if (Nr) return Ae;
+  Nr = 1;
+  const a = U();
+  return Ae = (i, r, n) => a(i, r, n) <= 0, Ae;
+}
+var Te, Or;
+function Hr() {
+  if (Or) return Te;
+  Or = 1;
+  const a = br(), u = Mr(), i = Y(), r = Ye(), n = Be(), p = We();
+  return Te = (f, s, t, e) => {
+    switch (s) {
+      case "===":
+        return typeof f == "object" && (f = f.version), typeof t == "object" && (t = t.version), f === t;
+      case "!==":
+        return typeof f == "object" && (f = f.version), typeof t == "object" && (t = t.version), f !== t;
+      case "":
+      case "=":
+      case "==":
+        return a(f, t, e);
+      case "!=":
+        return u(f, t, e);
+      case ">":
+        return i(f, t, e);
+      case ">=":
+        return r(f, t, e);
+      case "<":
+        return n(f, t, e);
+      case "<=":
+        return p(f, t, e);
+      default:
+        throw new TypeError(`Invalid operator: ${s}`);
+    }
+  }, Te;
+}
+var ge, Sr;
+function st() {
+  if (Sr) return ge;
+  Sr = 1;
+  const a = j(), u = V(), { safeRe: i, t: r } = M();
+  return ge = (p, c) => {
+    if (p instanceof a)
+      return p;
+    if (typeof p == "number" && (p = String(p)), typeof p != "string")
+      return null;
+    c = c || {};
+    let f = null;
+    if (!c.rtl)
+      f = p.match(c.includePrerelease ? i[r.COERCEFULL] : i[r.COERCE]);
+    else {
+      const m = c.includePrerelease ? i[r.COERCERTLFULL] : i[r.COERCERTL];
+      let A;
+      for (; (A = m.exec(p)) && (!f || f.index + f[0].length !== p.length); )
+        (!f || A.index + A[0].length !== f.index + f[0].length) && (f = A), m.lastIndex = A.index + A[1].length + A[2].length;
+      m.lastIndex = -1;
+    }
+    if (f === null)
+      return null;
+    const s = f[2], t = f[3] || "0", e = f[4] || "0", o = c.includePrerelease && f[5] ? `-${f[5]}` : "", l = c.includePrerelease && f[6] ? `+${f[6]}` : "";
+    return u(`${s}.${t}.${e}${o}${l}`, c);
+  }, ge;
+}
+var we, Ar;
+function nt() {
+  if (Ar) return we;
+  Ar = 1;
+  class a {
+    constructor() {
+      this.max = 1e3, this.map = /* @__PURE__ */ new Map();
+    }
+    get(i) {
+      const r = this.map.get(i);
+      if (r !== void 0)
+        return this.map.delete(i), this.map.set(i, r), r;
+    }
+    delete(i) {
+      return this.map.delete(i);
+    }
+    set(i, r) {
+      if (!this.delete(i) && r !== void 0) {
+        if (this.map.size >= this.max) {
+          const p = this.map.keys().next().value;
+          this.delete(p);
+        }
+        this.map.set(i, r);
+      }
+      return this;
+    }
+  }
+  return we = a, we;
+}
+var qe, Tr;
+function X() {
+  if (Tr) return qe;
+  Tr = 1;
+  const a = /\s+/g;
+  class u {
+    constructor(h, I) {
+      if (I = n(I), h instanceof u)
+        return h.loose === !!I.loose && h.includePrerelease === !!I.includePrerelease ? h : new u(h.raw, I);
+      if (h instanceof p)
+        return this.raw = h.value, this.set = [[h]], this.formatted = void 0, this;
+      if (this.options = I, this.loose = !!I.loose, this.includePrerelease = !!I.includePrerelease, this.raw = h.trim().replace(a, " "), this.set = this.raw.split("||").map(($) => this.parseRange($.trim())).filter(($) => $.length), !this.set.length)
+        throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+      if (this.set.length > 1) {
+        const $ = this.set[0];
+        if (this.set = this.set.filter((v) => !E(v[0])), this.set.length === 0)
+          this.set = [$];
+        else if (this.set.length > 1) {
+          for (const v of this.set)
+            if (v.length === 1 && S(v[0])) {
+              this.set = [v];
+              break;
+            }
+        }
+      }
+      this.formatted = void 0;
+    }
+    get range() {
+      if (this.formatted === void 0) {
+        this.formatted = "";
+        for (let h = 0; h < this.set.length; h++) {
+          h > 0 && (this.formatted += "||");
+          const I = this.set[h];
+          for (let $ = 0; $ < I.length; $++)
+            $ > 0 && (this.formatted += " "), this.formatted += I[$].toString().trim();
+        }
+      }
+      return this.formatted;
+    }
+    format() {
+      return this.range;
+    }
+    toString() {
+      return this.range;
+    }
+    parseRange(h) {
+      const $ = ((this.options.includePrerelease && m) | (this.options.loose && A)) + ":" + h, v = r.get($);
+      if (v)
+        return v;
+      const d = this.options.loose, L = d ? s[t.HYPHENRANGELOOSE] : s[t.HYPHENRANGE];
+      h = h.replace(L, J(this.options.includePrerelease)), c("hyphen replace", h), h = h.replace(s[t.COMPARATORTRIM], e), c("comparator trim", h), h = h.replace(s[t.TILDETRIM], o), c("tilde trim", h), h = h.replace(s[t.CARETTRIM], l), c("caret trim", h);
+      let T = h.split(" ").map((P) => G(P, this.options)).join(" ").split(/\s+/).map((P) => Z(P, this.options));
+      d && (T = T.filter((P) => (c("loose invalid filter", P, this.options), !!P.match(s[t.COMPARATORLOOSE])))), c("range list", T);
+      const O = /* @__PURE__ */ new Map(), q = T.map((P) => new p(P, this.options));
+      for (const P of q) {
+        if (E(P))
+          return [P];
+        O.set(P.value, P);
+      }
+      O.size > 1 && O.has("") && O.delete("");
+      const _ = [...O.values()];
+      return r.set($, _), _;
+    }
+    intersects(h, I) {
+      if (!(h instanceof u))
+        throw new TypeError("a Range is required");
+      return this.set.some(($) => g($, I) && h.set.some((v) => g(v, I) && $.every((d) => v.every((L) => d.intersects(L, I)))));
+    }
+    // if ANY of the sets match ALL of its comparators, then pass
+    test(h) {
+      if (!h)
+        return !1;
+      if (typeof h == "string")
+        try {
+          h = new f(h, this.options);
+        } catch {
+          return !1;
+        }
+      for (let I = 0; I < this.set.length; I++)
+        if (Q(this.set[I], h, this.options))
+          return !0;
+      return !1;
+    }
+  }
+  qe = u;
+  const i = nt(), r = new i(), n = He(), p = W(), c = B(), f = j(), {
+    safeRe: s,
+    t,
+    comparatorTrimReplace: e,
+    tildeTrimReplace: o,
+    caretTrimReplace: l
+  } = M(), { FLAG_INCLUDE_PRERELEASE: m, FLAG_LOOSE: A } = k(), E = (R) => R.value === "<0.0.0-0", S = (R) => R.value === "", g = (R, h) => {
+    let I = !0;
+    const $ = R.slice();
+    let v = $.pop();
+    for (; I && $.length; )
+      I = $.every((d) => v.intersects(d, h)), v = $.pop();
+    return I;
+  }, G = (R, h) => (c("comp", R, h), R = C(R, h), c("caret", R), R = y(R, h), c("tildes", R), R = N(R, h), c("xrange", R), R = K(R, h), c("stars", R), R), w = (R) => !R || R.toLowerCase() === "x" || R === "*", y = (R, h) => R.trim().split(/\s+/).map((I) => F(I, h)).join(" "), F = (R, h) => {
+    const I = h.loose ? s[t.TILDELOOSE] : s[t.TILDE];
+    return R.replace(I, ($, v, d, L, T) => {
+      c("tilde", R, $, v, d, L, T);
+      let O;
+      return w(v) ? O = "" : w(d) ? O = `>=${v}.0.0 <${+v + 1}.0.0-0` : w(L) ? O = `>=${v}.${d}.0 <${v}.${+d + 1}.0-0` : T ? (c("replaceTilde pr", T), O = `>=${v}.${d}.${L}-${T} <${v}.${+d + 1}.0-0`) : O = `>=${v}.${d}.${L} <${v}.${+d + 1}.0-0`, c("tilde return", O), O;
+    });
+  }, C = (R, h) => R.trim().split(/\s+/).map((I) => D(I, h)).join(" "), D = (R, h) => {
+    c("caret", R, h);
+    const I = h.loose ? s[t.CARETLOOSE] : s[t.CARET], $ = h.includePrerelease ? "-0" : "";
+    return R.replace(I, (v, d, L, T, O) => {
+      c("caret", R, v, d, L, T, O);
+      let q;
+      return w(d) ? q = "" : w(L) ? q = `>=${d}.0.0${$} <${+d + 1}.0.0-0` : w(T) ? d === "0" ? q = `>=${d}.${L}.0${$} <${d}.${+L + 1}.0-0` : q = `>=${d}.${L}.0${$} <${+d + 1}.0.0-0` : O ? (c("replaceCaret pr", O), d === "0" ? L === "0" ? q = `>=${d}.${L}.${T}-${O} <${d}.${L}.${+T + 1}-0` : q = `>=${d}.${L}.${T}-${O} <${d}.${+L + 1}.0-0` : q = `>=${d}.${L}.${T}-${O} <${+d + 1}.0.0-0`) : (c("no pr"), d === "0" ? L === "0" ? q = `>=${d}.${L}.${T}${$} <${d}.${L}.${+T + 1}-0` : q = `>=${d}.${L}.${T}${$} <${d}.${+L + 1}.0-0` : q = `>=${d}.${L}.${T} <${+d + 1}.0.0-0`), c("caret return", q), q;
+    });
+  }, N = (R, h) => (c("replaceXRanges", R, h), R.split(/\s+/).map((I) => x(I, h)).join(" ")), x = (R, h) => {
+    R = R.trim();
+    const I = h.loose ? s[t.XRANGELOOSE] : s[t.XRANGE];
+    return R.replace(I, ($, v, d, L, T, O) => {
+      c("xRange", R, $, v, d, L, T, O);
+      const q = w(d), _ = q || w(L), P = _ || w(T), b = P;
+      return v === "=" && b && (v = ""), O = h.includePrerelease ? "-0" : "", q ? v === ">" || v === "<" ? $ = "<0.0.0-0" : $ = "*" : v && b ? (_ && (L = 0), T = 0, v === ">" ? (v = ">=", _ ? (d = +d + 1, L = 0, T = 0) : (L = +L + 1, T = 0)) : v === "<=" && (v = "<", _ ? d = +d + 1 : L = +L + 1), v === "<" && (O = "-0"), $ = `${v + d}.${L}.${T}${O}`) : _ ? $ = `>=${d}.0.0${O} <${+d + 1}.0.0-0` : P && ($ = `>=${d}.${L}.0${O} <${d}.${+L + 1}.0-0`), c("xRange return", $), $;
+    });
+  }, K = (R, h) => (c("replaceStars", R, h), R.trim().replace(s[t.STAR], "")), Z = (R, h) => (c("replaceGTE0", R, h), R.trim().replace(s[h.includePrerelease ? t.GTE0PRE : t.GTE0], "")), J = (R) => (h, I, $, v, d, L, T, O, q, _, P, b) => (w($) ? I = "" : w(v) ? I = `>=${$}.0.0${R ? "-0" : ""}` : w(d) ? I = `>=${$}.${v}.0${R ? "-0" : ""}` : L ? I = `>=${I}` : I = `>=${I}${R ? "-0" : ""}`, w(q) ? O = "" : w(_) ? O = `<${+q + 1}.0.0-0` : w(P) ? O = `<${q}.${+_ + 1}.0-0` : b ? O = `<=${q}.${_}.${P}-${b}` : R ? O = `<${q}.${_}.${+P + 1}-0` : O = `<=${O}`, `${I} ${O}`.trim()), Q = (R, h, I) => {
+    for (let $ = 0; $ < R.length; $++)
+      if (!R[$].test(h))
+        return !1;
+    if (h.prerelease.length && !I.includePrerelease) {
+      for (let $ = 0; $ < R.length; $++)
+        if (c(R[$].semver), R[$].semver !== p.ANY && R[$].semver.prerelease.length > 0) {
+          const v = R[$].semver;
+          if (v.major === h.major && v.minor === h.minor && v.patch === h.patch)
+            return !0;
+        }
+      return !1;
+    }
+    return !0;
+  };
+  return qe;
+}
+var Ce, gr;
+function W() {
+  if (gr) return Ce;
+  gr = 1;
+  const a = Symbol("SemVer ANY");
+  class u {
+    static get ANY() {
+      return a;
+    }
+    constructor(e, o) {
+      if (o = i(o), e instanceof u) {
+        if (e.loose === !!o.loose)
+          return e;
+        e = e.value;
+      }
+      e = e.trim().split(/\s+/).join(" "), c("comparator", e, o), this.options = o, this.loose = !!o.loose, this.parse(e), this.semver === a ? this.value = "" : this.value = this.operator + this.semver.version, c("comp", this);
+    }
+    parse(e) {
+      const o = this.options.loose ? r[n.COMPARATORLOOSE] : r[n.COMPARATOR], l = e.match(o);
+      if (!l)
+        throw new TypeError(`Invalid comparator: ${e}`);
+      this.operator = l[1] !== void 0 ? l[1] : "", this.operator === "=" && (this.operator = ""), l[2] ? this.semver = new f(l[2], this.options.loose) : this.semver = a;
+    }
+    toString() {
+      return this.value;
+    }
+    test(e) {
+      if (c("Comparator.test", e, this.options.loose), this.semver === a || e === a)
+        return !0;
+      if (typeof e == "string")
+        try {
+          e = new f(e, this.options);
+        } catch {
+          return !1;
+        }
+      return p(e, this.operator, this.semver, this.options);
+    }
+    intersects(e, o) {
+      if (!(e instanceof u))
+        throw new TypeError("a Comparator is required");
+      return this.operator === "" ? this.value === "" ? !0 : new s(e.value, o).test(this.value) : e.operator === "" ? e.value === "" ? !0 : new s(this.value, o).test(e.semver) : (o = i(o), o.includePrerelease && (this.value === "<0.0.0-0" || e.value === "<0.0.0-0") || !o.includePrerelease && (this.value.startsWith("<0.0.0") || e.value.startsWith("<0.0.0")) ? !1 : !!(this.operator.startsWith(">") && e.operator.startsWith(">") || this.operator.startsWith("<") && e.operator.startsWith("<") || this.semver.version === e.semver.version && this.operator.includes("=") && e.operator.includes("=") || p(this.semver, "<", e.semver, o) && this.operator.startsWith(">") && e.operator.startsWith("<") || p(this.semver, ">", e.semver, o) && this.operator.startsWith("<") && e.operator.startsWith(">")));
+    }
+  }
+  Ce = u;
+  const i = He(), { safeRe: r, t: n } = M(), p = Hr(), c = B(), f = j(), s = X();
+  return Ce;
+}
+var Pe, wr;
+function z() {
+  if (wr) return Pe;
+  wr = 1;
+  const a = X();
+  return Pe = (i, r, n) => {
+    try {
+      r = new a(r, n);
+    } catch {
+      return !1;
+    }
+    return r.test(i);
+  }, Pe;
+}
+var De, qr;
+function it() {
+  if (qr) return De;
+  qr = 1;
+  const a = X();
+  return De = (i, r) => new a(i, r).set.map((n) => n.map((p) => p.value).join(" ").trim().split(" ")), De;
+}
+var Ge, Cr;
+function at() {
+  if (Cr) return Ge;
+  Cr = 1;
+  const a = j(), u = X();
+  return Ge = (r, n, p) => {
+    let c = null, f = null, s = null;
+    try {
+      s = new u(n, p);
+    } catch {
+      return null;
+    }
+    return r.forEach((t) => {
+      s.test(t) && (!c || f.compare(t) === -1) && (c = t, f = new a(c, p));
+    }), c;
+  }, Ge;
+}
+var ye, Pr;
+function ot() {
+  if (Pr) return ye;
+  Pr = 1;
+  const a = j(), u = X();
+  return ye = (r, n, p) => {
+    let c = null, f = null, s = null;
+    try {
+      s = new u(n, p);
+    } catch {
+      return null;
+    }
+    return r.forEach((t) => {
+      s.test(t) && (!c || f.compare(t) === 1) && (c = t, f = new a(c, p));
+    }), c;
+  }, ye;
+}
+var _e, Dr;
+function ct() {
+  if (Dr) return _e;
+  Dr = 1;
+  const a = j(), u = X(), i = Y();
+  return _e = (n, p) => {
+    n = new u(n, p);
+    let c = new a("0.0.0");
+    if (n.test(c) || (c = new a("0.0.0-0"), n.test(c)))
+      return c;
+    c = null;
+    for (let f = 0; f < n.set.length; ++f) {
+      const s = n.set[f];
+      let t = null;
+      s.forEach((e) => {
+        const o = new a(e.semver.version);
+        switch (e.operator) {
+          case ">":
+            o.prerelease.length === 0 ? o.patch++ : o.prerelease.push(0), o.raw = o.format();
+          /* fallthrough */
+          case "":
+          case ">=":
+            (!t || i(o, t)) && (t = o);
+            break;
+          case "<":
+          case "<=":
+            break;
+          /* istanbul ignore next */
+          default:
+            throw new Error(`Unexpected operation: ${e.operator}`);
+        }
+      }), t && (!c || i(c, t)) && (c = t);
+    }
+    return c && n.test(c) ? c : null;
+  }, _e;
+}
+var je, Gr;
+function ut() {
+  if (Gr) return je;
+  Gr = 1;
+  const a = X();
+  return je = (i, r) => {
+    try {
+      return new a(i, r).range || "*";
+    } catch {
+      return null;
+    }
+  }, je;
+}
+var Fe, yr;
+function ze() {
+  if (yr) return Fe;
+  yr = 1;
+  const a = j(), u = W(), { ANY: i } = u, r = X(), n = z(), p = Y(), c = Be(), f = We(), s = Ye();
+  return Fe = (e, o, l, m) => {
+    e = new a(e, m), o = new r(o, m);
+    let A, E, S, g, G;
+    switch (l) {
+      case ">":
+        A = p, E = f, S = c, g = ">", G = ">=";
+        break;
+      case "<":
+        A = c, E = s, S = p, g = "<", G = "<=";
+        break;
+      default:
+        throw new TypeError('Must provide a hilo val of "<" or ">"');
+    }
+    if (n(e, o, m))
+      return !1;
+    for (let w = 0; w < o.set.length; ++w) {
+      const y = o.set[w];
+      let F = null, C = null;
+      if (y.forEach((D) => {
+        D.semver === i && (D = new u(">=0.0.0")), F = F || D, C = C || D, A(D.semver, F.semver, m) ? F = D : S(D.semver, C.semver, m) && (C = D);
+      }), F.operator === g || F.operator === G || (!C.operator || C.operator === g) && E(e, C.semver))
+        return !1;
+      if (C.operator === G && S(e, C.semver))
+        return !1;
+    }
+    return !0;
+  }, Fe;
+}
+var Ue, _r;
+function lt() {
+  if (_r) return Ue;
+  _r = 1;
+  const a = ze();
+  return Ue = (i, r, n) => a(i, r, ">", n), Ue;
+}
+var Xe, jr;
+function ft() {
+  if (jr) return Xe;
+  jr = 1;
+  const a = ze();
+  return Xe = (i, r, n) => a(i, r, "<", n), Xe;
+}
+var Ve, Fr;
+function ht() {
+  if (Fr) return Ve;
+  Fr = 1;
+  const a = X();
+  return Ve = (i, r, n) => (i = new a(i, n), r = new a(r, n), i.intersects(r, n)), Ve;
+}
+var xe, Ur;
+function Et() {
+  if (Ur) return xe;
+  Ur = 1;
+  const a = z(), u = U();
+  return xe = (i, r, n) => {
+    const p = [];
+    let c = null, f = null;
+    const s = i.sort((l, m) => u(l, m, n));
+    for (const l of s)
+      a(l, r, n) ? (f = l, c || (c = l)) : (f && p.push([c, f]), f = null, c = null);
+    c && p.push([c, null]);
+    const t = [];
+    for (const [l, m] of p)
+      l === m ? t.push(l) : !m && l === s[0] ? t.push("*") : m ? l === s[0] ? t.push(`<=${m}`) : t.push(`${l} - ${m}`) : t.push(`>=${l}`);
+    const e = t.join(" || "), o = typeof r.raw == "string" ? r.raw : String(r);
+    return e.length < o.length ? e : r;
+  }, xe;
+}
+var be, Xr;
+function pt() {
+  if (Xr) return be;
+  Xr = 1;
+  const a = X(), u = W(), { ANY: i } = u, r = z(), n = U(), p = (o, l, m = {}) => {
+    if (o === l)
+      return !0;
+    o = new a(o, m), l = new a(l, m);
+    let A = !1;
+    e: for (const E of o.set) {
+      for (const S of l.set) {
+        const g = s(E, S, m);
+        if (A = A || g !== null, g)
+          continue e;
+      }
+      if (A)
+        return !1;
+    }
+    return !0;
+  }, c = [new u(">=0.0.0-0")], f = [new u(">=0.0.0")], s = (o, l, m) => {
+    if (o === l)
+      return !0;
+    if (o.length === 1 && o[0].semver === i) {
+      if (l.length === 1 && l[0].semver === i)
+        return !0;
+      m.includePrerelease ? o = c : o = f;
+    }
+    if (l.length === 1 && l[0].semver === i) {
+      if (m.includePrerelease)
+        return !0;
+      l = f;
+    }
+    const A = /* @__PURE__ */ new Set();
+    let E, S;
+    for (const N of o)
+      N.operator === ">" || N.operator === ">=" ? E = t(E, N, m) : N.operator === "<" || N.operator === "<=" ? S = e(S, N, m) : A.add(N.semver);
+    if (A.size > 1)
+      return null;
+    let g;
+    if (E && S) {
+      if (g = n(E.semver, S.semver, m), g > 0)
+        return null;
+      if (g === 0 && (E.operator !== ">=" || S.operator !== "<="))
+        return null;
+    }
+    for (const N of A) {
+      if (E && !r(N, String(E), m) || S && !r(N, String(S), m))
+        return null;
+      for (const x of l)
+        if (!r(N, String(x), m))
+          return !1;
+      return !0;
+    }
+    let G, w, y, F, C = S && !m.includePrerelease && S.semver.prerelease.length ? S.semver : !1, D = E && !m.includePrerelease && E.semver.prerelease.length ? E.semver : !1;
+    C && C.prerelease.length === 1 && S.operator === "<" && C.prerelease[0] === 0 && (C = !1);
+    for (const N of l) {
+      if (F = F || N.operator === ">" || N.operator === ">=", y = y || N.operator === "<" || N.operator === "<=", E) {
+        if (D && N.semver.prerelease && N.semver.prerelease.length && N.semver.major === D.major && N.semver.minor === D.minor && N.semver.patch === D.patch && (D = !1), N.operator === ">" || N.operator === ">=") {
+          if (G = t(E, N, m), G === N && G !== E)
+            return !1;
+        } else if (E.operator === ">=" && !r(E.semver, String(N), m))
+          return !1;
+      }
+      if (S) {
+        if (C && N.semver.prerelease && N.semver.prerelease.length && N.semver.major === C.major && N.semver.minor === C.minor && N.semver.patch === C.patch && (C = !1), N.operator === "<" || N.operator === "<=") {
+          if (w = e(S, N, m), w === N && w !== S)
+            return !1;
+        } else if (S.operator === "<=" && !r(S.semver, String(N), m))
+          return !1;
+      }
+      if (!N.operator && (S || E) && g !== 0)
+        return !1;
+    }
+    return !(E && y && !S && g !== 0 || S && F && !E && g !== 0 || D || C);
+  }, t = (o, l, m) => {
+    if (!o)
+      return l;
+    const A = n(o.semver, l.semver, m);
+    return A > 0 ? o : A < 0 || l.operator === ">" && o.operator === ">=" ? l : o;
+  }, e = (o, l, m) => {
+    if (!o)
+      return l;
+    const A = n(o.semver, l.semver, m);
+    return A < 0 ? o : A > 0 || l.operator === "<" && o.operator === "<=" ? l : o;
+  };
+  return be = p, be;
+}
+var Me, Vr;
+function Rt() {
+  if (Vr) return Me;
+  Vr = 1;
+  const a = M(), u = k(), i = j(), r = xr(), n = V(), p = kr(), c = Br(), f = Yr(), s = Wr(), t = zr(), e = Kr(), o = Zr(), l = Jr(), m = U(), A = Qr(), E = et(), S = ke(), g = rt(), G = tt(), w = Y(), y = Be(), F = br(), C = Mr(), D = Ye(), N = We(), x = Hr(), K = st(), Z = W(), J = X(), Q = z(), R = it(), h = at(), I = ot(), $ = ct(), v = ut(), d = ze(), L = lt(), T = ft(), O = ht(), q = Et(), _ = pt();
+  return Me = {
+    parse: n,
+    valid: p,
+    clean: c,
+    inc: f,
+    diff: s,
+    major: t,
+    minor: e,
+    patch: o,
+    prerelease: l,
+    compare: m,
+    rcompare: A,
+    compareLoose: E,
+    compareBuild: S,
+    sort: g,
+    rsort: G,
+    gt: w,
+    lt: y,
+    eq: F,
+    neq: C,
+    gte: D,
+    lte: N,
+    cmp: x,
+    coerce: K,
+    Comparator: Z,
+    Range: J,
+    satisfies: Q,
+    toComparators: R,
+    maxSatisfying: h,
+    minSatisfying: I,
+    minVersion: $,
+    validRange: v,
+    outside: d,
+    gtr: L,
+    ltr: T,
+    intersects: O,
+    simplifyRange: q,
+    subset: _,
+    SemVer: i,
+    re: a.re,
+    src: a.src,
+    tokens: a.t,
+    SEMVER_SPEC_VERSION: u.SEMVER_SPEC_VERSION,
+    RELEASE_TYPES: u.RELEASE_TYPES,
+    compareIdentifiers: r.compareIdentifiers,
+    rcompareIdentifiers: r.rcompareIdentifiers
+  }, Me;
+}
+var mt = Rt();
+export {
+  mt as s
+};