@the-framery/vision-assessment-sdk 0.0.0-stage → 0.0.1

package/dist-sdk/vision-assessment.js

@@ -0,0 +1,4313 @@
+// @__NO_SIDE_EFFECTS__
+function Ms(e) {
+  const t = /* @__PURE__ */ Object.create(null);
+  for (const s of e.split(",")) t[s] = 1;
+  return (s) => s in t;
+}
+const K = {}, ke = [], Ae = () => {
+}, Kn = () => !1, kt = (e) => e.charCodeAt(0) === 111 && e.charCodeAt(1) === 110 && // uppercase letter
+(e.charCodeAt(2) > 122 || e.charCodeAt(2) < 97), Xt = (e) => e.startsWith("onUpdate:"), G = Object.assign, Fs = (e, t) => {
+  const s = e.indexOf(t);
+  s > -1 && e.splice(s, 1);
+}, ki = Object.prototype.hasOwnProperty, N = (e, t) => ki.call(e, t), P = Array.isArray, Xe = (e) => Pt(e) === "[object Map]", ys = (e) => Pt(e) === "[object Set]", fn = (e) => Pt(e) === "[object Date]", I = (e) => typeof e == "function", J = (e) => typeof e == "string", Be = (e) => typeof e == "symbol", B = (e) => e !== null && typeof e == "object", Bn = (e) => (B(e) || I(e)) && I(e.then) && I(e.catch), Xi = Object.prototype.toString, Pt = (e) => Xi.call(e), Zi = (e) => Pt(e).slice(8, -1), Ns = (e) => Pt(e) === "[object Object]", js = (e) => J(e) && e !== "NaN" && e[0] !== "-" && "" + parseInt(e, 10) === e, dt = /* @__PURE__ */ Ms(
+  // the leading comma is intentional so empty string "" is also included
+  ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
+), Zt = (e) => {
+  const t = /* @__PURE__ */ Object.create(null);
+  return ((s) => t[s] || (t[s] = e(s)));
+}, Qi = /-\w/g, oe = /* @__PURE__ */ Zt((e) => e.replace(Qi, (t) => t.slice(1).toUpperCase())), er = /\B([A-Z])/g, fe = /* @__PURE__ */ Zt(
+  (e) => e.replace(er, "-$1").toLowerCase()
+), Wn = /* @__PURE__ */ Zt((e) => e.charAt(0).toUpperCase() + e.slice(1)), os = /* @__PURE__ */ Zt((e) => e ? `on${Wn(e)}` : ""), Ce = (e, t) => !Object.is(e, t), ls = (e, ...t) => {
+  for (let s = 0; s < e.length; s++)
+    e[s](...t);
+}, qn = (e, t, s, n = !1) => {
+  Object.defineProperty(e, t, {
+    configurable: !0,
+    enumerable: !1,
+    writable: n,
+    value: s
+  });
+}, tr = (e) => {
+  const t = parseFloat(e);
+  return isNaN(t) ? e : t;
+}, un = (e) => {
+  const t = J(e) ? Number(e) : NaN;
+  return isNaN(t) ? e : t;
+};
+let an;
+const Qt = () => an || (an = typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof window < "u" ? window : typeof global < "u" ? global : {});
+function Ds(e) {
+  if (P(e)) {
+    const t = {};
+    for (let s = 0; s < e.length; s++) {
+      const n = e[s], i = J(n) ? rr(n) : Ds(n);
+      if (i)
+        for (const r in i)
+          t[r] = i[r];
+    }
+    return t;
+  } else if (J(e) || B(e))
+    return e;
+}
+const sr = /;(?![^(]*\))/g, nr = /:([^]+)/, ir = /"(?:[^"\\]|\\[^])*"|'(?:[^'\\]|\\[^])*'|\\[^]|\/\*[^]*?\*\//g;
+function rr(e) {
+  const t = {};
+  return e.replace(ir, (s) => s.startsWith("/*") ? "" : s).split(sr).forEach((s) => {
+    if (s) {
+      const n = s.split(nr);
+      n.length > 1 && (t[n[0].trim()] = n[1].trim());
+    }
+  }), t;
+}
+function Hs(e) {
+  let t = "";
+  if (J(e))
+    t = e;
+  else if (P(e))
+    for (let s = 0; s < e.length; s++) {
+      const n = Hs(e[s]);
+      n && (t += n + " ");
+    }
+  else if (B(e))
+    for (const s in e)
+      e[s] && (t += s + " ");
+  return t.trim();
+}
+const or = "itemscope,allowfullscreen,disablepictureinpicture,disableremoteplayback,formnovalidate,ismap,nomodule,novalidate,playsinline,readonly", lr = /* @__PURE__ */ Ms(or);
+function Gn(e) {
+  return !!e || e === "";
+}
+function cr(e, t, s) {
+  if (e.length !== t.length) return !1;
+  let n = !0;
+  for (let i = 0; n && i < e.length; i++)
+    n = es(e[i], t[i], s);
+  return n;
+}
+function hn(e, t, s) {
+  if (e.size !== t.size) return !1;
+  const n = Array.from(t), i = new Uint8Array(n.length);
+  for (const r of e) {
+    let o = -1;
+    for (let l = 0; l < n.length; l++)
+      if (!i[l] && es(r, n[l], s)) {
+        o = l;
+        break;
+      }
+    if (o < 0) return !1;
+    i[o] = 1;
+  }
+  return !0;
+}
+function fr(e, t, s) {
+  let n = Xe(e), i = Xe(t);
+  if (n || i || (n = ys(e), i = ys(t), n || i))
+    return n && i ? hn(e, t, s) : !1;
+  const r = Object.keys(e).length, o = Object.keys(t).length;
+  if (r !== o)
+    return !1;
+  for (const l in e) {
+    const f = e.hasOwnProperty(l), h = t.hasOwnProperty(l);
+    if (f && !h || !f && h || !es(e[l], t[l], s))
+      return !1;
+  }
+  return String(e) === String(t);
+}
+function dn(e, t, s, n) {
+  s || (s = [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map()]);
+  const [i, r] = s;
+  if (i.has(e) || r.has(t))
+    return i.get(e) === t && r.get(t) === e;
+  i.set(e, t), r.set(t, e);
+  const o = n(e, t, s);
+  return i.delete(e), r.delete(t), o;
+}
+function es(e, t, s) {
+  if (e === t) return !0;
+  let n = fn(e), i = fn(t);
+  return n || i ? n && i ? e.getTime() === t.getTime() : !1 : (n = Be(e), i = Be(t), n || i ? e === t : (n = P(e), i = P(t), n || i ? n && i ? dn(e, t, s, cr) : !1 : (n = B(e), i = B(t), n || i ? !n || !i ? !1 : dn(e, t, s, fr) : String(e) === String(t))));
+}
+let Z;
+class ur {
+  // TODO isolatedDeclarations "__v_skip"
+  constructor(t = !1) {
+    this.detached = t, this._active = !0, this._on = 0, this.effects = [], this.cleanups = [], this._isPaused = !1, this._warnOnRun = !0, this.__v_skip = !0, !t && Z && (Z.active ? (this.parent = Z, this.index = (Z.scopes || (Z.scopes = [])).push(
+      this
+    ) - 1) : (this._active = !1, this._warnOnRun = !1));
+  }
+  get active() {
+    return this._active;
+  }
+  pause() {
+    if (this._active) {
+      this._isPaused = !0;
+      let t, s;
+      if (this.scopes) {
+        const n = this.scopes.slice();
+        for (t = 0, s = n.length; t < s; t++)
+          n[t].pause();
+      }
+      for (t = 0, s = this.effects.length; t < s; t++)
+        this.effects[t].pause();
+    }
+  }
+  /**
+   * Resumes the effect scope, including all child scopes and effects.
+   */
+  resume() {
+    if (this._active && this._isPaused) {
+      this._isPaused = !1;
+      let t, s;
+      if (this.scopes) {
+        const i = this.scopes.slice();
+        for (t = 0, s = i.length; t < s; t++)
+          i[t].resume();
+      }
+      const n = this.effects.slice();
+      for (t = 0, s = n.length; t < s; t++)
+        n[t].resume();
+    }
+  }
+  run(t) {
+    if (this._active) {
+      const s = Z;
+      try {
+        return Z = this, t();
+      } finally {
+        Z = s;
+      }
+    }
+  }
+  /**
+   * This should only be called on non-detached scopes
+   * @internal
+   */
+  on() {
+    ++this._on === 1 && (this.prevScope = Z, Z = this);
+  }
+  /**
+   * This should only be called on non-detached scopes
+   * @internal
+   */
+  off() {
+    if (this._on > 0 && --this._on === 0) {
+      if (Z === this)
+        Z = this.prevScope;
+      else {
+        let t = Z;
+        for (; t; ) {
+          if (t.prevScope === this) {
+            t.prevScope = this.prevScope;
+            break;
+          }
+          t = t.prevScope;
+        }
+      }
+      this.prevScope = void 0;
+    }
+  }
+  stop(t) {
+    if (this._active) {
+      this._active = !1;
+      let s, n;
+      for (s = 0, n = this.effects.length; s < n; s++)
+        this.effects[s].stop();
+      for (this.effects.length = 0, s = 0, n = this.cleanups.length; s < n; s++)
+        this.cleanups[s]();
+      if (this.cleanups.length = 0, this.scopes) {
+        const i = this.scopes.slice();
+        for (s = 0, n = i.length; s < n; s++)
+          i[s].stop(!0);
+        this.scopes.length = 0;
+      }
+      if (!this.detached && this.parent && !t) {
+        const i = this.parent.scopes.pop();
+        i && i !== this && (this.parent.scopes[this.index] = i, i.index = this.index);
+      }
+      this.parent = void 0;
+    }
+  }
+}
+function ar() {
+  return Z;
+}
+let U;
+const cs = /* @__PURE__ */ new WeakSet();
+class Jn {
+  constructor(t) {
+    this.fn = t, this.deps = void 0, this.depsTail = void 0, this.flags = 5, this.next = void 0, this.cleanup = void 0, this.scheduler = void 0, Z && (Z.active ? Z.effects.push(this) : this.flags &= -2);
+  }
+  pause() {
+    this.flags |= 64;
+  }
+  resume() {
+    this.flags & 64 && (this.flags &= -65, cs.has(this) && (cs.delete(this), this.trigger()));
+  }
+  /**
+   * @internal
+   */
+  notify() {
+    this.flags & 2 && !(this.flags & 32) || this.flags & 8 || zn(this);
+  }
+  run() {
+    if (!(this.flags & 1))
+      return this.fn();
+    this.flags |= 2, pn(this), kn(this);
+    const t = U, s = pe;
+    U = this, pe = !0;
+    try {
+      return this.fn();
+    } finally {
+      Xn(this), U = t, pe = s, this.flags &= -3;
+    }
+  }
+  stop() {
+    if (this.flags & 1) {
+      for (let t = this.deps; t; t = t.nextDep)
+        Vs(t);
+      this.deps = this.depsTail = void 0, pn(this), this.onStop && this.onStop(), this.flags &= -2;
+    }
+  }
+  trigger() {
+    this.flags & 64 ? cs.add(this) : this.scheduler ? this.scheduler() : this.runIfDirty();
+  }
+  /**
+   * @internal
+   */
+  runIfDirty() {
+    vs(this) && this.run();
+  }
+  get dirty() {
+    return vs(this);
+  }
+}
+let Yn = 0, pt, gt;
+function zn(e, t = !1) {
+  if (e.flags |= 8, t) {
+    e.next = gt, gt = e;
+    return;
+  }
+  e.next = pt, pt = e;
+}
+function Ls() {
+  Yn++;
+}
+function $s() {
+  if (--Yn > 0)
+    return;
+  if (gt) {
+    let t = gt;
+    for (gt = void 0; t; ) {
+      const s = t.next;
+      t.next = void 0, t.flags &= -9, t = s;
+    }
+  }
+  let e;
+  for (; pt; ) {
+    let t = pt;
+    for (pt = void 0; t; ) {
+      const s = t.next;
+      if (t.next = void 0, t.flags &= -9, t.flags & 1)
+        try {
+          t.trigger();
+        } catch (n) {
+          e || (e = n);
+        }
+      t = s;
+    }
+  }
+  if (e) throw e;
+}
+function kn(e) {
+  for (let t = e.deps; t; t = t.nextDep)
+    t.version = -1, t.prevActiveLink = t.dep.activeLink, t.dep.activeLink = t;
+}
+function Xn(e) {
+  let t, s = e.depsTail, n = s;
+  for (; n; ) {
+    const i = n.prevDep;
+    n.version === -1 ? (n === s && (s = i), Vs(n), hr(n)) : t = n, n.dep.activeLink = n.prevActiveLink, n.prevActiveLink = void 0, n = i;
+  }
+  e.deps = t, e.depsTail = s;
+}
+function vs(e) {
+  for (let t = e.deps; t; t = t.nextDep)
+    if (t.dep.version !== t.version || t.dep.computed && (Zn(t.dep.computed) || t.dep.version !== t.version))
+      return !0;
+  return !!e._dirty;
+}
+function Zn(e) {
+  if (e.flags & 4 && !(e.flags & 16) || (e.flags &= -17, e.globalVersion === St) || (e.globalVersion = St, !e.isSSR && e.flags & 128 && (!e.deps && !e._dirty || !vs(e))))
+    return;
+  e.flags |= 2;
+  const t = e.dep, s = U, n = pe;
+  U = e, pe = !0;
+  try {
+    kn(e);
+    const i = e.fn(e._value);
+    (t.version === 0 || Ce(i, e._value)) && (e.flags |= 128, e._value = i, t.version++);
+  } catch (i) {
+    throw t.version++, i;
+  } finally {
+    U = s, pe = n, Xn(e), e.flags &= -3;
+  }
+}
+function Vs(e, t = !1) {
+  const { dep: s, prevSub: n, nextSub: i } = e;
+  if (n && (n.nextSub = i, e.prevSub = void 0), i && (i.prevSub = n, e.nextSub = void 0), s.subs === e && (s.subs = n, !n && s.computed)) {
+    s.computed.flags &= -5;
+    for (let r = s.computed.deps; r; r = r.nextDep)
+      Vs(r, !0);
+  }
+  !t && !--s.sc && s.map && s.map.delete(s.key);
+}
+function hr(e) {
+  const { prevDep: t, nextDep: s } = e;
+  t && (t.nextDep = s, e.prevDep = void 0), s && (s.prevDep = t, e.nextDep = void 0);
+}
+let pe = !0;
+const Qn = [];
+function Ee() {
+  Qn.push(pe), pe = !1;
+}
+function Oe() {
+  const e = Qn.pop();
+  pe = e === void 0 ? !0 : e;
+}
+function pn(e) {
+  const { cleanup: t } = e;
+  if (e.cleanup = void 0, t) {
+    const s = U;
+    U = void 0;
+    try {
+      t();
+    } finally {
+      U = s;
+    }
+  }
+}
+let St = 0;
+class dr {
+  constructor(t, s) {
+    this.sub = t, this.dep = s, this.version = s.version, this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
+  }
+}
+class Us {
+  // TODO isolatedDeclarations "__v_skip"
+  constructor(t) {
+    this.computed = t, this.version = 0, this.activeLink = void 0, this.subs = void 0, this.map = void 0, this.key = void 0, this.sc = 0, this.__v_skip = !0;
+  }
+  track(t) {
+    if (!U || !pe || U === this.computed)
+      return;
+    let s = this.activeLink;
+    if (s === void 0 || s.sub !== U)
+      s = this.activeLink = new dr(U, this), U.deps ? (s.prevDep = U.depsTail, U.depsTail.nextDep = s, U.depsTail = s) : U.deps = U.depsTail = s, ei(s);
+    else if (s.version === -1 && (s.version = this.version, s.nextDep)) {
+      const n = s.nextDep;
+      n.prevDep = s.prevDep, s.prevDep && (s.prevDep.nextDep = n), s.prevDep = U.depsTail, s.nextDep = void 0, U.depsTail.nextDep = s, U.depsTail = s, U.deps === s && (U.deps = n);
+    }
+    return s;
+  }
+  trigger(t) {
+    this.version++, St++, this.notify(t);
+  }
+  notify(t) {
+    Ls();
+    try {
+      for (let s = this.subs; s; s = s.prevSub)
+        s.sub.notify() && s.sub.dep.notify();
+    } finally {
+      $s();
+    }
+  }
+}
+function ei(e) {
+  if (e.dep.sc++, e.sub.flags & 4) {
+    const t = e.dep.computed;
+    if (t && !e.dep.subs) {
+      t.flags |= 20;
+      for (let n = t.deps; n; n = n.nextDep)
+        ei(n);
+    }
+    const s = e.dep.subs;
+    s !== e && (e.prevSub = s, s && (s.nextSub = e)), e.dep.subs = e;
+  }
+}
+const xs = /* @__PURE__ */ new WeakMap(), Ze = /* @__PURE__ */ Symbol(
+  ""
+), Ss = /* @__PURE__ */ Symbol(
+  ""
+), wt = /* @__PURE__ */ Symbol(
+  ""
+);
+function Q(e, t, s) {
+  if (pe && U) {
+    let n = xs.get(e);
+    n || xs.set(e, n = /* @__PURE__ */ new Map());
+    let i = n.get(s);
+    i || (n.set(s, i = new Us()), i.map = n, i.key = s), i.track();
+  }
+}
+function Ne(e, t, s, n, i, r) {
+  const o = xs.get(e);
+  if (!o) {
+    St++;
+    return;
+  }
+  const l = (f) => {
+    f && f.trigger();
+  };
+  if (Ls(), t === "clear")
+    o.forEach(l);
+  else {
+    const f = P(e), h = f && js(s);
+    if (f && s === "length") {
+      const a = Number(n);
+      o.forEach((p, w) => {
+        (w === "length" || w === wt || !Be(w) && w >= a) && l(p);
+      });
+    } else
+      switch ((s !== void 0 || o.has(void 0)) && l(o.get(s)), h && l(o.get(wt)), t) {
+        case "add":
+          f ? h && l(o.get("length")) : (l(o.get(Ze)), Xe(e) && l(o.get(Ss)));
+          break;
+        case "delete":
+          f || (l(o.get(Ze)), Xe(e) && l(o.get(Ss)));
+          break;
+        case "set":
+          Xe(e) && l(o.get(Ze));
+          break;
+      }
+  }
+  $s();
+}
+function st(e) {
+  const t = /* @__PURE__ */ j(e);
+  return t === e || (Q(t, "iterate", wt), /* @__PURE__ */ ge(e)) ? t : /* @__PURE__ */ je(e) ? /* @__PURE__ */ Qe(e) ? t.map((s) => tt(Pe(s))) : t.map(tt) : t.map(Pe);
+}
+function Ks(e) {
+  return Q(e = /* @__PURE__ */ j(e), "iterate", wt), e;
+}
+function xe(e, t) {
+  return /* @__PURE__ */ je(e) ? tt(/* @__PURE__ */ Qe(e) ? Pe(t) : t) : Pe(t);
+}
+const pr = {
+  __proto__: null,
+  [Symbol.iterator]() {
+    return fs(this, Symbol.iterator, (e) => xe(this, e));
+  },
+  concat(...e) {
+    return st(this).concat(
+      ...e.map((t) => P(t) ? st(t) : t)
+    );
+  },
+  entries() {
+    return fs(this, "entries", (e) => (e[1] = xe(this, e[1]), e));
+  },
+  every(e, t) {
+    return Ie(this, "every", e, t, void 0, arguments);
+  },
+  filter(e, t) {
+    return Ie(
+      this,
+      "filter",
+      e,
+      t,
+      (s) => s.map((n) => xe(this, n)),
+      arguments
+    );
+  },
+  find(e, t) {
+    return Ie(
+      this,
+      "find",
+      e,
+      t,
+      (s) => xe(this, s),
+      arguments
+    );
+  },
+  findIndex(e, t) {
+    return Ie(this, "findIndex", e, t, void 0, arguments);
+  },
+  findLast(e, t) {
+    return Ie(
+      this,
+      "findLast",
+      e,
+      t,
+      (s) => xe(this, s),
+      arguments
+    );
+  },
+  findLastIndex(e, t) {
+    return Ie(this, "findLastIndex", e, t, void 0, arguments);
+  },
+  // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
+  forEach(e, t) {
+    return Ie(this, "forEach", e, t, void 0, arguments);
+  },
+  includes(...e) {
+    return us(this, "includes", e);
+  },
+  indexOf(...e) {
+    return us(this, "indexOf", e);
+  },
+  join(e) {
+    return st(this).join(e);
+  },
+  // keys() iterator only reads `length`, no optimization required
+  lastIndexOf(...e) {
+    return us(this, "lastIndexOf", e);
+  },
+  map(e, t) {
+    return Ie(this, "map", e, t, void 0, arguments);
+  },
+  pop() {
+    return ft(this, "pop");
+  },
+  push(...e) {
+    return ft(this, "push", e);
+  },
+  reduce(e, ...t) {
+    return _n(this, "reduce", e, t);
+  },
+  reduceRight(e, ...t) {
+    return _n(this, "reduceRight", e, t);
+  },
+  shift() {
+    return ft(this, "shift");
+  },
+  // slice could use ARRAY_ITERATE but also seems to beg for range tracking
+  some(e, t) {
+    return Ie(this, "some", e, t, void 0, arguments);
+  },
+  splice(...e) {
+    return ft(this, "splice", e);
+  },
+  toReversed() {
+    return st(this).toReversed();
+  },
+  toSorted(e) {
+    return st(this).toSorted(e);
+  },
+  toSpliced(...e) {
+    return st(this).toSpliced(...e);
+  },
+  unshift(...e) {
+    return ft(this, "unshift", e);
+  },
+  values() {
+    return fs(this, "values", (e) => xe(this, e));
+  }
+};
+function fs(e, t, s) {
+  const n = Ks(e), i = n[t], r = i.call(n);
+  if (n !== e && !/* @__PURE__ */ ge(e)) {
+    if (r[Symbol.toStringTag] === "Array Iterator") {
+      const o = Object.create(Object.getPrototypeOf(r));
+      return o.next = () => gn(r.next(), s), i !== ti[t] && Object.defineProperties(o, {
+        return: {
+          get() {
+            const l = r.return;
+            return typeof l == "function" ? l.bind(r) : l;
+          }
+        },
+        throw: {
+          get() {
+            const l = r.throw;
+            return typeof l == "function" ? l.bind(r) : l;
+          }
+        }
+      }), o;
+    }
+    r._next = r.next, r.next = () => gn(r._next(), s);
+  }
+  return r;
+}
+function gn(e, t) {
+  return e.done || (e.value = t(e.value)), e;
+}
+const ti = Array.prototype;
+function Ie(e, t, s, n, i, r) {
+  const o = Ks(e), l = o !== e && !/* @__PURE__ */ ge(e), f = o[t];
+  if (f !== ti[t]) {
+    const p = f.apply(e, r);
+    return l ? Pe(p) : p;
+  }
+  let h = s;
+  o !== e && (l ? h = function(p, w) {
+    return s.call(this, xe(e, p), w, e);
+  } : s.length > 2 && (h = function(p, w) {
+    return s.call(this, p, w, e);
+  }));
+  const a = f.call(o, h, n);
+  return l && i ? i(a) : a;
+}
+function _n(e, t, s, n) {
+  const i = Ks(e), r = i !== e && !/* @__PURE__ */ ge(e);
+  let o = s, l = !1;
+  i !== e && (r ? (l = n.length === 0, o = function(h, a, p) {
+    return l && (l = !1, h = xe(e, h)), s.call(this, h, xe(e, a), p, e);
+  }) : s.length > 3 && (o = function(h, a, p) {
+    return s.call(this, h, a, p, e);
+  }));
+  const f = i[t](o, ...n);
+  return l ? xe(e, f) : f;
+}
+function us(e, t, s) {
+  const n = /* @__PURE__ */ j(e);
+  Q(n, "iterate", wt);
+  const i = n[t](...s);
+  return (i === -1 || i === !1) && /* @__PURE__ */ Gs(s[0]) ? (s[0] = /* @__PURE__ */ j(s[0]), n[t](...s)) : i;
+}
+function ft(e, t, s = []) {
+  Ee(), Ls();
+  const n = (/* @__PURE__ */ j(e))[t].apply(e, s);
+  return $s(), Oe(), n;
+}
+const gr = /* @__PURE__ */ Ms("__proto__,__v_isRef,__isVue"), si = /* @__PURE__ */ new Set(
+  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((e) => e !== "arguments" && e !== "caller").map((e) => Symbol[e]).filter(Be)
+);
+function _r(e) {
+  Be(e) || (e = String(e));
+  const t = /* @__PURE__ */ j(this);
+  return Q(t, "has", e), t.hasOwnProperty(e);
+}
+class ni {
+  constructor(t = !1, s = !1) {
+    this._isReadonly = t, this._isShallow = s;
+  }
+  get(t, s, n) {
+    if (s === "__v_skip") return t.__v_skip;
+    const i = this._isReadonly, r = this._isShallow;
+    if (s === "__v_isReactive")
+      return !i;
+    if (s === "__v_isReadonly")
+      return i;
+    if (s === "__v_isShallow")
+      return r;
+    if (s === "__v_raw")
+      return n === (i ? r ? Ar : li : r ? oi : ri).get(t) || // receiver is not the reactive proxy, but has the same prototype
+      // this means the receiver is a user proxy of the reactive proxy
+      Object.getPrototypeOf(t) === Object.getPrototypeOf(n) ? t : void 0;
+    const o = P(t);
+    if (!i) {
+      let f;
+      if (o && (f = pr[s]))
+        return f;
+      if (s === "hasOwnProperty")
+        return _r;
+    }
+    const l = Reflect.get(
+      t,
+      s,
+      // if this is a proxy wrapping a ref, return methods using the raw ref
+      // as receiver so that we don't have to call `toRaw` on the ref in all
+      // its class methods
+      /* @__PURE__ */ ee(t) ? t : n
+    );
+    if ((Be(s) ? si.has(s) : gr(s)) || (i || Q(t, "get", s), r))
+      return l;
+    if (/* @__PURE__ */ ee(l)) {
+      const f = o && js(s) ? l : l.value;
+      return i && B(f) ? /* @__PURE__ */ Cs(f) : f;
+    }
+    return B(l) ? i ? /* @__PURE__ */ Cs(l) : /* @__PURE__ */ Ws(l) : l;
+  }
+}
+class ii extends ni {
+  constructor(t = !1) {
+    super(!1, t);
+  }
+  set(t, s, n, i) {
+    let r = t[s];
+    const o = P(t) && js(s);
+    if (!this._isShallow) {
+      const h = /* @__PURE__ */ je(r);
+      if (!/* @__PURE__ */ ge(n) && !/* @__PURE__ */ je(n) && (r = /* @__PURE__ */ j(r), n = /* @__PURE__ */ j(n)), !o && /* @__PURE__ */ ee(r) && !/* @__PURE__ */ ee(n))
+        return h || (r.value = n), !0;
+    }
+    const l = o ? Number(s) < t.length : N(t, s), f = Reflect.set(
+      t,
+      s,
+      n,
+      /* @__PURE__ */ ee(t) ? t : i
+    );
+    return t === /* @__PURE__ */ j(i) && f && (l ? Ce(n, r) && Ne(t, "set", s, n) : Ne(t, "add", s, n)), f;
+  }
+  deleteProperty(t, s) {
+    const n = N(t, s);
+    t[s];
+    const i = Reflect.deleteProperty(t, s);
+    return i && n && Ne(t, "delete", s, void 0), i;
+  }
+  has(t, s) {
+    const n = Reflect.has(t, s);
+    return (!Be(s) || !si.has(s)) && Q(t, "has", s), n;
+  }
+  ownKeys(t) {
+    return Q(
+      t,
+      "iterate",
+      P(t) ? "length" : Ze
+    ), Reflect.ownKeys(t);
+  }
+}
+class mr extends ni {
+  constructor(t = !1) {
+    super(!0, t);
+  }
+  set(t, s) {
+    return !0;
+  }
+  deleteProperty(t, s) {
+    return !0;
+  }
+}
+const br = /* @__PURE__ */ new ii(), yr = /* @__PURE__ */ new mr(), vr = /* @__PURE__ */ new ii(!0);
+const ws = (e) => e, Ht = (e) => Reflect.getPrototypeOf(e);
+function xr(e, t, s) {
+  return function(...n) {
+    const i = this.__v_raw, r = /* @__PURE__ */ j(i), o = Xe(r), l = e === "entries" || e === Symbol.iterator && o, f = e === "keys" && o, h = i[e](...n), a = s ? ws : t ? tt : Pe;
+    return !t && Q(
+      r,
+      "iterate",
+      f ? Ss : Ze
+    ), G(
+      // inheriting all iterator properties
+      Object.create(h),
+      {
+        // iterator protocol
+        next() {
+          const { value: p, done: w } = h.next();
+          return w ? { value: p, done: w } : {
+            value: l ? [a(p[0]), a(p[1])] : a(p),
+            done: w
+          };
+        }
+      }
+    );
+  };
+}
+function Lt(e) {
+  return function(...t) {
+    return e === "delete" ? !1 : e === "clear" ? void 0 : this;
+  };
+}
+function Sr(e, t) {
+  const s = {
+    get(i) {
+      const r = this.__v_raw, o = /* @__PURE__ */ j(r), l = /* @__PURE__ */ j(i);
+      e || (Ce(i, l) && Q(o, "get", i), Q(o, "get", l));
+      const { has: f } = Ht(o), h = t ? ws : e ? tt : Pe;
+      if (f.call(o, i))
+        return h(r.get(i));
+      if (f.call(o, l))
+        return h(r.get(l));
+      r !== o && r.get(i);
+    },
+    get size() {
+      const i = this.__v_raw;
+      return !e && Q(/* @__PURE__ */ j(i), "iterate", Ze), i.size;
+    },
+    has(i) {
+      const r = this.__v_raw, o = /* @__PURE__ */ j(r), l = /* @__PURE__ */ j(i);
+      return e || (Ce(i, l) && Q(o, "has", i), Q(o, "has", l)), i === l ? r.has(i) : r.has(i) || r.has(l);
+    },
+    forEach(i, r) {
+      const o = this, l = o.__v_raw, f = /* @__PURE__ */ j(l), h = t ? ws : e ? tt : Pe;
+      return !e && Q(f, "iterate", Ze), l.forEach((a, p) => i.call(r, h(a), h(p), o));
+    }
+  };
+  return G(
+    s,
+    e ? {
+      add: Lt("add"),
+      set: Lt("set"),
+      delete: Lt("delete"),
+      clear: Lt("clear")
+    } : {
+      add(i) {
+        const r = /* @__PURE__ */ j(this), o = Ht(r), l = /* @__PURE__ */ j(i), f = !t && !/* @__PURE__ */ ge(i) && !/* @__PURE__ */ je(i) ? l : i;
+        return o.has.call(r, f) || Ce(i, f) && o.has.call(r, i) || Ce(l, f) && o.has.call(r, l) || (r.add(f), Ne(r, "add", f, f)), this;
+      },
+      set(i, r) {
+        !t && !/* @__PURE__ */ ge(r) && !/* @__PURE__ */ je(r) && (r = /* @__PURE__ */ j(r));
+        const o = /* @__PURE__ */ j(this), { has: l, get: f } = Ht(o);
+        let h = l.call(o, i);
+        h || (i = /* @__PURE__ */ j(i), h = l.call(o, i));
+        const a = f.call(o, i);
+        return o.set(i, r), h ? Ce(r, a) && Ne(o, "set", i, r) : Ne(o, "add", i, r), this;
+      },
+      delete(i) {
+        const r = /* @__PURE__ */ j(this), { has: o, get: l } = Ht(r);
+        let f = o.call(r, i);
+        f || (i = /* @__PURE__ */ j(i), f = o.call(r, i)), l && l.call(r, i);
+        const h = r.delete(i);
+        return f && Ne(r, "delete", i, void 0), h;
+      },
+      clear() {
+        const i = /* @__PURE__ */ j(this), r = i.size !== 0, o = i.clear();
+        return r && Ne(
+          i,
+          "clear",
+          void 0,
+          void 0
+        ), o;
+      }
+    }
+  ), [
+    "keys",
+    "values",
+    "entries",
+    Symbol.iterator
+  ].forEach((i) => {
+    s[i] = xr(i, e, t);
+  }), s;
+}
+function Bs(e, t) {
+  const s = Sr(e, t);
+  return (n, i, r) => i === "__v_isReactive" ? !e : i === "__v_isReadonly" ? e : i === "__v_isShallow" ? t : i === "__v_raw" ? n : Reflect.get(
+    N(s, i) && i in n ? s : n,
+    i,
+    r
+  );
+}
+const wr = {
+  get: /* @__PURE__ */ Bs(!1, !1)
+}, Cr = {
+  get: /* @__PURE__ */ Bs(!1, !0)
+}, Tr = {
+  get: /* @__PURE__ */ Bs(!0, !1)
+};
+const ri = /* @__PURE__ */ new WeakMap(), oi = /* @__PURE__ */ new WeakMap(), li = /* @__PURE__ */ new WeakMap(), Ar = /* @__PURE__ */ new WeakMap();
+function Er(e) {
+  switch (e) {
+    case "Object":
+    case "Array":
+      return 1;
+    case "Map":
+    case "Set":
+    case "WeakMap":
+    case "WeakSet":
+      return 2;
+    default:
+      return 0;
+  }
+}
+// @__NO_SIDE_EFFECTS__
+function Ws(e) {
+  return /* @__PURE__ */ je(e) ? e : qs(
+    e,
+    !1,
+    br,
+    wr,
+    ri
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function Or(e) {
+  return qs(
+    e,
+    !1,
+    vr,
+    Cr,
+    oi
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function Cs(e) {
+  return qs(
+    e,
+    !0,
+    yr,
+    Tr,
+    li
+  );
+}
+function qs(e, t, s, n, i) {
+  if (!B(e) || e.__v_raw && !(t && e.__v_isReactive) || e.__v_skip || !Object.isExtensible(e))
+    return e;
+  const r = i.get(e);
+  if (r)
+    return r;
+  const o = Er(Zi(e));
+  if (o === 0)
+    return e;
+  const l = new Proxy(
+    e,
+    o === 2 ? n : s
+  );
+  return i.set(e, l), l;
+}
+// @__NO_SIDE_EFFECTS__
+function Qe(e) {
+  return /* @__PURE__ */ je(e) ? /* @__PURE__ */ Qe(e.__v_raw) : !!(e && e.__v_isReactive);
+}
+// @__NO_SIDE_EFFECTS__
+function je(e) {
+  return !!(e && e.__v_isReadonly);
+}
+// @__NO_SIDE_EFFECTS__
+function ge(e) {
+  return !!(e && e.__v_isShallow);
+}
+// @__NO_SIDE_EFFECTS__
+function Gs(e) {
+  return e ? !!e.__v_raw : !1;
+}
+// @__NO_SIDE_EFFECTS__
+function j(e) {
+  const t = e && e.__v_raw;
+  return t ? /* @__PURE__ */ j(t) : e;
+}
+function Pr(e) {
+  return !N(e, "__v_skip") && Object.isExtensible(e) && qn(e, "__v_skip", !0), e;
+}
+const Pe = (e) => B(e) ? /* @__PURE__ */ Ws(e) : e, tt = (e) => B(e) ? /* @__PURE__ */ Cs(e) : e;
+// @__NO_SIDE_EFFECTS__
+function ee(e) {
+  return e ? e.__v_isRef === !0 : !1;
+}
+// @__NO_SIDE_EFFECTS__
+function Rr(e) {
+  return Ir(e, !1);
+}
+function Ir(e, t) {
+  return /* @__PURE__ */ ee(e) ? e : new Mr(e, t);
+}
+class Mr {
+  constructor(t, s) {
+    this.dep = new Us(), this.__v_isRef = !0, this.__v_isShallow = !1, this._rawValue = s ? t : /* @__PURE__ */ j(t), this._value = s ? t : Pe(t), this.__v_isShallow = s;
+  }
+  get value() {
+    return this.dep.track(), this._value;
+  }
+  set value(t) {
+    const s = this._rawValue, n = this.__v_isShallow || /* @__PURE__ */ ge(t) || /* @__PURE__ */ je(t);
+    t = n ? t : /* @__PURE__ */ j(t), Ce(t, s) && (this._rawValue = t, this._value = n ? t : Pe(t), this.dep.trigger());
+  }
+}
+function ci(e) {
+  return /* @__PURE__ */ ee(e) ? e.value : e;
+}
+const Fr = {
+  get: (e, t, s) => t === "__v_raw" ? e : ci(Reflect.get(e, t, s)),
+  set: (e, t, s, n) => {
+    const i = e[t];
+    return /* @__PURE__ */ ee(i) && !/* @__PURE__ */ ee(s) ? (i.value = s, !0) : Reflect.set(e, t, s, n);
+  }
+};
+function fi(e) {
+  return /* @__PURE__ */ Qe(e) ? e : new Proxy(e, Fr);
+}
+class Nr {
+  constructor(t, s, n) {
+    this.fn = t, this.setter = s, this._value = void 0, this.dep = new Us(this), this.__v_isRef = !0, this.deps = void 0, this.depsTail = void 0, this.flags = 16, this.globalVersion = St - 1, this.next = void 0, this.effect = this, this.__v_isReadonly = !s, this.isSSR = n;
+  }
+  /**
+   * @internal
+   */
+  notify() {
+    if (this.flags |= 16, !(this.flags & 8) && // avoid infinite self recursion
+    U !== this)
+      return zn(this, !0), !0;
+  }
+  get value() {
+    const t = this.dep.track();
+    return Zn(this), t && (t.version = this.dep.version), this._value;
+  }
+  set value(t) {
+    this.setter && this.setter(t);
+  }
+}
+// @__NO_SIDE_EFFECTS__
+function jr(e, t, s = !1) {
+  let n, i;
+  return I(e) ? n = e : (n = e.get, i = e.set), new Nr(n, i, s);
+}
+const $t = {}, Bt = /* @__PURE__ */ new WeakMap();
+let ze;
+function Dr(e, t = !1, s = ze) {
+  if (s) {
+    let n = Bt.get(s);
+    n || Bt.set(s, n = []), n.push(e);
+  }
+}
+function Hr(e, t, s = K) {
+  const { immediate: n, deep: i, once: r, scheduler: o, augmentJob: l, call: f } = s, h = (E) => i ? E : /* @__PURE__ */ ge(E) || i === !1 || i === 0 ? Ue(E, 1) : Ue(E);
+  let a, p, w, C, D = !1, R = !1;
+  if (/* @__PURE__ */ ee(e) ? (p = () => e.value, D = /* @__PURE__ */ ge(e)) : /* @__PURE__ */ Qe(e) ? (p = () => h(e), D = !0) : P(e) ? (R = !0, D = e.some((E) => /* @__PURE__ */ Qe(E) || /* @__PURE__ */ ge(E)), p = () => e.map((E) => {
+    if (/* @__PURE__ */ ee(E))
+      return E.value;
+    if (/* @__PURE__ */ Qe(E))
+      return h(E);
+    if (I(E))
+      return f ? f(E, 2) : E();
+  })) : I(e) ? t ? p = f ? () => f(e, 2) : e : p = () => {
+    if (w) {
+      Ee();
+      try {
+        w();
+      } finally {
+        Oe();
+      }
+    }
+    const E = ze;
+    ze = a;
+    try {
+      return f ? f(e, 3, [C]) : e(C);
+    } finally {
+      ze = E;
+    }
+  } : p = Ae, t && i) {
+    const E = p, k = i === !0 ? 1 / 0 : i;
+    p = () => Ue(E(), k);
+  }
+  const Y = ar(), W = () => {
+    a.stop(), Y && Y.active && Fs(Y.effects, a);
+  };
+  if (r && t) {
+    const E = t;
+    t = (...k) => {
+      try {
+        return E(...k);
+      } finally {
+        W();
+      }
+    };
+  }
+  let F = R ? new Array(e.length).fill($t) : $t;
+  const H = (E) => {
+    if (!(!(a.flags & 1) || !a.dirty && !E))
+      if (t) {
+        const k = a.run();
+        if (E || i || D || (R ? k.some((Le, me) => Ce(Le, F[me])) : Ce(k, F))) {
+          const Le = ze;
+          Ee();
+          try {
+            w && w(), ze = a;
+            const me = [
+              k,
+              // pass undefined as the old value when it's changed for the first time
+              F === $t ? void 0 : R && F[0] === $t ? [] : F,
+              C
+            ];
+            F = k, f ? f(t, 3, me) : (
+              // @ts-expect-error
+              t(...me)
+            );
+          } finally {
+            ze = Le, Oe();
+          }
+        }
+      } else
+        a.run();
+  };
+  return l && l(H), a = new Jn(p), a.scheduler = o ? () => o(H, !1) : H, C = (E) => Dr(E, !1, a), w = a.onStop = () => {
+    const E = Bt.get(a);
+    if (E) {
+      if (f)
+        f(E, 4);
+      else
+        for (const k of E) k();
+      Bt.delete(a);
+    }
+  }, t ? n ? H(!0) : F = a.run() : o ? o(H.bind(null, !0), !0) : a.run(), W.pause = a.pause.bind(a), W.resume = a.resume.bind(a), W.stop = W, W;
+}
+function Ue(e, t = 1 / 0, s) {
+  if (t <= 0 || !B(e) || e.__v_skip || (s = s || /* @__PURE__ */ new Map(), (s.get(e) || 0) >= t))
+    return e;
+  if (s.set(e, t), t--, /* @__PURE__ */ ee(e))
+    Ue(e.value, t, s);
+  else if (P(e))
+    for (let n = 0; n < e.length; n++)
+      Ue(e[n], t, s);
+  else if (ys(e) || Xe(e))
+    e.forEach((n) => {
+      Ue(n, t, s);
+    });
+  else if (Ns(e)) {
+    for (const n in e)
+      Ue(e[n], t, s);
+    for (const n of Object.getOwnPropertySymbols(e))
+      Object.prototype.propertyIsEnumerable.call(e, n) && Ue(e[n], t, s);
+  }
+  return e;
+}
+function Rt(e, t, s, n) {
+  try {
+    return n ? e(...n) : e();
+  } catch (i) {
+    ts(i, t, s);
+  }
+}
+function _e(e, t, s, n) {
+  if (I(e)) {
+    const i = Rt(e, t, s, n);
+    return i && Bn(i) && i.catch((r) => {
+      ts(r, t, s, void 0, !0);
+    }), i;
+  }
+  if (P(e)) {
+    const i = [];
+    for (let r = 0; r < e.length; r++)
+      i.push(_e(e[r], t, s, n));
+    return i;
+  }
+}
+function ts(e, t, s, n = !0, i = !1) {
+  const r = t ? t.vnode : null, { errorHandler: o, throwUnhandledErrorInProduction: l } = t && t.appContext.config || K;
+  if (t) {
+    let f = t.parent;
+    const h = t.proxy, a = `https://vuejs.org/error-reference/#runtime-${s}`;
+    for (; f; ) {
+      const p = f.ec;
+      if (p && !f.isUnmounted && // Async failures may outlive stopped scopes whose unmount effects
+      // are deferred or discarded by Suspense.
+      (!i || f.scope.active)) {
+        for (let w = 0; w < p.length; w++)
+          if (p[w](e, h, a) === !1)
+            return;
+      }
+      f = f.parent;
+    }
+    if (o) {
+      Ee(), Rt(o, null, 10, [
+        e,
+        h,
+        a
+      ]), Oe();
+      return;
+    }
+  }
+  Lr(e, s, r, n, l);
+}
+function Lr(e, t, s, n = !0, i = !1) {
+  if (i)
+    throw e;
+  console.error(e);
+}
+const ie = [];
+let he = -1;
+const Se = [];
+let Ve = null, nt = 0;
+const ui = /* @__PURE__ */ Promise.resolve();
+let Wt = null;
+function ai(e) {
+  const t = Wt || ui;
+  return e ? t.then(this ? e.bind(this) : e) : t;
+}
+function $r(e) {
+  let t = he + 1, s = ie.length;
+  for (; t < s; ) {
+    const n = t + s >>> 1, i = ie[n], r = Ct(i);
+    r < e || r === e && i.flags & 2 ? t = n + 1 : s = n;
+  }
+  return t;
+}
+function Js(e) {
+  if (!(e.flags & 1)) {
+    const t = Ct(e), s = ie[ie.length - 1];
+    !s || // fast path when the job id is larger than the tail
+    !(e.flags & 2) && t >= Ct(s) ? ie.push(e) : ie.splice($r(t), 0, e), e.flags |= 1, hi();
+  }
+}
+function hi() {
+  Wt || (Wt = ui.then(gi));
+}
+function Vr(e) {
+  if (!P(e))
+    Ve && e.id === -1 ? Ve.splice(nt + 1, 0, e) : e.flags & 1 || (Se.push(e), e.flags |= 1);
+  else
+    for (let t = 0; t < e.length; t++)
+      Se.push(e[t]);
+  hi();
+}
+function di(e, t, s, n = he + 1) {
+  for (; n < ie.length; n++) {
+    const i = ie[n];
+    if (i && i.flags & 2) {
+      if (e && i.id !== e.uid || t !== void 0 && !(i.id >= t))
+        continue;
+      ie.splice(n, 1), n = e ? n - 1 : he, i.flags & 4 && (i.flags &= -2), i(), i.flags & 4 || (i.flags &= -2);
+    }
+  }
+}
+function pi(e, t, s = 0) {
+  if (Se.length) {
+    let n = Se, i = 0;
+    if (t) {
+      n = [];
+      for (let o = 0; o < Se.length; o++) {
+        const l = Se[o];
+        (l.i !== void 0 ? !l.i || l.i.uid < s : t.has(l)) ? Se[i++] = l : n.push(l);
+      }
+    }
+    const r = [...new Set(n)].sort((o, l) => Ct(o) - Ct(l));
+    if (Se.length = i, Ve) {
+      for (let o = 0; o < r.length; o++)
+        Ve.push(r[o]);
+      return;
+    }
+    for (Ve = r, nt = 0; nt < Ve.length; nt++) {
+      const o = Ve[nt];
+      o.flags & 4 && (o.flags &= -2), o.flags & 8 || o(), o.flags &= -2;
+    }
+    Ve = null, nt = 0;
+  }
+}
+let as = !1;
+function Ur(e, t) {
+  if (as) {
+    e();
+    return;
+  }
+  const s = t === void 0 ? void 0 : new Set(Se);
+  e(), as = !0;
+  try {
+    di(void 0, t), pi(void 0, s, t);
+  } finally {
+    as = !1;
+  }
+}
+const Ct = (e) => e.id == null ? e.flags & 2 ? -1 : 1 / 0 : e.id;
+function gi(e) {
+  try {
+    for (he = 0; he < ie.length; he++) {
+      const t = ie[he];
+      t && !(t.flags & 8) && (t.flags & 4 && (t.flags &= -2), Rt(
+        t,
+        t.i,
+        t.i ? 15 : 14
+      ), t.flags & 4 || (t.flags &= -2));
+    }
+  } finally {
+    for (; he < ie.length; he++) {
+      const t = ie[he];
+      t && (t.flags &= -2);
+    }
+    he = -1, ie.length = 0, pi(), Wt = null, (ie.length || Se.length) && gi();
+  }
+}
+let Te = null, _i = null;
+function qt(e) {
+  const t = Te;
+  return Te = e, _i = e && e.type.__scopeId || null, t;
+}
+function Kr(e, t = Te, s) {
+  if (!t || e._n)
+    return e;
+  const n = (...i) => {
+    n._d && En(-1);
+    const r = qt(t), o = et.length;
+    let l;
+    try {
+      l = e(...i);
+    } finally {
+      for (let f = et.length; f > o; f--) Ui();
+      qt(r), n._d && En(1);
+    }
+    return l;
+  };
+  return n._n = !0, n._c = !0, n._d = !0, n;
+}
+function Je(e, t, s, n) {
+  let i = e;
+  if (n === "beforeMount")
+    e._mount = e;
+  else if (n === "beforeUpdate") {
+    const l = t && t._mount;
+    l && (l._latest = e, e._mount = l);
+  } else if (n === "mounted") {
+    const l = e._latest;
+    e._mount = e._latest = void 0, l && (i = l, l._mount = void 0);
+  }
+  const r = i.dirs, o = t && t.dirs;
+  for (let l = 0; l < r.length; l++) {
+    let f = r[l];
+    o ? f.oldValue = o[l].value : n === "mounted" && f.oldValue !== void 0 && (f = G({}, f, { oldValue: void 0 }));
+    let h = f.dir[n];
+    h && (Ee(), _e(h, s, 8, [
+      e.el,
+      f,
+      i,
+      t
+    ]), Oe());
+  }
+}
+function Br(e, t) {
+  if (re) {
+    let s = re.provides;
+    const n = re.parent && re.parent.provides;
+    n === s && (s = re.provides = Object.create(n)), s[e] = t;
+  }
+}
+function Ut(e, t, s = !1) {
+  const n = Go();
+  if (n || it) {
+    let i = it ? it._context.provides : n ? n.parent == null || n.ce ? n.vnode.appContext && n.vnode.appContext.provides : n.parent.provides : void 0;
+    if (i && e in i)
+      return i[e];
+    if (arguments.length > 1)
+      return s && I(t) ? t.call(n && n.proxy) : t;
+  }
+}
+const Wr = /* @__PURE__ */ Symbol.for("v-scx"), qr = () => Ut(Wr);
+function Gr(e, t) {
+  return Ys(e, null, t);
+}
+function hs(e, t, s) {
+  return Ys(e, t, s);
+}
+function Ys(e, t, s = K) {
+  const { immediate: n, deep: i, flush: r, once: o } = s, l = G({}, s), f = t && n || !t && r !== "post";
+  let h;
+  if (Ot) {
+    if (r === "sync") {
+      const C = qr();
+      h = C.__watcherHandles || (C.__watcherHandles = []);
+    } else if (!f) {
+      const C = () => {
+      };
+      return C.stop = Ae, C.resume = Ae, C.pause = Ae, C;
+    }
+  }
+  const a = re;
+  l.call = (C, D, R) => _e(C, a, D, R);
+  let p = !1;
+  r === "post" ? l.scheduler = (C) => {
+    C.i = a, ne(C, a && a.suspense);
+  } : r !== "sync" && (p = !0, l.scheduler = (C, D) => {
+    D ? C() : Js(C);
+  }), l.augmentJob = (C) => {
+    t && (C.flags |= 4), p && (C.flags |= 2, a && (C.id = a.uid, C.i = a));
+  };
+  const w = Hr(e, t, l);
+  return Ot && (h ? h.push(w) : f && w()), w;
+}
+function Jr(e, t, s) {
+  const n = this.proxy, i = J(e) ? e.includes(".") ? mi(n, e) : () => n[e] : e.bind(n, n);
+  let r;
+  I(t) ? r = t : (r = t.handler, s = t);
+  const o = It(this), l = Ys(i, r.bind(n), s);
+  return o(), l;
+}
+function mi(e, t) {
+  const s = t.split(".");
+  return () => {
+    let n = e;
+    for (let i = 0; i < s.length && n; i++)
+      n = n[s[i]];
+    return n;
+  };
+}
+const Yr = /* @__PURE__ */ Symbol("_vte"), ss = (e) => e.__isTeleport, ds = /* @__PURE__ */ Symbol("_leaveCb");
+function zr(e) {
+  let t = e[0];
+  if (e.length > 1) {
+    for (const s of e)
+      if (s.type !== De) {
+        t = s;
+        break;
+      }
+  }
+  return t;
+}
+function bi(e) {
+  if (!zs(e))
+    return ss(e.type) && e.children ? zr(e.children) : e;
+  if (e.component)
+    return e.component.subTree;
+  const { shapeFlag: t, children: s } = e;
+  if (s) {
+    if (t & 16)
+      return s[0];
+    if (t & 32 && I(s.default))
+      return s.default();
+  }
+}
+function _t(e, t) {
+  if (e.shapeFlag & 6 && e.component) {
+    e.transition = t;
+    const s = e.component.subTree;
+    _t(
+      ss(s.type) && bi(s) || s,
+      t
+    );
+  } else if (e.shapeFlag & 128) {
+    const s = e.suspense;
+    if (s) {
+      const n = s.isHydrating ? s.pendingBranch : s.activeBranch;
+      n && _t(n, t.clone(n));
+    } else
+      e.ssContent.transition = t.clone(e.ssContent), e.ssFallback.transition = t.clone(e.ssFallback);
+  } else if (e.transition = t, e.type === de && P(e.children)) {
+    const s = Oi(e.children, !1);
+    s && _t(s, t);
+  }
+}
+function Ts(e) {
+  if (e.component)
+    return Ts(e.component.subTree);
+  if (e.type === de) {
+    const t = P(e.children) && Oi(e.children, !1);
+    return t ? Ts(t) : void 0;
+  }
+  if (e.type !== De)
+    return e;
+}
+// @__NO_SIDE_EFFECTS__
+function yi(e, t) {
+  return I(e) ? (
+    // #8236: extend call and options.name access are considered side-effects
+    // by Rollup, so we have to wrap it in a pure-annotated IIFE.
+    G({ name: e.name }, t, { setup: e })
+  ) : e;
+}
+function vi(e) {
+  e.ids = [e.ids[0] + e.ids[2]++ + "-", 0, 0];
+}
+function mn(e, t) {
+  let s;
+  return !!((s = Object.getOwnPropertyDescriptor(e, t)) && !s.configurable);
+}
+const Gt = /* @__PURE__ */ new WeakMap();
+function mt(e, t, s, n, i = !1) {
+  if (P(e)) {
+    e.forEach(
+      (R, Y) => mt(
+        R,
+        t && (P(t) ? t[Y] : t),
+        s,
+        n,
+        i
+      )
+    );
+    return;
+  }
+  if (bt(n) && !i) {
+    n.shapeFlag & 512 && n.type.__asyncResolved && n.component.subTree.component && mt(e, t, s, n.component.subTree);
+    return;
+  }
+  const r = n.shapeFlag & 4 ? Qs(n.component) : n.el, o = i ? null : r, { i: l, r: f } = e, h = t && t.r, a = l.refs === K ? l.refs = {} : l.refs, p = l.setupState, w = /* @__PURE__ */ j(p), C = p === K ? Kn : (R) => mn(a, R) ? !1 : N(w, R), D = (R, Y) => !(Y && mn(a, Y));
+  if (h != null && h !== f) {
+    if (bn(t), J(h))
+      a[h] = null, C(h) && (p[h] = null);
+    else if (/* @__PURE__ */ ee(h)) {
+      const R = t;
+      D(h, R.k) && (h.value = null), R.k && (a[R.k] = null);
+    }
+  }
+  if (I(f))
+    Rt(f, l, 12, [o, a]);
+  else {
+    const R = J(f), Y = /* @__PURE__ */ ee(f);
+    if (R || Y) {
+      const W = () => {
+        if (e.f) {
+          const F = R ? C(f) ? p[f] : a[f] : D() || !e.k ? f.value : a[e.k];
+          if (i)
+            P(F) && Fs(F, r);
+          else if (P(F))
+            F.includes(r) || F.push(r);
+          else if (R)
+            a[f] = [r], C(f) && (p[f] = a[f]);
+          else {
+            const H = [r];
+            D(f, e.k) && (f.value = H), e.k && (a[e.k] = H);
+          }
+        } else R ? (a[f] = o, C(f) && (p[f] = o)) : Y && (D(f, e.k) && (f.value = o), e.k && (a[e.k] = o));
+      };
+      if (o) {
+        const F = () => {
+          W(), Gt.delete(e);
+        };
+        F.id = -1, Gt.set(e, F), ne(F, s);
+      } else
+        bn(e), W();
+    }
+  }
+}
+function bn(e) {
+  const t = Gt.get(e);
+  t && (t.flags |= 8, Gt.delete(e));
+}
+Qt().requestIdleCallback;
+Qt().cancelIdleCallback;
+const bt = (e) => !!e.type.__asyncLoader, zs = (e) => e.type.__isKeepAlive;
+function kr(e, t) {
+  xi(e, "a", t);
+}
+function Xr(e, t) {
+  xi(e, "da", t);
+}
+function xi(e, t, s = re) {
+  const n = e.__wdc || (e.__wdc = () => {
+    let i = s;
+    for (; i; ) {
+      if (i.isDeactivated)
+        return;
+      i = i.parent;
+    }
+    return e();
+  });
+  if (Tt(t, n, s), s) {
+    let i = s.parent;
+    for (; i && i.parent; )
+      zs(i.parent.vnode) && Zr(n, t, s, i), i = i.parent;
+  }
+}
+function Zr(e, t, s, n) {
+  const i = Tt(
+    t,
+    e,
+    n,
+    !0
+    /* prepend */
+  ), r = Tt(
+    "um",
+    () => Fs(n[t], i),
+    s
+  );
+  r.flags = 16;
+}
+function Tt(e, t, s = re, n = !1) {
+  if (s) {
+    const i = s[e] || (s[e] = []), r = t.__weh || (t.__weh = (...o) => {
+      Ee();
+      const l = It(s), f = _e(t, s, e, o);
+      return l(), Oe(), f;
+    });
+    return n ? i.unshift(r) : i.push(r), r;
+  }
+}
+const He = (e) => (t, s = re) => {
+  (!Ot || e === "sp") && Tt(e, (...n) => t(...n), s);
+}, Qr = He("bm"), Si = He("m"), eo = He(
+  "bu"
+), to = He("u"), wi = He(
+  "bum"
+), so = He("um"), no = He(
+  "sp"
+), io = He("rtg"), ro = He("rtc");
+function oo(e, t = re) {
+  Tt("ec", e, t);
+}
+const lo = /* @__PURE__ */ Symbol.for("v-ndc"), As = (e) => e ? Wi(e) ? Qs(e) : As(e.parent) : null, yt = (
+  // Move PURE marker to new line to workaround compiler discarding it
+  // due to type annotation
+  /* @__PURE__ */ G(/* @__PURE__ */ Object.create(null), {
+    $: (e) => e,
+    $el: (e) => e.vnode.el,
+    $data: (e) => e.data,
+    $props: (e) => e.props,
+    $attrs: (e) => e.attrs,
+    $slots: (e) => e.slots,
+    $refs: (e) => e.refs,
+    $parent: (e) => As(e.parent),
+    $root: (e) => As(e.root),
+    $host: (e) => e.ce,
+    $emit: (e) => e.emit,
+    $options: (e) => Ti(e),
+    $forceUpdate: (e) => e.f || (e.f = () => {
+      Js(e.update);
+    }),
+    $nextTick: (e) => e.n || (e.n = ai.bind(e.proxy)),
+    $watch: (e) => Jr.bind(e)
+  })
+), ps = (e, t) => e !== K && !e.__isScriptSetup && N(e, t), co = {
+  get({ _: e }, t) {
+    if (t === "__v_skip")
+      return !0;
+    const { ctx: s, setupState: n, data: i, props: r, accessCache: o, type: l, appContext: f } = e;
+    if (t[0] !== "$") {
+      const w = o[t];
+      if (w !== void 0)
+        switch (w) {
+          case 1:
+            return n[t];
+          case 2:
+            return i[t];
+          case 4:
+            return s[t];
+          case 3:
+            return r[t];
+        }
+      else {
+        if (ps(n, t))
+          return o[t] = 1, n[t];
+        if (i !== K && N(i, t))
+          return o[t] = 2, i[t];
+        if (N(r, t))
+          return o[t] = 3, r[t];
+        if (s !== K && N(s, t))
+          return o[t] = 4, s[t];
+        Es && (o[t] = 0);
+      }
+    }
+    const h = yt[t];
+    let a, p;
+    if (h)
+      return t === "$attrs" && Q(e.attrs, "get", ""), h(e);
+    if (
+      // css module (injected by vue-loader)
+      (a = l.__cssModules) && (a = a[t])
+    )
+      return a;
+    if (s !== K && N(s, t))
+      return o[t] = 4, s[t];
+    if (
+      // global properties
+      p = f.config.globalProperties, N(p, t)
+    )
+      return p[t];
+  },
+  set({ _: e }, t, s) {
+    const { data: n, setupState: i, ctx: r } = e;
+    return ps(i, t) ? (i[t] = s, !0) : n !== K && N(n, t) ? (n[t] = s, !0) : N(e.props, t) || t[0] === "$" && t.slice(1) in e ? !1 : (r[t] = s, !0);
+  },
+  has({
+    _: { data: e, setupState: t, accessCache: s, ctx: n, appContext: i, props: r, type: o }
+  }, l) {
+    let f;
+    return !!(s[l] || e !== K && l[0] !== "$" && N(e, l) || ps(t, l) || N(r, l) || N(n, l) || N(yt, l) || N(i.config.globalProperties, l) || (f = o.__cssModules) && f[l]);
+  },
+  defineProperty(e, t, s) {
+    return s.get != null ? e._.accessCache[t] = 0 : N(s, "value") && this.set(e, t, s.value, null), Reflect.defineProperty(e, t, s);
+  }
+};
+function yn(e) {
+  return P(e) ? e.reduce(
+    (t, s) => (t[s] = null, t),
+    {}
+  ) : e;
+}
+let Es = !0;
+function fo(e) {
+  const t = Ti(e), s = e.proxy, n = e.ctx;
+  Es = !1, t.beforeCreate && vn(t.beforeCreate, e, "bc");
+  const {
+    // state
+    data: i,
+    computed: r,
+    methods: o,
+    watch: l,
+    provide: f,
+    inject: h,
+    // lifecycle
+    created: a,
+    beforeMount: p,
+    mounted: w,
+    beforeUpdate: C,
+    updated: D,
+    activated: R,
+    deactivated: Y,
+    beforeDestroy: W,
+    beforeUnmount: F,
+    destroyed: H,
+    unmounted: E,
+    render: k,
+    renderTracked: Le,
+    renderTriggered: me,
+    errorCaptured: $e,
+    serverPrefetch: Mt,
+    // public API
+    expose: We,
+    inheritAttrs: ot,
+    // assets
+    components: Ft,
+    directives: Nt,
+    filters: rs
+  } = t;
+  if (h && uo(h, n, null), o)
+    for (const q in o) {
+      const V = o[q];
+      I(V) && (n[q] = V.bind(s));
+    }
+  if (i) {
+    const q = i.call(s, s);
+    B(q) && (e.data = /* @__PURE__ */ Ws(q));
+  }
+  if (Es = !0, r)
+    for (const q in r) {
+      const V = r[q], qe = I(V) ? V.bind(s, s) : I(V.get) ? V.get.bind(s, s) : Ae, jt = !I(V) && I(V.set) ? V.set.bind(s) : Ae, Ge = Rs({
+        get: qe,
+        set: jt
+      });
+      Object.defineProperty(n, q, {
+        enumerable: !0,
+        configurable: !0,
+        get: () => Ge.value,
+        set: (ue) => Ge.value = ue
+      });
+    }
+  if (l)
+    for (const q in l)
+      Ci(l[q], n, s, q);
+  if (f) {
+    const q = I(f) ? f.call(s) : f;
+    Reflect.ownKeys(q).forEach((V) => {
+      Br(V, q[V]);
+    });
+  }
+  a && vn(a, e, "c");
+  function te(q, V) {
+    P(V) ? V.forEach((qe) => q(qe.bind(s))) : V && q(V.bind(s));
+  }
+  if (te(Qr, p), te(Si, w), te(eo, C), te(to, D), te(kr, R), te(Xr, Y), te(oo, $e), te(ro, Le), te(io, me), te(wi, F), te(so, E), te(no, Mt), P(We))
+    if (We.length) {
+      const q = e.exposed || (e.exposed = {});
+      We.forEach((V) => {
+        Object.defineProperty(q, V, {
+          get: () => s[V],
+          set: (qe) => s[V] = qe,
+          enumerable: !0
+        });
+      });
+    } else e.exposed || (e.exposed = {});
+  k && e.render === Ae && (e.render = k), ot != null && (e.inheritAttrs = ot), Ft && (e.components = Ft), Nt && (e.directives = Nt), Mt && vi(e);
+}
+function uo(e, t, s = Ae) {
+  P(e) && (e = Os(e));
+  for (const n in e) {
+    const i = e[n];
+    let r;
+    B(i) ? "default" in i ? r = Ut(
+      i.from || n,
+      i.default,
+      !0
+    ) : r = Ut(i.from || n) : r = Ut(i), /* @__PURE__ */ ee(r) ? Object.defineProperty(t, n, {
+      enumerable: !0,
+      configurable: !0,
+      get: () => r.value,
+      set: (o) => r.value = o
+    }) : t[n] = r;
+  }
+}
+function vn(e, t, s) {
+  _e(
+    P(e) ? e.map((n) => n.bind(t.proxy)) : e.bind(t.proxy),
+    t,
+    s
+  );
+}
+function Ci(e, t, s, n) {
+  let i = n.includes(".") ? mi(s, n) : () => s[n];
+  if (J(e)) {
+    const r = t[e];
+    I(r) && hs(i, r);
+  } else if (I(e))
+    hs(i, e.bind(s));
+  else if (B(e))
+    if (P(e))
+      e.forEach((r) => Ci(r, t, s, n));
+    else {
+      const r = I(e.handler) ? e.handler.bind(s) : t[e.handler];
+      I(r) && hs(i, r, e);
+    }
+}
+function Ti(e) {
+  const t = e.type, { mixins: s, extends: n } = t, {
+    mixins: i,
+    optionsCache: r,
+    config: { optionMergeStrategies: o }
+  } = e.appContext, l = r.get(t);
+  let f;
+  return l ? f = l : !i.length && !s && !n ? f = t : (f = {}, i.length && i.forEach(
+    (h) => Jt(f, h, o, !0)
+  ), Jt(f, t, o)), B(t) && r.set(t, f), f;
+}
+function Jt(e, t, s, n = !1) {
+  const { mixins: i, extends: r } = t;
+  r && Jt(e, r, s, !0), i && i.forEach(
+    (o) => Jt(e, o, s, !0)
+  );
+  for (const o in t)
+    if (!(n && o === "expose")) {
+      const l = ao[o] || s && s[o];
+      e[o] = l ? l(e[o], t[o]) : t[o];
+    }
+  return e;
+}
+const ao = {
+  data: xn,
+  props: Sn,
+  emits: Sn,
+  // objects
+  methods: at,
+  computed: at,
+  // lifecycle
+  beforeCreate: se,
+  created: se,
+  beforeMount: se,
+  mounted: se,
+  beforeUpdate: se,
+  updated: se,
+  beforeDestroy: se,
+  beforeUnmount: se,
+  destroyed: se,
+  unmounted: se,
+  activated: se,
+  deactivated: se,
+  errorCaptured: se,
+  serverPrefetch: se,
+  // assets
+  components: at,
+  directives: at,
+  // watch
+  watch: po,
+  // provide / inject
+  provide: xn,
+  inject: ho
+};
+function xn(e, t) {
+  return t ? e ? function() {
+    return G(
+      I(e) ? e.call(this, this) : e,
+      I(t) ? t.call(this, this) : t
+    );
+  } : t : e;
+}
+function ho(e, t) {
+  return at(Os(e), Os(t));
+}
+function Os(e) {
+  if (P(e)) {
+    const t = {};
+    for (let s = 0; s < e.length; s++)
+      t[e[s]] = e[s];
+    return t;
+  }
+  return e;
+}
+function se(e, t) {
+  return e ? [...new Set([].concat(e, t))] : t;
+}
+function at(e, t) {
+  return e ? G(/* @__PURE__ */ Object.create(null), e, t) : t;
+}
+function Sn(e, t) {
+  return e ? P(e) && P(t) ? [.../* @__PURE__ */ new Set([...e, ...t])] : G(
+    /* @__PURE__ */ Object.create(null),
+    yn(e),
+    yn(t ?? {})
+  ) : t;
+}
+function po(e, t) {
+  if (!e) return t;
+  if (!t) return e;
+  const s = G(/* @__PURE__ */ Object.create(null), e);
+  for (const n in t)
+    s[n] = se(e[n], t[n]);
+  return s;
+}
+function Ai() {
+  return {
+    app: null,
+    config: {
+      isNativeTag: Kn,
+      performance: !1,
+      globalProperties: {},
+      optionMergeStrategies: {},
+      errorHandler: void 0,
+      warnHandler: void 0,
+      compilerOptions: {}
+    },
+    mixins: [],
+    components: {},
+    directives: {},
+    provides: /* @__PURE__ */ Object.create(null),
+    optionsCache: /* @__PURE__ */ new WeakMap(),
+    propsCache: /* @__PURE__ */ new WeakMap(),
+    emitsCache: /* @__PURE__ */ new WeakMap()
+  };
+}
+let go = 0;
+function _o(e, t) {
+  return function(n, i = null) {
+    I(n) || (n = G({}, n)), i != null && !B(i) && (i = null);
+    const r = Ai(), o = /* @__PURE__ */ new WeakSet(), l = [];
+    let f = !1;
+    const h = r.app = {
+      _uid: go++,
+      _component: n,
+      _props: i,
+      _container: null,
+      _context: r,
+      _instance: null,
+      version: Zo,
+      get config() {
+        return r.config;
+      },
+      set config(a) {
+      },
+      use(a, ...p) {
+        return o.has(a) || (a && I(a.install) ? (o.add(a), a.install(h, ...p)) : I(a) && (o.add(a), a(h, ...p))), h;
+      },
+      mixin(a) {
+        return r.mixins.includes(a) || r.mixins.push(a), h;
+      },
+      component(a, p) {
+        return p ? (r.components[a] = p, h) : r.components[a];
+      },
+      directive(a, p) {
+        return p ? (r.directives[a] = p, h) : r.directives[a];
+      },
+      mount(a, p, w) {
+        if (!f) {
+          const C = h._ceVNode || Ke(n, i);
+          return C.appContext = r, w === !0 ? w = "svg" : w === !1 && (w = void 0), e(C, a, w), f = !0, h._container = a, a.__vue_app__ = h, Qs(C.component);
+        }
+      },
+      onUnmount(a) {
+        l.push(a);
+      },
+      unmount() {
+        f && (_e(
+          l,
+          h._instance,
+          16
+        ), e(null, h._container), delete h._container.__vue_app__);
+      },
+      provide(a, p) {
+        return r.provides[a] = p, h;
+      },
+      runWithContext(a) {
+        const p = it;
+        it = h;
+        try {
+          return a();
+        } finally {
+          it = p;
+        }
+      }
+    };
+    return h;
+  };
+}
+let it = null;
+const mo = (e, t) => t === "modelValue" || t === "model-value" ? e.modelModifiers : e[`${t}Modifiers`] || e[`${oe(t)}Modifiers`] || e[`${fe(t)}Modifiers`];
+function bo(e, t, ...s) {
+  if (e.isUnmounted) return;
+  const n = e.vnode.props || K;
+  let i = s;
+  const r = t.startsWith("update:"), o = r && mo(n, t.slice(7));
+  o && (o.trim && (i = s.map((a) => J(a) ? a.trim() : a)), o.number && (i = i.map(tr)));
+  let l, f = n[l = os(t)] || // also try camelCase event handler (#2249)
+  n[l = os(oe(t))];
+  !f && r && (f = n[l = os(fe(t))]), f && _e(
+    f,
+    e,
+    6,
+    i
+  );
+  const h = n[l + "Once"];
+  if (h) {
+    if (!e.emitted)
+      e.emitted = {};
+    else if (e.emitted[l])
+      return;
+    e.emitted[l] = !0, _e(
+      h,
+      e,
+      6,
+      i
+    );
+  }
+}
+const yo = /* @__PURE__ */ new WeakMap();
+function Ei(e, t, s = !1) {
+  const n = s ? yo : t.emitsCache, i = n.get(e);
+  if (i !== void 0)
+    return i;
+  const r = e.emits;
+  let o = {}, l = !1;
+  if (!I(e)) {
+    const f = (h) => {
+      const a = Ei(h, t, !0);
+      a && (l = !0, G(o, a));
+    };
+    !s && t.mixins.length && t.mixins.forEach(f), e.extends && f(e.extends), e.mixins && e.mixins.forEach(f);
+  }
+  return !r && !l ? (B(e) && n.set(e, null), null) : (P(r) ? r.forEach((f) => o[f] = null) : G(o, r), B(e) && n.set(e, o), o);
+}
+function ns(e, t) {
+  return !e || !kt(t) ? !1 : (t = t.slice(2), t = t === "Once" ? t : t.replace(/Once$/, ""), N(e, t[0].toLowerCase() + t.slice(1)) || N(e, fe(t)) || N(e, t));
+}
+function wn(e) {
+  const {
+    type: t,
+    vnode: s,
+    proxy: n,
+    withProxy: i,
+    propsOptions: [r],
+    slots: o,
+    attrs: l,
+    emit: f,
+    render: h,
+    renderCache: a,
+    props: p,
+    data: w,
+    setupState: C,
+    ctx: D,
+    inheritAttrs: R
+  } = e, Y = qt(e);
+  let W, F;
+  try {
+    if (s.shapeFlag & 4) {
+      const E = i || n, k = E;
+      W = we(
+        h.call(
+          k,
+          E,
+          a,
+          p,
+          C,
+          w,
+          D
+        )
+      ), F = l;
+    } else {
+      const E = t;
+      W = we(
+        E.length > 1 ? E(
+          p,
+          { attrs: l, slots: o, emit: f }
+        ) : E(
+          p,
+          null
+        )
+      ), F = t.props ? l : vo(l);
+    }
+  } catch (E) {
+    et.length = 0, ts(E, e, 1), W = Ke(De);
+  }
+  let H = W;
+  if (F && R !== !1) {
+    const E = Object.keys(F), { shapeFlag: k } = H;
+    E.length && k & 7 && (r && E.some(Xt) && (F = xo(
+      F,
+      r
+    )), H = rt(H, F, !1, !0));
+  }
+  if (s.dirs && (H = rt(H, null, !1, !0), H.dirs = H.dirs ? H.dirs.concat(s.dirs) : s.dirs), s.transition) {
+    const E = ss(H.type) && bi(H) || H;
+    _t(E, s.transition);
+  }
+  return W = H, qt(Y), W;
+}
+function Oi(e, t = !0) {
+  let s;
+  for (let n = 0; n < e.length; n++) {
+    const i = e[n];
+    if (Zs(i)) {
+      if (i.type !== De || i.children === "v-if") {
+        if (s)
+          return;
+        s = i;
+      }
+    } else
+      return;
+  }
+  return s;
+}
+const vo = (e) => {
+  let t;
+  for (const s in e)
+    (s === "class" || s === "style" || kt(s)) && ((t || (t = {}))[s] = e[s]);
+  return t;
+}, xo = (e, t) => {
+  const s = {};
+  for (const n in e)
+    (!Xt(n) || !(n.slice(9) in t)) && (s[n] = e[n]);
+  return s;
+};
+function So(e, t, s) {
+  const { props: n, children: i, component: r } = e, { props: o, children: l, patchFlag: f } = t, h = r.emitsOptions;
+  if (t.dirs || t.transition)
+    return !0;
+  if (s && f >= 0) {
+    if (f & 1024)
+      return !0;
+    if (f & 16)
+      return n ? Cn(n, o, h) : !!o;
+    if (f & 8) {
+      const a = t.dynamicProps;
+      for (let p = 0; p < a.length; p++) {
+        const w = a[p];
+        if (Pi(o, n, w) && !ns(h, w))
+          return !0;
+      }
+    }
+  } else
+    return (i || l) && (!l || !l.$stable) ? !0 : n === o ? !1 : n ? o ? Cn(n, o, h) : !0 : !!o;
+  return !1;
+}
+function Cn(e, t, s) {
+  const n = Object.keys(t);
+  if (n.length !== Object.keys(e).length)
+    return !0;
+  for (let i = 0; i < n.length; i++) {
+    const r = n[i];
+    if (!N(e, r) || Pi(t, e, r) && !ns(s, r))
+      return !0;
+  }
+  return !1;
+}
+function Pi(e, t, s) {
+  const n = e[s], i = t[s];
+  return s === "style" && B(n) && B(i) ? !es(n, i) : n !== i;
+}
+function wo({ vnode: e, parent: t, suspense: s }, n) {
+  for (; t; ) {
+    const i = t.subTree;
+    if (i.suspense && i.suspense.activeBranch === e && (i.suspense.vnode.el = i.el = n, e = i), i === e)
+      (e = t.vnode).el = n, t = t.parent;
+    else
+      break;
+  }
+  s && s.activeBranch === e && (s.vnode.el = n);
+}
+const Ri = {}, Ii = () => Object.create(Ri), Mi = (e) => Object.getPrototypeOf(e) === Ri;
+function Co(e, t, s, n = !1) {
+  const i = {}, r = Ii();
+  e.propsDefaults = /* @__PURE__ */ Object.create(null), Fi(e, t, i, r);
+  for (const o in e.propsOptions[0])
+    o in i || (i[o] = void 0);
+  s ? e.props = n ? i : /* @__PURE__ */ Or(i) : e.type.props ? e.props = i : e.props = r, e.attrs = r;
+}
+function To(e, t, s, n) {
+  const {
+    props: i,
+    attrs: r,
+    vnode: { patchFlag: o }
+  } = e, l = /* @__PURE__ */ j(i), [f] = e.propsOptions;
+  let h = !1;
+  if (
+    // always force full diff in dev
+    // - #1942 if hmr is enabled with sfc component
+    // - vite#872 non-sfc component used by sfc component
+    (n || o > 0) && !(o & 16)
+  ) {
+    if (o & 8) {
+      const a = e.vnode.dynamicProps;
+      for (let p = 0; p < a.length; p++) {
+        let w = a[p];
+        if (ns(e.emitsOptions, w))
+          continue;
+        const C = t[w];
+        if (f)
+          if (N(r, w))
+            C !== r[w] && (r[w] = C, h = !0);
+          else {
+            const D = oe(w);
+            i[D] = Ps(
+              f,
+              l,
+              D,
+              C,
+              e,
+              !1
+            );
+          }
+        else
+          C !== r[w] && (r[w] = C, h = !0);
+      }
+    }
+  } else {
+    Fi(e, t, i, r) && (h = !0);
+    let a;
+    for (const p in l)
+      (!t || // for camelCase
+      !N(t, p) && // it's possible the original props was passed in as kebab-case
+      // and converted to camelCase (#955)
+      ((a = fe(p)) === p || !N(t, a))) && (f ? s && // for camelCase
+      (s[p] !== void 0 || // for kebab-case
+      s[a] !== void 0) && (i[p] = Ps(
+        f,
+        l,
+        p,
+        void 0,
+        e,
+        !0
+      )) : delete i[p]);
+    if (r !== l)
+      for (const p in r)
+        (!t || !N(t, p)) && (delete r[p], h = !0);
+  }
+  h && Ne(e.attrs, "set", "");
+}
+function Fi(e, t, s, n) {
+  const [i, r] = e.propsOptions;
+  let o = !1, l;
+  if (t)
+    for (let f in t) {
+      if (dt(f))
+        continue;
+      const h = t[f];
+      let a;
+      i && N(i, a = oe(f)) ? !r || !r.includes(a) ? s[a] = h : (l || (l = {}))[a] = h : ns(e.emitsOptions, f) || (!(f in n) || h !== n[f]) && (n[f] = h, o = !0);
+    }
+  if (r) {
+    const f = /* @__PURE__ */ j(s), h = l || K;
+    for (let a = 0; a < r.length; a++) {
+      const p = r[a];
+      s[p] = Ps(
+        i,
+        f,
+        p,
+        h[p],
+        e,
+        !N(h, p)
+      );
+    }
+  }
+  return o;
+}
+function Ps(e, t, s, n, i, r) {
+  const o = e[s];
+  if (o != null) {
+    const l = N(o, "default");
+    if (l && n === void 0) {
+      const f = o.default;
+      if (o.type !== Function && !o.skipFactory && I(f)) {
+        const { propsDefaults: h } = i;
+        if (s in h)
+          n = h[s];
+        else {
+          const a = It(i);
+          n = h[s] = f.call(
+            null,
+            t
+          ), a();
+        }
+      } else
+        n = f;
+      i.ce && i.ce._setProp(s, n);
+    }
+    o[
+      0
+      /* shouldCast */
+    ] && (r && !l ? n = !1 : o[
+      1
+      /* shouldCastTrue */
+    ] && (n === "" || n === fe(s)) && (n = !0));
+  }
+  return n;
+}
+const Ao = /* @__PURE__ */ new WeakMap();
+function Ni(e, t, s = !1) {
+  const n = s ? Ao : t.propsCache, i = n.get(e);
+  if (i)
+    return i;
+  const r = e.props, o = {}, l = [];
+  let f = !1;
+  if (!I(e)) {
+    const a = (p) => {
+      f = !0;
+      const [w, C] = Ni(p, t, !0);
+      G(o, w), C && l.push(...C);
+    };
+    !s && t.mixins.length && t.mixins.forEach(a), e.extends && a(e.extends), e.mixins && e.mixins.forEach(a);
+  }
+  if (!r && !f)
+    return B(e) && n.set(e, ke), ke;
+  if (P(r))
+    for (let a = 0; a < r.length; a++) {
+      const p = oe(r[a]);
+      Tn(p) && (o[p] = K);
+    }
+  else if (r)
+    for (const a in r) {
+      const p = oe(a);
+      if (Tn(p)) {
+        const w = r[a], C = o[p] = P(w) || I(w) ? { type: w } : G({}, w), D = C.type;
+        let R = !1, Y = !0;
+        if (P(D))
+          for (let W = 0; W < D.length; ++W) {
+            const F = D[W], H = I(F) && F.name;
+            if (H === "Boolean") {
+              R = !0;
+              break;
+            } else H === "String" && (Y = !1);
+          }
+        else
+          R = I(D) && D.name === "Boolean";
+        C[
+          0
+          /* shouldCast */
+        ] = R, C[
+          1
+          /* shouldCastTrue */
+        ] = Y, (R || N(C, "default")) && l.push(p);
+      }
+    }
+  const h = [o, l];
+  return B(e) && n.set(e, h), h;
+}
+function Tn(e) {
+  return e[0] !== "$" && !dt(e);
+}
+const ks = (e) => e === "_" || e === "_ctx" || e === "$stable", Xs = (e) => P(e) ? e.map(we) : [we(e)], Eo = (e, t, s) => {
+  if (t._n)
+    return t;
+  const n = Kr((...i) => Xs(t(...i)), s);
+  return n._c = !1, n;
+}, ji = (e, t, s) => {
+  const n = e._ctx;
+  for (const i in e) {
+    if (ks(i)) continue;
+    const r = e[i];
+    if (I(r))
+      t[i] = Eo(i, r, n);
+    else if (r != null) {
+      const o = Xs(r);
+      t[i] = () => o;
+    }
+  }
+}, Di = (e, t) => {
+  const s = Xs(t);
+  e.slots.default = () => s;
+}, Hi = (e, t, s) => {
+  for (const n in t)
+    (s || !ks(n)) && (e[n] = t[n]);
+}, Oo = (e, t, s) => {
+  const n = e.slots = Ii();
+  if (e.vnode.shapeFlag & 32) {
+    const i = t._;
+    i ? (Hi(n, t, s), s && qn(n, "_", i, !0)) : ji(t, n);
+  } else t && Di(e, t);
+}, Po = (e, t, s) => {
+  const { vnode: n, slots: i } = e;
+  let r = !0, o = K;
+  if (n.shapeFlag & 32) {
+    const l = t._;
+    l ? s && l === 1 ? r = !1 : Hi(i, t, s) : (r = !t.$stable, ji(t, i)), o = t;
+  } else t && (Di(e, t), o = { default: 1 });
+  if (r)
+    for (const l in i)
+      !ks(l) && o[l] == null && delete i[l];
+}, ne = jo;
+function Ro(e) {
+  return Io(e);
+}
+function Io(e, t) {
+  const s = Qt();
+  s.__VUE__ = !0;
+  const {
+    insert: n,
+    remove: i,
+    patchProp: r,
+    createElement: o,
+    createText: l,
+    createComment: f,
+    setText: h,
+    setElementText: a,
+    parentNode: p,
+    nextSibling: w,
+    setScopeId: C = Ae,
+    insertStaticContent: D
+  } = e, R = (c, u, d, b = null, g = null, m = null, x = void 0, v = null, y = !!u.dynamicChildren) => {
+    if (c === u)
+      return;
+    c && !ut(c, u) && (b = Dt(c), ue(c, g, m, !0), c = null), u.patchFlag === -2 && (y = !1, u.dynamicChildren = null), u.dynamicChildren && c && c.dynamicChildren && c.dynamicChildren.hasOnce && (u.dynamicChildren === ke && (u.dynamicChildren = []), u.dynamicChildren.hasOnce = !0);
+    const { type: _, ref: T, shapeFlag: S } = u;
+    switch (_) {
+      case is:
+        Y(c, u, d, b);
+        break;
+      case De:
+        W(c, u, d, b);
+        break;
+      case _s:
+        c == null && F(u, d, b, x);
+        break;
+      case de:
+        Ft(
+          c,
+          u,
+          d,
+          b,
+          g,
+          m,
+          x,
+          v,
+          y
+        );
+        break;
+      default:
+        S & 1 ? k(
+          c,
+          u,
+          d,
+          b,
+          g,
+          m,
+          x,
+          v,
+          y
+        ) : S & 6 ? Nt(
+          c,
+          u,
+          d,
+          b,
+          g,
+          m,
+          x,
+          v,
+          y
+        ) : (S & 64 || S & 128) && _.process(
+          c,
+          u,
+          d,
+          b,
+          g,
+          m,
+          x,
+          v,
+          y,
+          ct
+        );
+    }
+    T != null && g ? mt(T, c && c.ref, m, u || c, !u) : T == null && c && c.ref != null && mt(c.ref, null, m, c, !0);
+  }, Y = (c, u, d, b) => {
+    if (c == null)
+      n(
+        u.el = l(u.children),
+        d,
+        b
+      );
+    else {
+      const g = u.el = c.el;
+      u.children !== c.children && h(g, u.children);
+    }
+  }, W = (c, u, d, b) => {
+    c == null ? n(
+      u.el = f(u.children || ""),
+      d,
+      b
+    ) : u.el = c.el;
+  }, F = (c, u, d, b) => {
+    [c.el, c.anchor] = D(
+      c.children,
+      u,
+      d,
+      b,
+      c.el,
+      c.anchor
+    );
+  }, H = ({ el: c, anchor: u }, d, b) => {
+    let g;
+    for (; c && c !== u; )
+      g = w(c), n(c, d, b), c = g;
+    n(u, d, b);
+  }, E = ({ el: c, anchor: u }) => {
+    let d;
+    for (; c && c !== u; )
+      d = w(c), i(c), c = d;
+    i(u);
+  }, k = (c, u, d, b, g, m, x, v, y) => {
+    if (u.type === "svg" ? x = "svg" : u.type === "math" && (x = "mathml"), c == null)
+      Le(
+        u,
+        d,
+        b,
+        g,
+        m,
+        x,
+        v,
+        y
+      );
+    else {
+      const _ = c.el && c.el._isVueCE ? c.el : null;
+      try {
+        _ && _._beginPatch(), Mt(
+          c,
+          u,
+          g,
+          m,
+          x,
+          v,
+          y
+        );
+      } finally {
+        _ && _._endPatch();
+      }
+    }
+  }, Le = (c, u, d, b, g, m, x, v) => {
+    let y, _;
+    const { props: T, shapeFlag: S, transition: A, dirs: O } = c;
+    if (y = c.el = o(
+      c.type,
+      m,
+      T && T.is,
+      T
+    ), S & 8 ? a(y, c.children) : S & 16 && $e(
+      c.children,
+      y,
+      null,
+      b,
+      g,
+      gs(c, m),
+      x,
+      v
+    ), O && Je(c, null, b, "created"), me(y, c, c.scopeId, x, b), T) {
+      for (const $ in T)
+        $ !== "value" && !dt($) && r(y, $, null, T[$], m, b);
+      "value" in T && r(y, "value", null, T.value, m), (_ = T.onVnodeBeforeMount) && ve(_, b, c);
+    }
+    O && Je(c, null, b, "beforeMount");
+    const M = Mo(g, A);
+    M ? A.beforeEnter(y) : A && !A.persisted && (y[No] = !0), n(y, u, d), ((_ = T && T.onVnodeMounted) || M || O) && ne(() => {
+      _ && ve(_, b, c), M && A.enter(y), O && Je(c, null, b, "mounted");
+    }, g);
+  }, me = (c, u, d, b, g) => {
+    if (d && C(c, d), b)
+      for (let m = 0; m < b.length; m++)
+        C(c, b[m]);
+    if (g) {
+      let m = g.subTree;
+      if (u === m || Vi(m.type) && (m.ssContent === u || m.ssFallback === u)) {
+        const x = g.vnode;
+        me(
+          c,
+          x,
+          x.scopeId,
+          x.slotScopeIds,
+          g.parent
+        );
+      }
+    }
+  }, $e = (c, u, d, b, g, m, x, v, y = 0) => {
+    for (let _ = y; _ < c.length; _++) {
+      const T = c[_] = v ? Fe(c[_]) : we(c[_]);
+      R(
+        null,
+        T,
+        u,
+        d,
+        b,
+        g,
+        m,
+        x,
+        v
+      );
+    }
+  }, Mt = (c, u, d, b, g, m, x) => {
+    const v = u.el = c.el;
+    let { patchFlag: y, dynamicChildren: _, dirs: T } = u;
+    y |= c.patchFlag & 16;
+    const S = c.props || K, A = u.props || K;
+    let O;
+    if (d && Ye(d, !1), (O = A.onVnodeBeforeUpdate) && ve(O, d, u, c), T && Je(u, c, d, "beforeUpdate"), d && Ye(d, !0), // #6385 the old vnode may be a user-wrapped non-isomorphic block
+    // Force full diff when block metadata is unstable.
+    _ && (!c.dynamicChildren || c.dynamicChildren.length !== _.length) && (y = 0, x = !1, _ = null), (S.innerHTML && A.innerHTML == null || S.textContent && A.textContent == null) && a(v, ""), _ ? We(
+      c.dynamicChildren,
+      _,
+      v,
+      d,
+      b,
+      gs(u, g),
+      m
+    ) : x || V(
+      c,
+      u,
+      v,
+      null,
+      d,
+      b,
+      gs(u, g),
+      m,
+      !1
+    ), y > 0) {
+      if (y & 16)
+        ot(v, S, A, d, g);
+      else if (y & 2 && S.class !== A.class && r(v, "class", null, A.class, g), y & 4 && r(v, "style", S.style, A.style, g), y & 8) {
+        const M = u.dynamicProps;
+        for (let $ = 0; $ < M.length; $++) {
+          const L = M[$], z = S[L], X = A[L];
+          (X !== z || L === "value") && r(v, L, z, X, g, d);
+        }
+      }
+      y & 1 && c.children !== u.children && a(v, u.children);
+    } else !x && _ == null && ot(v, S, A, d, g);
+    ((O = A.onVnodeUpdated) || T) && ne(() => {
+      O && ve(O, d, u, c), T && Je(u, c, d, "updated");
+    }, b);
+  }, We = (c, u, d, b, g, m, x) => {
+    for (let v = 0; v < u.length; v++) {
+      const y = c[v], _ = u[v], T = y.el || vt(y), S = (
+        // oldVNode may be an errored async setup() component inside Suspense
+        // which will not have a mounted element
+        T && // - In the case of a Fragment, we need to provide the actual parent
+        // of the Fragment itself so it can move its children.
+        (y.type === de || // - In the case of different nodes, there is going to be a replacement
+        // which also requires the correct parent container
+        !ut(y, _) || // - In the case of a component, it could contain anything.
+        y.shapeFlag & 198) ? p(T) : (
+          // In other cases, the parent container is not actually used so we
+          // just pass the block element here to avoid a DOM parentNode call.
+          d
+        )
+      );
+      R(
+        y,
+        _,
+        S,
+        null,
+        b,
+        g,
+        m,
+        x,
+        !0
+      );
+    }
+  }, ot = (c, u, d, b, g) => {
+    if (u !== d) {
+      if (u !== K)
+        for (const m in u)
+          !dt(m) && !(m in d) && r(
+            c,
+            m,
+            u[m],
+            null,
+            g,
+            b
+          );
+      for (const m in d) {
+        if (dt(m)) continue;
+        const x = d[m], v = u[m];
+        x !== v && m !== "value" && r(c, m, v, x, g, b);
+      }
+      "value" in d && r(c, "value", u.value, d.value, g);
+    }
+  }, Ft = (c, u, d, b, g, m, x, v, y) => {
+    const _ = u.el = c ? c.el : l(""), T = u.anchor = c ? c.anchor : l("");
+    let { patchFlag: S, dynamicChildren: A, slotScopeIds: O } = u;
+    O && (v = v ? v.concat(O) : O), c == null ? (n(_, d, b), n(T, d, b), $e(
+      // #10007
+      // such fragment like `<></>` will be compiled into
+      // a fragment which doesn't have a children.
+      // In this case fallback to an empty array
+      u.children || [],
+      d,
+      T,
+      g,
+      m,
+      x,
+      v,
+      y
+    )) : S > 0 && S & 64 && A && // #2715 the previous fragment could've been a BAILed one as a result
+    // of renderSlot() with no valid children
+    c.dynamicChildren && c.dynamicChildren.length === A.length ? (We(
+      c.dynamicChildren,
+      A,
+      d,
+      g,
+      m,
+      x,
+      v
+    ), // #2080 if the stable fragment has a key, it's a <template v-for> that may
+    //  get moved around. Make sure all root level vnodes inherit el.
+    // #2134 or if it's a component root, it may also get moved around
+    // as the component is being moved.
+    (u.key != null || g && u === g.subTree) && Li(
+      c,
+      u,
+      !0
+      /* shallow */
+    )) : V(
+      c,
+      u,
+      d,
+      T,
+      g,
+      m,
+      x,
+      v,
+      y
+    );
+  }, Nt = (c, u, d, b, g, m, x, v, y) => {
+    u.slotScopeIds = v, c == null ? u.shapeFlag & 512 ? g.ctx.activate(
+      u,
+      d,
+      b,
+      x,
+      y
+    ) : rs(
+      u,
+      d,
+      b,
+      g,
+      m,
+      x,
+      y
+    ) : tn(c, u, y);
+  }, rs = (c, u, d, b, g, m, x) => {
+    const v = c.component = qo(
+      c,
+      b,
+      g
+    );
+    if (zs(c) && (v.ctx.renderer = ct), Jo(v, !1, x), v.asyncDep) {
+      if (g && g.registerDep(
+        v,
+        te,
+        x,
+        m
+      ), !c.el) {
+        const y = v.subTree = Ke(De);
+        W(null, y, u, d), c.placeholder = y.el;
+      }
+    } else
+      te(
+        v,
+        c,
+        u,
+        d,
+        g,
+        m,
+        x
+      );
+  }, tn = (c, u, d) => {
+    const b = u.component = c.component;
+    if (So(c, u, d))
+      if (b.asyncDep && !b.asyncResolved) {
+        u.el = c.el, u.placeholder = c.placeholder, q(b, u, d);
+        return;
+      } else
+        b.next = u, b.update();
+    else
+      u.el = c.el, u.placeholder = c.placeholder, b.vnode = u;
+  }, te = (c, u, d, b, g, m, x) => {
+    const v = () => {
+      if (c.isMounted) {
+        let { next: S, bu: A, u: O, parent: M, vnode: $ } = c;
+        {
+          const be = $i(c);
+          if (be) {
+            S && (S.el = $.el, q(c, S, x)), be.asyncDep.then(() => {
+              const Re = () => {
+                c.job.flags & 8 || (g && g.pendingBranch ? ne(Re, g) : _());
+              };
+              Re.flags = 48, ne(Re, g);
+            });
+            return;
+          }
+        }
+        let L = S, z;
+        Ye(c, !1), S ? (S.el = $.el, q(c, S, x)) : S = $, A && ls(A), (z = S.props && S.props.onVnodeBeforeUpdate) && ve(z, M, S, $), Ye(c, !0);
+        const X = wn(c), ae = c.subTree;
+        c.subTree = X, R(
+          ae,
+          X,
+          // parent may have changed if it's in a teleport. a root that is a
+          // pending async component only has its placeholder comment
+          p(
+            ae.el || vt(ae)
+          ),
+          // anchor may have changed if it's in a fragment
+          Dt(ae),
+          c,
+          g,
+          m
+        ), S.el = X.el, L === null && wo(c, X.el), O && ne(O, g), (z = S.props && S.props.onVnodeUpdated) && ne(
+          () => ve(z, M, S, $),
+          g
+        );
+      } else {
+        let S;
+        const { el: A, props: O } = u, { bm: M, m: $, parent: L, root: z, type: X } = c, ae = bt(u);
+        Ye(c, !1), M && ls(M), !ae && (S = O && O.onVnodeBeforeMount) && ve(S, L, u), Ye(c, !0);
+        {
+          z.ce && z.ce._hasShadowRoot() && z.ce._injectChildStyle(
+            X,
+            c.parent ? c.parent.type : void 0
+          );
+          const be = c.subTree = wn(c);
+          R(
+            null,
+            be,
+            d,
+            b,
+            c,
+            g,
+            m
+          ), u.el = be.el;
+        }
+        if ($ && ne($, g), !ae && (S = O && O.onVnodeMounted)) {
+          const be = u;
+          ne(
+            () => ve(S, L, be),
+            g
+          );
+        }
+        (u.shapeFlag & 256 || L && bt(L.vnode) && L.vnode.shapeFlag & 256) && c.a && ne(c.a, g), c.isMounted = !0, u = d = b = null;
+      }
+    };
+    c.scope.on();
+    const y = c.effect = new Jn(v);
+    c.scope.off();
+    const _ = c.update = y.run.bind(y), T = c.job = y.runIfDirty.bind(y);
+    T.i = c, T.id = c.uid, y.scheduler = () => Js(T), Ye(c, !0), _();
+  }, q = (c, u, d) => {
+    u.component = c;
+    const b = c.vnode.props;
+    c.vnode = u, c.next = null, To(c, u.props, b, d), Po(c, u.children, d), Ee(), di(c), Oe();
+  }, V = (c, u, d, b, g, m, x, v, y = !1) => {
+    const _ = c && c.children, T = c ? c.shapeFlag : 0, S = u.children, { patchFlag: A, shapeFlag: O } = u;
+    if (A > 0) {
+      if (A & 128) {
+        jt(
+          _,
+          S,
+          d,
+          b,
+          g,
+          m,
+          x,
+          v,
+          y
+        );
+        return;
+      } else if (A & 256) {
+        qe(
+          _,
+          S,
+          d,
+          b,
+          g,
+          m,
+          x,
+          v,
+          y
+        );
+        return;
+      }
+    }
+    O & 8 ? (T & 16 && lt(_, g, m), S !== _ && a(d, S)) : T & 16 ? O & 16 ? jt(
+      _,
+      S,
+      d,
+      b,
+      g,
+      m,
+      x,
+      v,
+      y
+    ) : lt(_, g, m, !0) : (T & 8 && a(d, ""), O & 16 && $e(
+      S,
+      d,
+      b,
+      g,
+      m,
+      x,
+      v,
+      y
+    ));
+  }, qe = (c, u, d, b, g, m, x, v, y) => {
+    c = c || ke, u = u || ke;
+    const _ = c.length, T = u.length, S = Math.min(_, T);
+    let A;
+    for (A = 0; A < S; A++) {
+      const O = u[A] = y ? Fe(u[A]) : we(u[A]);
+      R(
+        c[A],
+        O,
+        d,
+        null,
+        g,
+        m,
+        x,
+        v,
+        y
+      );
+    }
+    _ > T ? lt(
+      c,
+      g,
+      m,
+      !0,
+      !1,
+      S
+    ) : $e(
+      u,
+      d,
+      b,
+      g,
+      m,
+      x,
+      v,
+      y,
+      S
+    );
+  }, jt = (c, u, d, b, g, m, x, v, y) => {
+    let _ = 0;
+    const T = u.length;
+    let S = c.length - 1, A = T - 1;
+    for (; _ <= S && _ <= A; ) {
+      const O = c[_], M = u[_] = y ? Fe(u[_]) : we(u[_]);
+      if (ut(O, M))
+        R(
+          O,
+          M,
+          d,
+          null,
+          g,
+          m,
+          x,
+          v,
+          y
+        );
+      else
+        break;
+      _++;
+    }
+    for (; _ <= S && _ <= A; ) {
+      const O = c[S], M = u[A] = y ? Fe(u[A]) : we(u[A]);
+      if (ut(O, M))
+        R(
+          O,
+          M,
+          d,
+          null,
+          g,
+          m,
+          x,
+          v,
+          y
+        );
+      else
+        break;
+      S--, A--;
+    }
+    if (_ > S) {
+      if (_ <= A) {
+        const O = A + 1, M = O < T ? u[O].el : b;
+        for (; _ <= A; )
+          R(
+            null,
+            u[_] = y ? Fe(u[_]) : we(u[_]),
+            d,
+            M,
+            g,
+            m,
+            x,
+            v,
+            y
+          ), _++;
+      }
+    } else if (_ > A)
+      for (; _ <= S; )
+        ue(c[_], g, m, !0), _++;
+    else {
+      const O = _, M = _, $ = /* @__PURE__ */ new Map();
+      for (_ = M; _ <= A; _++) {
+        const le = u[_] = y ? Fe(u[_]) : we(u[_]);
+        le.key != null && $.set(le.key, _);
+      }
+      let L, z = 0;
+      const X = A - M + 1;
+      let ae = !1, be = 0;
+      const Re = new Array(X);
+      for (_ = 0; _ < X; _++) Re[_] = 0;
+      for (_ = O; _ <= S; _++) {
+        const le = c[_];
+        if (z >= X) {
+          ue(le, g, m, !0);
+          continue;
+        }
+        let ye;
+        if (le.key != null)
+          ye = $.get(le.key);
+        else
+          for (L = M; L <= A; L++)
+            if (Re[L - M] === 0 && ut(le, u[L])) {
+              ye = L;
+              break;
+            }
+        ye === void 0 ? ue(le, g, m, !0) : (Re[ye - M] = _ + 1, ye >= be ? be = ye : ae = !0, R(
+          le,
+          u[ye],
+          d,
+          null,
+          g,
+          m,
+          x,
+          v,
+          y
+        ), z++);
+      }
+      const on = ae ? Fo(Re) : ke;
+      for (L = on.length - 1, _ = X - 1; _ >= 0; _--) {
+        const le = M + _, ye = u[le], ln = u[le + 1], cn = le + 1 < T ? (
+          // #13559, #14173 fallback to el placeholder for unresolved async component
+          ln.el || vt(ln)
+        ) : b;
+        Re[_] === 0 ? R(
+          null,
+          ye,
+          d,
+          cn,
+          g,
+          m,
+          x,
+          v,
+          y
+        ) : ae && (L < 0 || _ !== on[L] ? Ge(ye, d, cn, 2) : L--);
+      }
+    }
+  }, Ge = (c, u, d, b, g = null) => {
+    const { el: m, type: x, transition: v, children: y, shapeFlag: _ } = c;
+    if (_ & 6) {
+      Ge(c.component.subTree, u, d, b);
+      return;
+    }
+    if (_ & 128) {
+      c.suspense.move(u, d, b);
+      return;
+    }
+    if (_ & 64) {
+      x.move(c, u, d, ct);
+      return;
+    }
+    if (x === de) {
+      n(m, u, d);
+      for (let S = 0; S < y.length; S++)
+        Ge(y[S], u, d, b);
+      n(c.anchor, u, d);
+      return;
+    }
+    if (x === _s) {
+      H(c, u, d);
+      return;
+    }
+    if (b !== 2 && _ & 1 && v)
+      if (b === 0)
+        v.persisted && !m[ds] ? n(m, u, d) : (v.beforeEnter(m), n(m, u, d), ne(() => v.enter(m), g));
+      else {
+        const { leave: S, delayLeave: A, afterLeave: O } = v, M = () => {
+          c.ctx.isUnmounted ? i(m) : n(m, u, d);
+        }, $ = () => {
+          const L = m._isLeaving || !!m[ds];
+          m._isLeaving && m[ds](
+            !0
+            /* cancelled */
+          ), v.persisted && !L ? M() : S(m, () => {
+            M(), O && O();
+          });
+        };
+        A ? A(m, M, $) : $();
+      }
+    else
+      n(m, u, d);
+  }, ue = (c, u, d, b = !1, g = !1) => {
+    const {
+      type: m,
+      props: x,
+      ref: v,
+      children: y,
+      dynamicChildren: _,
+      shapeFlag: T,
+      patchFlag: S,
+      dirs: A,
+      cacheIndex: O,
+      memo: M
+    } = c;
+    if ((S === -2 || _ && _.hasOnce) && (g = !1), v != null && (Ee(), mt(v, null, d, c, !0), Oe()), O != null && (!c.ctx || c.ctx === u) && (u.renderCache[O] = void 0), T & 256 && u.ctx.deactivate(c))
+      return;
+    const $ = T & 1 && A, L = !bt(c);
+    let z;
+    if (L && (z = x && x.onVnodeBeforeUnmount) && ve(z, u, c), T & 6)
+      zi(c.component, d, b);
+    else {
+      if (T & 128) {
+        c.suspense.unmount(d, b);
+        return;
+      }
+      $ && Je(c, null, u, "beforeUnmount"), T & 64 ? c.type.remove(
+        c,
+        u,
+        d,
+        ct,
+        b
+      ) : _ && // #5154
+      // when v-once is used inside a block, setBlockTracking(-1) marks the
+      // parent block with hasOnce: true
+      // so that it doesn't take the fast path during unmount - otherwise
+      // components nested in v-once are never unmounted.
+      !_.hasOnce && // #1153: fast path should not be taken for non-stable (v-for) fragments
+      (m !== de || S > 0 && S & 64) ? lt(
+        _,
+        u,
+        d,
+        !1,
+        !0
+      ) : (m === de && S & 384 || !g && T & 16) && lt(y, u, d), b && sn(c);
+    }
+    const X = M != null && O == null;
+    (L && (z = x && x.onVnodeUnmounted) || $ || X) && ne(() => {
+      z && ve(z, u, c), $ && Je(c, null, u, "unmounted"), X && (c.el = null);
+    }, d);
+  }, sn = (c) => {
+    const { type: u, el: d, anchor: b, transition: g } = c, m = u === de;
+    if (m && !g) {
+      nn(d, b);
+      return;
+    }
+    if (u === _s) {
+      E(c), g && !g.persisted && g.afterLeave && g.afterLeave();
+      return;
+    }
+    const x = m ? Ts(c) : c, v = () => {
+      m ? p(d) && nn(d, b) : i(d), g && !g.persisted && g.afterLeave && g.afterLeave();
+    };
+    if (x && x.shapeFlag & 1 && g && !g.persisted) {
+      const { leave: y, delayLeave: _ } = g, T = x.el, S = () => y(T, v);
+      _ ? _(T, v, S) : S();
+    } else
+      v();
+  }, nn = (c, u) => {
+    let d;
+    for (; c !== u; )
+      d = w(c), i(c), c = d;
+    i(u);
+  }, zi = (c, u, d) => {
+    const { bum: b, scope: g, job: m, subTree: x, um: v, m: y, a: _ } = c;
+    An(y), An(_), b && ls(b), g.stop(), m ? (m.flags |= 8, ue(x, c, u, d)) : x && (x.transition = c.vnode.transition, ue(x, c, u, d)), v && ne(v, u);
+    const T = () => {
+      c.isUnmounted = !0;
+    };
+    T.flags = 16, ne(T, u);
+  }, lt = (c, u, d, b = !1, g = !1, m = 0) => {
+    for (let x = m; x < c.length; x++)
+      ue(c[x], u, d, b, g);
+  }, Dt = (c) => {
+    if (c.shapeFlag & 6)
+      return Dt(c.component.subTree);
+    if (c.shapeFlag & 128)
+      return c.suspense.next();
+    const u = w(c.anchor || c.el), d = u && u[Yr];
+    return d ? w(d) : u;
+  }, rn = (c, u, d) => {
+    const b = c && u._vnode ? void 0 : c && c.component ? c.component.uid : Wo();
+    Ur(() => {
+      c == null ? u._vnode && ue(u._vnode, null, null, !0) : R(
+        u._vnode || null,
+        c,
+        u,
+        null,
+        null,
+        null,
+        d
+      ), u._vnode = c;
+    }, b);
+  }, ct = {
+    p: R,
+    um: ue,
+    m: Ge,
+    r: sn,
+    mt: rs,
+    mc: $e,
+    pc: V,
+    pbc: We,
+    n: Dt,
+    o: e
+  };
+  return {
+    render: rn,
+    hydrate: void 0,
+    createApp: _o(rn)
+  };
+}
+function gs({ type: e, props: t }, s) {
+  return s === "svg" && e === "foreignObject" || s === "mathml" && e === "annotation-xml" && t && t.encoding && t.encoding.includes("html") ? void 0 : s;
+}
+function Ye({ effect: e, job: t }, s) {
+  s ? (e.flags |= 32, t.flags |= 4) : (e.flags &= -33, t.flags &= -5);
+}
+function Mo(e, t) {
+  return (!e || e && !e.pendingBranch) && t && !t.persisted;
+}
+function Li(e, t, s = !1) {
+  const n = e.children, i = t.children;
+  if (P(n) && P(i))
+    for (let r = 0; r < n.length; r++) {
+      const o = n[r];
+      let l = i[r];
+      l.shapeFlag & 1 && !l.dynamicChildren && ((l.patchFlag <= 0 || l.patchFlag === 32) && (l = i[r] = Fe(i[r]), l.el = o.el), !s && l.patchFlag !== -2 && Li(o, l)), l.type === is && (l.patchFlag === -1 && (l = i[r] = Fe(l)), l.el = o.el), l.type === De && !l.el && (l.el = o.el);
+    }
+}
+function Fo(e) {
+  const t = e.slice(), s = [0];
+  let n, i, r, o, l;
+  const f = e.length;
+  for (n = 0; n < f; n++) {
+    const h = e[n];
+    if (h !== 0) {
+      if (i = s[s.length - 1], e[i] < h) {
+        t[n] = i, s.push(n);
+        continue;
+      }
+      for (r = 0, o = s.length - 1; r < o; )
+        l = r + o >> 1, e[s[l]] < h ? r = l + 1 : o = l;
+      h < e[s[r]] && (r > 0 && (t[n] = s[r - 1]), s[r] = n);
+    }
+  }
+  for (r = s.length, o = s[r - 1]; r-- > 0; )
+    s[r] = o, o = t[o];
+  return s;
+}
+function $i(e) {
+  const t = e.subTree.component;
+  if (t)
+    return t.asyncDep && !t.asyncResolved ? t : $i(t);
+}
+function An(e) {
+  if (e)
+    for (let t = 0; t < e.length; t++)
+      e[t].flags |= 8;
+}
+function vt(e) {
+  if (e.placeholder)
+    return e.placeholder;
+  const t = e.component;
+  if (t)
+    return vt(t.subTree);
+  const s = e.suspense;
+  return s && s.activeBranch ? vt(s.activeBranch) : null;
+}
+const Vi = (e) => e.__isSuspense, No = /* @__PURE__ */ Symbol("_deferredEnter");
+function jo(e, t) {
+  t && t.pendingBranch ? P(e) ? t.effects.push(...e) : t.effects.push(e) : Vr(e);
+}
+const de = /* @__PURE__ */ Symbol.for("v-fgt"), is = /* @__PURE__ */ Symbol.for("v-txt"), De = /* @__PURE__ */ Symbol.for("v-cmt"), _s = /* @__PURE__ */ Symbol.for("v-stc"), et = [];
+let ce = null;
+function Do(e = !1) {
+  et.push(ce = e ? null : []);
+}
+function Ui() {
+  et.pop(), ce = et[et.length - 1] || null;
+}
+let At = 1;
+function En(e, t = !1) {
+  At += e, e < 0 && ce && t && (ce.hasOnce = !0);
+}
+function Ho(e) {
+  return e.dynamicChildren = At > 0 ? ce || ke : null, Ui(), At > 0 && ce && ce.push(e), e;
+}
+function Lo(e, t, s, n, i, r) {
+  return Ho(
+    xt(
+      e,
+      t,
+      s,
+      n,
+      i,
+      r,
+      !0
+    )
+  );
+}
+function Zs(e) {
+  return e ? e.__v_isVNode === !0 : !1;
+}
+function ut(e, t) {
+  return e.type === t.type && e.key === t.key;
+}
+const Ki = ({ key: e }) => e ?? null, Kt = ({
+  ref: e,
+  ref_key: t,
+  ref_for: s
+}) => (typeof e == "number" && (e = "" + e), e != null ? J(e) || /* @__PURE__ */ ee(e) || I(e) ? { i: Te, r: e, k: t, f: !!s } : e : null);
+function xt(e, t = null, s = null, n = 0, i = null, r = e === de ? 0 : 1, o = !1, l = !1) {
+  const f = {
+    __v_isVNode: !0,
+    __v_skip: !0,
+    type: e,
+    props: t,
+    key: t && Ki(t),
+    ref: t && Kt(t),
+    scopeId: _i,
+    slotScopeIds: null,
+    children: s,
+    component: null,
+    suspense: null,
+    ssContent: null,
+    ssFallback: null,
+    dirs: null,
+    transition: null,
+    el: null,
+    anchor: null,
+    target: null,
+    targetStart: null,
+    targetAnchor: null,
+    staticCount: 0,
+    shapeFlag: r,
+    patchFlag: n,
+    dynamicProps: i,
+    dynamicChildren: null,
+    appContext: null,
+    ctx: Te
+  };
+  return l ? (Yt(f, s), r & 128 && e.normalize(f)) : s && (f.shapeFlag |= J(s) ? 8 : 16), At > 0 && // avoid a block node from tracking itself
+  !o && // has current parent block
+  ce && // presence of a patch flag indicates this node needs patching on updates.
+  // component nodes also should always be patched, because even if the
+  // component doesn't need to update, it needs to persist the instance on to
+  // the next vnode so that it can be properly unmounted later.
+  (f.patchFlag > 0 || r & 6) && // the EVENTS flag is only for hydration and if it is the only flag, the
+  // vnode should not be considered dynamic due to handler caching.
+  f.patchFlag !== 32 && ce.push(f), f;
+}
+const Ke = $o;
+function $o(e, t = null, s = null, n = 0, i = null, r = !1) {
+  if ((!e || e === lo) && (e = De), Zs(e)) {
+    const l = rt(
+      e,
+      t,
+      !0
+      /* mergeRef: true */
+    );
+    return s && Yt(l, s), At > 0 && !r && ce && (l.shapeFlag & 6 ? ce[ce.indexOf(e)] = l : ce.push(l)), l.patchFlag = -2, l;
+  }
+  if (Xo(e) && (e = e.__vccOpts), t) {
+    t = Vo(t);
+    let { class: l, style: f } = t;
+    l && !J(l) && (t.class = Hs(l)), B(f) && (/* @__PURE__ */ Gs(f) && !P(f) && (f = G({}, f)), t.style = Ds(f));
+  }
+  const o = J(e) ? 1 : Vi(e) ? 128 : ss(e) ? 64 : B(e) ? 4 : I(e) ? 2 : 0;
+  return xt(
+    e,
+    t,
+    s,
+    n,
+    i,
+    o,
+    r,
+    !0
+  );
+}
+function Vo(e) {
+  return e ? /* @__PURE__ */ Gs(e) ? G({}, e) : Mi(e) ? G({}, e[Gi] || e) : e : null;
+}
+function rt(e, t, s = !1, n = !1) {
+  const { props: i, ref: r, patchFlag: o, children: l, transition: f } = e, h = t ? Ko(i || {}, t) : i, a = {
+    __v_isVNode: !0,
+    __v_skip: !0,
+    type: e.type,
+    props: h,
+    key: h && Ki(h),
+    ref: t && t.ref ? (
+      // #2078 in the case of <component :is="vnode" ref="extra"/>
+      // if the vnode itself already has a ref, cloneVNode will need to merge
+      // the refs so the single vnode can be set on multiple refs
+      s && r ? P(r) ? r.concat(Kt(t)) : [r, Kt(t)] : Kt(t)
+    ) : r,
+    scopeId: e.scopeId,
+    slotScopeIds: e.slotScopeIds,
+    children: l,
+    target: e.target,
+    targetStart: e.targetStart,
+    targetAnchor: e.targetAnchor,
+    staticCount: e.staticCount,
+    shapeFlag: e.shapeFlag,
+    // if the vnode is cloned with extra props, we can no longer assume its
+    // existing patch flag to be reliable and need to add the FULL_PROPS flag.
+    // note: preserve flag for fragments since they use the flag for children
+    // fast paths only.
+    patchFlag: t && e.type !== de ? o === -1 ? 16 : o | 16 : o,
+    dynamicProps: e.dynamicProps,
+    dynamicChildren: e.dynamicChildren,
+    appContext: e.appContext,
+    dirs: e.dirs,
+    transition: f,
+    // These should technically only be non-null on mounted VNodes. However,
+    // they *should* be copied for kept-alive vnodes. So we just always copy
+    // them since them being non-null during a mount doesn't affect the logic as
+    // they will simply be overwritten.
+    component: e.component,
+    suspense: e.suspense,
+    ssContent: e.ssContent && rt(e.ssContent),
+    ssFallback: e.ssFallback && rt(e.ssFallback),
+    placeholder: e.placeholder,
+    el: e.el,
+    anchor: e.anchor,
+    ctx: e.ctx,
+    ce: e.ce,
+    cacheIndex: e.cacheIndex
+  };
+  return f && n && _t(
+    a,
+    f.clone(a)
+  ), a;
+}
+function Uo(e = " ", t = 0) {
+  return Ke(is, null, e, t);
+}
+function we(e) {
+  return e == null || typeof e == "boolean" ? Ke(De) : P(e) ? Ke(
+    de,
+    null,
+    // #3666, avoid reference pollution when reusing vnode
+    e.slice()
+  ) : Zs(e) ? Fe(e) : Ke(is, null, String(e));
+}
+function Fe(e) {
+  return e.el === null && e.patchFlag !== -1 || e.memo ? e : rt(e);
+}
+function Yt(e, t) {
+  let s = 0;
+  const { shapeFlag: n } = e;
+  if (t == null)
+    t = null;
+  else if (P(t))
+    s = 16;
+  else if (typeof t == "object")
+    if (n & 65) {
+      const i = t.default;
+      i && (i._c && (i._d = !1), Yt(e, i()), i._c && (i._d = !0));
+      return;
+    } else {
+      s = 32;
+      const i = t._;
+      !i && !Mi(t) ? t._ctx = Te : i === 3 && Te && (Te.slots._ === 1 ? t._ = 1 : (t._ = 2, e.patchFlag |= 1024));
+    }
+  else if (I(t)) {
+    if (n & 65) {
+      Yt(e, { default: t });
+      return;
+    }
+    t = { default: t, _ctx: Te }, s = 32;
+  } else
+    t = String(t), n & 64 ? (s = 16, t = [Uo(t)]) : s = 8;
+  e.children = t, e.shapeFlag |= s;
+}
+function Ko(...e) {
+  const t = {};
+  for (let s = 0; s < e.length; s++) {
+    const n = e[s];
+    for (const i in n)
+      if (i === "class")
+        t.class !== n.class && (t.class = Hs([t.class, n.class]));
+      else if (i === "style")
+        t.style = Ds([t.style, n.style]);
+      else if (kt(i)) {
+        const r = t[i], o = n[i];
+        o && r !== o && !(P(r) && r.includes(o)) ? t[i] = r ? [].concat(r, o) : o : o == null && r == null && // mergeProps({ 'onUpdate:modelValue': undefined }) should not retain
+        // the model listener.
+        !Xt(i) && (t[i] = o);
+      } else i !== "" && (t[i] = n[i]);
+  }
+  return t;
+}
+function ve(e, t, s, n = null) {
+  _e(e, t, 7, [
+    s,
+    n
+  ]);
+}
+const Bo = /* @__PURE__ */ Ai();
+let Bi = 0;
+function Wo() {
+  return Bi;
+}
+function qo(e, t, s) {
+  const n = e.type, i = (t ? t.appContext : e.appContext) || Bo, r = {
+    uid: Bi++,
+    vnode: e,
+    type: n,
+    parent: t,
+    appContext: i,
+    root: null,
+    // to be immediately set
+    next: null,
+    subTree: null,
+    // will be set synchronously right after creation
+    effect: null,
+    update: null,
+    // will be set synchronously right after creation
+    job: null,
+    scope: new ur(
+      !0
+      /* detached */
+    ),
+    render: null,
+    proxy: null,
+    exposed: null,
+    exposeProxy: null,
+    withProxy: null,
+    provides: t ? t.provides : Object.create(i.provides),
+    ids: t ? t.ids : ["", 0, 0],
+    accessCache: null,
+    renderCache: [],
+    // local resolved assets
+    components: null,
+    directives: null,
+    // resolved props and emits options
+    propsOptions: Ni(n, i),
+    emitsOptions: Ei(n, i),
+    // emit
+    emit: null,
+    // to be set immediately
+    emitted: null,
+    // props default value
+    propsDefaults: K,
+    // inheritAttrs
+    inheritAttrs: n.inheritAttrs,
+    // state
+    ctx: K,
+    data: K,
+    props: K,
+    attrs: K,
+    slots: K,
+    refs: K,
+    setupState: K,
+    setupContext: null,
+    // suspense related
+    suspense: s,
+    suspenseId: s ? s.pendingId : 0,
+    asyncDep: null,
+    asyncResolved: !1,
+    // lifecycle hooks
+    // not using enums here because it results in computed properties
+    isMounted: !1,
+    isUnmounted: !1,
+    isDeactivated: !1,
+    bc: null,
+    c: null,
+    bm: null,
+    m: null,
+    bu: null,
+    u: null,
+    um: null,
+    bum: null,
+    da: null,
+    a: null,
+    rtg: null,
+    rtc: null,
+    ec: null,
+    sp: null
+  };
+  return r.ctx = { _: r }, r.root = t ? t.root : r, r.emit = bo.bind(null, r), e.ce && e.ce(r), r;
+}
+let re = null;
+const Go = () => re || Te;
+let zt, Et;
+{
+  const e = Qt(), t = (s, n) => {
+    let i;
+    return (i = e[s]) || (i = e[s] = []), i.push(n), (r) => {
+      i.length > 1 ? i.forEach((o) => o(r)) : i[0](r);
+    };
+  };
+  zt = t(
+    "__VUE_INSTANCE_SETTERS__",
+    (s) => re = s
+  ), Et = t(
+    "__VUE_SSR_SETTERS__",
+    (s) => Ot = s
+  );
+}
+const It = (e) => {
+  const t = re;
+  return zt(e), e.scope.on(), () => {
+    e.scope.off(), zt(t);
+  };
+}, On = () => {
+  re && re.scope.off(), zt(null);
+};
+function Wi(e) {
+  return e.vnode.shapeFlag & 4;
+}
+let Ot = !1;
+function Jo(e, t = !1, s = !1) {
+  t && Et(t);
+  const { props: n, children: i } = e.vnode, r = Wi(e);
+  Co(e, n, r, t), Oo(e, i, s || t);
+  const o = r ? Yo(e, t) : void 0;
+  return t && Et(!1), o;
+}
+function Yo(e, t) {
+  const s = e.type;
+  e.accessCache = /* @__PURE__ */ Object.create(null), e.proxy = new Proxy(e.ctx, co);
+  const { setup: n } = s;
+  if (n) {
+    Ee();
+    const i = e.setupContext = n.length > 1 ? ko(e) : null, r = It(e), o = Rt(
+      n,
+      e,
+      0,
+      [
+        e.props,
+        i
+      ]
+    ), l = Bn(o);
+    if (Oe(), r(), (l || e.sp) && !bt(e) && vi(e), l) {
+      if (o.then(On, On), t)
+        return o.then((f) => {
+          Et(!0);
+          try {
+            Pn(e, f, t);
+          } finally {
+            Et(!1);
+          }
+        }).catch((f) => {
+          ts(f, e, 0, void 0, !0), e.ssrRender = (h, a) => a("<!---->");
+        });
+      e.asyncDep = o;
+    } else
+      Pn(e, o);
+  } else
+    qi(e);
+}
+function Pn(e, t, s) {
+  I(t) ? e.type.__ssrInlineRender ? e.ssrRender = t : e.render = t : B(t) && (e.setupState = fi(t)), qi(e);
+}
+function qi(e, t, s) {
+  const n = e.type;
+  e.render || (e.render = n.render || Ae);
+  {
+    const i = It(e);
+    Ee();
+    try {
+      fo(e);
+    } finally {
+      Oe(), i();
+    }
+  }
+}
+const Gi = /* @__PURE__ */ Symbol(), zo = {
+  get(e, t) {
+    return Q(e, "get", ""), t === Gi ? e : e[t];
+  }
+};
+function ko(e) {
+  const t = (s) => {
+    e.exposed = s || {};
+  };
+  return {
+    attrs: new Proxy(e.attrs, zo),
+    slots: e.slots,
+    emit: e.emit,
+    expose: t
+  };
+}
+function Qs(e) {
+  return e.exposed ? e.exposeProxy || (e.exposeProxy = new Proxy(fi(Pr(e.exposed)), {
+    get(t, s) {
+      if (s in t)
+        return t[s];
+      if (s in yt)
+        return yt[s](e);
+    },
+    has(t, s) {
+      return s in t || s in yt;
+    }
+  })) : e.proxy;
+}
+function Xo(e) {
+  return I(e) && "__vccOpts" in e;
+}
+const Rs = (e, t) => /* @__PURE__ */ jr(e, t, Ot), Zo = "3.5.45";
+let Is;
+const Rn = typeof window < "u" && window.trustedTypes;
+if (Rn)
+  try {
+    Is = /* @__PURE__ */ Rn.createPolicy("vue", {
+      createHTML: (e) => e
+    });
+  } catch {
+  }
+const Ji = Is ? (e) => Is.createHTML(e) : (e) => e, Qo = "http://www.w3.org/2000/svg", el = "http://www.w3.org/1998/Math/MathML", Me = typeof document < "u" ? document : null, In = Me && /* @__PURE__ */ Me.createElement("template"), tl = {
+  insert: (e, t, s) => {
+    t.insertBefore(e, s || null);
+  },
+  remove: (e) => {
+    const t = e.parentNode;
+    t && t.removeChild(e);
+  },
+  createElement: (e, t, s, n) => {
+    const i = t === "svg" ? Me.createElementNS(Qo, e) : t === "mathml" ? Me.createElementNS(el, e) : s ? Me.createElement(e, { is: s }) : Me.createElement(e);
+    return e === "select" && n && n.multiple != null && i.setAttribute("multiple", n.multiple), i;
+  },
+  createText: (e) => Me.createTextNode(e),
+  createComment: (e) => Me.createComment(e),
+  setText: (e, t) => {
+    e.nodeValue = t;
+  },
+  setElementText: (e, t) => {
+    e.textContent = t;
+  },
+  parentNode: (e) => e.parentNode,
+  nextSibling: (e) => e.nextSibling,
+  querySelector: (e) => Me.querySelector(e),
+  setScopeId(e, t) {
+    e.setAttribute(t, "");
+  },
+  // __UNSAFE__
+  // Reason: innerHTML.
+  // Static content here can only come from compiled templates.
+  // As long as the user only uses trusted templates, this is safe.
+  insertStaticContent(e, t, s, n, i, r) {
+    const o = s ? s.previousSibling : t.lastChild;
+    if (i && (i === r || i.nextSibling))
+      for (; t.insertBefore(i.cloneNode(!0), s), !(i === r || !(i = i.nextSibling)); )
+        ;
+    else {
+      In.innerHTML = Ji(
+        n === "svg" ? `<svg>${e}</svg>` : n === "mathml" ? `<math>${e}</math>` : e
+      );
+      const l = In.content;
+      if (n === "svg" || n === "mathml") {
+        const f = l.firstChild;
+        for (; f.firstChild; )
+          l.appendChild(f.firstChild);
+        l.removeChild(f);
+      }
+      t.insertBefore(l, s);
+    }
+    return [
+      // first
+      o ? o.nextSibling : t.firstChild,
+      // last
+      s ? s.previousSibling : t.lastChild
+    ];
+  }
+}, sl = /* @__PURE__ */ Symbol("_vtc");
+function nl(e, t, s) {
+  const n = e[sl];
+  n && (t = (t ? [t, ...n] : [...n]).join(" ")), t == null ? e.removeAttribute("class") : s ? e.setAttribute("class", t) : e.className = t;
+}
+const Mn = /* @__PURE__ */ Symbol("_vod"), il = /* @__PURE__ */ Symbol("_vsh"), rl = /* @__PURE__ */ Symbol(""), ol = /(?:^|;)\s*display\s*:/;
+function ll(e, t, s) {
+  const n = e.style, i = J(s);
+  let r = !1;
+  if (s && !i) {
+    if (t)
+      if (J(t))
+        for (const o of t.split(";")) {
+          const l = o.slice(0, o.indexOf(":")).trim();
+          s[l] == null && ht(n, l, "");
+        }
+      else
+        for (const o in t)
+          s[o] == null && ht(n, o, "");
+    for (const o in s) {
+      o === "display" && (r = !0);
+      const l = s[o];
+      l != null ? fl(
+        e,
+        o,
+        !J(t) && t ? t[o] : void 0,
+        l
+      ) || ht(n, o, l) : ht(n, o, "");
+    }
+  } else if (i) {
+    if (t !== s) {
+      const o = n[rl];
+      o && (s += ";" + o), n.cssText = s, r = ol.test(s);
+    }
+  } else t && e.removeAttribute("style");
+  Mn in e && ((!i || t !== s) && (e[Mn] = r ? n.display : ""), e[il] && (n.display = "none"));
+}
+const Vt = /\s*!important$/;
+function ht(e, t, s) {
+  if (P(s))
+    s.forEach((n) => ht(e, t, n));
+  else if (s == null && (s = ""), t.startsWith("--"))
+    Vt.test(s) ? e.setProperty(t, s.replace(Vt, ""), "important") : e.setProperty(t, s);
+  else {
+    const n = cl(e, t);
+    Vt.test(s) ? e.setProperty(
+      fe(n),
+      s.replace(Vt, ""),
+      "important"
+    ) : e[n] = s;
+  }
+}
+const Fn = ["Webkit", "Moz", "ms"], ms = {};
+function cl(e, t) {
+  const s = ms[t];
+  if (s)
+    return s;
+  let n = oe(t);
+  if (n !== "filter" && n in e)
+    return ms[t] = n;
+  n = Wn(n);
+  for (let i = 0; i < Fn.length; i++) {
+    const r = Fn[i] + n;
+    if (r in e)
+      return ms[t] = r;
+  }
+  return t;
+}
+function fl(e, t, s, n) {
+  return e.tagName === "TEXTAREA" && (t === "width" || t === "height") && J(n) && s === n;
+}
+const Nn = "http://www.w3.org/1999/xlink";
+function jn(e, t, s, n, i, r = lr(t)) {
+  n && t.startsWith("xlink:") ? s == null ? e.removeAttributeNS(Nn, t.slice(6, t.length)) : e.setAttributeNS(Nn, t, s) : s == null || r && !Gn(s) ? e.removeAttribute(t) : e.setAttribute(
+    t,
+    r ? "" : Be(s) ? String(s) : s
+  );
+}
+function Dn(e, t, s, n, i) {
+  if (t === "innerHTML" || t === "textContent") {
+    s != null && (e[t] = t === "innerHTML" ? Ji(s) : s);
+    return;
+  }
+  const r = e.tagName;
+  if (t === "value" && r !== "PROGRESS" && // custom elements may use _value internally
+  !r.includes("-")) {
+    const l = r === "OPTION" ? e.getAttribute("value") || "" : e.value, f = s == null ? (
+      // #11647: value should be set as empty string for null and undefined,
+      // but <input type="checkbox"> should be set as 'on'.
+      e.type === "checkbox" ? "on" : ""
+    ) : String(s);
+    (l !== f || !("_value" in e)) && (e.value = f), s == null && e.removeAttribute(t), e._value = s;
+    return;
+  }
+  let o = !1;
+  if (s === "" || s == null) {
+    const l = typeof e[t];
+    l === "boolean" ? s = Gn(s) : s == null && l === "string" ? (s = "", o = !0) : l === "number" && (s = 0, o = !0);
+  }
+  try {
+    e[t] = s;
+  } catch {
+  }
+  o && e.removeAttribute(i || t);
+}
+function ul(e, t, s, n) {
+  e.addEventListener(t, s, n);
+}
+function al(e, t, s, n) {
+  e.removeEventListener(t, s, n);
+}
+const Hn = /* @__PURE__ */ Symbol("_vei");
+function hl(e, t, s, n, i = null) {
+  const r = e[Hn] || (e[Hn] = {}), o = r[t];
+  if (n && o)
+    o.value = n;
+  else {
+    const [l, f] = gl(t);
+    if (n) {
+      const h = r[t] = bl(
+        n,
+        i
+      );
+      ul(e, l, h, f);
+    } else o && (al(e, l, o, f), r[t] = void 0);
+  }
+}
+const dl = /(Once|Passive|Capture)$/, pl = /^on:?(?:Once|Passive|Capture)$/;
+function gl(e) {
+  let t, s;
+  for (; (s = e.match(dl)) && !pl.test(e); )
+    t || (t = {}), e = e.slice(0, e.length - s[1].length), t[s[1].toLowerCase()] = !0;
+  return [e[2] === ":" ? e.slice(3) : fe(e.slice(2)), t];
+}
+let bs = 0;
+const _l = /* @__PURE__ */ Promise.resolve(), ml = () => bs || (_l.then(() => bs = 0), bs = Date.now());
+function bl(e, t) {
+  const s = (n) => {
+    if (!n._vts)
+      n._vts = Date.now();
+    else if (n._vts <= s.attached)
+      return;
+    const i = s.value;
+    if (P(i)) {
+      const r = n.stopImmediatePropagation;
+      n.stopImmediatePropagation = () => {
+        r.call(n), n._stopped = !0;
+      };
+      const o = i.slice(), l = [n];
+      for (let f = 0; f < o.length && !n._stopped; f++) {
+        const h = o[f];
+        h && _e(
+          h,
+          t,
+          5,
+          l
+        );
+      }
+    } else
+      _e(
+        i,
+        t,
+        5,
+        [n]
+      );
+  };
+  return s.value = e, s.attached = ml(), s;
+}
+const Ln = (e) => e.charCodeAt(0) === 111 && e.charCodeAt(1) === 110 && // lowercase letter
+e.charCodeAt(2) > 96 && e.charCodeAt(2) < 123, yl = (e, t, s, n, i, r) => {
+  const o = i === "svg";
+  t === "class" ? nl(e, n, o) : t === "style" ? ll(e, s, n) : kt(t) ? Xt(t) || hl(e, t, s, n, r) : (t[0] === "." ? (t = t.slice(1), !0) : t[0] === "^" ? (t = t.slice(1), !1) : vl(e, t, n, o)) ? (Dn(e, t, n), !e.tagName.includes("-") && (t === "value" || t === "checked" || t === "selected") && jn(e, t, n, o, r, t !== "value")) : /* #11081 force set props for possible async custom element */ e._isVueCE && // #12408 check if it's declared prop or it's async custom element
+  (xl(e, t) || // @ts-expect-error _def is private
+  e._def.__asyncLoader && (/[A-Z]/.test(t) || !J(n))) ? Dn(e, oe(t), n, r, t) : (t === "true-value" ? e._trueValue = n : t === "false-value" && (e._falseValue = n), jn(e, t, n, o));
+};
+function vl(e, t, s, n) {
+  if (n)
+    return !!(t === "innerHTML" || t === "textContent" || t in e && Ln(t) && I(s));
+  if (t === "spellcheck" || t === "draggable" || t === "translate" || t === "autocorrect" || t === "sandbox" && e.tagName === "IFRAME" || t === "form" || t === "list" && e.tagName === "INPUT" || t === "type" && e.tagName === "TEXTAREA")
+    return !1;
+  if (t === "width" || t === "height") {
+    const i = e.tagName;
+    if (i === "IMG" || i === "VIDEO" || i === "CANVAS" || i === "SOURCE")
+      return !1;
+  }
+  return Ln(t) && J(s) ? !1 : t in e;
+}
+function xl(e, t) {
+  const s = (
+    // @ts-expect-error _def is private
+    e._def.props
+  );
+  if (!s)
+    return !1;
+  const n = oe(t);
+  return Array.isArray(s) ? s.some((i) => oe(i) === n) : Object.keys(s).some((i) => oe(i) === n);
+}
+const $n = {};
+// @__NO_SIDE_EFFECTS__
+function Sl(e, t, s) {
+  let n = /* @__PURE__ */ yi(e, t);
+  Ns(n) && (n = G({}, n, t));
+  class i extends en {
+    constructor(o) {
+      super(n, o, s);
+    }
+  }
+  return i.def = n, i;
+}
+const wl = typeof HTMLElement < "u" ? HTMLElement : class {
+};
+class en extends wl {
+  constructor(t, s = {}, n = Un) {
+    super(), this._def = t, this._props = s, this._createApp = n, this._isVueCE = !0, this._instance = null, this._app = null, this._nonce = this._def.nonce, this._connected = !1, this._resolved = !1, this._patching = !1, this._dirty = !1, this._numberProps = null, this._styleChildren = /* @__PURE__ */ new WeakSet(), this._styleAnchors = /* @__PURE__ */ new WeakMap(), this._ob = null, this.shadowRoot && n !== Un ? this._root = this.shadowRoot : t.shadowRoot !== !1 ? (this.attachShadow(
+      G({}, t.shadowRootOptions, {
+        mode: "open"
+      })
+    ), this._root = this.shadowRoot) : this._root = this;
+  }
+  connectedCallback() {
+    if (!this.isConnected) return;
+    !this.shadowRoot && !this._resolved && this._parseSlots(), this._connected = !0;
+    let t = this;
+    for (; t = t && // #12479 should check assignedSlot first to get correct parent
+    (t.assignedSlot || t.parentNode || t.host); )
+      if (t instanceof en) {
+        this._parent = t;
+        break;
+      }
+    this._instance || (this._resolved ? this._mount(this._def) : t && t._pendingResolve ? this._pendingResolve = t._pendingResolve.then(() => {
+      if (this._pendingResolve = void 0, this.isConnected)
+        return this._resolveDef();
+    }) : this._resolveDef());
+  }
+  _setParent(t = this._parent) {
+    t && (this._instance.parent = t._instance, this._inheritParentContext(t));
+  }
+  _inheritParentContext(t = this._parent) {
+    t && this._app && Object.setPrototypeOf(
+      this._app._context.provides,
+      t._instance.provides
+    );
+  }
+  disconnectedCallback() {
+    this._connected = !1, ai(() => {
+      this._connected || (this._ob && (this._ob.disconnect(), this._ob = null), this._app && this._app.unmount(), this._instance && (this._instance.ce = void 0), this._app = this._instance = null, this._teleportTargets && (this._teleportTargets.clear(), this._teleportTargets = void 0));
+    });
+  }
+  _processMutations(t) {
+    for (const s of t)
+      this._setAttr(s.attributeName);
+  }
+  /**
+   * resolve inner component definition (handle possible async component)
+   */
+  _resolveDef() {
+    if (this._pendingResolve)
+      return this._pendingResolve;
+    for (let n = 0; n < this.attributes.length; n++)
+      this._setAttr(this.attributes[n].name);
+    this._ob = new MutationObserver(this._processMutations.bind(this)), this._ob.observe(this, { attributes: !0 });
+    const t = (n, i = !1) => {
+      this._resolved = !0, this._pendingResolve = void 0;
+      const { props: r, styles: o } = n;
+      let l;
+      if (r && !P(r))
+        for (const f in r) {
+          const h = r[f];
+          (h === Number || h && h.type === Number) && (f in this._props && (this._props[f] = un(this._props[f])), (l || (l = /* @__PURE__ */ Object.create(null)))[oe(f)] = !0);
+        }
+      this._numberProps = l, this._resolveProps(n), this.shadowRoot && this._applyStyles(o), this._connected && this._mount(n);
+    }, s = this._def.__asyncLoader;
+    if (s)
+      return this._pendingResolve = s().then((n) => {
+        n.configureApp = this._def.configureApp, t(this._def = n, !0);
+      }), this._pendingResolve;
+    t(this._def);
+  }
+  _mount(t) {
+    this._app = this._createApp(t), this._inheritParentContext(), t.configureApp && t.configureApp(this._app), this._app._ceVNode = this._createVNode(), this._app.mount(this._root);
+    const s = this._instance && this._instance.exposed;
+    if (s)
+      for (const n in s)
+        N(this, n) || Object.defineProperty(this, n, {
+          // unwrap ref to be consistent with public instance behavior
+          get: () => ci(s[n])
+        });
+  }
+  _resolveProps(t) {
+    const { props: s } = t, n = P(s) ? s : Object.keys(s || {});
+    for (const i of Object.keys(this))
+      i[0] !== "_" && n.includes(i) && this._setProp(i, this[i]);
+    for (const i of n.map(oe))
+      Object.defineProperty(this, i, {
+        get() {
+          return this._getProp(i);
+        },
+        set(r) {
+          this._setProp(i, r, !0, !this._patching);
+        }
+      });
+  }
+  _setAttr(t) {
+    if (t.startsWith("data-v-")) return;
+    const s = this.hasAttribute(t);
+    let n = s ? this.getAttribute(t) : $n;
+    const i = oe(t);
+    s && this._numberProps && this._numberProps[i] && (n = un(n)), this._setProp(i, n, !1, !0);
+  }
+  /**
+   * @internal
+   */
+  _getProp(t) {
+    return this._props[t];
+  }
+  /**
+   * @internal
+   */
+  _setProp(t, s, n = !0, i = !1) {
+    if (s !== this._props[t] && (this._dirty = !0, s === $n ? delete this._props[t] : (this._props[t] = s, t === "key" && this._app && (this._app._ceVNode.key = s)), i && this._instance && this._update(), n)) {
+      const r = this._ob;
+      r && (this._processMutations(r.takeRecords()), r.disconnect()), s === !0 ? this.setAttribute(fe(t), "") : typeof s == "string" || typeof s == "number" ? this.setAttribute(fe(t), s + "") : s || this.removeAttribute(fe(t)), r && r.observe(this, { attributes: !0 });
+    }
+  }
+  _update() {
+    const t = this._createVNode();
+    this._app && (t.appContext = this._app._context), Tl(t, this._root);
+  }
+  _createVNode() {
+    const t = {};
+    this.shadowRoot || (t.onVnodeMounted = t.onVnodeUpdated = this._renderSlots.bind(this));
+    const s = Ke(this._def, G(t, this._props));
+    return this._instance || (s.ce = (n) => {
+      this._instance = n, n.ce = this, n.isCE = !0;
+      const i = (r, o) => {
+        this.dispatchEvent(
+          new CustomEvent(
+            r,
+            Ns(o[0]) ? G({ detail: o }, o[0]) : { detail: o }
+          )
+        );
+      };
+      n.emit = (r, ...o) => {
+        i(r, o), fe(r) !== r && i(fe(r), o);
+      }, this._setParent();
+    }), s;
+  }
+  _applyStyles(t, s, n) {
+    if (!t) return;
+    if (s) {
+      if (s === this._def || this._styleChildren.has(s))
+        return;
+      this._styleChildren.add(s);
+    }
+    const i = this._nonce, r = this.shadowRoot, o = n ? this._getStyleAnchor(n) || this._getStyleAnchor(this._def) : this._getRootStyleInsertionAnchor(r);
+    let l = null;
+    for (let f = t.length - 1; f >= 0; f--) {
+      const h = document.createElement("style");
+      i && h.setAttribute("nonce", i), h.textContent = t[f], r.insertBefore(h, l || o), l = h, f === 0 && (n || this._styleAnchors.set(this._def, h), s && this._styleAnchors.set(s, h));
+    }
+  }
+  _getStyleAnchor(t) {
+    if (!t)
+      return null;
+    const s = this._styleAnchors.get(t);
+    return s && s.parentNode === this.shadowRoot ? s : (s && this._styleAnchors.delete(t), null);
+  }
+  _getRootStyleInsertionAnchor(t) {
+    for (let s = 0; s < t.childNodes.length; s++) {
+      const n = t.childNodes[s];
+      if (!(n instanceof HTMLStyleElement))
+        return n;
+    }
+    return null;
+  }
+  /**
+   * Only called when shadowRoot is false
+   */
+  _parseSlots() {
+    const t = this._slots = {};
+    let s;
+    for (; s = this.firstChild; ) {
+      const n = s.nodeType === 1 && s.getAttribute("slot") || "default";
+      (t[n] || (t[n] = [])).push(s), this.removeChild(s);
+    }
+  }
+  /**
+   * Only called when shadowRoot is false
+   */
+  _renderSlots() {
+    const t = this._getSlots(), s = this._instance.type.__scopeId;
+    for (let n = 0; n < t.length; n++) {
+      const i = t[n], r = i.getAttribute("name") || "default", o = this._slots[r], l = i.parentNode;
+      if (o)
+        for (const f of o) {
+          if (s && f.nodeType === 1) {
+            const h = s + "-s", a = document.createTreeWalker(f, 1);
+            f.setAttribute(h, "");
+            let p;
+            for (; p = a.nextNode(); )
+              p.setAttribute(h, "");
+          }
+          l.insertBefore(f, i);
+        }
+      else
+        for (; i.firstChild; ) l.insertBefore(i.firstChild, i);
+      l.removeChild(i);
+    }
+  }
+  /**
+   * @internal
+   */
+  _getSlots() {
+    const t = [this];
+    this._teleportTargets && t.push(...this._teleportTargets);
+    const s = /* @__PURE__ */ new Set();
+    for (const n of t) {
+      const i = n.querySelectorAll("slot");
+      for (let r = 0; r < i.length; r++)
+        s.add(i[r]);
+    }
+    return Array.from(s);
+  }
+  /**
+   * @internal
+   */
+  _injectChildStyle(t, s) {
+    this._applyStyles(t.styles, t, s);
+  }
+  /**
+   * @internal
+   */
+  _beginPatch() {
+    this._patching = !0, this._dirty = !1;
+  }
+  /**
+   * @internal
+   */
+  _endPatch() {
+    this._patching = !1, this._dirty && this._instance && this._update();
+  }
+  /**
+   * @internal
+   */
+  _hasShadowRoot() {
+    return this._def.shadowRoot !== !1;
+  }
+  /**
+   * @internal
+   */
+  _removeChildStyle(t) {
+  }
+}
+const Cl = /* @__PURE__ */ G({ patchProp: yl }, tl);
+let Vn;
+function Yi() {
+  return Vn || (Vn = Ro(Cl));
+}
+const Tl = ((...e) => {
+  Yi().render(...e);
+}), Un = ((...e) => {
+  const t = Yi().createApp(...e), { mount: s } = t;
+  return t.mount = (n) => {
+    const i = El(n);
+    if (!i) return;
+    const r = t._component;
+    !I(r) && !r.render && !r.template && (r.template = i.innerHTML), i.nodeType === 1 && (i.textContent = "");
+    const o = s(i, !1, Al(i));
+    return i instanceof Element && (i.removeAttribute("v-cloak"), i.setAttribute("data-v-app", "")), o;
+  }, t;
+});
+function Al(e) {
+  if (e instanceof SVGElement)
+    return "svg";
+  if (typeof MathMLElement == "function" && e instanceof MathMLElement)
+    return "mathml";
+}
+function El(e) {
+  return J(e) ? document.querySelector(e) : e;
+}
+const Ol = { class: "card" }, Pl = ["disabled"], Rl = /* @__PURE__ */ yi({
+  __name: "VisionAssessment.ce",
+  props: {
+    env: { type: String },
+    sessionId: { type: String },
+    customerId: { type: [String, Number] },
+    patientId: { type: [String, Number] }
+  },
+  setup(e) {
+    const t = {
+      prod: { exexUrl: "https://acuity.theframery.com/acuity", pid: "" },
+      // Used by the demo (demo/fake-exex.html); a relative URL on the host's own site.
+      local: { exexUrl: "/fake-exex.html", pid: "demo-partner" }
+    }, s = e, n = Rs(
+      () => s.env && Object.hasOwn(t, s.env) ? t[s.env] : void 0
+    );
+    Gr(() => {
+      n.value || console.warn(
+        `<vision-assessment>: \`env\` must be one of ${Object.keys(t).join(", ")} (got ${JSON.stringify(s.env)}).`
+      );
+    });
+    const i = /* @__PURE__ */ Rr(!1), r = Rs(
+      () => !!n.value?.pid && !!s.sessionId && !i.value
+    ), o = (a) => a !== void 0 && a !== "";
+    function l(a, { exexUrl: p, pid: w }) {
+      const C = new URL(p, window.location.href);
+      return C.searchParams.set("pid", w), C.searchParams.set("eaid", crypto.randomUUID()), C.searchParams.set("sessionId", a), o(s.customerId) && C.searchParams.set("customerId", String(s.customerId)), o(s.patientId) && C.searchParams.set("patientId", String(s.patientId)), C.toString();
+    }
+    function f() {
+      !r.value || !s.sessionId || !n.value || (i.value = !0, window.location.assign(l(s.sessionId, n.value)));
+    }
+    function h(a) {
+      a.persisted && (i.value = !1);
+    }
+    return Si(() => window.addEventListener("pageshow", h)), wi(() => window.removeEventListener("pageshow", h)), (a, p) => (Do(), Lo("section", Ol, [
+      p[1] || (p[1] = xt("h2", null, "Visual acuity check", -1)),
+      p[2] || (p[2] = xt("p", null, "Take a quick online check of your distance vision. You'll be taken to a separate page to complete it.", -1)),
+      xt("button", {
+        class: "primary",
+        disabled: !r.value,
+        onClick: p[0] || (p[0] = (w) => f())
+      }, "Start", 8, Pl)
+    ]));
+  }
+}), Il = ':host{display:block;font-family:var(--va-font-family, system-ui, -apple-system, "Segoe UI", sans-serif);color:var(--va-text, #1f2937)}.card{box-sizing:border-box;background:var(--va-surface, #fff);border-radius:8px;padding:1.25rem;text-align:center;box-shadow:0 1px 3px #0000001a}button{font:inherit;cursor:pointer;padding:.5rem 1.5rem;border:1px solid var(--va-primary, #2563eb);border-radius:6px;background:var(--va-primary, #2563eb);color:var(--va-primary-text, #fff)}button:disabled{opacity:.5;cursor:not-allowed}', Ml = (e, t) => {
+  const s = e.__vccOpts || e;
+  for (const [n, i] of t)
+    s[n] = i;
+  return s;
+}, Fl = /* @__PURE__ */ Ml(Rl, [["styles", [Il]]]), Nl = /* @__PURE__ */ Sl(Fl);
+customElements.get("vision-assessment") || customElements.define("vision-assessment", Nl);
+export {
+  Nl as VisionAssessmentElement
+};