@storybook/cli 0.0.0-pr-31987-sha-64db30c4 → 0.0.0-pr-31819-sha-e4987461

package/dist/_node-chunks/chunk-Z5JDYKZQ.js

@@ -0,0 +1,1080 @@
+import CJS_COMPAT_NODE_URL from 'node:url';
+import CJS_COMPAT_NODE_PATH from 'node:path';
+import CJS_COMPAT_NODE_MODULE from "node:module";
+
+const __filename = CJS_COMPAT_NODE_URL.fileURLToPath(import.meta.url);
+const __dirname = CJS_COMPAT_NODE_PATH.dirname(__filename);
+const require = CJS_COMPAT_NODE_MODULE.createRequire(import.meta.url);
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  a as o,
+  c as p
+} from "./chunk-DIYAIJOC.js";
+
+// ../../node_modules/semver/internal/constants.js
+var v = p((Ji, he) => {
+  "use strict";
+  var tt = "2.0.0", st = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+  9007199254740991, it = 16, nt = 250, ot = [
+    "major",
+    "premajor",
+    "minor",
+    "preminor",
+    "patch",
+    "prepatch",
+    "prerelease"
+  ];
+  he.exports = {
+    MAX_LENGTH: 256,
+    MAX_SAFE_COMPONENT_LENGTH: it,
+    MAX_SAFE_BUILD_LENGTH: nt,
+    MAX_SAFE_INTEGER: st,
+    RELEASE_TYPES: ot,
+    SEMVER_SPEC_VERSION: tt,
+    FLAG_INCLUDE_PRERELEASE: 1,
+    FLAG_LOOSE: 2
+  };
+});
+
+// ../../node_modules/semver/internal/debug.js
+var x = p((Qi, pe) => {
+  "use strict";
+  var ct = typeof process == "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...t) => console.error("SEMVER", ...t) : () => {
+  };
+  pe.exports = ct;
+});
+
+// ../../node_modules/semver/internal/re.js
+var g = p((q, Re) => {
+  "use strict";
+  var {
+    MAX_SAFE_COMPONENT_LENGTH: z,
+    MAX_SAFE_BUILD_LENGTH: lt,
+    MAX_LENGTH: at
+  } = v(), ut = x();
+  q = Re.exports = {};
+  var Et = q.re = [], ft = q.safeRe = [], l = q.src = [], ht = q.safeSrc = [], a = q.t = {}, pt = 0, K = "[a-zA-Z0-9-]", Rt = [
+    ["\\s", 1],
+    ["\\d", at],
+    [K, lt]
+  ], $t = /* @__PURE__ */ o((t) => {
+    for (let [e, r] of Rt)
+      t = t.split(`${e}*`).join(`${e}{0,${r}}`).split(`${e}+`).join(`${e}{1,${r}}`);
+    return t;
+  }, "makeSafeRegex"), R = /* @__PURE__ */ o((t, e, r) => {
+    let s = $t(e), i = pt++;
+    ut(t, i, e), a[t] = i, l[i] = e, ht[i] = s, Et[i] = new RegExp(e, r ? "g" : void 0), ft[i] = new RegExp(s, r ? "g" : void 0);
+  }, "createToken");
+  R("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+  R("NUMERICIDENTIFIERLOOSE", "\\d+");
+  R("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${K}*`);
+  R("MAINVERSION", `(${l[a.NUMERICIDENTIFIER]})\\.(${l[a.NUMERICIDENTIFIER]})\\.(${l[a.NUMERICIDENTIFIER]})`);
+  R("MAINVERSIONLOOSE", `(${l[a.NUMERICIDENTIFIERLOOSE]})\\.(${l[a.NUMERICIDENTIFIERLOOSE]})\\.(${l[a.NUMERICIDENTIFIERLOOSE]})`);
+  R("PRERELEASEIDENTIFIER", `(?:${l[a.NONNUMERICIDENTIFIER]}|${l[a.NUMERICIDENTIFIER]})`);
+  R("PRERELEASEIDENTIFIERLOOSE", `(?:${l[a.NONNUMERICIDENTIFIER]}|${l[a.NUMERICIDENTIFIERLOOSE]})`);
+  R("PRERELEASE", `(?:-(${l[a.PRERELEASEIDENTIFIER]}(?:\\.${l[a.PRERELEASEIDENTIFIER]})*))`);
+  R("PRERELEASELOOSE", `(?:-?(${l[a.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${l[a.PRERELEASEIDENTIFIERLOOSE]})*))`);
+  R("BUILDIDENTIFIER", `${K}+`);
+  R("BUILD", `(?:\\+(${l[a.BUILDIDENTIFIER]}(?:\\.${l[a.BUILDIDENTIFIER]})*))`);
+  R("FULLPLAIN", `v?${l[a.MAINVERSION]}${l[a.PRERELEASE]}?${l[a.BUILD]}?`);
+  R("FULL", `^${l[a.FULLPLAIN]}$`);
+  R("LOOSEPLAIN", `[v=\\s]*${l[a.MAINVERSIONLOOSE]}${l[a.PRERELEASELOOSE]}?${l[a.BUILD]}?`);
+  R("LOOSE", `^${l[a.LOOSEPLAIN]}$`);
+  R("GTLT", "((?:<|>)?=?)");
+  R("XRANGEIDENTIFIERLOOSE", `${l[a.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+  R("XRANGEIDENTIFIER", `${l[a.NUMERICIDENTIFIER]}|x|X|\\*`);
+  R("XRANGEPLAIN", `[v=\\s]*(${l[a.XRANGEIDENTIFIER]})(?:\\.(${l[a.XRANGEIDENTIFIER]})(?:\\.(${l[a.XRANGEIDENTIFIER]})(?:${l[a.PRERELEASE]})?${l[a.BUILD]}?)?)?`);
+  R("XRANGEPLAINLOOSE", `[v=\\s]*(${l[a.XRANGEIDENTIFIERLOOSE]})(?:\\.(${l[a.XRANGEIDENTIFIERLOOSE]})(?:\\.(${l[a.XRANGEIDENTIFIERLOOSE]})(?:${l[a.PRERELEASELOOSE]})?${l[a.BUILD]}?)?)?`);
+  R("XRANGE", `^${l[a.GTLT]}\\s*${l[a.XRANGEPLAIN]}$`);
+  R("XRANGELOOSE", `^${l[a.GTLT]}\\s*${l[a.XRANGEPLAINLOOSE]}$`);
+  R("COERCEPLAIN", `(^|[^\\d])(\\d{1,${z}})(?:\\.(\\d{1,${z}}))?(?:\\.(\\d{1,${z}}))?`);
+  R("COERCE", `${l[a.COERCEPLAIN]}(?:$|[^\\d])`);
+  R("COERCEFULL", l[a.COERCEPLAIN] + `(?:${l[a.PRERELEASE]})?(?:${l[a.BUILD]})?(?:$|[^\\d])`);
+  R("COERCERTL", l[a.COERCE], !0);
+  R("COERCERTLFULL", l[a.COERCEFULL], !0);
+  R("LONETILDE", "(?:~>?)");
+  R("TILDETRIM", `(\\s*)${l[a.LONETILDE]}\\s+`, !0);
+  q.tildeTrimReplace = "$1~";
+  R("TILDE", `^${l[a.LONETILDE]}${l[a.XRANGEPLAIN]}$`);
+  R("TILDELOOSE", `^${l[a.LONETILDE]}${l[a.XRANGEPLAINLOOSE]}$`);
+  R("LONECARET", "(?:\\^)");
+  R("CARETTRIM", `(\\s*)${l[a.LONECARET]}\\s+`, !0);
+  q.caretTrimReplace = "$1^";
+  R("CARET", `^${l[a.LONECARET]}${l[a.XRANGEPLAIN]}$`);
+  R("CARETLOOSE", `^${l[a.LONECARET]}${l[a.XRANGEPLAINLOOSE]}$`);
+  R("COMPARATORLOOSE", `^${l[a.GTLT]}\\s*(${l[a.LOOSEPLAIN]})$|^$`);
+  R("COMPARATOR", `^${l[a.GTLT]}\\s*(${l[a.FULLPLAIN]})$|^$`);
+  R("COMPARATORTRIM", `(\\s*)${l[a.GTLT]}\\s*(${l[a.LOOSEPLAIN]}|${l[a.XRANGEPLAIN]})`, !0);
+  q.comparatorTrimReplace = "$1$2$3";
+  R("HYPHENRANGE", `^\\s*(${l[a.XRANGEPLAIN]})\\s+-\\s+(${l[a.XRANGEPLAIN]})\\s*$`);
+  R("HYPHENRANGELOOSE", `^\\s*(${l[a.XRANGEPLAINLOOSE]})\\s+-\\s+(${l[a.XRANGEPLAINLOOSE]})\\s*$`);
+  R("STAR", "(<|>)?=?\\s*\\*");
+  R("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+  R("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+});
+
+// ../../node_modules/semver/internal/parse-options.js
+var j = p((rn, $e) => {
+  "use strict";
+  var mt = Object.freeze({ loose: !0 }), It = Object.freeze({}), Lt = /* @__PURE__ */ o((t) => t ? typeof t != "object" ? mt : t : It, "parseOptions");
+  $e.exports = Lt;
+});
+
+// ../../node_modules/semver/internal/identifiers.js
+var Z = p((sn, Le) => {
+  "use strict";
+  var me = /^[0-9]+$/, Ie = /* @__PURE__ */ o((t, e) => {
+    let r = me.test(t), s = me.test(e);
+    return r && s && (t = +t, e = +e), t === e ? 0 : r && !s ? -1 : s && !r ? 1 : t < e ? -1 : 1;
+  }, "compareIdentifiers"), Nt = /* @__PURE__ */ o((t, e) => Ie(e, t), "rcompareIdentifiers");
+  Le.exports = {
+    compareIdentifiers: Ie,
+    rcompareIdentifiers: Nt
+  };
+});
+
+// ../../node_modules/semver/classes/semver.js
+var N = p((on, Oe) => {
+  "use strict";
+  var X = x(), { MAX_LENGTH: Ne, MAX_SAFE_INTEGER: U } = v(), { safeRe: V, t: _ } = g(), Ot = j(), { compareIdentifiers: P } = Z(), J = class t {
+    static {
+      o(this, "SemVer");
+    }
+    constructor(e, r) {
+      if (r = Ot(r), e instanceof t) {
+        if (e.loose === !!r.loose && e.includePrerelease === !!r.includePrerelease)
+          return e;
+        e = e.version;
+      } else if (typeof e != "string")
+        throw new TypeError(`Invalid version. Must be a string. Got type "${typeof e}".`);
+      if (e.length > Ne)
+        throw new TypeError(
+          `version is longer than ${Ne} characters`
+        );
+      X("SemVer", e, r), this.options = r, this.loose = !!r.loose, this.includePrerelease = !!r.includePrerelease;
+      let s = e.trim().match(r.loose ? V[_.LOOSE] : V[_.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 > U || this.major < 0)
+        throw new TypeError("Invalid major version");
+      if (this.minor > U || this.minor < 0)
+        throw new TypeError("Invalid minor version");
+      if (this.patch > U || this.patch < 0)
+        throw new TypeError("Invalid patch version");
+      s[4] ? this.prerelease = s[4].split(".").map((i) => {
+        if (/^[0-9]+$/.test(i)) {
+          let n = +i;
+          if (n >= 0 && n < U)
+            return n;
+        }
+        return i;
+      }) : 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 (X("SemVer.compare", this.version, this.options, e), !(e instanceof t)) {
+        if (typeof e == "string" && e === this.version)
+          return 0;
+        e = new t(e, this.options);
+      }
+      return e.version === this.version ? 0 : this.compareMain(e) || this.comparePre(e);
+    }
+    compareMain(e) {
+      return e instanceof t || (e = new t(e, this.options)), P(this.major, e.major) || P(this.minor, e.minor) || P(this.patch, e.patch);
+    }
+    comparePre(e) {
+      if (e instanceof t || (e = new t(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 {
+        let s = this.prerelease[r], i = e.prerelease[r];
+        if (X("prerelease compare", r, s, i), s === void 0 && i === void 0)
+          return 0;
+        if (i === void 0)
+          return 1;
+        if (s === void 0)
+          return -1;
+        if (s === i)
+          continue;
+        return P(s, i);
+      } while (++r);
+    }
+    compareBuild(e) {
+      e instanceof t || (e = new t(e, this.options));
+      let r = 0;
+      do {
+        let s = this.build[r], i = e.build[r];
+        if (X("build compare", r, s, i), s === void 0 && i === void 0)
+          return 0;
+        if (i === void 0)
+          return 1;
+        if (s === void 0)
+          return -1;
+        if (s === i)
+          continue;
+        return P(s, i);
+      } while (++r);
+    }
+    // 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(e, r, s) {
+      if (e.startsWith("pre")) {
+        if (!r && s === !1)
+          throw new Error("invalid increment argument: identifier is empty");
+        if (r) {
+          let i = `-${r}`.match(this.options.loose ? V[_.PRERELEASELOOSE] : V[_.PRERELEASE]);
+          if (!i || i[1] !== r)
+            throw new Error(`invalid identifier: ${r}`);
+        }
+      }
+      switch (e) {
+        case "premajor":
+          this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", r, s);
+          break;
+        case "preminor":
+          this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", r, s);
+          break;
+        case "prepatch":
+          this.prerelease.length = 0, this.inc("patch", r, s), this.inc("pre", r, s);
+          break;
+        // If the input is a non-prerelease version, this acts the same as
+        // prepatch.
+        case "prerelease":
+          this.prerelease.length === 0 && this.inc("patch", r, s), this.inc("pre", r, s);
+          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": {
+          let i = Number(s) ? 1 : 0;
+          if (this.prerelease.length === 0)
+            this.prerelease = [i];
+          else {
+            let n = this.prerelease.length;
+            for (; --n >= 0; )
+              typeof this.prerelease[n] == "number" && (this.prerelease[n]++, n = -2);
+            if (n === -1) {
+              if (r === this.prerelease.join(".") && s === !1)
+                throw new Error("invalid increment argument: identifier already exists");
+              this.prerelease.push(i);
+            }
+          }
+          if (r) {
+            let n = [r, i];
+            s === !1 && (n = [r]), P(this.prerelease[0], r) === 0 ? isNaN(this.prerelease[1]) && (this.prerelease = n) : this.prerelease = n;
+          }
+          break;
+        }
+        default:
+          throw new Error(`invalid increment argument: ${e}`);
+      }
+      return this.raw = this.format(), this.build.length && (this.raw += `+${this.build.join(".")}`), this;
+    }
+  };
+  Oe.exports = J;
+});
+
+// ../../node_modules/semver/functions/parse.js
+var w = p((ln, de) => {
+  "use strict";
+  var Se = N(), St = /* @__PURE__ */ o((t, e, r = !1) => {
+    if (t instanceof Se)
+      return t;
+    try {
+      return new Se(t, e);
+    } catch (s) {
+      if (!r)
+        return null;
+      throw s;
+    }
+  }, "parse");
+  de.exports = St;
+});
+
+// ../../node_modules/semver/functions/valid.js
+var Te = p((un, Ae) => {
+  "use strict";
+  var dt = w(), At = /* @__PURE__ */ o((t, e) => {
+    let r = dt(t, e);
+    return r ? r.version : null;
+  }, "valid");
+  Ae.exports = At;
+});
+
+// ../../node_modules/semver/functions/clean.js
+var we = p((fn, qe) => {
+  "use strict";
+  var Tt = w(), qt = /* @__PURE__ */ o((t, e) => {
+    let r = Tt(t.trim().replace(/^[=v]+/, ""), e);
+    return r ? r.version : null;
+  }, "clean");
+  qe.exports = qt;
+});
+
+// ../../node_modules/semver/functions/inc.js
+var ve = p((pn, Pe) => {
+  "use strict";
+  var ge = N(), wt = /* @__PURE__ */ o((t, e, r, s, i) => {
+    typeof r == "string" && (i = s, s = r, r = void 0);
+    try {
+      return new ge(
+        t instanceof ge ? t.version : t,
+        r
+      ).inc(e, s, i).version;
+    } catch {
+      return null;
+    }
+  }, "inc");
+  Pe.exports = wt;
+});
+
+// ../../node_modules/semver/functions/diff.js
+var De = p(($n, Ce) => {
+  "use strict";
+  var xe = w(), gt = /* @__PURE__ */ o((t, e) => {
+    let r = xe(t, null, !0), s = xe(e, null, !0), i = r.compare(s);
+    if (i === 0)
+      return null;
+    let n = i > 0, c = n ? r : s, u = n ? s : r, E = !!c.prerelease.length;
+    if (!!u.prerelease.length && !E) {
+      if (!u.patch && !u.minor)
+        return "major";
+      if (u.compareMain(c) === 0)
+        return u.minor && !u.patch ? "minor" : "patch";
+    }
+    let m = E ? "pre" : "";
+    return r.major !== s.major ? m + "major" : r.minor !== s.minor ? m + "minor" : r.patch !== s.patch ? m + "patch" : "prerelease";
+  }, "diff");
+  Ce.exports = gt;
+});
+
+// ../../node_modules/semver/functions/major.js
+var ye = p((In, Ge) => {
+  "use strict";
+  var Pt = N(), vt = /* @__PURE__ */ o((t, e) => new Pt(t, e).major, "major");
+  Ge.exports = vt;
+});
+
+// ../../node_modules/semver/functions/minor.js
+var je = p((Nn, Fe) => {
+  "use strict";
+  var xt = N(), Ct = /* @__PURE__ */ o((t, e) => new xt(t, e).minor, "minor");
+  Fe.exports = Ct;
+});
+
+// ../../node_modules/semver/functions/patch.js
+var Ue = p((Sn, Xe) => {
+  "use strict";
+  var Dt = N(), Gt = /* @__PURE__ */ o((t, e) => new Dt(t, e).patch, "patch");
+  Xe.exports = Gt;
+});
+
+// ../../node_modules/semver/functions/prerelease.js
+var _e = p((An, Ve) => {
+  "use strict";
+  var yt = w(), Ft = /* @__PURE__ */ o((t, e) => {
+    let r = yt(t, e);
+    return r && r.prerelease.length ? r.prerelease : null;
+  }, "prerelease");
+  Ve.exports = Ft;
+});
+
+// ../../node_modules/semver/functions/compare.js
+var A = p((qn, He) => {
+  "use strict";
+  var be = N(), jt = /* @__PURE__ */ o((t, e, r) => new be(t, r).compare(new be(e, r)), "compare");
+  He.exports = jt;
+});
+
+// ../../node_modules/semver/functions/rcompare.js
+var Me = p((gn, ke) => {
+  "use strict";
+  var Xt = A(), Ut = /* @__PURE__ */ o((t, e, r) => Xt(e, t, r), "rcompare");
+  ke.exports = Ut;
+});
+
+// ../../node_modules/semver/functions/compare-loose.js
+var We = p((vn, Ye) => {
+  "use strict";
+  var Vt = A(), _t = /* @__PURE__ */ o((t, e) => Vt(t, e, !0), "compareLoose");
+  Ye.exports = _t;
+});
+
+// ../../node_modules/semver/functions/compare-build.js
+var b = p((Cn, ze) => {
+  "use strict";
+  var Be = N(), bt = /* @__PURE__ */ o((t, e, r) => {
+    let s = new Be(t, r), i = new Be(e, r);
+    return s.compare(i) || s.compareBuild(i);
+  }, "compareBuild");
+  ze.exports = bt;
+});
+
+// ../../node_modules/semver/functions/sort.js
+var Ze = p((Gn, Ke) => {
+  "use strict";
+  var Ht = b(), kt = /* @__PURE__ */ o((t, e) => t.sort((r, s) => Ht(r, s, e)), "sort");
+  Ke.exports = kt;
+});
+
+// ../../node_modules/semver/functions/rsort.js
+var Qe = p((Fn, Je) => {
+  "use strict";
+  var Mt = b(), Yt = /* @__PURE__ */ o((t, e) => t.sort((r, s) => Mt(s, r, e)), "rsort");
+  Je.exports = Yt;
+});
+
+// ../../node_modules/semver/functions/gt.js
+var C = p((Xn, er) => {
+  "use strict";
+  var Wt = A(), Bt = /* @__PURE__ */ o((t, e, r) => Wt(t, e, r) > 0, "gt");
+  er.exports = Bt;
+});
+
+// ../../node_modules/semver/functions/lt.js
+var H = p((Vn, rr) => {
+  "use strict";
+  var zt = A(), Kt = /* @__PURE__ */ o((t, e, r) => zt(t, e, r) < 0, "lt");
+  rr.exports = Kt;
+});
+
+// ../../node_modules/semver/functions/eq.js
+var Q = p((bn, tr) => {
+  "use strict";
+  var Zt = A(), Jt = /* @__PURE__ */ o((t, e, r) => Zt(t, e, r) === 0, "eq");
+  tr.exports = Jt;
+});
+
+// ../../node_modules/semver/functions/neq.js
+var ee = p((kn, sr) => {
+  "use strict";
+  var Qt = A(), es = /* @__PURE__ */ o((t, e, r) => Qt(t, e, r) !== 0, "neq");
+  sr.exports = es;
+});
+
+// ../../node_modules/semver/functions/gte.js
+var k = p((Yn, ir) => {
+  "use strict";
+  var rs = A(), ts = /* @__PURE__ */ o((t, e, r) => rs(t, e, r) >= 0, "gte");
+  ir.exports = ts;
+});
+
+// ../../node_modules/semver/functions/lte.js
+var M = p((Bn, nr) => {
+  "use strict";
+  var ss = A(), is = /* @__PURE__ */ o((t, e, r) => ss(t, e, r) <= 0, "lte");
+  nr.exports = is;
+});
+
+// ../../node_modules/semver/functions/cmp.js
+var re = p((Kn, or) => {
+  "use strict";
+  var ns = Q(), os = ee(), cs = C(), ls = k(), as = H(), us = M(), Es = /* @__PURE__ */ o((t, e, r, s) => {
+    switch (e) {
+      case "===":
+        return typeof t == "object" && (t = t.version), typeof r == "object" && (r = r.version), t === r;
+      case "!==":
+        return typeof t == "object" && (t = t.version), typeof r == "object" && (r = r.version), t !== r;
+      case "":
+      case "=":
+      case "==":
+        return ns(t, r, s);
+      case "!=":
+        return os(t, r, s);
+      case ">":
+        return cs(t, r, s);
+      case ">=":
+        return ls(t, r, s);
+      case "<":
+        return as(t, r, s);
+      case "<=":
+        return us(t, r, s);
+      default:
+        throw new TypeError(`Invalid operator: ${e}`);
+    }
+  }, "cmp");
+  or.exports = Es;
+});
+
+// ../../node_modules/semver/functions/coerce.js
+var lr = p((Jn, cr) => {
+  "use strict";
+  var fs = N(), hs = w(), { safeRe: Y, t: W } = g(), ps = /* @__PURE__ */ o((t, e) => {
+    if (t instanceof fs)
+      return t;
+    if (typeof t == "number" && (t = String(t)), typeof t != "string")
+      return null;
+    e = e || {};
+    let r = null;
+    if (!e.rtl)
+      r = t.match(e.includePrerelease ? Y[W.COERCEFULL] : Y[W.COERCE]);
+    else {
+      let E = e.includePrerelease ? Y[W.COERCERTLFULL] : Y[W.COERCERTL], $;
+      for (; ($ = E.exec(t)) && (!r || r.index + r[0].length !== t.length); )
+        (!r || $.index + $[0].length !== r.index + r[0].length) && (r = $), E.lastIndex = $.index + $[1].length + $[2].length;
+      E.lastIndex = -1;
+    }
+    if (r === null)
+      return null;
+    let s = r[2], i = r[3] || "0", n = r[4] || "0", c = e.includePrerelease && r[5] ? `-${r[5]}` : "", u = e.includePrerelease && r[6] ? `+${r[6]}` : "";
+    return hs(`${s}.${i}.${n}${c}${u}`, e);
+  }, "coerce");
+  cr.exports = ps;
+});
+
+// ../../node_modules/semver/internal/lrucache.js
+var ur = p((eo, ar) => {
+  "use strict";
+  var te = class {
+    static {
+      o(this, "LRUCache");
+    }
+    constructor() {
+      this.max = 1e3, this.map = /* @__PURE__ */ new Map();
+    }
+    get(e) {
+      let r = this.map.get(e);
+      if (r !== void 0)
+        return this.map.delete(e), this.map.set(e, r), r;
+    }
+    delete(e) {
+      return this.map.delete(e);
+    }
+    set(e, r) {
+      if (!this.delete(e) && r !== void 0) {
+        if (this.map.size >= this.max) {
+          let i = this.map.keys().next().value;
+          this.delete(i);
+        }
+        this.map.set(e, r);
+      }
+      return this;
+    }
+  };
+  ar.exports = te;
+});
+
+// ../../node_modules/semver/classes/range.js
+var T = p((to, pr) => {
+  "use strict";
+  var Rs = /\s+/g, se = class t {
+    static {
+      o(this, "Range");
+    }
+    constructor(e, r) {
+      if (r = ms(r), e instanceof t)
+        return e.loose === !!r.loose && e.includePrerelease === !!r.includePrerelease ? e : new t(e.raw, r);
+      if (e instanceof ie)
+        return this.raw = e.value, this.set = [[e]], this.formatted = void 0, this;
+      if (this.options = r, this.loose = !!r.loose, this.includePrerelease = !!r.includePrerelease, this.raw = e.trim().replace(Rs, " "), this.set = this.raw.split("||").map((s) => this.parseRange(s.trim())).filter((s) => s.length), !this.set.length)
+        throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+      if (this.set.length > 1) {
+        let s = this.set[0];
+        if (this.set = this.set.filter((i) => !fr(i[0])), this.set.length === 0)
+          this.set = [s];
+        else if (this.set.length > 1) {
+          for (let i of this.set)
+            if (i.length === 1 && As(i[0])) {
+              this.set = [i];
+              break;
+            }
+        }
+      }
+      this.formatted = void 0;
+    }
+    get range() {
+      if (this.formatted === void 0) {
+        this.formatted = "";
+        for (let e = 0; e < this.set.length; e++) {
+          e > 0 && (this.formatted += "||");
+          let r = this.set[e];
+          for (let s = 0; s < r.length; s++)
+            s > 0 && (this.formatted += " "), this.formatted += r[s].toString().trim();
+        }
+      }
+      return this.formatted;
+    }
+    format() {
+      return this.range;
+    }
+    toString() {
+      return this.range;
+    }
+    parseRange(e) {
+      let s = ((this.options.includePrerelease && Ss) | (this.options.loose && ds)) + ":" + e, i = Er.get(s);
+      if (i)
+        return i;
+      let n = this.options.loose, c = n ? d[O.HYPHENRANGELOOSE] : d[O.HYPHENRANGE];
+      e = e.replace(c, Gs(this.options.includePrerelease)), I("hyphen replace", e), e = e.replace(d[O.COMPARATORTRIM], Ls), I("comparator trim", e), e = e.replace(d[O.TILDETRIM], Ns), I("tilde trim", e), e = e.replace(d[O.CARETTRIM], Os), I("caret trim", e);
+      let u = e.split(" ").map((f) => Ts(f, this.options)).join(" ").split(/\s+/).map((f) => Ds(f, this.options));
+      n && (u = u.filter((f) => (I("loose invalid filter", f, this.options), !!f.match(d[O.COMPARATORLOOSE])))), I("range list", u);
+      let E = /* @__PURE__ */ new Map(), $ = u.map((f) => new ie(f, this.options));
+      for (let f of $) {
+        if (fr(f))
+          return [f];
+        E.set(f.value, f);
+      }
+      E.size > 1 && E.has("") && E.delete("");
+      let m = [...E.values()];
+      return Er.set(s, m), m;
+    }
+    intersects(e, r) {
+      if (!(e instanceof t))
+        throw new TypeError("a Range is required");
+      return this.set.some((s) => hr(s, r) && e.set.some((i) => hr(i, r) && s.every((n) => i.every((c) => n.intersects(c, r)))));
+    }
+    // if ANY of the sets match ALL of its comparators, then pass
+    test(e) {
+      if (!e)
+        return !1;
+      if (typeof e == "string")
+        try {
+          e = new Is(e, this.options);
+        } catch {
+          return !1;
+        }
+      for (let r = 0; r < this.set.length; r++)
+        if (ys(this.set[r], e, this.options))
+          return !0;
+      return !1;
+    }
+  };
+  pr.exports = se;
+  var $s = ur(), Er = new $s(), ms = j(), ie = D(), I = x(), Is = N(), {
+    safeRe: d,
+    t: O,
+    comparatorTrimReplace: Ls,
+    tildeTrimReplace: Ns,
+    caretTrimReplace: Os
+  } = g(), { FLAG_INCLUDE_PRERELEASE: Ss, FLAG_LOOSE: ds } = v(), fr = /* @__PURE__ */ o((t) => t.value === "<0.0.0-0", "isNullSet"), As = /* @__PURE__ */ o((t) => t.value === "", "isAny"), hr = /* @__PURE__ */ o((t, e) => {
+    let r = !0, s = t.slice(), i = s.pop();
+    for (; r && s.length; )
+      r = s.every((n) => i.intersects(n, e)), i = s.pop();
+    return r;
+  }, "isSatisfiable"), Ts = /* @__PURE__ */ o((t, e) => (I("comp", t, e), t = gs(t, e), I("caret", t), t = qs(t, e), I("tildes", t), t = vs(t, e), I("xrange", t), t = Cs(t, e), I("stars", t), t), "parseComparator"), S = /* @__PURE__ */ o((t) => !t || t.toLowerCase() === "x" || t === "*", "isX"), qs = /* @__PURE__ */ o((t, e) => t.trim().split(/\s+/).map((r) => ws(r, e)).join(" "), "replaceTildes"), ws = /* @__PURE__ */ o((t, e) => {
+    let r = e.loose ? d[O.TILDELOOSE] : d[O.TILDE];
+    return t.replace(r, (s, i, n, c, u) => {
+      I("tilde", t, s, i, n, c, u);
+      let E;
+      return S(i) ? E = "" : S(n) ? E = `>=${i}.0.0 <${+i + 1}.0.0-0` : S(c) ? E = `>=${i}.${n}.0 <${i}.${+n + 1}.0-0` : u ? (I("replaceTilde pr", u), E = `>=${i}.${n}.${c}-${u} <${i}.${+n + 1}.0-0`) : E = `>=${i}.${n}.${c} <${i}.${+n + 1}.0-0`, I("tilde return", E), E;
+    });
+  }, "replaceTilde"), gs = /* @__PURE__ */ o((t, e) => t.trim().split(/\s+/).map((r) => Ps(r, e)).join(" "), "replaceCarets"), Ps = /* @__PURE__ */ o((t, e) => {
+    I("caret", t, e);
+    let r = e.loose ? d[O.CARETLOOSE] : d[O.CARET], s = e.includePrerelease ? "-0" : "";
+    return t.replace(r, (i, n, c, u, E) => {
+      I("caret", t, i, n, c, u, E);
+      let $;
+      return S(n) ? $ = "" : S(c) ? $ = `>=${n}.0.0${s} <${+n + 1}.0.0-0` : S(u) ? n === "0" ? $ = `>=${n}.${c}.0${s} <${n}.${+c + 1}.0-0` : $ = `>=${n}.${c}.0${s} <${+n + 1}.0.0-0` : E ? (I("replaceCaret pr", E), n === "0" ? c === "0" ? $ = `>=${n}.${c}.${u}-${E} <${n}.${c}.${+u + 1}-0` : $ = `>=${n}.${c}.${u}-${E} <${n}.${+c + 1}.0-0` : $ = `>=${n}.${c}.${u}-${E} <${+n + 1}.0.0-0`) : (I("no pr"), n === "0" ? c === "0" ? $ = `>=${n}.${c}.${u}${s} <${n}.${c}.${+u + 1}-0` : $ = `>=${n}.${c}.${u}${s} <${n}.${+c + 1}.0-0` : $ = `>=${n}.${c}.${u} <${+n + 1}.0.0-0`), I("caret return", $), $;
+    });
+  }, "replaceCaret"), vs = /* @__PURE__ */ o((t, e) => (I("replaceXRanges", t, e), t.split(/\s+/).map((r) => xs(r, e)).join(" ")), "replaceXRanges"), xs = /* @__PURE__ */ o((t, e) => {
+    t = t.trim();
+    let r = e.loose ? d[O.XRANGELOOSE] : d[O.XRANGE];
+    return t.replace(r, (s, i, n, c, u, E) => {
+      I("xRange", t, s, i, n, c, u, E);
+      let $ = S(n), m = $ || S(c), f = m || S(u), L = f;
+      return i === "=" && L && (i = ""), E = e.includePrerelease ? "-0" : "", $ ? i === ">" || i === "<" ? s = "<0.0.0-0" : s = "*" : i && L ? (m && (c = 0), u = 0, i === ">" ? (i = ">=", m ? (n = +n + 1, c = 0, u = 0) : (c = +c + 1, u = 0)) : i === "<=" && (i = "<", m ? n = +n + 1 : c = +c + 1), i === "<" && (E = "-0"), s = `${i + n}.${c}.${u}${E}`) : m ? s = `>=${n}.0.0${E} <${+n + 1}.0.0-0` : f && (s = `>=${n}.${c}.0${E} <${n}.${+c + 1}.0-0`), I("xRange return", s), s;
+    });
+  }, "replaceXRange"), Cs = /* @__PURE__ */ o((t, e) => (I("replaceStars", t, e), t.trim().replace(d[O.STAR], "")), "replaceStars"), Ds = /* @__PURE__ */ o((t, e) => (I("replaceGTE0", t, e), t.trim().replace(d[e.includePrerelease ? O.GTE0PRE : O.GTE0], "")), "replaceGTE0"), Gs = /* @__PURE__ */ o((t) => (e, r, s, i, n, c, u, E, $, m, f, L) => (S(s) ? r = "" : S(i) ? r = `>=${s}.0.0${t ? "-0" : ""}` : S(n) ? r = `>=${s}.${i}.0${t ? "-0" : ""}` : c ? r = `>=${r}` : r = `>=${r}${t ? "-0" : ""}`, S($) ? E = "" : S(m) ? E = `<${+$ + 1}.0.0-0` : S(f) ? E = `<${$}.${+m + 1}.0-0` : L ? E = `<=${$}.${m}.${f}-${L}` : t ? E = `<${$}.${m}.${+f + 1}-0` : E = `<=${E}`, `${r} ${E}`.trim()), "hyphenReplace"), ys = /* @__PURE__ */ o((t, e, r) => {
+    for (let s = 0; s < t.length; s++)
+      if (!t[s].test(e))
+        return !1;
+    if (e.prerelease.length && !r.includePrerelease) {
+      for (let s = 0; s < t.length; s++)
+        if (I(t[s].semver), t[s].semver !== ie.ANY && t[s].semver.prerelease.length > 0) {
+          let i = t[s].semver;
+          if (i.major === e.major && i.minor === e.minor && i.patch === e.patch)
+            return !0;
+        }
+      return !1;
+    }
+    return !0;
+  }, "testSet");
+});
+
+// ../../node_modules/semver/classes/comparator.js
+var D = p((io, Nr) => {
+  "use strict";
+  var G = Symbol("SemVer ANY"), ce = class t {
+    static {
+      o(this, "Comparator");
+    }
+    static get ANY() {
+      return G;
+    }
+    constructor(e, r) {
+      if (r = Rr(r), e instanceof t) {
+        if (e.loose === !!r.loose)
+          return e;
+        e = e.value;
+      }
+      e = e.trim().split(/\s+/).join(" "), oe("comparator", e, r), this.options = r, this.loose = !!r.loose, this.parse(e), this.semver === G ? this.value = "" : this.value = this.operator + this.semver.version, oe("comp", this);
+    }
+    parse(e) {
+      let r = this.options.loose ? $r[mr.COMPARATORLOOSE] : $r[mr.COMPARATOR], s = e.match(r);
+      if (!s)
+        throw new TypeError(`Invalid comparator: ${e}`);
+      this.operator = s[1] !== void 0 ? s[1] : "", this.operator === "=" && (this.operator = ""), s[2] ? this.semver = new Ir(s[2], this.options.loose) : this.semver = G;
+    }
+    toString() {
+      return this.value;
+    }
+    test(e) {
+      if (oe("Comparator.test", e, this.options.loose), this.semver === G || e === G)
+        return !0;
+      if (typeof e == "string")
+        try {
+          e = new Ir(e, this.options);
+        } catch {
+          return !1;
+        }
+      return ne(e, this.operator, this.semver, this.options);
+    }
+    intersects(e, r) {
+      if (!(e instanceof t))
+        throw new TypeError("a Comparator is required");
+      return this.operator === "" ? this.value === "" ? !0 : new Lr(e.value, r).test(this.value) : e.operator === "" ? e.value === "" ? !0 : new Lr(this.value, r).test(e.semver) : (r = Rr(r), r.includePrerelease && (this.value === "<0.0.0-0" || e.value === "<0.0.0-0") || !r.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("=") || ne(this.semver, "<", e.semver, r) && this.operator.startsWith(">") && e.operator.startsWith("<") || ne(this.semver, ">", e.semver, r) && this.operator.startsWith("<") && e.operator.startsWith(">")));
+    }
+  };
+  Nr.exports = ce;
+  var Rr = j(), { safeRe: $r, t: mr } = g(), ne = re(), oe = x(), Ir = N(), Lr = T();
+});
+
+// ../../node_modules/semver/functions/satisfies.js
+var y = p((oo, Or) => {
+  "use strict";
+  var Fs = T(), js = /* @__PURE__ */ o((t, e, r) => {
+    try {
+      e = new Fs(e, r);
+    } catch {
+      return !1;
+    }
+    return e.test(t);
+  }, "satisfies");
+  Or.exports = js;
+});
+
+// ../../node_modules/semver/ranges/to-comparators.js
+var dr = p((lo, Sr) => {
+  "use strict";
+  var Xs = T(), Us = /* @__PURE__ */ o((t, e) => new Xs(t, e).set.map((r) => r.map((s) => s.value).join(" ").trim().split(" ")), "toComparators");
+  Sr.exports = Us;
+});
+
+// ../../node_modules/semver/ranges/max-satisfying.js
+var Tr = p((uo, Ar) => {
+  "use strict";
+  var Vs = N(), _s = T(), bs = /* @__PURE__ */ o((t, e, r) => {
+    let s = null, i = null, n = null;
+    try {
+      n = new _s(e, r);
+    } catch {
+      return null;
+    }
+    return t.forEach((c) => {
+      n.test(c) && (!s || i.compare(c) === -1) && (s = c, i = new Vs(s, r));
+    }), s;
+  }, "maxSatisfying");
+  Ar.exports = bs;
+});
+
+// ../../node_modules/semver/ranges/min-satisfying.js
+var wr = p((fo, qr) => {
+  "use strict";
+  var Hs = N(), ks = T(), Ms = /* @__PURE__ */ o((t, e, r) => {
+    let s = null, i = null, n = null;
+    try {
+      n = new ks(e, r);
+    } catch {
+      return null;
+    }
+    return t.forEach((c) => {
+      n.test(c) && (!s || i.compare(c) === 1) && (s = c, i = new Hs(s, r));
+    }), s;
+  }, "minSatisfying");
+  qr.exports = Ms;
+});
+
+// ../../node_modules/semver/ranges/min-version.js
+var vr = p((po, Pr) => {
+  "use strict";
+  var le = N(), Ys = T(), gr = C(), Ws = /* @__PURE__ */ o((t, e) => {
+    t = new Ys(t, e);
+    let r = new le("0.0.0");
+    if (t.test(r) || (r = new le("0.0.0-0"), t.test(r)))
+      return r;
+    r = null;
+    for (let s = 0; s < t.set.length; ++s) {
+      let i = t.set[s], n = null;
+      i.forEach((c) => {
+        let u = new le(c.semver.version);
+        switch (c.operator) {
+          case ">":
+            u.prerelease.length === 0 ? u.patch++ : u.prerelease.push(0), u.raw = u.format();
+          /* fallthrough */
+          case "":
+          case ">=":
+            (!n || gr(u, n)) && (n = u);
+            break;
+          case "<":
+          case "<=":
+            break;
+          /* istanbul ignore next */
+          default:
+            throw new Error(`Unexpected operation: ${c.operator}`);
+        }
+      }), n && (!r || gr(r, n)) && (r = n);
+    }
+    return r && t.test(r) ? r : null;
+  }, "minVersion");
+  Pr.exports = Ws;
+});
+
+// ../../node_modules/semver/ranges/valid.js
+var Cr = p(($o, xr) => {
+  "use strict";
+  var Bs = T(), zs = /* @__PURE__ */ o((t, e) => {
+    try {
+      return new Bs(t, e).range || "*";
+    } catch {
+      return null;
+    }
+  }, "validRange");
+  xr.exports = zs;
+});
+
+// ../../node_modules/semver/ranges/outside.js
+var B = p((Io, Fr) => {
+  "use strict";
+  var Ks = N(), yr = D(), { ANY: Zs } = yr, Js = T(), Qs = y(), Dr = C(), Gr = H(), ei = M(), ri = k(), ti = /* @__PURE__ */ o((t, e, r, s) => {
+    t = new Ks(t, s), e = new Js(e, s);
+    let i, n, c, u, E;
+    switch (r) {
+      case ">":
+        i = Dr, n = ei, c = Gr, u = ">", E = ">=";
+        break;
+      case "<":
+        i = Gr, n = ri, c = Dr, u = "<", E = "<=";
+        break;
+      default:
+        throw new TypeError('Must provide a hilo val of "<" or ">"');
+    }
+    if (Qs(t, e, s))
+      return !1;
+    for (let $ = 0; $ < e.set.length; ++$) {
+      let m = e.set[$], f = null, L = null;
+      if (m.forEach((h) => {
+        h.semver === Zs && (h = new yr(">=0.0.0")), f = f || h, L = L || h, i(h.semver, f.semver, s) ? f = h : c(h.semver, L.semver, s) && (L = h);
+      }), f.operator === u || f.operator === E || (!L.operator || L.operator === u) && n(t, L.semver))
+        return !1;
+      if (L.operator === E && c(t, L.semver))
+        return !1;
+    }
+    return !0;
+  }, "outside");
+  Fr.exports = ti;
+});
+
+// ../../node_modules/semver/ranges/gtr.js
+var Xr = p((No, jr) => {
+  "use strict";
+  var si = B(), ii = /* @__PURE__ */ o((t, e, r) => si(t, e, ">", r), "gtr");
+  jr.exports = ii;
+});
+
+// ../../node_modules/semver/ranges/ltr.js
+var Vr = p((So, Ur) => {
+  "use strict";
+  var ni = B(), oi = /* @__PURE__ */ o((t, e, r) => ni(t, e, "<", r), "ltr");
+  Ur.exports = oi;
+});
+
+// ../../node_modules/semver/ranges/intersects.js
+var Hr = p((To, br) => {
+  "use strict";
+  var _r = T(), ci = /* @__PURE__ */ o((t, e, r) => (t = new _r(t, r), e = new _r(e, r), t.intersects(e, r)), "intersects");
+  br.exports = ci;
+});
+
+// ../../node_modules/semver/ranges/simplify.js
+var Mr = p((wo, kr) => {
+  "use strict";
+  var li = y(), ai = A();
+  kr.exports = (t, e, r) => {
+    let s = [], i = null, n = null, c = t.sort((m, f) => ai(m, f, r));
+    for (let m of c)
+      li(m, e, r) ? (n = m, i || (i = m)) : (n && s.push([i, n]), n = null, i = null);
+    i && s.push([i, null]);
+    let u = [];
+    for (let [m, f] of s)
+      m === f ? u.push(m) : !f && m === c[0] ? u.push("*") : f ? m === c[0] ? u.push(`<=${f}`) : u.push(`${m} - ${f}`) : u.push(`>=${m}`);
+    let E = u.join(" || "), $ = typeof e.raw == "string" ? e.raw : String(e);
+    return E.length < $.length ? E : e;
+  };
+});
+
+// ../../node_modules/semver/ranges/subset.js
+var Zr = p((go, Kr) => {
+  "use strict";
+  var Yr = T(), ue = D(), { ANY: ae } = ue, F = y(), Ee = A(), ui = /* @__PURE__ */ o((t, e, r = {}) => {
+    if (t === e)
+      return !0;
+    t = new Yr(t, r), e = new Yr(e, r);
+    let s = !1;
+    e: for (let i of t.set) {
+      for (let n of e.set) {
+        let c = fi(i, n, r);
+        if (s = s || c !== null, c)
+          continue e;
+      }
+      if (s)
+        return !1;
+    }
+    return !0;
+  }, "subset"), Ei = [new ue(">=0.0.0-0")], Wr = [new ue(">=0.0.0")], fi = /* @__PURE__ */ o((t, e, r) => {
+    if (t === e)
+      return !0;
+    if (t.length === 1 && t[0].semver === ae) {
+      if (e.length === 1 && e[0].semver === ae)
+        return !0;
+      r.includePrerelease ? t = Ei : t = Wr;
+    }
+    if (e.length === 1 && e[0].semver === ae) {
+      if (r.includePrerelease)
+        return !0;
+      e = Wr;
+    }
+    let s = /* @__PURE__ */ new Set(), i, n;
+    for (let h of t)
+      h.operator === ">" || h.operator === ">=" ? i = Br(i, h, r) : h.operator === "<" || h.operator === "<=" ? n = zr(n, h, r) : s.add(h.semver);
+    if (s.size > 1)
+      return null;
+    let c;
+    if (i && n) {
+      if (c = Ee(i.semver, n.semver, r), c > 0)
+        return null;
+      if (c === 0 && (i.operator !== ">=" || n.operator !== "<="))
+        return null;
+    }
+    for (let h of s) {
+      if (i && !F(h, String(i), r) || n && !F(h, String(n), r))
+        return null;
+      for (let rt of e)
+        if (!F(h, String(rt), r))
+          return !1;
+      return !0;
+    }
+    let u, E, $, m, f = n && !r.includePrerelease && n.semver.prerelease.length ? n.semver : !1, L = i && !r.includePrerelease && i.semver.prerelease.length ? i.semver : !1;
+    f && f.prerelease.length === 1 && n.operator === "<" && f.prerelease[0] === 0 && (f = !1);
+    for (let h of e) {
+      if (m = m || h.operator === ">" || h.operator === ">=", $ = $ || h.operator === "<" || h.operator === "<=", i) {
+        if (L && h.semver.prerelease && h.semver.prerelease.length && h.semver.major === L.major && h.semver.minor === L.minor && h.semver.patch === L.patch && (L = !1), h.operator === ">" || h.operator === ">=") {
+          if (u = Br(i, h, r), u === h && u !== i)
+            return !1;
+        } else if (i.operator === ">=" && !F(i.semver, String(h), r))
+          return !1;
+      }
+      if (n) {
+        if (f && h.semver.prerelease && h.semver.prerelease.length && h.semver.major === f.major && h.semver.minor === f.minor && h.semver.patch === f.patch && (f = !1), h.operator === "<" || h.operator === "<=") {
+          if (E = zr(n, h, r), E === h && E !== n)
+            return !1;
+        } else if (n.operator === "<=" && !F(n.semver, String(h), r))
+          return !1;
+      }
+      if (!h.operator && (n || i) && c !== 0)
+        return !1;
+    }
+    return !(i && $ && !n && c !== 0 || n && m && !i && c !== 0 || L || f);
+  }, "simpleSubset"), Br = /* @__PURE__ */ o((t, e, r) => {
+    if (!t)
+      return e;
+    let s = Ee(t.semver, e.semver, r);
+    return s > 0 ? t : s < 0 || e.operator === ">" && t.operator === ">=" ? e : t;
+  }, "higherGT"), zr = /* @__PURE__ */ o((t, e, r) => {
+    if (!t)
+      return e;
+    let s = Ee(t.semver, e.semver, r);
+    return s < 0 ? t : s > 0 || e.operator === "<" && t.operator === "<=" ? e : t;
+  }, "lowerLT");
+  Kr.exports = ui;
+});
+
+// ../../node_modules/semver/index.js
+var Zi = p((vo, et) => {
+  "use strict";
+  var fe = g(), Jr = v(), hi = N(), Qr = Z(), pi = w(), Ri = Te(), $i = we(), mi = ve(), Ii = De(), Li = ye(), Ni = je(), Oi = Ue(), Si = _e(), di = A(), Ai = Me(), Ti = We(), qi = b(), wi = Ze(), gi = Qe(), Pi = C(), vi = H(), xi = Q(), Ci = ee(), Di = k(), Gi = M(), yi = re(), Fi = lr(), ji = D(), Xi = T(), Ui = y(), Vi = dr(), _i = Tr(), bi = wr(), Hi = vr(), ki = Cr(), Mi = B(), Yi = Xr(), Wi = Vr(), Bi = Hr(), zi = Mr(), Ki = Zr();
+  et.exports = {
+    parse: pi,
+    valid: Ri,
+    clean: $i,
+    inc: mi,
+    diff: Ii,
+    major: Li,
+    minor: Ni,
+    patch: Oi,
+    prerelease: Si,
+    compare: di,
+    rcompare: Ai,
+    compareLoose: Ti,
+    compareBuild: qi,
+    sort: wi,
+    rsort: gi,
+    gt: Pi,
+    lt: vi,
+    eq: xi,
+    neq: Ci,
+    gte: Di,
+    lte: Gi,
+    cmp: yi,
+    coerce: Fi,
+    Comparator: ji,
+    Range: Xi,
+    satisfies: Ui,
+    toComparators: Vi,
+    maxSatisfying: _i,
+    minSatisfying: bi,
+    minVersion: Hi,
+    validRange: ki,
+    outside: Mi,
+    gtr: Yi,
+    ltr: Wi,
+    intersects: Bi,
+    simplifyRange: zi,
+    subset: Ki,
+    SemVer: hi,
+    re: fe.re,
+    src: fe.src,
+    tokens: fe.t,
+    SEMVER_SPEC_VERSION: Jr.SEMVER_SPEC_VERSION,
+    RELEASE_TYPES: Jr.RELEASE_TYPES,
+    compareIdentifiers: Qr.compareIdentifiers,
+    rcompareIdentifiers: Qr.rcompareIdentifiers
+  };
+});
+
+export {
+  Zi as a
+};