@cccsaurora/clue-ui 1.3.0-dev.403 → 1.3.0

package/store-DClHBq7r.js

@@ -0,0 +1,1169 @@
+var Zr = Object.defineProperty;
+var Jr = (a, s, t) => s in a ? Zr(a, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[s] = t;
+var V = (a, s, t) => Jr(a, typeof s != "symbol" ? s + "" : s, t);
+import { g as Qr } from "./_commonjsHelpers-C6fGbg64.js";
+import Mr, { useContext as et } from "react";
+import { u as rt } from "./uniq-B4UZ671_.js";
+var H = { exports: {} }, re, Ze;
+function k() {
+  if (Ze) return re;
+  Ze = 1;
+  const a = "2.0.0", s = 256, t = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+  9007199254740991, r = 16, n = s - 6;
+  return re = {
+    MAX_LENGTH: s,
+    MAX_SAFE_COMPONENT_LENGTH: r,
+    MAX_SAFE_BUILD_LENGTH: n,
+    MAX_SAFE_INTEGER: t,
+    RELEASE_TYPES: [
+      "major",
+      "premajor",
+      "minor",
+      "preminor",
+      "patch",
+      "prepatch",
+      "prerelease"
+    ],
+    SEMVER_SPEC_VERSION: a,
+    FLAG_INCLUDE_PRERELEASE: 1,
+    FLAG_LOOSE: 2
+  }, re;
+}
+var te, Je;
+function W() {
+  return Je || (Je = 1, te = typeof process == "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...s) => console.error("SEMVER", ...s) : () => {
+  }), te;
+}
+var Qe;
+function M() {
+  return Qe || (Qe = 1, (function(a, s) {
+    const {
+      MAX_SAFE_COMPONENT_LENGTH: t,
+      MAX_SAFE_BUILD_LENGTH: r,
+      MAX_LENGTH: n
+    } = k(), u = W();
+    s = a.exports = {};
+    const l = s.re = [], f = s.safeRe = [], o = s.src = [], i = s.safeSrc = [], e = s.t = {};
+    let c = 0;
+    const h = "[a-zA-Z0-9-]", R = [
+      ["\\s", 1],
+      ["\\d", n],
+      [h, r]
+    ], O = (S) => {
+      for (const [P, F] of R)
+        S = S.split(`${P}*`).join(`${P}{0,${F}}`).split(`${P}+`).join(`${P}{1,${F}}`);
+      return S;
+    }, p = (S, P, F) => {
+      const T = O(P), D = c++;
+      u(S, D, P), e[S] = D, o[D] = P, i[D] = T, l[D] = new RegExp(P, F ? "g" : void 0), f[D] = new RegExp(T, F ? "g" : void 0);
+    };
+    p("NUMERICIDENTIFIER", "0|[1-9]\\d*"), p("NUMERICIDENTIFIERLOOSE", "\\d+"), p("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${h}*`), p("MAINVERSION", `(${o[e.NUMERICIDENTIFIER]})\\.(${o[e.NUMERICIDENTIFIER]})\\.(${o[e.NUMERICIDENTIFIER]})`), p("MAINVERSIONLOOSE", `(${o[e.NUMERICIDENTIFIERLOOSE]})\\.(${o[e.NUMERICIDENTIFIERLOOSE]})\\.(${o[e.NUMERICIDENTIFIERLOOSE]})`), p("PRERELEASEIDENTIFIER", `(?:${o[e.NONNUMERICIDENTIFIER]}|${o[e.NUMERICIDENTIFIER]})`), p("PRERELEASEIDENTIFIERLOOSE", `(?:${o[e.NONNUMERICIDENTIFIER]}|${o[e.NUMERICIDENTIFIERLOOSE]})`), p("PRERELEASE", `(?:-(${o[e.PRERELEASEIDENTIFIER]}(?:\\.${o[e.PRERELEASEIDENTIFIER]})*))`), p("PRERELEASELOOSE", `(?:-?(${o[e.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${o[e.PRERELEASEIDENTIFIERLOOSE]})*))`), p("BUILDIDENTIFIER", `${h}+`), p("BUILD", `(?:\\+(${o[e.BUILDIDENTIFIER]}(?:\\.${o[e.BUILDIDENTIFIER]})*))`), p("FULLPLAIN", `v?${o[e.MAINVERSION]}${o[e.PRERELEASE]}?${o[e.BUILD]}?`), p("FULL", `^${o[e.FULLPLAIN]}$`), p("LOOSEPLAIN", `[v=\\s]*${o[e.MAINVERSIONLOOSE]}${o[e.PRERELEASELOOSE]}?${o[e.BUILD]}?`), p("LOOSE", `^${o[e.LOOSEPLAIN]}$`), p("GTLT", "((?:<|>)?=?)"), p("XRANGEIDENTIFIERLOOSE", `${o[e.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`), p("XRANGEIDENTIFIER", `${o[e.NUMERICIDENTIFIER]}|x|X|\\*`), p("XRANGEPLAIN", `[v=\\s]*(${o[e.XRANGEIDENTIFIER]})(?:\\.(${o[e.XRANGEIDENTIFIER]})(?:\\.(${o[e.XRANGEIDENTIFIER]})(?:${o[e.PRERELEASE]})?${o[e.BUILD]}?)?)?`), p("XRANGEPLAINLOOSE", `[v=\\s]*(${o[e.XRANGEIDENTIFIERLOOSE]})(?:\\.(${o[e.XRANGEIDENTIFIERLOOSE]})(?:\\.(${o[e.XRANGEIDENTIFIERLOOSE]})(?:${o[e.PRERELEASELOOSE]})?${o[e.BUILD]}?)?)?`), p("XRANGE", `^${o[e.GTLT]}\\s*${o[e.XRANGEPLAIN]}$`), p("XRANGELOOSE", `^${o[e.GTLT]}\\s*${o[e.XRANGEPLAINLOOSE]}$`), p("COERCEPLAIN", `(^|[^\\d])(\\d{1,${t}})(?:\\.(\\d{1,${t}}))?(?:\\.(\\d{1,${t}}))?`), p("COERCE", `${o[e.COERCEPLAIN]}(?:$|[^\\d])`), p("COERCEFULL", o[e.COERCEPLAIN] + `(?:${o[e.PRERELEASE]})?(?:${o[e.BUILD]})?(?:$|[^\\d])`), p("COERCERTL", o[e.COERCE], !0), p("COERCERTLFULL", o[e.COERCEFULL], !0), p("LONETILDE", "(?:~>?)"), p("TILDETRIM", `(\\s*)${o[e.LONETILDE]}\\s+`, !0), s.tildeTrimReplace = "$1~", p("TILDE", `^${o[e.LONETILDE]}${o[e.XRANGEPLAIN]}$`), p("TILDELOOSE", `^${o[e.LONETILDE]}${o[e.XRANGEPLAINLOOSE]}$`), p("LONECARET", "(?:\\^)"), p("CARETTRIM", `(\\s*)${o[e.LONECARET]}\\s+`, !0), s.caretTrimReplace = "$1^", p("CARET", `^${o[e.LONECARET]}${o[e.XRANGEPLAIN]}$`), p("CARETLOOSE", `^${o[e.LONECARET]}${o[e.XRANGEPLAINLOOSE]}$`), p("COMPARATORLOOSE", `^${o[e.GTLT]}\\s*(${o[e.LOOSEPLAIN]})$|^$`), p("COMPARATOR", `^${o[e.GTLT]}\\s*(${o[e.FULLPLAIN]})$|^$`), p("COMPARATORTRIM", `(\\s*)${o[e.GTLT]}\\s*(${o[e.LOOSEPLAIN]}|${o[e.XRANGEPLAIN]})`, !0), s.comparatorTrimReplace = "$1$2$3", p("HYPHENRANGE", `^\\s*(${o[e.XRANGEPLAIN]})\\s+-\\s+(${o[e.XRANGEPLAIN]})\\s*$`), p("HYPHENRANGELOOSE", `^\\s*(${o[e.XRANGEPLAINLOOSE]})\\s+-\\s+(${o[e.XRANGEPLAINLOOSE]})\\s*$`), p("STAR", "(<|>)?=?\\s*\\*"), p("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"), p("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  })(H, H.exports)), H.exports;
+}
+var se, er;
+function He() {
+  if (er) return se;
+  er = 1;
+  const a = Object.freeze({ loose: !0 }), s = Object.freeze({});
+  return se = (r) => r ? typeof r != "object" ? a : r : s, se;
+}
+var ne, rr;
+function Hr() {
+  if (rr) return ne;
+  rr = 1;
+  const a = /^[0-9]+$/, s = (r, n) => {
+    const u = a.test(r), l = a.test(n);
+    return u && l && (r = +r, n = +n), r === n ? 0 : u && !l ? -1 : l && !u ? 1 : r < n ? -1 : 1;
+  };
+  return ne = {
+    compareIdentifiers: s,
+    rcompareIdentifiers: (r, n) => s(n, r)
+  }, ne;
+}
+var ie, tr;
+function G() {
+  if (tr) return ie;
+  tr = 1;
+  const a = W(), { MAX_LENGTH: s, MAX_SAFE_INTEGER: t } = k(), { safeRe: r, t: n } = M(), u = He(), { compareIdentifiers: l } = Hr();
+  class f {
+    constructor(i, e) {
+      if (e = u(e), i instanceof f) {
+        if (i.loose === !!e.loose && i.includePrerelease === !!e.includePrerelease)
+          return i;
+        i = i.version;
+      } else if (typeof i != "string")
+        throw new TypeError(`Invalid version. Must be a string. Got type "${typeof i}".`);
+      if (i.length > s)
+        throw new TypeError(
+          `version is longer than ${s} characters`
+        );
+      a("SemVer", i, e), this.options = e, this.loose = !!e.loose, this.includePrerelease = !!e.includePrerelease;
+      const c = i.trim().match(e.loose ? r[n.LOOSE] : r[n.FULL]);
+      if (!c)
+        throw new TypeError(`Invalid Version: ${i}`);
+      if (this.raw = i, this.major = +c[1], this.minor = +c[2], this.patch = +c[3], this.major > t || this.major < 0)
+        throw new TypeError("Invalid major version");
+      if (this.minor > t || this.minor < 0)
+        throw new TypeError("Invalid minor version");
+      if (this.patch > t || this.patch < 0)
+        throw new TypeError("Invalid patch version");
+      c[4] ? this.prerelease = c[4].split(".").map((h) => {
+        if (/^[0-9]+$/.test(h)) {
+          const R = +h;
+          if (R >= 0 && R < t)
+            return R;
+        }
+        return h;
+      }) : this.prerelease = [], this.build = c[5] ? c[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(i) {
+      if (a("SemVer.compare", this.version, this.options, i), !(i instanceof f)) {
+        if (typeof i == "string" && i === this.version)
+          return 0;
+        i = new f(i, this.options);
+      }
+      return i.version === this.version ? 0 : this.compareMain(i) || this.comparePre(i);
+    }
+    compareMain(i) {
+      return i instanceof f || (i = new f(i, this.options)), l(this.major, i.major) || l(this.minor, i.minor) || l(this.patch, i.patch);
+    }
+    comparePre(i) {
+      if (i instanceof f || (i = new f(i, this.options)), this.prerelease.length && !i.prerelease.length)
+        return -1;
+      if (!this.prerelease.length && i.prerelease.length)
+        return 1;
+      if (!this.prerelease.length && !i.prerelease.length)
+        return 0;
+      let e = 0;
+      do {
+        const c = this.prerelease[e], h = i.prerelease[e];
+        if (a("prerelease compare", e, c, h), c === void 0 && h === void 0)
+          return 0;
+        if (h === void 0)
+          return 1;
+        if (c === void 0)
+          return -1;
+        if (c === h)
+          continue;
+        return l(c, h);
+      } while (++e);
+    }
+    compareBuild(i) {
+      i instanceof f || (i = new f(i, this.options));
+      let e = 0;
+      do {
+        const c = this.build[e], h = i.build[e];
+        if (a("build compare", e, c, h), c === void 0 && h === void 0)
+          return 0;
+        if (h === void 0)
+          return 1;
+        if (c === void 0)
+          return -1;
+        if (c === h)
+          continue;
+        return l(c, h);
+      } 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(i, e, c) {
+      if (i.startsWith("pre")) {
+        if (!e && c === !1)
+          throw new Error("invalid increment argument: identifier is empty");
+        if (e) {
+          const h = `-${e}`.match(this.options.loose ? r[n.PRERELEASELOOSE] : r[n.PRERELEASE]);
+          if (!h || h[1] !== e)
+            throw new Error(`invalid identifier: ${e}`);
+        }
+      }
+      switch (i) {
+        case "premajor":
+          this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", e, c);
+          break;
+        case "preminor":
+          this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", e, c);
+          break;
+        case "prepatch":
+          this.prerelease.length = 0, this.inc("patch", e, c), this.inc("pre", e, c);
+          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, c), this.inc("pre", e, c);
+          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 h = Number(c) ? 1 : 0;
+          if (this.prerelease.length === 0)
+            this.prerelease = [h];
+          else {
+            let R = this.prerelease.length;
+            for (; --R >= 0; )
+              typeof this.prerelease[R] == "number" && (this.prerelease[R]++, R = -2);
+            if (R === -1) {
+              if (e === this.prerelease.join(".") && c === !1)
+                throw new Error("invalid increment argument: identifier already exists");
+              this.prerelease.push(h);
+            }
+          }
+          if (e) {
+            let R = [e, h];
+            c === !1 && (R = [e]), l(this.prerelease[0], e) === 0 ? isNaN(this.prerelease[1]) && (this.prerelease = R) : this.prerelease = R;
+          }
+          break;
+        }
+        default:
+          throw new Error(`invalid increment argument: ${i}`);
+      }
+      return this.raw = this.format(), this.build.length && (this.raw += `+${this.build.join(".")}`), this;
+    }
+  }
+  return ie = f, ie;
+}
+var ae, sr;
+function x() {
+  if (sr) return ae;
+  sr = 1;
+  const a = G();
+  return ae = (t, r, n = !1) => {
+    if (t instanceof a)
+      return t;
+    try {
+      return new a(t, r);
+    } catch (u) {
+      if (!n)
+        return null;
+      throw u;
+    }
+  }, ae;
+}
+var oe, nr;
+function tt() {
+  if (nr) return oe;
+  nr = 1;
+  const a = x();
+  return oe = (t, r) => {
+    const n = a(t, r);
+    return n ? n.version : null;
+  }, oe;
+}
+var le, ir;
+function st() {
+  if (ir) return le;
+  ir = 1;
+  const a = x();
+  return le = (t, r) => {
+    const n = a(t.trim().replace(/^[=v]+/, ""), r);
+    return n ? n.version : null;
+  }, le;
+}
+var ce, ar;
+function nt() {
+  if (ar) return ce;
+  ar = 1;
+  const a = G();
+  return ce = (t, r, n, u, l) => {
+    typeof n == "string" && (l = u, u = n, n = void 0);
+    try {
+      return new a(
+        t instanceof a ? t.version : t,
+        n
+      ).inc(r, u, l).version;
+    } catch {
+      return null;
+    }
+  }, ce;
+}
+var ue, or;
+function it() {
+  if (or) return ue;
+  or = 1;
+  const a = x();
+  return ue = (t, r) => {
+    const n = a(t, null, !0), u = a(r, null, !0), l = n.compare(u);
+    if (l === 0)
+      return null;
+    const f = l > 0, o = f ? n : u, i = f ? u : n, e = !!o.prerelease.length;
+    if (!!i.prerelease.length && !e) {
+      if (!i.patch && !i.minor)
+        return "major";
+      if (i.compareMain(o) === 0)
+        return i.minor && !i.patch ? "minor" : "patch";
+    }
+    const h = e ? "pre" : "";
+    return n.major !== u.major ? h + "major" : n.minor !== u.minor ? h + "minor" : n.patch !== u.patch ? h + "patch" : "prerelease";
+  }, ue;
+}
+var fe, lr;
+function at() {
+  if (lr) return fe;
+  lr = 1;
+  const a = G();
+  return fe = (t, r) => new a(t, r).major, fe;
+}
+var he, cr;
+function ot() {
+  if (cr) return he;
+  cr = 1;
+  const a = G();
+  return he = (t, r) => new a(t, r).minor, he;
+}
+var Ee, ur;
+function lt() {
+  if (ur) return Ee;
+  ur = 1;
+  const a = G();
+  return Ee = (t, r) => new a(t, r).patch, Ee;
+}
+var pe, fr;
+function ct() {
+  if (fr) return pe;
+  fr = 1;
+  const a = x();
+  return pe = (t, r) => {
+    const n = a(t, r);
+    return n && n.prerelease.length ? n.prerelease : null;
+  }, pe;
+}
+var me, hr;
+function b() {
+  if (hr) return me;
+  hr = 1;
+  const a = G();
+  return me = (t, r, n) => new a(t, n).compare(new a(r, n)), me;
+}
+var Re, Er;
+function ut() {
+  if (Er) return Re;
+  Er = 1;
+  const a = b();
+  return Re = (t, r, n) => a(r, t, n), Re;
+}
+var de, pr;
+function ft() {
+  if (pr) return de;
+  pr = 1;
+  const a = b();
+  return de = (t, r) => a(t, r, !0), de;
+}
+var ve, mr;
+function ke() {
+  if (mr) return ve;
+  mr = 1;
+  const a = G();
+  return ve = (t, r, n) => {
+    const u = new a(t, n), l = new a(r, n);
+    return u.compare(l) || u.compareBuild(l);
+  }, ve;
+}
+var $e, Rr;
+function ht() {
+  if (Rr) return $e;
+  Rr = 1;
+  const a = ke();
+  return $e = (t, r) => t.sort((n, u) => a(n, u, r)), $e;
+}
+var ge, dr;
+function Et() {
+  if (dr) return ge;
+  dr = 1;
+  const a = ke();
+  return ge = (t, r) => t.sort((n, u) => a(u, n, r)), ge;
+}
+var Ie, vr;
+function Y() {
+  if (vr) return Ie;
+  vr = 1;
+  const a = b();
+  return Ie = (t, r, n) => a(t, r, n) > 0, Ie;
+}
+var Le, $r;
+function We() {
+  if ($r) return Le;
+  $r = 1;
+  const a = b();
+  return Le = (t, r, n) => a(t, r, n) < 0, Le;
+}
+var Se, gr;
+function kr() {
+  if (gr) return Se;
+  gr = 1;
+  const a = b();
+  return Se = (t, r, n) => a(t, r, n) === 0, Se;
+}
+var Ne, Ir;
+function Wr() {
+  if (Ir) return Ne;
+  Ir = 1;
+  const a = b();
+  return Ne = (t, r, n) => a(t, r, n) !== 0, Ne;
+}
+var Oe, Lr;
+function Ye() {
+  if (Lr) return Oe;
+  Lr = 1;
+  const a = b();
+  return Oe = (t, r, n) => a(t, r, n) >= 0, Oe;
+}
+var Ae, Sr;
+function ze() {
+  if (Sr) return Ae;
+  Sr = 1;
+  const a = b();
+  return Ae = (t, r, n) => a(t, r, n) <= 0, Ae;
+}
+var Pe, Nr;
+function Yr() {
+  if (Nr) return Pe;
+  Nr = 1;
+  const a = kr(), s = Wr(), t = Y(), r = Ye(), n = We(), u = ze();
+  return Pe = (f, o, i, e) => {
+    switch (o) {
+      case "===":
+        return typeof f == "object" && (f = f.version), typeof i == "object" && (i = i.version), f === i;
+      case "!==":
+        return typeof f == "object" && (f = f.version), typeof i == "object" && (i = i.version), f !== i;
+      case "":
+      case "=":
+      case "==":
+        return a(f, i, e);
+      case "!=":
+        return s(f, i, e);
+      case ">":
+        return t(f, i, e);
+      case ">=":
+        return r(f, i, e);
+      case "<":
+        return n(f, i, e);
+      case "<=":
+        return u(f, i, e);
+      default:
+        throw new TypeError(`Invalid operator: ${o}`);
+    }
+  }, Pe;
+}
+var Te, Or;
+function pt() {
+  if (Or) return Te;
+  Or = 1;
+  const a = G(), s = x(), { safeRe: t, t: r } = M();
+  return Te = (u, l) => {
+    if (u instanceof a)
+      return u;
+    if (typeof u == "number" && (u = String(u)), typeof u != "string")
+      return null;
+    l = l || {};
+    let f = null;
+    if (!l.rtl)
+      f = u.match(l.includePrerelease ? t[r.COERCEFULL] : t[r.COERCE]);
+    else {
+      const R = l.includePrerelease ? t[r.COERCERTLFULL] : t[r.COERCERTL];
+      let O;
+      for (; (O = R.exec(u)) && (!f || f.index + f[0].length !== u.length); )
+        (!f || O.index + O[0].length !== f.index + f[0].length) && (f = O), R.lastIndex = O.index + O[1].length + O[2].length;
+      R.lastIndex = -1;
+    }
+    if (f === null)
+      return null;
+    const o = f[2], i = f[3] || "0", e = f[4] || "0", c = l.includePrerelease && f[5] ? `-${f[5]}` : "", h = l.includePrerelease && f[6] ? `+${f[6]}` : "";
+    return s(`${o}.${i}.${e}${c}${h}`, l);
+  }, Te;
+}
+var we, Ar;
+function mt() {
+  if (Ar) return we;
+  Ar = 1;
+  class a {
+    constructor() {
+      this.max = 1e3, this.map = /* @__PURE__ */ new Map();
+    }
+    get(t) {
+      const r = this.map.get(t);
+      if (r !== void 0)
+        return this.map.delete(t), this.map.set(t, r), r;
+    }
+    delete(t) {
+      return this.map.delete(t);
+    }
+    set(t, r) {
+      if (!this.delete(t) && r !== void 0) {
+        if (this.map.size >= this.max) {
+          const u = this.map.keys().next().value;
+          this.delete(u);
+        }
+        this.map.set(t, r);
+      }
+      return this;
+    }
+  }
+  return we = a, we;
+}
+var Ce, Pr;
+function U() {
+  if (Pr) return Ce;
+  Pr = 1;
+  const a = /\s+/g;
+  class s {
+    constructor(E, $) {
+      if ($ = n($), E instanceof s)
+        return E.loose === !!$.loose && E.includePrerelease === !!$.includePrerelease ? E : new s(E.raw, $);
+      if (E instanceof u)
+        return this.raw = E.value, this.set = [[E]], this.formatted = void 0, this;
+      if (this.options = $, this.loose = !!$.loose, this.includePrerelease = !!$.includePrerelease, this.raw = E.trim().replace(a, " "), this.set = this.raw.split("||").map((d) => this.parseRange(d.trim())).filter((d) => d.length), !this.set.length)
+        throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+      if (this.set.length > 1) {
+        const d = this.set[0];
+        if (this.set = this.set.filter((g) => !p(g[0])), this.set.length === 0)
+          this.set = [d];
+        else if (this.set.length > 1) {
+          for (const g of this.set)
+            if (g.length === 1 && S(g[0])) {
+              this.set = [g];
+              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 += "||");
+          const $ = this.set[E];
+          for (let d = 0; d < $.length; d++)
+            d > 0 && (this.formatted += " "), this.formatted += $[d].toString().trim();
+        }
+      }
+      return this.formatted;
+    }
+    format() {
+      return this.range;
+    }
+    toString() {
+      return this.range;
+    }
+    parseRange(E) {
+      const d = ((this.options.includePrerelease && R) | (this.options.loose && O)) + ":" + E, g = r.get(d);
+      if (g)
+        return g;
+      const v = this.options.loose, I = v ? o[i.HYPHENRANGELOOSE] : o[i.HYPHENRANGE];
+      E = E.replace(I, Q(this.options.includePrerelease)), l("hyphen replace", E), E = E.replace(o[i.COMPARATORTRIM], e), l("comparator trim", E), E = E.replace(o[i.TILDETRIM], c), l("tilde trim", E), E = E.replace(o[i.CARETTRIM], h), l("caret trim", E);
+      let A = E.split(" ").map((q) => F(q, this.options)).join(" ").split(/\s+/).map((q) => J(q, this.options));
+      v && (A = A.filter((q) => (l("loose invalid filter", q, this.options), !!q.match(o[i.COMPARATORLOOSE])))), l("range list", A);
+      const N = /* @__PURE__ */ new Map(), w = A.map((q) => new u(q, this.options));
+      for (const q of w) {
+        if (p(q))
+          return [q];
+        N.set(q.value, q);
+      }
+      N.size > 1 && N.has("") && N.delete("");
+      const _ = [...N.values()];
+      return r.set(d, _), _;
+    }
+    intersects(E, $) {
+      if (!(E instanceof s))
+        throw new TypeError("a Range is required");
+      return this.set.some((d) => P(d, $) && E.set.some((g) => P(g, $) && d.every((v) => g.every((I) => v.intersects(I, $)))));
+    }
+    // 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 f(E, this.options);
+        } catch {
+          return !1;
+        }
+      for (let $ = 0; $ < this.set.length; $++)
+        if (ee(this.set[$], E, this.options))
+          return !0;
+      return !1;
+    }
+  }
+  Ce = s;
+  const t = mt(), r = new t(), n = He(), u = z(), l = W(), f = G(), {
+    safeRe: o,
+    t: i,
+    comparatorTrimReplace: e,
+    tildeTrimReplace: c,
+    caretTrimReplace: h
+  } = M(), { FLAG_INCLUDE_PRERELEASE: R, FLAG_LOOSE: O } = k(), p = (m) => m.value === "<0.0.0-0", S = (m) => m.value === "", P = (m, E) => {
+    let $ = !0;
+    const d = m.slice();
+    let g = d.pop();
+    for (; $ && d.length; )
+      $ = d.every((v) => g.intersects(v, E)), g = d.pop();
+    return $;
+  }, F = (m, E) => (l("comp", m, E), m = C(m, E), l("caret", m), m = D(m, E), l("tildes", m), m = L(m, E), l("xrange", m), m = Z(m, E), l("stars", m), m), T = (m) => !m || m.toLowerCase() === "x" || m === "*", D = (m, E) => m.trim().split(/\s+/).map(($) => j($, E)).join(" "), j = (m, E) => {
+    const $ = E.loose ? o[i.TILDELOOSE] : o[i.TILDE];
+    return m.replace($, (d, g, v, I, A) => {
+      l("tilde", m, d, g, v, I, A);
+      let N;
+      return T(g) ? N = "" : T(v) ? N = `>=${g}.0.0 <${+g + 1}.0.0-0` : T(I) ? N = `>=${g}.${v}.0 <${g}.${+v + 1}.0-0` : A ? (l("replaceTilde pr", A), N = `>=${g}.${v}.${I}-${A} <${g}.${+v + 1}.0-0`) : N = `>=${g}.${v}.${I} <${g}.${+v + 1}.0-0`, l("tilde return", N), N;
+    });
+  }, C = (m, E) => m.trim().split(/\s+/).map(($) => y($, E)).join(" "), y = (m, E) => {
+    l("caret", m, E);
+    const $ = E.loose ? o[i.CARETLOOSE] : o[i.CARET], d = E.includePrerelease ? "-0" : "";
+    return m.replace($, (g, v, I, A, N) => {
+      l("caret", m, g, v, I, A, N);
+      let w;
+      return T(v) ? w = "" : T(I) ? w = `>=${v}.0.0${d} <${+v + 1}.0.0-0` : T(A) ? v === "0" ? w = `>=${v}.${I}.0${d} <${v}.${+I + 1}.0-0` : w = `>=${v}.${I}.0${d} <${+v + 1}.0.0-0` : N ? (l("replaceCaret pr", N), v === "0" ? I === "0" ? w = `>=${v}.${I}.${A}-${N} <${v}.${I}.${+A + 1}-0` : w = `>=${v}.${I}.${A}-${N} <${v}.${+I + 1}.0-0` : w = `>=${v}.${I}.${A}-${N} <${+v + 1}.0.0-0`) : (l("no pr"), v === "0" ? I === "0" ? w = `>=${v}.${I}.${A}${d} <${v}.${I}.${+A + 1}-0` : w = `>=${v}.${I}.${A}${d} <${v}.${+I + 1}.0-0` : w = `>=${v}.${I}.${A} <${+v + 1}.0.0-0`), l("caret return", w), w;
+    });
+  }, L = (m, E) => (l("replaceXRanges", m, E), m.split(/\s+/).map(($) => X($, E)).join(" ")), X = (m, E) => {
+    m = m.trim();
+    const $ = E.loose ? o[i.XRANGELOOSE] : o[i.XRANGE];
+    return m.replace($, (d, g, v, I, A, N) => {
+      l("xRange", m, d, g, v, I, A, N);
+      const w = T(v), _ = w || T(I), q = _ || T(A), B = q;
+      return g === "=" && B && (g = ""), N = E.includePrerelease ? "-0" : "", w ? g === ">" || g === "<" ? d = "<0.0.0-0" : d = "*" : g && B ? (_ && (I = 0), A = 0, g === ">" ? (g = ">=", _ ? (v = +v + 1, I = 0, A = 0) : (I = +I + 1, A = 0)) : g === "<=" && (g = "<", _ ? v = +v + 1 : I = +I + 1), g === "<" && (N = "-0"), d = `${g + v}.${I}.${A}${N}`) : _ ? d = `>=${v}.0.0${N} <${+v + 1}.0.0-0` : q && (d = `>=${v}.${I}.0${N} <${v}.${+I + 1}.0-0`), l("xRange return", d), d;
+    });
+  }, Z = (m, E) => (l("replaceStars", m, E), m.trim().replace(o[i.STAR], "")), J = (m, E) => (l("replaceGTE0", m, E), m.trim().replace(o[E.includePrerelease ? i.GTE0PRE : i.GTE0], "")), Q = (m) => (E, $, d, g, v, I, A, N, w, _, q, B) => (T(d) ? $ = "" : T(g) ? $ = `>=${d}.0.0${m ? "-0" : ""}` : T(v) ? $ = `>=${d}.${g}.0${m ? "-0" : ""}` : I ? $ = `>=${$}` : $ = `>=${$}${m ? "-0" : ""}`, T(w) ? N = "" : T(_) ? N = `<${+w + 1}.0.0-0` : T(q) ? N = `<${w}.${+_ + 1}.0-0` : B ? N = `<=${w}.${_}.${q}-${B}` : m ? N = `<${w}.${_}.${+q + 1}-0` : N = `<=${N}`, `${$} ${N}`.trim()), ee = (m, E, $) => {
+    for (let d = 0; d < m.length; d++)
+      if (!m[d].test(E))
+        return !1;
+    if (E.prerelease.length && !$.includePrerelease) {
+      for (let d = 0; d < m.length; d++)
+        if (l(m[d].semver), m[d].semver !== u.ANY && m[d].semver.prerelease.length > 0) {
+          const g = m[d].semver;
+          if (g.major === E.major && g.minor === E.minor && g.patch === E.patch)
+            return !0;
+        }
+      return !1;
+    }
+    return !0;
+  };
+  return Ce;
+}
+var qe, Tr;
+function z() {
+  if (Tr) return qe;
+  Tr = 1;
+  const a = Symbol("SemVer ANY");
+  class s {
+    static get ANY() {
+      return a;
+    }
+    constructor(e, c) {
+      if (c = t(c), e instanceof s) {
+        if (e.loose === !!c.loose)
+          return e;
+        e = e.value;
+      }
+      e = e.trim().split(/\s+/).join(" "), l("comparator", e, c), this.options = c, this.loose = !!c.loose, this.parse(e), this.semver === a ? this.value = "" : this.value = this.operator + this.semver.version, l("comp", this);
+    }
+    parse(e) {
+      const c = this.options.loose ? r[n.COMPARATORLOOSE] : r[n.COMPARATOR], h = e.match(c);
+      if (!h)
+        throw new TypeError(`Invalid comparator: ${e}`);
+      this.operator = h[1] !== void 0 ? h[1] : "", this.operator === "=" && (this.operator = ""), h[2] ? this.semver = new f(h[2], this.options.loose) : this.semver = a;
+    }
+    toString() {
+      return this.value;
+    }
+    test(e) {
+      if (l("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 u(e, this.operator, this.semver, this.options);
+    }
+    intersects(e, c) {
+      if (!(e instanceof s))
+        throw new TypeError("a Comparator is required");
+      return this.operator === "" ? this.value === "" ? !0 : new o(e.value, c).test(this.value) : e.operator === "" ? e.value === "" ? !0 : new o(this.value, c).test(e.semver) : (c = t(c), c.includePrerelease && (this.value === "<0.0.0-0" || e.value === "<0.0.0-0") || !c.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("=") || u(this.semver, "<", e.semver, c) && this.operator.startsWith(">") && e.operator.startsWith("<") || u(this.semver, ">", e.semver, c) && this.operator.startsWith("<") && e.operator.startsWith(">")));
+    }
+  }
+  qe = s;
+  const t = He(), { safeRe: r, t: n } = M(), u = Yr(), l = W(), f = G(), o = U();
+  return qe;
+}
+var ye, wr;
+function K() {
+  if (wr) return ye;
+  wr = 1;
+  const a = U();
+  return ye = (t, r, n) => {
+    try {
+      r = new a(r, n);
+    } catch {
+      return !1;
+    }
+    return r.test(t);
+  }, ye;
+}
+var Fe, Cr;
+function Rt() {
+  if (Cr) return Fe;
+  Cr = 1;
+  const a = U();
+  return Fe = (t, r) => new a(t, r).set.map((n) => n.map((u) => u.value).join(" ").trim().split(" ")), Fe;
+}
+var De, qr;
+function dt() {
+  if (qr) return De;
+  qr = 1;
+  const a = G(), s = U();
+  return De = (r, n, u) => {
+    let l = null, f = null, o = null;
+    try {
+      o = new s(n, u);
+    } catch {
+      return null;
+    }
+    return r.forEach((i) => {
+      o.test(i) && (!l || f.compare(i) === -1) && (l = i, f = new a(l, u));
+    }), l;
+  }, De;
+}
+var _e, yr;
+function vt() {
+  if (yr) return _e;
+  yr = 1;
+  const a = G(), s = U();
+  return _e = (r, n, u) => {
+    let l = null, f = null, o = null;
+    try {
+      o = new s(n, u);
+    } catch {
+      return null;
+    }
+    return r.forEach((i) => {
+      o.test(i) && (!l || f.compare(i) === 1) && (l = i, f = new a(l, u));
+    }), l;
+  }, _e;
+}
+var Ge, Fr;
+function $t() {
+  if (Fr) return Ge;
+  Fr = 1;
+  const a = G(), s = U(), t = Y();
+  return Ge = (n, u) => {
+    n = new s(n, u);
+    let l = new a("0.0.0");
+    if (n.test(l) || (l = new a("0.0.0-0"), n.test(l)))
+      return l;
+    l = null;
+    for (let f = 0; f < n.set.length; ++f) {
+      const o = n.set[f];
+      let i = null;
+      o.forEach((e) => {
+        const c = new a(e.semver.version);
+        switch (e.operator) {
+          case ">":
+            c.prerelease.length === 0 ? c.patch++ : c.prerelease.push(0), c.raw = c.format();
+          /* fallthrough */
+          case "":
+          case ">=":
+            (!i || t(c, i)) && (i = c);
+            break;
+          case "<":
+          case "<=":
+            break;
+          /* istanbul ignore next */
+          default:
+            throw new Error(`Unexpected operation: ${e.operator}`);
+        }
+      }), i && (!l || t(l, i)) && (l = i);
+    }
+    return l && n.test(l) ? l : null;
+  }, Ge;
+}
+var je, Dr;
+function gt() {
+  if (Dr) return je;
+  Dr = 1;
+  const a = U();
+  return je = (t, r) => {
+    try {
+      return new a(t, r).range || "*";
+    } catch {
+      return null;
+    }
+  }, je;
+}
+var be, _r;
+function Ke() {
+  if (_r) return be;
+  _r = 1;
+  const a = G(), s = z(), { ANY: t } = s, r = U(), n = K(), u = Y(), l = We(), f = ze(), o = Ye();
+  return be = (e, c, h, R) => {
+    e = new a(e, R), c = new r(c, R);
+    let O, p, S, P, F;
+    switch (h) {
+      case ">":
+        O = u, p = f, S = l, P = ">", F = ">=";
+        break;
+      case "<":
+        O = l, p = o, S = u, P = "<", F = "<=";
+        break;
+      default:
+        throw new TypeError('Must provide a hilo val of "<" or ">"');
+    }
+    if (n(e, c, R))
+      return !1;
+    for (let T = 0; T < c.set.length; ++T) {
+      const D = c.set[T];
+      let j = null, C = null;
+      if (D.forEach((y) => {
+        y.semver === t && (y = new s(">=0.0.0")), j = j || y, C = C || y, O(y.semver, j.semver, R) ? j = y : S(y.semver, C.semver, R) && (C = y);
+      }), j.operator === P || j.operator === F || (!C.operator || C.operator === P) && p(e, C.semver))
+        return !1;
+      if (C.operator === F && S(e, C.semver))
+        return !1;
+    }
+    return !0;
+  }, be;
+}
+var Ue, Gr;
+function It() {
+  if (Gr) return Ue;
+  Gr = 1;
+  const a = Ke();
+  return Ue = (t, r, n) => a(t, r, ">", n), Ue;
+}
+var Ve, jr;
+function Lt() {
+  if (jr) return Ve;
+  jr = 1;
+  const a = Ke();
+  return Ve = (t, r, n) => a(t, r, "<", n), Ve;
+}
+var xe, br;
+function St() {
+  if (br) return xe;
+  br = 1;
+  const a = U();
+  return xe = (t, r, n) => (t = new a(t, n), r = new a(r, n), t.intersects(r, n)), xe;
+}
+var Xe, Ur;
+function Nt() {
+  if (Ur) return Xe;
+  Ur = 1;
+  const a = K(), s = b();
+  return Xe = (t, r, n) => {
+    const u = [];
+    let l = null, f = null;
+    const o = t.sort((h, R) => s(h, R, n));
+    for (const h of o)
+      a(h, r, n) ? (f = h, l || (l = h)) : (f && u.push([l, f]), f = null, l = null);
+    l && u.push([l, null]);
+    const i = [];
+    for (const [h, R] of u)
+      h === R ? i.push(h) : !R && h === o[0] ? i.push("*") : R ? h === o[0] ? i.push(`<=${R}`) : i.push(`${h} - ${R}`) : i.push(`>=${h}`);
+    const e = i.join(" || "), c = typeof r.raw == "string" ? r.raw : String(r);
+    return e.length < c.length ? e : r;
+  }, Xe;
+}
+var Be, Vr;
+function Ot() {
+  if (Vr) return Be;
+  Vr = 1;
+  const a = U(), s = z(), { ANY: t } = s, r = K(), n = b(), u = (c, h, R = {}) => {
+    if (c === h)
+      return !0;
+    c = new a(c, R), h = new a(h, R);
+    let O = !1;
+    e: for (const p of c.set) {
+      for (const S of h.set) {
+        const P = o(p, S, R);
+        if (O = O || P !== null, P)
+          continue e;
+      }
+      if (O)
+        return !1;
+    }
+    return !0;
+  }, l = [new s(">=0.0.0-0")], f = [new s(">=0.0.0")], o = (c, h, R) => {
+    if (c === h)
+      return !0;
+    if (c.length === 1 && c[0].semver === t) {
+      if (h.length === 1 && h[0].semver === t)
+        return !0;
+      R.includePrerelease ? c = l : c = f;
+    }
+    if (h.length === 1 && h[0].semver === t) {
+      if (R.includePrerelease)
+        return !0;
+      h = f;
+    }
+    const O = /* @__PURE__ */ new Set();
+    let p, S;
+    for (const L of c)
+      L.operator === ">" || L.operator === ">=" ? p = i(p, L, R) : L.operator === "<" || L.operator === "<=" ? S = e(S, L, R) : O.add(L.semver);
+    if (O.size > 1)
+      return null;
+    let P;
+    if (p && S) {
+      if (P = n(p.semver, S.semver, R), P > 0)
+        return null;
+      if (P === 0 && (p.operator !== ">=" || S.operator !== "<="))
+        return null;
+    }
+    for (const L of O) {
+      if (p && !r(L, String(p), R) || S && !r(L, String(S), R))
+        return null;
+      for (const X of h)
+        if (!r(L, String(X), R))
+          return !1;
+      return !0;
+    }
+    let F, T, D, j, C = S && !R.includePrerelease && S.semver.prerelease.length ? S.semver : !1, y = p && !R.includePrerelease && p.semver.prerelease.length ? p.semver : !1;
+    C && C.prerelease.length === 1 && S.operator === "<" && C.prerelease[0] === 0 && (C = !1);
+    for (const L of h) {
+      if (j = j || L.operator === ">" || L.operator === ">=", D = D || L.operator === "<" || L.operator === "<=", p) {
+        if (y && L.semver.prerelease && L.semver.prerelease.length && L.semver.major === y.major && L.semver.minor === y.minor && L.semver.patch === y.patch && (y = !1), L.operator === ">" || L.operator === ">=") {
+          if (F = i(p, L, R), F === L && F !== p)
+            return !1;
+        } else if (p.operator === ">=" && !r(p.semver, String(L), R))
+          return !1;
+      }
+      if (S) {
+        if (C && L.semver.prerelease && L.semver.prerelease.length && L.semver.major === C.major && L.semver.minor === C.minor && L.semver.patch === C.patch && (C = !1), L.operator === "<" || L.operator === "<=") {
+          if (T = e(S, L, R), T === L && T !== S)
+            return !1;
+        } else if (S.operator === "<=" && !r(S.semver, String(L), R))
+          return !1;
+      }
+      if (!L.operator && (S || p) && P !== 0)
+        return !1;
+    }
+    return !(p && D && !S && P !== 0 || S && j && !p && P !== 0 || y || C);
+  }, i = (c, h, R) => {
+    if (!c)
+      return h;
+    const O = n(c.semver, h.semver, R);
+    return O > 0 ? c : O < 0 || h.operator === ">" && c.operator === ">=" ? h : c;
+  }, e = (c, h, R) => {
+    if (!c)
+      return h;
+    const O = n(c.semver, h.semver, R);
+    return O < 0 ? c : O > 0 || h.operator === "<" && c.operator === "<=" ? h : c;
+  };
+  return Be = u, Be;
+}
+var Me, xr;
+function At() {
+  if (xr) return Me;
+  xr = 1;
+  const a = M(), s = k(), t = G(), r = Hr(), n = x(), u = tt(), l = st(), f = nt(), o = it(), i = at(), e = ot(), c = lt(), h = ct(), R = b(), O = ut(), p = ft(), S = ke(), P = ht(), F = Et(), T = Y(), D = We(), j = kr(), C = Wr(), y = Ye(), L = ze(), X = Yr(), Z = pt(), J = z(), Q = U(), ee = K(), m = Rt(), E = dt(), $ = vt(), d = $t(), g = gt(), v = Ke(), I = It(), A = Lt(), N = St(), w = Nt(), _ = Ot();
+  return Me = {
+    parse: n,
+    valid: u,
+    clean: l,
+    inc: f,
+    diff: o,
+    major: i,
+    minor: e,
+    patch: c,
+    prerelease: h,
+    compare: R,
+    rcompare: O,
+    compareLoose: p,
+    compareBuild: S,
+    sort: P,
+    rsort: F,
+    gt: T,
+    lt: D,
+    eq: j,
+    neq: C,
+    gte: y,
+    lte: L,
+    cmp: X,
+    coerce: Z,
+    Comparator: J,
+    Range: Q,
+    satisfies: ee,
+    toComparators: m,
+    maxSatisfying: E,
+    minSatisfying: $,
+    minVersion: d,
+    validRange: g,
+    outside: v,
+    gtr: I,
+    ltr: A,
+    intersects: N,
+    simplifyRange: w,
+    subset: _,
+    SemVer: t,
+    re: a.re,
+    src: a.src,
+    tokens: a.t,
+    SEMVER_SPEC_VERSION: s.SEMVER_SPEC_VERSION,
+    RELEASE_TYPES: s.RELEASE_TYPES,
+    compareIdentifiers: r.compareIdentifiers,
+    rcompareIdentifiers: r.rcompareIdentifiers
+  }, Me;
+}
+var Pt = At();
+const Xr = /* @__PURE__ */ Qr(Pt);
+var Tt = /* @__PURE__ */ (function() {
+  function a() {
+    this.registry = /* @__PURE__ */ new Map();
+  }
+  var s = a.prototype;
+  return s.addEventListener = function(r, n) {
+    var u = this.registry.get(r);
+    u ? u.push(n) : this.registry.set(r, [n]);
+  }, s.removeEventListener = function(r, n) {
+    var u = this.registry.get(r);
+    if (u) {
+      var l = u.indexOf(n);
+      l > -1 && u.splice(l, 1);
+    }
+  }, s.dispatchEvent = function(r) {
+    window.debug && console.log("DEBUG::", "Event:", r.name);
+    var n = this.registry.get(r.name);
+    for (var u in n)
+      if (n[u](r), !r.propagate) break;
+  }, a;
+})();
+function wt(a, s) {
+  var t = Xr.diff(a, s);
+  return (t === null || t === "patch" || t === "minor") && Xr.gte(a, s);
+}
+var zr = /* @__PURE__ */ (function() {
+  function a() {
+    this._eventCallableRegistry = new Tt(), this.functionArray = /* @__PURE__ */ new Map(), this.pluginMap = /* @__PURE__ */ new Map();
+  }
+  var s = a.prototype;
+  return s.install = function(r) {
+    var n = this, u = r.getPluginName(), l = u.split("@"), f = l[0], o = r.getDependencies() || [], i = [];
+    o.forEach(function(e) {
+      var c = e.split("@"), h = c[0], R = c[1], O = n.getInstalledPluginNameWithVersion(h), p = O ? O.split("@") : [null, ""], S = p[1];
+      O ? wt(S, R) || i.push("Error installing " + u + `.
+` + O + " doesn't satisfy the required dependency " + e + ".") : i.push("Error installing " + u + ". Could not find dependency " + e + ".");
+    }), i.length === 0 ? (this.pluginMap.set(f, r), r.init(this), r.activate()) : i.forEach(function(e) {
+      console.error(e);
+    });
+  }, s.getInstalledPluginNameWithVersion = function(r) {
+    var n = this.pluginMap.get(r);
+    return n ? n.getPluginName() : null;
+  }, s.addFunction = function(r, n) {
+    this.functionArray.set(r, n);
+  }, s.executeFunction = function(r) {
+    var n = this.functionArray.get(r);
+    if (n) {
+      for (var u = arguments.length, l = new Array(u > 1 ? u - 1 : 0), f = 1; f < u; f++)
+        l[f - 1] = arguments[f];
+      return n.apply(void 0, l);
+    }
+    console.error("No function added for the key " + r + ".");
+  }, s.removeFunction = function(r) {
+    this.functionArray.delete(r);
+  }, s.uninstall = function(r) {
+    var n = this.pluginMap.get(r);
+    n && (n.deactivate(), this.pluginMap.delete(r));
+  }, s.addEventListener = function(r, n) {
+    this._eventCallableRegistry.addEventListener(r, n);
+  }, s.removeEventListener = function(r, n) {
+    this._eventCallableRegistry.removeEventListener(r, n);
+  }, s.dispatchEvent = function(r) {
+    this._eventCallableRegistry.dispatchEvent(r);
+  }, a;
+})();
+function Br() {
+  return new zr();
+}
+var Kr = /* @__PURE__ */ Mr.createContext(/* @__PURE__ */ new zr()), _t = function(s) {
+  var t = s.pluginStore, r = s.children;
+  return Mr.createElement(Kr.Provider, {
+    value: t
+  }, r);
+};
+function Gt() {
+  return et(Kr);
+}
+class Ct {
+  constructor() {
+    V(this, "_pluginStore", Br());
+    V(this, "plugins", []);
+    V(this, "pluginsByFormat", {});
+    V(this, "pluginsByActionId", {});
+    V(this, "pluginsByFetcherId", {});
+    V(this, "actionPlugins", []);
+    V(this, "fetcherPlugins", []);
+  }
+  reset() {
+    this._pluginStore = Br(), this.plugins = [], this.pluginsByFormat = {}, this.pluginsByActionId = {}, this.pluginsByFetcherId = {}, this.actionPlugins = [], this.fetcherPlugins = [];
+  }
+  install(s) {
+    this.plugins.includes(s.name) || (console.log(`Installing plugin ${s.getPluginName()} by ${s.author}`), this.pluginStore.install(s), this.plugins.push(s.name), s.format && (this.pluginsByFormat[s.format] = [...this.pluginsByFormat[s.format] ?? [], s.name]), s.actionIds && s.actionResult && s.actionIds.forEach((t) => {
+      this.pluginsByActionId[t] = [...this.pluginsByActionId[t] ?? [], s.name];
+    }), s.fetcherIds && s.fetcherResult && s.fetcherIds.forEach((t) => {
+      this.pluginsByFetcherId[t] = [...this.pluginsByFetcherId[t] ?? [], s.name];
+    }), s.actionResult && this.actionPlugins.push(s.name), s.fetcherResult && this.fetcherPlugins.push(s.name));
+  }
+  /**
+   * Get plugins based on the given criteria.
+   *
+   * Only plugins that match format and result type criteria will be returned, which could be an empty list.
+   *
+   * If no criteria is provided all available plugins are returned.
+   *
+   * The order of the plugins matters, for example if a plugin specifies an action ID, it will be ordered before a
+   * plugin just specifies the format and result type.
+   *
+   * @param format filter plugins by this format
+   * @param resultType filter plugins by the result type that they accept (action or fetcher)
+   * @param actionId prefer plugins that specify this action ID
+   * @param fetcherId prefer plugins that specify this fetcher ID
+   * @returns an array of plugin names that match the given criteria
+   */
+  getPlugins(s, t, r, n) {
+    let u, l = /* @__PURE__ */ new Set(), f = [], o;
+    if (!s && !t && !r && !n)
+      return this.plugins;
+    if (r ? (u = this.pluginsByActionId[r], l = new Set(Object.values(this.pluginsByActionId).flat())) : n && (u = this.pluginsByFetcherId[n], l = new Set(Object.values(this.pluginsByFetcherId).flat())), o = t === "action" ? this.actionPlugins : t === "fetcher" ? this.fetcherPlugins : void 0, f = s ? this.pluginsByFormat[s] ?? [] : this.plugins, t && ((o == null ? void 0 : o.length) ?? 0) === 0)
+      return [];
+    let i = [];
+    return (r || n) && (u != null && u.length) && (i = f.filter((e) => u.includes(e))), t ? i = [
+      ...i,
+      ...o != null && o.length ? f.filter((e) => o.includes(e) && !l.has(e)) ?? [] : []
+    ] : s && (i = [...i, ...f.filter((e) => !l.has(e))]), rt(i);
+  }
+  getPlugin(s, t, r, n) {
+    const u = this.getPlugins(s, t, r, n);
+    return u.length > 0 ? u[0] : void 0;
+  }
+  getAvailableFormats(s) {
+    const t = Object.keys(this.pluginsByFormat);
+    return s ? t.filter((r) => this.pluginsByFormat[r].includes(s)) : t;
+  }
+  get pluginStore() {
+    return this._pluginStore;
+  }
+}
+const jt = new Ct();
+export {
+  Ct as C,
+  _t as P,
+  jt as c,
+  Gt as u
+};