vite-plugin-vue-devtools 0.4.7 → 0.4.10

package/dist/client/assets/{index-233a79fb.js → index-b8a9099c.js}

@@ -73,6 +73,7 @@ const isArray$1 = Array.isArray;
 const isMap = (val) => toTypeString(val) === "[object Map]";
 const isSet = (val) => toTypeString(val) === "[object Set]";
 const isDate = (val) => toTypeString(val) === "[object Date]";
+const isRegExp = (val) => toTypeString(val) === "[object RegExp]";
 const isFunction = (val) => typeof val === "function";
 const isString = (val) => typeof val === "string";
 const isSymbol = (val) => typeof val === "symbol";
@@ -138,6 +139,9 @@ const getGlobalThis = () => {
   return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
 };
 
+const GLOBALS_WHITE_LISTED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console";
+const isGloballyWhitelisted = /* @__PURE__ */ makeMap(GLOBALS_WHITE_LISTED);
+
 function normalizeStyle(value) {
   if (isArray$1(value)) {
     const res = {};
@@ -363,6 +367,9 @@ class EffectScope {
     }
   }
 }
+function effectScope(detached) {
+  return new EffectScope(detached);
+}
 function recordEffectScope(effect, scope = activeEffectScope) {
   if (scope && scope.active) {
     scope.effects.push(effect);
@@ -483,6 +490,26 @@ function cleanupEffect(effect2) {
     deps.length = 0;
   }
 }
+function effect(fn, options) {
+  if (fn.effect) {
+    fn = fn.effect.fn;
+  }
+  const _effect = new ReactiveEffect(fn);
+  if (options) {
+    extend(_effect, options);
+    if (options.scope)
+      recordEffectScope(_effect, options.scope);
+  }
+  if (!options || !options.lazy) {
+    _effect.run();
+  }
+  const runner = _effect.run.bind(_effect);
+  runner.effect = _effect;
+  return runner;
+}
+function stop(runner) {
+  runner.effect.stop();
+}
 let shouldTrack = true;
 const trackStack = [];
 function pauseTracking() {
@@ -618,6 +645,7 @@ const builtInSymbols = new Set(
 const get$1 = /* @__PURE__ */ createGetter();
 const shallowGet = /* @__PURE__ */ createGetter(false, true);
 const readonlyGet = /* @__PURE__ */ createGetter(true);
+const shallowReadonlyGet = /* @__PURE__ */ createGetter(true, true);
 const arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
 function createArrayInstrumentations() {
   const instrumentations = {};
@@ -763,6 +791,13 @@ const shallowReactiveHandlers = /* @__PURE__ */ extend(
     set: shallowSet
   }
 );
+const shallowReadonlyHandlers = /* @__PURE__ */ extend(
+  {},
+  readonlyHandlers,
+  {
+    get: shallowReadonlyGet
+  }
+);
 
 const toShallow = (value) => value;
 const getProto = (v) => Reflect.getPrototypeOf(v);
@@ -1026,6 +1061,9 @@ const shallowCollectionHandlers = {
 const readonlyCollectionHandlers = {
   get: /* @__PURE__ */ createInstrumentationGetter(true, false)
 };
+const shallowReadonlyCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(true, true)
+};
 
 const reactiveMap = /* @__PURE__ */ new WeakMap();
 const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
@@ -1078,6 +1116,15 @@ function readonly(target) {
     readonlyMap
   );
 }
+function shallowReadonly(target) {
+  return createReactiveObject(
+    target,
+    true,
+    shallowReadonlyHandlers,
+    shallowReadonlyCollectionHandlers,
+    shallowReadonlyMap
+  );
+}
 function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
   if (!isObject(target)) {
     return target;
@@ -1186,6 +1233,9 @@ function triggerRef(ref2) {
 function unref(ref2) {
   return isRef(ref2) ? ref2.value : ref2;
 }
+function toValue$2(source) {
+  return isFunction(source) ? source() : unref(source);
+}
 const shallowUnwrapHandlers = {
   get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
   set: (target, key, value, receiver) => {
@@ -1327,6 +1377,9 @@ function computed$1(getterOrOptions, debugOptions, isSSR = false) {
 function warn(msg, ...args) {
   return;
 }
+function assertNumber(val, type) {
+  return;
+}
 function callWithErrorHandling(fn, instance, type, args) {
   let res;
   try {
@@ -1512,6 +1565,38 @@ function flushJobs(seen) {
   }
 }
 
+let devtools;
+let buffer = [];
+function setDevtoolsHook(hook, target) {
+  var _a, _b;
+  devtools = hook;
+  if (devtools) {
+    devtools.enabled = true;
+    buffer.forEach(({ event, args }) => devtools.emit(event, ...args));
+    buffer = [];
+  } else if (
+    // 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 !== "undefined" && // some envs mock window but not fully
+    window.HTMLElement && // also exclude jsdom
+    !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))
+  ) {
+    const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
+    replay.push((newHook) => {
+      setDevtoolsHook(newHook, target);
+    });
+    setTimeout(() => {
+      if (!devtools) {
+        target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
+        buffer = [];
+      }
+    }, 3e3);
+  } else {
+    buffer = [];
+  }
+}
+
 function emit(instance, event, ...rawArgs) {
   if (instance.isUnmounted)
     return;
@@ -1746,6 +1831,24 @@ function renderComponentRoot(instance) {
   setCurrentRenderingInstance(prev);
   return result;
 }
+function filterSingleRoot(children) {
+  let singleRoot;
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    if (isVNode(child)) {
+      if (child.type !== Comment || child.children === "v-if") {
+        if (singleRoot) {
+          return;
+        } else {
+          singleRoot = child;
+        }
+      }
+    } else {
+      return;
+    }
+  }
+  return singleRoot;
+}
 const getFunctionalFallthrough = (attrs) => {
   let res;
   for (const key in attrs) {
@@ -1829,6 +1932,517 @@ function updateHOCHostEl({ vnode, parent }, el) {
 }
 
 const isSuspense = (type) => type.__isSuspense;
+const SuspenseImpl = {
+  name: "Suspense",
+  // In order to make Suspense tree-shakable, we need to avoid importing it
+  // directly in the renderer. The renderer checks for the __isSuspense flag
+  // on a vnode's type and calls the `process` method, passing in renderer
+  // internals.
+  __isSuspense: true,
+  process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) {
+    if (n1 == null) {
+      mountSuspense(
+        n2,
+        container,
+        anchor,
+        parentComponent,
+        parentSuspense,
+        isSVG,
+        slotScopeIds,
+        optimized,
+        rendererInternals
+      );
+    } else {
+      patchSuspense(
+        n1,
+        n2,
+        container,
+        anchor,
+        parentComponent,
+        isSVG,
+        slotScopeIds,
+        optimized,
+        rendererInternals
+      );
+    }
+  },
+  hydrate: hydrateSuspense,
+  create: createSuspenseBoundary,
+  normalize: normalizeSuspenseChildren
+};
+const Suspense = SuspenseImpl ;
+function triggerEvent(vnode, name) {
+  const eventListener = vnode.props && vnode.props[name];
+  if (isFunction(eventListener)) {
+    eventListener();
+  }
+}
+function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) {
+  const {
+    p: patch,
+    o: { createElement }
+  } = rendererInternals;
+  const hiddenContainer = createElement("div");
+  const suspense = vnode.suspense = createSuspenseBoundary(
+    vnode,
+    parentSuspense,
+    parentComponent,
+    container,
+    hiddenContainer,
+    anchor,
+    isSVG,
+    slotScopeIds,
+    optimized,
+    rendererInternals
+  );
+  patch(
+    null,
+    suspense.pendingBranch = vnode.ssContent,
+    hiddenContainer,
+    null,
+    parentComponent,
+    suspense,
+    isSVG,
+    slotScopeIds
+  );
+  if (suspense.deps > 0) {
+    triggerEvent(vnode, "onPending");
+    triggerEvent(vnode, "onFallback");
+    patch(
+      null,
+      vnode.ssFallback,
+      container,
+      anchor,
+      parentComponent,
+      null,
+      // fallback tree will not have suspense context
+      isSVG,
+      slotScopeIds
+    );
+    setActiveBranch(suspense, vnode.ssFallback);
+  } else {
+    suspense.resolve(false, true);
+  }
+}
+function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) {
+  const suspense = n2.suspense = n1.suspense;
+  suspense.vnode = n2;
+  n2.el = n1.el;
+  const newBranch = n2.ssContent;
+  const newFallback = n2.ssFallback;
+  const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense;
+  if (pendingBranch) {
+    suspense.pendingBranch = newBranch;
+    if (isSameVNodeType(newBranch, pendingBranch)) {
+      patch(
+        pendingBranch,
+        newBranch,
+        suspense.hiddenContainer,
+        null,
+        parentComponent,
+        suspense,
+        isSVG,
+        slotScopeIds,
+        optimized
+      );
+      if (suspense.deps <= 0) {
+        suspense.resolve();
+      } else if (isInFallback) {
+        patch(
+          activeBranch,
+          newFallback,
+          container,
+          anchor,
+          parentComponent,
+          null,
+          // fallback tree will not have suspense context
+          isSVG,
+          slotScopeIds,
+          optimized
+        );
+        setActiveBranch(suspense, newFallback);
+      }
+    } else {
+      suspense.pendingId++;
+      if (isHydrating) {
+        suspense.isHydrating = false;
+        suspense.activeBranch = pendingBranch;
+      } else {
+        unmount(pendingBranch, parentComponent, suspense);
+      }
+      suspense.deps = 0;
+      suspense.effects.length = 0;
+      suspense.hiddenContainer = createElement("div");
+      if (isInFallback) {
+        patch(
+          null,
+          newBranch,
+          suspense.hiddenContainer,
+          null,
+          parentComponent,
+          suspense,
+          isSVG,
+          slotScopeIds,
+          optimized
+        );
+        if (suspense.deps <= 0) {
+          suspense.resolve();
+        } else {
+          patch(
+            activeBranch,
+            newFallback,
+            container,
+            anchor,
+            parentComponent,
+            null,
+            // fallback tree will not have suspense context
+            isSVG,
+            slotScopeIds,
+            optimized
+          );
+          setActiveBranch(suspense, newFallback);
+        }
+      } else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
+        patch(
+          activeBranch,
+          newBranch,
+          container,
+          anchor,
+          parentComponent,
+          suspense,
+          isSVG,
+          slotScopeIds,
+          optimized
+        );
+        suspense.resolve(true);
+      } else {
+        patch(
+          null,
+          newBranch,
+          suspense.hiddenContainer,
+          null,
+          parentComponent,
+          suspense,
+          isSVG,
+          slotScopeIds,
+          optimized
+        );
+        if (suspense.deps <= 0) {
+          suspense.resolve();
+        }
+      }
+    }
+  } else {
+    if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
+      patch(
+        activeBranch,
+        newBranch,
+        container,
+        anchor,
+        parentComponent,
+        suspense,
+        isSVG,
+        slotScopeIds,
+        optimized
+      );
+      setActiveBranch(suspense, newBranch);
+    } else {
+      triggerEvent(n2, "onPending");
+      suspense.pendingBranch = newBranch;
+      suspense.pendingId++;
+      patch(
+        null,
+        newBranch,
+        suspense.hiddenContainer,
+        null,
+        parentComponent,
+        suspense,
+        isSVG,
+        slotScopeIds,
+        optimized
+      );
+      if (suspense.deps <= 0) {
+        suspense.resolve();
+      } else {
+        const { timeout, pendingId } = suspense;
+        if (timeout > 0) {
+          setTimeout(() => {
+            if (suspense.pendingId === pendingId) {
+              suspense.fallback(newFallback);
+            }
+          }, timeout);
+        } else if (timeout === 0) {
+          suspense.fallback(newFallback);
+        }
+      }
+    }
+  }
+}
+function createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals, isHydrating = false) {
+  const {
+    p: patch,
+    m: move,
+    um: unmount,
+    n: next,
+    o: { parentNode, remove }
+  } = rendererInternals;
+  let parentSuspenseId;
+  const isSuspensible = isVNodeSuspensible(vnode);
+  if (isSuspensible) {
+    if (parentSuspense == null ? void 0 : parentSuspense.pendingBranch) {
+      parentSuspenseId = parentSuspense.pendingId;
+      parentSuspense.deps++;
+    }
+  }
+  const timeout = vnode.props ? toNumber(vnode.props.timeout) : void 0;
+  const suspense = {
+    vnode,
+    parent: parentSuspense,
+    parentComponent,
+    isSVG,
+    container,
+    hiddenContainer,
+    anchor,
+    deps: 0,
+    pendingId: 0,
+    timeout: typeof timeout === "number" ? timeout : -1,
+    activeBranch: null,
+    pendingBranch: null,
+    isInFallback: true,
+    isHydrating,
+    isUnmounted: false,
+    effects: [],
+    resolve(resume = false, sync = false) {
+      const {
+        vnode: vnode2,
+        activeBranch,
+        pendingBranch,
+        pendingId,
+        effects,
+        parentComponent: parentComponent2,
+        container: container2
+      } = suspense;
+      if (suspense.isHydrating) {
+        suspense.isHydrating = false;
+      } else if (!resume) {
+        const delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === "out-in";
+        if (delayEnter) {
+          activeBranch.transition.afterLeave = () => {
+            if (pendingId === suspense.pendingId) {
+              move(pendingBranch, container2, anchor2, 0);
+            }
+          };
+        }
+        let { anchor: anchor2 } = suspense;
+        if (activeBranch) {
+          anchor2 = next(activeBranch);
+          unmount(activeBranch, parentComponent2, suspense, true);
+        }
+        if (!delayEnter) {
+          move(pendingBranch, container2, anchor2, 0);
+        }
+      }
+      setActiveBranch(suspense, pendingBranch);
+      suspense.pendingBranch = null;
+      suspense.isInFallback = false;
+      let parent = suspense.parent;
+      let hasUnresolvedAncestor = false;
+      while (parent) {
+        if (parent.pendingBranch) {
+          parent.effects.push(...effects);
+          hasUnresolvedAncestor = true;
+          break;
+        }
+        parent = parent.parent;
+      }
+      if (!hasUnresolvedAncestor) {
+        queuePostFlushCb(effects);
+      }
+      suspense.effects = [];
+      if (isSuspensible) {
+        if (parentSuspense && parentSuspense.pendingBranch && parentSuspenseId === parentSuspense.pendingId) {
+          parentSuspense.deps--;
+          if (parentSuspense.deps === 0 && !sync) {
+            parentSuspense.resolve();
+          }
+        }
+      }
+      triggerEvent(vnode2, "onResolve");
+    },
+    fallback(fallbackVNode) {
+      if (!suspense.pendingBranch) {
+        return;
+      }
+      const { vnode: vnode2, activeBranch, parentComponent: parentComponent2, container: container2, isSVG: isSVG2 } = suspense;
+      triggerEvent(vnode2, "onFallback");
+      const anchor2 = next(activeBranch);
+      const mountFallback = () => {
+        if (!suspense.isInFallback) {
+          return;
+        }
+        patch(
+          null,
+          fallbackVNode,
+          container2,
+          anchor2,
+          parentComponent2,
+          null,
+          // fallback tree will not have suspense context
+          isSVG2,
+          slotScopeIds,
+          optimized
+        );
+        setActiveBranch(suspense, fallbackVNode);
+      };
+      const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === "out-in";
+      if (delayEnter) {
+        activeBranch.transition.afterLeave = mountFallback;
+      }
+      suspense.isInFallback = true;
+      unmount(
+        activeBranch,
+        parentComponent2,
+        null,
+        // no suspense so unmount hooks fire now
+        true
+        // shouldRemove
+      );
+      if (!delayEnter) {
+        mountFallback();
+      }
+    },
+    move(container2, anchor2, type) {
+      suspense.activeBranch && move(suspense.activeBranch, container2, anchor2, type);
+      suspense.container = container2;
+    },
+    next() {
+      return suspense.activeBranch && next(suspense.activeBranch);
+    },
+    registerDep(instance, setupRenderEffect) {
+      const isInPendingSuspense = !!suspense.pendingBranch;
+      if (isInPendingSuspense) {
+        suspense.deps++;
+      }
+      const hydratedEl = instance.vnode.el;
+      instance.asyncDep.catch((err) => {
+        handleError(err, instance, 0);
+      }).then((asyncSetupResult) => {
+        if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) {
+          return;
+        }
+        instance.asyncResolved = true;
+        const { vnode: vnode2 } = instance;
+        handleSetupResult(instance, asyncSetupResult, false);
+        if (hydratedEl) {
+          vnode2.el = hydratedEl;
+        }
+        const placeholder = !hydratedEl && instance.subTree.el;
+        setupRenderEffect(
+          instance,
+          vnode2,
+          // component may have been moved before resolve.
+          // if this is not a hydration, instance.subTree will be the comment
+          // placeholder.
+          parentNode(hydratedEl || instance.subTree.el),
+          // anchor will not be used if this is hydration, so only need to
+          // consider the comment placeholder case.
+          hydratedEl ? null : next(instance.subTree),
+          suspense,
+          isSVG,
+          optimized
+        );
+        if (placeholder) {
+          remove(placeholder);
+        }
+        updateHOCHostEl(instance, vnode2.el);
+        if (isInPendingSuspense && --suspense.deps === 0) {
+          suspense.resolve();
+        }
+      });
+    },
+    unmount(parentSuspense2, doRemove) {
+      suspense.isUnmounted = true;
+      if (suspense.activeBranch) {
+        unmount(
+          suspense.activeBranch,
+          parentComponent,
+          parentSuspense2,
+          doRemove
+        );
+      }
+      if (suspense.pendingBranch) {
+        unmount(
+          suspense.pendingBranch,
+          parentComponent,
+          parentSuspense2,
+          doRemove
+        );
+      }
+    }
+  };
+  return suspense;
+}
+function hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals, hydrateNode) {
+  const suspense = vnode.suspense = createSuspenseBoundary(
+    vnode,
+    parentSuspense,
+    parentComponent,
+    node.parentNode,
+    document.createElement("div"),
+    null,
+    isSVG,
+    slotScopeIds,
+    optimized,
+    rendererInternals,
+    true
+    /* hydrating */
+  );
+  const result = hydrateNode(
+    node,
+    suspense.pendingBranch = vnode.ssContent,
+    parentComponent,
+    suspense,
+    slotScopeIds,
+    optimized
+  );
+  if (suspense.deps === 0) {
+    suspense.resolve(false, true);
+  }
+  return result;
+}
+function normalizeSuspenseChildren(vnode) {
+  const { shapeFlag, children } = vnode;
+  const isSlotChildren = shapeFlag & 32;
+  vnode.ssContent = normalizeSuspenseSlot(
+    isSlotChildren ? children.default : children
+  );
+  vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(Comment);
+}
+function normalizeSuspenseSlot(s) {
+  let block;
+  if (isFunction(s)) {
+    const trackBlock = isBlockTreeEnabled && s._c;
+    if (trackBlock) {
+      s._d = false;
+      openBlock();
+    }
+    s = s();
+    if (trackBlock) {
+      s._d = true;
+      block = currentBlock;
+      closeBlock();
+    }
+  }
+  if (isArray$1(s)) {
+    const singleChild = filterSingleRoot(s);
+    s = singleChild;
+  }
+  s = normalizeVNode(s);
+  if (block && !s.dynamicChildren) {
+    s.dynamicChildren = block.filter((c) => c !== s);
+  }
+  return s;
+}
 function queueEffectWithSuspense(fn, suspense) {
   if (suspense && suspense.pendingBranch) {
     if (isArray$1(fn)) {
@@ -1840,10 +2454,37 @@ function queueEffectWithSuspense(fn, suspense) {
     queuePostFlushCb(fn);
   }
 }
+function setActiveBranch(suspense, branch) {
+  suspense.activeBranch = branch;
+  const { vnode, parentComponent } = suspense;
+  const el = vnode.el = branch.el;
+  if (parentComponent && parentComponent.subTree === vnode) {
+    parentComponent.vnode.el = el;
+    updateHOCHostEl(parentComponent, el);
+  }
+}
+function isVNodeSuspensible(vnode) {
+  var _a;
+  return ((_a = vnode.props) == null ? void 0 : _a.suspensible) != null && vnode.props.suspensible !== false;
+}
 
 function watchEffect(effect, options) {
   return doWatch(effect, null, options);
 }
+function watchPostEffect(effect, options) {
+  return doWatch(
+    effect,
+    null,
+    { flush: "post" }
+  );
+}
+function watchSyncEffect(effect, options) {
+  return doWatch(
+    effect,
+    null,
+    { flush: "sync" }
+  );
+}
 const INITIAL_WATCHER_VALUE = {};
 function watch(source, cb, options) {
   return doWatch(source, cb, options);
@@ -2417,15 +3058,331 @@ function defineComponent(options, extraOptions) {
 }
 
 const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
-
-const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
-function onActivated(hook, target) {
-  registerKeepAliveHook(hook, "a", target);
-}
-function onDeactivated(hook, target) {
-  registerKeepAliveHook(hook, "da", target);
-}
-function registerKeepAliveHook(hook, type, target = currentInstance) {
+function defineAsyncComponent(source) {
+  if (isFunction(source)) {
+    source = { loader: source };
+  }
+  const {
+    loader,
+    loadingComponent,
+    errorComponent,
+    delay = 200,
+    timeout,
+    // undefined = never times out
+    suspensible = true,
+    onError: userOnError
+  } = source;
+  let pendingRequest = null;
+  let resolvedComp;
+  let retries = 0;
+  const retry = () => {
+    retries++;
+    pendingRequest = null;
+    return load();
+  };
+  const load = () => {
+    let thisRequest;
+    return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => {
+      err = err instanceof Error ? err : new Error(String(err));
+      if (userOnError) {
+        return new Promise((resolve, reject) => {
+          const userRetry = () => resolve(retry());
+          const userFail = () => reject(err);
+          userOnError(err, userRetry, userFail, retries + 1);
+        });
+      } else {
+        throw err;
+      }
+    }).then((comp) => {
+      if (thisRequest !== pendingRequest && pendingRequest) {
+        return pendingRequest;
+      }
+      if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
+        comp = comp.default;
+      }
+      resolvedComp = comp;
+      return comp;
+    }));
+  };
+  return defineComponent({
+    name: "AsyncComponentWrapper",
+    __asyncLoader: load,
+    get __asyncResolved() {
+      return resolvedComp;
+    },
+    setup() {
+      const instance = currentInstance;
+      if (resolvedComp) {
+        return () => createInnerComp(resolvedComp, instance);
+      }
+      const onError = (err) => {
+        pendingRequest = null;
+        handleError(
+          err,
+          instance,
+          13,
+          !errorComponent
+          /* do not throw in dev if user provided error component */
+        );
+      };
+      if (suspensible && instance.suspense || isInSSRComponentSetup) {
+        return load().then((comp) => {
+          return () => createInnerComp(comp, instance);
+        }).catch((err) => {
+          onError(err);
+          return () => errorComponent ? createVNode(errorComponent, {
+            error: err
+          }) : null;
+        });
+      }
+      const loaded = ref(false);
+      const error = ref();
+      const delayed = ref(!!delay);
+      if (delay) {
+        setTimeout(() => {
+          delayed.value = false;
+        }, delay);
+      }
+      if (timeout != null) {
+        setTimeout(() => {
+          if (!loaded.value && !error.value) {
+            const err = new Error(
+              `Async component timed out after ${timeout}ms.`
+            );
+            onError(err);
+            error.value = err;
+          }
+        }, timeout);
+      }
+      load().then(() => {
+        loaded.value = true;
+        if (instance.parent && isKeepAlive(instance.parent.vnode)) {
+          queueJob(instance.parent.update);
+        }
+      }).catch((err) => {
+        onError(err);
+        error.value = err;
+      });
+      return () => {
+        if (loaded.value && resolvedComp) {
+          return createInnerComp(resolvedComp, instance);
+        } else if (error.value && errorComponent) {
+          return createVNode(errorComponent, {
+            error: error.value
+          });
+        } else if (loadingComponent && !delayed.value) {
+          return createVNode(loadingComponent);
+        }
+      };
+    }
+  });
+}
+function createInnerComp(comp, parent) {
+  const { ref: ref2, props, children, ce } = parent.vnode;
+  const vnode = createVNode(comp, props, children);
+  vnode.ref = ref2;
+  vnode.ce = ce;
+  delete parent.vnode.ce;
+  return vnode;
+}
+
+const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
+const KeepAliveImpl = {
+  name: `KeepAlive`,
+  // Marker for special handling inside the renderer. We are not using a ===
+  // check directly on KeepAlive in the renderer, because importing it directly
+  // would prevent it from being tree-shaken.
+  __isKeepAlive: true,
+  props: {
+    include: [String, RegExp, Array],
+    exclude: [String, RegExp, Array],
+    max: [String, Number]
+  },
+  setup(props, { slots }) {
+    const instance = getCurrentInstance();
+    const sharedContext = instance.ctx;
+    if (!sharedContext.renderer) {
+      return () => {
+        const children = slots.default && slots.default();
+        return children && children.length === 1 ? children[0] : children;
+      };
+    }
+    const cache = /* @__PURE__ */ new Map();
+    const keys = /* @__PURE__ */ new Set();
+    let current = null;
+    const parentSuspense = instance.suspense;
+    const {
+      renderer: {
+        p: patch,
+        m: move,
+        um: _unmount,
+        o: { createElement }
+      }
+    } = sharedContext;
+    const storageContainer = createElement("div");
+    sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => {
+      const instance2 = vnode.component;
+      move(vnode, container, anchor, 0, parentSuspense);
+      patch(
+        instance2.vnode,
+        vnode,
+        container,
+        anchor,
+        instance2,
+        parentSuspense,
+        isSVG,
+        vnode.slotScopeIds,
+        optimized
+      );
+      queuePostRenderEffect(() => {
+        instance2.isDeactivated = false;
+        if (instance2.a) {
+          invokeArrayFns(instance2.a);
+        }
+        const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
+        if (vnodeHook) {
+          invokeVNodeHook(vnodeHook, instance2.parent, vnode);
+        }
+      }, parentSuspense);
+    };
+    sharedContext.deactivate = (vnode) => {
+      const instance2 = vnode.component;
+      move(vnode, storageContainer, null, 1, parentSuspense);
+      queuePostRenderEffect(() => {
+        if (instance2.da) {
+          invokeArrayFns(instance2.da);
+        }
+        const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
+        if (vnodeHook) {
+          invokeVNodeHook(vnodeHook, instance2.parent, vnode);
+        }
+        instance2.isDeactivated = true;
+      }, parentSuspense);
+    };
+    function unmount(vnode) {
+      resetShapeFlag(vnode);
+      _unmount(vnode, instance, parentSuspense, true);
+    }
+    function pruneCache(filter) {
+      cache.forEach((vnode, key) => {
+        const name = getComponentName(vnode.type);
+        if (name && (!filter || !filter(name))) {
+          pruneCacheEntry(key);
+        }
+      });
+    }
+    function pruneCacheEntry(key) {
+      const cached = cache.get(key);
+      if (!current || !isSameVNodeType(cached, current)) {
+        unmount(cached);
+      } else if (current) {
+        resetShapeFlag(current);
+      }
+      cache.delete(key);
+      keys.delete(key);
+    }
+    watch(
+      () => [props.include, props.exclude],
+      ([include, exclude]) => {
+        include && pruneCache((name) => matches$1(include, name));
+        exclude && pruneCache((name) => !matches$1(exclude, name));
+      },
+      // prune post-render after `current` has been updated
+      { flush: "post", deep: true }
+    );
+    let pendingCacheKey = null;
+    const cacheSubtree = () => {
+      if (pendingCacheKey != null) {
+        cache.set(pendingCacheKey, getInnerChild(instance.subTree));
+      }
+    };
+    onMounted(cacheSubtree);
+    onUpdated(cacheSubtree);
+    onBeforeUnmount(() => {
+      cache.forEach((cached) => {
+        const { subTree, suspense } = instance;
+        const vnode = getInnerChild(subTree);
+        if (cached.type === vnode.type && cached.key === vnode.key) {
+          resetShapeFlag(vnode);
+          const da = vnode.component.da;
+          da && queuePostRenderEffect(da, suspense);
+          return;
+        }
+        unmount(cached);
+      });
+    });
+    return () => {
+      pendingCacheKey = null;
+      if (!slots.default) {
+        return null;
+      }
+      const children = slots.default();
+      const rawVNode = children[0];
+      if (children.length > 1) {
+        current = null;
+        return children;
+      } else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) {
+        current = null;
+        return rawVNode;
+      }
+      let vnode = getInnerChild(rawVNode);
+      const comp = vnode.type;
+      const name = getComponentName(
+        isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp
+      );
+      const { include, exclude, max } = props;
+      if (include && (!name || !matches$1(include, name)) || exclude && name && matches$1(exclude, name)) {
+        current = vnode;
+        return rawVNode;
+      }
+      const key = vnode.key == null ? comp : vnode.key;
+      const cachedVNode = cache.get(key);
+      if (vnode.el) {
+        vnode = cloneVNode(vnode);
+        if (rawVNode.shapeFlag & 128) {
+          rawVNode.ssContent = vnode;
+        }
+      }
+      pendingCacheKey = key;
+      if (cachedVNode) {
+        vnode.el = cachedVNode.el;
+        vnode.component = cachedVNode.component;
+        if (vnode.transition) {
+          setTransitionHooks(vnode, vnode.transition);
+        }
+        vnode.shapeFlag |= 512;
+        keys.delete(key);
+        keys.add(key);
+      } else {
+        keys.add(key);
+        if (max && keys.size > parseInt(max, 10)) {
+          pruneCacheEntry(keys.values().next().value);
+        }
+      }
+      vnode.shapeFlag |= 256;
+      current = vnode;
+      return isSuspense(rawVNode.type) ? rawVNode : vnode;
+    };
+  }
+};
+const KeepAlive = KeepAliveImpl;
+function matches$1(pattern, name) {
+  if (isArray$1(pattern)) {
+    return pattern.some((p) => matches$1(p, name));
+  } else if (isString(pattern)) {
+    return pattern.split(",").includes(name);
+  } else if (isRegExp(pattern)) {
+    return pattern.test(name);
+  }
+  return false;
+}
+function onActivated(hook, target) {
+  registerKeepAliveHook(hook, "a", target);
+}
+function onDeactivated(hook, target) {
+  registerKeepAliveHook(hook, "da", target);
+}
+function registerKeepAliveHook(hook, type, target = currentInstance) {
   const wrappedHook = hook.__wdc || (hook.__wdc = () => {
     let current = target;
     while (current) {
@@ -2459,6 +3416,13 @@ function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
     remove(keepAliveRoot[type], injected);
   }, target);
 }
+function resetShapeFlag(vnode) {
+  vnode.shapeFlag &= ~256;
+  vnode.shapeFlag &= ~512;
+}
+function getInnerChild(vnode) {
+  return vnode.shapeFlag & 128 ? vnode.ssContent : vnode;
+}
 
 function injectHook(type, hook, target = currentInstance, prepend = false) {
   if (target) {
@@ -2585,6 +3549,25 @@ function renderList(source, renderItem, cache, index) {
   return ret;
 }
 
+function createSlots(slots, dynamicSlots) {
+  for (let i = 0; i < dynamicSlots.length; i++) {
+    const slot = dynamicSlots[i];
+    if (isArray$1(slot)) {
+      for (let j = 0; j < slot.length; j++) {
+        slots[slot[j].name] = slot[j].fn;
+      }
+    } else if (slot) {
+      slots[slot.name] = slot.key ? (...args) => {
+        const res = slot.fn(...args);
+        if (res)
+          res.key = slot.key;
+        return res;
+      } : slot.fn;
+    }
+  }
+  return slots;
+}
+
 function renderSlot(slots, name, props = {}, fallback, noSlotted) {
   if (currentRenderingInstance.isCE || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.isCE) {
     if (name !== "default")
@@ -2759,12 +3742,134 @@ const PublicInstanceProxyHandlers = {
     return Reflect.defineProperty(target, key, descriptor);
   }
 };
+const RuntimeCompiledPublicInstanceProxyHandlers = /* @__PURE__ */ extend(
+  {},
+  PublicInstanceProxyHandlers,
+  {
+    get(target, key) {
+      if (key === Symbol.unscopables) {
+        return;
+      }
+      return PublicInstanceProxyHandlers.get(target, key, target);
+    },
+    has(_, key) {
+      const has = key[0] !== "_" && !isGloballyWhitelisted(key);
+      return has;
+    }
+  }
+);
+function defineProps() {
+  return null;
+}
+function defineEmits() {
+  return null;
+}
+function defineExpose(exposed) {
+}
+function defineOptions(options) {
+}
+function defineSlots() {
+  return null;
+}
+function defineModel() {
+}
+function withDefaults(props, defaults) {
+  return null;
+}
+function useSlots() {
+  return getContext().slots;
+}
+function useAttrs() {
+  return getContext().attrs;
+}
+function useModel(props, name, options) {
+  const i = getCurrentInstance();
+  if (options && options.local) {
+    const proxy = ref(props[name]);
+    watch(
+      () => props[name],
+      (v) => proxy.value = v
+    );
+    watch(proxy, (value) => {
+      if (value !== props[name]) {
+        i.emit(`update:${name}`, value);
+      }
+    });
+    return proxy;
+  } else {
+    return {
+      __v_isRef: true,
+      get value() {
+        return props[name];
+      },
+      set value(value) {
+        i.emit(`update:${name}`, value);
+      }
+    };
+  }
+}
+function getContext() {
+  const i = getCurrentInstance();
+  return i.setupContext || (i.setupContext = createSetupContext(i));
+}
 function normalizePropsOrEmits(props) {
   return isArray$1(props) ? props.reduce(
     (normalized, p) => (normalized[p] = null, normalized),
     {}
   ) : props;
 }
+function mergeDefaults(raw, defaults) {
+  const props = normalizePropsOrEmits(raw);
+  for (const key in defaults) {
+    if (key.startsWith("__skip"))
+      continue;
+    let opt = props[key];
+    if (opt) {
+      if (isArray$1(opt) || isFunction(opt)) {
+        opt = props[key] = { type: opt, default: defaults[key] };
+      } else {
+        opt.default = defaults[key];
+      }
+    } else if (opt === null) {
+      opt = props[key] = { default: defaults[key] };
+    } else ;
+    if (opt && defaults[`__skip_${key}`]) {
+      opt.skipFactory = true;
+    }
+  }
+  return props;
+}
+function mergeModels(a, b) {
+  if (!a || !b)
+    return a || b;
+  if (isArray$1(a) && isArray$1(b))
+    return a.concat(b);
+  return extend({}, normalizePropsOrEmits(a), normalizePropsOrEmits(b));
+}
+function createPropsRestProxy(props, excludedKeys) {
+  const ret = {};
+  for (const key in props) {
+    if (!excludedKeys.includes(key)) {
+      Object.defineProperty(ret, key, {
+        enumerable: true,
+        get: () => props[key]
+      });
+    }
+  }
+  return ret;
+}
+function withAsyncContext(getAwaitable) {
+  const ctx = getCurrentInstance();
+  let awaitable = getAwaitable();
+  unsetCurrentInstance();
+  if (isPromise(awaitable)) {
+    awaitable = awaitable.catch((e) => {
+      setCurrentInstance(ctx);
+      throw e;
+    });
+  }
+  return [awaitable, () => setCurrentInstance(ctx)];
+}
 let shouldCacheAccess = true;
 function applyOptions(instance) {
   const options = resolveMergedOptions(instance);
@@ -3241,6 +4346,9 @@ function inject(key, defaultValue, treatDefaultAsFactory = false) {
     } else ;
   }
 }
+function hasInjectionContext() {
+  return !!(currentInstance || currentRenderingInstance || currentApp);
+}
 
 function initProps(instance, rawProps, isStateful, isSSR = false) {
   const props = {};
@@ -3610,79 +4718,446 @@ function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
         isUnmount
       )
     );
-    return;
-  }
-  if (isAsyncWrapper(vnode) && !isUnmount) {
-    return;
-  }
-  const refValue = vnode.shapeFlag & 4 ? getExposeProxy(vnode.component) || vnode.component.proxy : vnode.el;
-  const value = isUnmount ? null : refValue;
-  const { i: owner, r: ref } = rawRef;
-  const oldRef = oldRawRef && oldRawRef.r;
-  const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs;
-  const setupState = owner.setupState;
-  if (oldRef != null && oldRef !== ref) {
-    if (isString(oldRef)) {
-      refs[oldRef] = null;
-      if (hasOwn(setupState, oldRef)) {
-        setupState[oldRef] = null;
+    return;
+  }
+  if (isAsyncWrapper(vnode) && !isUnmount) {
+    return;
+  }
+  const refValue = vnode.shapeFlag & 4 ? getExposeProxy(vnode.component) || vnode.component.proxy : vnode.el;
+  const value = isUnmount ? null : refValue;
+  const { i: owner, r: ref } = rawRef;
+  const oldRef = oldRawRef && oldRawRef.r;
+  const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs;
+  const setupState = owner.setupState;
+  if (oldRef != null && oldRef !== ref) {
+    if (isString(oldRef)) {
+      refs[oldRef] = null;
+      if (hasOwn(setupState, oldRef)) {
+        setupState[oldRef] = null;
+      }
+    } else if (isRef(oldRef)) {
+      oldRef.value = null;
+    }
+  }
+  if (isFunction(ref)) {
+    callWithErrorHandling(ref, owner, 12, [value, refs]);
+  } else {
+    const _isString = isString(ref);
+    const _isRef = isRef(ref);
+    if (_isString || _isRef) {
+      const doSet = () => {
+        if (rawRef.f) {
+          const existing = _isString ? hasOwn(setupState, ref) ? setupState[ref] : refs[ref] : ref.value;
+          if (isUnmount) {
+            isArray$1(existing) && remove(existing, refValue);
+          } else {
+            if (!isArray$1(existing)) {
+              if (_isString) {
+                refs[ref] = [refValue];
+                if (hasOwn(setupState, ref)) {
+                  setupState[ref] = refs[ref];
+                }
+              } else {
+                ref.value = [refValue];
+                if (rawRef.k)
+                  refs[rawRef.k] = ref.value;
+              }
+            } else if (!existing.includes(refValue)) {
+              existing.push(refValue);
+            }
+          }
+        } else if (_isString) {
+          refs[ref] = value;
+          if (hasOwn(setupState, ref)) {
+            setupState[ref] = value;
+          }
+        } else if (_isRef) {
+          ref.value = value;
+          if (rawRef.k)
+            refs[rawRef.k] = value;
+        } else ;
+      };
+      if (value) {
+        doSet.id = -1;
+        queuePostRenderEffect(doSet, parentSuspense);
+      } else {
+        doSet();
+      }
+    }
+  }
+}
+
+let hasMismatch = false;
+const isSVGContainer = (container) => /svg/.test(container.namespaceURI) && container.tagName !== "foreignObject";
+const isComment = (node) => node.nodeType === 8 /* COMMENT */;
+function createHydrationFunctions(rendererInternals) {
+  const {
+    mt: mountComponent,
+    p: patch,
+    o: {
+      patchProp,
+      createText,
+      nextSibling,
+      parentNode,
+      remove,
+      insert,
+      createComment
+    }
+  } = rendererInternals;
+  const hydrate = (vnode, container) => {
+    if (!container.hasChildNodes()) {
+      patch(null, vnode, container);
+      flushPostFlushCbs();
+      container._vnode = vnode;
+      return;
+    }
+    hasMismatch = false;
+    hydrateNode(container.firstChild, vnode, null, null, null);
+    flushPostFlushCbs();
+    container._vnode = vnode;
+    if (hasMismatch && true) {
+      console.error(`Hydration completed but contains mismatches.`);
+    }
+  };
+  const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => {
+    const isFragmentStart = isComment(node) && node.data === "[";
+    const onMismatch = () => handleMismatch(
+      node,
+      vnode,
+      parentComponent,
+      parentSuspense,
+      slotScopeIds,
+      isFragmentStart
+    );
+    const { type, ref, shapeFlag, patchFlag } = vnode;
+    let domType = node.nodeType;
+    vnode.el = node;
+    if (patchFlag === -2) {
+      optimized = false;
+      vnode.dynamicChildren = null;
+    }
+    let nextNode = null;
+    switch (type) {
+      case Text:
+        if (domType !== 3 /* TEXT */) {
+          if (vnode.children === "") {
+            insert(vnode.el = createText(""), parentNode(node), node);
+            nextNode = node;
+          } else {
+            nextNode = onMismatch();
+          }
+        } else {
+          if (node.data !== vnode.children) {
+            hasMismatch = true;
+            node.data = vnode.children;
+          }
+          nextNode = nextSibling(node);
+        }
+        break;
+      case Comment:
+        if (domType !== 8 /* COMMENT */ || isFragmentStart) {
+          nextNode = onMismatch();
+        } else {
+          nextNode = nextSibling(node);
+        }
+        break;
+      case Static:
+        if (isFragmentStart) {
+          node = nextSibling(node);
+          domType = node.nodeType;
+        }
+        if (domType === 1 /* ELEMENT */ || domType === 3 /* TEXT */) {
+          nextNode = node;
+          const needToAdoptContent = !vnode.children.length;
+          for (let i = 0; i < vnode.staticCount; i++) {
+            if (needToAdoptContent)
+              vnode.children += nextNode.nodeType === 1 /* ELEMENT */ ? nextNode.outerHTML : nextNode.data;
+            if (i === vnode.staticCount - 1) {
+              vnode.anchor = nextNode;
+            }
+            nextNode = nextSibling(nextNode);
+          }
+          return isFragmentStart ? nextSibling(nextNode) : nextNode;
+        } else {
+          onMismatch();
+        }
+        break;
+      case Fragment:
+        if (!isFragmentStart) {
+          nextNode = onMismatch();
+        } else {
+          nextNode = hydrateFragment(
+            node,
+            vnode,
+            parentComponent,
+            parentSuspense,
+            slotScopeIds,
+            optimized
+          );
+        }
+        break;
+      default:
+        if (shapeFlag & 1) {
+          if (domType !== 1 /* ELEMENT */ || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) {
+            nextNode = onMismatch();
+          } else {
+            nextNode = hydrateElement(
+              node,
+              vnode,
+              parentComponent,
+              parentSuspense,
+              slotScopeIds,
+              optimized
+            );
+          }
+        } else if (shapeFlag & 6) {
+          vnode.slotScopeIds = slotScopeIds;
+          const container = parentNode(node);
+          mountComponent(
+            vnode,
+            container,
+            null,
+            parentComponent,
+            parentSuspense,
+            isSVGContainer(container),
+            optimized
+          );
+          nextNode = isFragmentStart ? locateClosingAsyncAnchor(node) : nextSibling(node);
+          if (nextNode && isComment(nextNode) && nextNode.data === "teleport end") {
+            nextNode = nextSibling(nextNode);
+          }
+          if (isAsyncWrapper(vnode)) {
+            let subTree;
+            if (isFragmentStart) {
+              subTree = createVNode(Fragment);
+              subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild;
+            } else {
+              subTree = node.nodeType === 3 ? createTextVNode("") : createVNode("div");
+            }
+            subTree.el = node;
+            vnode.component.subTree = subTree;
+          }
+        } else if (shapeFlag & 64) {
+          if (domType !== 8 /* COMMENT */) {
+            nextNode = onMismatch();
+          } else {
+            nextNode = vnode.type.hydrate(
+              node,
+              vnode,
+              parentComponent,
+              parentSuspense,
+              slotScopeIds,
+              optimized,
+              rendererInternals,
+              hydrateChildren
+            );
+          }
+        } else if (shapeFlag & 128) {
+          nextNode = vnode.type.hydrate(
+            node,
+            vnode,
+            parentComponent,
+            parentSuspense,
+            isSVGContainer(parentNode(node)),
+            slotScopeIds,
+            optimized,
+            rendererInternals,
+            hydrateNode
+          );
+        } else ;
+    }
+    if (ref != null) {
+      setRef(ref, null, parentSuspense, vnode);
+    }
+    return nextNode;
+  };
+  const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
+    optimized = optimized || !!vnode.dynamicChildren;
+    const { type, props, patchFlag, shapeFlag, dirs } = vnode;
+    const forcePatchValue = type === "input" && dirs || type === "option";
+    if (forcePatchValue || patchFlag !== -1) {
+      if (dirs) {
+        invokeDirectiveHook(vnode, null, parentComponent, "created");
+      }
+      if (props) {
+        if (forcePatchValue || !optimized || patchFlag & (16 | 32)) {
+          for (const key in props) {
+            if (forcePatchValue && key.endsWith("value") || isOn(key) && !isReservedProp(key)) {
+              patchProp(
+                el,
+                key,
+                null,
+                props[key],
+                false,
+                void 0,
+                parentComponent
+              );
+            }
+          }
+        } else if (props.onClick) {
+          patchProp(
+            el,
+            "onClick",
+            null,
+            props.onClick,
+            false,
+            void 0,
+            parentComponent
+          );
+        }
+      }
+      let vnodeHooks;
+      if (vnodeHooks = props && props.onVnodeBeforeMount) {
+        invokeVNodeHook(vnodeHooks, parentComponent, vnode);
+      }
+      if (dirs) {
+        invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
+      }
+      if ((vnodeHooks = props && props.onVnodeMounted) || dirs) {
+        queueEffectWithSuspense(() => {
+          vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);
+          dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
+        }, parentSuspense);
+      }
+      if (shapeFlag & 16 && // skip if element has innerHTML / textContent
+      !(props && (props.innerHTML || props.textContent))) {
+        let next = hydrateChildren(
+          el.firstChild,
+          vnode,
+          el,
+          parentComponent,
+          parentSuspense,
+          slotScopeIds,
+          optimized
+        );
+        while (next) {
+          hasMismatch = true;
+          const cur = next;
+          next = next.nextSibling;
+          remove(cur);
+        }
+      } else if (shapeFlag & 8) {
+        if (el.textContent !== vnode.children) {
+          hasMismatch = true;
+          el.textContent = vnode.children;
+        }
+      }
+    }
+    return el.nextSibling;
+  };
+  const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => {
+    optimized = optimized || !!parentVNode.dynamicChildren;
+    const children = parentVNode.children;
+    const l = children.length;
+    for (let i = 0; i < l; i++) {
+      const vnode = optimized ? children[i] : children[i] = normalizeVNode(children[i]);
+      if (node) {
+        node = hydrateNode(
+          node,
+          vnode,
+          parentComponent,
+          parentSuspense,
+          slotScopeIds,
+          optimized
+        );
+      } else if (vnode.type === Text && !vnode.children) {
+        continue;
+      } else {
+        hasMismatch = true;
+        patch(
+          null,
+          vnode,
+          container,
+          null,
+          parentComponent,
+          parentSuspense,
+          isSVGContainer(container),
+          slotScopeIds
+        );
+      }
+    }
+    return node;
+  };
+  const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
+    const { slotScopeIds: fragmentSlotScopeIds } = vnode;
+    if (fragmentSlotScopeIds) {
+      slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
+    }
+    const container = parentNode(node);
+    const next = hydrateChildren(
+      nextSibling(node),
+      vnode,
+      container,
+      parentComponent,
+      parentSuspense,
+      slotScopeIds,
+      optimized
+    );
+    if (next && isComment(next) && next.data === "]") {
+      return nextSibling(vnode.anchor = next);
+    } else {
+      hasMismatch = true;
+      insert(vnode.anchor = createComment(`]`), container, next);
+      return next;
+    }
+  };
+  const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => {
+    hasMismatch = true;
+    vnode.el = null;
+    if (isFragment) {
+      const end = locateClosingAsyncAnchor(node);
+      while (true) {
+        const next2 = nextSibling(node);
+        if (next2 && next2 !== end) {
+          remove(next2);
+        } else {
+          break;
+        }
       }
-    } else if (isRef(oldRef)) {
-      oldRef.value = null;
     }
-  }
-  if (isFunction(ref)) {
-    callWithErrorHandling(ref, owner, 12, [value, refs]);
-  } else {
-    const _isString = isString(ref);
-    const _isRef = isRef(ref);
-    if (_isString || _isRef) {
-      const doSet = () => {
-        if (rawRef.f) {
-          const existing = _isString ? hasOwn(setupState, ref) ? setupState[ref] : refs[ref] : ref.value;
-          if (isUnmount) {
-            isArray$1(existing) && remove(existing, refValue);
+    const next = nextSibling(node);
+    const container = parentNode(node);
+    remove(node);
+    patch(
+      null,
+      vnode,
+      container,
+      next,
+      parentComponent,
+      parentSuspense,
+      isSVGContainer(container),
+      slotScopeIds
+    );
+    return next;
+  };
+  const locateClosingAsyncAnchor = (node) => {
+    let match = 0;
+    while (node) {
+      node = nextSibling(node);
+      if (node && isComment(node)) {
+        if (node.data === "[")
+          match++;
+        if (node.data === "]") {
+          if (match === 0) {
+            return nextSibling(node);
           } else {
-            if (!isArray$1(existing)) {
-              if (_isString) {
-                refs[ref] = [refValue];
-                if (hasOwn(setupState, ref)) {
-                  setupState[ref] = refs[ref];
-                }
-              } else {
-                ref.value = [refValue];
-                if (rawRef.k)
-                  refs[rawRef.k] = ref.value;
-              }
-            } else if (!existing.includes(refValue)) {
-              existing.push(refValue);
-            }
-          }
-        } else if (_isString) {
-          refs[ref] = value;
-          if (hasOwn(setupState, ref)) {
-            setupState[ref] = value;
+            match--;
           }
-        } else if (_isRef) {
-          ref.value = value;
-          if (rawRef.k)
-            refs[rawRef.k] = value;
-        } else ;
-      };
-      if (value) {
-        doSet.id = -1;
-        queuePostRenderEffect(doSet, parentSuspense);
-      } else {
-        doSet();
+        }
       }
     }
-  }
+    return node;
+  };
+  return [hydrate, hydrateNode];
 }
 
 const queuePostRenderEffect = queueEffectWithSuspense ;
 function createRenderer(options) {
   return baseCreateRenderer(options);
 }
+function createHydrationRenderer(options) {
+  return baseCreateRenderer(options, createHydrationFunctions);
+}
 function baseCreateRenderer(options, createHydrationFns) {
   const target = getGlobalThis();
   target.__VUE__ = true;
@@ -5294,6 +6769,8 @@ function isVNode(value) {
 function isSameVNodeType(n1, n2) {
   return n1.type === n2.type && n1.key === n2.key;
 }
+function transformVNodeArgs(transformer) {
+}
 const InternalObjectKey = `__vInternal`;
 const normalizeKey = ({ key }) => key != null ? key : null;
 const normalizeRef = ({
@@ -5746,6 +7223,16 @@ function handleSetupResult(instance, setupResult, isSSR) {
   finishComponentSetup(instance, isSSR);
 }
 let compile;
+let installWithProxy;
+function registerRuntimeCompiler(_compile) {
+  compile = _compile;
+  installWithProxy = (i) => {
+    if (i.render._rc) {
+      i.withProxy = new Proxy(i.ctx, RuntimeCompiledPublicInstanceProxyHandlers);
+    }
+  };
+}
+const isRuntimeOnly = () => !compile;
 function finishComponentSetup(instance, isSSR, skipOptions) {
   const Component = instance.type;
   if (!instance.render) {
@@ -5768,6 +7255,9 @@ function finishComponentSetup(instance, isSSR, skipOptions) {
       }
     }
     instance.render = Component.render || NOOP;
+    if (installWithProxy) {
+      installWithProxy(instance);
+    }
   }
   {
     setCurrentInstance(instance);
@@ -5859,7 +7349,49 @@ const useSSRContext = () => {
   }
 };
 
+function initCustomFormatter() {
+  {
+    return;
+  }
+}
+
+function withMemo(memo, render, cache, index) {
+  const cached = cache[index];
+  if (cached && isMemoSame(cached, memo)) {
+    return cached;
+  }
+  const ret = render();
+  ret.memo = memo.slice();
+  return cache[index] = ret;
+}
+function isMemoSame(cached, memo) {
+  const prev = cached.memo;
+  if (prev.length != memo.length) {
+    return false;
+  }
+  for (let i = 0; i < prev.length; i++) {
+    if (hasChanged(prev[i], memo[i])) {
+      return false;
+    }
+  }
+  if (isBlockTreeEnabled > 0 && currentBlock) {
+    currentBlock.push(cached);
+  }
+  return true;
+}
+
 const version = "3.3.4";
+const _ssrUtils = {
+  createComponentInstance,
+  setupComponent,
+  renderComponentRoot,
+  setCurrentRenderingInstance,
+  isVNode: isVNode,
+  normalizeVNode
+};
+const ssrUtils = _ssrUtils ;
+const resolveFilter = null;
+const compatUtils = null;
 
 /* Injected with object hook! */
 
@@ -6203,6 +7735,276 @@ function shouldSetAsProp(el, key, value, isSVG) {
   return key in el;
 }
 
+function defineCustomElement(options, hydrate2) {
+  const Comp = defineComponent(options);
+  class VueCustomElement extends VueElement {
+    constructor(initialProps) {
+      super(Comp, initialProps, hydrate2);
+    }
+  }
+  VueCustomElement.def = Comp;
+  return VueCustomElement;
+}
+const defineSSRCustomElement = (options) => {
+  return defineCustomElement(options, hydrate);
+};
+const BaseClass = typeof HTMLElement !== "undefined" ? HTMLElement : class {
+};
+class VueElement extends BaseClass {
+  constructor(_def, _props = {}, hydrate2) {
+    super();
+    this._def = _def;
+    this._props = _props;
+    /**
+     * @internal
+     */
+    this._instance = null;
+    this._connected = false;
+    this._resolved = false;
+    this._numberProps = null;
+    if (this.shadowRoot && hydrate2) {
+      hydrate2(this._createVNode(), this.shadowRoot);
+    } else {
+      this.attachShadow({ mode: "open" });
+      if (!this._def.__asyncLoader) {
+        this._resolveProps(this._def);
+      }
+    }
+  }
+  connectedCallback() {
+    this._connected = true;
+    if (!this._instance) {
+      if (this._resolved) {
+        this._update();
+      } else {
+        this._resolveDef();
+      }
+    }
+  }
+  disconnectedCallback() {
+    this._connected = false;
+    nextTick(() => {
+      if (!this._connected) {
+        render$1(null, this.shadowRoot);
+        this._instance = null;
+      }
+    });
+  }
+  /**
+   * resolve inner component definition (handle possible async component)
+   */
+  _resolveDef() {
+    this._resolved = true;
+    for (let i = 0; i < this.attributes.length; i++) {
+      this._setAttr(this.attributes[i].name);
+    }
+    new MutationObserver((mutations) => {
+      for (const m of mutations) {
+        this._setAttr(m.attributeName);
+      }
+    }).observe(this, { attributes: true });
+    const resolve = (def, isAsync = false) => {
+      const { props, styles } = def;
+      let numberProps;
+      if (props && !isArray$1(props)) {
+        for (const key in props) {
+          const opt = props[key];
+          if (opt === Number || opt && opt.type === Number) {
+            if (key in this._props) {
+              this._props[key] = toNumber(this._props[key]);
+            }
+            (numberProps || (numberProps = /* @__PURE__ */ Object.create(null)))[camelize(key)] = true;
+          }
+        }
+      }
+      this._numberProps = numberProps;
+      if (isAsync) {
+        this._resolveProps(def);
+      }
+      this._applyStyles(styles);
+      this._update();
+    };
+    const asyncDef = this._def.__asyncLoader;
+    if (asyncDef) {
+      asyncDef().then((def) => resolve(def, true));
+    } else {
+      resolve(this._def);
+    }
+  }
+  _resolveProps(def) {
+    const { props } = def;
+    const declaredPropKeys = isArray$1(props) ? props : Object.keys(props || {});
+    for (const key of Object.keys(this)) {
+      if (key[0] !== "_" && declaredPropKeys.includes(key)) {
+        this._setProp(key, this[key], true, false);
+      }
+    }
+    for (const key of declaredPropKeys.map(camelize)) {
+      Object.defineProperty(this, key, {
+        get() {
+          return this._getProp(key);
+        },
+        set(val) {
+          this._setProp(key, val);
+        }
+      });
+    }
+  }
+  _setAttr(key) {
+    let value = this.getAttribute(key);
+    const camelKey = camelize(key);
+    if (this._numberProps && this._numberProps[camelKey]) {
+      value = toNumber(value);
+    }
+    this._setProp(camelKey, value, false);
+  }
+  /**
+   * @internal
+   */
+  _getProp(key) {
+    return this._props[key];
+  }
+  /**
+   * @internal
+   */
+  _setProp(key, val, shouldReflect = true, shouldUpdate = true) {
+    if (val !== this._props[key]) {
+      this._props[key] = val;
+      if (shouldUpdate && this._instance) {
+        this._update();
+      }
+      if (shouldReflect) {
+        if (val === true) {
+          this.setAttribute(hyphenate(key), "");
+        } else if (typeof val === "string" || typeof val === "number") {
+          this.setAttribute(hyphenate(key), val + "");
+        } else if (!val) {
+          this.removeAttribute(hyphenate(key));
+        }
+      }
+    }
+  }
+  _update() {
+    render$1(this._createVNode(), this.shadowRoot);
+  }
+  _createVNode() {
+    const vnode = createVNode(this._def, extend({}, this._props));
+    if (!this._instance) {
+      vnode.ce = (instance) => {
+        this._instance = instance;
+        instance.isCE = true;
+        const dispatch = (event, args) => {
+          this.dispatchEvent(
+            new CustomEvent(event, {
+              detail: args
+            })
+          );
+        };
+        instance.emit = (event, ...args) => {
+          dispatch(event, args);
+          if (hyphenate(event) !== event) {
+            dispatch(hyphenate(event), args);
+          }
+        };
+        let parent = this;
+        while (parent = parent && (parent.parentNode || parent.host)) {
+          if (parent instanceof VueElement) {
+            instance.parent = parent._instance;
+            instance.provides = parent._instance.provides;
+            break;
+          }
+        }
+      };
+    }
+    return vnode;
+  }
+  _applyStyles(styles) {
+    if (styles) {
+      styles.forEach((css) => {
+        const s = document.createElement("style");
+        s.textContent = css;
+        this.shadowRoot.appendChild(s);
+      });
+    }
+  }
+}
+
+function useCssModule(name = "$style") {
+  {
+    const instance = getCurrentInstance();
+    if (!instance) {
+      return EMPTY_OBJ;
+    }
+    const modules = instance.type.__cssModules;
+    if (!modules) {
+      return EMPTY_OBJ;
+    }
+    const mod = modules[name];
+    if (!mod) {
+      return EMPTY_OBJ;
+    }
+    return mod;
+  }
+}
+
+function useCssVars(getter) {
+  const instance = getCurrentInstance();
+  if (!instance) {
+    return;
+  }
+  const updateTeleports = instance.ut = (vars = getter(instance.proxy)) => {
+    Array.from(
+      document.querySelectorAll(`[data-v-owner="${instance.uid}"]`)
+    ).forEach((node) => setVarsOnNode(node, vars));
+  };
+  const setVars = () => {
+    const vars = getter(instance.proxy);
+    setVarsOnVNode(instance.subTree, vars);
+    updateTeleports(vars);
+  };
+  watchPostEffect(setVars);
+  onMounted(() => {
+    const ob = new MutationObserver(setVars);
+    ob.observe(instance.subTree.el.parentNode, { childList: true });
+    onUnmounted(() => ob.disconnect());
+  });
+}
+function setVarsOnVNode(vnode, vars) {
+  if (vnode.shapeFlag & 128) {
+    const suspense = vnode.suspense;
+    vnode = suspense.activeBranch;
+    if (suspense.pendingBranch && !suspense.isHydrating) {
+      suspense.effects.push(() => {
+        setVarsOnVNode(suspense.activeBranch, vars);
+      });
+    }
+  }
+  while (vnode.component) {
+    vnode = vnode.component.subTree;
+  }
+  if (vnode.shapeFlag & 1 && vnode.el) {
+    setVarsOnNode(vnode.el, vars);
+  } else if (vnode.type === Fragment) {
+    vnode.children.forEach((c) => setVarsOnVNode(c, vars));
+  } else if (vnode.type === Static) {
+    let { el, anchor } = vnode;
+    while (el) {
+      setVarsOnNode(el, vars);
+      if (el === anchor)
+        break;
+      el = el.nextSibling;
+    }
+  }
+}
+function setVarsOnNode(el, vars) {
+  if (el.nodeType === 1) {
+    const style = el.style;
+    for (const key in vars) {
+      style.setProperty(`--${key}`, vars[key]);
+    }
+  }
+}
+
 const TRANSITION = "transition";
 const ANIMATION = "animation";
 const Transition = (props, { slots }) => h(BaseTransition, resolveTransitionProps(props), slots);
@@ -6225,7 +8027,7 @@ const DOMTransitionPropsValidators = {
   leaveActiveClass: String,
   leaveToClass: String
 };
-Transition.props = /* @__PURE__ */ extend(
+const TransitionPropsValidators = Transition.props = /* @__PURE__ */ extend(
   {},
   BaseTransitionPropsValidators,
   DOMTransitionPropsValidators
@@ -6443,27 +8245,146 @@ function getTransitionInfo(el, expectedType) {
     type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null;
     propCount = type ? type === TRANSITION ? transitionDurations.length : animationDurations.length : 0;
   }
-  const hasTransform = type === TRANSITION && /\b(transform|all)(,|$)/.test(
-    getStyleProperties(`${TRANSITION}Property`).toString()
-  );
-  return {
-    type,
-    timeout,
-    propCount,
-    hasTransform
-  };
-}
-function getTimeout(delays, durations) {
-  while (delays.length < durations.length) {
-    delays = delays.concat(delays);
+  const hasTransform = type === TRANSITION && /\b(transform|all)(,|$)/.test(
+    getStyleProperties(`${TRANSITION}Property`).toString()
+  );
+  return {
+    type,
+    timeout,
+    propCount,
+    hasTransform
+  };
+}
+function getTimeout(delays, durations) {
+  while (delays.length < durations.length) {
+    delays = delays.concat(delays);
+  }
+  return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));
+}
+function toMs(s) {
+  return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
+}
+function forceReflow() {
+  return document.body.offsetHeight;
+}
+
+const positionMap = /* @__PURE__ */ new WeakMap();
+const newPositionMap = /* @__PURE__ */ new WeakMap();
+const TransitionGroupImpl = {
+  name: "TransitionGroup",
+  props: /* @__PURE__ */ extend({}, TransitionPropsValidators, {
+    tag: String,
+    moveClass: String
+  }),
+  setup(props, { slots }) {
+    const instance = getCurrentInstance();
+    const state = useTransitionState();
+    let prevChildren;
+    let children;
+    onUpdated(() => {
+      if (!prevChildren.length) {
+        return;
+      }
+      const moveClass = props.moveClass || `${props.name || "v"}-move`;
+      if (!hasCSSTransform(
+        prevChildren[0].el,
+        instance.vnode.el,
+        moveClass
+      )) {
+        return;
+      }
+      prevChildren.forEach(callPendingCbs);
+      prevChildren.forEach(recordPosition);
+      const movedChildren = prevChildren.filter(applyTranslation);
+      forceReflow();
+      movedChildren.forEach((c) => {
+        const el = c.el;
+        const style = el.style;
+        addTransitionClass(el, moveClass);
+        style.transform = style.webkitTransform = style.transitionDuration = "";
+        const cb = el._moveCb = (e) => {
+          if (e && e.target !== el) {
+            return;
+          }
+          if (!e || /transform$/.test(e.propertyName)) {
+            el.removeEventListener("transitionend", cb);
+            el._moveCb = null;
+            removeTransitionClass(el, moveClass);
+          }
+        };
+        el.addEventListener("transitionend", cb);
+      });
+    });
+    return () => {
+      const rawProps = toRaw(props);
+      const cssTransitionProps = resolveTransitionProps(rawProps);
+      let tag = rawProps.tag || Fragment;
+      prevChildren = children;
+      children = slots.default ? getTransitionRawChildren(slots.default()) : [];
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        if (child.key != null) {
+          setTransitionHooks(
+            child,
+            resolveTransitionHooks(child, cssTransitionProps, state, instance)
+          );
+        }
+      }
+      if (prevChildren) {
+        for (let i = 0; i < prevChildren.length; i++) {
+          const child = prevChildren[i];
+          setTransitionHooks(
+            child,
+            resolveTransitionHooks(child, cssTransitionProps, state, instance)
+          );
+          positionMap.set(child, child.el.getBoundingClientRect());
+        }
+      }
+      return createVNode(tag, null, children);
+    };
+  }
+};
+const removeMode = (props) => delete props.mode;
+/* @__PURE__ */ removeMode(TransitionGroupImpl.props);
+const TransitionGroup = TransitionGroupImpl;
+function callPendingCbs(c) {
+  const el = c.el;
+  if (el._moveCb) {
+    el._moveCb();
+  }
+  if (el._enterCb) {
+    el._enterCb();
+  }
+}
+function recordPosition(c) {
+  newPositionMap.set(c, c.el.getBoundingClientRect());
+}
+function applyTranslation(c) {
+  const oldPos = positionMap.get(c);
+  const newPos = newPositionMap.get(c);
+  const dx = oldPos.left - newPos.left;
+  const dy = oldPos.top - newPos.top;
+  if (dx || dy) {
+    const s = c.el.style;
+    s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;
+    s.transitionDuration = "0s";
+    return c;
+  }
+}
+function hasCSSTransform(el, root, moveClass) {
+  const clone = el.cloneNode();
+  if (el._vtc) {
+    el._vtc.forEach((cls) => {
+      cls.split(/\s+/).forEach((c) => c && clone.classList.remove(c));
+    });
   }
-  return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));
-}
-function toMs(s) {
-  return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
-}
-function forceReflow() {
-  return document.body.offsetHeight;
+  moveClass.split(/\s+/).forEach((c) => c && clone.classList.add(c));
+  clone.style.display = "none";
+  const container = root.nodeType === 1 ? root : root.parentNode;
+  container.appendChild(clone);
+  const { hasTransform } = getTransitionInfo(clone);
+  container.removeChild(clone);
+  return hasTransform;
 }
 
 const getModelAssigner = (vnode) => {
@@ -6696,6 +8617,40 @@ function callModelHook(el, binding, vnode, prevVNode, hook) {
   const fn = modelToUse[hook];
   fn && fn(el, binding, vnode, prevVNode);
 }
+function initVModelForSSR() {
+  vModelText.getSSRProps = ({ value }) => ({ value });
+  vModelRadio.getSSRProps = ({ value }, vnode) => {
+    if (vnode.props && looseEqual(vnode.props.value, value)) {
+      return { checked: true };
+    }
+  };
+  vModelCheckbox.getSSRProps = ({ value }, vnode) => {
+    if (isArray$1(value)) {
+      if (vnode.props && looseIndexOf(value, vnode.props.value) > -1) {
+        return { checked: true };
+      }
+    } else if (isSet(value)) {
+      if (vnode.props && value.has(vnode.props.value)) {
+        return { checked: true };
+      }
+    } else if (value) {
+      return { checked: true };
+    }
+  };
+  vModelDynamic.getSSRProps = (binding, vnode) => {
+    if (typeof vnode.type !== "string") {
+      return;
+    }
+    const modelToUse = resolveDynamicModel(
+      // resolveDynamicModel expects an uppercase tag name, but vnode.type is lowercase
+      vnode.type.toUpperCase(),
+      vnode.props && vnode.props.type
+    );
+    if (modelToUse.getSSRProps) {
+      return modelToUse.getSSRProps(binding, vnode);
+    }
+  };
+}
 
 const systemModifiers = ["ctrl", "shift", "alt", "meta"];
 const modifierGuards = {
@@ -6780,12 +8735,31 @@ const vShow = {
 function setDisplay(el, value) {
   el.style.display = value ? el._vod : "none";
 }
+function initVShowForSSR() {
+  vShow.getSSRProps = ({ value }) => {
+    if (!value) {
+      return { style: { display: "none" } };
+    }
+  };
+}
 
 const rendererOptions = /* @__PURE__ */ extend({ patchProp }, nodeOps);
 let renderer;
+let enabledHydration = false;
 function ensureRenderer() {
   return renderer || (renderer = createRenderer(rendererOptions));
 }
+function ensureHydrationRenderer() {
+  renderer = enabledHydration ? renderer : createHydrationRenderer(rendererOptions);
+  enabledHydration = true;
+  return renderer;
+}
+const render$1 = (...args) => {
+  ensureRenderer().render(...args);
+};
+const hydrate = (...args) => {
+  ensureHydrationRenderer().hydrate(...args);
+};
 const createApp = (...args) => {
   const app = ensureRenderer().createApp(...args);
   const { mount } = app;
@@ -6807,6 +8781,17 @@ const createApp = (...args) => {
   };
   return app;
 };
+const createSSRApp = (...args) => {
+  const app = ensureHydrationRenderer().createApp(...args);
+  const { mount } = app;
+  app.mount = (containerOrSelector) => {
+    const container = normalizeContainer(containerOrSelector);
+    if (container) {
+      return mount(container, true, container instanceof SVGElement);
+    }
+  };
+  return app;
+};
 function normalizeContainer(container) {
   if (isString(container)) {
     const res = document.querySelector(container);
@@ -6814,6 +8799,14 @@ function normalizeContainer(container) {
   }
   return container;
 }
+let ssrDirectiveInitialized = false;
+const initDirectivesForSSR = () => {
+  if (!ssrDirectiveInitialized) {
+    ssrDirectiveInitialized = true;
+    initVModelForSSR();
+    initVShowForSSR();
+  }
+} ;
 
 /* Injected with object hook! */
 
@@ -12780,6 +14773,29 @@ function useTimeoutFn(cb, interval, options = {}) {
   };
 }
 
+function useToggle(initialValue = false, options = {}) {
+  const {
+    truthyValue = true,
+    falsyValue = false
+  } = options;
+  const valueIsRef = isRef(initialValue);
+  const _value = ref(initialValue);
+  function toggle(value) {
+    if (arguments.length) {
+      _value.value = value;
+      return _value.value;
+    } else {
+      const truthy = toValue$1(truthyValue);
+      _value.value = _value.value === truthy ? toValue$1(falsyValue) : truthy;
+      return _value.value;
+    }
+  }
+  if (valueIsRef)
+    return toggle;
+  else
+    return [_value, toggle];
+}
+
 var __getOwnPropSymbols$8$1 = Object.getOwnPropertySymbols;
 var __hasOwnProp$8$1 = Object.prototype.hasOwnProperty;
 var __propIsEnum$8$1 = Object.prototype.propertyIsEnumerable;
@@ -14278,6 +16294,8 @@ function useVModel(props, key, emit, options = {}) {
 /* Injected with object hook! */
 
 const FRAME_STATE_STORAGE_KEY = "__vue-devtools-frame-state__";
+const TABS_STORAGE_KEY = "__vue-devtools-tabs__";
+const TABS_GROUP_STORAGE_KEY = "__vue-devtools-tabs-group__";
 
 /* Injected with object hook! */
 
@@ -14387,20 +16405,20 @@ const _sfc_main$a = /* @__PURE__ */ defineComponent({
 
 /* Injected with object hook! */
 
-const __pages_import_0__ = () => __vitePreload(() => import('./timeline-0c017176.js'),true?["./timeline-0c017176.js","./StateFields.vue_vue_type_script_setup_true_lang-6969f024.js","./VIcon.vue_vue_type_script_setup_true_lang-41c110ef.js","./index-8d0405da.js","./VIconButton.vue_vue_type_script_setup_true_lang-a89f6c88.js","./VPanelGrids-24560813.js","./_commonjsHelpers-c0d8ada0.js","./splitpanes.es-2be998f1.js","./timeline-b315b2e0.css"]:void 0,import.meta.url);
-const __pages_import_1__ = () => __vitePreload(() => import('./settings-5fd1add1.js'),true?["./settings-5fd1add1.js","./VIcon.vue_vue_type_script_setup_true_lang-41c110ef.js","./VIconTitle.vue_vue_type_script_setup_true_lang-d3431291.js"]:void 0,import.meta.url);
-const __pages_import_2__ = () => __vitePreload(() => import('./routes-64dbd0f9.js'),true?["./routes-64dbd0f9.js","./VPanelGrids-24560813.js","./StateFields.vue_vue_type_script_setup_true_lang-6969f024.js","./VIcon.vue_vue_type_script_setup_true_lang-41c110ef.js","./index-8d0405da.js","./VIconButton.vue_vue_type_script_setup_true_lang-a89f6c88.js","./splitpanes.es-2be998f1.js"]:void 0,import.meta.url);
-const __pages_import_3__ = () => __vitePreload(() => import('./pinia-8c6ed567.js'),true?["./pinia-8c6ed567.js","./StateFields.vue_vue_type_script_setup_true_lang-6969f024.js","./VIcon.vue_vue_type_script_setup_true_lang-41c110ef.js","./index-8d0405da.js","./VIconButton.vue_vue_type_script_setup_true_lang-a89f6c88.js","./splitpanes.es-2be998f1.js"]:void 0,import.meta.url);
-const __pages_import_4__ = () => __vitePreload(() => import('./pages-f80c7a3e.js'),true?["./pages-f80c7a3e.js","./VSectionBlock-ba31730a.js","./VIconTitle.vue_vue_type_script_setup_true_lang-d3431291.js","./VIcon.vue_vue_type_script_setup_true_lang-41c110ef.js","./VSectionBlock-52804693.css","./VTextInput.vue_vue_type_script_setup_true_lang-5373326c.js"]:void 0,import.meta.url);
-const __pages_import_5__ = () => __vitePreload(() => import('./overview-aef80b27.js'),true?["./overview-aef80b27.js","./VPanelGrids-24560813.js","./rpc-358fc96c.js","./index-8d0405da.js"]:void 0,import.meta.url);
-const __pages_import_6__ = () => __vitePreload(() => import('./npm-6d9ce0f4.js'),true?["./npm-6d9ce0f4.js","./VSectionBlock-ba31730a.js","./VIconTitle.vue_vue_type_script_setup_true_lang-d3431291.js","./VIcon.vue_vue_type_script_setup_true_lang-41c110ef.js","./VSectionBlock-52804693.css","./VTextInput.vue_vue_type_script_setup_true_lang-5373326c.js","./_commonjsHelpers-c0d8ada0.js","./rpc-358fc96c.js","./npm-125f4259.css"]:void 0,import.meta.url);
-const __pages_import_7__ = () => __vitePreload(() => import('./inspect-4188d5cc.js'),true?["./inspect-4188d5cc.js","./IframeView.vue_vue_type_script_setup_true_lang-4c77817b.js","./rpc-358fc96c.js"]:void 0,import.meta.url);
-const __pages_import_9__ = () => __vitePreload(() => import('./graph-65afb14a.js'),true?["./graph-65afb14a.js","./fuse.esm-c317b696.js","./rpc-358fc96c.js"]:void 0,import.meta.url);
-const __pages_import_10__ = () => __vitePreload(() => import('./documentations-99f74693.js'),true?["./documentations-99f74693.js","./IframeView.vue_vue_type_script_setup_true_lang-4c77817b.js","./rpc-358fc96c.js"]:void 0,import.meta.url);
-const __pages_import_11__ = () => __vitePreload(() => import('./components-f31cfed4.js'),true?["./components-f31cfed4.js","./VPanelGrids-24560813.js","./StateFields.vue_vue_type_script_setup_true_lang-6969f024.js","./VIcon.vue_vue_type_script_setup_true_lang-41c110ef.js","./index-8d0405da.js","./VIconButton.vue_vue_type_script_setup_true_lang-a89f6c88.js","./splitpanes.es-2be998f1.js"]:void 0,import.meta.url);
-const __pages_import_12__ = () => __vitePreload(() => import('./component-docs-49ee42b3.js'),true?["./component-docs-49ee42b3.js","./VTextInput.vue_vue_type_script_setup_true_lang-5373326c.js","./VIcon.vue_vue_type_script_setup_true_lang-41c110ef.js","./splitpanes.es-2be998f1.js","./fuse.esm-c317b696.js","./rpc-358fc96c.js","./component-docs-351d62d5.css"]:void 0,import.meta.url);
-const __pages_import_13__ = () => __vitePreload(() => import('./assets-136b5c5e.js'),true?["./assets-136b5c5e.js","./VPanelGrids-24560813.js","./VIconButton.vue_vue_type_script_setup_true_lang-a89f6c88.js","./VIcon.vue_vue_type_script_setup_true_lang-41c110ef.js","./rpc-358fc96c.js","./VSectionBlock-ba31730a.js","./VIconTitle.vue_vue_type_script_setup_true_lang-d3431291.js","./VSectionBlock-52804693.css","./VTextInput.vue_vue_type_script_setup_true_lang-5373326c.js","./fuse.esm-c317b696.js"]:void 0,import.meta.url);
-const __pages_import_14__ = () => __vitePreload(() => import('./__eyedropper-8e124d1e.js'),true?["./__eyedropper-8e124d1e.js","./VPanelGrids-24560813.js"]:void 0,import.meta.url);
+const __pages_import_0__ = () => __vitePreload(() => import('./timeline-5fa02442.js'),true?["./timeline-5fa02442.js","./StateFields.vue_vue_type_script_setup_true_lang-a78e5cb0.js","./VIcon.vue_vue_type_script_setup_true_lang-82a30fea.js","./index-07396aec.js","./VIconButton.vue_vue_type_script_setup_true_lang-fe1578eb.js","./VPanelGrids-dc69b639.js","./_commonjsHelpers-65004790.js","./splitpanes.es-dd27b7fe.js","./timeline-b315b2e0.css"]:void 0,import.meta.url);
+const __pages_import_1__ = () => __vitePreload(() => import('./settings-c390240d.js'),true?["./settings-c390240d.js","./VIcon.vue_vue_type_script_setup_true_lang-82a30fea.js","./_commonjsHelpers-65004790.js","./VIconButton.vue_vue_type_script_setup_true_lang-fe1578eb.js","./VTextInput.vue_vue_type_script_setup_true_lang-c7c2878d.js","./VIconTitle.vue_vue_type_script_setup_true_lang-53c720d3.js","./settings-3815e37a.css"]:void 0,import.meta.url);
+const __pages_import_2__ = () => __vitePreload(() => import('./routes-ab38a14f.js'),true?["./routes-ab38a14f.js","./VPanelGrids-dc69b639.js","./StateFields.vue_vue_type_script_setup_true_lang-a78e5cb0.js","./VIcon.vue_vue_type_script_setup_true_lang-82a30fea.js","./index-07396aec.js","./VIconButton.vue_vue_type_script_setup_true_lang-fe1578eb.js","./splitpanes.es-dd27b7fe.js"]:void 0,import.meta.url);
+const __pages_import_3__ = () => __vitePreload(() => import('./pinia-55c3fcd8.js'),true?["./pinia-55c3fcd8.js","./StateFields.vue_vue_type_script_setup_true_lang-a78e5cb0.js","./VIcon.vue_vue_type_script_setup_true_lang-82a30fea.js","./index-07396aec.js","./VIconButton.vue_vue_type_script_setup_true_lang-fe1578eb.js","./splitpanes.es-dd27b7fe.js"]:void 0,import.meta.url);
+const __pages_import_4__ = () => __vitePreload(() => import('./pages-72e88bdb.js'),true?["./pages-72e88bdb.js","./VSectionBlock-57ec7b68.js","./VIconTitle.vue_vue_type_script_setup_true_lang-53c720d3.js","./VIcon.vue_vue_type_script_setup_true_lang-82a30fea.js","./VSectionBlock-52804693.css","./VTextInput.vue_vue_type_script_setup_true_lang-c7c2878d.js"]:void 0,import.meta.url);
+const __pages_import_5__ = () => __vitePreload(() => import('./overview-95247458.js'),true?["./overview-95247458.js","./VPanelGrids-dc69b639.js","./rpc-cf3bd0fc.js","./index-07396aec.js"]:void 0,import.meta.url);
+const __pages_import_6__ = () => __vitePreload(() => import('./npm-62fb6b03.js'),true?["./npm-62fb6b03.js","./VSectionBlock-57ec7b68.js","./VIconTitle.vue_vue_type_script_setup_true_lang-53c720d3.js","./VIcon.vue_vue_type_script_setup_true_lang-82a30fea.js","./VSectionBlock-52804693.css","./VTextInput.vue_vue_type_script_setup_true_lang-c7c2878d.js","./_commonjsHelpers-65004790.js","./rpc-cf3bd0fc.js","./npm-125f4259.css"]:void 0,import.meta.url);
+const __pages_import_7__ = () => __vitePreload(() => import('./inspect-2b7bf157.js'),true?["./inspect-2b7bf157.js","./IframeView.vue_vue_type_script_setup_true_lang-e86027e5.js","./rpc-cf3bd0fc.js"]:void 0,import.meta.url);
+const __pages_import_9__ = () => __vitePreload(() => import('./graph-d61217d6.js'),true?["./graph-d61217d6.js","./fuse.esm-c317b696.js","./rpc-cf3bd0fc.js"]:void 0,import.meta.url);
+const __pages_import_10__ = () => __vitePreload(() => import('./documentations-a41234ba.js'),true?["./documentations-a41234ba.js","./IframeView.vue_vue_type_script_setup_true_lang-e86027e5.js","./rpc-cf3bd0fc.js"]:void 0,import.meta.url);
+const __pages_import_11__ = () => __vitePreload(() => import('./components-433e30b5.js'),true?["./components-433e30b5.js","./VPanelGrids-dc69b639.js","./StateFields.vue_vue_type_script_setup_true_lang-a78e5cb0.js","./VIcon.vue_vue_type_script_setup_true_lang-82a30fea.js","./index-07396aec.js","./VIconButton.vue_vue_type_script_setup_true_lang-fe1578eb.js","./splitpanes.es-dd27b7fe.js"]:void 0,import.meta.url);
+const __pages_import_12__ = () => __vitePreload(() => import('./component-docs-e06030af.js'),true?["./component-docs-e06030af.js","./VTextInput.vue_vue_type_script_setup_true_lang-c7c2878d.js","./VIcon.vue_vue_type_script_setup_true_lang-82a30fea.js","./splitpanes.es-dd27b7fe.js","./fuse.esm-c317b696.js","./rpc-cf3bd0fc.js","./component-docs-351d62d5.css"]:void 0,import.meta.url);
+const __pages_import_13__ = () => __vitePreload(() => import('./assets-2b8518ac.js'),true?["./assets-2b8518ac.js","./VPanelGrids-dc69b639.js","./VIconButton.vue_vue_type_script_setup_true_lang-fe1578eb.js","./VIcon.vue_vue_type_script_setup_true_lang-82a30fea.js","./rpc-cf3bd0fc.js","./VSectionBlock-57ec7b68.js","./VIconTitle.vue_vue_type_script_setup_true_lang-53c720d3.js","./VSectionBlock-52804693.css","./VTextInput.vue_vue_type_script_setup_true_lang-c7c2878d.js","./fuse.esm-c317b696.js"]:void 0,import.meta.url);
+const __pages_import_14__ = () => __vitePreload(() => import('./__eyedropper-c3a23916.js'),true?["./__eyedropper-c3a23916.js","./VPanelGrids-dc69b639.js"]:void 0,import.meta.url);
 
 const routes$1 = [{"name":"timeline","path":"/timeline","component":__pages_import_0__,"props":true},{"name":"settings","path":"/settings","component":__pages_import_1__,"props":true},{"name":"routes","path":"/routes","component":__pages_import_2__,"props":true},{"name":"pinia","path":"/pinia","component":__pages_import_3__,"props":true},{"name":"pages","path":"/pages","component":__pages_import_4__,"props":true},{"name":"overview","path":"/overview","component":__pages_import_5__,"props":true},{"name":"npm","path":"/npm","component":__pages_import_6__,"props":true},{"name":"inspect","path":"/inspect","component":__pages_import_7__,"props":true},{"name":"index","path":"/","component":_sfc_main$a,"props":true},{"name":"graph","path":"/graph","component":__pages_import_9__,"props":true},{"name":"documentations","path":"/documentations","component":__pages_import_10__,"props":true},{"name":"components","path":"/components","component":__pages_import_11__,"props":true},{"name":"component-docs","path":"/component-docs","component":__pages_import_12__,"props":true},{"name":"assets","path":"/assets","component":__pages_import_13__,"props":true},{"name":"__eyedropper","path":"/__eyedropper","component":__pages_import_14__,"props":true}];
 /* Injected with object hook! */
@@ -14453,6 +16471,253 @@ function useDevtoolsClient() {
 
 /* Injected with object hook! */
 
+const devToolsSettings = useLocalStorage("__vue-devtools-settings__", {
+  scale: 1,
+  hiddenTabs: [],
+  hiddenTabGroups: []
+}, { mergeDefaults: true });
+const devToolsSettingsRefs = toRefs(devToolsSettings);
+function useDevToolsSettings() {
+  return devToolsSettingsRefs;
+}
+
+/* Injected with object hook! */
+
+const builtinTabs = [
+  {
+    path: "overview",
+    title: "Overview",
+    icon: "i-carbon-information",
+    group: "app"
+  },
+  {
+    path: "pages",
+    title: "Pages",
+    icon: "i-carbon-tree-view-alt",
+    group: "app"
+  },
+  {
+    path: "components",
+    title: "Components",
+    icon: "i-carbon-assembly-cluster",
+    group: "app"
+  },
+  {
+    path: "assets",
+    title: "Assets",
+    icon: "i-carbon-image-copy",
+    group: "app"
+  },
+  {
+    path: "routes",
+    title: "Routes",
+    icon: "mdi:location-path",
+    group: "modules"
+  },
+  {
+    path: "pinia",
+    title: "Pinia",
+    icon: "icon-park-outline:pineapple",
+    group: "modules"
+  },
+  {
+    path: "timeline",
+    title: "Timeline",
+    icon: "i-icon-park-outline:vertical-timeline",
+    group: "app"
+  },
+  {
+    title: "EyeDropper",
+    icon: "i-mdi:eyedropper",
+    group: "advanced",
+    event: (client, router) => {
+      router.replace("/__eyedropper");
+      client.panel?.toggleViewMode("xs");
+    }
+  },
+  {
+    path: "component-docs",
+    title: "Component docs",
+    icon: "i-carbon-document-preliminary",
+    group: "advanced"
+  },
+  {
+    path: "npm",
+    title: "Search packages",
+    icon: "i-teenyicons:npm-outline",
+    group: "advanced"
+  },
+  {
+    path: "graph",
+    title: "Graph",
+    icon: "i-carbon-network-4",
+    group: "advanced"
+  },
+  {
+    path: "inspect",
+    title: "Inspect",
+    icon: "i-carbon-ibm-watson-discovery",
+    group: "advanced"
+  },
+  {
+    path: "documentations",
+    title: "Documentations",
+    icon: "i-carbon-document",
+    group: "advanced"
+  }
+];
+const DEFAULT_TAB_GROUP = "ungrouped";
+const settings = useDevToolsSettings();
+function getInitialTabs() {
+  return builtinTabs.map((tab) => ({
+    ...tab,
+    disabled: settings.hiddenTabs.value.includes(tab.title),
+    group: tab.group ?? DEFAULT_TAB_GROUP,
+    groupIndex: -1
+  }));
+}
+const allTabs = useLocalStorage(TABS_STORAGE_KEY, getInitialTabs(), {
+  shallow: true
+});
+computed(() => allTabs.value.filter((item) => !item.disabled));
+const groupsData = useLocalStorage(TABS_GROUP_STORAGE_KEY, initGroupData(allTabs.value));
+const allGroupedTabs = computed(() => getGroupedTab(allTabs.value));
+const enabledGroupedTabs = computed(() => getGroupedTab(allTabs.value, true));
+watch([settings.hiddenTabs, settings.hiddenTabGroups], ([tabsNames, groupNames]) => {
+  const allTabsNames = [...tabsNames, ...groupNames.flatMap((name) => groupsData.value[name].data.map((item) => item.name))];
+  updateDisabledTabs(allTabsNames, groupNames);
+});
+function useGroupedTabStore(enabledOnly) {
+  return enabledOnly ? enabledGroupedTabs : allGroupedTabs;
+}
+function getGroupedTab(dataSource, enabledOnly = false) {
+  const groupsKeys = Object.keys(groupsData.value);
+  if (groupsKeys.includes(DEFAULT_TAB_GROUP)) {
+    groupsKeys.splice(groupsKeys.indexOf(DEFAULT_TAB_GROUP), 1);
+    groupsKeys.push(DEFAULT_TAB_GROUP);
+  }
+  const groups = groupsKeys.reduce((groups2, key) => {
+    groups2[key] = {
+      show: groupsData.value[key].show,
+      tabs: []
+    };
+    return groups2;
+  }, {});
+  if (!groupsKeys.includes(DEFAULT_TAB_GROUP)) {
+    groups[DEFAULT_TAB_GROUP] = {
+      show: true,
+      tabs: []
+    };
+  }
+  for (const tab of dataSource) {
+    if (enabledOnly && tab.disabled)
+      continue;
+    const group = tab.group;
+    if (!groups[group])
+      console.warn(`Unknown tab group: ${group}`);
+    else
+      groups[group].tabs.push(tab);
+  }
+  return Object.entries(groups);
+}
+function initGroupData(tabs) {
+  return tabs.reduce((groups, tab) => {
+    const group = tab.group;
+    if (!groups[group]) {
+      groups[group] = {
+        show: true,
+        data: []
+      };
+    }
+    groups[group].data.push({
+      name: tab.title,
+      index: tab.groupIndex
+    });
+    return groups;
+  }, {});
+}
+function updateDisabledTabs(disabledTabNames, disabledGroups = []) {
+  const currentTabs = allTabs.value.slice();
+  currentTabs.forEach((tab) => {
+    tab.disabled = disabledTabNames.includes(tab.title);
+  });
+  allTabs.value = currentTabs;
+  for (const group of Object.values(groupsData.value))
+    group.show = true;
+  if (disabledGroups.length) {
+    for (const group of disabledGroups)
+      groupsData.value[group].show = false;
+  }
+}
+function updateTabsPosition(groupName, newTabs) {
+  const currentTabs = allTabs.value.slice();
+  currentTabs.forEach((tab) => {
+    const newTab = newTabs.find((item) => item.title === tab.title);
+    if (newTab) {
+      const index = newTabs.indexOf(newTab);
+      tab.groupIndex = index;
+      if (tab.group !== groupName)
+        tab.group = groupName;
+    }
+  });
+  allTabs.value = currentTabs;
+  groupsData.value[groupName].data = newTabs.map((item) => ({
+    name: item.title,
+    index: item.groupIndex
+  }));
+}
+function getSortedTabs(sourceTabs) {
+  const tabs = sourceTabs.slice();
+  tabs.sort((a, b) => a.groupIndex - b.groupIndex);
+  return tabs;
+}
+function ungroupAllTabs() {
+  const tabs = allTabs.value.slice();
+  const names = [];
+  tabs.forEach((tab) => {
+    tab.group = DEFAULT_TAB_GROUP;
+    tab.groupIndex = -1;
+    names.push(tab.title);
+  });
+  allTabs.value = tabs;
+  groupsData.value[DEFAULT_TAB_GROUP].data = names.map((name) => ({ name, index: -1 }));
+}
+function resetAllTabs() {
+  allTabs.value = getInitialTabs();
+  groupsData.value = initGroupData(allTabs.value);
+}
+function shouldHideTabGroup(groupName, tabLength) {
+  return groupName === DEFAULT_TAB_GROUP && tabLength === 0;
+}
+function removeTabGroup(group) {
+  const tabs = allTabs.value;
+  const tabNames = [];
+  tabs.forEach((item) => {
+    if (item.group === group) {
+      item.group = DEFAULT_TAB_GROUP;
+      item.groupIndex = -1;
+      tabNames.push(item.title);
+    }
+  });
+  allTabs.value = tabs;
+  Reflect.deleteProperty(groupsData.value, group);
+  groupsData.value[DEFAULT_TAB_GROUP].data.push(...tabNames.map((name) => ({ name, index: -1 })));
+}
+function checkGroupExist(groupName) {
+  return groupsData.value[groupName];
+}
+function createGroup(groupName) {
+  groupsData.value[groupName] = {
+    show: true,
+    data: []
+  };
+}
+function getMappedBuiltinTabs(tab) {
+  return builtinTabs.find((item) => item.title === tab.title);
+}
+
+/* Injected with object hook! */
+
 const _sfc_main$8 = /* @__PURE__ */ defineComponent({
   __name: "SideNavItem",
   props: {
@@ -14461,6 +16726,11 @@ const _sfc_main$8 = /* @__PURE__ */ defineComponent({
   setup(__props) {
     const client = useDevtoolsClient();
     const router = useRouter();
+    function handleClick(tab) {
+      const builtinTab = getMappedBuiltinTabs(tab);
+      if (builtinTab)
+        builtinTab.event?.(client.value, router);
+    }
     return (_ctx, _cache) => {
       const _component_TabIcon = _sfc_main$9;
       const _component_VTooltip = resolveComponent("VTooltip");
@@ -14483,7 +16753,7 @@ const _sfc_main$8 = /* @__PURE__ */ defineComponent({
             p1: "",
             "text-secondary": "",
             "exact-active-class": "!text-primary bg-active",
-            onClick: _cache[0] || (_cache[0] = ($event) => _ctx.tab.event?.(unref(client), unref(router)))
+            onClick: _cache[0] || (_cache[0] = () => handleClick(_ctx.tab))
           }, {
             default: withCtx(() => [
               createVNode(_component_TabIcon, {
@@ -16276,136 +18546,8 @@ const _sfc_main$3 = /* @__PURE__ */ defineComponent({
 
 /* Injected with object hook! */
 
-const devToolsSettings = useLocalStorage("__vue-devtools-settings__", {
-  scale: 1,
-  hiddenTabs: [],
-  hiddenTabCategories: []
-}, { mergeDefaults: true });
-const devToolsSettingsRefs = toRefs(devToolsSettings);
-function useDevToolsSettings() {
-  return devToolsSettingsRefs;
-}
-
-/* Injected with object hook! */
-
-const builtinTabs = [
-  {
-    path: "overview",
-    title: "Overview",
-    icon: "i-carbon-information"
-  },
-  {
-    path: "pages",
-    title: "Pages",
-    icon: "i-carbon-tree-view-alt"
-  },
-  {
-    path: "components",
-    title: "Components",
-    icon: "i-carbon-assembly-cluster"
-  },
-  {
-    path: "assets",
-    title: "Assets",
-    icon: "i-carbon-image-copy"
-  },
-  {
-    path: "routes",
-    title: "Routes",
-    icon: "mdi:location-path",
-    category: "modules"
-  },
-  {
-    path: "pinia",
-    title: "Pinia",
-    icon: "icon-park-outline:pineapple",
-    category: "modules"
-  },
-  {
-    path: "timeline",
-    title: "Timeline",
-    icon: "i-icon-park-outline:vertical-timeline"
-  },
-  // migrate to inspector button
-  // {
-  //   title: 'Inspector',
-  //   icon: 'i-carbon-select-window',
-  //   category: 'advanced',
-  //   event: (client, router) => {
-  //     router.replace('/__inspecting')
-  //     client?.inspector?.enable()
-  //   },
-  // },
-  {
-    title: "EyeDropper",
-    icon: "i-mdi:eyedropper",
-    category: "advanced",
-    event: (client, router) => {
-      router.replace("/__eyedropper");
-      client.panel?.toggleViewMode("xs");
-    }
-  },
-  {
-    path: "component-docs",
-    title: "Component docs",
-    icon: "i-carbon-document-preliminary",
-    category: "advanced"
-  },
-  {
-    path: "npm",
-    title: "Search packages",
-    icon: "i-teenyicons:npm-outline",
-    category: "advanced"
-  },
-  {
-    path: "graph",
-    title: "Graph",
-    icon: "i-carbon-network-4",
-    category: "advanced"
-  },
-  {
-    path: "inspect",
-    title: "Inspect",
-    icon: "i-carbon-ibm-watson-discovery",
-    category: "advanced"
-  },
-  {
-    path: "documentations",
-    title: "Documentations",
-    icon: "i-carbon-document",
-    category: "advanced"
-  }
-];
-function useTabs() {
-  const settings = useDevToolsSettings();
-  return {
-    enabled: computed(() => {
-      return builtinTabs.filter((tab) => !settings.hiddenTabs.value.includes(tab.title ?? ""));
-    }),
-    all: computed(() => builtinTabs)
-  };
-}
-function useCategorizedTabs(enabledOnly = true) {
-  const _tabs = useTabs();
-  const tabs = enabledOnly ? _tabs.enabled : _tabs.all;
-  const settings = useDevToolsSettings();
-  return computed(() => {
-    const categories = {
-      app: [],
-      modules: [],
-      advanced: []
-    };
-    for (const tab of tabs.value) {
-      const category = tab?.category || "app";
-      if (enabledOnly && settings.hiddenTabCategories.value.includes(category))
-        continue;
-      if (!categories[category])
-        console.warn(`Unknown tab category: ${category}`);
-      else
-        categories[category].push(tab);
-    }
-    return Object.entries(categories);
-  });
+function useGroupedTabs(enabledOnly = true) {
+  return useGroupedTabStore(enabledOnly);
 }
 
 /* Injected with object hook! */
@@ -16465,7 +18607,7 @@ const _hoisted_9 = /* @__PURE__ */ createBaseVNode("div", {
 const _sfc_main$2 = /* @__PURE__ */ defineComponent({
   __name: "SideNav",
   setup(__props) {
-    const categories = useCategorizedTabs();
+    const groupedTabs = useGroupedTabs();
     return (_ctx, _cache) => {
       const _component_DockingPanel = _sfc_main$3;
       const _component_VDropdown = resolveComponent("VDropdown");
@@ -16489,11 +18631,11 @@ const _sfc_main$2 = /* @__PURE__ */ defineComponent({
           _hoisted_4
         ]),
         createBaseVNode("div", _hoisted_5, [
-          (openBlock(true), createElementBlock(Fragment, null, renderList(unref(categories), ([name, tabs], idx) => {
+          (openBlock(true), createElementBlock(Fragment, null, renderList(unref(groupedTabs), ([name, { tabs, show }], idx) => {
             return openBlock(), createElementBlock(Fragment, { key: name }, [
-              tabs.length ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+              tabs.length && show ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
                 idx ? (openBlock(), createElementBlock("div", _hoisted_6)) : createCommentVNode("", true),
-                (openBlock(true), createElementBlock(Fragment, null, renderList(tabs, (tab) => {
+                (openBlock(true), createElementBlock(Fragment, null, renderList(unref(getSortedTabs)(tabs), (tab) => {
                   return openBlock(), createBlock(_component_SideNavItem, {
                     key: tab.path,
                     tab
@@ -17314,4 +19456,4 @@ app.mount("#app");
 
 /* Injected with object hook! */
 
-export { toggleRouteRecordMatcher as $, timelineLayer as A, activeTimelineEvents as B, activeTimelineEventIndex as C, toggleTimelineEventIndex as D, timelineEventDetails as E, Fragment as F, activeLayerId as G, toggleTimelineLayer as H, useVModel as I, vModelSelect as J, isRef as K, vModelCheckbox as L, withKeys as M, useCategorizedTabs as N, isInPopup as O, createTextVNode as P, useDevToolsSettings as Q, useFrameState as R, _sfc_main$4 as S, _sfc_main$d as T, _sfc_main$7 as U, _sfc_main$9 as V, router$1 as W, routeRecordMatcherState as X, activeRouteRecordMatcherState as Y, activeRouteRecordIndex as Z, __unplugin_components_7 as _, popScopeId as a, __unplugin_components_1 as a0, ref as a1, computed as a2, piniaStoresCategory as a3, toRaw as a4, piniaState as a5, piniaGetters as a6, withModifiers as a7, onMounted as a8, currentRoute as a9, onClickOutside as aA, Transition as aB, useStyleTag as aC, computedAsync as aD, useTimeAgo as aE, onKeyDown as aF, _export_sfc as aG, vModelDynamic as aH, __vitePreload as aI, useRouter as aJ, useDevtoolsClient as aK, routes as aa, vueVersion as ab, __unplugin_components_0 as ac, useEventListener as ad, hookApi as ae, useScrollLock as af, watch as ag, useInfiniteScroll as ah, useStorage as ai, vModelText as aj, useDark as ak, Teleport as al, useColorMode as am, reactive as an, useElementBounding as ao, watchEffect as ap, onUnmounted as aq, shallowRef as ar, onVueInstanceUpdate as as, instance as at, useCopy as au, nanoid as av, vShow as aw, getCurrentInstance as ax, h as ay, useElementSize as az, resolveDirective as b, createBlock as c, withDirectives as d, createElementBlock as e, renderSlot as f, createCommentVNode as g, withCtx as h, renderList as i, resolveDynamicComponent as j, mergeProps as k, normalizeStyle as l, markRaw as m, nextTick as n, openBlock as o, pushScopeId as p, normalizeClass as q, resolveComponent as r, shallowReactive as s, toHandlers as t, createVNode as u, defineComponent as v, withScopeId as w, createBaseVNode as x, toDisplayString as y, unref as z };
+export { cloneVNode as $, timelineLayer as A, activeTimelineEvents as B, activeTimelineEventIndex as C, toggleTimelineEventIndex as D, timelineEventDetails as E, Fragment as F, activeLayerId as G, toggleTimelineLayer as H, BaseTransition as I, BaseTransitionPropsValidators as J, Comment as K, EffectScope as L, KeepAlive as M, Suspense as N, Text as O, Transition as P, TransitionGroup as Q, ReactiveEffect as R, Static as S, Teleport as T, assertNumber as U, VueElement as V, callWithAsyncErrorHandling as W, callWithErrorHandling as X, camelize as Y, capitalize as Z, __unplugin_components_7 as _, popScopeId as a, ref as a$, compatUtils as a0, computed as a1, createApp as a2, createHydrationRenderer as a3, createPropsRestProxy as a4, createRenderer as a5, createSSRApp as a6, createSlots as a7, createStaticVNode as a8, createTextVNode as a9, isReactive as aA, isReadonly as aB, isRef as aC, isRuntimeOnly as aD, isShallow as aE, isVNode as aF, mergeDefaults as aG, mergeModels as aH, normalizeProps as aI, onActivated as aJ, onBeforeMount as aK, onBeforeUnmount as aL, onBeforeUpdate as aM, onDeactivated as aN, onErrorCaptured as aO, onMounted as aP, onRenderTracked as aQ, onRenderTriggered as aR, onScopeDispose as aS, onServerPrefetch as aT, onUnmounted as aU, onUpdated as aV, provide as aW, proxyRefs as aX, queuePostFlushCb as aY, reactive as aZ, readonly as a_, customRef as aa, defineAsyncComponent as ab, defineCustomElement as ac, defineEmits as ad, defineExpose as ae, defineModel as af, defineOptions as ag, defineProps as ah, defineSSRCustomElement as ai, defineSlots as aj, devtools as ak, effect as al, effectScope as am, getCurrentInstance as an, getCurrentScope as ao, getTransitionRawChildren as ap, guardReactiveProps as aq, h as ar, handleError as as, hasInjectionContext as at, hydrate as au, initCustomFormatter as av, initDirectivesForSSR as aw, inject as ax, isMemoSame as ay, isProxy as az, resolveDirective as b, _sfc_main$9 as b$, registerRuntimeCompiler as b0, render$1 as b1, resolveFilter as b2, resolveTransitionHooks as b3, setBlockTracking as b4, setDevtoolsHook as b5, setTransitionHooks as b6, shallowReadonly as b7, shallowRef as b8, ssrContextKey as b9, watchPostEffect as bA, watchSyncEffect as bB, withAsyncContext as bC, withDefaults as bD, withKeys as bE, withMemo as bF, withModifiers as bG, useVModel as bH, getSortedTabs as bI, updateTabsPosition as bJ, _export_sfc as bK, _sfc_main$d as bL, _sfc_main$5 as bM, useToggle as bN, shouldHideTabGroup as bO, DEFAULT_TAB_GROUP as bP, useGroupedTabs as bQ, ungroupAllTabs as bR, resetAllTabs as bS, removeTabGroup as bT, checkGroupExist as bU, createGroup as bV, isInPopup as bW, useDevToolsSettings as bX, useFrameState as bY, _sfc_main$4 as bZ, _sfc_main$7 as b_, ssrUtils as ba, stop as bb, toHandlerKey as bc, toRaw as bd, toRef$1 as be, toRefs$1 as bf, toValue$2 as bg, transformVNodeArgs as bh, triggerRef as bi, useAttrs as bj, useCssModule as bk, useCssVars as bl, useModel as bm, useSSRContext as bn, useSlots as bo, useTransitionState as bp, vModelCheckbox as bq, vModelDynamic as br, vModelRadio as bs, vModelSelect as bt, vModelText as bu, vShow as bv, version as bw, warn as bx, watch as by, watchEffect as bz, createBlock as c, router$1 as c0, routeRecordMatcherState as c1, activeRouteRecordMatcherState as c2, activeRouteRecordIndex as c3, toggleRouteRecordMatcher as c4, __unplugin_components_1 as c5, piniaStoresCategory as c6, piniaState as c7, piniaGetters as c8, currentRoute as c9, routes as ca, vueVersion as cb, __unplugin_components_0 as cc, useEventListener as cd, hookApi as ce, useScrollLock as cf, useInfiniteScroll as cg, useStorage as ch, useDark as ci, useColorMode as cj, useElementBounding as ck, onVueInstanceUpdate as cl, instance as cm, useCopy as cn, nanoid as co, useElementSize as cp, onClickOutside as cq, useStyleTag as cr, computedAsync as cs, useTimeAgo as ct, onKeyDown as cu, __vitePreload as cv, useRouter as cw, useDevtoolsClient as cx, withDirectives as d, createElementBlock as e, renderSlot as f, createCommentVNode as g, withCtx as h, renderList as i, resolveDynamicComponent as j, mergeProps as k, normalizeStyle as l, markRaw as m, nextTick as n, openBlock as o, pushScopeId as p, normalizeClass as q, resolveComponent as r, shallowReactive as s, toHandlers as t, createVNode as u, defineComponent as v, withScopeId as w, createBaseVNode as x, toDisplayString as y, unref as z };