@univerjs/ui-adapter-vue3 0.8.3-nightly.202507010644

package/lib/index.js

@@ -0,0 +1,3647 @@
+import { DependentOn as xr, Inject as Bs, Injector as vr, Plugin as yr } from "@univerjs/core";
+import { UniverUIPlugin as wr, ComponentManager as Sr } from "@univerjs/ui";
+import { cloneElement as Tr, createElement as vn, useRef as Cr, useEffect as Er } from "react";
+/**
+* @vue/shared v3.5.17
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+/*! #__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function bs(e) {
+  const t = /* @__PURE__ */ Object.create(null);
+  for (const s of e.split(",")) t[s] = 1;
+  return (s) => s in t;
+}
+const V = {}, ot = [], xe = () => {
+}, Or = () => !1, Lt = (e) => e.charCodeAt(0) === 111 && e.charCodeAt(1) === 110 && // uppercase letter
+(e.charCodeAt(2) > 122 || e.charCodeAt(2) < 97), xs = (e) => e.startsWith("onUpdate:"), te = Object.assign, vs = (e, t) => {
+  const s = e.indexOf(t);
+  s > -1 && e.splice(s, 1);
+}, Pr = Object.prototype.hasOwnProperty, D = (e, t) => Pr.call(e, t), A = Array.isArray, lt = (e) => $t(e) === "[object Map]", Ar = (e) => $t(e) === "[object Set]", I = (e) => typeof e == "function", J = (e) => typeof e == "string", Qe = (e) => typeof e == "symbol", q = (e) => e !== null && typeof e == "object", yn = (e) => (q(e) || I(e)) && I(e.then) && I(e.catch), Ir = Object.prototype.toString, $t = (e) => Ir.call(e), Rr = (e) => $t(e).slice(8, -1), Mr = (e) => $t(e) === "[object Object]", ys = (e) => J(e) && e !== "NaN" && e[0] !== "-" && "" + parseInt(e, 10) === e, ft = /* @__PURE__ */ bs(
+  // the leading comma is intentional so empty string "" is also included
+  ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
+), Ut = (e) => {
+  const t = /* @__PURE__ */ Object.create(null);
+  return (s) => t[s] || (t[s] = e(s));
+}, Fr = /-(\w)/g, He = Ut(
+  (e) => e.replace(Fr, (t, s) => s ? s.toUpperCase() : "")
+), Dr = /\B([A-Z])/g, Be = Ut(
+  (e) => e.replace(Dr, "-$1").toLowerCase()
+), wn = Ut((e) => e.charAt(0).toUpperCase() + e.slice(1)), Yt = Ut(
+  (e) => e ? `on${wn(e)}` : ""
+), Ke = (e, t) => !Object.is(e, t), zt = (e, ...t) => {
+  for (let s = 0; s < e.length; s++)
+    e[s](...t);
+}, is = (e, t, s, n = !1) => {
+  Object.defineProperty(e, t, {
+    configurable: !0,
+    enumerable: !1,
+    writable: n,
+    value: s
+  });
+}, Hr = (e) => {
+  const t = parseFloat(e);
+  return isNaN(t) ? e : t;
+};
+let qs;
+const Vt = () => qs || (qs = typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof window < "u" ? window : typeof global < "u" ? global : {});
+function ws(e) {
+  if (A(e)) {
+    const t = {};
+    for (let s = 0; s < e.length; s++) {
+      const n = e[s], r = J(n) ? $r(n) : ws(n);
+      if (r)
+        for (const i in r)
+          t[i] = r[i];
+    }
+    return t;
+  } else if (J(e) || q(e))
+    return e;
+}
+const jr = /;(?![^(]*\))/g, Nr = /:([^]+)/, Lr = /\/\*[^]*?\*\//g;
+function $r(e) {
+  const t = {};
+  return e.replace(Lr, "").split(jr).forEach((s) => {
+    if (s) {
+      const n = s.split(Nr);
+      n.length > 1 && (t[n[0].trim()] = n[1].trim());
+    }
+  }), t;
+}
+function Ss(e) {
+  let t = "";
+  if (J(e))
+    t = e;
+  else if (A(e))
+    for (let s = 0; s < e.length; s++) {
+      const n = Ss(e[s]);
+      n && (t += n + " ");
+    }
+  else if (q(e))
+    for (const s in e)
+      e[s] && (t += s + " ");
+  return t.trim();
+}
+const Ur = "itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly", Vr = /* @__PURE__ */ bs(Ur);
+function Sn(e) {
+  return !!e || e === "";
+}
+/**
+* @vue/reactivity v3.5.17
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+let re;
+class Kr {
+  constructor(t = !1) {
+    this.detached = t, this._active = !0, this._on = 0, this.effects = [], this.cleanups = [], this._isPaused = !1, this.parent = re, !t && re && (this.index = (re.scopes || (re.scopes = [])).push(
+      this
+    ) - 1);
+  }
+  get active() {
+    return this._active;
+  }
+  pause() {
+    if (this._active) {
+      this._isPaused = !0;
+      let t, s;
+      if (this.scopes)
+        for (t = 0, s = this.scopes.length; t < s; t++)
+          this.scopes[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)
+        for (t = 0, s = this.scopes.length; t < s; t++)
+          this.scopes[t].resume();
+      for (t = 0, s = this.effects.length; t < s; t++)
+        this.effects[t].resume();
+    }
+  }
+  run(t) {
+    if (this._active) {
+      const s = re;
+      try {
+        return re = this, t();
+      } finally {
+        re = s;
+      }
+    }
+  }
+  /**
+   * This should only be called on non-detached scopes
+   * @internal
+   */
+  on() {
+    ++this._on === 1 && (this.prevScope = re, re = this);
+  }
+  /**
+   * This should only be called on non-detached scopes
+   * @internal
+   */
+  off() {
+    this._on > 0 && --this._on === 0 && (re = this.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) {
+        for (s = 0, n = this.scopes.length; s < n; s++)
+          this.scopes[s].stop(!0);
+        this.scopes.length = 0;
+      }
+      if (!this.detached && this.parent && !t) {
+        const r = this.parent.scopes.pop();
+        r && r !== this && (this.parent.scopes[this.index] = r, r.index = this.index);
+      }
+      this.parent = void 0;
+    }
+  }
+}
+function Wr() {
+  return re;
+}
+let U;
+const Xt = /* @__PURE__ */ new WeakSet();
+class Tn {
+  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, re && re.active && re.effects.push(this);
+  }
+  pause() {
+    this.flags |= 64;
+  }
+  resume() {
+    this.flags & 64 && (this.flags &= -65, Xt.has(this) && (Xt.delete(this), this.trigger()));
+  }
+  /**
+   * @internal
+   */
+  notify() {
+    this.flags & 2 && !(this.flags & 32) || this.flags & 8 || En(this);
+  }
+  run() {
+    if (!(this.flags & 1))
+      return this.fn();
+    this.flags |= 2, Gs(this), On(this);
+    const t = U, s = ce;
+    U = this, ce = !0;
+    try {
+      return this.fn();
+    } finally {
+      Pn(this), U = t, ce = s, this.flags &= -3;
+    }
+  }
+  stop() {
+    if (this.flags & 1) {
+      for (let t = this.deps; t; t = t.nextDep)
+        Es(t);
+      this.deps = this.depsTail = void 0, Gs(this), this.onStop && this.onStop(), this.flags &= -2;
+    }
+  }
+  trigger() {
+    this.flags & 64 ? Xt.add(this) : this.scheduler ? this.scheduler() : this.runIfDirty();
+  }
+  /**
+   * @internal
+   */
+  runIfDirty() {
+    os(this) && this.run();
+  }
+  get dirty() {
+    return os(this);
+  }
+}
+let Cn = 0, ct, ut;
+function En(e, t = !1) {
+  if (e.flags |= 8, t) {
+    e.next = ut, ut = e;
+    return;
+  }
+  e.next = ct, ct = e;
+}
+function Ts() {
+  Cn++;
+}
+function Cs() {
+  if (--Cn > 0)
+    return;
+  if (ut) {
+    let t = ut;
+    for (ut = void 0; t; ) {
+      const s = t.next;
+      t.next = void 0, t.flags &= -9, t = s;
+    }
+  }
+  let e;
+  for (; ct; ) {
+    let t = ct;
+    for (ct = 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 On(e) {
+  for (let t = e.deps; t; t = t.nextDep)
+    t.version = -1, t.prevActiveLink = t.dep.activeLink, t.dep.activeLink = t;
+}
+function Pn(e) {
+  let t, s = e.depsTail, n = s;
+  for (; n; ) {
+    const r = n.prevDep;
+    n.version === -1 ? (n === s && (s = r), Es(n), Br(n)) : t = n, n.dep.activeLink = n.prevActiveLink, n.prevActiveLink = void 0, n = r;
+  }
+  e.deps = t, e.depsTail = s;
+}
+function os(e) {
+  for (let t = e.deps; t; t = t.nextDep)
+    if (t.dep.version !== t.version || t.dep.computed && (An(t.dep.computed) || t.dep.version !== t.version))
+      return !0;
+  return !!e._dirty;
+}
+function An(e) {
+  if (e.flags & 4 && !(e.flags & 16) || (e.flags &= -17, e.globalVersion === gt) || (e.globalVersion = gt, !e.isSSR && e.flags & 128 && (!e.deps && !e._dirty || !os(e))))
+    return;
+  e.flags |= 2;
+  const t = e.dep, s = U, n = ce;
+  U = e, ce = !0;
+  try {
+    On(e);
+    const r = e.fn(e._value);
+    (t.version === 0 || Ke(r, e._value)) && (e.flags |= 128, e._value = r, t.version++);
+  } catch (r) {
+    throw t.version++, r;
+  } finally {
+    U = s, ce = n, Pn(e), e.flags &= -3;
+  }
+}
+function Es(e, t = !1) {
+  const { dep: s, prevSub: n, nextSub: r } = e;
+  if (n && (n.nextSub = r, e.prevSub = void 0), r && (r.prevSub = n, e.nextSub = void 0), s.subs === e && (s.subs = n, !n && s.computed)) {
+    s.computed.flags &= -5;
+    for (let i = s.computed.deps; i; i = i.nextDep)
+      Es(i, !0);
+  }
+  !t && !--s.sc && s.map && s.map.delete(s.key);
+}
+function Br(e) {
+  const { prevDep: t, nextDep: s } = e;
+  t && (t.nextDep = s, e.prevDep = void 0), s && (s.prevDep = t, e.nextDep = void 0);
+}
+let ce = !0;
+const In = [];
+function Ee() {
+  In.push(ce), ce = !1;
+}
+function Oe() {
+  const e = In.pop();
+  ce = e === void 0 ? !0 : e;
+}
+function Gs(e) {
+  const { cleanup: t } = e;
+  if (e.cleanup = void 0, t) {
+    const s = U;
+    U = void 0;
+    try {
+      t();
+    } finally {
+      U = s;
+    }
+  }
+}
+let gt = 0;
+class qr {
+  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 Rn {
+  // 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 || !ce || U === this.computed)
+      return;
+    let s = this.activeLink;
+    if (s === void 0 || s.sub !== U)
+      s = this.activeLink = new qr(U, this), U.deps ? (s.prevDep = U.depsTail, U.depsTail.nextDep = s, U.depsTail = s) : U.deps = U.depsTail = s, Mn(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++, gt++, this.notify(t);
+  }
+  notify(t) {
+    Ts();
+    try {
+      for (let s = this.subs; s; s = s.prevSub)
+        s.sub.notify() && s.sub.dep.notify();
+    } finally {
+      Cs();
+    }
+  }
+}
+function Mn(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)
+        Mn(n);
+    }
+    const s = e.dep.subs;
+    s !== e && (e.prevSub = s, s && (s.nextSub = e)), e.dep.subs = e;
+  }
+}
+const ls = /* @__PURE__ */ new WeakMap(), We = Symbol(
+  ""
+), fs = Symbol(
+  ""
+), _t = Symbol(
+  ""
+);
+function z(e, t, s) {
+  if (ce && U) {
+    let n = ls.get(e);
+    n || ls.set(e, n = /* @__PURE__ */ new Map());
+    let r = n.get(s);
+    r || (n.set(s, r = new Rn()), r.map = n, r.key = s), r.track();
+  }
+}
+function Ce(e, t, s, n, r, i) {
+  const o = ls.get(e);
+  if (!o) {
+    gt++;
+    return;
+  }
+  const f = (u) => {
+    u && u.trigger();
+  };
+  if (Ts(), t === "clear")
+    o.forEach(f);
+  else {
+    const u = A(e), h = u && ys(s);
+    if (u && s === "length") {
+      const a = Number(n);
+      o.forEach((p, S) => {
+        (S === "length" || S === _t || !Qe(S) && S >= a) && f(p);
+      });
+    } else
+      switch ((s !== void 0 || o.has(void 0)) && f(o.get(s)), h && f(o.get(_t)), t) {
+        case "add":
+          u ? h && f(o.get("length")) : (f(o.get(We)), lt(e) && f(o.get(fs)));
+          break;
+        case "delete":
+          u || (f(o.get(We)), lt(e) && f(o.get(fs)));
+          break;
+        case "set":
+          lt(e) && f(o.get(We));
+          break;
+      }
+  }
+  Cs();
+}
+function qe(e) {
+  const t = j(e);
+  return t === e ? t : (z(t, "iterate", _t), ve(e) ? t : t.map(le));
+}
+function Os(e) {
+  return z(e = j(e), "iterate", _t), e;
+}
+const Gr = {
+  __proto__: null,
+  [Symbol.iterator]() {
+    return Zt(this, Symbol.iterator, le);
+  },
+  concat(...e) {
+    return qe(this).concat(
+      ...e.map((t) => A(t) ? qe(t) : t)
+    );
+  },
+  entries() {
+    return Zt(this, "entries", (e) => (e[1] = le(e[1]), e));
+  },
+  every(e, t) {
+    return we(this, "every", e, t, void 0, arguments);
+  },
+  filter(e, t) {
+    return we(this, "filter", e, t, (s) => s.map(le), arguments);
+  },
+  find(e, t) {
+    return we(this, "find", e, t, le, arguments);
+  },
+  findIndex(e, t) {
+    return we(this, "findIndex", e, t, void 0, arguments);
+  },
+  findLast(e, t) {
+    return we(this, "findLast", e, t, le, arguments);
+  },
+  findLastIndex(e, t) {
+    return we(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 we(this, "forEach", e, t, void 0, arguments);
+  },
+  includes(...e) {
+    return Qt(this, "includes", e);
+  },
+  indexOf(...e) {
+    return Qt(this, "indexOf", e);
+  },
+  join(e) {
+    return qe(this).join(e);
+  },
+  // keys() iterator only reads `length`, no optimisation required
+  lastIndexOf(...e) {
+    return Qt(this, "lastIndexOf", e);
+  },
+  map(e, t) {
+    return we(this, "map", e, t, void 0, arguments);
+  },
+  pop() {
+    return nt(this, "pop");
+  },
+  push(...e) {
+    return nt(this, "push", e);
+  },
+  reduce(e, ...t) {
+    return Js(this, "reduce", e, t);
+  },
+  reduceRight(e, ...t) {
+    return Js(this, "reduceRight", e, t);
+  },
+  shift() {
+    return nt(this, "shift");
+  },
+  // slice could use ARRAY_ITERATE but also seems to beg for range tracking
+  some(e, t) {
+    return we(this, "some", e, t, void 0, arguments);
+  },
+  splice(...e) {
+    return nt(this, "splice", e);
+  },
+  toReversed() {
+    return qe(this).toReversed();
+  },
+  toSorted(e) {
+    return qe(this).toSorted(e);
+  },
+  toSpliced(...e) {
+    return qe(this).toSpliced(...e);
+  },
+  unshift(...e) {
+    return nt(this, "unshift", e);
+  },
+  values() {
+    return Zt(this, "values", le);
+  }
+};
+function Zt(e, t, s) {
+  const n = Os(e), r = n[t]();
+  return n !== e && !ve(e) && (r._next = r.next, r.next = () => {
+    const i = r._next();
+    return i.value && (i.value = s(i.value)), i;
+  }), r;
+}
+const Jr = Array.prototype;
+function we(e, t, s, n, r, i) {
+  const o = Os(e), f = o !== e && !ve(e), u = o[t];
+  if (u !== Jr[t]) {
+    const p = u.apply(e, i);
+    return f ? le(p) : p;
+  }
+  let h = s;
+  o !== e && (f ? h = function(p, S) {
+    return s.call(this, le(p), S, e);
+  } : s.length > 2 && (h = function(p, S) {
+    return s.call(this, p, S, e);
+  }));
+  const a = u.call(o, h, n);
+  return f && r ? r(a) : a;
+}
+function Js(e, t, s, n) {
+  const r = Os(e);
+  let i = s;
+  return r !== e && (ve(e) ? s.length > 3 && (i = function(o, f, u) {
+    return s.call(this, o, f, u, e);
+  }) : i = function(o, f, u) {
+    return s.call(this, o, le(f), u, e);
+  }), r[t](i, ...n);
+}
+function Qt(e, t, s) {
+  const n = j(e);
+  z(n, "iterate", _t);
+  const r = n[t](...s);
+  return (r === -1 || r === !1) && Rs(s[0]) ? (s[0] = j(s[0]), n[t](...s)) : r;
+}
+function nt(e, t, s = []) {
+  Ee(), Ts();
+  const n = j(e)[t].apply(e, s);
+  return Cs(), Oe(), n;
+}
+const Yr = /* @__PURE__ */ bs("__proto__,__v_isRef,__isVue"), Fn = new Set(
+  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((e) => e !== "arguments" && e !== "caller").map((e) => Symbol[e]).filter(Qe)
+);
+function zr(e) {
+  Qe(e) || (e = String(e));
+  const t = j(this);
+  return z(t, "has", e), t.hasOwnProperty(e);
+}
+class Dn {
+  constructor(t = !1, s = !1) {
+    this._isReadonly = t, this._isShallow = s;
+  }
+  get(t, s, n) {
+    if (s === "__v_skip") return t.__v_skip;
+    const r = this._isReadonly, i = this._isShallow;
+    if (s === "__v_isReactive")
+      return !r;
+    if (s === "__v_isReadonly")
+      return r;
+    if (s === "__v_isShallow")
+      return i;
+    if (s === "__v_raw")
+      return n === (r ? i ? ii : Ln : i ? Nn : jn).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 = A(t);
+    if (!r) {
+      let u;
+      if (o && (u = Gr[s]))
+        return u;
+      if (s === "hasOwnProperty")
+        return zr;
+    }
+    const f = 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
+      ee(t) ? t : n
+    );
+    return (Qe(s) ? Fn.has(s) : Yr(s)) || (r || z(t, "get", s), i) ? f : ee(f) ? o && ys(s) ? f : f.value : q(f) ? r ? $n(f) : As(f) : f;
+  }
+}
+class Hn extends Dn {
+  constructor(t = !1) {
+    super(!1, t);
+  }
+  set(t, s, n, r) {
+    let i = t[s];
+    if (!this._isShallow) {
+      const u = ze(i);
+      if (!ve(n) && !ze(n) && (i = j(i), n = j(n)), !A(t) && ee(i) && !ee(n))
+        return u ? !1 : (i.value = n, !0);
+    }
+    const o = A(t) && ys(s) ? Number(s) < t.length : D(t, s), f = Reflect.set(
+      t,
+      s,
+      n,
+      ee(t) ? t : r
+    );
+    return t === j(r) && (o ? Ke(n, i) && Ce(t, "set", s, n) : Ce(t, "add", s, n)), f;
+  }
+  deleteProperty(t, s) {
+    const n = D(t, s);
+    t[s];
+    const r = Reflect.deleteProperty(t, s);
+    return r && n && Ce(t, "delete", s, void 0), r;
+  }
+  has(t, s) {
+    const n = Reflect.has(t, s);
+    return (!Qe(s) || !Fn.has(s)) && z(t, "has", s), n;
+  }
+  ownKeys(t) {
+    return z(
+      t,
+      "iterate",
+      A(t) ? "length" : We
+    ), Reflect.ownKeys(t);
+  }
+}
+class Xr extends Dn {
+  constructor(t = !1) {
+    super(!0, t);
+  }
+  set(t, s) {
+    return !0;
+  }
+  deleteProperty(t, s) {
+    return !0;
+  }
+}
+const Zr = /* @__PURE__ */ new Hn(), Qr = /* @__PURE__ */ new Xr(), kr = /* @__PURE__ */ new Hn(!0);
+const cs = (e) => e, Et = (e) => Reflect.getPrototypeOf(e);
+function ei(e, t, s) {
+  return function(...n) {
+    const r = this.__v_raw, i = j(r), o = lt(i), f = e === "entries" || e === Symbol.iterator && o, u = e === "keys" && o, h = r[e](...n), a = s ? cs : t ? us : le;
+    return !t && z(
+      i,
+      "iterate",
+      u ? fs : We
+    ), {
+      // iterator protocol
+      next() {
+        const { value: p, done: S } = h.next();
+        return S ? { value: p, done: S } : {
+          value: f ? [a(p[0]), a(p[1])] : a(p),
+          done: S
+        };
+      },
+      // iterable protocol
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  };
+}
+function Ot(e) {
+  return function(...t) {
+    return e === "delete" ? !1 : e === "clear" ? void 0 : this;
+  };
+}
+function ti(e, t) {
+  const s = {
+    get(r) {
+      const i = this.__v_raw, o = j(i), f = j(r);
+      e || (Ke(r, f) && z(o, "get", r), z(o, "get", f));
+      const { has: u } = Et(o), h = t ? cs : e ? us : le;
+      if (u.call(o, r))
+        return h(i.get(r));
+      if (u.call(o, f))
+        return h(i.get(f));
+      i !== o && i.get(r);
+    },
+    get size() {
+      const r = this.__v_raw;
+      return !e && z(j(r), "iterate", We), Reflect.get(r, "size", r);
+    },
+    has(r) {
+      const i = this.__v_raw, o = j(i), f = j(r);
+      return e || (Ke(r, f) && z(o, "has", r), z(o, "has", f)), r === f ? i.has(r) : i.has(r) || i.has(f);
+    },
+    forEach(r, i) {
+      const o = this, f = o.__v_raw, u = j(f), h = t ? cs : e ? us : le;
+      return !e && z(u, "iterate", We), f.forEach((a, p) => r.call(i, h(a), h(p), o));
+    }
+  };
+  return te(
+    s,
+    e ? {
+      add: Ot("add"),
+      set: Ot("set"),
+      delete: Ot("delete"),
+      clear: Ot("clear")
+    } : {
+      add(r) {
+        !t && !ve(r) && !ze(r) && (r = j(r));
+        const i = j(this);
+        return Et(i).has.call(i, r) || (i.add(r), Ce(i, "add", r, r)), this;
+      },
+      set(r, i) {
+        !t && !ve(i) && !ze(i) && (i = j(i));
+        const o = j(this), { has: f, get: u } = Et(o);
+        let h = f.call(o, r);
+        h || (r = j(r), h = f.call(o, r));
+        const a = u.call(o, r);
+        return o.set(r, i), h ? Ke(i, a) && Ce(o, "set", r, i) : Ce(o, "add", r, i), this;
+      },
+      delete(r) {
+        const i = j(this), { has: o, get: f } = Et(i);
+        let u = o.call(i, r);
+        u || (r = j(r), u = o.call(i, r)), f && f.call(i, r);
+        const h = i.delete(r);
+        return u && Ce(i, "delete", r, void 0), h;
+      },
+      clear() {
+        const r = j(this), i = r.size !== 0, o = r.clear();
+        return i && Ce(
+          r,
+          "clear",
+          void 0,
+          void 0
+        ), o;
+      }
+    }
+  ), [
+    "keys",
+    "values",
+    "entries",
+    Symbol.iterator
+  ].forEach((r) => {
+    s[r] = ei(r, e, t);
+  }), s;
+}
+function Ps(e, t) {
+  const s = ti(e, t);
+  return (n, r, i) => r === "__v_isReactive" ? !e : r === "__v_isReadonly" ? e : r === "__v_raw" ? n : Reflect.get(
+    D(s, r) && r in n ? s : n,
+    r,
+    i
+  );
+}
+const si = {
+  get: /* @__PURE__ */ Ps(!1, !1)
+}, ni = {
+  get: /* @__PURE__ */ Ps(!1, !0)
+}, ri = {
+  get: /* @__PURE__ */ Ps(!0, !1)
+};
+const jn = /* @__PURE__ */ new WeakMap(), Nn = /* @__PURE__ */ new WeakMap(), Ln = /* @__PURE__ */ new WeakMap(), ii = /* @__PURE__ */ new WeakMap();
+function oi(e) {
+  switch (e) {
+    case "Object":
+    case "Array":
+      return 1;
+    case "Map":
+    case "Set":
+    case "WeakMap":
+    case "WeakSet":
+      return 2;
+    default:
+      return 0;
+  }
+}
+function li(e) {
+  return e.__v_skip || !Object.isExtensible(e) ? 0 : oi(Rr(e));
+}
+function As(e) {
+  return ze(e) ? e : Is(
+    e,
+    !1,
+    Zr,
+    si,
+    jn
+  );
+}
+function fi(e) {
+  return Is(
+    e,
+    !1,
+    kr,
+    ni,
+    Nn
+  );
+}
+function $n(e) {
+  return Is(
+    e,
+    !0,
+    Qr,
+    ri,
+    Ln
+  );
+}
+function Is(e, t, s, n, r) {
+  if (!q(e) || e.__v_raw && !(t && e.__v_isReactive))
+    return e;
+  const i = li(e);
+  if (i === 0)
+    return e;
+  const o = r.get(e);
+  if (o)
+    return o;
+  const f = new Proxy(
+    e,
+    i === 2 ? n : s
+  );
+  return r.set(e, f), f;
+}
+function at(e) {
+  return ze(e) ? at(e.__v_raw) : !!(e && e.__v_isReactive);
+}
+function ze(e) {
+  return !!(e && e.__v_isReadonly);
+}
+function ve(e) {
+  return !!(e && e.__v_isShallow);
+}
+function Rs(e) {
+  return e ? !!e.__v_raw : !1;
+}
+function j(e) {
+  const t = e && e.__v_raw;
+  return t ? j(t) : e;
+}
+function ci(e) {
+  return !D(e, "__v_skip") && Object.isExtensible(e) && is(e, "__v_skip", !0), e;
+}
+const le = (e) => q(e) ? As(e) : e, us = (e) => q(e) ? $n(e) : e;
+function ee(e) {
+  return e ? e.__v_isRef === !0 : !1;
+}
+function ui(e) {
+  return ee(e) ? e.value : e;
+}
+const ai = {
+  get: (e, t, s) => t === "__v_raw" ? e : ui(Reflect.get(e, t, s)),
+  set: (e, t, s, n) => {
+    const r = e[t];
+    return ee(r) && !ee(s) ? (r.value = s, !0) : Reflect.set(e, t, s, n);
+  }
+};
+function Un(e) {
+  return at(e) ? e : new Proxy(e, ai);
+}
+class di {
+  constructor(t, s, n) {
+    this.fn = t, this.setter = s, this._value = void 0, this.dep = new Rn(this), this.__v_isRef = !0, this.deps = void 0, this.depsTail = void 0, this.flags = 16, this.globalVersion = gt - 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 En(this, !0), !0;
+  }
+  get value() {
+    const t = this.dep.track();
+    return An(this), t && (t.version = this.dep.version), this._value;
+  }
+  set value(t) {
+    this.setter && this.setter(t);
+  }
+}
+function hi(e, t, s = !1) {
+  let n, r;
+  return I(e) ? n = e : (n = e.get, r = e.set), new di(n, r, s);
+}
+const Pt = {}, Mt = /* @__PURE__ */ new WeakMap();
+let Ve;
+function pi(e, t = !1, s = Ve) {
+  if (s) {
+    let n = Mt.get(s);
+    n || Mt.set(s, n = []), n.push(e);
+  }
+}
+function gi(e, t, s = V) {
+  const { immediate: n, deep: r, once: i, scheduler: o, augmentJob: f, call: u } = s, h = (O) => r ? O : ve(O) || r === !1 || r === 0 ? Fe(O, 1) : Fe(O);
+  let a, p, S, T, F = !1, M = !1;
+  if (ee(e) ? (p = () => e.value, F = ve(e)) : at(e) ? (p = () => h(e), F = !0) : A(e) ? (M = !0, F = e.some((O) => at(O) || ve(O)), p = () => e.map((O) => {
+    if (ee(O))
+      return O.value;
+    if (at(O))
+      return h(O);
+    if (I(O))
+      return u ? u(O, 2) : O();
+  })) : I(e) ? t ? p = u ? () => u(e, 2) : e : p = () => {
+    if (S) {
+      Ee();
+      try {
+        S();
+      } finally {
+        Oe();
+      }
+    }
+    const O = Ve;
+    Ve = a;
+    try {
+      return u ? u(e, 3, [T]) : e(T);
+    } finally {
+      Ve = O;
+    }
+  } : p = xe, t && r) {
+    const O = p, G = r === !0 ? 1 / 0 : r;
+    p = () => Fe(O(), G);
+  }
+  const Y = Wr(), N = () => {
+    a.stop(), Y && Y.active && vs(Y.effects, a);
+  };
+  if (i && t) {
+    const O = t;
+    t = (...G) => {
+      O(...G), N();
+    };
+  }
+  let W = M ? new Array(e.length).fill(Pt) : Pt;
+  const B = (O) => {
+    if (!(!(a.flags & 1) || !a.dirty && !O))
+      if (t) {
+        const G = a.run();
+        if (r || F || (M ? G.some((Ae, ue) => Ke(Ae, W[ue])) : Ke(G, W))) {
+          S && S();
+          const Ae = Ve;
+          Ve = a;
+          try {
+            const ue = [
+              G,
+              // pass undefined as the old value when it's changed for the first time
+              W === Pt ? void 0 : M && W[0] === Pt ? [] : W,
+              T
+            ];
+            W = G, u ? u(t, 3, ue) : (
+              // @ts-expect-error
+              t(...ue)
+            );
+          } finally {
+            Ve = Ae;
+          }
+        }
+      } else
+        a.run();
+  };
+  return f && f(B), a = new Tn(p), a.scheduler = o ? () => o(B, !1) : B, T = (O) => pi(O, !1, a), S = a.onStop = () => {
+    const O = Mt.get(a);
+    if (O) {
+      if (u)
+        u(O, 4);
+      else
+        for (const G of O) G();
+      Mt.delete(a);
+    }
+  }, t ? n ? B(!0) : W = a.run() : o ? o(B.bind(null, !0), !0) : a.run(), N.pause = a.pause.bind(a), N.resume = a.resume.bind(a), N.stop = N, N;
+}
+function Fe(e, t = 1 / 0, s) {
+  if (t <= 0 || !q(e) || e.__v_skip || (s = s || /* @__PURE__ */ new Set(), s.has(e)))
+    return e;
+  if (s.add(e), t--, ee(e))
+    Fe(e.value, t, s);
+  else if (A(e))
+    for (let n = 0; n < e.length; n++)
+      Fe(e[n], t, s);
+  else if (Ar(e) || lt(e))
+    e.forEach((n) => {
+      Fe(n, t, s);
+    });
+  else if (Mr(e)) {
+    for (const n in e)
+      Fe(e[n], t, s);
+    for (const n of Object.getOwnPropertySymbols(e))
+      Object.prototype.propertyIsEnumerable.call(e, n) && Fe(e[n], t, s);
+  }
+  return e;
+}
+/**
+* @vue/runtime-core v3.5.17
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+function xt(e, t, s, n) {
+  try {
+    return n ? e(...n) : e();
+  } catch (r) {
+    Kt(r, t, s);
+  }
+}
+function ye(e, t, s, n) {
+  if (I(e)) {
+    const r = xt(e, t, s, n);
+    return r && yn(r) && r.catch((i) => {
+      Kt(i, t, s);
+    }), r;
+  }
+  if (A(e)) {
+    const r = [];
+    for (let i = 0; i < e.length; i++)
+      r.push(ye(e[i], t, s, n));
+    return r;
+  }
+}
+function Kt(e, t, s, n = !0) {
+  const r = t ? t.vnode : null, { errorHandler: i, throwUnhandledErrorInProduction: o } = t && t.appContext.config || V;
+  if (t) {
+    let f = t.parent;
+    const u = t.proxy, h = `https://vuejs.org/error-reference/#runtime-${s}`;
+    for (; f; ) {
+      const a = f.ec;
+      if (a) {
+        for (let p = 0; p < a.length; p++)
+          if (a[p](e, u, h) === !1)
+            return;
+      }
+      f = f.parent;
+    }
+    if (i) {
+      Ee(), xt(i, null, 10, [
+        e,
+        u,
+        h
+      ]), Oe();
+      return;
+    }
+  }
+  _i(e, s, r, n, o);
+}
+function _i(e, t, s, n = !0, r = !1) {
+  if (r)
+    throw e;
+  console.error(e);
+}
+const Q = [];
+let _e = -1;
+const Je = [];
+let Re = null, Ge = 0;
+const Vn = /* @__PURE__ */ Promise.resolve();
+let Ft = null;
+function mi(e) {
+  const t = Ft || Vn;
+  return e ? t.then(this ? e.bind(this) : e) : t;
+}
+function bi(e) {
+  let t = _e + 1, s = Q.length;
+  for (; t < s; ) {
+    const n = t + s >>> 1, r = Q[n], i = mt(r);
+    i < e || i === e && r.flags & 2 ? t = n + 1 : s = n;
+  }
+  return t;
+}
+function Ms(e) {
+  if (!(e.flags & 1)) {
+    const t = mt(e), s = Q[Q.length - 1];
+    !s || // fast path when the job id is larger than the tail
+    !(e.flags & 2) && t >= mt(s) ? Q.push(e) : Q.splice(bi(t), 0, e), e.flags |= 1, Kn();
+  }
+}
+function Kn() {
+  Ft || (Ft = Vn.then(Bn));
+}
+function xi(e) {
+  A(e) ? Je.push(...e) : Re && e.id === -1 ? Re.splice(Ge + 1, 0, e) : e.flags & 1 || (Je.push(e), e.flags |= 1), Kn();
+}
+function Ys(e, t, s = _e + 1) {
+  for (; s < Q.length; s++) {
+    const n = Q[s];
+    if (n && n.flags & 2) {
+      if (e && n.id !== e.uid)
+        continue;
+      Q.splice(s, 1), s--, n.flags & 4 && (n.flags &= -2), n(), n.flags & 4 || (n.flags &= -2);
+    }
+  }
+}
+function Wn(e) {
+  if (Je.length) {
+    const t = [...new Set(Je)].sort(
+      (s, n) => mt(s) - mt(n)
+    );
+    if (Je.length = 0, Re) {
+      Re.push(...t);
+      return;
+    }
+    for (Re = t, Ge = 0; Ge < Re.length; Ge++) {
+      const s = Re[Ge];
+      s.flags & 4 && (s.flags &= -2), s.flags & 8 || s(), s.flags &= -2;
+    }
+    Re = null, Ge = 0;
+  }
+}
+const mt = (e) => e.id == null ? e.flags & 2 ? -1 : 1 / 0 : e.id;
+function Bn(e) {
+  try {
+    for (_e = 0; _e < Q.length; _e++) {
+      const t = Q[_e];
+      t && !(t.flags & 8) && (t.flags & 4 && (t.flags &= -2), xt(
+        t,
+        t.i,
+        t.i ? 15 : 14
+      ), t.flags & 4 || (t.flags &= -2));
+    }
+  } finally {
+    for (; _e < Q.length; _e++) {
+      const t = Q[_e];
+      t && (t.flags &= -2);
+    }
+    _e = -1, Q.length = 0, Wn(), Ft = null, (Q.length || Je.length) && Bn();
+  }
+}
+let be = null, qn = null;
+function Dt(e) {
+  const t = be;
+  return be = e, qn = e && e.type.__scopeId || null, t;
+}
+function vi(e, t = be, s) {
+  if (!t || e._n)
+    return e;
+  const n = (...r) => {
+    n._d && nn(-1);
+    const i = Dt(t);
+    let o;
+    try {
+      o = e(...r);
+    } finally {
+      Dt(i), n._d && nn(1);
+    }
+    return o;
+  };
+  return n._n = !0, n._c = !0, n._d = !0, n;
+}
+function $e(e, t, s, n) {
+  const r = e.dirs, i = t && t.dirs;
+  for (let o = 0; o < r.length; o++) {
+    const f = r[o];
+    i && (f.oldValue = i[o].value);
+    let u = f.dir[n];
+    u && (Ee(), ye(u, s, 8, [
+      e.el,
+      f,
+      e,
+      t
+    ]), Oe());
+  }
+}
+const yi = Symbol("_vte"), wi = (e) => e.__isTeleport;
+function Fs(e, t) {
+  e.shapeFlag & 6 && e.component ? (e.transition = t, Fs(e.component.subTree, t)) : e.shapeFlag & 128 ? (e.ssContent.transition = t.clone(e.ssContent), e.ssFallback.transition = t.clone(e.ssFallback)) : e.transition = t;
+}
+function Gn(e) {
+  e.ids = [e.ids[0] + e.ids[2]++ + "-", 0, 0];
+}
+function dt(e, t, s, n, r = !1) {
+  if (A(e)) {
+    e.forEach(
+      (F, M) => dt(
+        F,
+        t && (A(t) ? t[M] : t),
+        s,
+        n,
+        r
+      )
+    );
+    return;
+  }
+  if (ht(n) && !r) {
+    n.shapeFlag & 512 && n.type.__asyncResolved && n.component.subTree.component && dt(e, t, s, n.component.subTree);
+    return;
+  }
+  const i = n.shapeFlag & 4 ? Ls(n.component) : n.el, o = r ? null : i, { i: f, r: u } = e, h = t && t.r, a = f.refs === V ? f.refs = {} : f.refs, p = f.setupState, S = j(p), T = p === V ? () => !1 : (F) => D(S, F);
+  if (h != null && h !== u && (J(h) ? (a[h] = null, T(h) && (p[h] = null)) : ee(h) && (h.value = null)), I(u))
+    xt(u, f, 12, [o, a]);
+  else {
+    const F = J(u), M = ee(u);
+    if (F || M) {
+      const Y = () => {
+        if (e.f) {
+          const N = F ? T(u) ? p[u] : a[u] : u.value;
+          r ? A(N) && vs(N, i) : A(N) ? N.includes(i) || N.push(i) : F ? (a[u] = [i], T(u) && (p[u] = a[u])) : (u.value = [i], e.k && (a[e.k] = u.value));
+        } else F ? (a[u] = o, T(u) && (p[u] = o)) : M && (u.value = o, e.k && (a[e.k] = o));
+      };
+      o ? (Y.id = -1, oe(Y, s)) : Y();
+    }
+  }
+}
+Vt().requestIdleCallback;
+Vt().cancelIdleCallback;
+const ht = (e) => !!e.type.__asyncLoader, Jn = (e) => e.type.__isKeepAlive;
+function Si(e, t) {
+  Yn(e, "a", t);
+}
+function Ti(e, t) {
+  Yn(e, "da", t);
+}
+function Yn(e, t, s = k) {
+  const n = e.__wdc || (e.__wdc = () => {
+    let r = s;
+    for (; r; ) {
+      if (r.isDeactivated)
+        return;
+      r = r.parent;
+    }
+    return e();
+  });
+  if (Wt(t, n, s), s) {
+    let r = s.parent;
+    for (; r && r.parent; )
+      Jn(r.parent.vnode) && Ci(n, t, s, r), r = r.parent;
+  }
+}
+function Ci(e, t, s, n) {
+  const r = Wt(
+    t,
+    e,
+    n,
+    !0
+    /* prepend */
+  );
+  zn(() => {
+    vs(n[t], r);
+  }, s);
+}
+function Wt(e, t, s = k, n = !1) {
+  if (s) {
+    const r = s[e] || (s[e] = []), i = t.__weh || (t.__weh = (...o) => {
+      Ee();
+      const f = vt(s), u = ye(t, s, e, o);
+      return f(), Oe(), u;
+    });
+    return n ? r.unshift(i) : r.push(i), i;
+  }
+}
+const Pe = (e) => (t, s = k) => {
+  (!bt || e === "sp") && Wt(e, (...n) => t(...n), s);
+}, Ei = Pe("bm"), Oi = Pe("m"), Pi = Pe(
+  "bu"
+), Ai = Pe("u"), Ii = Pe(
+  "bum"
+), zn = Pe("um"), Ri = Pe(
+  "sp"
+), Mi = Pe("rtg"), Fi = Pe("rtc");
+function Di(e, t = k) {
+  Wt("ec", e, t);
+}
+const Hi = Symbol.for("v-ndc"), as = (e) => e ? pr(e) ? Ls(e) : as(e.parent) : null, pt = (
+  // Move PURE marker to new line to workaround compiler discarding it
+  // due to type annotation
+  /* @__PURE__ */ te(/* @__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) => Zn(e),
+    $forceUpdate: (e) => e.f || (e.f = () => {
+      Ms(e.update);
+    }),
+    $nextTick: (e) => e.n || (e.n = mi.bind(e.proxy)),
+    $watch: (e) => no.bind(e)
+  })
+), kt = (e, t) => e !== V && !e.__isScriptSetup && D(e, t), ji = {
+  get({ _: e }, t) {
+    if (t === "__v_skip")
+      return !0;
+    const { ctx: s, setupState: n, data: r, props: i, accessCache: o, type: f, appContext: u } = e;
+    let h;
+    if (t[0] !== "$") {
+      const T = o[t];
+      if (T !== void 0)
+        switch (T) {
+          case 1:
+            return n[t];
+          case 2:
+            return r[t];
+          case 4:
+            return s[t];
+          case 3:
+            return i[t];
+        }
+      else {
+        if (kt(n, t))
+          return o[t] = 1, n[t];
+        if (r !== V && D(r, t))
+          return o[t] = 2, r[t];
+        if (
+          // only cache other properties when instance has declared (thus stable)
+          // props
+          (h = e.propsOptions[0]) && D(h, t)
+        )
+          return o[t] = 3, i[t];
+        if (s !== V && D(s, t))
+          return o[t] = 4, s[t];
+        ds && (o[t] = 0);
+      }
+    }
+    const a = pt[t];
+    let p, S;
+    if (a)
+      return t === "$attrs" && z(e.attrs, "get", ""), a(e);
+    if (
+      // css module (injected by vue-loader)
+      (p = f.__cssModules) && (p = p[t])
+    )
+      return p;
+    if (s !== V && D(s, t))
+      return o[t] = 4, s[t];
+    if (
+      // global properties
+      S = u.config.globalProperties, D(S, t)
+    )
+      return S[t];
+  },
+  set({ _: e }, t, s) {
+    const { data: n, setupState: r, ctx: i } = e;
+    return kt(r, t) ? (r[t] = s, !0) : n !== V && D(n, t) ? (n[t] = s, !0) : D(e.props, t) || t[0] === "$" && t.slice(1) in e ? !1 : (i[t] = s, !0);
+  },
+  has({
+    _: { data: e, setupState: t, accessCache: s, ctx: n, appContext: r, propsOptions: i }
+  }, o) {
+    let f;
+    return !!s[o] || e !== V && D(e, o) || kt(t, o) || (f = i[0]) && D(f, o) || D(n, o) || D(pt, o) || D(r.config.globalProperties, o);
+  },
+  defineProperty(e, t, s) {
+    return s.get != null ? e._.accessCache[t] = 0 : D(s, "value") && this.set(e, t, s.value, null), Reflect.defineProperty(e, t, s);
+  }
+};
+function zs(e) {
+  return A(e) ? e.reduce(
+    (t, s) => (t[s] = null, t),
+    {}
+  ) : e;
+}
+let ds = !0;
+function Ni(e) {
+  const t = Zn(e), s = e.proxy, n = e.ctx;
+  ds = !1, t.beforeCreate && Xs(t.beforeCreate, e, "bc");
+  const {
+    // state
+    data: r,
+    computed: i,
+    methods: o,
+    watch: f,
+    provide: u,
+    inject: h,
+    // lifecycle
+    created: a,
+    beforeMount: p,
+    mounted: S,
+    beforeUpdate: T,
+    updated: F,
+    activated: M,
+    deactivated: Y,
+    beforeDestroy: N,
+    beforeUnmount: W,
+    destroyed: B,
+    unmounted: O,
+    render: G,
+    renderTracked: Ae,
+    renderTriggered: ue,
+    errorCaptured: Ie,
+    serverPrefetch: yt,
+    // public API
+    expose: je,
+    inheritAttrs: ke,
+    // assets
+    components: wt,
+    directives: St,
+    filters: Gt
+  } = t;
+  if (h && Li(h, n, null), o)
+    for (const K in o) {
+      const L = o[K];
+      I(L) && (n[K] = L.bind(s));
+    }
+  if (r) {
+    const K = r.call(s, s);
+    q(K) && (e.data = As(K));
+  }
+  if (ds = !0, i)
+    for (const K in i) {
+      const L = i[K], Ne = I(L) ? L.bind(s, s) : I(L.get) ? L.get.bind(s, s) : xe, Tt = !I(L) && I(L.set) ? L.set.bind(s) : xe, Le = Co({
+        get: Ne,
+        set: Tt
+      });
+      Object.defineProperty(n, K, {
+        enumerable: !0,
+        configurable: !0,
+        get: () => Le.value,
+        set: (ae) => Le.value = ae
+      });
+    }
+  if (f)
+    for (const K in f)
+      Xn(f[K], n, s, K);
+  if (u) {
+    const K = I(u) ? u.call(s) : u;
+    Reflect.ownKeys(K).forEach((L) => {
+      Bi(L, K[L]);
+    });
+  }
+  a && Xs(a, e, "c");
+  function X(K, L) {
+    A(L) ? L.forEach((Ne) => K(Ne.bind(s))) : L && K(L.bind(s));
+  }
+  if (X(Ei, p), X(Oi, S), X(Pi, T), X(Ai, F), X(Si, M), X(Ti, Y), X(Di, Ie), X(Fi, Ae), X(Mi, ue), X(Ii, W), X(zn, O), X(Ri, yt), A(je))
+    if (je.length) {
+      const K = e.exposed || (e.exposed = {});
+      je.forEach((L) => {
+        Object.defineProperty(K, L, {
+          get: () => s[L],
+          set: (Ne) => s[L] = Ne
+        });
+      });
+    } else e.exposed || (e.exposed = {});
+  G && e.render === xe && (e.render = G), ke != null && (e.inheritAttrs = ke), wt && (e.components = wt), St && (e.directives = St), yt && Gn(e);
+}
+function Li(e, t, s = xe) {
+  A(e) && (e = hs(e));
+  for (const n in e) {
+    const r = e[n];
+    let i;
+    q(r) ? "default" in r ? i = At(
+      r.from || n,
+      r.default,
+      !0
+    ) : i = At(r.from || n) : i = At(r), ee(i) ? Object.defineProperty(t, n, {
+      enumerable: !0,
+      configurable: !0,
+      get: () => i.value,
+      set: (o) => i.value = o
+    }) : t[n] = i;
+  }
+}
+function Xs(e, t, s) {
+  ye(
+    A(e) ? e.map((n) => n.bind(t.proxy)) : e.bind(t.proxy),
+    t,
+    s
+  );
+}
+function Xn(e, t, s, n) {
+  let r = n.includes(".") ? ur(s, n) : () => s[n];
+  if (J(e)) {
+    const i = t[e];
+    I(i) && ts(r, i);
+  } else if (I(e))
+    ts(r, e.bind(s));
+  else if (q(e))
+    if (A(e))
+      e.forEach((i) => Xn(i, t, s, n));
+    else {
+      const i = I(e.handler) ? e.handler.bind(s) : t[e.handler];
+      I(i) && ts(r, i, e);
+    }
+}
+function Zn(e) {
+  const t = e.type, { mixins: s, extends: n } = t, {
+    mixins: r,
+    optionsCache: i,
+    config: { optionMergeStrategies: o }
+  } = e.appContext, f = i.get(t);
+  let u;
+  return f ? u = f : !r.length && !s && !n ? u = t : (u = {}, r.length && r.forEach(
+    (h) => Ht(u, h, o, !0)
+  ), Ht(u, t, o)), q(t) && i.set(t, u), u;
+}
+function Ht(e, t, s, n = !1) {
+  const { mixins: r, extends: i } = t;
+  i && Ht(e, i, s, !0), r && r.forEach(
+    (o) => Ht(e, o, s, !0)
+  );
+  for (const o in t)
+    if (!(n && o === "expose")) {
+      const f = $i[o] || s && s[o];
+      e[o] = f ? f(e[o], t[o]) : t[o];
+    }
+  return e;
+}
+const $i = {
+  data: Zs,
+  props: Qs,
+  emits: Qs,
+  // objects
+  methods: it,
+  computed: it,
+  // lifecycle
+  beforeCreate: Z,
+  created: Z,
+  beforeMount: Z,
+  mounted: Z,
+  beforeUpdate: Z,
+  updated: Z,
+  beforeDestroy: Z,
+  beforeUnmount: Z,
+  destroyed: Z,
+  unmounted: Z,
+  activated: Z,
+  deactivated: Z,
+  errorCaptured: Z,
+  serverPrefetch: Z,
+  // assets
+  components: it,
+  directives: it,
+  // watch
+  watch: Vi,
+  // provide / inject
+  provide: Zs,
+  inject: Ui
+};
+function Zs(e, t) {
+  return t ? e ? function() {
+    return te(
+      I(e) ? e.call(this, this) : e,
+      I(t) ? t.call(this, this) : t
+    );
+  } : t : e;
+}
+function Ui(e, t) {
+  return it(hs(e), hs(t));
+}
+function hs(e) {
+  if (A(e)) {
+    const t = {};
+    for (let s = 0; s < e.length; s++)
+      t[e[s]] = e[s];
+    return t;
+  }
+  return e;
+}
+function Z(e, t) {
+  return e ? [...new Set([].concat(e, t))] : t;
+}
+function it(e, t) {
+  return e ? te(/* @__PURE__ */ Object.create(null), e, t) : t;
+}
+function Qs(e, t) {
+  return e ? A(e) && A(t) ? [.../* @__PURE__ */ new Set([...e, ...t])] : te(
+    /* @__PURE__ */ Object.create(null),
+    zs(e),
+    zs(t != null ? t : {})
+  ) : t;
+}
+function Vi(e, t) {
+  if (!e) return t;
+  if (!t) return e;
+  const s = te(/* @__PURE__ */ Object.create(null), e);
+  for (const n in t)
+    s[n] = Z(e[n], t[n]);
+  return s;
+}
+function Qn() {
+  return {
+    app: null,
+    config: {
+      isNativeTag: Or,
+      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 Ki = 0;
+function Wi(e, t) {
+  return function(n, r = null) {
+    I(n) || (n = te({}, n)), r != null && !q(r) && (r = null);
+    const i = Qn(), o = /* @__PURE__ */ new WeakSet(), f = [];
+    let u = !1;
+    const h = i.app = {
+      _uid: Ki++,
+      _component: n,
+      _props: r,
+      _container: null,
+      _context: i,
+      _instance: null,
+      version: Oo,
+      get config() {
+        return i.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 i.mixins.includes(a) || i.mixins.push(a), h;
+      },
+      component(a, p) {
+        return p ? (i.components[a] = p, h) : i.components[a];
+      },
+      directive(a, p) {
+        return p ? (i.directives[a] = p, h) : i.directives[a];
+      },
+      mount(a, p, S) {
+        if (!u) {
+          const T = h._ceVNode || fe(n, r);
+          return T.appContext = i, S === !0 ? S = "svg" : S === !1 && (S = void 0), e(T, a, S), u = !0, h._container = a, a.__vue_app__ = h, Ls(T.component);
+        }
+      },
+      onUnmount(a) {
+        f.push(a);
+      },
+      unmount() {
+        u && (ye(
+          f,
+          h._instance,
+          16
+        ), e(null, h._container), delete h._container.__vue_app__);
+      },
+      provide(a, p) {
+        return i.provides[a] = p, h;
+      },
+      runWithContext(a) {
+        const p = Ye;
+        Ye = h;
+        try {
+          return a();
+        } finally {
+          Ye = p;
+        }
+      }
+    };
+    return h;
+  };
+}
+let Ye = null;
+function Bi(e, t) {
+  if (k) {
+    let s = k.provides;
+    const n = k.parent && k.parent.provides;
+    n === s && (s = k.provides = Object.create(n)), s[e] = t;
+  }
+}
+function At(e, t, s = !1) {
+  const n = k || be;
+  if (n || Ye) {
+    let r = Ye ? Ye._context.provides : n ? n.parent == null || n.ce ? n.vnode.appContext && n.vnode.appContext.provides : n.parent.provides : void 0;
+    if (r && e in r)
+      return r[e];
+    if (arguments.length > 1)
+      return s && I(t) ? t.call(n && n.proxy) : t;
+  }
+}
+const kn = {}, er = () => Object.create(kn), tr = (e) => Object.getPrototypeOf(e) === kn;
+function qi(e, t, s, n = !1) {
+  const r = {}, i = er();
+  e.propsDefaults = /* @__PURE__ */ Object.create(null), sr(e, t, r, i);
+  for (const o in e.propsOptions[0])
+    o in r || (r[o] = void 0);
+  s ? e.props = n ? r : fi(r) : e.type.props ? e.props = r : e.props = i, e.attrs = i;
+}
+function Gi(e, t, s, n) {
+  const {
+    props: r,
+    attrs: i,
+    vnode: { patchFlag: o }
+  } = e, f = j(r), [u] = 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 S = a[p];
+        if (Bt(e.emitsOptions, S))
+          continue;
+        const T = t[S];
+        if (u)
+          if (D(i, S))
+            T !== i[S] && (i[S] = T, h = !0);
+          else {
+            const F = He(S);
+            r[F] = ps(
+              u,
+              f,
+              F,
+              T,
+              e,
+              !1
+            );
+          }
+        else
+          T !== i[S] && (i[S] = T, h = !0);
+      }
+    }
+  } else {
+    sr(e, t, r, i) && (h = !0);
+    let a;
+    for (const p in f)
+      (!t || // for camelCase
+      !D(t, p) && // it's possible the original props was passed in as kebab-case
+      // and converted to camelCase (#955)
+      ((a = Be(p)) === p || !D(t, a))) && (u ? s && // for camelCase
+      (s[p] !== void 0 || // for kebab-case
+      s[a] !== void 0) && (r[p] = ps(
+        u,
+        f,
+        p,
+        void 0,
+        e,
+        !0
+      )) : delete r[p]);
+    if (i !== f)
+      for (const p in i)
+        (!t || !D(t, p)) && (delete i[p], h = !0);
+  }
+  h && Ce(e.attrs, "set", "");
+}
+function sr(e, t, s, n) {
+  const [r, i] = e.propsOptions;
+  let o = !1, f;
+  if (t)
+    for (let u in t) {
+      if (ft(u))
+        continue;
+      const h = t[u];
+      let a;
+      r && D(r, a = He(u)) ? !i || !i.includes(a) ? s[a] = h : (f || (f = {}))[a] = h : Bt(e.emitsOptions, u) || (!(u in n) || h !== n[u]) && (n[u] = h, o = !0);
+    }
+  if (i) {
+    const u = j(s), h = f || V;
+    for (let a = 0; a < i.length; a++) {
+      const p = i[a];
+      s[p] = ps(
+        r,
+        u,
+        p,
+        h[p],
+        e,
+        !D(h, p)
+      );
+    }
+  }
+  return o;
+}
+function ps(e, t, s, n, r, i) {
+  const o = e[s];
+  if (o != null) {
+    const f = D(o, "default");
+    if (f && n === void 0) {
+      const u = o.default;
+      if (o.type !== Function && !o.skipFactory && I(u)) {
+        const { propsDefaults: h } = r;
+        if (s in h)
+          n = h[s];
+        else {
+          const a = vt(r);
+          n = h[s] = u.call(
+            null,
+            t
+          ), a();
+        }
+      } else
+        n = u;
+      r.ce && r.ce._setProp(s, n);
+    }
+    o[
+      0
+      /* shouldCast */
+    ] && (i && !f ? n = !1 : o[
+      1
+      /* shouldCastTrue */
+    ] && (n === "" || n === Be(s)) && (n = !0));
+  }
+  return n;
+}
+const Ji = /* @__PURE__ */ new WeakMap();
+function nr(e, t, s = !1) {
+  const n = s ? Ji : t.propsCache, r = n.get(e);
+  if (r)
+    return r;
+  const i = e.props, o = {}, f = [];
+  let u = !1;
+  if (!I(e)) {
+    const a = (p) => {
+      u = !0;
+      const [S, T] = nr(p, t, !0);
+      te(o, S), T && f.push(...T);
+    };
+    !s && t.mixins.length && t.mixins.forEach(a), e.extends && a(e.extends), e.mixins && e.mixins.forEach(a);
+  }
+  if (!i && !u)
+    return q(e) && n.set(e, ot), ot;
+  if (A(i))
+    for (let a = 0; a < i.length; a++) {
+      const p = He(i[a]);
+      ks(p) && (o[p] = V);
+    }
+  else if (i)
+    for (const a in i) {
+      const p = He(a);
+      if (ks(p)) {
+        const S = i[a], T = o[p] = A(S) || I(S) ? { type: S } : te({}, S), F = T.type;
+        let M = !1, Y = !0;
+        if (A(F))
+          for (let N = 0; N < F.length; ++N) {
+            const W = F[N], B = I(W) && W.name;
+            if (B === "Boolean") {
+              M = !0;
+              break;
+            } else B === "String" && (Y = !1);
+          }
+        else
+          M = I(F) && F.name === "Boolean";
+        T[
+          0
+          /* shouldCast */
+        ] = M, T[
+          1
+          /* shouldCastTrue */
+        ] = Y, (M || D(T, "default")) && f.push(p);
+      }
+    }
+  const h = [o, f];
+  return q(e) && n.set(e, h), h;
+}
+function ks(e) {
+  return e[0] !== "$" && !ft(e);
+}
+const Ds = (e) => e[0] === "_" || e === "$stable", Hs = (e) => A(e) ? e.map(me) : [me(e)], Yi = (e, t, s) => {
+  if (t._n)
+    return t;
+  const n = vi((...r) => Hs(t(...r)), s);
+  return n._c = !1, n;
+}, rr = (e, t, s) => {
+  const n = e._ctx;
+  for (const r in e) {
+    if (Ds(r)) continue;
+    const i = e[r];
+    if (I(i))
+      t[r] = Yi(r, i, n);
+    else if (i != null) {
+      const o = Hs(i);
+      t[r] = () => o;
+    }
+  }
+}, ir = (e, t) => {
+  const s = Hs(t);
+  e.slots.default = () => s;
+}, or = (e, t, s) => {
+  for (const n in t)
+    (s || !Ds(n)) && (e[n] = t[n]);
+}, zi = (e, t, s) => {
+  const n = e.slots = er();
+  if (e.vnode.shapeFlag & 32) {
+    const r = t.__;
+    r && is(n, "__", r, !0);
+    const i = t._;
+    i ? (or(n, t, s), s && is(n, "_", i, !0)) : rr(t, n);
+  } else t && ir(e, t);
+}, Xi = (e, t, s) => {
+  const { vnode: n, slots: r } = e;
+  let i = !0, o = V;
+  if (n.shapeFlag & 32) {
+    const f = t._;
+    f ? s && f === 1 ? i = !1 : or(r, t, s) : (i = !t.$stable, rr(t, r)), o = t;
+  } else t && (ir(e, t), o = { default: 1 });
+  if (i)
+    for (const f in r)
+      !Ds(f) && o[f] == null && delete r[f];
+}, oe = uo;
+function Zi(e) {
+  return Qi(e);
+}
+function Qi(e, t) {
+  const s = Vt();
+  s.__VUE__ = !0;
+  const {
+    insert: n,
+    remove: r,
+    patchProp: i,
+    createElement: o,
+    createText: f,
+    createComment: u,
+    setText: h,
+    setElementText: a,
+    parentNode: p,
+    nextSibling: S,
+    setScopeId: T = xe,
+    insertStaticContent: F
+  } = e, M = (l, c, d, m = null, g = null, _ = null, y = void 0, v = null, x = !!c.dynamicChildren) => {
+    if (l === c)
+      return;
+    l && !rt(l, c) && (m = Ct(l), ae(l, g, _, !0), l = null), c.patchFlag === -2 && (x = !1, c.dynamicChildren = null);
+    const { type: b, ref: E, shapeFlag: w } = c;
+    switch (b) {
+      case qt:
+        Y(l, c, d, m);
+        break;
+      case Xe:
+        N(l, c, d, m);
+        break;
+      case ss:
+        l == null && W(c, d, m, y);
+        break;
+      case Te:
+        wt(
+          l,
+          c,
+          d,
+          m,
+          g,
+          _,
+          y,
+          v,
+          x
+        );
+        break;
+      default:
+        w & 1 ? G(
+          l,
+          c,
+          d,
+          m,
+          g,
+          _,
+          y,
+          v,
+          x
+        ) : w & 6 ? St(
+          l,
+          c,
+          d,
+          m,
+          g,
+          _,
+          y,
+          v,
+          x
+        ) : (w & 64 || w & 128) && b.process(
+          l,
+          c,
+          d,
+          m,
+          g,
+          _,
+          y,
+          v,
+          x,
+          tt
+        );
+    }
+    E != null && g ? dt(E, l && l.ref, _, c || l, !c) : E == null && l && l.ref != null && dt(l.ref, null, _, l, !0);
+  }, Y = (l, c, d, m) => {
+    if (l == null)
+      n(
+        c.el = f(c.children),
+        d,
+        m
+      );
+    else {
+      const g = c.el = l.el;
+      c.children !== l.children && h(g, c.children);
+    }
+  }, N = (l, c, d, m) => {
+    l == null ? n(
+      c.el = u(c.children || ""),
+      d,
+      m
+    ) : c.el = l.el;
+  }, W = (l, c, d, m) => {
+    [l.el, l.anchor] = F(
+      l.children,
+      c,
+      d,
+      m,
+      l.el,
+      l.anchor
+    );
+  }, B = ({ el: l, anchor: c }, d, m) => {
+    let g;
+    for (; l && l !== c; )
+      g = S(l), n(l, d, m), l = g;
+    n(c, d, m);
+  }, O = ({ el: l, anchor: c }) => {
+    let d;
+    for (; l && l !== c; )
+      d = S(l), r(l), l = d;
+    r(c);
+  }, G = (l, c, d, m, g, _, y, v, x) => {
+    c.type === "svg" ? y = "svg" : c.type === "math" && (y = "mathml"), l == null ? Ae(
+      c,
+      d,
+      m,
+      g,
+      _,
+      y,
+      v,
+      x
+    ) : yt(
+      l,
+      c,
+      g,
+      _,
+      y,
+      v,
+      x
+    );
+  }, Ae = (l, c, d, m, g, _, y, v) => {
+    let x, b;
+    const { props: E, shapeFlag: w, transition: C, dirs: P } = l;
+    if (x = l.el = o(
+      l.type,
+      _,
+      E && E.is,
+      E
+    ), w & 8 ? a(x, l.children) : w & 16 && Ie(
+      l.children,
+      x,
+      null,
+      m,
+      g,
+      es(l, _),
+      y,
+      v
+    ), P && $e(l, null, m, "created"), ue(x, l, l.scopeId, y, m), E) {
+      for (const $ in E)
+        $ !== "value" && !ft($) && i(x, $, null, E[$], _, m);
+      "value" in E && i(x, "value", null, E.value, _), (b = E.onVnodeBeforeMount) && ge(b, m, l);
+    }
+    P && $e(l, null, m, "beforeMount");
+    const R = ki(g, C);
+    R && C.beforeEnter(x), n(x, c, d), ((b = E && E.onVnodeMounted) || R || P) && oe(() => {
+      b && ge(b, m, l), R && C.enter(x), P && $e(l, null, m, "mounted");
+    }, g);
+  }, ue = (l, c, d, m, g) => {
+    if (d && T(l, d), m)
+      for (let _ = 0; _ < m.length; _++)
+        T(l, m[_]);
+    if (g) {
+      let _ = g.subTree;
+      if (c === _ || dr(_.type) && (_.ssContent === c || _.ssFallback === c)) {
+        const y = g.vnode;
+        ue(
+          l,
+          y,
+          y.scopeId,
+          y.slotScopeIds,
+          g.parent
+        );
+      }
+    }
+  }, Ie = (l, c, d, m, g, _, y, v, x = 0) => {
+    for (let b = x; b < l.length; b++) {
+      const E = l[b] = v ? Me(l[b]) : me(l[b]);
+      M(
+        null,
+        E,
+        c,
+        d,
+        m,
+        g,
+        _,
+        y,
+        v
+      );
+    }
+  }, yt = (l, c, d, m, g, _, y) => {
+    const v = c.el = l.el;
+    let { patchFlag: x, dynamicChildren: b, dirs: E } = c;
+    x |= l.patchFlag & 16;
+    const w = l.props || V, C = c.props || V;
+    let P;
+    if (d && Ue(d, !1), (P = C.onVnodeBeforeUpdate) && ge(P, d, c, l), E && $e(c, l, d, "beforeUpdate"), d && Ue(d, !0), (w.innerHTML && C.innerHTML == null || w.textContent && C.textContent == null) && a(v, ""), b ? je(
+      l.dynamicChildren,
+      b,
+      v,
+      d,
+      m,
+      es(c, g),
+      _
+    ) : y || L(
+      l,
+      c,
+      v,
+      null,
+      d,
+      m,
+      es(c, g),
+      _,
+      !1
+    ), x > 0) {
+      if (x & 16)
+        ke(v, w, C, d, g);
+      else if (x & 2 && w.class !== C.class && i(v, "class", null, C.class, g), x & 4 && i(v, "style", w.style, C.style, g), x & 8) {
+        const R = c.dynamicProps;
+        for (let $ = 0; $ < R.length; $++) {
+          const H = R[$], se = w[H], ne = C[H];
+          (ne !== se || H === "value") && i(v, H, se, ne, g, d);
+        }
+      }
+      x & 1 && l.children !== c.children && a(v, c.children);
+    } else !y && b == null && ke(v, w, C, d, g);
+    ((P = C.onVnodeUpdated) || E) && oe(() => {
+      P && ge(P, d, c, l), E && $e(c, l, d, "updated");
+    }, m);
+  }, je = (l, c, d, m, g, _, y) => {
+    for (let v = 0; v < c.length; v++) {
+      const x = l[v], b = c[v], E = (
+        // oldVNode may be an errored async setup() component inside Suspense
+        // which will not have a mounted element
+        x.el && // - In the case of a Fragment, we need to provide the actual parent
+        // of the Fragment itself so it can move its children.
+        (x.type === Te || // - In the case of different nodes, there is going to be a replacement
+        // which also requires the correct parent container
+        !rt(x, b) || // - In the case of a component, it could contain anything.
+        x.shapeFlag & 198) ? p(x.el) : (
+          // 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
+        )
+      );
+      M(
+        x,
+        b,
+        E,
+        null,
+        m,
+        g,
+        _,
+        y,
+        !0
+      );
+    }
+  }, ke = (l, c, d, m, g) => {
+    if (c !== d) {
+      if (c !== V)
+        for (const _ in c)
+          !ft(_) && !(_ in d) && i(
+            l,
+            _,
+            c[_],
+            null,
+            g,
+            m
+          );
+      for (const _ in d) {
+        if (ft(_)) continue;
+        const y = d[_], v = c[_];
+        y !== v && _ !== "value" && i(l, _, v, y, g, m);
+      }
+      "value" in d && i(l, "value", c.value, d.value, g);
+    }
+  }, wt = (l, c, d, m, g, _, y, v, x) => {
+    const b = c.el = l ? l.el : f(""), E = c.anchor = l ? l.anchor : f("");
+    let { patchFlag: w, dynamicChildren: C, slotScopeIds: P } = c;
+    P && (v = v ? v.concat(P) : P), l == null ? (n(b, d, m), n(E, d, m), Ie(
+      // #10007
+      // such fragment like `<></>` will be compiled into
+      // a fragment which doesn't have a children.
+      // In this case fallback to an empty array
+      c.children || [],
+      d,
+      E,
+      g,
+      _,
+      y,
+      v,
+      x
+    )) : w > 0 && w & 64 && C && // #2715 the previous fragment could've been a BAILed one as a result
+    // of renderSlot() with no valid children
+    l.dynamicChildren ? (je(
+      l.dynamicChildren,
+      C,
+      d,
+      g,
+      _,
+      y,
+      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.
+    (c.key != null || g && c === g.subTree) && lr(
+      l,
+      c,
+      !0
+      /* shallow */
+    )) : L(
+      l,
+      c,
+      d,
+      E,
+      g,
+      _,
+      y,
+      v,
+      x
+    );
+  }, St = (l, c, d, m, g, _, y, v, x) => {
+    c.slotScopeIds = v, l == null ? c.shapeFlag & 512 ? g.ctx.activate(
+      c,
+      d,
+      m,
+      y,
+      x
+    ) : Gt(
+      c,
+      d,
+      m,
+      g,
+      _,
+      y,
+      x
+    ) : $s(l, c, x);
+  }, Gt = (l, c, d, m, g, _, y) => {
+    const v = l.component = xo(
+      l,
+      m,
+      g
+    );
+    if (Jn(l) && (v.ctx.renderer = tt), vo(v, !1, y), v.asyncDep) {
+      if (g && g.registerDep(v, X, y), !l.el) {
+        const x = v.subTree = fe(Xe);
+        N(null, x, c, d);
+      }
+    } else
+      X(
+        v,
+        l,
+        c,
+        d,
+        g,
+        _,
+        y
+      );
+  }, $s = (l, c, d) => {
+    const m = c.component = l.component;
+    if (fo(l, c, d))
+      if (m.asyncDep && !m.asyncResolved) {
+        K(m, c, d);
+        return;
+      } else
+        m.next = c, m.update();
+    else
+      c.el = l.el, m.vnode = c;
+  }, X = (l, c, d, m, g, _, y) => {
+    const v = () => {
+      if (l.isMounted) {
+        let { next: w, bu: C, u: P, parent: R, vnode: $ } = l;
+        {
+          const he = fr(l);
+          if (he) {
+            w && (w.el = $.el, K(l, w, y)), he.asyncDep.then(() => {
+              l.isUnmounted || v();
+            });
+            return;
+          }
+        }
+        let H = w, se;
+        Ue(l, !1), w ? (w.el = $.el, K(l, w, y)) : w = $, C && zt(C), (se = w.props && w.props.onVnodeBeforeUpdate) && ge(se, R, w, $), Ue(l, !0);
+        const ne = tn(l), de = l.subTree;
+        l.subTree = ne, M(
+          de,
+          ne,
+          // parent may have changed if it's in a teleport
+          p(de.el),
+          // anchor may have changed if it's in a fragment
+          Ct(de),
+          l,
+          g,
+          _
+        ), w.el = ne.el, H === null && co(l, ne.el), P && oe(P, g), (se = w.props && w.props.onVnodeUpdated) && oe(
+          () => ge(se, R, w, $),
+          g
+        );
+      } else {
+        let w;
+        const { el: C, props: P } = c, { bm: R, m: $, parent: H, root: se, type: ne } = l, de = ht(c);
+        Ue(l, !1), R && zt(R), !de && (w = P && P.onVnodeBeforeMount) && ge(w, H, c), Ue(l, !0);
+        {
+          se.ce && // @ts-expect-error _def is private
+          se.ce._def.shadowRoot !== !1 && se.ce._injectChildStyle(ne);
+          const he = l.subTree = tn(l);
+          M(
+            null,
+            he,
+            d,
+            m,
+            l,
+            g,
+            _
+          ), c.el = he.el;
+        }
+        if ($ && oe($, g), !de && (w = P && P.onVnodeMounted)) {
+          const he = c;
+          oe(
+            () => ge(w, H, he),
+            g
+          );
+        }
+        (c.shapeFlag & 256 || H && ht(H.vnode) && H.vnode.shapeFlag & 256) && l.a && oe(l.a, g), l.isMounted = !0, c = d = m = null;
+      }
+    };
+    l.scope.on();
+    const x = l.effect = new Tn(v);
+    l.scope.off();
+    const b = l.update = x.run.bind(x), E = l.job = x.runIfDirty.bind(x);
+    E.i = l, E.id = l.uid, x.scheduler = () => Ms(E), Ue(l, !0), b();
+  }, K = (l, c, d) => {
+    c.component = l;
+    const m = l.vnode.props;
+    l.vnode = c, l.next = null, Gi(l, c.props, m, d), Xi(l, c.children, d), Ee(), Ys(l), Oe();
+  }, L = (l, c, d, m, g, _, y, v, x = !1) => {
+    const b = l && l.children, E = l ? l.shapeFlag : 0, w = c.children, { patchFlag: C, shapeFlag: P } = c;
+    if (C > 0) {
+      if (C & 128) {
+        Tt(
+          b,
+          w,
+          d,
+          m,
+          g,
+          _,
+          y,
+          v,
+          x
+        );
+        return;
+      } else if (C & 256) {
+        Ne(
+          b,
+          w,
+          d,
+          m,
+          g,
+          _,
+          y,
+          v,
+          x
+        );
+        return;
+      }
+    }
+    P & 8 ? (E & 16 && et(b, g, _), w !== b && a(d, w)) : E & 16 ? P & 16 ? Tt(
+      b,
+      w,
+      d,
+      m,
+      g,
+      _,
+      y,
+      v,
+      x
+    ) : et(b, g, _, !0) : (E & 8 && a(d, ""), P & 16 && Ie(
+      w,
+      d,
+      m,
+      g,
+      _,
+      y,
+      v,
+      x
+    ));
+  }, Ne = (l, c, d, m, g, _, y, v, x) => {
+    l = l || ot, c = c || ot;
+    const b = l.length, E = c.length, w = Math.min(b, E);
+    let C;
+    for (C = 0; C < w; C++) {
+      const P = c[C] = x ? Me(c[C]) : me(c[C]);
+      M(
+        l[C],
+        P,
+        d,
+        null,
+        g,
+        _,
+        y,
+        v,
+        x
+      );
+    }
+    b > E ? et(
+      l,
+      g,
+      _,
+      !0,
+      !1,
+      w
+    ) : Ie(
+      c,
+      d,
+      m,
+      g,
+      _,
+      y,
+      v,
+      x,
+      w
+    );
+  }, Tt = (l, c, d, m, g, _, y, v, x) => {
+    let b = 0;
+    const E = c.length;
+    let w = l.length - 1, C = E - 1;
+    for (; b <= w && b <= C; ) {
+      const P = l[b], R = c[b] = x ? Me(c[b]) : me(c[b]);
+      if (rt(P, R))
+        M(
+          P,
+          R,
+          d,
+          null,
+          g,
+          _,
+          y,
+          v,
+          x
+        );
+      else
+        break;
+      b++;
+    }
+    for (; b <= w && b <= C; ) {
+      const P = l[w], R = c[C] = x ? Me(c[C]) : me(c[C]);
+      if (rt(P, R))
+        M(
+          P,
+          R,
+          d,
+          null,
+          g,
+          _,
+          y,
+          v,
+          x
+        );
+      else
+        break;
+      w--, C--;
+    }
+    if (b > w) {
+      if (b <= C) {
+        const P = C + 1, R = P < E ? c[P].el : m;
+        for (; b <= C; )
+          M(
+            null,
+            c[b] = x ? Me(c[b]) : me(c[b]),
+            d,
+            R,
+            g,
+            _,
+            y,
+            v,
+            x
+          ), b++;
+      }
+    } else if (b > C)
+      for (; b <= w; )
+        ae(l[b], g, _, !0), b++;
+    else {
+      const P = b, R = b, $ = /* @__PURE__ */ new Map();
+      for (b = R; b <= C; b++) {
+        const ie = c[b] = x ? Me(c[b]) : me(c[b]);
+        ie.key != null && $.set(ie.key, b);
+      }
+      let H, se = 0;
+      const ne = C - R + 1;
+      let de = !1, he = 0;
+      const st = new Array(ne);
+      for (b = 0; b < ne; b++) st[b] = 0;
+      for (b = P; b <= w; b++) {
+        const ie = l[b];
+        if (se >= ne) {
+          ae(ie, g, _, !0);
+          continue;
+        }
+        let pe;
+        if (ie.key != null)
+          pe = $.get(ie.key);
+        else
+          for (H = R; H <= C; H++)
+            if (st[H - R] === 0 && rt(ie, c[H])) {
+              pe = H;
+              break;
+            }
+        pe === void 0 ? ae(ie, g, _, !0) : (st[pe - R] = b + 1, pe >= he ? he = pe : de = !0, M(
+          ie,
+          c[pe],
+          d,
+          null,
+          g,
+          _,
+          y,
+          v,
+          x
+        ), se++);
+      }
+      const Ks = de ? eo(st) : ot;
+      for (H = Ks.length - 1, b = ne - 1; b >= 0; b--) {
+        const ie = R + b, pe = c[ie], Ws = ie + 1 < E ? c[ie + 1].el : m;
+        st[b] === 0 ? M(
+          null,
+          pe,
+          d,
+          Ws,
+          g,
+          _,
+          y,
+          v,
+          x
+        ) : de && (H < 0 || b !== Ks[H] ? Le(pe, d, Ws, 2) : H--);
+      }
+    }
+  }, Le = (l, c, d, m, g = null) => {
+    const { el: _, type: y, transition: v, children: x, shapeFlag: b } = l;
+    if (b & 6) {
+      Le(l.component.subTree, c, d, m);
+      return;
+    }
+    if (b & 128) {
+      l.suspense.move(c, d, m);
+      return;
+    }
+    if (b & 64) {
+      y.move(l, c, d, tt);
+      return;
+    }
+    if (y === Te) {
+      n(_, c, d);
+      for (let w = 0; w < x.length; w++)
+        Le(x[w], c, d, m);
+      n(l.anchor, c, d);
+      return;
+    }
+    if (y === ss) {
+      B(l, c, d);
+      return;
+    }
+    if (m !== 2 && b & 1 && v)
+      if (m === 0)
+        v.beforeEnter(_), n(_, c, d), oe(() => v.enter(_), g);
+      else {
+        const { leave: w, delayLeave: C, afterLeave: P } = v, R = () => {
+          l.ctx.isUnmounted ? r(_) : n(_, c, d);
+        }, $ = () => {
+          w(_, () => {
+            R(), P && P();
+          });
+        };
+        C ? C(_, R, $) : $();
+      }
+    else
+      n(_, c, d);
+  }, ae = (l, c, d, m = !1, g = !1) => {
+    const {
+      type: _,
+      props: y,
+      ref: v,
+      children: x,
+      dynamicChildren: b,
+      shapeFlag: E,
+      patchFlag: w,
+      dirs: C,
+      cacheIndex: P
+    } = l;
+    if (w === -2 && (g = !1), v != null && (Ee(), dt(v, null, d, l, !0), Oe()), P != null && (c.renderCache[P] = void 0), E & 256) {
+      c.ctx.deactivate(l);
+      return;
+    }
+    const R = E & 1 && C, $ = !ht(l);
+    let H;
+    if ($ && (H = y && y.onVnodeBeforeUnmount) && ge(H, c, l), E & 6)
+      br(l.component, d, m);
+    else {
+      if (E & 128) {
+        l.suspense.unmount(d, m);
+        return;
+      }
+      R && $e(l, null, c, "beforeUnmount"), E & 64 ? l.type.remove(
+        l,
+        c,
+        d,
+        tt,
+        m
+      ) : 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.
+      !b.hasOnce && // #1153: fast path should not be taken for non-stable (v-for) fragments
+      (_ !== Te || w > 0 && w & 64) ? et(
+        b,
+        c,
+        d,
+        !1,
+        !0
+      ) : (_ === Te && w & 384 || !g && E & 16) && et(x, c, d), m && Us(l);
+    }
+    ($ && (H = y && y.onVnodeUnmounted) || R) && oe(() => {
+      H && ge(H, c, l), R && $e(l, null, c, "unmounted");
+    }, d);
+  }, Us = (l) => {
+    const { type: c, el: d, anchor: m, transition: g } = l;
+    if (c === Te) {
+      mr(d, m);
+      return;
+    }
+    if (c === ss) {
+      O(l);
+      return;
+    }
+    const _ = () => {
+      r(d), g && !g.persisted && g.afterLeave && g.afterLeave();
+    };
+    if (l.shapeFlag & 1 && g && !g.persisted) {
+      const { leave: y, delayLeave: v } = g, x = () => y(d, _);
+      v ? v(l.el, _, x) : x();
+    } else
+      _();
+  }, mr = (l, c) => {
+    let d;
+    for (; l !== c; )
+      d = S(l), r(l), l = d;
+    r(c);
+  }, br = (l, c, d) => {
+    const {
+      bum: m,
+      scope: g,
+      job: _,
+      subTree: y,
+      um: v,
+      m: x,
+      a: b,
+      parent: E,
+      slots: { __: w }
+    } = l;
+    en(x), en(b), m && zt(m), E && A(w) && w.forEach((C) => {
+      E.renderCache[C] = void 0;
+    }), g.stop(), _ && (_.flags |= 8, ae(y, l, c, d)), v && oe(v, c), oe(() => {
+      l.isUnmounted = !0;
+    }, c), c && c.pendingBranch && !c.isUnmounted && l.asyncDep && !l.asyncResolved && l.suspenseId === c.pendingId && (c.deps--, c.deps === 0 && c.resolve());
+  }, et = (l, c, d, m = !1, g = !1, _ = 0) => {
+    for (let y = _; y < l.length; y++)
+      ae(l[y], c, d, m, g);
+  }, Ct = (l) => {
+    if (l.shapeFlag & 6)
+      return Ct(l.component.subTree);
+    if (l.shapeFlag & 128)
+      return l.suspense.next();
+    const c = S(l.anchor || l.el), d = c && c[yi];
+    return d ? S(d) : c;
+  };
+  let Jt = !1;
+  const Vs = (l, c, d) => {
+    l == null ? c._vnode && ae(c._vnode, null, null, !0) : M(
+      c._vnode || null,
+      l,
+      c,
+      null,
+      null,
+      null,
+      d
+    ), c._vnode = l, Jt || (Jt = !0, Ys(), Wn(), Jt = !1);
+  }, tt = {
+    p: M,
+    um: ae,
+    m: Le,
+    r: Us,
+    mt: Gt,
+    mc: Ie,
+    pc: L,
+    pbc: je,
+    n: Ct,
+    o: e
+  };
+  return {
+    render: Vs,
+    hydrate: void 0,
+    createApp: Wi(Vs)
+  };
+}
+function es({ 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 Ue({ effect: e, job: t }, s) {
+  s ? (e.flags |= 32, t.flags |= 4) : (e.flags &= -33, t.flags &= -5);
+}
+function ki(e, t) {
+  return (!e || e && !e.pendingBranch) && t && !t.persisted;
+}
+function lr(e, t, s = !1) {
+  const n = e.children, r = t.children;
+  if (A(n) && A(r))
+    for (let i = 0; i < n.length; i++) {
+      const o = n[i];
+      let f = r[i];
+      f.shapeFlag & 1 && !f.dynamicChildren && ((f.patchFlag <= 0 || f.patchFlag === 32) && (f = r[i] = Me(r[i]), f.el = o.el), !s && f.patchFlag !== -2 && lr(o, f)), f.type === qt && (f.el = o.el), f.type === Xe && !f.el && (f.el = o.el);
+    }
+}
+function eo(e) {
+  const t = e.slice(), s = [0];
+  let n, r, i, o, f;
+  const u = e.length;
+  for (n = 0; n < u; n++) {
+    const h = e[n];
+    if (h !== 0) {
+      if (r = s[s.length - 1], e[r] < h) {
+        t[n] = r, s.push(n);
+        continue;
+      }
+      for (i = 0, o = s.length - 1; i < o; )
+        f = i + o >> 1, e[s[f]] < h ? i = f + 1 : o = f;
+      h < e[s[i]] && (i > 0 && (t[n] = s[i - 1]), s[i] = n);
+    }
+  }
+  for (i = s.length, o = s[i - 1]; i-- > 0; )
+    s[i] = o, o = t[o];
+  return s;
+}
+function fr(e) {
+  const t = e.subTree.component;
+  if (t)
+    return t.asyncDep && !t.asyncResolved ? t : fr(t);
+}
+function en(e) {
+  if (e)
+    for (let t = 0; t < e.length; t++)
+      e[t].flags |= 8;
+}
+const to = Symbol.for("v-scx"), so = () => At(to);
+function ts(e, t, s) {
+  return cr(e, t, s);
+}
+function cr(e, t, s = V) {
+  const { immediate: n, deep: r, flush: i, once: o } = s, f = te({}, s), u = t && n || !t && i !== "post";
+  let h;
+  if (bt) {
+    if (i === "sync") {
+      const T = so();
+      h = T.__watcherHandles || (T.__watcherHandles = []);
+    } else if (!u) {
+      const T = () => {
+      };
+      return T.stop = xe, T.resume = xe, T.pause = xe, T;
+    }
+  }
+  const a = k;
+  f.call = (T, F, M) => ye(T, a, F, M);
+  let p = !1;
+  i === "post" ? f.scheduler = (T) => {
+    oe(T, a && a.suspense);
+  } : i !== "sync" && (p = !0, f.scheduler = (T, F) => {
+    F ? T() : Ms(T);
+  }), f.augmentJob = (T) => {
+    t && (T.flags |= 4), p && (T.flags |= 2, a && (T.id = a.uid, T.i = a));
+  };
+  const S = gi(e, t, f);
+  return bt && (h ? h.push(S) : u && S()), S;
+}
+function no(e, t, s) {
+  const n = this.proxy, r = J(e) ? e.includes(".") ? ur(n, e) : () => n[e] : e.bind(n, n);
+  let i;
+  I(t) ? i = t : (i = t.handler, s = t);
+  const o = vt(this), f = cr(r, i.bind(n), s);
+  return o(), f;
+}
+function ur(e, t) {
+  const s = t.split(".");
+  return () => {
+    let n = e;
+    for (let r = 0; r < s.length && n; r++)
+      n = n[s[r]];
+    return n;
+  };
+}
+const ro = (e, t) => t === "modelValue" || t === "model-value" ? e.modelModifiers : e[`${t}Modifiers`] || e[`${He(t)}Modifiers`] || e[`${Be(t)}Modifiers`];
+function io(e, t, ...s) {
+  if (e.isUnmounted) return;
+  const n = e.vnode.props || V;
+  let r = s;
+  const i = t.startsWith("update:"), o = i && ro(n, t.slice(7));
+  o && (o.trim && (r = s.map((a) => J(a) ? a.trim() : a)), o.number && (r = s.map(Hr)));
+  let f, u = n[f = Yt(t)] || // also try camelCase event handler (#2249)
+  n[f = Yt(He(t))];
+  !u && i && (u = n[f = Yt(Be(t))]), u && ye(
+    u,
+    e,
+    6,
+    r
+  );
+  const h = n[f + "Once"];
+  if (h) {
+    if (!e.emitted)
+      e.emitted = {};
+    else if (e.emitted[f])
+      return;
+    e.emitted[f] = !0, ye(
+      h,
+      e,
+      6,
+      r
+    );
+  }
+}
+function ar(e, t, s = !1) {
+  const n = t.emitsCache, r = n.get(e);
+  if (r !== void 0)
+    return r;
+  const i = e.emits;
+  let o = {}, f = !1;
+  if (!I(e)) {
+    const u = (h) => {
+      const a = ar(h, t, !0);
+      a && (f = !0, te(o, a));
+    };
+    !s && t.mixins.length && t.mixins.forEach(u), e.extends && u(e.extends), e.mixins && e.mixins.forEach(u);
+  }
+  return !i && !f ? (q(e) && n.set(e, null), null) : (A(i) ? i.forEach((u) => o[u] = null) : te(o, i), q(e) && n.set(e, o), o);
+}
+function Bt(e, t) {
+  return !e || !Lt(t) ? !1 : (t = t.slice(2).replace(/Once$/, ""), D(e, t[0].toLowerCase() + t.slice(1)) || D(e, Be(t)) || D(e, t));
+}
+function tn(e) {
+  const {
+    type: t,
+    vnode: s,
+    proxy: n,
+    withProxy: r,
+    propsOptions: [i],
+    slots: o,
+    attrs: f,
+    emit: u,
+    render: h,
+    renderCache: a,
+    props: p,
+    data: S,
+    setupState: T,
+    ctx: F,
+    inheritAttrs: M
+  } = e, Y = Dt(e);
+  let N, W;
+  try {
+    if (s.shapeFlag & 4) {
+      const O = r || n, G = O;
+      N = me(
+        h.call(
+          G,
+          O,
+          a,
+          p,
+          T,
+          S,
+          F
+        )
+      ), W = f;
+    } else {
+      const O = t;
+      N = me(
+        O.length > 1 ? O(
+          p,
+          { attrs: f, slots: o, emit: u }
+        ) : O(
+          p,
+          null
+        )
+      ), W = t.props ? f : oo(f);
+    }
+  } catch (O) {
+    Kt(O, e, 1), N = fe(Xe);
+  }
+  let B = N;
+  if (W && M !== !1) {
+    const O = Object.keys(W), { shapeFlag: G } = B;
+    O.length && G & 7 && (i && O.some(xs) && (W = lo(
+      W,
+      i
+    )), B = Ze(B, W, !1, !0));
+  }
+  return s.dirs && (B = Ze(B, null, !1, !0), B.dirs = B.dirs ? B.dirs.concat(s.dirs) : s.dirs), s.transition && Fs(B, s.transition), N = B, Dt(Y), N;
+}
+const oo = (e) => {
+  let t;
+  for (const s in e)
+    (s === "class" || s === "style" || Lt(s)) && ((t || (t = {}))[s] = e[s]);
+  return t;
+}, lo = (e, t) => {
+  const s = {};
+  for (const n in e)
+    (!xs(n) || !(n.slice(9) in t)) && (s[n] = e[n]);
+  return s;
+};
+function fo(e, t, s) {
+  const { props: n, children: r, component: i } = e, { props: o, children: f, patchFlag: u } = t, h = i.emitsOptions;
+  if (t.dirs || t.transition)
+    return !0;
+  if (s && u >= 0) {
+    if (u & 1024)
+      return !0;
+    if (u & 16)
+      return n ? sn(n, o, h) : !!o;
+    if (u & 8) {
+      const a = t.dynamicProps;
+      for (let p = 0; p < a.length; p++) {
+        const S = a[p];
+        if (o[S] !== n[S] && !Bt(h, S))
+          return !0;
+      }
+    }
+  } else
+    return (r || f) && (!f || !f.$stable) ? !0 : n === o ? !1 : n ? o ? sn(n, o, h) : !0 : !!o;
+  return !1;
+}
+function sn(e, t, s) {
+  const n = Object.keys(t);
+  if (n.length !== Object.keys(e).length)
+    return !0;
+  for (let r = 0; r < n.length; r++) {
+    const i = n[r];
+    if (t[i] !== e[i] && !Bt(s, i))
+      return !0;
+  }
+  return !1;
+}
+function co({ vnode: e, parent: t }, s) {
+  for (; t; ) {
+    const n = t.subTree;
+    if (n.suspense && n.suspense.activeBranch === e && (n.el = e.el), n === e)
+      (e = t.vnode).el = s, t = t.parent;
+    else
+      break;
+  }
+}
+const dr = (e) => e.__isSuspense;
+function uo(e, t) {
+  t && t.pendingBranch ? A(e) ? t.effects.push(...e) : t.effects.push(e) : xi(e);
+}
+const Te = Symbol.for("v-fgt"), qt = Symbol.for("v-txt"), Xe = Symbol.for("v-cmt"), ss = Symbol.for("v-stc");
+let De = null, js = 1;
+function nn(e, t = !1) {
+  js += e, e < 0 && De && t && (De.hasOnce = !0);
+}
+function jt(e) {
+  return e ? e.__v_isVNode === !0 : !1;
+}
+function rt(e, t) {
+  return e.type === t.type && e.key === t.key;
+}
+const hr = ({ key: e }) => e != null ? e : null, It = ({
+  ref: e,
+  ref_key: t,
+  ref_for: s
+}) => (typeof e == "number" && (e = "" + e), e != null ? J(e) || ee(e) || I(e) ? { i: be, r: e, k: t, f: !!s } : e : null);
+function ao(e, t = null, s = null, n = 0, r = null, i = e === Te ? 0 : 1, o = !1, f = !1) {
+  const u = {
+    __v_isVNode: !0,
+    __v_skip: !0,
+    type: e,
+    props: t,
+    key: t && hr(t),
+    ref: t && It(t),
+    scopeId: qn,
+    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: i,
+    patchFlag: n,
+    dynamicProps: r,
+    dynamicChildren: null,
+    appContext: null,
+    ctx: be
+  };
+  return f ? (Ns(u, s), i & 128 && e.normalize(u)) : s && (u.shapeFlag |= J(s) ? 8 : 16), js > 0 && // avoid a block node from tracking itself
+  !o && // has current parent block
+  De && // 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.
+  (u.patchFlag > 0 || i & 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.
+  u.patchFlag !== 32 && De.push(u), u;
+}
+const fe = ho;
+function ho(e, t = null, s = null, n = 0, r = null, i = !1) {
+  if ((!e || e === Hi) && (e = Xe), jt(e)) {
+    const f = Ze(
+      e,
+      t,
+      !0
+      /* mergeRef: true */
+    );
+    return s && Ns(f, s), js > 0 && !i && De && (f.shapeFlag & 6 ? De[De.indexOf(e)] = f : De.push(f)), f.patchFlag = -2, f;
+  }
+  if (To(e) && (e = e.__vccOpts), t) {
+    t = po(t);
+    let { class: f, style: u } = t;
+    f && !J(f) && (t.class = Ss(f)), q(u) && (Rs(u) && !A(u) && (u = te({}, u)), t.style = ws(u));
+  }
+  const o = J(e) ? 1 : dr(e) ? 128 : wi(e) ? 64 : q(e) ? 4 : I(e) ? 2 : 0;
+  return ao(
+    e,
+    t,
+    s,
+    n,
+    r,
+    o,
+    i,
+    !0
+  );
+}
+function po(e) {
+  return e ? Rs(e) || tr(e) ? te({}, e) : e : null;
+}
+function Ze(e, t, s = !1, n = !1) {
+  const { props: r, ref: i, patchFlag: o, children: f, transition: u } = e, h = t ? _o(r || {}, t) : r, a = {
+    __v_isVNode: !0,
+    __v_skip: !0,
+    type: e.type,
+    props: h,
+    key: h && hr(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 && i ? A(i) ? i.concat(It(t)) : [i, It(t)] : It(t)
+    ) : i,
+    scopeId: e.scopeId,
+    slotScopeIds: e.slotScopeIds,
+    children: f,
+    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 !== Te ? o === -1 ? 16 : o | 16 : o,
+    dynamicProps: e.dynamicProps,
+    dynamicChildren: e.dynamicChildren,
+    appContext: e.appContext,
+    dirs: e.dirs,
+    transition: u,
+    // 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 && Ze(e.ssContent),
+    ssFallback: e.ssFallback && Ze(e.ssFallback),
+    el: e.el,
+    anchor: e.anchor,
+    ctx: e.ctx,
+    ce: e.ce
+  };
+  return u && n && Fs(
+    a,
+    u.clone(a)
+  ), a;
+}
+function go(e = " ", t = 0) {
+  return fe(qt, null, e, t);
+}
+function me(e) {
+  return e == null || typeof e == "boolean" ? fe(Xe) : A(e) ? fe(
+    Te,
+    null,
+    // #3666, avoid reference pollution when reusing vnode
+    e.slice()
+  ) : jt(e) ? Me(e) : fe(qt, null, String(e));
+}
+function Me(e) {
+  return e.el === null && e.patchFlag !== -1 || e.memo ? e : Ze(e);
+}
+function Ns(e, t) {
+  let s = 0;
+  const { shapeFlag: n } = e;
+  if (t == null)
+    t = null;
+  else if (A(t))
+    s = 16;
+  else if (typeof t == "object")
+    if (n & 65) {
+      const r = t.default;
+      r && (r._c && (r._d = !1), Ns(e, r()), r._c && (r._d = !0));
+      return;
+    } else {
+      s = 32;
+      const r = t._;
+      !r && !tr(t) ? t._ctx = be : r === 3 && be && (be.slots._ === 1 ? t._ = 1 : (t._ = 2, e.patchFlag |= 1024));
+    }
+  else I(t) ? (t = { default: t, _ctx: be }, s = 32) : (t = String(t), n & 64 ? (s = 16, t = [go(t)]) : s = 8);
+  e.children = t, e.shapeFlag |= s;
+}
+function _o(...e) {
+  const t = {};
+  for (let s = 0; s < e.length; s++) {
+    const n = e[s];
+    for (const r in n)
+      if (r === "class")
+        t.class !== n.class && (t.class = Ss([t.class, n.class]));
+      else if (r === "style")
+        t.style = ws([t.style, n.style]);
+      else if (Lt(r)) {
+        const i = t[r], o = n[r];
+        o && i !== o && !(A(i) && i.includes(o)) && (t[r] = i ? [].concat(i, o) : o);
+      } else r !== "" && (t[r] = n[r]);
+  }
+  return t;
+}
+function ge(e, t, s, n = null) {
+  ye(e, t, 7, [
+    s,
+    n
+  ]);
+}
+const mo = Qn();
+let bo = 0;
+function xo(e, t, s) {
+  const n = e.type, r = (t ? t.appContext : e.appContext) || mo, i = {
+    uid: bo++,
+    vnode: e,
+    type: n,
+    parent: t,
+    appContext: r,
+    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 Kr(
+      !0
+      /* detached */
+    ),
+    render: null,
+    proxy: null,
+    exposed: null,
+    exposeProxy: null,
+    withProxy: null,
+    provides: t ? t.provides : Object.create(r.provides),
+    ids: t ? t.ids : ["", 0, 0],
+    accessCache: null,
+    renderCache: [],
+    // local resolved assets
+    components: null,
+    directives: null,
+    // resolved props and emits options
+    propsOptions: nr(n, r),
+    emitsOptions: ar(n, r),
+    // emit
+    emit: null,
+    // to be set immediately
+    emitted: null,
+    // props default value
+    propsDefaults: V,
+    // inheritAttrs
+    inheritAttrs: n.inheritAttrs,
+    // state
+    ctx: V,
+    data: V,
+    props: V,
+    attrs: V,
+    slots: V,
+    refs: V,
+    setupState: V,
+    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 i.ctx = { _: i }, i.root = t ? t.root : i, i.emit = io.bind(null, i), e.ce && e.ce(i), i;
+}
+let k = null, Nt, gs;
+{
+  const e = Vt(), t = (s, n) => {
+    let r;
+    return (r = e[s]) || (r = e[s] = []), r.push(n), (i) => {
+      r.length > 1 ? r.forEach((o) => o(i)) : r[0](i);
+    };
+  };
+  Nt = t(
+    "__VUE_INSTANCE_SETTERS__",
+    (s) => k = s
+  ), gs = t(
+    "__VUE_SSR_SETTERS__",
+    (s) => bt = s
+  );
+}
+const vt = (e) => {
+  const t = k;
+  return Nt(e), e.scope.on(), () => {
+    e.scope.off(), Nt(t);
+  };
+}, rn = () => {
+  k && k.scope.off(), Nt(null);
+};
+function pr(e) {
+  return e.vnode.shapeFlag & 4;
+}
+let bt = !1;
+function vo(e, t = !1, s = !1) {
+  t && gs(t);
+  const { props: n, children: r } = e.vnode, i = pr(e);
+  qi(e, n, i, t), zi(e, r, s || t);
+  const o = i ? yo(e, t) : void 0;
+  return t && gs(!1), o;
+}
+function yo(e, t) {
+  const s = e.type;
+  e.accessCache = /* @__PURE__ */ Object.create(null), e.proxy = new Proxy(e.ctx, ji);
+  const { setup: n } = s;
+  if (n) {
+    Ee();
+    const r = e.setupContext = n.length > 1 ? So(e) : null, i = vt(e), o = xt(
+      n,
+      e,
+      0,
+      [
+        e.props,
+        r
+      ]
+    ), f = yn(o);
+    if (Oe(), i(), (f || e.sp) && !ht(e) && Gn(e), f) {
+      if (o.then(rn, rn), t)
+        return o.then((u) => {
+          on(e, u);
+        }).catch((u) => {
+          Kt(u, e, 0);
+        });
+      e.asyncDep = o;
+    } else
+      on(e, o);
+  } else
+    gr(e);
+}
+function on(e, t, s) {
+  I(t) ? e.type.__ssrInlineRender ? e.ssrRender = t : e.render = t : q(t) && (e.setupState = Un(t)), gr(e);
+}
+function gr(e, t, s) {
+  const n = e.type;
+  e.render || (e.render = n.render || xe);
+  {
+    const r = vt(e);
+    Ee();
+    try {
+      Ni(e);
+    } finally {
+      Oe(), r();
+    }
+  }
+}
+const wo = {
+  get(e, t) {
+    return z(e, "get", ""), e[t];
+  }
+};
+function So(e) {
+  const t = (s) => {
+    e.exposed = s || {};
+  };
+  return {
+    attrs: new Proxy(e.attrs, wo),
+    slots: e.slots,
+    emit: e.emit,
+    expose: t
+  };
+}
+function Ls(e) {
+  return e.exposed ? e.exposeProxy || (e.exposeProxy = new Proxy(Un(ci(e.exposed)), {
+    get(t, s) {
+      if (s in t)
+        return t[s];
+      if (s in pt)
+        return pt[s](e);
+    },
+    has(t, s) {
+      return s in t || s in pt;
+    }
+  })) : e.proxy;
+}
+function To(e) {
+  return I(e) && "__vccOpts" in e;
+}
+const Co = (e, t) => hi(e, t, bt);
+function Eo(e, t, s) {
+  const n = arguments.length;
+  return n === 2 ? q(t) && !A(t) ? jt(t) ? fe(e, null, [t]) : fe(e, t) : fe(e, null, t) : (n > 3 ? s = Array.prototype.slice.call(arguments, 2) : n === 3 && jt(s) && (s = [s]), fe(e, t, s));
+}
+const Oo = "3.5.17";
+/**
+* @vue/runtime-dom v3.5.17
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+let _s;
+const ln = typeof window < "u" && window.trustedTypes;
+if (ln)
+  try {
+    _s = /* @__PURE__ */ ln.createPolicy("vue", {
+      createHTML: (e) => e
+    });
+  } catch {
+  }
+const _r = _s ? (e) => _s.createHTML(e) : (e) => e, Po = "http://www.w3.org/2000/svg", Ao = "http://www.w3.org/1998/Math/MathML", Se = typeof document < "u" ? document : null, fn = Se && /* @__PURE__ */ Se.createElement("template"), Io = {
+  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 r = t === "svg" ? Se.createElementNS(Po, e) : t === "mathml" ? Se.createElementNS(Ao, e) : s ? Se.createElement(e, { is: s }) : Se.createElement(e);
+    return e === "select" && n && n.multiple != null && r.setAttribute("multiple", n.multiple), r;
+  },
+  createText: (e) => Se.createTextNode(e),
+  createComment: (e) => Se.createComment(e),
+  setText: (e, t) => {
+    e.nodeValue = t;
+  },
+  setElementText: (e, t) => {
+    e.textContent = t;
+  },
+  parentNode: (e) => e.parentNode,
+  nextSibling: (e) => e.nextSibling,
+  querySelector: (e) => Se.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, r, i) {
+    const o = s ? s.previousSibling : t.lastChild;
+    if (r && (r === i || r.nextSibling))
+      for (; t.insertBefore(r.cloneNode(!0), s), !(r === i || !(r = r.nextSibling)); )
+        ;
+    else {
+      fn.innerHTML = _r(
+        n === "svg" ? `<svg>${e}</svg>` : n === "mathml" ? `<math>${e}</math>` : e
+      );
+      const f = fn.content;
+      if (n === "svg" || n === "mathml") {
+        const u = f.firstChild;
+        for (; u.firstChild; )
+          f.appendChild(u.firstChild);
+        f.removeChild(u);
+      }
+      t.insertBefore(f, s);
+    }
+    return [
+      // first
+      o ? o.nextSibling : t.firstChild,
+      // last
+      s ? s.previousSibling : t.lastChild
+    ];
+  }
+}, Ro = Symbol("_vtc");
+function Mo(e, t, s) {
+  const n = e[Ro];
+  n && (t = (t ? [t, ...n] : [...n]).join(" ")), t == null ? e.removeAttribute("class") : s ? e.setAttribute("class", t) : e.className = t;
+}
+const cn = Symbol("_vod"), Fo = Symbol("_vsh"), Do = Symbol(""), Ho = /(^|;)\s*display\s*:/;
+function jo(e, t, s) {
+  const n = e.style, r = J(s);
+  let i = !1;
+  if (s && !r) {
+    if (t)
+      if (J(t))
+        for (const o of t.split(";")) {
+          const f = o.slice(0, o.indexOf(":")).trim();
+          s[f] == null && Rt(n, f, "");
+        }
+      else
+        for (const o in t)
+          s[o] == null && Rt(n, o, "");
+    for (const o in s)
+      o === "display" && (i = !0), Rt(n, o, s[o]);
+  } else if (r) {
+    if (t !== s) {
+      const o = n[Do];
+      o && (s += ";" + o), n.cssText = s, i = Ho.test(s);
+    }
+  } else t && e.removeAttribute("style");
+  cn in e && (e[cn] = i ? n.display : "", e[Fo] && (n.display = "none"));
+}
+const un = /\s*!important$/;
+function Rt(e, t, s) {
+  if (A(s))
+    s.forEach((n) => Rt(e, t, n));
+  else if (s == null && (s = ""), t.startsWith("--"))
+    e.setProperty(t, s);
+  else {
+    const n = No(e, t);
+    un.test(s) ? e.setProperty(
+      Be(n),
+      s.replace(un, ""),
+      "important"
+    ) : e[n] = s;
+  }
+}
+const an = ["Webkit", "Moz", "ms"], ns = {};
+function No(e, t) {
+  const s = ns[t];
+  if (s)
+    return s;
+  let n = He(t);
+  if (n !== "filter" && n in e)
+    return ns[t] = n;
+  n = wn(n);
+  for (let r = 0; r < an.length; r++) {
+    const i = an[r] + n;
+    if (i in e)
+      return ns[t] = i;
+  }
+  return t;
+}
+const dn = "http://www.w3.org/1999/xlink";
+function hn(e, t, s, n, r, i = Vr(t)) {
+  n && t.startsWith("xlink:") ? s == null ? e.removeAttributeNS(dn, t.slice(6, t.length)) : e.setAttributeNS(dn, t, s) : s == null || i && !Sn(s) ? e.removeAttribute(t) : e.setAttribute(
+    t,
+    i ? "" : Qe(s) ? String(s) : s
+  );
+}
+function pn(e, t, s, n, r) {
+  if (t === "innerHTML" || t === "textContent") {
+    s != null && (e[t] = t === "innerHTML" ? _r(s) : s);
+    return;
+  }
+  const i = e.tagName;
+  if (t === "value" && i !== "PROGRESS" && // custom elements may use _value internally
+  !i.includes("-")) {
+    const f = i === "OPTION" ? e.getAttribute("value") || "" : e.value, u = 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);
+    (f !== u || !("_value" in e)) && (e.value = u), s == null && e.removeAttribute(t), e._value = s;
+    return;
+  }
+  let o = !1;
+  if (s === "" || s == null) {
+    const f = typeof e[t];
+    f === "boolean" ? s = Sn(s) : s == null && f === "string" ? (s = "", o = !0) : f === "number" && (s = 0, o = !0);
+  }
+  try {
+    e[t] = s;
+  } catch {
+  }
+  o && e.removeAttribute(r || t);
+}
+function Lo(e, t, s, n) {
+  e.addEventListener(t, s, n);
+}
+function $o(e, t, s, n) {
+  e.removeEventListener(t, s, n);
+}
+const gn = Symbol("_vei");
+function Uo(e, t, s, n, r = null) {
+  const i = e[gn] || (e[gn] = {}), o = i[t];
+  if (n && o)
+    o.value = n;
+  else {
+    const [f, u] = Vo(t);
+    if (n) {
+      const h = i[t] = Bo(
+        n,
+        r
+      );
+      Lo(e, f, h, u);
+    } else o && ($o(e, f, o, u), i[t] = void 0);
+  }
+}
+const _n = /(?:Once|Passive|Capture)$/;
+function Vo(e) {
+  let t;
+  if (_n.test(e)) {
+    t = {};
+    let n;
+    for (; n = e.match(_n); )
+      e = e.slice(0, e.length - n[0].length), t[n[0].toLowerCase()] = !0;
+  }
+  return [e[2] === ":" ? e.slice(3) : Be(e.slice(2)), t];
+}
+let rs = 0;
+const Ko = /* @__PURE__ */ Promise.resolve(), Wo = () => rs || (Ko.then(() => rs = 0), rs = Date.now());
+function Bo(e, t) {
+  const s = (n) => {
+    if (!n._vts)
+      n._vts = Date.now();
+    else if (n._vts <= s.attached)
+      return;
+    ye(
+      qo(n, s.value),
+      t,
+      5,
+      [n]
+    );
+  };
+  return s.value = e, s.attached = Wo(), s;
+}
+function qo(e, t) {
+  if (A(t)) {
+    const s = e.stopImmediatePropagation;
+    return e.stopImmediatePropagation = () => {
+      s.call(e), e._stopped = !0;
+    }, t.map(
+      (n) => (r) => !r._stopped && n && n(r)
+    );
+  } else
+    return t;
+}
+const mn = (e) => e.charCodeAt(0) === 111 && e.charCodeAt(1) === 110 && // lowercase letter
+e.charCodeAt(2) > 96 && e.charCodeAt(2) < 123, Go = (e, t, s, n, r, i) => {
+  const o = r === "svg";
+  t === "class" ? Mo(e, n, o) : t === "style" ? jo(e, s, n) : Lt(t) ? xs(t) || Uo(e, t, s, n, i) : (t[0] === "." ? (t = t.slice(1), !0) : t[0] === "^" ? (t = t.slice(1), !1) : Jo(e, t, n, o)) ? (pn(e, t, n), !e.tagName.includes("-") && (t === "value" || t === "checked" || t === "selected") && hn(e, t, n, o, i, t !== "value")) : /* #11081 force set props for possible async custom element */ e._isVueCE && (/[A-Z]/.test(t) || !J(n)) ? pn(e, He(t), n, i, t) : (t === "true-value" ? e._trueValue = n : t === "false-value" && (e._falseValue = n), hn(e, t, n, o));
+};
+function Jo(e, t, s, n) {
+  if (n)
+    return !!(t === "innerHTML" || t === "textContent" || t in e && mn(t) && I(s));
+  if (t === "spellcheck" || t === "draggable" || t === "translate" || t === "autocorrect" || t === "form" || t === "list" && e.tagName === "INPUT" || t === "type" && e.tagName === "TEXTAREA")
+    return !1;
+  if (t === "width" || t === "height") {
+    const r = e.tagName;
+    if (r === "IMG" || r === "VIDEO" || r === "CANVAS" || r === "SOURCE")
+      return !1;
+  }
+  return mn(t) && J(s) ? !1 : t in e;
+}
+const Yo = /* @__PURE__ */ te({ patchProp: Go }, Io);
+let bn;
+function zo() {
+  return bn || (bn = Zi(Yo));
+}
+const Xo = (...e) => {
+  zo().render(...e);
+};
+var Zo = Object.defineProperty, Qo = Object.getOwnPropertyDescriptor, ko = (e, t, s) => t in e ? Zo(e, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : e[t] = s, el = (e, t, s, n) => {
+  for (var r = n > 1 ? void 0 : n ? Qo(t, s) : t, i = e.length - 1, o; i >= 0; i--)
+    (o = e[i]) && (r = o(r) || r);
+  return r;
+}, xn = (e, t) => (s, n) => t(s, n, e), tl = (e, t, s) => ko(e, t + "", s);
+let ms = class extends yr {
+  constructor(e = {}, t, s) {
+    super(), this._config = e, this._injector = t, this._componentManager = s;
+  }
+  onStarting() {
+    this._componentManager.setHandler("vue3", (e) => (t) => {
+      Tr(
+        vn(sl, {
+          component: e,
+          // Prevent passing undefined or null props to Vue component
+          props: Object.keys(t).filter((s) => t[s] !== void 0 && t[s] !== null).reduce((s, n) => (s[n] = t[n], s), {})
+        })
+      );
+    });
+  }
+};
+tl(ms, "pluginName", "UNIVER_UI_ADAPTER_VUE3_PLUGIN");
+ms = el([
+  xr(wr),
+  xn(1, Bs(vr)),
+  xn(2, Bs(Sr))
+], ms);
+function sl(e) {
+  const { component: t, props: s } = e, n = Cr(null);
+  return Er(() => {
+    if (!n.current) return;
+    const r = Eo(t, s), i = document.createElement("div");
+    return document.body.appendChild(i), Xo(r, n.current), () => {
+      document.body.removeChild(i);
+    };
+  }, [s]), vn("div", { ref: n });
+}
+export {
+  ms as UniverVue3AdapterPlugin
+};