vue-chrts 0.0.80 → 0.0.81

package/dist/index-HFl5iMMW.js

@@ -0,0 +1,2334 @@
+import { shallowRef as ce, defineComponent as Be, unref as Y, shallowReactive as Yt, reactive as Xt, inject as ee, computed as M, h as vt, provide as Oe, ref as _e, watch as oe, getCurrentInstance as fe, watchEffect as yt, nextTick as Ue, createElementBlock as He, openBlock as ze, createElementVNode as ye, renderSlot as Zt, toRef as en, readonly as Et, customRef as tn, onMounted as _t, hasInjectionContext as wt, getCurrentScope as nn, onScopeDispose as on, toValue as F, resolveComponent as Je, createVNode as pe, withCtx as rn, createApp as sn } from "vue";
+function an() {
+  return bt().__VUE_DEVTOOLS_GLOBAL_HOOK__;
+}
+function bt() {
+  return typeof navigator < "u" && typeof window < "u" ? window : typeof globalThis < "u" ? globalThis : {};
+}
+const cn = typeof Proxy == "function", ln = "devtools-plugin:setup", un = "plugin:settings:set";
+let Z, Te;
+function fn() {
+  var e;
+  return Z !== void 0 || (typeof window < "u" && window.performance ? (Z = !0, Te = window.performance) : typeof globalThis < "u" && (!((e = globalThis.perf_hooks) === null || e === void 0) && e.performance) ? (Z = !0, Te = globalThis.perf_hooks.performance) : Z = !1), Z;
+}
+function dn() {
+  return fn() ? Te.now() : Date.now();
+}
+class hn {
+  constructor(t, n) {
+    this.target = null, this.targetQueue = [], this.onQueue = [], this.plugin = t, this.hook = n;
+    const o = {};
+    if (t.settings)
+      for (const u in t.settings) {
+        const d = t.settings[u];
+        o[u] = d.defaultValue;
+      }
+    const r = `__vue-devtools-plugin-settings__${t.id}`;
+    let l = Object.assign({}, o);
+    try {
+      const u = localStorage.getItem(r), d = JSON.parse(u);
+      Object.assign(l, d);
+    } catch {
+    }
+    this.fallbacks = {
+      getSettings() {
+        return l;
+      },
+      setSettings(u) {
+        try {
+          localStorage.setItem(r, JSON.stringify(u));
+        } catch {
+        }
+        l = u;
+      },
+      now() {
+        return dn();
+      }
+    }, n && n.on(un, (u, d) => {
+      u === this.plugin.id && this.fallbacks.setSettings(d);
+    }), this.proxiedOn = new Proxy({}, {
+      get: (u, d) => this.target ? this.target.on[d] : (...a) => {
+        this.onQueue.push({
+          method: d,
+          args: a
+        });
+      }
+    }), this.proxiedTarget = new Proxy({}, {
+      get: (u, d) => this.target ? this.target[d] : d === "on" ? this.proxiedOn : Object.keys(this.fallbacks).includes(d) ? (...a) => (this.targetQueue.push({
+        method: d,
+        args: a,
+        resolve: () => {
+        }
+      }), this.fallbacks[d](...a)) : (...a) => new Promise((p) => {
+        this.targetQueue.push({
+          method: d,
+          args: a,
+          resolve: p
+        });
+      })
+    });
+  }
+  async setRealTarget(t) {
+    this.target = t;
+    for (const n of this.onQueue)
+      this.target.on[n.method](...n.args);
+    for (const n of this.targetQueue)
+      n.resolve(await this.target[n.method](...n.args));
+  }
+}
+function pn(e, t) {
+  const n = e, o = bt(), r = an(), l = cn && n.enableEarlyProxy;
+  if (r && (o.__VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__ || !l))
+    r.emit(ln, e, t);
+  else {
+    const u = l ? new hn(n, r) : null;
+    (o.__VUE_DEVTOOLS_PLUGINS__ = o.__VUE_DEVTOOLS_PLUGINS__ || []).push({
+      pluginDescriptor: n,
+      setupFn: t,
+      proxy: u
+    }), u && t(u.proxiedTarget);
+  }
+}
+/*!
+  * vue-router v4.5.0
+  * (c) 2024 Eduardo San Martin Morote
+  * @license MIT
+  */
+const z = typeof document < "u";
+function St(e) {
+  return typeof e == "object" || "displayName" in e || "props" in e || "__vccOpts" in e;
+}
+function mn(e) {
+  return e.__esModule || e[Symbol.toStringTag] === "Module" || // support CF with dynamic imports that do not
+  // add the Module string tag
+  e.default && St(e.default);
+}
+const P = Object.assign;
+function Pe(e, t) {
+  const n = {};
+  for (const o in t) {
+    const r = t[o];
+    n[o] = B(r) ? r.map(e) : e(r);
+  }
+  return n;
+}
+const ie = () => {
+}, B = Array.isArray;
+function S(e) {
+  const t = Array.from(arguments).slice(1);
+  console.warn.apply(console, ["[Vue Router warn]: " + e].concat(t));
+}
+const Rt = /#/g, gn = /&/g, vn = /\//g, yn = /=/g, En = /\?/g, Nt = /\+/g, _n = /%5B/g, wn = /%5D/g, kt = /%5E/g, bn = /%60/g, Ot = /%7B/g, Sn = /%7C/g, Pt = /%7D/g, Rn = /%20/g;
+function Ge(e) {
+  return encodeURI("" + e).replace(Sn, "|").replace(_n, "[").replace(wn, "]");
+}
+function Nn(e) {
+  return Ge(e).replace(Ot, "{").replace(Pt, "}").replace(kt, "^");
+}
+function Ve(e) {
+  return Ge(e).replace(Nt, "%2B").replace(Rn, "+").replace(Rt, "%23").replace(gn, "%26").replace(bn, "`").replace(Ot, "{").replace(Pt, "}").replace(kt, "^");
+}
+function kn(e) {
+  return Ve(e).replace(yn, "%3D");
+}
+function On(e) {
+  return Ge(e).replace(Rt, "%23").replace(En, "%3F");
+}
+function Pn(e) {
+  return e == null ? "" : On(e).replace(vn, "%2F");
+}
+function te(e) {
+  try {
+    return decodeURIComponent("" + e);
+  } catch {
+    process.env.NODE_ENV !== "production" && S(`Error decoding "${e}". Using original value`);
+  }
+  return "" + e;
+}
+const Cn = /\/$/, An = (e) => e.replace(Cn, "");
+function Ce(e, t, n = "/") {
+  let o, r = {}, l = "", u = "";
+  const d = t.indexOf("#");
+  let a = t.indexOf("?");
+  return d < a && d >= 0 && (a = -1), a > -1 && (o = t.slice(0, a), l = t.slice(a + 1, d > -1 ? d : t.length), r = e(l)), d > -1 && (o = o || t.slice(0, d), u = t.slice(d, t.length)), o = Tn(o ?? t, n), {
+    fullPath: o + (l && "?") + l + u,
+    path: o,
+    query: r,
+    hash: te(u)
+  };
+}
+function $n(e, t) {
+  const n = t.query ? e(t.query) : "";
+  return t.path + (n && "?") + n + (t.hash || "");
+}
+function Ye(e, t) {
+  return !t || !e.toLowerCase().startsWith(t.toLowerCase()) ? e : e.slice(t.length) || "/";
+}
+function Xe(e, t, n) {
+  const o = t.matched.length - 1, r = n.matched.length - 1;
+  return o > -1 && o === r && q(t.matched[o], n.matched[r]) && Ct(t.params, n.params) && e(t.query) === e(n.query) && t.hash === n.hash;
+}
+function q(e, t) {
+  return (e.aliasOf || e) === (t.aliasOf || t);
+}
+function Ct(e, t) {
+  if (Object.keys(e).length !== Object.keys(t).length)
+    return !1;
+  for (const n in e)
+    if (!xn(e[n], t[n]))
+      return !1;
+  return !0;
+}
+function xn(e, t) {
+  return B(e) ? Ze(e, t) : B(t) ? Ze(t, e) : e === t;
+}
+function Ze(e, t) {
+  return B(t) ? e.length === t.length && e.every((n, o) => n === t[o]) : e.length === 1 && e[0] === t;
+}
+function Tn(e, t) {
+  if (e.startsWith("/"))
+    return e;
+  if (process.env.NODE_ENV !== "production" && !t.startsWith("/"))
+    return S(`Cannot resolve a relative location without an absolute path. Trying to resolve "${e}" from "${t}". It should look like "/${t}".`), e;
+  if (!e)
+    return t;
+  const n = t.split("/"), o = e.split("/"), r = o[o.length - 1];
+  (r === ".." || r === ".") && o.push("");
+  let l = n.length - 1, u, d;
+  for (u = 0; u < o.length; u++)
+    if (d = o[u], d !== ".")
+      if (d === "..")
+        l > 1 && l--;
+      else
+        break;
+  return n.slice(0, l).join("/") + "/" + o.slice(u).join("/");
+}
+const G = {
+  path: "/",
+  // TODO: could we use a symbol in the future?
+  name: void 0,
+  params: {},
+  query: {},
+  hash: "",
+  fullPath: "/",
+  matched: [],
+  meta: {},
+  redirectedFrom: void 0
+};
+var le;
+(function(e) {
+  e.pop = "pop", e.push = "push";
+})(le || (le = {}));
+var ae;
+(function(e) {
+  e.back = "back", e.forward = "forward", e.unknown = "";
+})(ae || (ae = {}));
+function Vn(e) {
+  if (!e)
+    if (z) {
+      const t = document.querySelector("base");
+      e = t && t.getAttribute("href") || "/", e = e.replace(/^\w+:\/\/[^\/]+/, "");
+    } else
+      e = "/";
+  return e[0] !== "/" && e[0] !== "#" && (e = "/" + e), An(e);
+}
+const Dn = /^[^#]+#/;
+function In(e, t) {
+  return e.replace(Dn, "#") + t;
+}
+function Mn(e, t) {
+  const n = document.documentElement.getBoundingClientRect(), o = e.getBoundingClientRect();
+  return {
+    behavior: t.behavior,
+    left: o.left - n.left - (t.left || 0),
+    top: o.top - n.top - (t.top || 0)
+  };
+}
+const we = () => ({
+  left: window.scrollX,
+  top: window.scrollY
+});
+function jn(e) {
+  let t;
+  if ("el" in e) {
+    const n = e.el, o = typeof n == "string" && n.startsWith("#");
+    if (process.env.NODE_ENV !== "production" && typeof e.el == "string" && (!o || !document.getElementById(e.el.slice(1))))
+      try {
+        const l = document.querySelector(e.el);
+        if (o && l) {
+          S(`The selector "${e.el}" should be passed as "el: document.querySelector('${e.el}')" because it starts with "#".`);
+          return;
+        }
+      } catch {
+        S(`The selector "${e.el}" is invalid. If you are using an id selector, make sure to escape it. You can find more information about escaping characters in selectors at https://mathiasbynens.be/notes/css-escapes or use CSS.escape (https://developer.mozilla.org/en-US/docs/Web/API/CSS/escape).`);
+        return;
+      }
+    const r = typeof n == "string" ? o ? document.getElementById(n.slice(1)) : document.querySelector(n) : n;
+    if (!r) {
+      process.env.NODE_ENV !== "production" && S(`Couldn't find element using selector "${e.el}" returned by scrollBehavior.`);
+      return;
+    }
+    t = Mn(r, e);
+  } else
+    t = e;
+  "scrollBehavior" in document.documentElement.style ? window.scrollTo(t) : window.scrollTo(t.left != null ? t.left : window.scrollX, t.top != null ? t.top : window.scrollY);
+}
+function et(e, t) {
+  return (history.state ? history.state.position - t : -1) + e;
+}
+const De = /* @__PURE__ */ new Map();
+function Ln(e, t) {
+  De.set(e, t);
+}
+function Wn(e) {
+  const t = De.get(e);
+  return De.delete(e), t;
+}
+let Bn = () => location.protocol + "//" + location.host;
+function At(e, t) {
+  const { pathname: n, search: o, hash: r } = t, l = e.indexOf("#");
+  if (l > -1) {
+    let d = r.includes(e.slice(l)) ? e.slice(l).length : 1, a = r.slice(d);
+    return a[0] !== "/" && (a = "/" + a), Ye(a, "");
+  }
+  return Ye(n, e) + o + r;
+}
+function Un(e, t, n, o) {
+  let r = [], l = [], u = null;
+  const d = ({ state: c }) => {
+    const h = At(e, location), v = n.value, E = t.value;
+    let w = 0;
+    if (c) {
+      if (n.value = h, t.value = c, u && u === v) {
+        u = null;
+        return;
+      }
+      w = E ? c.position - E.position : 0;
+    } else
+      o(h);
+    r.forEach((N) => {
+      N(n.value, v, {
+        delta: w,
+        type: le.pop,
+        direction: w ? w > 0 ? ae.forward : ae.back : ae.unknown
+      });
+    });
+  };
+  function a() {
+    u = n.value;
+  }
+  function p(c) {
+    r.push(c);
+    const h = () => {
+      const v = r.indexOf(c);
+      v > -1 && r.splice(v, 1);
+    };
+    return l.push(h), h;
+  }
+  function i() {
+    const { history: c } = window;
+    c.state && c.replaceState(P({}, c.state, { scroll: we() }), "");
+  }
+  function s() {
+    for (const c of l)
+      c();
+    l = [], window.removeEventListener("popstate", d), window.removeEventListener("beforeunload", i);
+  }
+  return window.addEventListener("popstate", d), window.addEventListener("beforeunload", i, {
+    passive: !0
+  }), {
+    pauseListeners: a,
+    listen: p,
+    destroy: s
+  };
+}
+function tt(e, t, n, o = !1, r = !1) {
+  return {
+    back: e,
+    current: t,
+    forward: n,
+    replaced: o,
+    position: window.history.length,
+    scroll: r ? we() : null
+  };
+}
+function Hn(e) {
+  const { history: t, location: n } = window, o = {
+    value: At(e, n)
+  }, r = { value: t.state };
+  r.value || l(o.value, {
+    back: null,
+    current: o.value,
+    forward: null,
+    // the length is off by one, we need to decrease it
+    position: t.length - 1,
+    replaced: !0,
+    // don't add a scroll as the user may have an anchor, and we want
+    // scrollBehavior to be triggered without a saved position
+    scroll: null
+  }, !0);
+  function l(a, p, i) {
+    const s = e.indexOf("#"), c = s > -1 ? (n.host && document.querySelector("base") ? e : e.slice(s)) + a : Bn() + e + a;
+    try {
+      t[i ? "replaceState" : "pushState"](p, "", c), r.value = p;
+    } catch (h) {
+      process.env.NODE_ENV !== "production" ? S("Error with push/replace State", h) : console.error(h), n[i ? "replace" : "assign"](c);
+    }
+  }
+  function u(a, p) {
+    const i = P({}, t.state, tt(
+      r.value.back,
+      // keep back and forward entries but override current position
+      a,
+      r.value.forward,
+      !0
+    ), p, { position: r.value.position });
+    l(a, i, !0), o.value = a;
+  }
+  function d(a, p) {
+    const i = P(
+      {},
+      // use current history state to gracefully handle a wrong call to
+      // history.replaceState
+      // https://github.com/vuejs/router/issues/366
+      r.value,
+      t.state,
+      {
+        forward: a,
+        scroll: we()
+      }
+    );
+    process.env.NODE_ENV !== "production" && !t.state && S(`history.state seems to have been manually replaced without preserving the necessary values. Make sure to preserve existing history state if you are manually calling history.replaceState:
+
+history.replaceState(history.state, '', url)
+
+You can find more information at https://router.vuejs.org/guide/migration/#Usage-of-history-state`), l(i.current, i, !0);
+    const s = P({}, tt(o.value, a, null), { position: i.position + 1 }, p);
+    l(a, s, !1), o.value = a;
+  }
+  return {
+    location: o,
+    state: r,
+    push: d,
+    replace: u
+  };
+}
+function zn(e) {
+  e = Vn(e);
+  const t = Hn(e), n = Un(e, t.state, t.location, t.replace);
+  function o(l, u = !0) {
+    u || n.pauseListeners(), history.go(l);
+  }
+  const r = P({
+    // it's overridden right after
+    location: "",
+    base: e,
+    go: o,
+    createHref: In.bind(null, e)
+  }, t, n);
+  return Object.defineProperty(r, "location", {
+    enumerable: !0,
+    get: () => t.location.value
+  }), Object.defineProperty(r, "state", {
+    enumerable: !0,
+    get: () => t.state.value
+  }), r;
+}
+function Ee(e) {
+  return typeof e == "string" || e && typeof e == "object";
+}
+function $t(e) {
+  return typeof e == "string" || typeof e == "symbol";
+}
+const Ie = Symbol(process.env.NODE_ENV !== "production" ? "navigation failure" : "");
+var nt;
+(function(e) {
+  e[e.aborted = 4] = "aborted", e[e.cancelled = 8] = "cancelled", e[e.duplicated = 16] = "duplicated";
+})(nt || (nt = {}));
+const Gn = {
+  1({ location: e, currentLocation: t }) {
+    return `No match for
+ ${JSON.stringify(e)}${t ? `
+while being at
+` + JSON.stringify(t) : ""}`;
+  },
+  2({ from: e, to: t }) {
+    return `Redirected from "${e.fullPath}" to "${Fn(t)}" via a navigation guard.`;
+  },
+  4({ from: e, to: t }) {
+    return `Navigation aborted from "${e.fullPath}" to "${t.fullPath}" via a navigation guard.`;
+  },
+  8({ from: e, to: t }) {
+    return `Navigation cancelled from "${e.fullPath}" to "${t.fullPath}" with a new navigation.`;
+  },
+  16({ from: e, to: t }) {
+    return `Avoided redundant navigation to current location: "${e.fullPath}".`;
+  }
+};
+function ne(e, t) {
+  return process.env.NODE_ENV !== "production" ? P(new Error(Gn[e](t)), {
+    type: e,
+    [Ie]: !0
+  }, t) : P(new Error(), {
+    type: e,
+    [Ie]: !0
+  }, t);
+}
+function H(e, t) {
+  return e instanceof Error && Ie in e && (t == null || !!(e.type & t));
+}
+const Kn = ["params", "query", "hash"];
+function Fn(e) {
+  if (typeof e == "string")
+    return e;
+  if (e.path != null)
+    return e.path;
+  const t = {};
+  for (const n of Kn)
+    n in e && (t[n] = e[n]);
+  return JSON.stringify(t, null, 2);
+}
+const ot = "[^/]+?", qn = {
+  sensitive: !1,
+  strict: !1,
+  start: !0,
+  end: !0
+}, Qn = /[.+*?^${}()[\]/\\]/g;
+function Jn(e, t) {
+  const n = P({}, qn, t), o = [];
+  let r = n.start ? "^" : "";
+  const l = [];
+  for (const p of e) {
+    const i = p.length ? [] : [
+      90
+      /* PathScore.Root */
+    ];
+    n.strict && !p.length && (r += "/");
+    for (let s = 0; s < p.length; s++) {
+      const c = p[s];
+      let h = 40 + (n.sensitive ? 0.25 : 0);
+      if (c.type === 0)
+        s || (r += "/"), r += c.value.replace(Qn, "\\$&"), h += 40;
+      else if (c.type === 1) {
+        const { value: v, repeatable: E, optional: w, regexp: N } = c;
+        l.push({
+          name: v,
+          repeatable: E,
+          optional: w
+        });
+        const b = N || ot;
+        if (b !== ot) {
+          h += 10;
+          try {
+            new RegExp(`(${b})`);
+          } catch (A) {
+            throw new Error(`Invalid custom RegExp for param "${v}" (${b}): ` + A.message);
+          }
+        }
+        let _ = E ? `((?:${b})(?:/(?:${b}))*)` : `(${b})`;
+        s || (_ = // avoid an optional / if there are more segments e.g. /:p?-static
+        // or /:p?-:p2
+        w && p.length < 2 ? `(?:/${_})` : "/" + _), w && (_ += "?"), r += _, h += 20, w && (h += -8), E && (h += -20), b === ".*" && (h += -50);
+      }
+      i.push(h);
+    }
+    o.push(i);
+  }
+  if (n.strict && n.end) {
+    const p = o.length - 1;
+    o[p][o[p].length - 1] += 0.7000000000000001;
+  }
+  n.strict || (r += "/?"), n.end ? r += "$" : n.strict && !r.endsWith("/") && (r += "(?:/|$)");
+  const u = new RegExp(r, n.sensitive ? "" : "i");
+  function d(p) {
+    const i = p.match(u), s = {};
+    if (!i)
+      return null;
+    for (let c = 1; c < i.length; c++) {
+      const h = i[c] || "", v = l[c - 1];
+      s[v.name] = h && v.repeatable ? h.split("/") : h;
+    }
+    return s;
+  }
+  function a(p) {
+    let i = "", s = !1;
+    for (const c of e) {
+      (!s || !i.endsWith("/")) && (i += "/"), s = !1;
+      for (const h of c)
+        if (h.type === 0)
+          i += h.value;
+        else if (h.type === 1) {
+          const { value: v, repeatable: E, optional: w } = h, N = v in p ? p[v] : "";
+          if (B(N) && !E)
+            throw new Error(`Provided param "${v}" is an array but it is not repeatable (* or + modifiers)`);
+          const b = B(N) ? N.join("/") : N;
+          if (!b)
+            if (w)
+              c.length < 2 && (i.endsWith("/") ? i = i.slice(0, -1) : s = !0);
+            else
+              throw new Error(`Missing required param "${v}"`);
+          i += b;
+        }
+    }
+    return i || "/";
+  }
+  return {
+    re: u,
+    score: o,
+    keys: l,
+    parse: d,
+    stringify: a
+  };
+}
+function Yn(e, t) {
+  let n = 0;
+  for (; n < e.length && n < t.length; ) {
+    const o = t[n] - e[n];
+    if (o)
+      return o;
+    n++;
+  }
+  return e.length < t.length ? e.length === 1 && e[0] === 80 ? -1 : 1 : e.length > t.length ? t.length === 1 && t[0] === 80 ? 1 : -1 : 0;
+}
+function xt(e, t) {
+  let n = 0;
+  const o = e.score, r = t.score;
+  for (; n < o.length && n < r.length; ) {
+    const l = Yn(o[n], r[n]);
+    if (l)
+      return l;
+    n++;
+  }
+  if (Math.abs(r.length - o.length) === 1) {
+    if (rt(o))
+      return 1;
+    if (rt(r))
+      return -1;
+  }
+  return r.length - o.length;
+}
+function rt(e) {
+  const t = e[e.length - 1];
+  return e.length > 0 && t[t.length - 1] < 0;
+}
+const Xn = {
+  type: 0,
+  value: ""
+}, Zn = /[a-zA-Z0-9_]/;
+function eo(e) {
+  if (!e)
+    return [[]];
+  if (e === "/")
+    return [[Xn]];
+  if (!e.startsWith("/"))
+    throw new Error(process.env.NODE_ENV !== "production" ? `Route paths should start with a "/": "${e}" should be "/${e}".` : `Invalid path "${e}"`);
+  function t(h) {
+    throw new Error(`ERR (${n})/"${p}": ${h}`);
+  }
+  let n = 0, o = n;
+  const r = [];
+  let l;
+  function u() {
+    l && r.push(l), l = [];
+  }
+  let d = 0, a, p = "", i = "";
+  function s() {
+    p && (n === 0 ? l.push({
+      type: 0,
+      value: p
+    }) : n === 1 || n === 2 || n === 3 ? (l.length > 1 && (a === "*" || a === "+") && t(`A repeatable param (${p}) must be alone in its segment. eg: '/:ids+.`), l.push({
+      type: 1,
+      value: p,
+      regexp: i,
+      repeatable: a === "*" || a === "+",
+      optional: a === "*" || a === "?"
+    })) : t("Invalid state to consume buffer"), p = "");
+  }
+  function c() {
+    p += a;
+  }
+  for (; d < e.length; ) {
+    if (a = e[d++], a === "\\" && n !== 2) {
+      o = n, n = 4;
+      continue;
+    }
+    switch (n) {
+      case 0:
+        a === "/" ? (p && s(), u()) : a === ":" ? (s(), n = 1) : c();
+        break;
+      case 4:
+        c(), n = o;
+        break;
+      case 1:
+        a === "(" ? n = 2 : Zn.test(a) ? c() : (s(), n = 0, a !== "*" && a !== "?" && a !== "+" && d--);
+        break;
+      case 2:
+        a === ")" ? i[i.length - 1] == "\\" ? i = i.slice(0, -1) + a : n = 3 : i += a;
+        break;
+      case 3:
+        s(), n = 0, a !== "*" && a !== "?" && a !== "+" && d--, i = "";
+        break;
+      default:
+        t("Unknown state");
+        break;
+    }
+  }
+  return n === 2 && t(`Unfinished custom RegExp for param "${p}"`), s(), u(), r;
+}
+function to(e, t, n) {
+  const o = Jn(eo(e.path), n);
+  if (process.env.NODE_ENV !== "production") {
+    const l = /* @__PURE__ */ new Set();
+    for (const u of o.keys)
+      l.has(u.name) && S(`Found duplicated params with name "${u.name}" for path "${e.path}". Only the last one will be available on "$route.params".`), l.add(u.name);
+  }
+  const r = P(o, {
+    record: e,
+    parent: t,
+    // these needs to be populated by the parent
+    children: [],
+    alias: []
+  });
+  return t && !r.record.aliasOf == !t.record.aliasOf && t.children.push(r), r;
+}
+function no(e, t) {
+  const n = [], o = /* @__PURE__ */ new Map();
+  t = ct({ strict: !1, end: !0, sensitive: !1 }, t);
+  function r(s) {
+    return o.get(s);
+  }
+  function l(s, c, h) {
+    const v = !h, E = it(s);
+    process.env.NODE_ENV !== "production" && io(E, c), E.aliasOf = h && h.record;
+    const w = ct(t, s), N = [E];
+    if ("alias" in s) {
+      const A = typeof s.alias == "string" ? [s.alias] : s.alias;
+      for (const D of A)
+        N.push(
+          // we need to normalize again to ensure the `mods` property
+          // being non enumerable
+          it(P({}, E, {
+            // this allows us to hold a copy of the `components` option
+            // so that async components cache is hold on the original record
+            components: h ? h.record.components : E.components,
+            path: D,
+            // we might be the child of an alias
+            aliasOf: h ? h.record : E
+            // the aliases are always of the same kind as the original since they
+            // are defined on the same record
+          }))
+        );
+    }
+    let b, _;
+    for (const A of N) {
+      const { path: D } = A;
+      if (c && D[0] !== "/") {
+        const L = c.record.path, I = L[L.length - 1] === "/" ? "" : "/";
+        A.path = c.record.path + (D && I + D);
+      }
+      if (process.env.NODE_ENV !== "production" && A.path === "*")
+        throw new Error(`Catch all routes ("*") must now be defined using a param with a custom regexp.
+See more at https://router.vuejs.org/guide/migration/#Removed-star-or-catch-all-routes.`);
+      if (b = to(A, c, w), process.env.NODE_ENV !== "production" && c && D[0] === "/" && co(b, c), h ? (h.alias.push(b), process.env.NODE_ENV !== "production" && so(h, b)) : (_ = _ || b, _ !== b && _.alias.push(b), v && s.name && !at(b) && (process.env.NODE_ENV !== "production" && ao(s, c), u(s.name))), Tt(b) && a(b), E.children) {
+        const L = E.children;
+        for (let I = 0; I < L.length; I++)
+          l(L[I], b, h && h.children[I]);
+      }
+      h = h || b;
+    }
+    return _ ? () => {
+      u(_);
+    } : ie;
+  }
+  function u(s) {
+    if ($t(s)) {
+      const c = o.get(s);
+      c && (o.delete(s), n.splice(n.indexOf(c), 1), c.children.forEach(u), c.alias.forEach(u));
+    } else {
+      const c = n.indexOf(s);
+      c > -1 && (n.splice(c, 1), s.record.name && o.delete(s.record.name), s.children.forEach(u), s.alias.forEach(u));
+    }
+  }
+  function d() {
+    return n;
+  }
+  function a(s) {
+    const c = lo(s, n);
+    n.splice(c, 0, s), s.record.name && !at(s) && o.set(s.record.name, s);
+  }
+  function p(s, c) {
+    let h, v = {}, E, w;
+    if ("name" in s && s.name) {
+      if (h = o.get(s.name), !h)
+        throw ne(1, {
+          location: s
+        });
+      if (process.env.NODE_ENV !== "production") {
+        const _ = Object.keys(s.params || {}).filter((A) => !h.keys.find((D) => D.name === A));
+        _.length && S(`Discarded invalid param(s) "${_.join('", "')}" when navigating. See https://github.com/vuejs/router/blob/main/packages/router/CHANGELOG.md#414-2022-08-22 for more details.`);
+      }
+      w = h.record.name, v = P(
+        // paramsFromLocation is a new object
+        st(
+          c.params,
+          // only keep params that exist in the resolved location
+          // only keep optional params coming from a parent record
+          h.keys.filter((_) => !_.optional).concat(h.parent ? h.parent.keys.filter((_) => _.optional) : []).map((_) => _.name)
+        ),
+        // discard any existing params in the current location that do not exist here
+        // #1497 this ensures better active/exact matching
+        s.params && st(s.params, h.keys.map((_) => _.name))
+      ), E = h.stringify(v);
+    } else if (s.path != null)
+      E = s.path, process.env.NODE_ENV !== "production" && !E.startsWith("/") && S(`The Matcher cannot resolve relative paths but received "${E}". Unless you directly called \`matcher.resolve("${E}")\`, this is probably a bug in vue-router. Please open an issue at https://github.com/vuejs/router/issues/new/choose.`), h = n.find((_) => _.re.test(E)), h && (v = h.parse(E), w = h.record.name);
+    else {
+      if (h = c.name ? o.get(c.name) : n.find((_) => _.re.test(c.path)), !h)
+        throw ne(1, {
+          location: s,
+          currentLocation: c
+        });
+      w = h.record.name, v = P({}, c.params, s.params), E = h.stringify(v);
+    }
+    const N = [];
+    let b = h;
+    for (; b; )
+      N.unshift(b.record), b = b.parent;
+    return {
+      name: w,
+      path: E,
+      params: v,
+      matched: N,
+      meta: ro(N)
+    };
+  }
+  e.forEach((s) => l(s));
+  function i() {
+    n.length = 0, o.clear();
+  }
+  return {
+    addRoute: l,
+    resolve: p,
+    removeRoute: u,
+    clearRoutes: i,
+    getRoutes: d,
+    getRecordMatcher: r
+  };
+}
+function st(e, t) {
+  const n = {};
+  for (const o of t)
+    o in e && (n[o] = e[o]);
+  return n;
+}
+function it(e) {
+  const t = {
+    path: e.path,
+    redirect: e.redirect,
+    name: e.name,
+    meta: e.meta || {},
+    aliasOf: e.aliasOf,
+    beforeEnter: e.beforeEnter,
+    props: oo(e),
+    children: e.children || [],
+    instances: {},
+    leaveGuards: /* @__PURE__ */ new Set(),
+    updateGuards: /* @__PURE__ */ new Set(),
+    enterCallbacks: {},
+    // must be declared afterwards
+    // mods: {},
+    components: "components" in e ? e.components || null : e.component && { default: e.component }
+  };
+  return Object.defineProperty(t, "mods", {
+    value: {}
+  }), t;
+}
+function oo(e) {
+  const t = {}, n = e.props || !1;
+  if ("component" in e)
+    t.default = n;
+  else
+    for (const o in e.components)
+      t[o] = typeof n == "object" ? n[o] : n;
+  return t;
+}
+function at(e) {
+  for (; e; ) {
+    if (e.record.aliasOf)
+      return !0;
+    e = e.parent;
+  }
+  return !1;
+}
+function ro(e) {
+  return e.reduce((t, n) => P(t, n.meta), {});
+}
+function ct(e, t) {
+  const n = {};
+  for (const o in e)
+    n[o] = o in t ? t[o] : e[o];
+  return n;
+}
+function Me(e, t) {
+  return e.name === t.name && e.optional === t.optional && e.repeatable === t.repeatable;
+}
+function so(e, t) {
+  for (const n of e.keys)
+    if (!n.optional && !t.keys.find(Me.bind(null, n)))
+      return S(`Alias "${t.record.path}" and the original record: "${e.record.path}" must have the exact same param named "${n.name}"`);
+  for (const n of t.keys)
+    if (!n.optional && !e.keys.find(Me.bind(null, n)))
+      return S(`Alias "${t.record.path}" and the original record: "${e.record.path}" must have the exact same param named "${n.name}"`);
+}
+function io(e, t) {
+  t && t.record.name && !e.name && !e.path && S(`The route named "${String(t.record.name)}" has a child without a name and an empty path. Using that name won't render the empty path child so you probably want to move the name to the child instead. If this is intentional, add a name to the child route to remove the warning.`);
+}
+function ao(e, t) {
+  for (let n = t; n; n = n.parent)
+    if (n.record.name === e.name)
+      throw new Error(`A route named "${String(e.name)}" has been added as a ${t === n ? "child" : "descendant"} of a route with the same name. Route names must be unique and a nested route cannot use the same name as an ancestor.`);
+}
+function co(e, t) {
+  for (const n of t.keys)
+    if (!e.keys.find(Me.bind(null, n)))
+      return S(`Absolute path "${e.record.path}" must have the exact same param named "${n.name}" as its parent "${t.record.path}".`);
+}
+function lo(e, t) {
+  let n = 0, o = t.length;
+  for (; n !== o; ) {
+    const l = n + o >> 1;
+    xt(e, t[l]) < 0 ? o = l : n = l + 1;
+  }
+  const r = uo(e);
+  return r && (o = t.lastIndexOf(r, o - 1), process.env.NODE_ENV !== "production" && o < 0 && S(`Finding ancestor route "${r.record.path}" failed for "${e.record.path}"`)), o;
+}
+function uo(e) {
+  let t = e;
+  for (; t = t.parent; )
+    if (Tt(t) && xt(e, t) === 0)
+      return t;
+}
+function Tt({ record: e }) {
+  return !!(e.name || e.components && Object.keys(e.components).length || e.redirect);
+}
+function fo(e) {
+  const t = {};
+  if (e === "" || e === "?")
+    return t;
+  const o = (e[0] === "?" ? e.slice(1) : e).split("&");
+  for (let r = 0; r < o.length; ++r) {
+    const l = o[r].replace(Nt, " "), u = l.indexOf("="), d = te(u < 0 ? l : l.slice(0, u)), a = u < 0 ? null : te(l.slice(u + 1));
+    if (d in t) {
+      let p = t[d];
+      B(p) || (p = t[d] = [p]), p.push(a);
+    } else
+      t[d] = a;
+  }
+  return t;
+}
+function lt(e) {
+  let t = "";
+  for (let n in e) {
+    const o = e[n];
+    if (n = kn(n), o == null) {
+      o !== void 0 && (t += (t.length ? "&" : "") + n);
+      continue;
+    }
+    (B(o) ? o.map((l) => l && Ve(l)) : [o && Ve(o)]).forEach((l) => {
+      l !== void 0 && (t += (t.length ? "&" : "") + n, l != null && (t += "=" + l));
+    });
+  }
+  return t;
+}
+function ho(e) {
+  const t = {};
+  for (const n in e) {
+    const o = e[n];
+    o !== void 0 && (t[n] = B(o) ? o.map((r) => r == null ? null : "" + r) : o == null ? o : "" + o);
+  }
+  return t;
+}
+const po = Symbol(process.env.NODE_ENV !== "production" ? "router view location matched" : ""), ut = Symbol(process.env.NODE_ENV !== "production" ? "router view depth" : ""), Ke = Symbol(process.env.NODE_ENV !== "production" ? "router" : ""), Vt = Symbol(process.env.NODE_ENV !== "production" ? "route location" : ""), je = Symbol(process.env.NODE_ENV !== "production" ? "router view location" : "");
+function re() {
+  let e = [];
+  function t(o) {
+    return e.push(o), () => {
+      const r = e.indexOf(o);
+      r > -1 && e.splice(r, 1);
+    };
+  }
+  function n() {
+    e = [];
+  }
+  return {
+    add: t,
+    list: () => e.slice(),
+    reset: n
+  };
+}
+function K(e, t, n, o, r, l = (u) => u()) {
+  const u = o && // name is defined if record is because of the function overload
+  (o.enterCallbacks[r] = o.enterCallbacks[r] || []);
+  return () => new Promise((d, a) => {
+    const p = (c) => {
+      c === !1 ? a(ne(4, {
+        from: n,
+        to: t
+      })) : c instanceof Error ? a(c) : Ee(c) ? a(ne(2, {
+        from: t,
+        to: c
+      })) : (u && // since enterCallbackArray is truthy, both record and name also are
+      o.enterCallbacks[r] === u && typeof c == "function" && u.push(c), d());
+    }, i = l(() => e.call(o && o.instances[r], t, n, process.env.NODE_ENV !== "production" ? mo(p, t, n) : p));
+    let s = Promise.resolve(i);
+    if (e.length < 3 && (s = s.then(p)), process.env.NODE_ENV !== "production" && e.length > 2) {
+      const c = `The "next" callback was never called inside of ${e.name ? '"' + e.name + '"' : ""}:
+${e.toString()}
+. If you are returning a value instead of calling "next", make sure to remove the "next" parameter from your function.`;
+      if (typeof i == "object" && "then" in i)
+        s = s.then((h) => p._called ? h : (S(c), Promise.reject(new Error("Invalid navigation guard"))));
+      else if (i !== void 0 && !p._called) {
+        S(c), a(new Error("Invalid navigation guard"));
+        return;
+      }
+    }
+    s.catch((c) => a(c));
+  });
+}
+function mo(e, t, n) {
+  let o = 0;
+  return function() {
+    o++ === 1 && S(`The "next" callback was called more than once in one navigation guard when going from "${n.fullPath}" to "${t.fullPath}". It should be called exactly one time in each navigation guard. This will fail in production.`), e._called = !0, o === 1 && e.apply(null, arguments);
+  };
+}
+function Ae(e, t, n, o, r = (l) => l()) {
+  const l = [];
+  for (const u of e) {
+    process.env.NODE_ENV !== "production" && !u.components && !u.children.length && S(`Record with path "${u.path}" is either missing a "component(s)" or "children" property.`);
+    for (const d in u.components) {
+      let a = u.components[d];
+      if (process.env.NODE_ENV !== "production") {
+        if (!a || typeof a != "object" && typeof a != "function")
+          throw S(`Component "${d}" in record with path "${u.path}" is not a valid component. Received "${String(a)}".`), new Error("Invalid route component");
+        if ("then" in a) {
+          S(`Component "${d}" in record with path "${u.path}" is a Promise instead of a function that returns a Promise. Did you write "import('./MyPage.vue')" instead of "() => import('./MyPage.vue')" ? This will break in production if not fixed.`);
+          const p = a;
+          a = () => p;
+        } else a.__asyncLoader && // warn only once per component
+        !a.__warnedDefineAsync && (a.__warnedDefineAsync = !0, S(`Component "${d}" in record with path "${u.path}" is defined using "defineAsyncComponent()". Write "() => import('./MyPage.vue')" instead of "defineAsyncComponent(() => import('./MyPage.vue'))".`));
+      }
+      if (!(t !== "beforeRouteEnter" && !u.instances[d]))
+        if (St(a)) {
+          const i = (a.__vccOpts || a)[t];
+          i && l.push(K(i, n, o, u, d, r));
+        } else {
+          let p = a();
+          process.env.NODE_ENV !== "production" && !("catch" in p) && (S(`Component "${d}" in record with path "${u.path}" is a function that does not return a Promise. If you were passing a functional component, make sure to add a "displayName" to the component. This will break in production if not fixed.`), p = Promise.resolve(p)), l.push(() => p.then((i) => {
+            if (!i)
+              throw new Error(`Couldn't resolve component "${d}" at "${u.path}"`);
+            const s = mn(i) ? i.default : i;
+            u.mods[d] = i, u.components[d] = s;
+            const h = (s.__vccOpts || s)[t];
+            return h && K(h, n, o, u, d, r)();
+          }));
+        }
+    }
+  }
+  return l;
+}
+function ft(e) {
+  const t = ee(Ke), n = ee(Vt);
+  let o = !1, r = null;
+  const l = M(() => {
+    const i = Y(e.to);
+    return process.env.NODE_ENV !== "production" && (!o || i !== r) && (Ee(i) || (o ? S(`Invalid value for prop "to" in useLink()
+- to:`, i, `
+- previous to:`, r, `
+- props:`, e) : S(`Invalid value for prop "to" in useLink()
+- to:`, i, `
+- props:`, e)), r = i, o = !0), t.resolve(i);
+  }), u = M(() => {
+    const { matched: i } = l.value, { length: s } = i, c = i[s - 1], h = n.matched;
+    if (!c || !h.length)
+      return -1;
+    const v = h.findIndex(q.bind(null, c));
+    if (v > -1)
+      return v;
+    const E = dt(i[s - 2]);
+    return (
+      // we are dealing with nested routes
+      s > 1 && // if the parent and matched route have the same path, this link is
+      // referring to the empty child. Or we currently are on a different
+      // child of the same parent
+      dt(c) === E && // avoid comparing the child with its parent
+      h[h.length - 1].path !== E ? h.findIndex(q.bind(null, i[s - 2])) : v
+    );
+  }), d = M(() => u.value > -1 && _o(n.params, l.value.params)), a = M(() => u.value > -1 && u.value === n.matched.length - 1 && Ct(n.params, l.value.params));
+  function p(i = {}) {
+    if (Eo(i)) {
+      const s = t[Y(e.replace) ? "replace" : "push"](
+        Y(e.to)
+        // avoid uncaught errors are they are logged anyway
+      ).catch(ie);
+      return e.viewTransition && typeof document < "u" && "startViewTransition" in document && document.startViewTransition(() => s), s;
+    }
+    return Promise.resolve();
+  }
+  if (process.env.NODE_ENV !== "production" && z) {
+    const i = fe();
+    if (i) {
+      const s = {
+        route: l.value,
+        isActive: d.value,
+        isExactActive: a.value,
+        error: null
+      };
+      i.__vrl_devtools = i.__vrl_devtools || [], i.__vrl_devtools.push(s), yt(() => {
+        s.route = l.value, s.isActive = d.value, s.isExactActive = a.value, s.error = Ee(Y(e.to)) ? null : 'Invalid "to" value';
+      }, { flush: "post" });
+    }
+  }
+  return {
+    route: l,
+    href: M(() => l.value.href),
+    isActive: d,
+    isExactActive: a,
+    navigate: p
+  };
+}
+function go(e) {
+  return e.length === 1 ? e[0] : e;
+}
+const vo = /* @__PURE__ */ Be({
+  name: "RouterLink",
+  compatConfig: { MODE: 3 },
+  props: {
+    to: {
+      type: [String, Object],
+      required: !0
+    },
+    replace: Boolean,
+    activeClass: String,
+    // inactiveClass: String,
+    exactActiveClass: String,
+    custom: Boolean,
+    ariaCurrentValue: {
+      type: String,
+      default: "page"
+    }
+  },
+  useLink: ft,
+  setup(e, { slots: t }) {
+    const n = Xt(ft(e)), { options: o } = ee(Ke), r = M(() => ({
+      [ht(e.activeClass, o.linkActiveClass, "router-link-active")]: n.isActive,
+      // [getLinkClass(
+      //   props.inactiveClass,
+      //   options.linkInactiveClass,
+      //   'router-link-inactive'
+      // )]: !link.isExactActive,
+      [ht(e.exactActiveClass, o.linkExactActiveClass, "router-link-exact-active")]: n.isExactActive
+    }));
+    return () => {
+      const l = t.default && go(t.default(n));
+      return e.custom ? l : vt("a", {
+        "aria-current": n.isExactActive ? e.ariaCurrentValue : null,
+        href: n.href,
+        // this would override user added attrs but Vue will still add
+        // the listener, so we end up triggering both
+        onClick: n.navigate,
+        class: r.value
+      }, l);
+    };
+  }
+}), yo = vo;
+function Eo(e) {
+  if (!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) && !e.defaultPrevented && !(e.button !== void 0 && e.button !== 0)) {
+    if (e.currentTarget && e.currentTarget.getAttribute) {
+      const t = e.currentTarget.getAttribute("target");
+      if (/\b_blank\b/i.test(t))
+        return;
+    }
+    return e.preventDefault && e.preventDefault(), !0;
+  }
+}
+function _o(e, t) {
+  for (const n in t) {
+    const o = t[n], r = e[n];
+    if (typeof o == "string") {
+      if (o !== r)
+        return !1;
+    } else if (!B(r) || r.length !== o.length || o.some((l, u) => l !== r[u]))
+      return !1;
+  }
+  return !0;
+}
+function dt(e) {
+  return e ? e.aliasOf ? e.aliasOf.path : e.path : "";
+}
+const ht = (e, t, n) => e ?? t ?? n, wo = /* @__PURE__ */ Be({
+  name: "RouterView",
+  // #674 we manually inherit them
+  inheritAttrs: !1,
+  props: {
+    name: {
+      type: String,
+      default: "default"
+    },
+    route: Object
+  },
+  // Better compat for @vue/compat users
+  // https://github.com/vuejs/router/issues/1315
+  compatConfig: { MODE: 3 },
+  setup(e, { attrs: t, slots: n }) {
+    process.env.NODE_ENV !== "production" && So();
+    const o = ee(je), r = M(() => e.route || o.value), l = ee(ut, 0), u = M(() => {
+      let p = Y(l);
+      const { matched: i } = r.value;
+      let s;
+      for (; (s = i[p]) && !s.components; )
+        p++;
+      return p;
+    }), d = M(() => r.value.matched[u.value]);
+    Oe(ut, M(() => u.value + 1)), Oe(po, d), Oe(je, r);
+    const a = _e();
+    return oe(() => [a.value, d.value, e.name], ([p, i, s], [c, h, v]) => {
+      i && (i.instances[s] = p, h && h !== i && p && p === c && (i.leaveGuards.size || (i.leaveGuards = h.leaveGuards), i.updateGuards.size || (i.updateGuards = h.updateGuards))), p && i && // if there is no instance but to and from are the same this might be
+      // the first visit
+      (!h || !q(i, h) || !c) && (i.enterCallbacks[s] || []).forEach((E) => E(p));
+    }, { flush: "post" }), () => {
+      const p = r.value, i = e.name, s = d.value, c = s && s.components[i];
+      if (!c)
+        return pt(n.default, { Component: c, route: p });
+      const h = s.props[i], v = h ? h === !0 ? p.params : typeof h == "function" ? h(p) : h : null, w = vt(c, P({}, v, t, {
+        onVnodeUnmounted: (N) => {
+          N.component.isUnmounted && (s.instances[i] = null);
+        },
+        ref: a
+      }));
+      if (process.env.NODE_ENV !== "production" && z && w.ref) {
+        const N = {
+          depth: u.value,
+          name: s.name,
+          path: s.path,
+          meta: s.meta
+        };
+        (B(w.ref) ? w.ref.map((_) => _.i) : [w.ref.i]).forEach((_) => {
+          _.__vrv_devtools = N;
+        });
+      }
+      return (
+        // pass the vnode to the slot as a prop.
+        // h and <component :is="..."> both accept vnodes
+        pt(n.default, { Component: w, route: p }) || w
+      );
+    };
+  }
+});
+function pt(e, t) {
+  if (!e)
+    return null;
+  const n = e(t);
+  return n.length === 1 ? n[0] : n;
+}
+const bo = wo;
+function So() {
+  const e = fe(), t = e.parent && e.parent.type.name, n = e.parent && e.parent.subTree && e.parent.subTree.type;
+  if (t && (t === "KeepAlive" || t.includes("Transition")) && typeof n == "object" && n.name === "RouterView") {
+    const o = t === "KeepAlive" ? "keep-alive" : "transition";
+    S(`<router-view> can no longer be used directly inside <transition> or <keep-alive>.
+Use slot props instead:
+
+<router-view v-slot="{ Component }">
+  <${o}>
+    <component :is="Component" />
+  </${o}>
+</router-view>`);
+  }
+}
+function se(e, t) {
+  const n = P({}, e, {
+    // remove variables that can contain vue instances
+    matched: e.matched.map((o) => Vo(o, ["instances", "children", "aliasOf"]))
+  });
+  return {
+    _custom: {
+      type: null,
+      readOnly: !0,
+      display: e.fullPath,
+      tooltip: t,
+      value: n
+    }
+  };
+}
+function me(e) {
+  return {
+    _custom: {
+      display: e
+    }
+  };
+}
+let Ro = 0;
+function No(e, t, n) {
+  if (t.__hasDevtools)
+    return;
+  t.__hasDevtools = !0;
+  const o = Ro++;
+  pn({
+    id: "org.vuejs.router" + (o ? "." + o : ""),
+    label: "Vue Router",
+    packageName: "vue-router",
+    homepage: "https://router.vuejs.org",
+    logo: "https://router.vuejs.org/logo.png",
+    componentStateTypes: ["Routing"],
+    app: e
+  }, (r) => {
+    typeof r.now != "function" && console.warn("[Vue Router]: You seem to be using an outdated version of Vue Devtools. Are you still using the Beta release instead of the stable one? You can find the links at https://devtools.vuejs.org/guide/installation.html."), r.on.inspectComponent((i, s) => {
+      i.instanceData && i.instanceData.state.push({
+        type: "Routing",
+        key: "$route",
+        editable: !1,
+        value: se(t.currentRoute.value, "Current Route")
+      });
+    }), r.on.visitComponentTree(({ treeNode: i, componentInstance: s }) => {
+      if (s.__vrv_devtools) {
+        const c = s.__vrv_devtools;
+        i.tags.push({
+          label: (c.name ? `${c.name.toString()}: ` : "") + c.path,
+          textColor: 0,
+          tooltip: "This component is rendered by &lt;router-view&gt;",
+          backgroundColor: Dt
+        });
+      }
+      B(s.__vrl_devtools) && (s.__devtoolsApi = r, s.__vrl_devtools.forEach((c) => {
+        let h = c.route.path, v = jt, E = "", w = 0;
+        c.error ? (h = c.error, v = Ao, w = $o) : c.isExactActive ? (v = Mt, E = "This is exactly active") : c.isActive && (v = It, E = "This link is active"), i.tags.push({
+          label: h,
+          textColor: w,
+          tooltip: E,
+          backgroundColor: v
+        });
+      }));
+    }), oe(t.currentRoute, () => {
+      a(), r.notifyComponentUpdate(), r.sendInspectorTree(d), r.sendInspectorState(d);
+    });
+    const l = "router:navigations:" + o;
+    r.addTimelineLayer({
+      id: l,
+      label: `Router${o ? " " + o : ""} Navigations`,
+      color: 4237508
+    }), t.onError((i, s) => {
+      r.addTimelineEvent({
+        layerId: l,
+        event: {
+          title: "Error during Navigation",
+          subtitle: s.fullPath,
+          logType: "error",
+          time: r.now(),
+          data: { error: i },
+          groupId: s.meta.__navigationId
+        }
+      });
+    });
+    let u = 0;
+    t.beforeEach((i, s) => {
+      const c = {
+        guard: me("beforeEach"),
+        from: se(s, "Current Location during this navigation"),
+        to: se(i, "Target location")
+      };
+      Object.defineProperty(i.meta, "__navigationId", {
+        value: u++
+      }), r.addTimelineEvent({
+        layerId: l,
+        event: {
+          time: r.now(),
+          title: "Start of navigation",
+          subtitle: i.fullPath,
+          data: c,
+          groupId: i.meta.__navigationId
+        }
+      });
+    }), t.afterEach((i, s, c) => {
+      const h = {
+        guard: me("afterEach")
+      };
+      c ? (h.failure = {
+        _custom: {
+          type: Error,
+          readOnly: !0,
+          display: c ? c.message : "",
+          tooltip: "Navigation Failure",
+          value: c
+        }
+      }, h.status = me("❌")) : h.status = me("✅"), h.from = se(s, "Current Location during this navigation"), h.to = se(i, "Target location"), r.addTimelineEvent({
+        layerId: l,
+        event: {
+          title: "End of navigation",
+          subtitle: i.fullPath,
+          time: r.now(),
+          data: h,
+          logType: c ? "warning" : "default",
+          groupId: i.meta.__navigationId
+        }
+      });
+    });
+    const d = "router-inspector:" + o;
+    r.addInspector({
+      id: d,
+      label: "Routes" + (o ? " " + o : ""),
+      icon: "book",
+      treeFilterPlaceholder: "Search routes"
+    });
+    function a() {
+      if (!p)
+        return;
+      const i = p;
+      let s = n.getRoutes().filter((c) => !c.parent || // these routes have a parent with no component which will not appear in the view
+      // therefore we still need to include them
+      !c.parent.record.components);
+      s.forEach(Bt), i.filter && (s = s.filter((c) => (
+        // save matches state based on the payload
+        Le(c, i.filter.toLowerCase())
+      ))), s.forEach((c) => Wt(c, t.currentRoute.value)), i.rootNodes = s.map(Lt);
+    }
+    let p;
+    r.on.getInspectorTree((i) => {
+      p = i, i.app === e && i.inspectorId === d && a();
+    }), r.on.getInspectorState((i) => {
+      if (i.app === e && i.inspectorId === d) {
+        const c = n.getRoutes().find((h) => h.record.__vd_id === i.nodeId);
+        c && (i.state = {
+          options: Oo(c)
+        });
+      }
+    }), r.sendInspectorTree(d), r.sendInspectorState(d);
+  });
+}
+function ko(e) {
+  return e.optional ? e.repeatable ? "*" : "?" : e.repeatable ? "+" : "";
+}
+function Oo(e) {
+  const { record: t } = e, n = [
+    { editable: !1, key: "path", value: t.path }
+  ];
+  return t.name != null && n.push({
+    editable: !1,
+    key: "name",
+    value: t.name
+  }), n.push({ editable: !1, key: "regexp", value: e.re }), e.keys.length && n.push({
+    editable: !1,
+    key: "keys",
+    value: {
+      _custom: {
+        type: null,
+        readOnly: !0,
+        display: e.keys.map((o) => `${o.name}${ko(o)}`).join(" "),
+        tooltip: "Param keys",
+        value: e.keys
+      }
+    }
+  }), t.redirect != null && n.push({
+    editable: !1,
+    key: "redirect",
+    value: t.redirect
+  }), e.alias.length && n.push({
+    editable: !1,
+    key: "aliases",
+    value: e.alias.map((o) => o.record.path)
+  }), Object.keys(e.record.meta).length && n.push({
+    editable: !1,
+    key: "meta",
+    value: e.record.meta
+  }), n.push({
+    key: "score",
+    editable: !1,
+    value: {
+      _custom: {
+        type: null,
+        readOnly: !0,
+        display: e.score.map((o) => o.join(", ")).join(" | "),
+        tooltip: "Score used to sort routes",
+        value: e.score
+      }
+    }
+  }), n;
+}
+const Dt = 15485081, It = 2450411, Mt = 8702998, Po = 2282478, jt = 16486972, Co = 6710886, Ao = 16704226, $o = 12131356;
+function Lt(e) {
+  const t = [], { record: n } = e;
+  n.name != null && t.push({
+    label: String(n.name),
+    textColor: 0,
+    backgroundColor: Po
+  }), n.aliasOf && t.push({
+    label: "alias",
+    textColor: 0,
+    backgroundColor: jt
+  }), e.__vd_match && t.push({
+    label: "matches",
+    textColor: 0,
+    backgroundColor: Dt
+  }), e.__vd_exactActive && t.push({
+    label: "exact",
+    textColor: 0,
+    backgroundColor: Mt
+  }), e.__vd_active && t.push({
+    label: "active",
+    textColor: 0,
+    backgroundColor: It
+  }), n.redirect && t.push({
+    label: typeof n.redirect == "string" ? `redirect: ${n.redirect}` : "redirects",
+    textColor: 16777215,
+    backgroundColor: Co
+  });
+  let o = n.__vd_id;
+  return o == null && (o = String(xo++), n.__vd_id = o), {
+    id: o,
+    label: n.path,
+    tags: t,
+    children: e.children.map(Lt)
+  };
+}
+let xo = 0;
+const To = /^\/(.*)\/([a-z]*)$/;
+function Wt(e, t) {
+  const n = t.matched.length && q(t.matched[t.matched.length - 1], e.record);
+  e.__vd_exactActive = e.__vd_active = n, n || (e.__vd_active = t.matched.some((o) => q(o, e.record))), e.children.forEach((o) => Wt(o, t));
+}
+function Bt(e) {
+  e.__vd_match = !1, e.children.forEach(Bt);
+}
+function Le(e, t) {
+  const n = String(e.re).match(To);
+  if (e.__vd_match = !1, !n || n.length < 3)
+    return !1;
+  if (new RegExp(n[1].replace(/\$$/, ""), n[2]).test(t))
+    return e.children.forEach((u) => Le(u, t)), e.record.path !== "/" || t === "/" ? (e.__vd_match = e.re.test(t), !0) : !1;
+  const r = e.record.path.toLowerCase(), l = te(r);
+  return !t.startsWith("/") && (l.includes(t) || r.includes(t)) || l.startsWith(t) || r.startsWith(t) || e.record.name && String(e.record.name).includes(t) ? !0 : e.children.some((u) => Le(u, t));
+}
+function Vo(e, t) {
+  const n = {};
+  for (const o in e)
+    t.includes(o) || (n[o] = e[o]);
+  return n;
+}
+function Do(e) {
+  const t = no(e.routes, e), n = e.parseQuery || fo, o = e.stringifyQuery || lt, r = e.history;
+  if (process.env.NODE_ENV !== "production" && !r)
+    throw new Error('Provide the "history" option when calling "createRouter()": https://router.vuejs.org/api/interfaces/RouterOptions.html#history');
+  const l = re(), u = re(), d = re(), a = ce(G);
+  let p = G;
+  z && e.scrollBehavior && "scrollRestoration" in history && (history.scrollRestoration = "manual");
+  const i = Pe.bind(null, (f) => "" + f), s = Pe.bind(null, Pn), c = (
+    // @ts-expect-error: intentionally avoid the type check
+    Pe.bind(null, te)
+  );
+  function h(f, g) {
+    let m, y;
+    return $t(f) ? (m = t.getRecordMatcher(f), process.env.NODE_ENV !== "production" && !m && S(`Parent route "${String(f)}" not found when adding child route`, g), y = g) : y = f, t.addRoute(y, m);
+  }
+  function v(f) {
+    const g = t.getRecordMatcher(f);
+    g ? t.removeRoute(g) : process.env.NODE_ENV !== "production" && S(`Cannot remove non-existent route "${String(f)}"`);
+  }
+  function E() {
+    return t.getRoutes().map((f) => f.record);
+  }
+  function w(f) {
+    return !!t.getRecordMatcher(f);
+  }
+  function N(f, g) {
+    if (g = P({}, g || a.value), typeof f == "string") {
+      const R = Ce(n, f, g.path), T = t.resolve({ path: R.path }, g), J = r.createHref(R.fullPath);
+      return process.env.NODE_ENV !== "production" && (J.startsWith("//") ? S(`Location "${f}" resolved to "${J}". A resolved location cannot start with multiple slashes.`) : T.matched.length || S(`No match found for location with path "${f}"`)), P(R, T, {
+        params: c(T.params),
+        hash: te(R.hash),
+        redirectedFrom: void 0,
+        href: J
+      });
+    }
+    if (process.env.NODE_ENV !== "production" && !Ee(f))
+      return S(`router.resolve() was passed an invalid location. This will fail in production.
+- Location:`, f), N({});
+    let m;
+    if (f.path != null)
+      process.env.NODE_ENV !== "production" && "params" in f && !("name" in f) && // @ts-expect-error: the type is never
+      Object.keys(f.params).length && S(`Path "${f.path}" was passed with params but they will be ignored. Use a named route alongside params instead.`), m = P({}, f, {
+        path: Ce(n, f.path, g.path).path
+      });
+    else {
+      const R = P({}, f.params);
+      for (const T in R)
+        R[T] == null && delete R[T];
+      m = P({}, f, {
+        params: s(R)
+      }), g.params = s(g.params);
+    }
+    const y = t.resolve(m, g), C = f.hash || "";
+    process.env.NODE_ENV !== "production" && C && !C.startsWith("#") && S(`A \`hash\` should always start with the character "#". Replace "${C}" with "#${C}".`), y.params = i(c(y.params));
+    const V = $n(o, P({}, f, {
+      hash: Nn(C),
+      path: y.path
+    })), O = r.createHref(V);
+    return process.env.NODE_ENV !== "production" && (O.startsWith("//") ? S(`Location "${f}" resolved to "${O}". A resolved location cannot start with multiple slashes.`) : y.matched.length || S(`No match found for location with path "${f.path != null ? f.path : f}"`)), P({
+      fullPath: V,
+      // keep the hash encoded so fullPath is effectively path + encodedQuery +
+      // hash
+      hash: C,
+      query: (
+        // if the user is using a custom query lib like qs, we might have
+        // nested objects, so we keep the query as is, meaning it can contain
+        // numbers at `$route.query`, but at the point, the user will have to
+        // use their own type anyway.
+        // https://github.com/vuejs/router/issues/328#issuecomment-649481567
+        o === lt ? ho(f.query) : f.query || {}
+      )
+    }, y, {
+      redirectedFrom: void 0,
+      href: O
+    });
+  }
+  function b(f) {
+    return typeof f == "string" ? Ce(n, f, a.value.path) : P({}, f);
+  }
+  function _(f, g) {
+    if (p !== f)
+      return ne(8, {
+        from: g,
+        to: f
+      });
+  }
+  function A(f) {
+    return I(f);
+  }
+  function D(f) {
+    return A(P(b(f), { replace: !0 }));
+  }
+  function L(f) {
+    const g = f.matched[f.matched.length - 1];
+    if (g && g.redirect) {
+      const { redirect: m } = g;
+      let y = typeof m == "function" ? m(f) : m;
+      if (typeof y == "string" && (y = y.includes("?") || y.includes("#") ? y = b(y) : (
+        // force empty params
+        { path: y }
+      ), y.params = {}), process.env.NODE_ENV !== "production" && y.path == null && !("name" in y))
+        throw S(`Invalid redirect found:
+${JSON.stringify(y, null, 2)}
+ when navigating to "${f.fullPath}". A redirect must contain a name or path. This will break in production.`), new Error("Invalid redirect");
+      return P({
+        query: f.query,
+        hash: f.hash,
+        // avoid transferring params if the redirect has a path
+        params: y.path != null ? {} : f.params
+      }, y);
+    }
+  }
+  function I(f, g) {
+    const m = p = N(f), y = a.value, C = f.state, V = f.force, O = f.replace === !0, R = L(m);
+    if (R)
+      return I(
+        P(b(R), {
+          state: typeof R == "object" ? P({}, C, R.state) : C,
+          force: V,
+          replace: O
+        }),
+        // keep original redirectedFrom if it exists
+        g || m
+      );
+    const T = m;
+    T.redirectedFrom = g;
+    let J;
+    return !V && Xe(o, y, m) && (J = ne(16, { to: T, from: y }), qe(
+      y,
+      y,
+      // this is a push, the only way for it to be triggered from a
+      // history.listen is with a redirect, which makes it become a push
+      !0,
+      // This cannot be the first navigation because the initial location
+      // cannot be manually navigated to
+      !1
+    )), (J ? Promise.resolve(J) : U(T, y)).catch((j) => H(j) ? (
+      // navigation redirects still mark the router as ready
+      H(
+        j,
+        2
+        /* ErrorTypes.NAVIGATION_GUARD_REDIRECT */
+      ) ? j : Re(j)
+    ) : (
+      // reject any unknown error
+      Se(j, T, y)
+    )).then((j) => {
+      if (j) {
+        if (H(
+          j,
+          2
+          /* ErrorTypes.NAVIGATION_GUARD_REDIRECT */
+        ))
+          return process.env.NODE_ENV !== "production" && // we are redirecting to the same location we were already at
+          Xe(o, N(j.to), T) && // and we have done it a couple of times
+          g && // @ts-expect-error: added only in dev
+          (g._count = g._count ? (
+            // @ts-expect-error
+            g._count + 1
+          ) : 1) > 30 ? (S(`Detected a possibly infinite redirection in a navigation guard when going from "${y.fullPath}" to "${T.fullPath}". Aborting to avoid a Stack Overflow.
+ Are you always returning a new location within a navigation guard? That would lead to this error. Only return when redirecting or aborting, that should fix this. This might break in production if not fixed.`), Promise.reject(new Error("Infinite redirect in navigation guard"))) : I(
+            // keep options
+            P({
+              // preserve an existing replacement but allow the redirect to override it
+              replace: O
+            }, b(j.to), {
+              state: typeof j.to == "object" ? P({}, C, j.to.state) : C,
+              force: V
+            }),
+            // preserve the original redirectedFrom if any
+            g || T
+          );
+      } else
+        j = $(T, y, !0, O, C);
+      return k(T, y, j), j;
+    });
+  }
+  function Q(f, g) {
+    const m = _(f, g);
+    return m ? Promise.reject(m) : Promise.resolve();
+  }
+  function W(f) {
+    const g = he.values().next().value;
+    return g && typeof g.runWithContext == "function" ? g.runWithContext(f) : f();
+  }
+  function U(f, g) {
+    let m;
+    const [y, C, V] = Io(f, g);
+    m = Ae(y.reverse(), "beforeRouteLeave", f, g);
+    for (const R of y)
+      R.leaveGuards.forEach((T) => {
+        m.push(K(T, f, g));
+      });
+    const O = Q.bind(null, f, g);
+    return m.push(O), X(m).then(() => {
+      m = [];
+      for (const R of l.list())
+        m.push(K(R, f, g));
+      return m.push(O), X(m);
+    }).then(() => {
+      m = Ae(C, "beforeRouteUpdate", f, g);
+      for (const R of C)
+        R.updateGuards.forEach((T) => {
+          m.push(K(T, f, g));
+        });
+      return m.push(O), X(m);
+    }).then(() => {
+      m = [];
+      for (const R of V)
+        if (R.beforeEnter)
+          if (B(R.beforeEnter))
+            for (const T of R.beforeEnter)
+              m.push(K(T, f, g));
+          else
+            m.push(K(R.beforeEnter, f, g));
+      return m.push(O), X(m);
+    }).then(() => (f.matched.forEach((R) => R.enterCallbacks = {}), m = Ae(V, "beforeRouteEnter", f, g, W), m.push(O), X(m))).then(() => {
+      m = [];
+      for (const R of u.list())
+        m.push(K(R, f, g));
+      return m.push(O), X(m);
+    }).catch((R) => H(
+      R,
+      8
+      /* ErrorTypes.NAVIGATION_CANCELLED */
+    ) ? R : Promise.reject(R));
+  }
+  function k(f, g, m) {
+    d.list().forEach((y) => W(() => y(f, g, m)));
+  }
+  function $(f, g, m, y, C) {
+    const V = _(f, g);
+    if (V)
+      return V;
+    const O = g === G, R = z ? history.state : {};
+    m && (y || O ? r.replace(f.fullPath, P({
+      scroll: O && R && R.scroll
+    }, C)) : r.push(f.fullPath, C)), a.value = f, qe(f, g, m, O), Re();
+  }
+  let x;
+  function Qt() {
+    x || (x = r.listen((f, g, m) => {
+      if (!Qe.listening)
+        return;
+      const y = N(f), C = L(y);
+      if (C) {
+        I(P(C, { replace: !0, force: !0 }), y).catch(ie);
+        return;
+      }
+      p = y;
+      const V = a.value;
+      z && Ln(et(V.fullPath, m.delta), we()), U(y, V).catch((O) => H(
+        O,
+        12
+        /* ErrorTypes.NAVIGATION_CANCELLED */
+      ) ? O : H(
+        O,
+        2
+        /* ErrorTypes.NAVIGATION_GUARD_REDIRECT */
+      ) ? (I(
+        P(b(O.to), {
+          force: !0
+        }),
+        y
+        // avoid an uncaught rejection, let push call triggerError
+      ).then((R) => {
+        H(
+          R,
+          20
+          /* ErrorTypes.NAVIGATION_DUPLICATED */
+        ) && !m.delta && m.type === le.pop && r.go(-1, !1);
+      }).catch(ie), Promise.reject()) : (m.delta && r.go(-m.delta, !1), Se(O, y, V))).then((O) => {
+        O = O || $(
+          // after navigation, all matched components are resolved
+          y,
+          V,
+          !1
+        ), O && (m.delta && // a new navigation has been triggered, so we do not want to revert, that will change the current history
+        // entry while a different route is displayed
+        !H(
+          O,
+          8
+          /* ErrorTypes.NAVIGATION_CANCELLED */
+        ) ? r.go(-m.delta, !1) : m.type === le.pop && H(
+          O,
+          20
+          /* ErrorTypes.NAVIGATION_DUPLICATED */
+        ) && r.go(-1, !1)), k(y, V, O);
+      }).catch(ie);
+    }));
+  }
+  let be = re(), Fe = re(), de;
+  function Se(f, g, m) {
+    Re(f);
+    const y = Fe.list();
+    return y.length ? y.forEach((C) => C(f, g, m)) : (process.env.NODE_ENV !== "production" && S("uncaught error during route navigation:"), console.error(f)), Promise.reject(f);
+  }
+  function Jt() {
+    return de && a.value !== G ? Promise.resolve() : new Promise((f, g) => {
+      be.add([f, g]);
+    });
+  }
+  function Re(f) {
+    return de || (de = !f, Qt(), be.list().forEach(([g, m]) => f ? m(f) : g()), be.reset()), f;
+  }
+  function qe(f, g, m, y) {
+    const { scrollBehavior: C } = e;
+    if (!z || !C)
+      return Promise.resolve();
+    const V = !m && Wn(et(f.fullPath, 0)) || (y || !m) && history.state && history.state.scroll || null;
+    return Ue().then(() => C(f, g, V)).then((O) => O && jn(O)).catch((O) => Se(O, f, g));
+  }
+  const Ne = (f) => r.go(f);
+  let ke;
+  const he = /* @__PURE__ */ new Set(), Qe = {
+    currentRoute: a,
+    listening: !0,
+    addRoute: h,
+    removeRoute: v,
+    clearRoutes: t.clearRoutes,
+    hasRoute: w,
+    getRoutes: E,
+    resolve: N,
+    options: e,
+    push: A,
+    replace: D,
+    go: Ne,
+    back: () => Ne(-1),
+    forward: () => Ne(1),
+    beforeEach: l.add,
+    beforeResolve: u.add,
+    afterEach: d.add,
+    onError: Fe.add,
+    isReady: Jt,
+    install(f) {
+      const g = this;
+      f.component("RouterLink", yo), f.component("RouterView", bo), f.config.globalProperties.$router = g, Object.defineProperty(f.config.globalProperties, "$route", {
+        enumerable: !0,
+        get: () => Y(a)
+      }), z && // used for the initial navigation client side to avoid pushing
+      // multiple times when the router is used in multiple apps
+      !ke && a.value === G && (ke = !0, A(r.location).catch((C) => {
+        process.env.NODE_ENV !== "production" && S("Unexpected error when starting the router:", C);
+      }));
+      const m = {};
+      for (const C in G)
+        Object.defineProperty(m, C, {
+          get: () => a.value[C],
+          enumerable: !0
+        });
+      f.provide(Ke, g), f.provide(Vt, Yt(m)), f.provide(je, a);
+      const y = f.unmount;
+      he.add(f), f.unmount = function() {
+        he.delete(f), he.size < 1 && (p = G, x && x(), x = null, a.value = G, ke = !1, de = !1), y();
+      }, process.env.NODE_ENV !== "production" && z && No(f, g, t);
+    }
+  };
+  function X(f) {
+    return f.reduce((g, m) => g.then(() => W(m)), Promise.resolve());
+  }
+  return Qe;
+}
+function Io(e, t) {
+  const n = [], o = [], r = [], l = Math.max(t.matched.length, e.matched.length);
+  for (let u = 0; u < l; u++) {
+    const d = t.matched[u];
+    d && (e.matched.find((p) => q(p, d)) ? o.push(d) : n.push(d));
+    const a = e.matched[u];
+    a && (t.matched.find((p) => q(p, a)) || r.push(a));
+  }
+  return [n, o, r];
+}
+const Ut = (e, t) => {
+  const n = e.__vccOpts || e;
+  for (const [o, r] of t)
+    n[o] = r;
+  return n;
+}, Mo = {}, jo = { class: "flex items-center justify-between" };
+function Lo(e, t) {
+  return ze(), He("div", jo, t[0] || (t[0] = [
+    ye("div", { class: "flex items-center gap-2" }, [
+      ye("img", {
+        width: "40",
+        src: "https://nuxterror.com/logo.svg",
+        alt: ""
+      }),
+      ye("h6", { class: "text-xl font-bold" }, "Nuxt Charts")
+    ], -1)
+  ]));
+}
+const Wo = /* @__PURE__ */ Ut(Mo, [["render", Lo]]), Bo = {}, Uo = { class: "rounded font-medium inline-flex items-center focus:outline-hidden disabled:cursor-not-allowed aria-disabled:cursor-not-allowed disabled:opacity-75 aria-disabled:opacity-75 transition-colors px-2.5 py-1.5 text-sm gap-1.5 text-background bg-primary hover:bg-primary/75 disabled:bg-(--ui-primary) aria-disabled:bg-(--ui-primary) focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-(--ui-primary)" };
+function Ho(e, t) {
+  return ze(), He("button", Uo, [
+    Zt(e.$slots, "default")
+  ]);
+}
+const zo = /* @__PURE__ */ Ut(Bo, [["render", Ho]]);
+function Go(e) {
+  return nn() ? (on(e), !0) : !1;
+}
+const $e = /* @__PURE__ */ new WeakMap(), Ko = (...e) => {
+  var t;
+  const n = e[0], o = (t = fe()) == null ? void 0 : t.proxy;
+  if (o == null && !wt())
+    throw new Error("injectLocal must be called in setup");
+  return o && $e.has(o) && n in $e.get(o) ? $e.get(o)[n] : ee(...e);
+}, Fo = typeof window < "u" && typeof document < "u";
+typeof WorkerGlobalScope < "u" && globalThis instanceof WorkerGlobalScope;
+const qo = Object.prototype.toString, Qo = (e) => qo.call(e) === "[object Object]", Jo = () => {
+};
+function Yo(e, t) {
+  function n(...o) {
+    return new Promise((r, l) => {
+      Promise.resolve(e(() => t.apply(this, o), { fn: t, thisArg: this, args: o })).then(r).catch(l);
+    });
+  }
+  return n;
+}
+const Ht = (e) => e();
+function Xo(e = Ht, t = {}) {
+  const {
+    initialState: n = "active"
+  } = t, o = zt(n === "active");
+  function r() {
+    o.value = !1;
+  }
+  function l() {
+    o.value = !0;
+  }
+  const u = (...d) => {
+    o.value && e(...d);
+  };
+  return { isActive: Et(o), pause: r, resume: l, eventFilter: u };
+}
+function mt(e) {
+  return e.endsWith("rem") ? Number.parseFloat(e) * 16 : Number.parseFloat(e);
+}
+function Zo(e) {
+  return fe();
+}
+function xe(e) {
+  return Array.isArray(e) ? e : [e];
+}
+function zt(...e) {
+  if (e.length !== 1)
+    return en(...e);
+  const t = e[0];
+  return typeof t == "function" ? Et(tn(() => ({ get: t, set: Jo }))) : _e(t);
+}
+function er(e, t, n = {}) {
+  const {
+    eventFilter: o = Ht,
+    ...r
+  } = n;
+  return oe(
+    e,
+    Yo(
+      o,
+      t
+    ),
+    r
+  );
+}
+function tr(e, t, n = {}) {
+  const {
+    eventFilter: o,
+    initialState: r = "active",
+    ...l
+  } = n, { eventFilter: u, pause: d, resume: a, isActive: p } = Xo(o, { initialState: r });
+  return { stop: er(
+    e,
+    t,
+    {
+      ...l,
+      eventFilter: u
+    }
+  ), pause: d, resume: a, isActive: p };
+}
+function Gt(e, t = !0, n) {
+  Zo() ? _t(e, n) : t ? e() : Ue(e);
+}
+function nr(e, t, n) {
+  return oe(
+    e,
+    t,
+    {
+      ...n,
+      immediate: !0
+    }
+  );
+}
+const ue = Fo ? window : void 0;
+function Kt(e) {
+  var t;
+  const n = F(e);
+  return (t = n == null ? void 0 : n.$el) != null ? t : n;
+}
+function We(...e) {
+  const t = [], n = () => {
+    t.forEach((d) => d()), t.length = 0;
+  }, o = (d, a, p, i) => (d.addEventListener(a, p, i), () => d.removeEventListener(a, p, i)), r = M(() => {
+    const d = xe(F(e[0])).filter((a) => a != null);
+    return d.every((a) => typeof a != "string") ? d : void 0;
+  }), l = nr(
+    () => {
+      var d, a;
+      return [
+        (a = (d = r.value) == null ? void 0 : d.map((p) => Kt(p))) != null ? a : [ue].filter((p) => p != null),
+        xe(F(r.value ? e[1] : e[0])),
+        xe(Y(r.value ? e[2] : e[1])),
+        // @ts-expect-error - TypeScript gets the correct types, but somehow still complains
+        F(r.value ? e[3] : e[2])
+      ];
+    },
+    ([d, a, p, i]) => {
+      if (n(), !(d != null && d.length) || !(a != null && a.length) || !(p != null && p.length))
+        return;
+      const s = Qo(i) ? { ...i } : i;
+      t.push(
+        ...d.flatMap(
+          (c) => a.flatMap(
+            (h) => p.map((v) => o(c, h, v, s))
+          )
+        )
+      );
+    },
+    { flush: "post" }
+  ), u = () => {
+    l(), n();
+  };
+  return Go(n), u;
+}
+function or() {
+  const e = ce(!1), t = fe();
+  return t && _t(() => {
+    e.value = !0;
+  }, t), e;
+}
+function rr(e) {
+  const t = or();
+  return M(() => (t.value, !!e()));
+}
+const sr = Symbol("vueuse-ssr-width");
+function ir() {
+  const e = wt() ? Ko(sr, null) : null;
+  return typeof e == "number" ? e : void 0;
+}
+function ar(e, t = {}) {
+  const { window: n = ue, ssrWidth: o = ir() } = t, r = rr(() => n && "matchMedia" in n && typeof n.matchMedia == "function"), l = _e(typeof o == "number"), u = ce(), d = ce(!1), a = (p) => {
+    d.value = p.matches;
+  };
+  return yt(() => {
+    if (l.value) {
+      l.value = !r.value;
+      const p = F(e).split(",");
+      d.value = p.some((i) => {
+        const s = i.includes("not all"), c = i.match(/\(\s*min-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/), h = i.match(/\(\s*max-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/);
+        let v = !!(c || h);
+        return c && v && (v = o >= mt(c[1])), h && v && (v = o <= mt(h[1])), s ? !v : v;
+      });
+      return;
+    }
+    r.value && (u.value = n.matchMedia(F(e)), d.value = u.value.matches);
+  }), We(u, "change", a, { passive: !0 }), M(() => d.value);
+}
+const ge = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, ve = "__vueuse_ssr_handlers__", cr = /* @__PURE__ */ lr();
+function lr() {
+  return ve in ge || (ge[ve] = ge[ve] || {}), ge[ve];
+}
+function Ft(e, t) {
+  return cr[e] || t;
+}
+function ur(e) {
+  return ar("(prefers-color-scheme: dark)", e);
+}
+function fr(e) {
+  return e == null ? "any" : e instanceof Set ? "set" : e instanceof Map ? "map" : e instanceof Date ? "date" : typeof e == "boolean" ? "boolean" : typeof e == "string" ? "string" : typeof e == "object" ? "object" : Number.isNaN(e) ? "any" : "number";
+}
+const dr = {
+  boolean: {
+    read: (e) => e === "true",
+    write: (e) => String(e)
+  },
+  object: {
+    read: (e) => JSON.parse(e),
+    write: (e) => JSON.stringify(e)
+  },
+  number: {
+    read: (e) => Number.parseFloat(e),
+    write: (e) => String(e)
+  },
+  any: {
+    read: (e) => e,
+    write: (e) => String(e)
+  },
+  string: {
+    read: (e) => e,
+    write: (e) => String(e)
+  },
+  map: {
+    read: (e) => new Map(JSON.parse(e)),
+    write: (e) => JSON.stringify(Array.from(e.entries()))
+  },
+  set: {
+    read: (e) => new Set(JSON.parse(e)),
+    write: (e) => JSON.stringify(Array.from(e))
+  },
+  date: {
+    read: (e) => new Date(e),
+    write: (e) => e.toISOString()
+  }
+}, gt = "vueuse-storage";
+function hr(e, t, n, o = {}) {
+  var r;
+  const {
+    flush: l = "pre",
+    deep: u = !0,
+    listenToStorageChanges: d = !0,
+    writeDefaults: a = !0,
+    mergeDefaults: p = !1,
+    shallow: i,
+    window: s = ue,
+    eventFilter: c,
+    onError: h = (k) => {
+      console.error(k);
+    },
+    initOnMounted: v
+  } = o, E = (i ? ce : _e)(typeof t == "function" ? t() : t), w = M(() => F(e));
+  if (!n)
+    try {
+      n = Ft("getDefaultStorage", () => {
+        var k;
+        return (k = ue) == null ? void 0 : k.localStorage;
+      })();
+    } catch (k) {
+      h(k);
+    }
+  if (!n)
+    return E;
+  const N = F(t), b = fr(N), _ = (r = o.serializer) != null ? r : dr[b], { pause: A, resume: D } = tr(
+    E,
+    () => I(E.value),
+    { flush: l, deep: u, eventFilter: c }
+  );
+  oe(w, () => W(), { flush: l }), s && d && Gt(() => {
+    n instanceof Storage ? We(s, "storage", W, { passive: !0 }) : We(s, gt, U), v && W();
+  }), v || W();
+  function L(k, $) {
+    if (s) {
+      const x = {
+        key: w.value,
+        oldValue: k,
+        newValue: $,
+        storageArea: n
+      };
+      s.dispatchEvent(n instanceof Storage ? new StorageEvent("storage", x) : new CustomEvent(gt, {
+        detail: x
+      }));
+    }
+  }
+  function I(k) {
+    try {
+      const $ = n.getItem(w.value);
+      if (k == null)
+        L($, null), n.removeItem(w.value);
+      else {
+        const x = _.write(k);
+        $ !== x && (n.setItem(w.value, x), L($, x));
+      }
+    } catch ($) {
+      h($);
+    }
+  }
+  function Q(k) {
+    const $ = k ? k.newValue : n.getItem(w.value);
+    if ($ == null)
+      return a && N != null && n.setItem(w.value, _.write(N)), N;
+    if (!k && p) {
+      const x = _.read($);
+      return typeof p == "function" ? p(x, N) : b === "object" && !Array.isArray(x) ? { ...N, ...x } : x;
+    } else return typeof $ != "string" ? $ : _.read($);
+  }
+  function W(k) {
+    if (!(k && k.storageArea !== n)) {
+      if (k && k.key == null) {
+        E.value = N;
+        return;
+      }
+      if (!(k && k.key !== w.value)) {
+        A();
+        try {
+          (k == null ? void 0 : k.newValue) !== _.write(E.value) && (E.value = Q(k));
+        } catch ($) {
+          h($);
+        } finally {
+          k ? Ue(D) : D();
+        }
+      }
+    }
+  }
+  function U(k) {
+    W(k.detail);
+  }
+  return E;
+}
+const pr = "*,*::before,*::after{-webkit-transition:none!important;-moz-transition:none!important;-o-transition:none!important;-ms-transition:none!important;transition:none!important}";
+function mr(e = {}) {
+  const {
+    selector: t = "html",
+    attribute: n = "class",
+    initialValue: o = "auto",
+    window: r = ue,
+    storage: l,
+    storageKey: u = "vueuse-color-scheme",
+    listenToStorageChanges: d = !0,
+    storageRef: a,
+    emitAuto: p,
+    disableTransition: i = !0
+  } = e, s = {
+    auto: "",
+    light: "light",
+    dark: "dark",
+    ...e.modes || {}
+  }, c = ur({ window: r }), h = M(() => c.value ? "dark" : "light"), v = a || (u == null ? zt(o) : hr(u, o, l, { window: r, listenToStorageChanges: d })), E = M(() => v.value === "auto" ? h.value : v.value), w = Ft(
+    "updateHTMLAttrs",
+    (A, D, L) => {
+      const I = typeof A == "string" ? r == null ? void 0 : r.document.querySelector(A) : Kt(A);
+      if (!I)
+        return;
+      const Q = /* @__PURE__ */ new Set(), W = /* @__PURE__ */ new Set();
+      let U = null;
+      if (D === "class") {
+        const $ = L.split(/\s/g);
+        Object.values(s).flatMap((x) => (x || "").split(/\s/g)).filter(Boolean).forEach((x) => {
+          $.includes(x) ? Q.add(x) : W.add(x);
+        });
+      } else
+        U = { key: D, value: L };
+      if (Q.size === 0 && W.size === 0 && U === null)
+        return;
+      let k;
+      i && (k = r.document.createElement("style"), k.appendChild(document.createTextNode(pr)), r.document.head.appendChild(k));
+      for (const $ of Q)
+        I.classList.add($);
+      for (const $ of W)
+        I.classList.remove($);
+      U && I.setAttribute(U.key, U.value), i && (r.getComputedStyle(k).opacity, document.head.removeChild(k));
+    }
+  );
+  function N(A) {
+    var D;
+    w(t, n, (D = s[A]) != null ? D : A);
+  }
+  function b(A) {
+    e.onChanged ? e.onChanged(A, N) : N(A);
+  }
+  oe(E, b, { flush: "post", immediate: !0 }), Gt(() => b(E.value));
+  const _ = M({
+    get() {
+      return p ? v.value : E.value;
+    },
+    set(A) {
+      v.value = A;
+    }
+  });
+  return Object.assign(_, { store: v, system: h, state: E });
+}
+const gr = { class: "max-w-7xl mx-auto py-4 flex items-center justify-between" }, vr = /* @__PURE__ */ Be({
+  __name: "App",
+  setup(e) {
+    const t = mr(), n = M(() => t.value === "dark");
+    function o() {
+      t.value = n.value ? "light" : "dark";
+    }
+    return (r, l) => {
+      const u = Je("RouterLink"), d = Je("RouterView");
+      return ze(), He("div", null, [
+        ye("div", gr, [
+          pe(u, { to: "/" }, {
+            default: rn(() => [
+              pe(Wo)
+            ]),
+            _: 1
+          }),
+          pe(zo, {
+            icon: n.value ? "i-heroicons-moon-20-solid" : "i-heroicons-sun-20-solid",
+            color: "gray",
+            variant: "ghost",
+            "aria-label": "Theme",
+            onClick: o,
+            class: "cursor-pointer"
+          }, null, 8, ["icon"])
+        ]),
+        pe(d)
+      ]);
+    };
+  }
+}), qt = sn(vr), yr = Do({
+  routes: [
+    {
+      path: "/",
+      name: "Home",
+      component: () => import("./Homepage-DIu5Y175.js")
+    }
+    // {
+    //   path: '/overview',
+    //   name: 'Overview',
+    //   component: () => import('./components/Overview.vue') // Replace with your OverviewPage component path
+    // }
+  ],
+  history: zn()
+});
+qt.use(yr);
+qt.mount("#app");
+const _r = {};
+export {
+  zo as B,
+  Wo as L,
+  _r as i
+};