st-comp 0.0.2 → 0.0.4

package/lib/bundle.js

@@ -0,0 +1,1614 @@
+function Xt(e, t) {
+  const n = /* @__PURE__ */ Object.create(null), s = e.split(",");
+  for (let r = 0; r < s.length; r++)
+    n[s[r]] = !0;
+  return t ? (r) => !!n[r.toLowerCase()] : (r) => !!n[r];
+}
+const T = process.env.NODE_ENV !== "production" ? Object.freeze({}) : {}, Zt = process.env.NODE_ENV !== "production" ? Object.freeze([]) : [], ht = () => {
+}, kt = /^on[^a-z]/, en = (e) => kt.test(e), R = Object.assign, tn = (e, t) => {
+  const n = e.indexOf(t);
+  n > -1 && e.splice(n, 1);
+}, nn = Object.prototype.hasOwnProperty, m = (e, t) => nn.call(e, t), h = Array.isArray, Y = (e) => be(e) === "[object Map]", rn = (e) => be(e) === "[object Set]", N = (e) => typeof e == "function", $ = (e) => typeof e == "string", Ae = (e) => typeof e == "symbol", S = (e) => e !== null && typeof e == "object", sn = (e) => S(e) && N(e.then) && N(e.catch), on = Object.prototype.toString, be = (e) => on.call(e), _t = (e) => be(e).slice(8, -1), cn = (e) => be(e) === "[object Object]", je = (e) => $(e) && e !== "NaN" && e[0] !== "-" && "" + parseInt(e, 10) === e, ln = (e) => {
+  const t = /* @__PURE__ */ Object.create(null);
+  return (n) => t[n] || (t[n] = e(n));
+}, un = ln(
+  (e) => e.charAt(0).toUpperCase() + e.slice(1)
+), ge = (e, t) => !Object.is(e, t), an = (e, t, n) => {
+  Object.defineProperty(e, t, {
+    configurable: !0,
+    enumerable: !1,
+    value: n
+  });
+};
+let Xe;
+const ve = () => Xe || (Xe = typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof window < "u" ? window : typeof global < "u" ? global : {});
+function ze(e) {
+  if (h(e)) {
+    const t = {};
+    for (let n = 0; n < e.length; n++) {
+      const s = e[n], r = $(s) ? hn(s) : ze(s);
+      if (r)
+        for (const o in r)
+          t[o] = r[o];
+    }
+    return t;
+  } else {
+    if ($(e))
+      return e;
+    if (S(e))
+      return e;
+  }
+}
+const fn = /;(?![^(]*\))/g, pn = /:([^]+)/, dn = /\/\*[^]*?\*\//g;
+function hn(e) {
+  const t = {};
+  return e.replace(dn, "").split(fn).forEach((n) => {
+    if (n) {
+      const s = n.split(pn);
+      s.length > 1 && (t[s[0].trim()] = s[1].trim());
+    }
+  }), t;
+}
+function Ke(e) {
+  let t = "";
+  if ($(e))
+    t = e;
+  else if (h(e))
+    for (let n = 0; n < e.length; n++) {
+      const s = Ke(e[n]);
+      s && (t += s + " ");
+    }
+  else if (S(e))
+    for (const n in e)
+      e[n] && (t += n + " ");
+  return t.trim();
+}
+function Ze(e, ...t) {
+  console.warn(`[Vue warn] ${e}`, ...t);
+}
+let gt;
+function _n(e, t = gt) {
+  t && t.active && t.effects.push(e);
+}
+function gn() {
+  return gt;
+}
+const Ie = (e) => {
+  const t = new Set(e);
+  return t.w = 0, t.n = 0, t;
+}, mt = (e) => (e.w & j) > 0, Et = (e) => (e.n & j) > 0, mn = ({ deps: e }) => {
+  if (e.length)
+    for (let t = 0; t < e.length; t++)
+      e[t].w |= j;
+}, En = (e) => {
+  const { deps: t } = e;
+  if (t.length) {
+    let n = 0;
+    for (let s = 0; s < t.length; s++) {
+      const r = t[s];
+      mt(r) && !Et(r) ? r.delete(e) : t[n++] = r, r.w &= ~j, r.n &= ~j;
+    }
+    t.length = n;
+  }
+}, Re = /* @__PURE__ */ new WeakMap();
+let k = 0, j = 1;
+const ye = 30;
+let b;
+const H = Symbol(process.env.NODE_ENV !== "production" ? "iterate" : ""), De = Symbol(process.env.NODE_ENV !== "production" ? "Map key iterate" : "");
+class wn {
+  constructor(t, n = null, s) {
+    this.fn = t, this.scheduler = n, this.active = !0, this.deps = [], this.parent = void 0, _n(this, s);
+  }
+  run() {
+    if (!this.active)
+      return this.fn();
+    let t = b, n = U;
+    for (; t; ) {
+      if (t === this)
+        return;
+      t = t.parent;
+    }
+    try {
+      return this.parent = b, b = this, U = !0, j = 1 << ++k, k <= ye ? mn(this) : ke(this), this.fn();
+    } finally {
+      k <= ye && En(this), j = 1 << --k, b = this.parent, U = n, this.parent = void 0, this.deferStop && this.stop();
+    }
+  }
+  stop() {
+    b === this ? this.deferStop = !0 : this.active && (ke(this), this.onStop && this.onStop(), this.active = !1);
+  }
+}
+function ke(e) {
+  const { deps: t } = e;
+  if (t.length) {
+    for (let n = 0; n < t.length; n++)
+      t[n].delete(e);
+    t.length = 0;
+  }
+}
+let U = !0;
+const wt = [];
+function Nt() {
+  wt.push(U), U = !1;
+}
+function bt() {
+  const e = wt.pop();
+  U = e === void 0 ? !0 : e;
+}
+function x(e, t, n) {
+  if (U && b) {
+    let s = Re.get(e);
+    s || Re.set(e, s = /* @__PURE__ */ new Map());
+    let r = s.get(n);
+    r || s.set(n, r = Ie());
+    const o = process.env.NODE_ENV !== "production" ? { effect: b, target: e, type: t, key: n } : void 0;
+    Nn(r, o);
+  }
+}
+function Nn(e, t) {
+  let n = !1;
+  k <= ye ? Et(e) || (e.n |= j, n = !mt(e)) : n = !e.has(b), n && (e.add(b), b.deps.push(e), process.env.NODE_ENV !== "production" && b.onTrack && b.onTrack(
+    R(
+      {
+        effect: b
+      },
+      t
+    )
+  ));
+}
+function z(e, t, n, s, r, o) {
+  const i = Re.get(e);
+  if (!i)
+    return;
+  let c = [];
+  if (t === "clear")
+    c = [...i.values()];
+  else if (n === "length" && h(e)) {
+    const a = Number(s);
+    i.forEach((d, l) => {
+      (l === "length" || l >= a) && c.push(d);
+    });
+  } else
+    switch (n !== void 0 && c.push(i.get(n)), t) {
+      case "add":
+        h(e) ? je(n) && c.push(i.get("length")) : (c.push(i.get(H)), Y(e) && c.push(i.get(De)));
+        break;
+      case "delete":
+        h(e) || (c.push(i.get(H)), Y(e) && c.push(i.get(De)));
+        break;
+      case "set":
+        Y(e) && c.push(i.get(H));
+        break;
+    }
+  const u = process.env.NODE_ENV !== "production" ? { target: e, type: t, key: n, newValue: s, oldValue: r, oldTarget: o } : void 0;
+  if (c.length === 1)
+    c[0] && (process.env.NODE_ENV !== "production" ? ie(c[0], u) : ie(c[0]));
+  else {
+    const a = [];
+    for (const d of c)
+      d && a.push(...d);
+    process.env.NODE_ENV !== "production" ? ie(Ie(a), u) : ie(Ie(a));
+  }
+}
+function ie(e, t) {
+  const n = h(e) ? e : [...e];
+  for (const s of n)
+    s.computed && et(s, t);
+  for (const s of n)
+    s.computed || et(s, t);
+}
+function et(e, t) {
+  (e !== b || e.allowRecurse) && (process.env.NODE_ENV !== "production" && e.onTrigger && e.onTrigger(R({ effect: e }, t)), e.scheduler ? e.scheduler() : e.run());
+}
+const bn = /* @__PURE__ */ Xt("__proto__,__v_isRef,__isVue"), Ot = new Set(
+  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((e) => e !== "arguments" && e !== "caller").map((e) => Symbol[e]).filter(Ae)
+), On = /* @__PURE__ */ He(), Sn = /* @__PURE__ */ He(!0), xn = /* @__PURE__ */ He(!0, !0), tt = /* @__PURE__ */ Vn();
+function Vn() {
+  const e = {};
+  return ["includes", "indexOf", "lastIndexOf"].forEach((t) => {
+    e[t] = function(...n) {
+      const s = p(this);
+      for (let o = 0, i = this.length; o < i; o++)
+        x(s, "get", o + "");
+      const r = s[t](...n);
+      return r === -1 || r === !1 ? s[t](...n.map(p)) : r;
+    };
+  }), ["push", "pop", "shift", "unshift", "splice"].forEach((t) => {
+    e[t] = function(...n) {
+      Nt();
+      const s = p(this)[t].apply(this, n);
+      return bt(), s;
+    };
+  }), e;
+}
+function vn(e) {
+  const t = p(this);
+  return x(t, "has", e), t.hasOwnProperty(e);
+}
+function He(e = !1, t = !1) {
+  return function(s, r, o) {
+    if (r === "__v_isReactive")
+      return !e;
+    if (r === "__v_isReadonly")
+      return e;
+    if (r === "__v_isShallow")
+      return t;
+    if (r === "__v_raw" && o === (e ? t ? It : vt : t ? Un : Vt).get(s))
+      return s;
+    const i = h(s);
+    if (!e) {
+      if (i && m(tt, r))
+        return Reflect.get(tt, r, o);
+      if (r === "hasOwnProperty")
+        return vn;
+    }
+    const c = Reflect.get(s, r, o);
+    return (Ae(r) ? Ot.has(r) : bn(r)) || (e || x(s, "get", r), t) ? c : O(c) ? i && je(r) ? c : c.value : S(c) ? e ? yt(c) : Rt(c) : c;
+  };
+}
+const In = /* @__PURE__ */ Rn();
+function Rn(e = !1) {
+  return function(n, s, r, o) {
+    let i = n[s];
+    if (J(i) && O(i) && !O(r))
+      return !1;
+    if (!e && (!$e(r) && !J(r) && (i = p(i), r = p(r)), !h(n) && O(i) && !O(r)))
+      return i.value = r, !0;
+    const c = h(n) && je(s) ? Number(s) < n.length : m(n, s), u = Reflect.set(n, s, r, o);
+    return n === p(o) && (c ? ge(r, i) && z(n, "set", s, r, i) : z(n, "add", s, r)), u;
+  };
+}
+function yn(e, t) {
+  const n = m(e, t), s = e[t], r = Reflect.deleteProperty(e, t);
+  return r && n && z(e, "delete", t, void 0, s), r;
+}
+function Dn(e, t) {
+  const n = Reflect.has(e, t);
+  return (!Ae(t) || !Ot.has(t)) && x(e, "has", t), n;
+}
+function $n(e) {
+  return x(e, "iterate", h(e) ? "length" : H), Reflect.ownKeys(e);
+}
+const Cn = {
+  get: On,
+  set: In,
+  deleteProperty: yn,
+  has: Dn,
+  ownKeys: $n
+}, St = {
+  get: Sn,
+  set(e, t) {
+    return process.env.NODE_ENV !== "production" && Ze(
+      `Set operation on key "${String(t)}" failed: target is readonly.`,
+      e
+    ), !0;
+  },
+  deleteProperty(e, t) {
+    return process.env.NODE_ENV !== "production" && Ze(
+      `Delete operation on key "${String(t)}" failed: target is readonly.`,
+      e
+    ), !0;
+  }
+}, Tn = /* @__PURE__ */ R(
+  {},
+  St,
+  {
+    get: xn
+  }
+), Ue = (e) => e, Oe = (e) => Reflect.getPrototypeOf(e);
+function ce(e, t, n = !1, s = !1) {
+  e = e.__v_raw;
+  const r = p(e), o = p(t);
+  n || (t !== o && x(r, "get", t), x(r, "get", o));
+  const { has: i } = Oe(r), c = s ? Ue : n ? Je : Le;
+  if (i.call(r, t))
+    return c(e.get(t));
+  if (i.call(r, o))
+    return c(e.get(o));
+  e !== r && e.get(t);
+}
+function le(e, t = !1) {
+  const n = this.__v_raw, s = p(n), r = p(e);
+  return t || (e !== r && x(s, "has", e), x(s, "has", r)), e === r ? n.has(e) : n.has(e) || n.has(r);
+}
+function ue(e, t = !1) {
+  return e = e.__v_raw, !t && x(p(e), "iterate", H), Reflect.get(e, "size", e);
+}
+function nt(e) {
+  e = p(e);
+  const t = p(this);
+  return Oe(t).has.call(t, e) || (t.add(e), z(t, "add", e, e)), this;
+}
+function rt(e, t) {
+  t = p(t);
+  const n = p(this), { has: s, get: r } = Oe(n);
+  let o = s.call(n, e);
+  o ? process.env.NODE_ENV !== "production" && xt(n, s, e) : (e = p(e), o = s.call(n, e));
+  const i = r.call(n, e);
+  return n.set(e, t), o ? ge(t, i) && z(n, "set", e, t, i) : z(n, "add", e, t), this;
+}
+function st(e) {
+  const t = p(this), { has: n, get: s } = Oe(t);
+  let r = n.call(t, e);
+  r ? process.env.NODE_ENV !== "production" && xt(t, n, e) : (e = p(e), r = n.call(t, e));
+  const o = s ? s.call(t, e) : void 0, i = t.delete(e);
+  return r && z(t, "delete", e, void 0, o), i;
+}
+function ot() {
+  const e = p(this), t = e.size !== 0, n = process.env.NODE_ENV !== "production" ? Y(e) ? new Map(e) : new Set(e) : void 0, s = e.clear();
+  return t && z(e, "clear", void 0, void 0, n), s;
+}
+function ae(e, t) {
+  return function(s, r) {
+    const o = this, i = o.__v_raw, c = p(i), u = t ? Ue : e ? Je : Le;
+    return !e && x(c, "iterate", H), i.forEach((a, d) => s.call(r, u(a), u(d), o));
+  };
+}
+function fe(e, t, n) {
+  return function(...s) {
+    const r = this.__v_raw, o = p(r), i = Y(o), c = e === "entries" || e === Symbol.iterator && i, u = e === "keys" && i, a = r[e](...s), d = n ? Ue : t ? Je : Le;
+    return !t && x(
+      o,
+      "iterate",
+      u ? De : H
+    ), {
+      // iterator protocol
+      next() {
+        const { value: l, done: f } = a.next();
+        return f ? { value: l, done: f } : {
+          value: c ? [d(l[0]), d(l[1])] : d(l),
+          done: f
+        };
+      },
+      // iterable protocol
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  };
+}
+function P(e) {
+  return function(...t) {
+    if (process.env.NODE_ENV !== "production") {
+      const n = t[0] ? `on key "${t[0]}" ` : "";
+      console.warn(
+        `${un(e)} operation ${n}failed: target is readonly.`,
+        p(this)
+      );
+    }
+    return e === "delete" ? !1 : this;
+  };
+}
+function Pn() {
+  const e = {
+    get(o) {
+      return ce(this, o);
+    },
+    get size() {
+      return ue(this);
+    },
+    has: le,
+    add: nt,
+    set: rt,
+    delete: st,
+    clear: ot,
+    forEach: ae(!1, !1)
+  }, t = {
+    get(o) {
+      return ce(this, o, !1, !0);
+    },
+    get size() {
+      return ue(this);
+    },
+    has: le,
+    add: nt,
+    set: rt,
+    delete: st,
+    clear: ot,
+    forEach: ae(!1, !0)
+  }, n = {
+    get(o) {
+      return ce(this, o, !0);
+    },
+    get size() {
+      return ue(this, !0);
+    },
+    has(o) {
+      return le.call(this, o, !0);
+    },
+    add: P("add"),
+    set: P("set"),
+    delete: P("delete"),
+    clear: P("clear"),
+    forEach: ae(!0, !1)
+  }, s = {
+    get(o) {
+      return ce(this, o, !0, !0);
+    },
+    get size() {
+      return ue(this, !0);
+    },
+    has(o) {
+      return le.call(this, o, !0);
+    },
+    add: P("add"),
+    set: P("set"),
+    delete: P("delete"),
+    clear: P("clear"),
+    forEach: ae(!0, !0)
+  };
+  return ["keys", "values", "entries", Symbol.iterator].forEach((o) => {
+    e[o] = fe(
+      o,
+      !1,
+      !1
+    ), n[o] = fe(
+      o,
+      !0,
+      !1
+    ), t[o] = fe(
+      o,
+      !1,
+      !0
+    ), s[o] = fe(
+      o,
+      !0,
+      !0
+    );
+  }), [
+    e,
+    n,
+    t,
+    s
+  ];
+}
+const [
+  Mn,
+  Fn,
+  An,
+  jn
+] = /* @__PURE__ */ Pn();
+function We(e, t) {
+  const n = t ? e ? jn : An : e ? Fn : Mn;
+  return (s, r, o) => r === "__v_isReactive" ? !e : r === "__v_isReadonly" ? e : r === "__v_raw" ? s : Reflect.get(
+    m(n, r) && r in s ? n : s,
+    r,
+    o
+  );
+}
+const zn = {
+  get: /* @__PURE__ */ We(!1, !1)
+}, Kn = {
+  get: /* @__PURE__ */ We(!0, !1)
+}, Hn = {
+  get: /* @__PURE__ */ We(!0, !0)
+};
+function xt(e, t, n) {
+  const s = p(n);
+  if (s !== n && t.call(e, s)) {
+    const r = _t(e);
+    console.warn(
+      `Reactive ${r} contains both the raw and reactive versions of the same object${r === "Map" ? " as keys" : ""}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`
+    );
+  }
+}
+const Vt = /* @__PURE__ */ new WeakMap(), Un = /* @__PURE__ */ new WeakMap(), vt = /* @__PURE__ */ new WeakMap(), It = /* @__PURE__ */ new WeakMap();
+function Wn(e) {
+  switch (e) {
+    case "Object":
+    case "Array":
+      return 1;
+    case "Map":
+    case "Set":
+    case "WeakMap":
+    case "WeakSet":
+      return 2;
+    default:
+      return 0;
+  }
+}
+function Bn(e) {
+  return e.__v_skip || !Object.isExtensible(e) ? 0 : Wn(_t(e));
+}
+function Rt(e) {
+  return J(e) ? e : Be(
+    e,
+    !1,
+    Cn,
+    zn,
+    Vt
+  );
+}
+function yt(e) {
+  return Be(
+    e,
+    !0,
+    St,
+    Kn,
+    vt
+  );
+}
+function pe(e) {
+  return Be(
+    e,
+    !0,
+    Tn,
+    Hn,
+    It
+  );
+}
+function Be(e, t, n, s, r) {
+  if (!S(e))
+    return process.env.NODE_ENV !== "production" && console.warn(`value cannot be made reactive: ${String(e)}`), e;
+  if (e.__v_raw && !(t && e.__v_isReactive))
+    return e;
+  const o = r.get(e);
+  if (o)
+    return o;
+  const i = Bn(e);
+  if (i === 0)
+    return e;
+  const c = new Proxy(
+    e,
+    i === 2 ? s : n
+  );
+  return r.set(e, c), c;
+}
+function W(e) {
+  return J(e) ? W(e.__v_raw) : !!(e && e.__v_isReactive);
+}
+function J(e) {
+  return !!(e && e.__v_isReadonly);
+}
+function $e(e) {
+  return !!(e && e.__v_isShallow);
+}
+function Ce(e) {
+  return W(e) || J(e);
+}
+function p(e) {
+  const t = e && e.__v_raw;
+  return t ? p(t) : e;
+}
+function Ln(e) {
+  return an(e, "__v_skip", !0), e;
+}
+const Le = (e) => S(e) ? Rt(e) : e, Je = (e) => S(e) ? yt(e) : e;
+function O(e) {
+  return !!(e && e.__v_isRef === !0);
+}
+function Jn(e) {
+  return O(e) ? e.value : e;
+}
+const qn = {
+  get: (e, t, n) => Jn(Reflect.get(e, t, n)),
+  set: (e, t, n, s) => {
+    const r = e[t];
+    return O(r) && !O(n) ? (r.value = n, !0) : Reflect.set(e, t, n, s);
+  }
+};
+function Gn(e) {
+  return W(e) ? e : new Proxy(e, qn);
+}
+const B = [];
+function Yn(e) {
+  B.push(e);
+}
+function Qn() {
+  B.pop();
+}
+function w(e, ...t) {
+  if (process.env.NODE_ENV === "production")
+    return;
+  Nt();
+  const n = B.length ? B[B.length - 1].component : null, s = n && n.appContext.config.warnHandler, r = Xn();
+  if (s)
+    L(
+      s,
+      n,
+      11,
+      [
+        e + t.join(""),
+        n && n.proxy,
+        r.map(
+          ({ vnode: o }) => `at <${Jt(n, o.type)}>`
+        ).join(`
+`),
+        r
+      ]
+    );
+  else {
+    const o = [`[Vue warn]: ${e}`, ...t];
+    r.length && o.push(`
+`, ...Zn(r)), console.warn(...o);
+  }
+  bt();
+}
+function Xn() {
+  let e = B[B.length - 1];
+  if (!e)
+    return [];
+  const t = [];
+  for (; e; ) {
+    const n = t[0];
+    n && n.vnode === e ? n.recurseCount++ : t.push({
+      vnode: e,
+      recurseCount: 0
+    });
+    const s = e.component && e.component.parent;
+    e = s && s.vnode;
+  }
+  return t;
+}
+function Zn(e) {
+  const t = [];
+  return e.forEach((n, s) => {
+    t.push(...s === 0 ? [] : [`
+`], ...kn(n));
+  }), t;
+}
+function kn({ vnode: e, recurseCount: t }) {
+  const n = t > 0 ? `... (${t} recursive calls)` : "", s = e.component ? e.component.parent == null : !1, r = ` at <${Jt(
+    e.component,
+    e.type,
+    s
+  )}`, o = ">" + n;
+  return e.props ? [r, ...er(e.props), o] : [r + o];
+}
+function er(e) {
+  const t = [], n = Object.keys(e);
+  return n.slice(0, 3).forEach((s) => {
+    t.push(...Dt(s, e[s]));
+  }), n.length > 3 && t.push(" ..."), t;
+}
+function Dt(e, t, n) {
+  return $(t) ? (t = JSON.stringify(t), n ? t : [`${e}=${t}`]) : typeof t == "number" || typeof t == "boolean" || t == null ? n ? t : [`${e}=${t}`] : O(t) ? (t = Dt(e, p(t.value), !0), n ? t : [`${e}=Ref<`, t, ">"]) : N(t) ? [`${e}=fn${t.name ? `<${t.name}>` : ""}`] : (t = p(t), n ? t : [`${e}=`, t]);
+}
+const $t = {
+  sp: "serverPrefetch hook",
+  bc: "beforeCreate hook",
+  c: "created hook",
+  bm: "beforeMount hook",
+  m: "mounted hook",
+  bu: "beforeUpdate hook",
+  u: "updated",
+  bum: "beforeUnmount hook",
+  um: "unmounted hook",
+  a: "activated hook",
+  da: "deactivated hook",
+  ec: "errorCaptured hook",
+  rtc: "renderTracked hook",
+  rtg: "renderTriggered hook",
+  0: "setup function",
+  1: "render function",
+  2: "watcher getter",
+  3: "watcher callback",
+  4: "watcher cleanup function",
+  5: "native event handler",
+  6: "component event handler",
+  7: "vnode hook",
+  8: "directive hook",
+  9: "transition hook",
+  10: "app errorHandler",
+  11: "app warnHandler",
+  12: "ref function",
+  13: "async component loader",
+  14: "scheduler flush. This is likely a Vue internals bug. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/core"
+};
+function L(e, t, n, s) {
+  let r;
+  try {
+    r = s ? e(...s) : e();
+  } catch (o) {
+    Ct(o, t, n);
+  }
+  return r;
+}
+function Te(e, t, n, s) {
+  if (N(e)) {
+    const o = L(e, t, n, s);
+    return o && sn(o) && o.catch((i) => {
+      Ct(i, t, n);
+    }), o;
+  }
+  const r = [];
+  for (let o = 0; o < e.length; o++)
+    r.push(Te(e[o], t, n, s));
+  return r;
+}
+function Ct(e, t, n, s = !0) {
+  const r = t ? t.vnode : null;
+  if (t) {
+    let o = t.parent;
+    const i = t.proxy, c = process.env.NODE_ENV !== "production" ? $t[n] : n;
+    for (; o; ) {
+      const a = o.ec;
+      if (a) {
+        for (let d = 0; d < a.length; d++)
+          if (a[d](e, i, c) === !1)
+            return;
+      }
+      o = o.parent;
+    }
+    const u = t.appContext.config.errorHandler;
+    if (u) {
+      L(
+        u,
+        null,
+        10,
+        [e, i, c]
+      );
+      return;
+    }
+  }
+  tr(e, n, r, s);
+}
+function tr(e, t, n, s = !0) {
+  if (process.env.NODE_ENV !== "production") {
+    const r = $t[t];
+    if (n && Yn(n), w(`Unhandled error${r ? ` during execution of ${r}` : ""}`), n && Qn(), s)
+      throw e;
+    console.error(e);
+  } else
+    console.error(e);
+}
+let me = !1, Pe = !1;
+const y = [];
+let F = 0;
+const Q = [];
+let C = null, M = 0;
+const Tt = /* @__PURE__ */ Promise.resolve();
+let qe = null;
+const nr = 100;
+function rr(e) {
+  const t = qe || Tt;
+  return e ? t.then(this ? e.bind(this) : e) : t;
+}
+function sr(e) {
+  let t = F + 1, n = y.length;
+  for (; t < n; ) {
+    const s = t + n >>> 1;
+    re(y[s]) < e ? t = s + 1 : n = s;
+  }
+  return t;
+}
+function Ge(e) {
+  (!y.length || !y.includes(
+    e,
+    me && e.allowRecurse ? F + 1 : F
+  )) && (e.id == null ? y.push(e) : y.splice(sr(e.id), 0, e), Pt());
+}
+function Pt() {
+  !me && !Pe && (Pe = !0, qe = Tt.then(Ft));
+}
+function Mt(e) {
+  h(e) ? Q.push(...e) : (!C || !C.includes(
+    e,
+    e.allowRecurse ? M + 1 : M
+  )) && Q.push(e), Pt();
+}
+function or(e) {
+  if (Q.length) {
+    const t = [...new Set(Q)];
+    if (Q.length = 0, C) {
+      C.push(...t);
+      return;
+    }
+    for (C = t, process.env.NODE_ENV !== "production" && (e = e || /* @__PURE__ */ new Map()), C.sort((n, s) => re(n) - re(s)), M = 0; M < C.length; M++)
+      process.env.NODE_ENV !== "production" && At(e, C[M]) || C[M]();
+    C = null, M = 0;
+  }
+}
+const re = (e) => e.id == null ? 1 / 0 : e.id, ir = (e, t) => {
+  const n = re(e) - re(t);
+  if (n === 0) {
+    if (e.pre && !t.pre)
+      return -1;
+    if (t.pre && !e.pre)
+      return 1;
+  }
+  return n;
+};
+function Ft(e) {
+  Pe = !1, me = !0, process.env.NODE_ENV !== "production" && (e = e || /* @__PURE__ */ new Map()), y.sort(ir);
+  const t = process.env.NODE_ENV !== "production" ? (n) => At(e, n) : ht;
+  try {
+    for (F = 0; F < y.length; F++) {
+      const n = y[F];
+      if (n && n.active !== !1) {
+        if (process.env.NODE_ENV !== "production" && t(n))
+          continue;
+        L(n, null, 14);
+      }
+    }
+  } finally {
+    F = 0, y.length = 0, or(e), me = !1, qe = null, (y.length || Q.length) && Ft(e);
+  }
+}
+function At(e, t) {
+  if (!e.has(t))
+    e.set(t, 1);
+  else {
+    const n = e.get(t);
+    if (n > nr) {
+      const s = t.ownerInstance, r = s && Lt(s.type);
+      return w(
+        `Maximum recursive updates exceeded${r ? ` in component <${r}>` : ""}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`
+      ), !0;
+    } else
+      e.set(t, n + 1);
+  }
+}
+const Z = /* @__PURE__ */ new Set();
+process.env.NODE_ENV !== "production" && (ve().__VUE_HMR_RUNTIME__ = {
+  createRecord: Se(cr),
+  rerender: Se(lr),
+  reload: Se(ur)
+});
+const Ee = /* @__PURE__ */ new Map();
+function cr(e, t) {
+  return Ee.has(e) ? !1 : (Ee.set(e, {
+    initialDef: te(t),
+    instances: /* @__PURE__ */ new Set()
+  }), !0);
+}
+function te(e) {
+  return qt(e) ? e.__vccOpts : e;
+}
+function lr(e, t) {
+  const n = Ee.get(e);
+  n && (n.initialDef.render = t, [...n.instances].forEach((s) => {
+    t && (s.render = t, te(s.type).render = t), s.renderCache = [], s.update();
+  }));
+}
+function ur(e, t) {
+  const n = Ee.get(e);
+  if (!n)
+    return;
+  t = te(t), it(n.initialDef, t);
+  const s = [...n.instances];
+  for (const r of s) {
+    const o = te(r.type);
+    Z.has(o) || (o !== n.initialDef && it(o, t), Z.add(o)), r.appContext.propsCache.delete(r.type), r.appContext.emitsCache.delete(r.type), r.appContext.optionsCache.delete(r.type), r.ceReload ? (Z.add(o), r.ceReload(t.styles), Z.delete(o)) : r.parent ? Ge(r.parent.update) : r.appContext.reload ? r.appContext.reload() : typeof window < "u" ? window.location.reload() : console.warn(
+      "[HMR] Root or manually mounted instance modified. Full reload required."
+    );
+  }
+  Mt(() => {
+    for (const r of s)
+      Z.delete(
+        te(r.type)
+      );
+  });
+}
+function it(e, t) {
+  R(e, t);
+  for (const n in e)
+    n !== "__file" && !(n in t) && delete e[n];
+}
+function Se(e) {
+  return (t, n) => {
+    try {
+      return e(t, n);
+    } catch (s) {
+      console.error(s), console.warn(
+        "[HMR] Something went wrong during Vue component hot-reload. Full reload required."
+      );
+    }
+  };
+}
+let A = null, ar = null;
+const fr = (e) => e.__isSuspense;
+function pr(e, t) {
+  t && t.pendingBranch ? h(e) ? t.effects.push(...e) : t.effects.push(e) : Mt(e);
+}
+const de = {};
+function dr(e, t, { immediate: n, deep: s, flush: r, onTrack: o, onTrigger: i } = T) {
+  var c;
+  process.env.NODE_ENV !== "production" && !t && (n !== void 0 && w(
+    'watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.'
+  ), s !== void 0 && w(
+    'watch() "deep" option is only respected when using the watch(source, callback, options?) signature.'
+  ));
+  const u = (g) => {
+    w(
+      "Invalid watch source: ",
+      g,
+      "A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types."
+    );
+  }, a = gn() === ((c = X) == null ? void 0 : c.scope) ? X : null;
+  let d, l = !1, f = !1;
+  if (O(e) ? (d = () => e.value, l = $e(e)) : W(e) ? (d = () => e, s = !0) : h(e) ? (f = !0, l = e.some((g) => W(g) || $e(g)), d = () => e.map((g) => {
+    if (O(g))
+      return g.value;
+    if (W(g))
+      return G(g);
+    if (N(g))
+      return L(g, a, 2);
+    process.env.NODE_ENV !== "production" && u(g);
+  })) : N(e) ? t ? d = () => L(e, a, 2) : d = () => {
+    if (!(a && a.isUnmounted))
+      return _ && _(), Te(
+        e,
+        a,
+        3,
+        [V]
+      );
+  } : (d = ht, process.env.NODE_ENV !== "production" && u(e)), t && s) {
+    const g = d;
+    d = () => G(g());
+  }
+  let _, V = (g) => {
+    _ = I.onStop = () => {
+      L(g, a, 4);
+    };
+  }, v = f ? new Array(e.length).fill(de) : de;
+  const K = () => {
+    if (I.active)
+      if (t) {
+        const g = I.run();
+        (s || l || (f ? g.some(
+          (Yt, Qt) => ge(Yt, v[Qt])
+        ) : ge(g, v))) && (_ && _(), Te(t, a, 3, [
+          g,
+          // pass undefined as the old value when it's changed for the first time
+          v === de ? void 0 : f && v[0] === de ? [] : v,
+          V
+        ]), v = g);
+      } else
+        I.run();
+  };
+  K.allowRecurse = !!t;
+  let oe;
+  r === "sync" ? oe = K : r === "post" ? oe = () => ft(K, a && a.suspense) : (K.pre = !0, a && (K.id = a.uid), oe = () => Ge(K));
+  const I = new wn(d, oe);
+  return process.env.NODE_ENV !== "production" && (I.onTrack = o, I.onTrigger = i), t ? n ? K() : v = I.run() : r === "post" ? ft(
+    I.run.bind(I),
+    a && a.suspense
+  ) : I.run(), () => {
+    I.stop(), a && a.scope && tn(a.scope.effects, I);
+  };
+}
+function hr(e, t, n) {
+  const s = this.proxy, r = $(e) ? e.includes(".") ? _r(s, e) : () => s[e] : e.bind(s, s);
+  let o;
+  N(t) ? o = t : (o = t.handler, n = t);
+  const i = X;
+  dt(this);
+  const c = dr(r, o.bind(s), n);
+  return i ? dt(i) : Pr(), c;
+}
+function _r(e, t) {
+  const n = t.split(".");
+  return () => {
+    let s = e;
+    for (let r = 0; r < n.length && s; r++)
+      s = s[n[r]];
+    return s;
+  };
+}
+function G(e, t) {
+  if (!S(e) || e.__v_skip || (t = t || /* @__PURE__ */ new Set(), t.has(e)))
+    return e;
+  if (t.add(e), O(e))
+    G(e.value, t);
+  else if (h(e))
+    for (let n = 0; n < e.length; n++)
+      G(e[n], t);
+  else if (rn(e) || Y(e))
+    e.forEach((n) => {
+      G(n, t);
+    });
+  else if (cn(e))
+    for (const n in e)
+      G(e[n], t);
+  return e;
+}
+const gr = Symbol.for("v-ndc"), Me = (e) => e ? Mr(e) ? Fr(e) || e.proxy : Me(e.parent) : null, ne = (
+  // Move PURE marker to new line to workaround compiler discarding it
+  // due to type annotation
+  /* @__PURE__ */ R(/* @__PURE__ */ Object.create(null), {
+    $: (e) => e,
+    $el: (e) => e.vnode.el,
+    $data: (e) => e.data,
+    $props: (e) => process.env.NODE_ENV !== "production" ? pe(e.props) : e.props,
+    $attrs: (e) => process.env.NODE_ENV !== "production" ? pe(e.attrs) : e.attrs,
+    $slots: (e) => process.env.NODE_ENV !== "production" ? pe(e.slots) : e.slots,
+    $refs: (e) => process.env.NODE_ENV !== "production" ? pe(e.refs) : e.refs,
+    $parent: (e) => Me(e.parent),
+    $root: (e) => Me(e.root),
+    $emit: (e) => e.emit,
+    $options: (e) => wr(e),
+    $forceUpdate: (e) => e.f || (e.f = () => Ge(e.update)),
+    $nextTick: (e) => e.n || (e.n = rr.bind(e.proxy)),
+    $watch: (e) => hr.bind(e)
+  })
+), mr = (e) => e === "_" || e === "$", xe = (e, t) => e !== T && !e.__isScriptSetup && m(e, t), Er = {
+  get({ _: e }, t) {
+    const { ctx: n, setupState: s, data: r, props: o, accessCache: i, type: c, appContext: u } = e;
+    if (process.env.NODE_ENV !== "production" && t === "__isVue")
+      return !0;
+    let a;
+    if (t[0] !== "$") {
+      const _ = i[t];
+      if (_ !== void 0)
+        switch (_) {
+          case 1:
+            return s[t];
+          case 2:
+            return r[t];
+          case 4:
+            return n[t];
+          case 3:
+            return o[t];
+        }
+      else {
+        if (xe(s, t))
+          return i[t] = 1, s[t];
+        if (r !== T && m(r, t))
+          return i[t] = 2, r[t];
+        if (
+          // only cache other properties when instance has declared (thus stable)
+          // props
+          (a = e.propsOptions[0]) && m(a, t)
+        )
+          return i[t] = 3, o[t];
+        if (n !== T && m(n, t))
+          return i[t] = 4, n[t];
+        i[t] = 0;
+      }
+    }
+    const d = ne[t];
+    let l, f;
+    if (d)
+      return t === "$attrs" ? (x(e, "get", t), process.env.NODE_ENV !== "production" && void 0) : process.env.NODE_ENV !== "production" && t === "$slots" && x(e, "get", t), d(e);
+    if (
+      // css module (injected by vue-loader)
+      (l = c.__cssModules) && (l = l[t])
+    )
+      return l;
+    if (n !== T && m(n, t))
+      return i[t] = 4, n[t];
+    if (
+      // global properties
+      f = u.config.globalProperties, m(f, t)
+    )
+      return f[t];
+    process.env.NODE_ENV !== "production" && A && (!$(t) || // #1091 avoid internal isRef/isVNode checks on component instance leading
+    // to infinite warning loop
+    t.indexOf("__v") !== 0) && (r !== T && mr(t[0]) && m(r, t) ? w(
+      `Property ${JSON.stringify(
+        t
+      )} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`
+    ) : e === A && w(
+      `Property ${JSON.stringify(t)} was accessed during render but is not defined on instance.`
+    ));
+  },
+  set({ _: e }, t, n) {
+    const { data: s, setupState: r, ctx: o } = e;
+    return xe(r, t) ? (r[t] = n, !0) : process.env.NODE_ENV !== "production" && r.__isScriptSetup && m(r, t) ? (w(`Cannot mutate <script setup> binding "${t}" from Options API.`), !1) : s !== T && m(s, t) ? (s[t] = n, !0) : m(e.props, t) ? (process.env.NODE_ENV !== "production" && w(`Attempting to mutate prop "${t}". Props are readonly.`), !1) : t[0] === "$" && t.slice(1) in e ? (process.env.NODE_ENV !== "production" && w(
+      `Attempting to mutate public property "${t}". Properties starting with $ are reserved and readonly.`
+    ), !1) : (process.env.NODE_ENV !== "production" && t in e.appContext.config.globalProperties ? Object.defineProperty(o, t, {
+      enumerable: !0,
+      configurable: !0,
+      value: n
+    }) : o[t] = n, !0);
+  },
+  has({
+    _: { data: e, setupState: t, accessCache: n, ctx: s, appContext: r, propsOptions: o }
+  }, i) {
+    let c;
+    return !!n[i] || e !== T && m(e, i) || xe(t, i) || (c = o[0]) && m(c, i) || m(s, i) || m(ne, i) || m(r.config.globalProperties, i);
+  },
+  defineProperty(e, t, n) {
+    return n.get != null ? e._.accessCache[t] = 0 : m(n, "value") && this.set(e, t, n.value, null), Reflect.defineProperty(e, t, n);
+  }
+};
+process.env.NODE_ENV !== "production" && (Er.ownKeys = (e) => (w(
+  "Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead."
+), Reflect.ownKeys(e)));
+function ct(e) {
+  return h(e) ? e.reduce(
+    (t, n) => (t[n] = null, t),
+    {}
+  ) : e;
+}
+function wr(e) {
+  const t = e.type, { mixins: n, extends: s } = t, {
+    mixins: r,
+    optionsCache: o,
+    config: { optionMergeStrategies: i }
+  } = e.appContext, c = o.get(t);
+  let u;
+  return c ? u = c : !r.length && !n && !s ? u = t : (u = {}, r.length && r.forEach(
+    (a) => we(u, a, i, !0)
+  ), we(u, t, i)), S(t) && o.set(t, u), u;
+}
+function we(e, t, n, s = !1) {
+  const { mixins: r, extends: o } = t;
+  o && we(e, o, n, !0), r && r.forEach(
+    (i) => we(e, i, n, !0)
+  );
+  for (const i in t)
+    if (s && i === "expose")
+      process.env.NODE_ENV !== "production" && w(
+        '"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.'
+      );
+    else {
+      const c = Nr[i] || n && n[i];
+      e[i] = c ? c(e[i], t[i]) : t[i];
+    }
+  return e;
+}
+const Nr = {
+  data: lt,
+  props: at,
+  emits: at,
+  // objects
+  methods: ee,
+  computed: ee,
+  // lifecycle
+  beforeCreate: E,
+  created: E,
+  beforeMount: E,
+  mounted: E,
+  beforeUpdate: E,
+  updated: E,
+  beforeDestroy: E,
+  beforeUnmount: E,
+  destroyed: E,
+  unmounted: E,
+  activated: E,
+  deactivated: E,
+  errorCaptured: E,
+  serverPrefetch: E,
+  // assets
+  components: ee,
+  directives: ee,
+  // watch
+  watch: Or,
+  // provide / inject
+  provide: lt,
+  inject: br
+};
+function lt(e, t) {
+  return t ? e ? function() {
+    return R(
+      N(e) ? e.call(this, this) : e,
+      N(t) ? t.call(this, this) : t
+    );
+  } : t : e;
+}
+function br(e, t) {
+  return ee(ut(e), ut(t));
+}
+function ut(e) {
+  if (h(e)) {
+    const t = {};
+    for (let n = 0; n < e.length; n++)
+      t[e[n]] = e[n];
+    return t;
+  }
+  return e;
+}
+function E(e, t) {
+  return e ? [...new Set([].concat(e, t))] : t;
+}
+function ee(e, t) {
+  return e ? R(/* @__PURE__ */ Object.create(null), e, t) : t;
+}
+function at(e, t) {
+  return e ? h(e) && h(t) ? [.../* @__PURE__ */ new Set([...e, ...t])] : R(
+    /* @__PURE__ */ Object.create(null),
+    ct(e),
+    ct(t ?? {})
+  ) : t;
+}
+function Or(e, t) {
+  if (!e)
+    return t;
+  if (!t)
+    return e;
+  const n = R(/* @__PURE__ */ Object.create(null), e);
+  for (const s in t)
+    n[s] = E(e[s], t[s]);
+  return n;
+}
+const ft = pr, Sr = (e) => e.__isTeleport, jt = Symbol.for("v-fgt"), xr = Symbol.for("v-txt"), Vr = Symbol.for("v-cmt"), he = [];
+let D = null;
+function zt(e = !1) {
+  he.push(D = e ? null : []);
+}
+function vr() {
+  he.pop(), D = he[he.length - 1] || null;
+}
+function Ir(e) {
+  return e.dynamicChildren = D || Zt, vr(), D && D.push(e), e;
+}
+function Kt(e, t, n, s, r, o) {
+  return Ir(
+    se(
+      e,
+      t,
+      n,
+      s,
+      r,
+      o,
+      !0
+      /* isBlock */
+    )
+  );
+}
+function Rr(e) {
+  return e ? e.__v_isVNode === !0 : !1;
+}
+const yr = (...e) => Wt(
+  ...e
+), Ht = "__vInternal", Ut = ({ key: e }) => e ?? null, _e = ({
+  ref: e,
+  ref_key: t,
+  ref_for: n
+}) => (typeof e == "number" && (e = "" + e), e != null ? $(e) || O(e) || N(e) ? { i: A, r: e, k: t, f: !!n } : e : null);
+function se(e, t = null, n = null, s = 0, r = null, o = e === jt ? 0 : 1, i = !1, c = !1) {
+  const u = {
+    __v_isVNode: !0,
+    __v_skip: !0,
+    type: e,
+    props: t,
+    key: t && Ut(t),
+    ref: t && _e(t),
+    scopeId: ar,
+    slotScopeIds: null,
+    children: n,
+    component: null,
+    suspense: null,
+    ssContent: null,
+    ssFallback: null,
+    dirs: null,
+    transition: null,
+    el: null,
+    anchor: null,
+    target: null,
+    targetAnchor: null,
+    staticCount: 0,
+    shapeFlag: o,
+    patchFlag: s,
+    dynamicProps: r,
+    dynamicChildren: null,
+    appContext: null,
+    ctx: A
+  };
+  return c ? (Ye(u, n), o & 128 && e.normalize(u)) : n && (u.shapeFlag |= $(n) ? 8 : 16), process.env.NODE_ENV !== "production" && u.key !== u.key && w("VNode created with invalid key (NaN). VNode type:", u.type), // avoid a block node from tracking itself
+  !i && // has current parent block
+  D && // 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 || o & 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 && D.push(u), u;
+}
+const Dr = process.env.NODE_ENV !== "production" ? yr : Wt;
+function Wt(e, t = null, n = null, s = 0, r = null, o = !1) {
+  if ((!e || e === gr) && (process.env.NODE_ENV !== "production" && !e && w(`Invalid vnode type when creating vnode: ${e}.`), e = Vr), Rr(e)) {
+    const c = Ne(
+      e,
+      t,
+      !0
+      /* mergeRef: true */
+    );
+    return n && Ye(c, n), !o && D && (c.shapeFlag & 6 ? D[D.indexOf(e)] = c : D.push(c)), c.patchFlag |= -2, c;
+  }
+  if (qt(e) && (e = e.__vccOpts), t) {
+    t = $r(t);
+    let { class: c, style: u } = t;
+    c && !$(c) && (t.class = Ke(c)), S(u) && (Ce(u) && !h(u) && (u = R({}, u)), t.style = ze(u));
+  }
+  const i = $(e) ? 1 : fr(e) ? 128 : Sr(e) ? 64 : S(e) ? 4 : N(e) ? 2 : 0;
+  return process.env.NODE_ENV !== "production" && i & 4 && Ce(e) && (e = p(e), w(
+    "Vue received a Component which was made a reactive object. This can lead to unnecessary performance overhead, and should be avoided by marking the component with `markRaw` or using `shallowRef` instead of `ref`.",
+    `
+Component that was made reactive: `,
+    e
+  )), se(
+    e,
+    t,
+    n,
+    s,
+    r,
+    i,
+    o,
+    !0
+  );
+}
+function $r(e) {
+  return e ? Ce(e) || Ht in e ? R({}, e) : e : null;
+}
+function Ne(e, t, n = !1) {
+  const { props: s, ref: r, patchFlag: o, children: i } = e, c = t ? Tr(s || {}, t) : s;
+  return {
+    __v_isVNode: !0,
+    __v_skip: !0,
+    type: e.type,
+    props: c,
+    key: c && Ut(c),
+    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
+      n && r ? h(r) ? r.concat(_e(t)) : [r, _e(t)] : _e(t)
+    ) : r,
+    scopeId: e.scopeId,
+    slotScopeIds: e.slotScopeIds,
+    children: process.env.NODE_ENV !== "production" && o === -1 && h(i) ? i.map(Bt) : i,
+    target: e.target,
+    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 !== jt ? o === -1 ? 16 : o | 16 : o,
+    dynamicProps: e.dynamicProps,
+    dynamicChildren: e.dynamicChildren,
+    appContext: e.appContext,
+    dirs: e.dirs,
+    transition: e.transition,
+    // 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 && Ne(e.ssContent),
+    ssFallback: e.ssFallback && Ne(e.ssFallback),
+    el: e.el,
+    anchor: e.anchor,
+    ctx: e.ctx,
+    ce: e.ce
+  };
+}
+function Bt(e) {
+  const t = Ne(e);
+  return h(e.children) && (t.children = e.children.map(Bt)), t;
+}
+function Cr(e = " ", t = 0) {
+  return Dr(xr, null, e, t);
+}
+function Ye(e, t) {
+  let n = 0;
+  const { shapeFlag: s } = e;
+  if (t == null)
+    t = null;
+  else if (h(t))
+    n = 16;
+  else if (typeof t == "object")
+    if (s & 65) {
+      const r = t.default;
+      r && (r._c && (r._d = !1), Ye(e, r()), r._c && (r._d = !0));
+      return;
+    } else {
+      n = 32;
+      const r = t._;
+      !r && !(Ht in t) ? t._ctx = A : r === 3 && A && (A.slots._ === 1 ? t._ = 1 : (t._ = 2, e.patchFlag |= 1024));
+    }
+  else
+    N(t) ? (t = { default: t, _ctx: A }, n = 32) : (t = String(t), s & 64 ? (n = 16, t = [Cr(t)]) : n = 8);
+  e.children = t, e.shapeFlag |= n;
+}
+function Tr(...e) {
+  const t = {};
+  for (let n = 0; n < e.length; n++) {
+    const s = e[n];
+    for (const r in s)
+      if (r === "class")
+        t.class !== s.class && (t.class = Ke([t.class, s.class]));
+      else if (r === "style")
+        t.style = ze([t.style, s.style]);
+      else if (en(r)) {
+        const o = t[r], i = s[r];
+        i && o !== i && !(h(o) && o.includes(i)) && (t[r] = o ? [].concat(o, i) : i);
+      } else
+        r !== "" && (t[r] = s[r]);
+  }
+  return t;
+}
+let X = null, Qe, q, pt = "__VUE_INSTANCE_SETTERS__";
+(q = ve()[pt]) || (q = ve()[pt] = []), q.push((e) => X = e), Qe = (e) => {
+  q.length > 1 ? q.forEach((t) => t(e)) : q[0](e);
+};
+const dt = (e) => {
+  Qe(e), e.scope.on();
+}, Pr = () => {
+  X && X.scope.off(), Qe(null);
+};
+function Mr(e) {
+  return e.vnode.shapeFlag & 4;
+}
+function Fr(e) {
+  if (e.exposed)
+    return e.exposeProxy || (e.exposeProxy = new Proxy(Gn(Ln(e.exposed)), {
+      get(t, n) {
+        if (n in t)
+          return t[n];
+        if (n in ne)
+          return ne[n](e);
+      },
+      has(t, n) {
+        return n in t || n in ne;
+      }
+    }));
+}
+const Ar = /(?:^|[-_])(\w)/g, jr = (e) => e.replace(Ar, (t) => t.toUpperCase()).replace(/[-_]/g, "");
+function Lt(e, t = !0) {
+  return N(e) ? e.displayName || e.name : e.name || t && e.__name;
+}
+function Jt(e, t, n = !1) {
+  let s = Lt(t);
+  if (!s && t.__file) {
+    const r = t.__file.match(/([^/\\]+)\.\w+$/);
+    r && (s = r[1]);
+  }
+  if (!s && e && e.parent) {
+    const r = (o) => {
+      for (const i in o)
+        if (o[i] === t)
+          return i;
+    };
+    s = r(
+      e.components || e.parent.type.components
+    ) || r(e.appContext.components);
+  }
+  return s ? jr(s) : n ? "App" : "Anonymous";
+}
+function qt(e) {
+  return N(e) && "__vccOpts" in e;
+}
+function Ve(e) {
+  return !!(e && e.__v_isShallow);
+}
+function zr() {
+  if (process.env.NODE_ENV === "production" || typeof window > "u")
+    return;
+  const e = { style: "color:#3ba776" }, t = { style: "color:#0b1bc9" }, n = { style: "color:#b62e24" }, s = { style: "color:#9d288c" }, r = {
+    header(l) {
+      return S(l) ? l.__isVue ? ["div", e, "VueInstance"] : O(l) ? [
+        "div",
+        {},
+        ["span", e, d(l)],
+        "<",
+        c(l.value),
+        ">"
+      ] : W(l) ? [
+        "div",
+        {},
+        ["span", e, Ve(l) ? "ShallowReactive" : "Reactive"],
+        "<",
+        c(l),
+        `>${J(l) ? " (readonly)" : ""}`
+      ] : J(l) ? [
+        "div",
+        {},
+        ["span", e, Ve(l) ? "ShallowReadonly" : "Readonly"],
+        "<",
+        c(l),
+        ">"
+      ] : null : null;
+    },
+    hasBody(l) {
+      return l && l.__isVue;
+    },
+    body(l) {
+      if (l && l.__isVue)
+        return [
+          "div",
+          {},
+          ...o(l.$)
+        ];
+    }
+  };
+  function o(l) {
+    const f = [];
+    l.type.props && l.props && f.push(i("props", p(l.props))), l.setupState !== T && f.push(i("setup", l.setupState)), l.data !== T && f.push(i("data", p(l.data)));
+    const _ = u(l, "computed");
+    _ && f.push(i("computed", _));
+    const V = u(l, "inject");
+    return V && f.push(i("injected", V)), f.push([
+      "div",
+      {},
+      [
+        "span",
+        {
+          style: s.style + ";opacity:0.66"
+        },
+        "$ (internal): "
+      ],
+      ["object", { object: l }]
+    ]), f;
+  }
+  function i(l, f) {
+    return f = R({}, f), Object.keys(f).length ? [
+      "div",
+      { style: "line-height:1.25em;margin-bottom:0.6em" },
+      [
+        "div",
+        {
+          style: "color:#476582"
+        },
+        l
+      ],
+      [
+        "div",
+        {
+          style: "padding-left:1.25em"
+        },
+        ...Object.keys(f).map((_) => [
+          "div",
+          {},
+          ["span", s, _ + ": "],
+          c(f[_], !1)
+        ])
+      ]
+    ] : ["span", {}];
+  }
+  function c(l, f = !0) {
+    return typeof l == "number" ? ["span", t, l] : typeof l == "string" ? ["span", n, JSON.stringify(l)] : typeof l == "boolean" ? ["span", s, l] : S(l) ? ["object", { object: f ? p(l) : l }] : ["span", n, String(l)];
+  }
+  function u(l, f) {
+    const _ = l.type;
+    if (N(_))
+      return;
+    const V = {};
+    for (const v in l.ctx)
+      a(_, v, f) && (V[v] = l.ctx[v]);
+    return V;
+  }
+  function a(l, f, _) {
+    const V = l[_];
+    if (h(V) && V.includes(f) || S(V) && f in V || l.extends && a(l.extends, f, _) || l.mixins && l.mixins.some((v) => a(v, f, _)))
+      return !0;
+  }
+  function d(l) {
+    return Ve(l) ? "ShallowRef" : l.effect ? "ComputedRef" : "Ref";
+  }
+  window.devtoolsFormatters ? window.devtoolsFormatters.push(r) : window.devtoolsFormatters = [r];
+}
+function Kr() {
+  zr();
+}
+process.env.NODE_ENV !== "production" && Kr();
+const Gt = (e, t) => {
+  const n = e.__vccOpts || e;
+  for (const [s, r] of t)
+    n[s] = r;
+  return n;
+}, Hr = {};
+function Ur(e, t) {
+  return zt(), Kt("button", null, "123456");
+}
+const Fe = /* @__PURE__ */ Gt(Hr, [["render", Ur]]);
+console.log("StButton", Fe, Fe.name);
+const Wr = {
+  install(e) {
+    e.component("StButton", Fe);
+  }
+}, Br = {}, Lr = /* @__PURE__ */ se("li", null, "1", -1), Jr = /* @__PURE__ */ se("li", null, "2", -1), qr = /* @__PURE__ */ se("li", null, "3", -1), Gr = [
+  Lr,
+  Jr,
+  qr
+];
+function Yr(e, t) {
+  return zt(), Kt("ul", null, Gr);
+}
+const Qr = /* @__PURE__ */ Gt(Br, [["render", Yr]]), Xr = {
+  install(e) {
+    e.component("StList", Qr);
+  }
+}, kr = {
+  install(e) {
+    Wr.install(e), Xr.install(e);
+  }
+};
+export {
+  kr as default
+};