@vue/runtime-core 3.5.16 → 3.6.0-alpha.1

package/dist/runtime-core.esm-bundler.js

@@ -1,16 +1,16 @@
 /**
-* @vue/runtime-core v3.5.16
+* @vue/runtime-core v3.6.0-alpha.1
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
-import { pauseTracking, resetTracking, isRef, toRaw, traverse, shallowRef, readonly, isReactive, ref, isShallow, isReadonly, shallowReadArray, toReadonly, toReactive, shallowReadonly, track, reactive, shallowReactive, trigger, ReactiveEffect, watch as watch$1, customRef, isProxy, proxyRefs, markRaw, EffectScope, computed as computed$1 } from '@vue/reactivity';
+import { setActiveSub, isRef, toRaw, traverse, shallowRef, readonly, isReactive, ref, isShallow, isReadonly, shallowReadArray, toReadonly, toReactive, shallowReadonly, track, reactive, shallowReactive, trigger, ReactiveEffect, setCurrentScope, WatcherEffect, customRef, isProxy, proxyRefs, markRaw, EffectScope, computed as computed$1 } from '@vue/reactivity';
 export { EffectScope, ReactiveEffect, TrackOpTypes, TriggerOpTypes, customRef, effect, effectScope, getCurrentScope, getCurrentWatcher, isProxy, isReactive, isReadonly, isRef, isShallow, markRaw, onScopeDispose, onWatcherCleanup, proxyRefs, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, toValue, triggerRef, unref } from '@vue/reactivity';
-import { isString, isFunction, EMPTY_OBJ, isPromise, isArray, NOOP, getGlobalThis, extend, isBuiltInDirective, hasOwn, remove, def, isOn, isReservedProp, normalizeClass, stringifyStyle, normalizeStyle, isKnownSvgAttr, isBooleanAttr, isKnownHtmlAttr, includeBooleanAttr, isRenderableAttrValue, getEscapedCssVarName, isObject, isRegExp, invokeArrayFns, toHandlerKey, camelize, capitalize, isSymbol, isGloballyAllowed, NO, EMPTY_ARR, hyphenate, makeMap, toRawType, hasChanged, looseToNumber, isModelListener, toNumber } from '@vue/shared';
+import { isString, isFunction, EMPTY_OBJ, isPromise, isArray, getGlobalThis, extend, isBuiltInDirective, hasOwn, remove, def, isOn, isReservedProp, normalizeClass, stringifyStyle, normalizeStyle, isKnownSvgAttr, isBooleanAttr, isKnownHtmlAttr, includeBooleanAttr, isRenderableAttrValue, normalizeCssVarValue, getEscapedCssVarName, isObject, isRegExp, invokeArrayFns, toHandlerKey, camelize, capitalize, isSymbol, NOOP, isGloballyAllowed, NO, hyphenate, EMPTY_ARR, makeMap, toRawType, getSequence, hasChanged, looseToNumber, isModelListener, toNumber, isBuiltInTag } from '@vue/shared';
 export { camelize, capitalize, normalizeClass, normalizeProps, normalizeStyle, toDisplayString, toHandlerKey } from '@vue/shared';
 
 const stack = [];
-function pushWarningContext(vnode) {
-  stack.push(vnode);
+function pushWarningContext(ctx) {
+  stack.push(ctx);
 }
 function popWarningContext() {
   stack.pop();
@@ -19,8 +19,9 @@ let isWarning = false;
 function warn$1(msg, ...args) {
   if (isWarning) return;
   isWarning = true;
-  pauseTracking();
-  const instance = stack.length ? stack[stack.length - 1].component : null;
+  const prevSub = setActiveSub();
+  const entry = stack.length ? stack[stack.length - 1] : null;
+  const instance = isVNode(entry) ? entry.component : entry;
   const appWarnHandler = instance && instance.appContext.config.warnHandler;
   const trace = getComponentTrace();
   if (appWarnHandler) {
@@ -34,9 +35,9 @@ function warn$1(msg, ...args) {
           var _a, _b;
           return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
         }).join(""),
-        instance && instance.proxy,
+        instance && instance.proxy || instance,
         trace.map(
-          ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
+          ({ ctx }) => `at <${formatComponentName(instance, ctx.type)}>`
         ).join("\n"),
         trace
       ]
@@ -50,27 +51,31 @@ function warn$1(msg, ...args) {
     }
     console.warn(...warnArgs);
   }
-  resetTracking();
+  setActiveSub(prevSub);
   isWarning = false;
 }
 function getComponentTrace() {
-  let currentVNode = stack[stack.length - 1];
-  if (!currentVNode) {
+  let currentCtx = stack[stack.length - 1];
+  if (!currentCtx) {
     return [];
   }
   const normalizedStack = [];
-  while (currentVNode) {
+  while (currentCtx) {
     const last = normalizedStack[0];
-    if (last && last.vnode === currentVNode) {
+    if (last && last.ctx === currentCtx) {
       last.recurseCount++;
     } else {
       normalizedStack.push({
-        vnode: currentVNode,
+        ctx: currentCtx,
         recurseCount: 0
       });
     }
-    const parentInstance = currentVNode.component && currentVNode.component.parent;
-    currentVNode = parentInstance && parentInstance.vnode;
+    if (isVNode(currentCtx)) {
+      const parent = currentCtx.component && currentCtx.component.parent;
+      currentCtx = parent && parent.vnode || parent;
+    } else {
+      currentCtx = currentCtx.parent;
+    }
   }
   return normalizedStack;
 }
@@ -82,16 +87,13 @@ function formatTrace(trace) {
   });
   return logs;
 }
-function formatTraceEntry({ vnode, recurseCount }) {
+function formatTraceEntry({ ctx, recurseCount }) {
   const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
-  const isRoot = vnode.component ? vnode.component.parent == null : false;
-  const open = ` at <${formatComponentName(
-    vnode.component,
-    vnode.type,
-    isRoot
-  )}`;
+  const instance = isVNode(ctx) ? ctx.component : ctx;
+  const isRoot = instance ? instance.parent == null : false;
+  const open = ` at <${formatComponentName(instance, ctx.type, isRoot)}`;
   const close = `>` + postfix;
-  return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
+  return ctx.props ? [open, ...formatProps(ctx.props), close] : [open + close];
 }
 function formatProps(props) {
   const res = [];
@@ -224,11 +226,10 @@ function callWithAsyncErrorHandling(fn, instance, type, args) {
   }
 }
 function handleError(err, instance, type, throwInDev = true) {
-  const contextVNode = instance ? instance.vnode : null;
   const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
   if (instance) {
     let cur = instance.parent;
-    const exposedInstance = instance.proxy;
+    const exposedInstance = instance.proxy || instance;
     const errorInfo = !!(process.env.NODE_ENV !== "production") ? ErrorTypeStrings$1[type] : `https://vuejs.org/error-reference/#runtime-${type}`;
     while (cur) {
       const errorCapturedHooks = cur.ec;
@@ -242,26 +243,26 @@ function handleError(err, instance, type, throwInDev = true) {
       cur = cur.parent;
     }
     if (errorHandler) {
-      pauseTracking();
+      const prevSub = setActiveSub();
       callWithErrorHandling(errorHandler, null, 10, [
         err,
         exposedInstance,
         errorInfo
       ]);
-      resetTracking();
+      setActiveSub(prevSub);
       return;
     }
   }
-  logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
+  logError(err, type, instance, throwInDev, throwUnhandledErrorInProduction);
 }
-function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
+function logError(err, type, instance, throwInDev = true, throwInProd = false) {
   if (!!(process.env.NODE_ENV !== "production")) {
     const info = ErrorTypeStrings$1[type];
-    if (contextVNode) {
-      pushWarningContext(contextVNode);
+    if (instance) {
+      pushWarningContext(instance);
     }
     warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
-    if (contextVNode) {
+    if (instance) {
       popWarningContext();
     }
     if (throwInDev) {
@@ -276,26 +277,23 @@ function logError(err, type, contextVNode, throwInDev = true, throwInProd = fals
   }
 }
 
-const queue = [];
-let flushIndex = -1;
-const pendingPostFlushCbs = [];
-let activePostFlushCbs = null;
+const jobs = [];
+let postJobs = [];
+let activePostJobs = null;
+let currentFlushPromise = null;
+let jobsLength = 0;
+let flushIndex = 0;
 let postFlushIndex = 0;
 const resolvedPromise = /* @__PURE__ */ Promise.resolve();
-let currentFlushPromise = null;
 const RECURSION_LIMIT = 100;
 function nextTick(fn) {
   const p = currentFlushPromise || resolvedPromise;
   return fn ? p.then(this ? fn.bind(this) : fn) : p;
 }
-function findInsertionIndex(id) {
-  let start = flushIndex + 1;
-  let end = queue.length;
+function findInsertionIndex(order, queue, start, end) {
   while (start < end) {
     const middle = start + end >>> 1;
-    const middleJob = queue[middle];
-    const middleJobId = getId(middleJob);
-    if (middleJobId < id || middleJobId === id && middleJob.flags & 2) {
+    if (queue[middle].order <= order) {
       start = middle + 1;
     } else {
       end = middle;
@@ -303,130 +301,168 @@ function findInsertionIndex(id) {
   }
   return start;
 }
-function queueJob(job) {
-  if (!(job.flags & 1)) {
-    const jobId = getId(job);
-    const lastJob = queue[queue.length - 1];
-    if (!lastJob || // fast path when the job id is larger than the tail
-    !(job.flags & 2) && jobId >= getId(lastJob)) {
-      queue.push(job);
+function queueJob(job, id, isPre = false) {
+  if (queueJobWorker(
+    job,
+    id === void 0 ? isPre ? -2 : Infinity : isPre ? id * 2 : id * 2 + 1,
+    jobs,
+    jobsLength,
+    flushIndex
+  )) {
+    jobsLength++;
+    queueFlush();
+  }
+}
+function queueJobWorker(job, order, queue, length, flushIndex2) {
+  const flags = job.flags;
+  if (!(flags & 1)) {
+    job.flags = flags | 1;
+    job.order = order;
+    if (flushIndex2 === length || // fast path when the job id is larger than the tail
+    order >= queue[length - 1].order) {
+      queue[length] = job;
     } else {
-      queue.splice(findInsertionIndex(jobId), 0, job);
+      queue.splice(findInsertionIndex(order, queue, flushIndex2, length), 0, job);
     }
-    job.flags |= 1;
-    queueFlush();
+    return true;
   }
+  return false;
 }
+const doFlushJobs = () => {
+  try {
+    flushJobs();
+  } catch (e) {
+    currentFlushPromise = null;
+    throw e;
+  }
+};
 function queueFlush() {
   if (!currentFlushPromise) {
-    currentFlushPromise = resolvedPromise.then(flushJobs);
+    currentFlushPromise = resolvedPromise.then(doFlushJobs);
   }
 }
-function queuePostFlushCb(cb) {
-  if (!isArray(cb)) {
-    if (activePostFlushCbs && cb.id === -1) {
-      activePostFlushCbs.splice(postFlushIndex + 1, 0, cb);
-    } else if (!(cb.flags & 1)) {
-      pendingPostFlushCbs.push(cb);
-      cb.flags |= 1;
+function queuePostFlushCb(jobs2, id = Infinity) {
+  if (!isArray(jobs2)) {
+    if (activePostJobs && id === -1) {
+      activePostJobs.splice(postFlushIndex, 0, jobs2);
+    } else {
+      queueJobWorker(jobs2, id, postJobs, postJobs.length, 0);
     }
   } else {
-    pendingPostFlushCbs.push(...cb);
+    for (const job of jobs2) {
+      queueJobWorker(job, id, postJobs, postJobs.length, 0);
+    }
   }
   queueFlush();
 }
-function flushPreFlushCbs(instance, seen, i = flushIndex + 1) {
+function flushPreFlushCbs(instance, seen) {
   if (!!(process.env.NODE_ENV !== "production")) {
     seen = seen || /* @__PURE__ */ new Map();
   }
-  for (; i < queue.length; i++) {
-    const cb = queue[i];
-    if (cb && cb.flags & 2) {
-      if (instance && cb.id !== instance.uid) {
-        continue;
-      }
-      if (!!(process.env.NODE_ENV !== "production") && checkRecursiveUpdates(seen, cb)) {
-        continue;
-      }
-      queue.splice(i, 1);
-      i--;
-      if (cb.flags & 4) {
-        cb.flags &= -2;
-      }
-      cb();
-      if (!(cb.flags & 4)) {
-        cb.flags &= -2;
-      }
+  for (let i = flushIndex; i < jobsLength; i++) {
+    const cb = jobs[i];
+    if (cb.order & 1 || cb.order === Infinity) {
+      continue;
+    }
+    if (instance && cb.order !== instance.uid * 2) {
+      continue;
+    }
+    if (!!(process.env.NODE_ENV !== "production") && checkRecursiveUpdates(seen, cb)) {
+      continue;
+    }
+    jobs.splice(i, 1);
+    i--;
+    jobsLength--;
+    if (cb.flags & 2) {
+      cb.flags &= -2;
+    }
+    cb();
+    if (!(cb.flags & 2)) {
+      cb.flags &= -2;
     }
   }
 }
 function flushPostFlushCbs(seen) {
-  if (pendingPostFlushCbs.length) {
-    const deduped = [...new Set(pendingPostFlushCbs)].sort(
-      (a, b) => getId(a) - getId(b)
-    );
-    pendingPostFlushCbs.length = 0;
-    if (activePostFlushCbs) {
-      activePostFlushCbs.push(...deduped);
+  if (postJobs.length) {
+    if (activePostJobs) {
+      activePostJobs.push(...postJobs);
+      postJobs.length = 0;
       return;
     }
-    activePostFlushCbs = deduped;
+    activePostJobs = postJobs;
+    postJobs = [];
     if (!!(process.env.NODE_ENV !== "production")) {
       seen = seen || /* @__PURE__ */ new Map();
     }
-    for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
-      const cb = activePostFlushCbs[postFlushIndex];
+    while (postFlushIndex < activePostJobs.length) {
+      const cb = activePostJobs[postFlushIndex++];
       if (!!(process.env.NODE_ENV !== "production") && checkRecursiveUpdates(seen, cb)) {
         continue;
       }
-      if (cb.flags & 4) {
+      if (cb.flags & 2) {
         cb.flags &= -2;
       }
-      if (!(cb.flags & 8)) cb();
-      cb.flags &= -2;
+      if (!(cb.flags & 4)) {
+        try {
+          cb();
+        } finally {
+          cb.flags &= -2;
+        }
+      }
     }
-    activePostFlushCbs = null;
+    activePostJobs = null;
     postFlushIndex = 0;
   }
 }
-const getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
+let isFlushing = false;
+function flushOnAppMount() {
+  if (!isFlushing) {
+    isFlushing = true;
+    flushPreFlushCbs();
+    flushPostFlushCbs();
+    isFlushing = false;
+  }
+}
 function flushJobs(seen) {
   if (!!(process.env.NODE_ENV !== "production")) {
-    seen = seen || /* @__PURE__ */ new Map();
+    seen || (seen = /* @__PURE__ */ new Map());
   }
-  const check = !!(process.env.NODE_ENV !== "production") ? (job) => checkRecursiveUpdates(seen, job) : NOOP;
   try {
-    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
-      const job = queue[flushIndex];
-      if (job && !(job.flags & 8)) {
-        if (!!(process.env.NODE_ENV !== "production") && check(job)) {
+    while (flushIndex < jobsLength) {
+      const job = jobs[flushIndex];
+      jobs[flushIndex++] = void 0;
+      if (!(job.flags & 4)) {
+        if (!!(process.env.NODE_ENV !== "production") && checkRecursiveUpdates(seen, job)) {
           continue;
         }
-        if (job.flags & 4) {
+        if (job.flags & 2) {
           job.flags &= ~1;
         }
-        callWithErrorHandling(
-          job,
-          job.i,
-          job.i ? 15 : 14
-        );
-        if (!(job.flags & 4)) {
-          job.flags &= ~1;
+        try {
+          job();
+        } catch (err) {
+          handleError(
+            err,
+            job.i,
+            job.i ? 15 : 14
+          );
+        } finally {
+          if (!(job.flags & 2)) {
+            job.flags &= ~1;
+          }
         }
       }
     }
   } finally {
-    for (; flushIndex < queue.length; flushIndex++) {
-      const job = queue[flushIndex];
-      if (job) {
-        job.flags &= -2;
-      }
+    while (flushIndex < jobsLength) {
+      jobs[flushIndex].flags &= -2;
+      jobs[flushIndex++] = void 0;
     }
-    flushIndex = -1;
-    queue.length = 0;
+    flushIndex = 0;
+    jobsLength = 0;
     flushPostFlushCbs(seen);
     currentFlushPromise = null;
-    if (queue.length || pendingPostFlushCbs.length) {
+    if (jobsLength || postJobs.length) {
       flushJobs(seen);
     }
   }
@@ -493,10 +529,17 @@ function rerender(id, newRender) {
       instance.render = newRender;
       normalizeClassComponent(instance.type).render = newRender;
     }
-    instance.renderCache = [];
     isHmrUpdating = true;
-    instance.update();
-    isHmrUpdating = false;
+    if (instance.vapor) {
+      instance.hmrRerender();
+    } else {
+      const i = instance;
+      i.renderCache = [];
+      i.effect.run();
+    }
+    nextTick(() => {
+      isHmrUpdating = false;
+    });
   });
 }
 function reload(id, newComp) {
@@ -505,42 +548,54 @@ function reload(id, newComp) {
   newComp = normalizeClassComponent(newComp);
   updateComponentDef(record.initialDef, newComp);
   const instances = [...record.instances];
-  for (let i = 0; i < instances.length; i++) {
-    const instance = instances[i];
-    const oldComp = normalizeClassComponent(instance.type);
-    let dirtyInstances = hmrDirtyComponents.get(oldComp);
-    if (!dirtyInstances) {
-      if (oldComp !== record.initialDef) {
-        updateComponentDef(oldComp, newComp);
-      }
-      hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set());
-    }
-    dirtyInstances.add(instance);
-    instance.appContext.propsCache.delete(instance.type);
-    instance.appContext.emitsCache.delete(instance.type);
-    instance.appContext.optionsCache.delete(instance.type);
-    if (instance.ceReload) {
+  if (newComp.vapor) {
+    for (const instance of instances) {
+      instance.hmrReload(newComp);
+    }
+  } else {
+    for (const instance of instances) {
+      const oldComp = normalizeClassComponent(instance.type);
+      let dirtyInstances = hmrDirtyComponents.get(oldComp);
+      if (!dirtyInstances) {
+        if (oldComp !== record.initialDef) {
+          updateComponentDef(oldComp, newComp);
+        }
+        hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set());
+      }
       dirtyInstances.add(instance);
-      instance.ceReload(newComp.styles);
-      dirtyInstances.delete(instance);
-    } else if (instance.parent) {
-      queueJob(() => {
-        isHmrUpdating = true;
-        instance.parent.update();
-        isHmrUpdating = false;
+      instance.appContext.propsCache.delete(instance.type);
+      instance.appContext.emitsCache.delete(instance.type);
+      instance.appContext.optionsCache.delete(instance.type);
+      if (instance.ceReload) {
+        dirtyInstances.add(instance);
+        instance.ceReload(newComp.styles);
         dirtyInstances.delete(instance);
-      });
-    } else if (instance.appContext.reload) {
-      instance.appContext.reload();
-    } else if (typeof window !== "undefined") {
-      window.location.reload();
-    } else {
-      console.warn(
-        "[HMR] Root or manually mounted instance modified. Full reload required."
-      );
-    }
-    if (instance.root.ce && instance !== instance.root) {
-      instance.root.ce._removeChildStyle(oldComp);
+      } else if (instance.parent) {
+        queueJob(() => {
+          isHmrUpdating = true;
+          const parent = instance.parent;
+          if (parent.vapor) {
+            parent.hmrRerender();
+          } else {
+            parent.effect.run();
+          }
+          nextTick(() => {
+            isHmrUpdating = false;
+          });
+          dirtyInstances.delete(instance);
+        });
+      } else if (instance.appContext.reload) {
+        instance.appContext.reload();
+      } else if (typeof window !== "undefined") {
+        window.location.reload();
+      } else {
+        console.warn(
+          "[HMR] Root or manually mounted instance modified. Full reload required."
+        );
+      }
+      if (instance.root.ce && instance !== instance.root) {
+        instance.root.ce._removeChildStyle(oldComp);
+      }
     }
   }
   queuePostFlushCb(() => {
@@ -753,14 +808,14 @@ function invokeDirectiveHook(vnode, prevVNode, instance, name) {
     }
     let hook = binding.dir[name];
     if (hook) {
-      pauseTracking();
+      const prevSub = setActiveSub();
       callWithAsyncErrorHandling(hook, instance, 8, [
         vnode.el,
         binding,
         vnode,
         prevVNode
       ]);
-      resetTracking();
+      setActiveSub(prevSub);
     }
   }
 }
@@ -860,29 +915,37 @@ const TeleportImpl = {
       }
       if (isTeleportDeferred(n2.props)) {
         n2.el.__isMounted = false;
-        queuePostRenderEffect(() => {
-          mountToTarget();
-          delete n2.el.__isMounted;
-        }, parentSuspense);
+        queuePostRenderEffect(
+          () => {
+            mountToTarget();
+            delete n2.el.__isMounted;
+          },
+          void 0,
+          parentSuspense
+        );
       } else {
         mountToTarget();
       }
     } else {
       if (isTeleportDeferred(n2.props) && n1.el.__isMounted === false) {
-        queuePostRenderEffect(() => {
-          TeleportImpl.process(
-            n1,
-            n2,
-            container,
-            anchor,
-            parentComponent,
-            parentSuspense,
-            namespace,
-            slotScopeIds,
-            optimized,
-            internals
-          );
-        }, parentSuspense);
+        queuePostRenderEffect(
+          () => {
+            TeleportImpl.process(
+              n1,
+              n2,
+              container,
+              anchor,
+              parentComponent,
+              parentSuspense,
+              namespace,
+              slotScopeIds,
+              optimized,
+              internals
+            );
+          },
+          void 0,
+          parentSuspense
+        );
         return;
       }
       n2.el = n1.el;
@@ -929,6 +992,7 @@ const TeleportImpl = {
             container,
             mainAnchor,
             internals,
+            parentComponent,
             1
           );
         } else {
@@ -948,6 +1012,7 @@ const TeleportImpl = {
               nextTarget,
               null,
               internals,
+              parentComponent,
               0
             );
           } else if (!!(process.env.NODE_ENV !== "production")) {
@@ -963,6 +1028,7 @@ const TeleportImpl = {
             target,
             targetAnchor,
             internals,
+            parentComponent,
             1
           );
         }
@@ -1002,7 +1068,7 @@ const TeleportImpl = {
   move: moveTeleport,
   hydrate: hydrateTeleport
 };
-function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) {
+function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, parentComponent, moveType = 2) {
   if (moveType === 0) {
     insert(vnode.targetAnchor, container, parentAnchor);
   }
@@ -1018,7 +1084,8 @@ function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }
           children[i],
           container,
           parentAnchor,
-          2
+          2,
+          parentComponent
         );
       }
     }
@@ -1203,7 +1270,7 @@ const BaseTransitionImpl = {
           state.isLeaving = true;
           leavingHooks.afterLeave = () => {
             state.isLeaving = false;
-            if (!(instance.job.flags & 8)) {
+            if (!(instance.job.flags & 4)) {
               instance.update();
             }
             delete leavingHooks.afterLeave;
@@ -1483,7 +1550,7 @@ function defineComponent(options, extraOptions) {
 }
 
 function useId() {
-  const i = getCurrentInstance();
+  const i = getCurrentGenericInstance();
   if (i) {
     return (i.appContext.config.idPrefix || "v") + "-" + i.ids[0] + i.ids[1]++;
   } else if (!!(process.env.NODE_ENV !== "production")) {
@@ -1499,7 +1566,7 @@ function markAsyncBoundary(instance) {
 
 const knownTemplateRefs = /* @__PURE__ */ new WeakSet();
 function useTemplateRef(key) {
-  const i = getCurrentInstance();
+  const i = getCurrentGenericInstance();
   const r = shallowRef(null);
   if (i) {
     const refs = i.refs === EMPTY_OBJ ? i.refs = {} : i.refs;
@@ -1619,8 +1686,7 @@ function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
         }
       };
       if (value) {
-        doSet.id = -1;
-        queuePostRenderEffect(doSet, parentSuspense);
+        queuePostRenderEffect(doSet, -1, parentSuspense);
       } else {
         doSet();
       }
@@ -1788,6 +1854,9 @@ function createHydrationFunctions(rendererInternals) {
             );
           }
         } else if (shapeFlag & 6) {
+          if (vnode.type.__vapor) {
+            throw new Error("Vapor component hydration is not supported yet.");
+          }
           vnode.slotScopeIds = slotScopeIds;
           const container = parentNode(node);
           if (isFragmentStart) {
@@ -1960,11 +2029,15 @@ Server rendered element contains more child nodes than client vdom.`
         invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
       }
       if ((vnodeHooks = props && props.onVnodeMounted) || dirs || needCallTransitionHooks) {
-        queueEffectWithSuspense(() => {
-          vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);
-          needCallTransitionHooks && transition.enter(el);
-          dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
-        }, parentSuspense);
+        queueEffectWithSuspense(
+          () => {
+            vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);
+            needCallTransitionHooks && transition.enter(el);
+            dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
+          },
+          void 0,
+          parentSuspense
+        );
       }
     }
     return el.nextSibling;
@@ -2244,14 +2317,16 @@ function resolveCssVars(instance, vnode, expectedMap) {
   if (instance.getCssVars && (vnode === root || root && root.type === Fragment && root.children.includes(vnode))) {
     const cssVars = instance.getCssVars();
     for (const key in cssVars) {
-      expectedMap.set(
-        `--${getEscapedCssVarName(key, false)}`,
-        String(cssVars[key])
-      );
+      const value = normalizeCssVarValue(cssVars[key]);
+      expectedMap.set(`--${getEscapedCssVarName(key, false)}`, value);
     }
   }
   if (vnode === root && instance.parent) {
-    resolveCssVars(instance.parent, instance.vnode, expectedMap);
+    resolveCssVars(
+      instance.parent,
+      instance.vnode,
+      expectedMap
+    );
   }
 }
 const allowMismatchAttr = "data-allow-mismatch";
@@ -2278,7 +2353,7 @@ function isMismatchAllowed(el, allowedType) {
     if (allowedType === 0 /* TEXT */ && list.includes("children")) {
       return true;
     }
-    return allowedAttr.split(",").includes(MismatchTypeString[allowedType]);
+    return list.includes(MismatchTypeString[allowedType]);
   }
 }
 
@@ -2510,7 +2585,7 @@ function defineAsyncComponent(source) {
       }
       load().then(() => {
         loaded.value = true;
-        if (instance.parent && isKeepAlive(instance.parent.vnode)) {
+        if (instance.parent && instance.parent.vnode && isKeepAlive(instance.parent.vnode)) {
           instance.parent.update();
         }
       }).catch((err) => {
@@ -2553,8 +2628,8 @@ const KeepAliveImpl = {
     max: [String, Number]
   },
   setup(props, { slots }) {
-    const instance = getCurrentInstance();
-    const sharedContext = instance.ctx;
+    const keepAliveInstance = getCurrentInstance();
+    const sharedContext = keepAliveInstance.ctx;
     if (!sharedContext.renderer) {
       return () => {
         const children = slots.default && slots.default();
@@ -2565,9 +2640,9 @@ const KeepAliveImpl = {
     const keys = /* @__PURE__ */ new Set();
     let current = null;
     if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
-      instance.__v_cache = cache;
+      keepAliveInstance.__v_cache = cache;
     }
-    const parentSuspense = instance.suspense;
+    const parentSuspense = keepAliveInstance.suspense;
     const {
       renderer: {
         p: patch,
@@ -2578,58 +2653,80 @@ const KeepAliveImpl = {
     } = sharedContext;
     const storageContainer = createElement("div");
     sharedContext.activate = (vnode, container, anchor, namespace, optimized) => {
-      const instance2 = vnode.component;
-      move(vnode, container, anchor, 0, parentSuspense);
+      const instance = vnode.component;
+      move(
+        vnode,
+        container,
+        anchor,
+        0,
+        keepAliveInstance,
+        parentSuspense
+      );
       patch(
-        instance2.vnode,
+        instance.vnode,
         vnode,
         container,
         anchor,
-        instance2,
+        instance,
         parentSuspense,
         namespace,
         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);
+      queuePostRenderEffect(
+        () => {
+          instance.isDeactivated = false;
+          if (instance.a) {
+            invokeArrayFns(instance.a);
+          }
+          const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
+          if (vnodeHook) {
+            invokeVNodeHook(vnodeHook, instance.parent, vnode);
+          }
+        },
+        void 0,
+        parentSuspense
+      );
       if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
-        devtoolsComponentAdded(instance2);
+        devtoolsComponentAdded(instance);
       }
     };
     sharedContext.deactivate = (vnode) => {
-      const instance2 = vnode.component;
-      invalidateMount(instance2.m);
-      invalidateMount(instance2.a);
-      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);
+      const instance = vnode.component;
+      invalidateMount(instance.m);
+      invalidateMount(instance.a);
+      move(
+        vnode,
+        storageContainer,
+        null,
+        1,
+        keepAliveInstance,
+        parentSuspense
+      );
+      queuePostRenderEffect(
+        () => {
+          if (instance.da) {
+            invokeArrayFns(instance.da);
+          }
+          const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
+          if (vnodeHook) {
+            invokeVNodeHook(vnodeHook, instance.parent, vnode);
+          }
+          instance.isDeactivated = true;
+        },
+        void 0,
+        parentSuspense
+      );
       if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
-        devtoolsComponentAdded(instance2);
+        devtoolsComponentAdded(instance);
       }
       if (!!(process.env.NODE_ENV !== "production") && true) {
-        instance2.__keepAliveStorageContainer = storageContainer;
+        instance.__keepAliveStorageContainer = storageContainer;
       }
     };
     function unmount(vnode) {
       resetShapeFlag(vnode);
-      _unmount(vnode, instance, parentSuspense, true);
+      _unmount(vnode, keepAliveInstance, parentSuspense, true);
     }
     function pruneCache(filter) {
       cache.forEach((vnode, key) => {
@@ -2661,12 +2758,19 @@ const KeepAliveImpl = {
     let pendingCacheKey = null;
     const cacheSubtree = () => {
       if (pendingCacheKey != null) {
-        if (isSuspense(instance.subTree.type)) {
-          queuePostRenderEffect(() => {
-            cache.set(pendingCacheKey, getInnerChild(instance.subTree));
-          }, instance.subTree.suspense);
+        if (isSuspense(keepAliveInstance.subTree.type)) {
+          queuePostRenderEffect(
+            () => {
+              cache.set(
+                pendingCacheKey,
+                getInnerChild(keepAliveInstance.subTree)
+              );
+            },
+            void 0,
+            keepAliveInstance.subTree.suspense
+          );
         } else {
-          cache.set(pendingCacheKey, getInnerChild(instance.subTree));
+          cache.set(pendingCacheKey, getInnerChild(keepAliveInstance.subTree));
         }
       }
     };
@@ -2674,12 +2778,12 @@ const KeepAliveImpl = {
     onUpdated(cacheSubtree);
     onBeforeUnmount(() => {
       cache.forEach((cached) => {
-        const { subTree, suspense } = instance;
+        const { subTree, suspense } = keepAliveInstance;
         const vnode = getInnerChild(subTree);
         if (cached.type === vnode.type && cached.key === vnode.key) {
           resetShapeFlag(vnode);
           const da = vnode.component.da;
-          da && queuePostRenderEffect(da, suspense);
+          da && queuePostRenderEffect(da, void 0, suspense);
           return;
         }
         unmount(cached);
@@ -2765,7 +2869,7 @@ function onActivated(hook, target) {
 function onDeactivated(hook, target) {
   registerKeepAliveHook(hook, "da", target);
 }
-function registerKeepAliveHook(hook, type, target = currentInstance) {
+function registerKeepAliveHook(hook, type, target = getCurrentInstance()) {
   const wrappedHook = hook.__wdc || (hook.__wdc = () => {
     let current = target;
     while (current) {
@@ -2779,7 +2883,7 @@ function registerKeepAliveHook(hook, type, target = currentInstance) {
   injectHook(type, wrappedHook, target);
   if (target) {
     let current = target.parent;
-    while (current && current.parent) {
+    while (current && current.parent && current.parent.vnode) {
       if (isKeepAlive(current.parent.vnode)) {
         injectToKeepAliveRoot(wrappedHook, type, target, current);
       }
@@ -2811,12 +2915,14 @@ function injectHook(type, hook, target = currentInstance, prepend = false) {
   if (target) {
     const hooks = target[type] || (target[type] = []);
     const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
-      pauseTracking();
-      const reset = setCurrentInstance(target);
-      const res = callWithAsyncErrorHandling(hook, target, type, args);
-      reset();
-      resetTracking();
-      return res;
+      const prevSub = setActiveSub();
+      const prev = setCurrentInstance(target);
+      try {
+        return callWithAsyncErrorHandling(hook, target, type, args);
+      } finally {
+        setCurrentInstance(...prev);
+        setActiveSub(prevSub);
+      }
     });
     if (prepend) {
       hooks.unshift(wrappedHook);
@@ -2887,7 +2993,11 @@ function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false
     const res = (
       // local registration
       // check instance[type] first which is resolved for options API
-      resolve(instance[type] || Component[type], name) || // global registration
+      resolve(
+        instance[type] || Component[type],
+        name
+      ) || // global registration
+      // @ts-expect-error filters only exist in compat mode
       resolve(instance.appContext[type], name)
     );
     if (!res && maybeSelfReference) {
@@ -2981,7 +3091,13 @@ function createSlots(slots, dynamicSlots) {
 }
 
 function renderSlot(slots, name, props = {}, fallback, noSlotted) {
-  if (currentRenderingInstance.ce || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.ce) {
+  let slot = slots[name];
+  if (slot && slot.__vapor) {
+    const ret = (openBlock(), createBlock(VaporSlot, props));
+    ret.vs = { slot, fallback };
+    return ret;
+  }
+  if (currentRenderingInstance && (currentRenderingInstance.ce || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.ce)) {
     if (name !== "default") props.name = name;
     return openBlock(), createBlock(
       Fragment,
@@ -2990,7 +3106,6 @@ function renderSlot(slots, name, props = {}, fallback, noSlotted) {
       64
     );
   }
-  let slot = slots[name];
   if (!!(process.env.NODE_ENV !== "production") && slot && slot.length > 1) {
     warn$1(
       `SSR-optimized slot function detected in a non-SSR-optimized render function. You need to mark this component with $dynamic-slots in the parent template.`
@@ -3045,8 +3160,9 @@ function toHandlers(obj, preserveCaseIfNecessary) {
 }
 
 const getPublicInstance = (i) => {
-  if (!i) return null;
-  if (isStatefulComponent(i)) return getComponentPublicInstance(i);
+  if (!i || i.vapor) return null;
+  if (isStatefulComponent(i))
+    return getComponentPublicInstance(i);
   return getPublicInstance(i.parent);
 };
 const publicPropertiesMap = (
@@ -3339,11 +3455,16 @@ function useAttrs() {
   return getContext().attrs;
 }
 function getContext() {
-  const i = getCurrentInstance();
+  const i = getCurrentGenericInstance();
   if (!!(process.env.NODE_ENV !== "production") && !i) {
     warn$1(`useContext() called without active instance.`);
   }
-  return i.setupContext || (i.setupContext = createSetupContext(i));
+  if (i.vapor) {
+    return i;
+  } else {
+    const ii = i;
+    return ii.setupContext || (ii.setupContext = createSetupContext(ii));
+  }
 }
 function normalizePropsOrEmits(props) {
   return isArray(props) ? props.reduce(
@@ -3391,14 +3512,14 @@ function createPropsRestProxy(props, excludedKeys) {
   return ret;
 }
 function withAsyncContext(getAwaitable) {
-  const ctx = getCurrentInstance();
+  const ctx = getCurrentGenericInstance();
   if (!!(process.env.NODE_ENV !== "production") && !ctx) {
     warn$1(
       `withAsyncContext called without active current instance. This is likely a bug.`
     );
   }
   let awaitable = getAwaitable();
-  unsetCurrentInstance();
+  setCurrentInstance(null, void 0);
   if (isPromise(awaitable)) {
     awaitable = awaitable.catch((e) => {
       setCurrentInstance(ctx);
@@ -3847,7 +3968,7 @@ function createAppContext() {
   };
 }
 let uid$1 = 0;
-function createAppAPI(render, hydrate) {
+function createAppAPI(mount, unmount, getPublicInstance, render) {
   return function createApp(rootComponent, rootProps = null) {
     if (!isFunction(rootComponent)) {
       rootComponent = extend({}, rootComponent);
@@ -3942,33 +4063,15 @@ function createAppAPI(render, hydrate) {
  If you want to mount another app on the same host container, you need to unmount the previous app by calling \`app.unmount()\` first.`
             );
           }
-          const vnode = app._ceVNode || createVNode(rootComponent, rootProps);
-          vnode.appContext = context;
-          if (namespace === true) {
-            namespace = "svg";
-          } else if (namespace === false) {
-            namespace = void 0;
-          }
-          if (!!(process.env.NODE_ENV !== "production")) {
-            context.reload = () => {
-              const cloned = cloneVNode(vnode);
-              cloned.el = null;
-              render(cloned, rootContainer, namespace);
-            };
-          }
-          if (isHydrate && hydrate) {
-            hydrate(vnode, rootContainer);
-          } else {
-            render(vnode, rootContainer, namespace);
+          const instance = mount(app, rootContainer, isHydrate, namespace);
+          if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
+            app._instance = instance;
+            devtoolsInitApp(app, version);
           }
           isMounted = true;
           app._container = rootContainer;
           rootContainer.__vue_app__ = app;
-          if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
-            app._instance = vnode.component;
-            devtoolsInitApp(app, version);
-          }
-          return getComponentPublicInstance(vnode.component);
+          return getPublicInstance(instance);
         } else if (!!(process.env.NODE_ENV !== "production")) {
           warn$1(
             `App has already been mounted.
@@ -3991,7 +4094,7 @@ If you want to remount the same app, move your app creation logic into a factory
             app._instance,
             16
           );
-          render(null, app._container);
+          unmount(app);
           if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
             app._instance = null;
             devtoolsUnmountApp(app);
@@ -4032,6 +4135,7 @@ If you want to remount the same app, move your app creation logic into a factory
 let currentApp = null;
 
 function provide(key, value) {
+  const currentInstance = getCurrentGenericInstance();
   if (!currentInstance) {
     if (!!(process.env.NODE_ENV !== "production")) {
       warn$1(`provide() can only be used inside setup().`);
@@ -4046,9 +4150,9 @@ function provide(key, value) {
   }
 }
 function inject(key, defaultValue, treatDefaultAsFactory = false) {
-  const instance = currentInstance || currentRenderingInstance;
+  const instance = getCurrentGenericInstance();
   if (instance || currentApp) {
-    let provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null || instance.ce ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
+    let provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null || instance.ce ? instance.appContext && instance.appContext.provides : instance.parent.provides : void 0;
     if (provides && key in provides) {
       return provides[key];
     } else if (arguments.length > 1) {
@@ -4061,7 +4165,7 @@ function inject(key, defaultValue, treatDefaultAsFactory = false) {
   }
 }
 function hasInjectionContext() {
-  return !!(currentInstance || currentRenderingInstance || currentApp);
+  return !!(getCurrentGenericInstance() || currentApp);
 }
 
 const internalObjectProto = {};
@@ -4069,7 +4173,7 @@ const createInternalObject = () => Object.create(internalObjectProto);
 const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;
 
 function initProps(instance, rawProps, isStateful, isSSR = false) {
-  const props = {};
+  const props = instance.props = {};
   const attrs = createInternalObject();
   instance.propsDefaults = /* @__PURE__ */ Object.create(null);
   setFullProps(instance, rawProps, props, attrs);
@@ -4079,7 +4183,7 @@ function initProps(instance, rawProps, isStateful, isSSR = false) {
     }
   }
   if (!!(process.env.NODE_ENV !== "production")) {
-    validateProps(rawProps || {}, props, instance);
+    validateProps(rawProps || {}, props, instance.propsOptions[0]);
   }
   if (isStateful) {
     instance.props = isSSR ? props : shallowReactive(props);
@@ -4131,11 +4235,10 @@ function updateProps(instance, rawProps, rawPrevProps, optimized) {
             const camelizedKey = camelize(key);
             props[camelizedKey] = resolvePropValue(
               options,
-              rawCurrentProps,
               camelizedKey,
               value,
               instance,
-              false
+              baseResolveDefault
             );
           }
         } else {
@@ -4162,10 +4265,10 @@ function updateProps(instance, rawProps, rawPrevProps, optimized) {
           rawPrevProps[kebabKey] !== void 0)) {
             props[key] = resolvePropValue(
               options,
-              rawCurrentProps,
               key,
               void 0,
               instance,
+              baseResolveDefault,
               true
             );
           }
@@ -4187,7 +4290,7 @@ function updateProps(instance, rawProps, rawPrevProps, optimized) {
     trigger(instance.attrs, "set", "");
   }
   if (!!(process.env.NODE_ENV !== "production")) {
-    validateProps(rawProps || {}, props, instance);
+    validateProps(rawProps || {}, props, instance.propsOptions[0]);
   }
 }
 function setFullProps(instance, rawProps, props, attrs) {
@@ -4216,39 +4319,37 @@ function setFullProps(instance, rawProps, props, attrs) {
     }
   }
   if (needCastKeys) {
-    const rawCurrentProps = toRaw(props);
     const castValues = rawCastValues || EMPTY_OBJ;
     for (let i = 0; i < needCastKeys.length; i++) {
       const key = needCastKeys[i];
       props[key] = resolvePropValue(
         options,
-        rawCurrentProps,
         key,
         castValues[key],
         instance,
+        baseResolveDefault,
         !hasOwn(castValues, key)
       );
     }
   }
   return hasAttrsChanged;
 }
-function resolvePropValue(options, props, key, value, instance, isAbsent) {
+function resolvePropValue(options, key, value, instance, resolveDefault, isAbsent = false) {
   const opt = options[key];
   if (opt != null) {
     const hasDefault = hasOwn(opt, "default");
     if (hasDefault && value === void 0) {
       const defaultValue = opt.default;
       if (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) {
-        const { propsDefaults } = instance;
-        if (key in propsDefaults) {
-          value = propsDefaults[key];
+        const cachedDefaults = instance.propsDefaults || (instance.propsDefaults = {});
+        if (hasOwn(cachedDefaults, key)) {
+          value = cachedDefaults[key];
         } else {
-          const reset = setCurrentInstance(instance);
-          value = propsDefaults[key] = defaultValue.call(
-            null,
-            props
+          value = cachedDefaults[key] = resolveDefault(
+            defaultValue,
+            instance,
+            key
           );
-          reset();
         }
       } else {
         value = defaultValue;
@@ -4267,6 +4368,17 @@ function resolvePropValue(options, props, key, value, instance, isAbsent) {
   }
   return value;
 }
+function baseResolveDefault(factory, instance, key) {
+  let value;
+  const prev = setCurrentInstance(instance);
+  const props = toRaw(instance.props);
+  value = factory.call(
+    null,
+    props
+  );
+  setCurrentInstance(...prev);
+  return value;
+}
 const mixinPropsCache = /* @__PURE__ */ new WeakMap();
 function normalizePropsOptions(comp, appContext, asMixin = false) {
   const cache = __VUE_OPTIONS_API__ && asMixin ? mixinPropsCache : appContext.propsCache;
@@ -4301,6 +4413,14 @@ function normalizePropsOptions(comp, appContext, asMixin = false) {
     }
     return EMPTY_ARR;
   }
+  baseNormalizePropsOptions(raw, normalized, needCastKeys);
+  const res = [normalized, needCastKeys];
+  if (isObject(comp)) {
+    cache.set(comp, res);
+  }
+  return res;
+}
+function baseNormalizePropsOptions(raw, normalized, needCastKeys) {
   if (isArray(raw)) {
     for (let i = 0; i < raw.length; i++) {
       if (!!(process.env.NODE_ENV !== "production") && !isString(raw[i])) {
@@ -4345,11 +4465,6 @@ function normalizePropsOptions(comp, appContext, asMixin = false) {
       }
     }
   }
-  const res = [normalized, needCastKeys];
-  if (isObject(comp)) {
-    cache.set(comp, res);
-  }
-  return res;
 }
 function validatePropName(key) {
   if (key[0] !== "$" && !isReservedProp(key)) {
@@ -4371,26 +4486,26 @@ function getType(ctor) {
   }
   return "";
 }
-function validateProps(rawProps, props, instance) {
-  const resolvedValues = toRaw(props);
-  const options = instance.propsOptions[0];
+function validateProps(rawProps, resolvedProps, options) {
+  resolvedProps = toRaw(resolvedProps);
   const camelizePropsKey = Object.keys(rawProps).map((key) => camelize(key));
   for (const key in options) {
-    let opt = options[key];
-    if (opt == null) continue;
-    validateProp(
-      key,
-      resolvedValues[key],
-      opt,
-      !!(process.env.NODE_ENV !== "production") ? shallowReadonly(resolvedValues) : resolvedValues,
-      !camelizePropsKey.includes(key)
-    );
+    const opt = options[key];
+    if (opt != null) {
+      validateProp(
+        key,
+        resolvedProps[key],
+        opt,
+        resolvedProps,
+        !camelizePropsKey.includes(key)
+      );
+    }
   }
 }
-function validateProp(name, value, prop, props, isAbsent) {
-  const { type, required, validator, skipCheck } = prop;
+function validateProp(key, value, propOptions, resolvedProps, isAbsent) {
+  const { type, required, validator, skipCheck } = propOptions;
   if (required && isAbsent) {
-    warn$1('Missing required prop: "' + name + '"');
+    warn$1('Missing required prop: "' + key + '"');
     return;
   }
   if (value == null && !required) {
@@ -4406,12 +4521,12 @@ function validateProp(name, value, prop, props, isAbsent) {
       isValid = valid;
     }
     if (!isValid) {
-      warn$1(getInvalidTypeMessage(name, value, expectedTypes));
+      warn$1(getInvalidTypeMessage(key, value, expectedTypes));
       return;
     }
   }
-  if (validator && !validator(value, props)) {
-    warn$1('Invalid prop: custom validator check failed for prop "' + name + '".');
+  if (validator && !validator(value, !!(process.env.NODE_ENV !== "production") ? shallowReadonly(resolvedProps) : resolvedProps)) {
+    warn$1('Invalid prop: custom validator check failed for prop "' + key + '".');
   }
 }
 const isSimpleType = /* @__PURE__ */ makeMap(
@@ -4482,7 +4597,7 @@ const normalizeSlot = (key, rawSlot, ctx) => {
     return rawSlot;
   }
   const normalized = withCtx((...args) => {
-    if (!!(process.env.NODE_ENV !== "production") && currentInstance && !(ctx === null && currentRenderingInstance) && !(ctx && ctx.root !== currentInstance.root)) {
+    if (!!(process.env.NODE_ENV !== "production") && currentInstance && !currentInstance.vapor && !(ctx === null && currentRenderingInstance) && !(ctx && ctx.root !== currentInstance.root)) {
       warn$1(
         `Slot "${key}" invoked outside of the render function: this will not track dependencies used in the slot. Invoke the slot function inside the render function instead.`
       );
@@ -4529,6 +4644,8 @@ const assignSlots = (slots, children, optimized) => {
 const initSlots = (instance, children, optimized) => {
   const slots = instance.slots = createInternalObject();
   if (instance.vnode.shapeFlag & 32) {
+    const cacheIndexes = children.__;
+    if (cacheIndexes) def(slots, "__", cacheIndexes, true);
     const type = children._;
     if (type) {
       assignSlots(slots, children, optimized);
@@ -4577,12 +4694,15 @@ const updateSlots = (instance, children, optimized) => {
 
 let supported;
 let perf;
+let cachedNow = 0;
+const p = /* @__PURE__ */ Promise.resolve();
+const getNow = () => cachedNow || (p.then(() => cachedNow = 0), cachedNow = isSupported() ? perf.now() : Date.now());
 function startMeasure(instance, type) {
   if (instance.appContext.config.performance && isSupported()) {
     perf.mark(`vue-${type}-${instance.uid}`);
   }
   if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
-    devtoolsPerfStart(instance, type, isSupported() ? perf.now() : Date.now());
+    devtoolsPerfStart(instance, type, getNow());
   }
 }
 function endMeasure(instance, type) {
@@ -4599,7 +4719,7 @@ function endMeasure(instance, type) {
     perf.clearMarks(endTag);
   }
   if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
-    devtoolsPerfEnd(instance, type, isSupported() ? perf.now() : Date.now());
+    devtoolsPerfEnd(instance, type, getNow());
   }
 }
 function isSupported() {
@@ -4615,7 +4735,9 @@ function isSupported() {
   return supported;
 }
 
+let initialized = false;
 function initFeatureFlags() {
+  if (initialized) return;
   const needWarn = [];
   if (typeof __VUE_OPTIONS_API__ !== "boolean") {
     !!(process.env.NODE_ENV !== "production") && needWarn.push(`__VUE_OPTIONS_API__`);
@@ -4637,8 +4759,17 @@ function initFeatureFlags() {
 For more details, see https://link.vuejs.org/feature-flags.`
     );
   }
+  initialized = true;
 }
 
+const MoveType = {
+  "ENTER": 0,
+  "0": "ENTER",
+  "LEAVE": 1,
+  "1": "LEAVE",
+  "REORDER": 2,
+  "2": "REORDER"
+};
 const queuePostRenderEffect = queueEffectWithSuspense ;
 function createRenderer(options) {
   return baseCreateRenderer(options);
@@ -4710,6 +4841,9 @@ function baseCreateRenderer(options, createHydrationFns) {
           optimized
         );
         break;
+      case VaporSlot:
+        getVaporInterface(parentComponent, n2).slot(n1, n2, container, anchor);
+        break;
       default:
         if (shapeFlag & 1) {
           processElement(
@@ -4767,6 +4901,8 @@ function baseCreateRenderer(options, createHydrationFns) {
     }
     if (ref != null && parentComponent) {
       setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
+    } else if (ref == null && n1 && n1.ref != null) {
+      setRef(n1.ref, null, parentSuspense, n1, true);
     }
   };
   const processText = (n1, n2, container, anchor) => {
@@ -4920,11 +5056,15 @@ function baseCreateRenderer(options, createHydrationFns) {
     }
     hostInsert(el, container, anchor);
     if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {
-      queuePostRenderEffect(() => {
-        vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
-        needCallTransitionHooks && transition.enter(el);
-        dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
-      }, parentSuspense);
+      queuePostRenderEffect(
+        () => {
+          vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
+          needCallTransitionHooks && transition.enter(el);
+          dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
+        },
+        void 0,
+        parentSuspense
+      );
     }
   };
   const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => {
@@ -4936,8 +5076,8 @@ function baseCreateRenderer(options, createHydrationFns) {
         hostSetScopeId(el, slotScopeIds[i]);
       }
     }
-    if (parentComponent) {
-      let subTree = parentComponent.subTree;
+    let subTree = parentComponent && parentComponent.subTree;
+    if (subTree) {
       if (!!(process.env.NODE_ENV !== "production") && subTree.patchFlag > 0 && subTree.patchFlag & 2048) {
         subTree = filterSingleRoot(subTree.children) || subTree;
       }
@@ -5054,10 +5194,14 @@ function baseCreateRenderer(options, createHydrationFns) {
       patchProps(el, oldProps, newProps, parentComponent, namespace);
     }
     if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {
-      queuePostRenderEffect(() => {
-        vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
-        dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated");
-      }, parentSuspense);
+      queuePostRenderEffect(
+        () => {
+          vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
+          dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated");
+        },
+        void 0,
+        parentSuspense
+      );
     }
   };
   const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, namespace, slotScopeIds) => {
@@ -5196,7 +5340,22 @@ function baseCreateRenderer(options, createHydrationFns) {
   };
   const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
     n2.slotScopeIds = slotScopeIds;
-    if (n1 == null) {
+    if (n2.type.__vapor) {
+      if (n1 == null) {
+        getVaporInterface(parentComponent, n2).mount(
+          n2,
+          container,
+          anchor,
+          parentComponent
+        );
+      } else {
+        getVaporInterface(parentComponent, n2).update(
+          n1,
+          n2,
+          shouldUpdateComponent(n1, n2, optimized)
+        );
+      }
+    } else if (n1 == null) {
       if (n2.shapeFlag & 512) {
         parentComponent.ctx.activate(
           n2,
@@ -5282,15 +5441,52 @@ function baseCreateRenderer(options, createHydrationFns) {
         return;
       } else {
         instance.next = n2;
-        instance.update();
+        instance.effect.run();
       }
     } else {
       n2.el = n1.el;
       instance.vnode = n2;
     }
   };
-  const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, namespace, optimized) => {
-    const componentUpdateFn = () => {
+  class SetupRenderEffect extends ReactiveEffect {
+    constructor(instance, initialVNode, container, anchor, parentSuspense, namespace, optimized) {
+      const prevScope = setCurrentScope(instance.scope);
+      super();
+      this.instance = instance;
+      this.initialVNode = initialVNode;
+      this.container = container;
+      this.anchor = anchor;
+      this.parentSuspense = parentSuspense;
+      this.namespace = namespace;
+      this.optimized = optimized;
+      setCurrentScope(prevScope);
+      this.job = instance.job = () => {
+        if (this.dirty) {
+          this.run();
+        }
+      };
+      this.job.i = instance;
+      if (!!(process.env.NODE_ENV !== "production")) {
+        this.onTrack = instance.rtc ? (e) => invokeArrayFns(instance.rtc, e) : void 0;
+        this.onTrigger = instance.rtg ? (e) => invokeArrayFns(instance.rtg, e) : void 0;
+      }
+    }
+    notify() {
+      if (!(this.flags & 256)) {
+        const job = this.job;
+        queueJob(job, job.i.uid);
+      }
+    }
+    fn() {
+      const {
+        instance,
+        initialVNode,
+        container,
+        anchor,
+        parentSuspense,
+        namespace,
+        optimized
+      } = this;
       if (!instance.isMounted) {
         let vnodeHook;
         const { el, props } = initialVNode;
@@ -5337,7 +5533,8 @@ function baseCreateRenderer(options, createHydrationFns) {
             hydrateSubTree();
           }
         } else {
-          if (root.ce) {
+          if (root.ce && // @ts-expect-error _def is private
+          root.ce._def.shadowRoot !== false) {
             root.ce._injectChildStyle(type);
           }
           if (!!(process.env.NODE_ENV !== "production")) {
@@ -5365,23 +5562,24 @@ function baseCreateRenderer(options, createHydrationFns) {
           initialVNode.el = subTree.el;
         }
         if (m) {
-          queuePostRenderEffect(m, parentSuspense);
+          queuePostRenderEffect(m, void 0, parentSuspense);
         }
         if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeMounted)) {
           const scopedInitialVNode = initialVNode;
           queuePostRenderEffect(
             () => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode),
+            void 0,
             parentSuspense
           );
         }
-        if (initialVNode.shapeFlag & 256 || parent && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) {
-          instance.a && queuePostRenderEffect(instance.a, parentSuspense);
+        if (initialVNode.shapeFlag & 256 || parent && parent.vnode && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) {
+          instance.a && queuePostRenderEffect(instance.a, void 0, parentSuspense);
         }
         instance.isMounted = true;
         if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
           devtoolsComponentAdded(instance);
         }
-        initialVNode = container = anchor = null;
+        this.initialVNode = this.container = this.anchor = null;
       } else {
         let { next, bu, u, parent, vnode } = instance;
         {
@@ -5393,7 +5591,7 @@ function baseCreateRenderer(options, createHydrationFns) {
             }
             nonHydratedAsyncRoot.asyncDep.then(() => {
               if (!instance.isUnmounted) {
-                componentUpdateFn();
+                this.fn();
               }
             });
             return;
@@ -5449,11 +5647,12 @@ function baseCreateRenderer(options, createHydrationFns) {
           updateHOCHostEl(instance, nextTree.el);
         }
         if (u) {
-          queuePostRenderEffect(u, parentSuspense);
+          queuePostRenderEffect(u, void 0, parentSuspense);
         }
         if (vnodeHook = next.props && next.props.onVnodeUpdated) {
           queuePostRenderEffect(
             () => invokeVNodeHook(vnodeHook, parent, next, vnode),
+            void 0,
             parentSuspense
           );
         }
@@ -5464,21 +5663,21 @@ function baseCreateRenderer(options, createHydrationFns) {
           popWarningContext();
         }
       }
-    };
-    instance.scope.on();
-    const effect = instance.effect = new ReactiveEffect(componentUpdateFn);
-    instance.scope.off();
-    const update = instance.update = effect.run.bind(effect);
-    const job = instance.job = effect.runIfDirty.bind(effect);
-    job.i = instance;
-    job.id = instance.uid;
-    effect.scheduler = () => queueJob(job);
-    toggleRecurse(instance, true);
-    if (!!(process.env.NODE_ENV !== "production")) {
-      effect.onTrack = instance.rtc ? (e) => invokeArrayFns(instance.rtc, e) : void 0;
-      effect.onTrigger = instance.rtg ? (e) => invokeArrayFns(instance.rtg, e) : void 0;
     }
-    update();
+  }
+  const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, namespace, optimized) => {
+    const effect = instance.effect = new SetupRenderEffect(
+      instance,
+      initialVNode,
+      container,
+      anchor,
+      parentSuspense,
+      namespace,
+      optimized
+    );
+    instance.update = effect.run.bind(effect);
+    toggleRecurse(instance, true);
+    effect.run();
   };
   const updateComponentPreRender = (instance, nextVNode, optimized) => {
     nextVNode.component = instance;
@@ -5487,9 +5686,9 @@ function baseCreateRenderer(options, createHydrationFns) {
     instance.next = null;
     updateProps(instance, nextVNode.props, prevProps, optimized);
     updateSlots(instance, nextVNode.children, optimized);
-    pauseTracking();
+    const prevSub = setActiveSub();
     flushPreFlushCbs(instance);
-    resetTracking();
+    setActiveSub(prevSub);
   };
   const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized = false) => {
     const c1 = n1 && n1.children;
@@ -5766,7 +5965,13 @@ function baseCreateRenderer(options, createHydrationFns) {
           );
         } else if (moved) {
           if (j < 0 || i !== increasingNewIndexSequence[j]) {
-            move(nextChild, container, anchor, 2);
+            move(
+              nextChild,
+              container,
+              anchor,
+              2,
+              parentComponent
+            );
           } else {
             j--;
           }
@@ -5774,10 +5979,20 @@ function baseCreateRenderer(options, createHydrationFns) {
       }
     }
   };
-  const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
+  const move = (vnode, container, anchor, moveType, parentComponent, parentSuspense = null) => {
     const { el, type, transition, children, shapeFlag } = vnode;
     if (shapeFlag & 6) {
-      move(vnode.component.subTree, container, anchor, moveType);
+      if (type.__vapor) {
+        getVaporInterface(parentComponent, vnode).move(vnode, container, anchor);
+      } else {
+        move(
+          vnode.component.subTree,
+          container,
+          anchor,
+          moveType,
+          parentComponent
+        );
+      }
       return;
     }
     if (shapeFlag & 128) {
@@ -5785,13 +6000,25 @@ function baseCreateRenderer(options, createHydrationFns) {
       return;
     }
     if (shapeFlag & 64) {
-      type.move(vnode, container, anchor, internals);
+      type.move(
+        vnode,
+        container,
+        anchor,
+        internals,
+        parentComponent
+      );
       return;
     }
     if (type === Fragment) {
       hostInsert(el, container, anchor);
       for (let i = 0; i < children.length; i++) {
-        move(children[i], container, anchor, moveType);
+        move(
+          children[i],
+          container,
+          anchor,
+          moveType,
+          parentComponent
+        );
       }
       hostInsert(vnode.anchor, container, anchor);
       return;
@@ -5805,7 +6032,11 @@ function baseCreateRenderer(options, createHydrationFns) {
       if (moveType === 0) {
         transition.beforeEnter(el);
         hostInsert(el, container, anchor);
-        queuePostRenderEffect(() => transition.enter(el), parentSuspense);
+        queuePostRenderEffect(
+          () => transition.enter(el),
+          void 0,
+          parentSuspense
+        );
       } else {
         const { leave, delayLeave, afterLeave } = transition;
         const remove2 = () => {
@@ -5847,9 +6078,9 @@ function baseCreateRenderer(options, createHydrationFns) {
       optimized = false;
     }
     if (ref != null) {
-      pauseTracking();
+      const prevSub = setActiveSub();
       setRef(ref, null, parentSuspense, vnode, true);
-      resetTracking();
+      setActiveSub(prevSub);
     }
     if (cacheIndex != null) {
       parentComponent.renderCache[cacheIndex] = void 0;
@@ -5865,7 +6096,12 @@ function baseCreateRenderer(options, createHydrationFns) {
       invokeVNodeHook(vnodeHook, parentComponent, vnode);
     }
     if (shapeFlag & 6) {
-      unmountComponent(vnode.component, parentSuspense, doRemove);
+      if (type.__vapor) {
+        getVaporInterface(parentComponent, vnode).unmount(vnode, doRemove);
+        return;
+      } else {
+        unmountComponent(vnode.component, parentSuspense, doRemove);
+      }
     } else {
       if (shapeFlag & 128) {
         vnode.suspense.unmount(parentSuspense, doRemove);
@@ -5899,15 +6135,23 @@ function baseCreateRenderer(options, createHydrationFns) {
       } else if (type === Fragment && patchFlag & (128 | 256) || !optimized && shapeFlag & 16) {
         unmountChildren(children, parentComponent, parentSuspense);
       }
+      if (type === VaporSlot) {
+        getVaporInterface(parentComponent, vnode).unmount(vnode, doRemove);
+        return;
+      }
       if (doRemove) {
         remove(vnode);
       }
     }
     if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {
-      queuePostRenderEffect(() => {
-        vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
-        shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");
-      }, parentSuspense);
+      queuePostRenderEffect(
+        () => {
+          vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
+          shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");
+        },
+        void 0,
+        parentSuspense
+      );
     }
   };
   const remove = (vnode) => {
@@ -5964,7 +6208,7 @@ function baseCreateRenderer(options, createHydrationFns) {
     const {
       bum,
       scope,
-      job,
+      effect,
       subTree,
       um,
       m,
@@ -5983,16 +6227,18 @@ function baseCreateRenderer(options, createHydrationFns) {
       });
     }
     scope.stop();
-    if (job) {
-      job.flags |= 8;
+    if (effect) {
+      effect.stop();
       unmount(subTree, instance, parentSuspense, doRemove);
     }
     if (um) {
-      queuePostRenderEffect(um, parentSuspense);
+      queuePostRenderEffect(um, void 0, parentSuspense);
     }
-    queuePostRenderEffect(() => {
-      instance.isUnmounted = true;
-    }, parentSuspense);
+    queuePostRenderEffect(
+      () => instance.isUnmounted = true,
+      void 0,
+      parentSuspense
+    );
     if (parentSuspense && parentSuspense.pendingBranch && !parentSuspense.isUnmounted && instance.asyncDep && !instance.asyncResolved && instance.suspenseId === parentSuspense.pendingId) {
       parentSuspense.deps--;
       if (parentSuspense.deps === 0) {
@@ -6010,6 +6256,9 @@ function baseCreateRenderer(options, createHydrationFns) {
   };
   const getNextHostNode = (vnode) => {
     if (vnode.shapeFlag & 6) {
+      if (vnode.type.__vapor) {
+        return hostNextSibling(vnode.component.block);
+      }
       return getNextHostNode(vnode.component.subTree);
     }
     if (vnode.shapeFlag & 128) {
@@ -6019,7 +6268,6 @@ function baseCreateRenderer(options, createHydrationFns) {
     const teleportEnd = el && el[TeleportEndKey];
     return teleportEnd ? hostNextSibling(teleportEnd) : el;
   };
-  let isFlushing = false;
   const render = (vnode, container, namespace) => {
     if (vnode == null) {
       if (container._vnode) {
@@ -6037,12 +6285,7 @@ function baseCreateRenderer(options, createHydrationFns) {
       );
     }
     container._vnode = vnode;
-    if (!isFlushing) {
-      isFlushing = true;
-      flushPreFlushCbs();
-      flushPostFlushCbs();
-      isFlushing = false;
-    }
+    flushOnAppMount();
   };
   const internals = {
     p: patch,
@@ -6050,6 +6293,7 @@ function baseCreateRenderer(options, createHydrationFns) {
     m: move,
     r: remove,
     mt: mountComponent,
+    umt: unmountComponent,
     mc: mountChildren,
     pc: patchChildren,
     pbc: patchBlockChildren,
@@ -6063,22 +6307,53 @@ function baseCreateRenderer(options, createHydrationFns) {
       internals
     );
   }
+  const mountApp = (app, container, isHydrate, namespace) => {
+    const vnode = app._ceVNode || createVNode(app._component, app._props);
+    vnode.appContext = app._context;
+    if (namespace === true) {
+      namespace = "svg";
+    } else if (namespace === false) {
+      namespace = void 0;
+    }
+    if (!!(process.env.NODE_ENV !== "production")) {
+      app._context.reload = () => {
+        const cloned = cloneVNode(vnode);
+        cloned.el = null;
+        render(cloned, container, namespace);
+      };
+    }
+    if (isHydrate && hydrate) {
+      hydrate(vnode, container);
+    } else {
+      render(vnode, container, namespace);
+    }
+    return vnode.component;
+  };
+  const unmountApp = (app) => {
+    render(null, app._container);
+  };
   return {
     render,
     hydrate,
-    createApp: createAppAPI(render, hydrate)
+    internals,
+    createApp: createAppAPI(
+      mountApp,
+      unmountApp,
+      getComponentPublicInstance)
   };
 }
 function resolveChildrenNamespace({ type, props }, currentNamespace) {
   return currentNamespace === "svg" && type === "foreignObject" || currentNamespace === "mathml" && type === "annotation-xml" && props && props.encoding && props.encoding.includes("html") ? void 0 : currentNamespace;
 }
-function toggleRecurse({ effect, job }, allowed) {
-  if (allowed) {
-    effect.flags |= 32;
-    job.flags |= 4;
-  } else {
-    effect.flags &= -33;
-    job.flags &= -5;
+function toggleRecurse({ effect, job, vapor }, allowed) {
+  if (!vapor) {
+    if (allowed) {
+      effect.flags |= 128;
+      job.flags |= 2;
+    } else {
+      effect.flags &= -129;
+      job.flags &= -3;
+    }
   }
 }
 function needTransition(parentSuspense, transition) {
@@ -6111,46 +6386,6 @@ function traverseStaticChildren(n1, n2, shallow = false) {
     }
   }
 }
-function getSequence(arr) {
-  const p = arr.slice();
-  const result = [0];
-  let i, j, u, v, c;
-  const len = arr.length;
-  for (i = 0; i < len; i++) {
-    const arrI = arr[i];
-    if (arrI !== 0) {
-      j = result[result.length - 1];
-      if (arr[j] < arrI) {
-        p[i] = j;
-        result.push(i);
-        continue;
-      }
-      u = 0;
-      v = result.length - 1;
-      while (u < v) {
-        c = u + v >> 1;
-        if (arr[result[c]] < arrI) {
-          u = c + 1;
-        } else {
-          v = c;
-        }
-      }
-      if (arrI < arr[result[u]]) {
-        if (u > 0) {
-          p[i] = result[u - 1];
-        }
-        result[u] = i;
-      }
-    }
-  }
-  u = result.length;
-  v = result[u - 1];
-  while (u-- > 0) {
-    result[u] = v;
-    v = p[v];
-  }
-  return result;
-}
 function locateNonHydratedAsyncRoot(instance) {
   const subComponent = instance.subTree.component;
   if (subComponent) {
@@ -6164,9 +6399,23 @@ function locateNonHydratedAsyncRoot(instance) {
 function invalidateMount(hooks) {
   if (hooks) {
     for (let i = 0; i < hooks.length; i++)
-      hooks[i].flags |= 8;
+      hooks[i].flags |= 4;
   }
 }
+function getVaporInterface(instance, vnode) {
+  const ctx = instance ? instance.appContext : vnode.appContext;
+  const res = ctx && ctx.vapor;
+  if (!!(process.env.NODE_ENV !== "production") && !res) {
+    warn$1(
+      `Vapor component found in vdom tree but vapor-in-vdom interop was not installed. Make sure to install it:
+\`\`\`
+import { vaporInteropPlugin } from 'vue'
+app.use(vaporInteropPlugin)
+\`\`\``
+    );
+  }
+  return res;
+}
 
 const ssrContextKey = Symbol.for("v-scx");
 const useSSRContext = () => {
@@ -6206,8 +6455,41 @@ function watch(source, cb, options) {
   }
   return doWatch(source, cb, options);
 }
+class RenderWatcherEffect extends WatcherEffect {
+  constructor(instance, source, cb, options, flush) {
+    super(source, cb, options);
+    this.flush = flush;
+    const job = () => {
+      if (this.dirty) {
+        this.run();
+      }
+    };
+    if (cb) {
+      this.flags |= 128;
+      job.flags |= 2;
+    }
+    if (instance) {
+      job.i = instance;
+    }
+    this.job = job;
+  }
+  notify() {
+    const flags = this.flags;
+    if (!(flags & 256)) {
+      const flush = this.flush;
+      const job = this.job;
+      if (flush === "post") {
+        queuePostRenderEffect(job, void 0, job.i ? job.i.suspense : null);
+      } else if (flush === "pre") {
+        queueJob(job, job.i ? job.i.uid : void 0, true);
+      } else {
+        job();
+      }
+    }
+  }
+}
 function doWatch(source, cb, options = EMPTY_OBJ) {
-  const { immediate, deep, flush, once } = options;
+  const { immediate, deep, flush = "pre", once } = options;
   if (!!(process.env.NODE_ENV !== "production") && !cb) {
     if (immediate !== void 0) {
       warn$1(
@@ -6244,42 +6526,32 @@ function doWatch(source, cb, options = EMPTY_OBJ) {
   }
   const instance = currentInstance;
   baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args);
-  let isPre = false;
-  if (flush === "post") {
-    baseWatchOptions.scheduler = (job) => {
-      queuePostRenderEffect(job, instance && instance.suspense);
-    };
-  } else if (flush !== "sync") {
-    isPre = true;
-    baseWatchOptions.scheduler = (job, isFirstRun) => {
-      if (isFirstRun) {
-        job();
-      } else {
-        queueJob(job);
-      }
-    };
+  const effect = new RenderWatcherEffect(
+    instance,
+    source,
+    cb,
+    baseWatchOptions,
+    flush
+  );
+  if (cb) {
+    effect.run(true);
+  } else if (flush === "post") {
+    queuePostRenderEffect(effect.job, void 0, instance && instance.suspense);
+  } else {
+    effect.run(true);
   }
-  baseWatchOptions.augmentJob = (job) => {
-    if (cb) {
-      job.flags |= 4;
-    }
-    if (isPre) {
-      job.flags |= 2;
-      if (instance) {
-        job.id = instance.uid;
-        job.i = instance;
-      }
-    }
-  };
-  const watchHandle = watch$1(source, cb, baseWatchOptions);
+  const stop = effect.stop.bind(effect);
+  stop.pause = effect.pause.bind(effect);
+  stop.resume = effect.resume.bind(effect);
+  stop.stop = stop;
   if (isInSSRComponentSetup) {
     if (ssrCleanup) {
-      ssrCleanup.push(watchHandle);
+      ssrCleanup.push(stop);
     } else if (runsImmediately) {
-      watchHandle();
+      stop();
     }
   }
-  return watchHandle;
+  return stop;
 }
 function instanceWatch(source, value, options) {
   const publicThis = this.proxy;
@@ -6291,9 +6563,9 @@ function instanceWatch(source, value, options) {
     cb = value.handler;
     options = value;
   }
-  const reset = setCurrentInstance(this);
+  const prev = setCurrentInstance(this);
   const res = doWatch(getter, cb.bind(publicThis), options);
-  reset();
+  setCurrentInstance(...prev);
   return res;
 }
 function createPathGetter(ctx, path) {
@@ -6308,7 +6580,7 @@ function createPathGetter(ctx, path) {
 }
 
 function useModel(props, name, options = EMPTY_OBJ) {
-  const i = getCurrentInstance();
+  const i = getCurrentGenericInstance();
   if (!!(process.env.NODE_ENV !== "production") && !i) {
     warn$1(`useModel() called without active instance.`);
     return ref();
@@ -6319,7 +6591,7 @@ function useModel(props, name, options = EMPTY_OBJ) {
     return ref();
   }
   const hyphenatedName = hyphenate(name);
-  const modifiers = getModelModifiers(props, camelizedName);
+  const modifiers = getModelModifiers(props, camelizedName, defaultPropGetter);
   const res = customRef((track, trigger) => {
     let localValue;
     let prevSetValue = EMPTY_OBJ;
@@ -6341,9 +6613,25 @@ function useModel(props, name, options = EMPTY_OBJ) {
         if (!hasChanged(emittedValue, localValue) && !(prevSetValue !== EMPTY_OBJ && hasChanged(value, prevSetValue))) {
           return;
         }
-        const rawProps = i.vnode.props;
-        if (!(rawProps && // check if parent has passed v-model
-        (name in rawProps || camelizedName in rawProps || hyphenatedName in rawProps) && (`onUpdate:${name}` in rawProps || `onUpdate:${camelizedName}` in rawProps || `onUpdate:${hyphenatedName}` in rawProps))) {
+        let rawPropKeys;
+        let parentPassedModelValue = false;
+        let parentPassedModelUpdater = false;
+        if (i.rawKeys) {
+          rawPropKeys = i.rawKeys();
+        } else {
+          const rawProps = i.vnode.props;
+          rawPropKeys = rawProps && Object.keys(rawProps);
+        }
+        if (rawPropKeys) {
+          for (const key of rawPropKeys) {
+            if (key === name || key === camelizedName || key === hyphenatedName) {
+              parentPassedModelValue = true;
+            } else if (key === `onUpdate:${name}` || key === `onUpdate:${camelizedName}` || key === `onUpdate:${hyphenatedName}`) {
+              parentPassedModelUpdater = true;
+            }
+          }
+        }
+        if (!parentPassedModelValue || !parentPassedModelUpdater) {
           localValue = value;
           trigger();
         }
@@ -6370,21 +6658,26 @@ function useModel(props, name, options = EMPTY_OBJ) {
   };
   return res;
 }
-const getModelModifiers = (props, modelName) => {
-  return modelName === "modelValue" || modelName === "model-value" ? props.modelModifiers : props[`${modelName}Modifiers`] || props[`${camelize(modelName)}Modifiers`] || props[`${hyphenate(modelName)}Modifiers`];
+const getModelModifiers = (props, modelName, getter) => {
+  return modelName === "modelValue" || modelName === "model-value" ? getter(props, "modelModifiers") : getter(props, `${modelName}Modifiers`) || getter(props, `${camelize(modelName)}Modifiers`) || getter(props, `${hyphenate(modelName)}Modifiers`);
 };
 
 function emit(instance, event, ...rawArgs) {
+  return baseEmit(
+    instance,
+    instance.vnode.props || EMPTY_OBJ,
+    defaultPropGetter,
+    event,
+    ...rawArgs
+  );
+}
+function baseEmit(instance, props, getter, event, ...rawArgs) {
   if (instance.isUnmounted) return;
-  const props = instance.vnode.props || EMPTY_OBJ;
   if (!!(process.env.NODE_ENV !== "production")) {
-    const {
-      emitsOptions,
-      propsOptions: [propsOptions]
-    } = instance;
+    const { emitsOptions, propsOptions } = instance;
     if (emitsOptions) {
       if (!(event in emitsOptions) && true) {
-        if (!propsOptions || !(toHandlerKey(camelize(event)) in propsOptions)) {
+        if (!propsOptions || !propsOptions[0] || !(toHandlerKey(camelize(event)) in propsOptions[0])) {
           warn$1(
             `Component emitted event "${event}" but it is neither declared in the emits option nor as an "${toHandlerKey(camelize(event))}" prop.`
           );
@@ -6404,7 +6697,7 @@ function emit(instance, event, ...rawArgs) {
   }
   let args = rawArgs;
   const isModelListener = event.startsWith("update:");
-  const modifiers = isModelListener && getModelModifiers(props, event.slice(7));
+  const modifiers = isModelListener && getModelModifiers(props, event.slice(7), getter);
   if (modifiers) {
     if (modifiers.trim) {
       args = rawArgs.map((a) => isString(a) ? a.trim() : a);
@@ -6418,7 +6711,7 @@ function emit(instance, event, ...rawArgs) {
   }
   if (!!(process.env.NODE_ENV !== "production")) {
     const lowerCaseEvent = event.toLowerCase();
-    if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) {
+    if (lowerCaseEvent !== event && getter(props, toHandlerKey(lowerCaseEvent))) {
       warn$1(
         `Event "${lowerCaseEvent}" is emitted in component ${formatComponentName(
           instance,
@@ -6430,10 +6723,10 @@ function emit(instance, event, ...rawArgs) {
     }
   }
   let handlerName;
-  let handler = props[handlerName = toHandlerKey(event)] || // also try camelCase event handler (#2249)
-  props[handlerName = toHandlerKey(camelize(event))];
+  let handler = getter(props, handlerName = toHandlerKey(event)) || // also try camelCase event handler (#2249)
+  getter(props, handlerName = toHandlerKey(camelize(event)));
   if (!handler && isModelListener) {
-    handler = props[handlerName = toHandlerKey(hyphenate(event))];
+    handler = getter(props, handlerName = toHandlerKey(hyphenate(event)));
   }
   if (handler) {
     callWithAsyncErrorHandling(
@@ -6443,7 +6736,7 @@ function emit(instance, event, ...rawArgs) {
       args
     );
   }
-  const onceHandler = props[handlerName + `Once`];
+  const onceHandler = getter(props, handlerName + `Once`);
   if (onceHandler) {
     if (!instance.emitted) {
       instance.emitted = {};
@@ -6459,6 +6752,9 @@ function emit(instance, event, ...rawArgs) {
     );
   }
 }
+function defaultPropGetter(props, key) {
+  return props[key];
+}
 function normalizeEmitsOptions(comp, appContext, asMixin = false) {
   const cache = appContext.emitsCache;
   const cached = cache.get(comp);
@@ -6786,7 +7082,7 @@ function hasPropsChanged(prevProps, nextProps, emitsOptions) {
   return false;
 }
 function updateHOCHostEl({ vnode, parent }, el) {
-  while (parent) {
+  while (parent && !parent.vapor) {
     const root = parent.subTree;
     if (root.suspense && root.suspense.activeBranch === vnode) {
       root.el = vnode.el;
@@ -7137,7 +7433,8 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
                 pendingBranch,
                 container2,
                 anchor === initialAnchor ? next(activeBranch) : anchor,
-                0
+                0,
+                parentComponent2
               );
               queuePostFlushCb(effects);
             }
@@ -7150,7 +7447,13 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
           unmount(activeBranch, parentComponent2, suspense, true);
         }
         if (!delayEnter) {
-          move(pendingBranch, container2, anchor, 0);
+          move(
+            pendingBranch,
+            container2,
+            anchor,
+            0,
+            parentComponent2
+          );
         }
       }
       setActiveBranch(suspense, pendingBranch);
@@ -7223,7 +7526,7 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
       }
     },
     move(container2, anchor2, type) {
-      suspense.activeBranch && move(suspense.activeBranch, container2, anchor2, type);
+      suspense.activeBranch && move(suspense.activeBranch, container2, anchor2, type, parentComponent);
       suspense.container = container2;
     },
     next() {
@@ -7363,7 +7666,7 @@ function normalizeSuspenseSlot(s) {
   }
   return s;
 }
-function queueEffectWithSuspense(fn, suspense) {
+function queueEffectWithSuspense(fn, id, suspense) {
   if (suspense && suspense.pendingBranch) {
     if (isArray(fn)) {
       suspense.effects.push(...fn);
@@ -7371,7 +7674,7 @@ function queueEffectWithSuspense(fn, suspense) {
       suspense.effects.push(fn);
     }
   } else {
-    queuePostFlushCb(fn);
+    queuePostFlushCb(fn, id);
   }
 }
 function setActiveBranch(suspense, branch) {
@@ -7397,6 +7700,7 @@ const Fragment = Symbol.for("v-fgt");
 const Text = Symbol.for("v-txt");
 const Comment = Symbol.for("v-cmt");
 const Static = Symbol.for("v-stc");
+const VaporSlot = Symbol.for("v-vps");
 const blockStack = [];
 let currentBlock = null;
 function openBlock(disableTracking = false) {
@@ -7770,8 +8074,45 @@ function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
   ]);
 }
 
+let currentInstance = null;
+const getCurrentGenericInstance = () => currentInstance || currentRenderingInstance;
+const getCurrentInstance = () => currentInstance && !currentInstance.vapor ? currentInstance : currentRenderingInstance;
+let isInSSRComponentSetup = false;
+let setInSSRSetupState;
+let simpleSetCurrentInstance;
+{
+  const g = getGlobalThis();
+  const registerGlobalSetter = (key, setter) => {
+    let setters;
+    if (!(setters = g[key])) setters = g[key] = [];
+    setters.push(setter);
+    return (v) => {
+      if (setters.length > 1) setters.forEach((set) => set(v));
+      else setters[0](v);
+    };
+  };
+  simpleSetCurrentInstance = registerGlobalSetter(
+    `__VUE_INSTANCE_SETTERS__`,
+    (v) => currentInstance = v
+  );
+  setInSSRSetupState = registerGlobalSetter(
+    `__VUE_SSR_SETTERS__`,
+    (v) => isInSSRComponentSetup = v
+  );
+}
+const setCurrentInstance = (instance, scope = instance !== null ? instance.scope : void 0) => {
+  try {
+    return [currentInstance, setCurrentScope(scope)];
+  } finally {
+    simpleSetCurrentInstance(instance);
+  }
+};
+
 const emptyAppContext = createAppContext();
 let uid = 0;
+function nextUid() {
+  return uid++;
+}
 function createComponentInstance(vnode, parent, suspense) {
   const type = vnode.type;
   const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
@@ -7814,7 +8155,7 @@ function createComponentInstance(vnode, parent, suspense) {
     // to be set immediately
     emitted: null,
     // props default value
-    propsDefaults: EMPTY_OBJ,
+    propsDefaults: null,
     // inheritAttrs
     inheritAttrs: type.inheritAttrs,
     // state
@@ -7863,44 +8204,6 @@ function createComponentInstance(vnode, parent, suspense) {
   }
   return instance;
 }
-let currentInstance = null;
-const getCurrentInstance = () => currentInstance || currentRenderingInstance;
-let internalSetCurrentInstance;
-let setInSSRSetupState;
-{
-  const g = getGlobalThis();
-  const registerGlobalSetter = (key, setter) => {
-    let setters;
-    if (!(setters = g[key])) setters = g[key] = [];
-    setters.push(setter);
-    return (v) => {
-      if (setters.length > 1) setters.forEach((set) => set(v));
-      else setters[0](v);
-    };
-  };
-  internalSetCurrentInstance = registerGlobalSetter(
-    `__VUE_INSTANCE_SETTERS__`,
-    (v) => currentInstance = v
-  );
-  setInSSRSetupState = registerGlobalSetter(
-    `__VUE_SSR_SETTERS__`,
-    (v) => isInSSRComponentSetup = v
-  );
-}
-const setCurrentInstance = (instance) => {
-  const prev = currentInstance;
-  internalSetCurrentInstance(instance);
-  instance.scope.on();
-  return () => {
-    instance.scope.off();
-    internalSetCurrentInstance(prev);
-  };
-};
-const unsetCurrentInstance = () => {
-  currentInstance && currentInstance.scope.off();
-  internalSetCurrentInstance(null);
-};
-const isBuiltInTag = /* @__PURE__ */ makeMap("slot,component");
 function validateComponentName(name, { isNativeTag }) {
   if (isBuiltInTag(name) || isNativeTag(name)) {
     warn$1(
@@ -7911,13 +8214,16 @@ function validateComponentName(name, { isNativeTag }) {
 function isStatefulComponent(instance) {
   return instance.vnode.shapeFlag & 4;
 }
-let isInSSRComponentSetup = false;
 function setupComponent(instance, isSSR = false, optimized = false) {
   isSSR && setInSSRSetupState(isSSR);
-  const { props, children } = instance.vnode;
+  const { props, children, vi } = instance.vnode;
   const isStateful = isStatefulComponent(instance);
-  initProps(instance, props, isStateful, isSSR);
-  initSlots(instance, children, optimized || isSSR);
+  if (vi) {
+    vi(instance);
+  } else {
+    initProps(instance, props, isStateful, isSSR);
+    initSlots(instance, children, optimized || isSSR);
+  }
   const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0;
   isSSR && setInSSRSetupState(false);
   return setupResult;
@@ -7954,9 +8260,9 @@ function setupStatefulComponent(instance, isSSR) {
   }
   const { setup } = Component;
   if (setup) {
-    pauseTracking();
+    const prevSub = setActiveSub();
     const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null;
-    const reset = setCurrentInstance(instance);
+    const prev = setCurrentInstance(instance);
     const setupResult = callWithErrorHandling(
       setup,
       instance,
@@ -7967,12 +8273,15 @@ function setupStatefulComponent(instance, isSSR) {
       ]
     );
     const isAsyncSetup = isPromise(setupResult);
-    resetTracking();
-    reset();
+    setActiveSub(prevSub);
+    setCurrentInstance(...prev);
     if ((isAsyncSetup || instance.sp) && !isAsyncWrapper(instance)) {
       markAsyncBoundary(instance);
     }
     if (isAsyncSetup) {
+      const unsetCurrentInstance = () => {
+        setCurrentInstance(null, void 0);
+      };
       setupResult.then(unsetCurrentInstance, unsetCurrentInstance);
       if (isSSR) {
         return setupResult.then((resolvedResult) => {
@@ -8067,13 +8376,13 @@ function finishComponentSetup(instance, isSSR, skipOptions) {
     }
   }
   if (__VUE_OPTIONS_API__ && true) {
-    const reset = setCurrentInstance(instance);
-    pauseTracking();
+    const prevInstance = setCurrentInstance(instance);
+    const prevSub = setActiveSub();
     try {
       applyOptions(instance);
     } finally {
-      resetTracking();
-      reset();
+      setActiveSub(prevSub);
+      setCurrentInstance(...prevInstance);
     }
   }
   if (!!(process.env.NODE_ENV !== "production") && !Component.render && instance.render === NOOP && !isSSR) {
@@ -8115,29 +8424,6 @@ function getSlotsProxy(instance) {
   });
 }
 function createSetupContext(instance) {
-  const expose = (exposed) => {
-    if (!!(process.env.NODE_ENV !== "production")) {
-      if (instance.exposed) {
-        warn$1(`expose() should be called only once per setup().`);
-      }
-      if (exposed != null) {
-        let exposedType = typeof exposed;
-        if (exposedType === "object") {
-          if (isArray(exposed)) {
-            exposedType = "array";
-          } else if (isRef(exposed)) {
-            exposedType = "ref";
-          }
-        }
-        if (exposedType !== "object") {
-          warn$1(
-            `expose() should be passed a plain object, received ${exposedType}.`
-          );
-        }
-      }
-    }
-    instance.exposed = exposed || {};
-  };
   if (!!(process.env.NODE_ENV !== "production")) {
     let attrsProxy;
     let slotsProxy;
@@ -8151,17 +8437,40 @@ function createSetupContext(instance) {
       get emit() {
         return (event, ...args) => instance.emit(event, ...args);
       },
-      expose
+      expose: (exposed) => expose(instance, exposed)
     });
   } else {
     return {
       attrs: new Proxy(instance.attrs, attrsProxyHandlers),
       slots: instance.slots,
       emit: instance.emit,
-      expose
+      expose: (exposed) => expose(instance, exposed)
     };
   }
 }
+function expose(instance, exposed) {
+  if (!!(process.env.NODE_ENV !== "production")) {
+    if (instance.exposed) {
+      warn$1(`expose() should be called only once per setup().`);
+    }
+    if (exposed != null) {
+      let exposedType = typeof exposed;
+      if (exposedType === "object") {
+        if (isArray(exposed)) {
+          exposedType = "array";
+        } else if (isRef(exposed)) {
+          exposedType = "ref";
+        }
+      }
+      if (exposedType !== "object") {
+        warn$1(
+          `expose() should be passed a plain object, received ${exposedType}.`
+        );
+      }
+    }
+  }
+  instance.exposed = exposed || {};
+}
 function getComponentPublicInstance(instance) {
   if (instance.exposed) {
     return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {
@@ -8169,7 +8478,9 @@ function getComponentPublicInstance(instance) {
         if (key in target) {
           return target[key];
         } else if (key in publicPropertiesMap) {
-          return publicPropertiesMap[key](instance);
+          return publicPropertiesMap[key](
+            instance
+          );
         }
       },
       has(target, key) {
@@ -8212,14 +8523,7 @@ function isClassComponent(value) {
 }
 
 const computed = (getterOrOptions, debugOptions) => {
-  const c = computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
-  if (!!(process.env.NODE_ENV !== "production")) {
-    const i = getCurrentInstance();
-    if (i && i.appContext.config.warnRecursiveComputed) {
-      c._warnRecursive = true;
-    }
-  }
-  return c;
+  return computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
 };
 
 function h(type, propsOrChildren, children) {
@@ -8260,9 +8564,9 @@ function initCustomFormatter() {
       if (obj.__isVue) {
         return ["div", vueStyle, `VueInstance`];
       } else if (isRef(obj)) {
-        pauseTracking();
+        const prevSub = setActiveSub();
         const value = obj.value;
-        resetTracking();
+        setActiveSub(prevSub);
         return [
           "div",
           {},
@@ -8449,7 +8753,7 @@ function isMemoSame(cached, memo) {
   return true;
 }
 
-const version = "3.5.16";
+const version = "3.6.0-alpha.1";
 const warn = !!(process.env.NODE_ENV !== "production") ? warn$1 : NOOP;
 const ErrorTypeStrings = ErrorTypeStrings$1 ;
 const devtools = !!(process.env.NODE_ENV !== "production") || true ? devtools$1 : void 0;
@@ -8471,4 +8775,4 @@ const resolveFilter = null;
 const compatUtils = null;
 const DeprecationTypes = null;
 
-export { BaseTransition, BaseTransitionPropsValidators, Comment, DeprecationTypes, ErrorCodes, ErrorTypeStrings, Fragment, KeepAlive, Static, Suspense, Teleport, Text, assertNumber, callWithAsyncErrorHandling, callWithErrorHandling, cloneVNode, compatUtils, computed, createBlock, createCommentVNode, createElementBlock, createBaseVNode as createElementVNode, createHydrationRenderer, createPropsRestProxy, createRenderer, createSlots, createStaticVNode, createTextVNode, createVNode, defineAsyncComponent, defineComponent, defineEmits, defineExpose, defineModel, defineOptions, defineProps, defineSlots, devtools, getCurrentInstance, getTransitionRawChildren, guardReactiveProps, h, handleError, hasInjectionContext, hydrateOnIdle, hydrateOnInteraction, hydrateOnMediaQuery, hydrateOnVisible, initCustomFormatter, inject, isMemoSame, isRuntimeOnly, isVNode, mergeDefaults, mergeModels, mergeProps, nextTick, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onServerPrefetch, onUnmounted, onUpdated, openBlock, popScopeId, provide, pushScopeId, queuePostFlushCb, registerRuntimeCompiler, renderList, renderSlot, resolveComponent, resolveDirective, resolveDynamicComponent, resolveFilter, resolveTransitionHooks, setBlockTracking, setDevtoolsHook, setTransitionHooks, ssrContextKey, ssrUtils, toHandlers, transformVNodeArgs, useAttrs, useId, useModel, useSSRContext, useSlots, useTemplateRef, useTransitionState, version, warn, watch, watchEffect, watchPostEffect, watchSyncEffect, withAsyncContext, withCtx, withDefaults, withDirectives, withMemo, withScopeId };
+export { BaseTransition, BaseTransitionPropsValidators, Comment, DeprecationTypes, ErrorCodes, ErrorTypeStrings, Fragment, KeepAlive, MoveType, Static, Suspense, Teleport, Text, assertNumber, baseEmit, baseNormalizePropsOptions, callWithAsyncErrorHandling, callWithErrorHandling, cloneVNode, compatUtils, computed, createAppAPI, createBlock, createCommentVNode, createElementBlock, createBaseVNode as createElementVNode, createHydrationRenderer, createInternalObject, createPropsRestProxy, createRenderer, createSlots, createStaticVNode, createTextVNode, createVNode, currentInstance, defineAsyncComponent, defineComponent, defineEmits, defineExpose, defineModel, defineOptions, defineProps, defineSlots, devtools, endMeasure, expose, flushOnAppMount, getCurrentInstance, getTransitionRawChildren, guardReactiveProps, h, handleError, hasInjectionContext, hydrateOnIdle, hydrateOnInteraction, hydrateOnMediaQuery, hydrateOnVisible, initCustomFormatter, initFeatureFlags, inject, isEmitListener, isMemoSame, isRuntimeOnly, isVNode, mergeDefaults, mergeModels, mergeProps, nextTick, nextUid, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onServerPrefetch, onUnmounted, onUpdated, openBlock, popScopeId, popWarningContext, provide, pushScopeId, pushWarningContext, queueJob, queuePostFlushCb, registerHMR, registerRuntimeCompiler, renderList, renderSlot, resolveComponent, resolveDirective, resolveDynamicComponent, resolveFilter, resolvePropValue, resolveTransitionHooks, setBlockTracking, setCurrentInstance, setDevtoolsHook, setTransitionHooks, simpleSetCurrentInstance, ssrContextKey, ssrUtils, startMeasure, toHandlers, transformVNodeArgs, unregisterHMR, useAttrs, useId, useModel, useSSRContext, useSlots, useTemplateRef, useTransitionState, validateComponentName, validateProps, version, warn, watch, watchEffect, watchPostEffect, watchSyncEffect, withAsyncContext, withCtx, withDefaults, withDirectives, withMemo, withScopeId };