@duxweb/dvha-naiveui 0.0.4 → 1.0.0

package/dist/esm/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js

@@ -0,0 +1,800 @@
+import { isRef as Q, isReactive as Ve, isShallow as q, isReadonly as ne, toRaw as C, computed as Ce, pauseTracking as X, resetTracking as Z, isProxy as Y, watch as ve } from "../../reactivity/dist/reactivity.esm-bundler.js";
+import { ReactiveEffect as wt, onWatcherCleanup as St, reactive as Ot, readonly as Vt, unref as Ct } from "../../reactivity/dist/reactivity.esm-bundler.js";
+import { isObject as v, EMPTY_OBJ as P, extend as k, isFunction as y, isArray as _, isString as D, getGlobalThis as W, normalizeClass as re, normalizeStyle as se, isOn as xe, NOOP as I, isPromise as be } from "../../shared/dist/shared.esm-bundler.js";
+import { capitalize as xt } from "../../shared/dist/shared.esm-bundler.js";
+/**
+* @vue/runtime-core v3.5.14
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+const S = [];
+function ke(e) {
+  S.push(e);
+}
+function Re() {
+  S.pop();
+}
+let z = !1;
+function m(e, ...t) {
+  if (z) return;
+  z = !0, X();
+  const n = S.length ? S[S.length - 1].component : null, o = n && n.appContext.config.warnHandler, s = Ie();
+  if (o)
+    J(
+      o,
+      n,
+      11,
+      [
+        // eslint-disable-next-line no-restricted-syntax
+        e + t.map((r) => {
+          var l, c;
+          return (c = (l = r.toString) == null ? void 0 : l.call(r)) != null ? c : JSON.stringify(r);
+        }).join(""),
+        n && n.proxy,
+        s.map(
+          ({ vnode: r }) => `at <${Se(n, r.type)}>`
+        ).join(`
+`),
+        s
+      ]
+    );
+  else {
+    const r = [`[Vue warn]: ${e}`, ...t];
+    s.length && r.push(`
+`, ...De(s)), console.warn(...r);
+  }
+  Z(), z = !1;
+}
+function Ie() {
+  let e = S[S.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 o = e.component && e.component.parent;
+    e = o && o.vnode;
+  }
+  return t;
+}
+function De(e) {
+  const t = [];
+  return e.forEach((n, o) => {
+    t.push(...o === 0 ? [] : [`
+`], ...Te(n));
+  }), t;
+}
+function Te({ vnode: e, recurseCount: t }) {
+  const n = t > 0 ? `... (${t} recursive calls)` : "", o = e.component ? e.component.parent == null : !1, s = ` at <${Se(
+    e.component,
+    e.type,
+    o
+  )}`, r = ">" + n;
+  return e.props ? [s, ...Fe(e.props), r] : [s + r];
+}
+function Fe(e) {
+  const t = [], n = Object.keys(e);
+  return n.slice(0, 3).forEach((o) => {
+    t.push(...ie(o, e[o]));
+  }), n.length > 3 && t.push(" ..."), t;
+}
+function ie(e, t, n) {
+  return D(t) ? (t = JSON.stringify(t), n ? t : [`${e}=${t}`]) : typeof t == "number" || typeof t == "boolean" || t == null ? n ? t : [`${e}=${t}`] : Q(t) ? (t = ie(e, C(t.value), !0), n ? t : [`${e}=Ref<`, t, ">"]) : y(t) ? [`${e}=fn${t.name ? `<${t.name}>` : ""}`] : (t = C(t), n ? t : [`${e}=`, t]);
+}
+const ce = {
+  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",
+  15: "component update",
+  16: "app unmount cleanup function"
+};
+function J(e, t, n, o) {
+  try {
+    return o ? e(...o) : e();
+  } catch (s) {
+    ee(s, t, n);
+  }
+}
+function le(e, t, n, o) {
+  if (y(e)) {
+    const s = J(e, t, n, o);
+    return s && be(s) && s.catch((r) => {
+      ee(r, t, n);
+    }), s;
+  }
+  if (_(e)) {
+    const s = [];
+    for (let r = 0; r < e.length; r++)
+      s.push(le(e[r], t, n, o));
+    return s;
+  } else process.env.NODE_ENV !== "production" && m(
+    `Invalid value type passed to callWithAsyncErrorHandling(): ${typeof e}`
+  );
+}
+function ee(e, t, n, o = !0) {
+  const s = t ? t.vnode : null, { errorHandler: r, throwUnhandledErrorInProduction: l } = t && t.appContext.config || P;
+  if (t) {
+    let c = t.parent;
+    const f = t.proxy, d = process.env.NODE_ENV !== "production" ? ce[n] : `https://vuejs.org/error-reference/#runtime-${n}`;
+    for (; c; ) {
+      const p = c.ec;
+      if (p) {
+        for (let i = 0; i < p.length; i++)
+          if (p[i](e, f, d) === !1)
+            return;
+      }
+      c = c.parent;
+    }
+    if (r) {
+      X(), J(r, null, 10, [
+        e,
+        f,
+        d
+      ]), Z();
+      return;
+    }
+  }
+  $e(e, n, s, o, l);
+}
+function $e(e, t, n, o = !0, s = !1) {
+  if (process.env.NODE_ENV !== "production") {
+    const r = ce[t];
+    if (n && ke(n), m(`Unhandled error${r ? ` during execution of ${r}` : ""}`), n && Re(), o)
+      throw e;
+    console.error(e);
+  } else {
+    if (s)
+      throw e;
+    console.error(e);
+  }
+}
+const g = [];
+let E = -1;
+const x = [];
+let N = null, O = 0;
+const Pe = /* @__PURE__ */ Promise.resolve();
+let j = null;
+const He = 100;
+function Ae(e) {
+  let t = E + 1, n = g.length;
+  for (; t < n; ) {
+    const o = t + n >>> 1, s = g[o], r = T(s);
+    r < e || r === e && s.flags & 2 ? t = o + 1 : n = o;
+  }
+  return t;
+}
+function ae(e) {
+  if (!(e.flags & 1)) {
+    const t = T(e), n = g[g.length - 1];
+    !n || // fast path when the job id is larger than the tail
+    !(e.flags & 2) && t >= T(n) ? g.push(e) : g.splice(Ae(t), 0, e), e.flags |= 1, ue();
+  }
+}
+function ue() {
+  j || (j = Pe.then(pe));
+}
+function fe(e) {
+  _(e) ? x.push(...e) : N && e.id === -1 ? N.splice(O + 1, 0, e) : e.flags & 1 || (x.push(e), e.flags |= 1), ue();
+}
+function Me(e) {
+  if (x.length) {
+    const t = [...new Set(x)].sort(
+      (n, o) => T(n) - T(o)
+    );
+    if (x.length = 0, N) {
+      N.push(...t);
+      return;
+    }
+    for (N = t, process.env.NODE_ENV !== "production" && (e = e || /* @__PURE__ */ new Map()), O = 0; O < N.length; O++) {
+      const n = N[O];
+      process.env.NODE_ENV !== "production" && de(e, n) || (n.flags & 4 && (n.flags &= -2), n.flags & 8 || n(), n.flags &= -2);
+    }
+    N = null, O = 0;
+  }
+}
+const T = (e) => e.id == null ? e.flags & 2 ? -1 : 1 / 0 : e.id;
+function pe(e) {
+  process.env.NODE_ENV !== "production" && (e = e || /* @__PURE__ */ new Map());
+  const t = process.env.NODE_ENV !== "production" ? (n) => de(e, n) : I;
+  try {
+    for (E = 0; E < g.length; E++) {
+      const n = g[E];
+      if (n && !(n.flags & 8)) {
+        if (process.env.NODE_ENV !== "production" && t(n))
+          continue;
+        n.flags & 4 && (n.flags &= -2), J(
+          n,
+          n.i,
+          n.i ? 15 : 14
+        ), n.flags & 4 || (n.flags &= -2);
+      }
+    }
+  } finally {
+    for (; E < g.length; E++) {
+      const n = g[E];
+      n && (n.flags &= -2);
+    }
+    E = -1, g.length = 0, Me(e), j = null, (g.length || x.length) && pe(e);
+  }
+}
+function de(e, t) {
+  const n = e.get(t) || 0;
+  if (n > He) {
+    const o = t.i, s = o && we(o.type);
+    return ee(
+      `Maximum recursive updates exceeded${s ? ` in component <${s}>` : ""}. 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.`,
+      null,
+      10
+    ), !0;
+  }
+  return e.set(t, n + 1), !1;
+}
+const K = /* @__PURE__ */ new Map();
+process.env.NODE_ENV !== "production" && (W().__VUE_HMR_RUNTIME__ = {
+  createRecord: B(Ue),
+  rerender: B(We),
+  reload: B(Je)
+});
+const H = /* @__PURE__ */ new Map();
+function Ue(e, t) {
+  return H.has(e) ? !1 : (H.set(e, {
+    initialDef: A(t),
+    instances: /* @__PURE__ */ new Set()
+  }), !0);
+}
+function A(e) {
+  return Oe(e) ? e.__vccOpts : e;
+}
+function We(e, t) {
+  const n = H.get(e);
+  n && (n.initialDef.render = t, [...n.instances].forEach((o) => {
+    t && (o.render = t, A(o.type).render = t), o.renderCache = [], o.update();
+  }));
+}
+function Je(e, t) {
+  const n = H.get(e);
+  if (!n) return;
+  t = A(t), oe(n.initialDef, t);
+  const o = [...n.instances];
+  for (let s = 0; s < o.length; s++) {
+    const r = o[s], l = A(r.type);
+    let c = K.get(l);
+    c || (l !== n.initialDef && oe(l, t), K.set(l, c = /* @__PURE__ */ new Set())), c.add(r), r.appContext.propsCache.delete(r.type), r.appContext.emitsCache.delete(r.type), r.appContext.optionsCache.delete(r.type), r.ceReload ? (c.add(r), r.ceReload(t.styles), c.delete(r)) : r.parent ? ae(() => {
+      r.parent.update(), c.delete(r);
+    }) : r.appContext.reload ? r.appContext.reload() : typeof window < "u" ? window.location.reload() : console.warn(
+      "[HMR] Root or manually mounted instance modified. Full reload required."
+    ), r.root.ce && r !== r.root && r.root.ce._removeChildStyle(l);
+  }
+  fe(() => {
+    K.clear();
+  });
+}
+function oe(e, t) {
+  k(e, t);
+  for (const n in e)
+    n !== "__file" && !(n in t) && delete e[n];
+}
+function B(e) {
+  return (t, n) => {
+    try {
+      return e(t, n);
+    } catch (o) {
+      console.error(o), console.warn(
+        "[HMR] Something went wrong during Vue component hot-reload. Full reload required."
+      );
+    }
+  };
+}
+let V, F = [];
+function he(e, t) {
+  var n, o;
+  V = e, V ? (V.enabled = !0, F.forEach(({ event: s, args: r }) => V.emit(s, ...r)), F = []) : /* handle late devtools injection - only do this if we are in an actual */ /* browser environment to avoid the timer handle stalling test runner exit */ /* (#4815) */ typeof window < "u" && // some envs mock window but not fully
+  window.HTMLElement && // also exclude jsdom
+  // eslint-disable-next-line no-restricted-syntax
+  !((o = (n = window.navigator) == null ? void 0 : n.userAgent) != null && o.includes("jsdom")) ? ((t.__VUE_DEVTOOLS_HOOK_REPLAY__ = t.__VUE_DEVTOOLS_HOOK_REPLAY__ || []).push((r) => {
+    he(r, t);
+  }), setTimeout(() => {
+    V || (t.__VUE_DEVTOOLS_HOOK_REPLAY__ = null, F = []);
+  }, 3e3)) : F = [];
+}
+let b = null, Le = null;
+const qe = (e) => e.__isTeleport;
+function me(e, t) {
+  e.shapeFlag & 6 && e.component ? (e.transition = t, me(e.component.subTree, t)) : e.shapeFlag & 128 ? (e.ssContent.transition = t.clone(e.ssContent), e.ssFallback.transition = t.clone(e.ssFallback)) : e.transition = t;
+}
+/*! #__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function ht(e, t) {
+  return y(e) ? (
+    // #8236: extend call and options.name access are considered side-effects
+    // by Rollup, so we have to wrap it in a pure-annotated IIFE.
+    k({ name: e.name }, t, { setup: e })
+  ) : e;
+}
+W().requestIdleCallback;
+W().cancelIdleCallback;
+const ze = Symbol.for("v-ndc"), Ke = {};
+process.env.NODE_ENV !== "production" && (Ke.ownKeys = (e) => (m(
+  "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)));
+let Be = null;
+function Ye(e, t, n = !1) {
+  const o = L || b;
+  if (o || Be) {
+    const s = o ? o.parent == null ? o.vnode.appContext && o.vnode.appContext.provides : o.parent.provides : void 0;
+    if (s && e in s)
+      return s[e];
+    if (arguments.length > 1)
+      return n && y(t) ? t.call(o && o.proxy) : t;
+    process.env.NODE_ENV !== "production" && m(`injection "${String(e)}" not found.`);
+  } else process.env.NODE_ENV !== "production" && m("inject() can only be used inside setup() or functional components.");
+}
+const je = {}, ge = (e) => Object.getPrototypeOf(e) === je, Ge = tt, Qe = Symbol.for("v-scx"), Xe = () => {
+  {
+    const e = Ye(Qe);
+    return e || process.env.NODE_ENV !== "production" && m(
+      "Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build."
+    ), e;
+  }
+};
+function mt(e, t) {
+  return Ze(e, null, t);
+}
+function Ze(e, t, n = P) {
+  const { immediate: o, deep: s, flush: r, once: l } = n;
+  process.env.NODE_ENV !== "production" && (o !== void 0 && m(
+    'watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.'
+  ), s !== void 0 && m(
+    'watch() "deep" option is only respected when using the watch(source, callback, options?) signature.'
+  ), l !== void 0 && m(
+    'watch() "once" option is only respected when using the watch(source, callback, options?) signature.'
+  ));
+  const c = k({}, n);
+  process.env.NODE_ENV !== "production" && (c.onWarn = m);
+  const f = r !== "post";
+  let d;
+  if (U) {
+    if (r === "sync") {
+      const a = Xe();
+      d = a.__watcherHandles || (a.__watcherHandles = []);
+    } else if (!f) {
+      const a = () => {
+      };
+      return a.stop = I, a.resume = I, a.pause = I, a;
+    }
+  }
+  const p = L;
+  c.call = (a, h, w) => le(a, p, h, w);
+  let i = !1;
+  r === "post" ? c.scheduler = (a) => {
+    Ge(a, p && p.suspense);
+  } : r !== "sync" && (i = !0, c.scheduler = (a, h) => {
+    h ? a() : ae(a);
+  }), c.augmentJob = (a) => {
+    i && (a.flags |= 2, p && (a.id = p.uid, a.i = p));
+  };
+  const u = ve(e, t, c);
+  return U && (d ? d.push(u) : f && u()), u;
+}
+const et = (e) => e.__isSuspense;
+function tt(e, t) {
+  t && t.pendingBranch ? _(e) ? t.effects.push(...e) : t.effects.push(e) : fe(e);
+}
+const _e = Symbol.for("v-fgt"), nt = Symbol.for("v-txt"), ot = Symbol.for("v-cmt");
+function G(e) {
+  return e ? e.__v_isVNode === !0 : !1;
+}
+const rt = (...e) => Ee(
+  ...e
+), ye = ({ key: e }) => e ?? null, $ = ({
+  ref: e,
+  ref_key: t,
+  ref_for: n
+}) => (typeof e == "number" && (e = "" + e), e != null ? D(e) || Q(e) || y(e) ? { i: b, r: e, k: t, f: !!n } : e : null);
+function st(e, t = null, n = null, o = 0, s = null, r = e === _e ? 0 : 1, l = !1, c = !1) {
+  const f = {
+    __v_isVNode: !0,
+    __v_skip: !0,
+    type: e,
+    props: t,
+    key: t && ye(t),
+    ref: t && $(t),
+    scopeId: Le,
+    slotScopeIds: null,
+    children: n,
+    component: null,
+    suspense: null,
+    ssContent: null,
+    ssFallback: null,
+    dirs: null,
+    transition: null,
+    el: null,
+    anchor: null,
+    target: null,
+    targetStart: null,
+    targetAnchor: null,
+    staticCount: 0,
+    shapeFlag: r,
+    patchFlag: o,
+    dynamicProps: s,
+    dynamicChildren: null,
+    appContext: null,
+    ctx: b
+  };
+  return c ? (te(f, n), r & 128 && e.normalize(f)) : n && (f.shapeFlag |= D(n) ? 8 : 16), process.env.NODE_ENV !== "production" && f.key !== f.key && m("VNode created with invalid key (NaN). VNode type:", f.type), f;
+}
+const R = process.env.NODE_ENV !== "production" ? rt : Ee;
+function Ee(e, t = null, n = null, o = 0, s = null, r = !1) {
+  if ((!e || e === ze) && (process.env.NODE_ENV !== "production" && !e && m(`Invalid vnode type when creating vnode: ${e}.`), e = ot), G(e)) {
+    const c = M(
+      e,
+      t,
+      !0
+      /* mergeRef: true */
+    );
+    return n && te(c, n), c.patchFlag = -2, c;
+  }
+  if (Oe(e) && (e = e.__vccOpts), t) {
+    t = it(t);
+    let { class: c, style: f } = t;
+    c && !D(c) && (t.class = re(c)), v(f) && (Y(f) && !_(f) && (f = k({}, f)), t.style = se(f));
+  }
+  const l = D(e) ? 1 : et(e) ? 128 : qe(e) ? 64 : v(e) ? 4 : y(e) ? 2 : 0;
+  return process.env.NODE_ENV !== "production" && l & 4 && Y(e) && (e = C(e), m(
+    "Vue received a Component that 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
+  )), st(
+    e,
+    t,
+    n,
+    o,
+    s,
+    l,
+    r,
+    !0
+  );
+}
+function it(e) {
+  return e ? Y(e) || ge(e) ? k({}, e) : e : null;
+}
+function M(e, t, n = !1, o = !1) {
+  const { props: s, ref: r, patchFlag: l, children: c, transition: f } = e, d = t ? lt(s || {}, t) : s, p = {
+    __v_isVNode: !0,
+    __v_skip: !0,
+    type: e.type,
+    props: d,
+    key: d && ye(d),
+    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 ? _(r) ? r.concat($(t)) : [r, $(t)] : $(t)
+    ) : r,
+    scopeId: e.scopeId,
+    slotScopeIds: e.slotScopeIds,
+    children: process.env.NODE_ENV !== "production" && l === -1 && _(c) ? c.map(Ne) : c,
+    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 !== _e ? l === -1 ? 16 : l | 16 : l,
+    dynamicProps: e.dynamicProps,
+    dynamicChildren: e.dynamicChildren,
+    appContext: e.appContext,
+    dirs: e.dirs,
+    transition: f,
+    // These should technically only be non-null on mounted VNodes. However,
+    // they *should* be copied for kept-alive vnodes. So we just always copy
+    // them since them being non-null during a mount doesn't affect the logic as
+    // they will simply be overwritten.
+    component: e.component,
+    suspense: e.suspense,
+    ssContent: e.ssContent && M(e.ssContent),
+    ssFallback: e.ssFallback && M(e.ssFallback),
+    el: e.el,
+    anchor: e.anchor,
+    ctx: e.ctx,
+    ce: e.ce
+  };
+  return f && o && me(
+    p,
+    f.clone(p)
+  ), p;
+}
+function Ne(e) {
+  const t = M(e);
+  return _(e.children) && (t.children = e.children.map(Ne)), t;
+}
+function ct(e = " ", t = 0) {
+  return R(nt, null, e, t);
+}
+function te(e, t) {
+  let n = 0;
+  const { shapeFlag: o } = e;
+  if (t == null)
+    t = null;
+  else if (_(t))
+    n = 16;
+  else if (typeof t == "object")
+    if (o & 65) {
+      const s = t.default;
+      s && (s._c && (s._d = !1), te(e, s()), s._c && (s._d = !0));
+      return;
+    } else
+      n = 32, !t._ && !ge(t) && (t._ctx = b);
+  else y(t) ? (t = { default: t, _ctx: b }, n = 32) : (t = String(t), o & 64 ? (n = 16, t = [ct(t)]) : n = 8);
+  e.children = t, e.shapeFlag |= n;
+}
+function lt(...e) {
+  const t = {};
+  for (let n = 0; n < e.length; n++) {
+    const o = e[n];
+    for (const s in o)
+      if (s === "class")
+        t.class !== o.class && (t.class = re([t.class, o.class]));
+      else if (s === "style")
+        t.style = se([t.style, o.style]);
+      else if (xe(s)) {
+        const r = t[s], l = o[s];
+        l && r !== l && !(_(r) && r.includes(l)) && (t[s] = r ? [].concat(r, l) : l);
+      } else s !== "" && (t[s] = o[s]);
+  }
+  return t;
+}
+let L = null;
+const at = () => L || b;
+{
+  const e = W(), t = (n, o) => {
+    let s;
+    return (s = e[n]) || (s = e[n] = []), s.push(o), (r) => {
+      s.length > 1 ? s.forEach((l) => l(r)) : s[0](r);
+    };
+  };
+  t(
+    "__VUE_INSTANCE_SETTERS__",
+    (n) => L = n
+  ), t(
+    "__VUE_SSR_SETTERS__",
+    (n) => U = n
+  );
+}
+let U = !1;
+process.env.NODE_ENV;
+const ut = /(?:^|[-_])(\w)/g, ft = (e) => e.replace(ut, (t) => t.toUpperCase()).replace(/[-_]/g, "");
+function we(e, t = !0) {
+  return y(e) ? e.displayName || e.name : e.name || t && e.__name;
+}
+function Se(e, t, n = !1) {
+  let o = we(t);
+  if (!o && t.__file) {
+    const s = t.__file.match(/([^/\\]+)\.\w+$/);
+    s && (o = s[1]);
+  }
+  if (!o && e && e.parent) {
+    const s = (r) => {
+      for (const l in r)
+        if (r[l] === t)
+          return l;
+    };
+    o = s(
+      e.components || e.parent.type.components
+    ) || s(e.appContext.components);
+  }
+  return o ? ft(o) : n ? "App" : "Anonymous";
+}
+function Oe(e) {
+  return y(e) && "__vccOpts" in e;
+}
+const gt = (e, t) => {
+  const n = Ce(e, t, U);
+  if (process.env.NODE_ENV !== "production") {
+    const o = at();
+    o && o.appContext.config.warnRecursiveComputed && (n._warnRecursive = !0);
+  }
+  return n;
+};
+function _t(e, t, n) {
+  const o = arguments.length;
+  return o === 2 ? v(t) && !_(t) ? G(t) ? R(e, null, [t]) : R(e, t) : R(e, null, t) : (o > 3 ? n = Array.prototype.slice.call(arguments, 2) : o === 3 && G(n) && (n = [n]), R(e, t, n));
+}
+function yt() {
+  if (process.env.NODE_ENV === "production" || typeof window > "u")
+    return;
+  const e = { style: "color:#3ba776" }, t = { style: "color:#1677ff" }, n = { style: "color:#f5222d" }, o = { style: "color:#eb2f96" }, s = {
+    __vue_custom_formatter: !0,
+    header(i) {
+      if (!v(i))
+        return null;
+      if (i.__isVue)
+        return ["div", e, "VueInstance"];
+      if (Q(i)) {
+        X();
+        const u = i.value;
+        return Z(), [
+          "div",
+          {},
+          ["span", e, p(i)],
+          "<",
+          c(u),
+          ">"
+        ];
+      } else {
+        if (Ve(i))
+          return [
+            "div",
+            {},
+            ["span", e, q(i) ? "ShallowReactive" : "Reactive"],
+            "<",
+            c(i),
+            `>${ne(i) ? " (readonly)" : ""}`
+          ];
+        if (ne(i))
+          return [
+            "div",
+            {},
+            ["span", e, q(i) ? "ShallowReadonly" : "Readonly"],
+            "<",
+            c(i),
+            ">"
+          ];
+      }
+      return null;
+    },
+    hasBody(i) {
+      return i && i.__isVue;
+    },
+    body(i) {
+      if (i && i.__isVue)
+        return [
+          "div",
+          {},
+          ...r(i.$)
+        ];
+    }
+  };
+  function r(i) {
+    const u = [];
+    i.type.props && i.props && u.push(l("props", C(i.props))), i.setupState !== P && u.push(l("setup", i.setupState)), i.data !== P && u.push(l("data", C(i.data)));
+    const a = f(i, "computed");
+    a && u.push(l("computed", a));
+    const h = f(i, "inject");
+    return h && u.push(l("injected", h)), u.push([
+      "div",
+      {},
+      [
+        "span",
+        {
+          style: o.style + ";opacity:0.66"
+        },
+        "$ (internal): "
+      ],
+      ["object", { object: i }]
+    ]), u;
+  }
+  function l(i, u) {
+    return u = k({}, u), Object.keys(u).length ? [
+      "div",
+      { style: "line-height:1.25em;margin-bottom:0.6em" },
+      [
+        "div",
+        {
+          style: "color:#476582"
+        },
+        i
+      ],
+      [
+        "div",
+        {
+          style: "padding-left:1.25em"
+        },
+        ...Object.keys(u).map((a) => [
+          "div",
+          {},
+          ["span", o, a + ": "],
+          c(u[a], !1)
+        ])
+      ]
+    ] : ["span", {}];
+  }
+  function c(i, u = !0) {
+    return typeof i == "number" ? ["span", t, i] : typeof i == "string" ? ["span", n, JSON.stringify(i)] : typeof i == "boolean" ? ["span", o, i] : v(i) ? ["object", { object: u ? C(i) : i }] : ["span", n, String(i)];
+  }
+  function f(i, u) {
+    const a = i.type;
+    if (y(a))
+      return;
+    const h = {};
+    for (const w in i.ctx)
+      d(a, w, u) && (h[w] = i.ctx[w]);
+    return h;
+  }
+  function d(i, u, a) {
+    const h = i[a];
+    if (_(h) && h.includes(u) || v(h) && u in h || i.extends && d(i.extends, u, a) || i.mixins && i.mixins.some((w) => d(w, u, a)))
+      return !0;
+  }
+  function p(i) {
+    return q(i) ? "ShallowRef" : i.effect ? "ComputedRef" : "Ref";
+  }
+  window.devtoolsFormatters ? window.devtoolsFormatters.push(s) : window.devtoolsFormatters = [s];
+}
+process.env.NODE_ENV !== "production" || I;
+process.env.NODE_ENV;
+process.env.NODE_ENV;
+export {
+  ot as Comment,
+  _e as Fragment,
+  wt as ReactiveEffect,
+  nt as Text,
+  le as callWithAsyncErrorHandling,
+  J as callWithErrorHandling,
+  xt as capitalize,
+  M as cloneVNode,
+  gt as computed,
+  st as createElementVNode,
+  ct as createTextVNode,
+  R as createVNode,
+  ht as defineComponent,
+  at as getCurrentInstance,
+  it as guardReactiveProps,
+  _t as h,
+  ee as handleError,
+  yt as initCustomFormatter,
+  Ye as inject,
+  Y as isProxy,
+  Ve as isReactive,
+  ne as isReadonly,
+  Q as isRef,
+  q as isShallow,
+  G as isVNode,
+  lt as mergeProps,
+  re as normalizeClass,
+  se as normalizeStyle,
+  St as onWatcherCleanup,
+  fe as queuePostFlushCb,
+  Ot as reactive,
+  Vt as readonly,
+  me as setTransitionHooks,
+  Qe as ssrContextKey,
+  C as toRaw,
+  Ct as unref,
+  Xe as useSSRContext,
+  mt as watchEffect
+};