@vc-shell/framework 1.1.46 → 1.1.47

package/dist/vendor-semver-BoKYtkQw.js

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