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

package/dist/runtime-core.cjs.prod.js

@@ -1,5 +1,5 @@
 /**
-* @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
 **/
@@ -10,7 +10,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var reactivity = require('@vue/reactivity');
 var shared = require('@vue/shared');
 
-function pushWarningContext(vnode) {
+function pushWarningContext(ctx) {
 }
 function popWarningContext() {
 }
@@ -107,11 +107,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 || shared.EMPTY_OBJ;
   if (instance) {
     let cur = instance.parent;
-    const exposedInstance = instance.proxy;
+    const exposedInstance = instance.proxy || instance;
     const errorInfo = `https://vuejs.org/error-reference/#runtime-${type}`;
     while (cur) {
       const errorCapturedHooks = cur.ec;
@@ -125,19 +124,19 @@ function handleError(err, instance, type, throwInDev = true) {
       cur = cur.parent;
     }
     if (errorHandler) {
-      reactivity.pauseTracking();
+      const prevSub = reactivity.setActiveSub();
       callWithErrorHandling(errorHandler, null, 10, [
         err,
         exposedInstance,
         errorInfo
       ]);
-      reactivity.resetTracking();
+      reactivity.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 (throwInProd) {
     throw err;
   } else {
@@ -145,25 +144,22 @@ 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;
 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;
@@ -171,112 +167,151 @@ 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 (!shared.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 (!shared.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) {
-  for (; i < queue.length; i++) {
-    const cb = queue[i];
-    if (cb && cb.flags & 2) {
-      if (instance && cb.id !== instance.uid) {
-        continue;
-      }
-      queue.splice(i, 1);
-      i--;
-      if (cb.flags & 4) {
-        cb.flags &= -2;
-      }
-      cb();
-      if (!(cb.flags & 4)) {
-        cb.flags &= -2;
-      }
+function flushPreFlushCbs(instance, seen) {
+  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;
+    }
+    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;
-    for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
-      const cb = activePostFlushCbs[postFlushIndex];
-      if (cb.flags & 4) {
+    activePostJobs = postJobs;
+    postJobs = [];
+    while (postFlushIndex < activePostJobs.length) {
+      const cb = activePostJobs[postFlushIndex++];
+      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) {
   try {
-    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
-      const job = queue[flushIndex];
-      if (job && !(job.flags & 8)) {
+    while (flushIndex < jobsLength) {
+      const job = jobs[flushIndex];
+      jobs[flushIndex++] = void 0;
+      if (!(job.flags & 4)) {
         if (false) ;
-        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();
     currentFlushPromise = null;
-    if (queue.length || pendingPostFlushCbs.length) {
+    if (jobsLength || postJobs.length) {
       flushJobs();
     }
   }
@@ -364,14 +399,14 @@ function invokeDirectiveHook(vnode, prevVNode, instance, name) {
     }
     let hook = binding.dir[name];
     if (hook) {
-      reactivity.pauseTracking();
+      const prevSub = reactivity.setActiveSub();
       callWithAsyncErrorHandling(hook, instance, 8, [
         vnode.el,
         binding,
         vnode,
         prevVNode
       ]);
-      reactivity.resetTracking();
+      reactivity.setActiveSub(prevSub);
     }
   }
 }
@@ -450,29 +485,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;
@@ -519,6 +562,7 @@ const TeleportImpl = {
             container,
             mainAnchor,
             internals,
+            parentComponent,
             1
           );
         } else {
@@ -538,6 +582,7 @@ const TeleportImpl = {
               nextTarget,
               null,
               internals,
+              parentComponent,
               0
             );
           }
@@ -547,6 +592,7 @@ const TeleportImpl = {
             target,
             targetAnchor,
             internals,
+            parentComponent,
             1
           );
         }
@@ -586,7 +632,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);
   }
@@ -602,7 +648,8 @@ function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }
           children[i],
           container,
           parentAnchor,
-          2
+          2,
+          parentComponent
         );
       }
     }
@@ -784,7 +831,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;
@@ -1056,7 +1103,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]++;
   }
@@ -1067,7 +1114,7 @@ function markAsyncBoundary(instance) {
 }
 
 function useTemplateRef(key) {
-  const i = getCurrentInstance();
+  const i = getCurrentGenericInstance();
   const r = reactivity.shallowRef(null);
   if (i) {
     const refs = i.refs === shared.EMPTY_OBJ ? i.refs = {} : i.refs;
@@ -1159,8 +1206,7 @@ function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
         } else ;
       };
       if (value) {
-        doSet.id = -1;
-        queuePostRenderEffect(doSet, parentSuspense);
+        queuePostRenderEffect(doSet, -1, parentSuspense);
       } else {
         doSet();
       }
@@ -1310,6 +1356,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) {
@@ -1458,11 +1507,15 @@ function createHydrationFunctions(rendererInternals) {
         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;
@@ -1632,7 +1685,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]);
   }
 }
 
@@ -1849,7 +1902,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) => {
@@ -1892,8 +1945,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();
@@ -1903,7 +1956,7 @@ const KeepAliveImpl = {
     const cache = /* @__PURE__ */ new Map();
     const keys = /* @__PURE__ */ new Set();
     let current = null;
-    const parentSuspense = instance.suspense;
+    const parentSuspense = keepAliveInstance.suspense;
     const {
       renderer: {
         p: patch,
@@ -1914,49 +1967,71 @@ 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) {
-          shared.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) {
+            shared.invokeArrayFns(instance.a);
+          }
+          const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
+          if (vnodeHook) {
+            invokeVNodeHook(vnodeHook, instance.parent, vnode);
+          }
+        },
+        void 0,
+        parentSuspense
+      );
     };
     sharedContext.deactivate = (vnode) => {
-      const instance2 = vnode.component;
-      invalidateMount(instance2.m);
-      invalidateMount(instance2.a);
-      move(vnode, storageContainer, null, 1, parentSuspense);
-      queuePostRenderEffect(() => {
-        if (instance2.da) {
-          shared.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) {
+            shared.invokeArrayFns(instance.da);
+          }
+          const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
+          if (vnodeHook) {
+            invokeVNodeHook(vnodeHook, instance.parent, vnode);
+          }
+          instance.isDeactivated = true;
+        },
+        void 0,
+        parentSuspense
+      );
     };
     function unmount(vnode) {
       resetShapeFlag(vnode);
-      _unmount(vnode, instance, parentSuspense, true);
+      _unmount(vnode, keepAliveInstance, parentSuspense, true);
     }
     function pruneCache(filter) {
       cache.forEach((vnode, key) => {
@@ -1988,12 +2063,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));
         }
       }
     };
@@ -2001,12 +2083,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);
@@ -2089,7 +2171,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) {
@@ -2103,7 +2185,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);
       }
@@ -2135,12 +2217,14 @@ function injectHook(type, hook, target = currentInstance, prepend = false) {
   if (target) {
     const hooks = target[type] || (target[type] = []);
     const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
-      reactivity.pauseTracking();
-      const reset = setCurrentInstance(target);
-      const res = callWithAsyncErrorHandling(hook, target, type, args);
-      reset();
-      reactivity.resetTracking();
-      return res;
+      const prevSub = reactivity.setActiveSub();
+      const prev = setCurrentInstance(target);
+      try {
+        return callWithAsyncErrorHandling(hook, target, type, args);
+      } finally {
+        setCurrentInstance(...prev);
+        reactivity.setActiveSub(prevSub);
+      }
     });
     if (prepend) {
       hooks.unshift(wrappedHook);
@@ -2206,7 +2290,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) {
@@ -2288,7 +2376,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,
@@ -2297,7 +2391,6 @@ function renderSlot(slots, name, props = {}, fallback, noSlotted) {
       64
     );
   }
-  let slot = slots[name];
   if (slot && slot._c) {
     slot._d = false;
   }
@@ -2342,8 +2435,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 = (
@@ -2507,8 +2601,13 @@ function useAttrs() {
   return getContext().attrs;
 }
 function getContext() {
-  const i = getCurrentInstance();
-  return i.setupContext || (i.setupContext = createSetupContext(i));
+  const i = getCurrentGenericInstance();
+  if (i.vapor) {
+    return i;
+  } else {
+    const ii = i;
+    return ii.setupContext || (ii.setupContext = createSetupContext(ii));
+  }
 }
 function normalizePropsOrEmits(props) {
   return shared.isArray(props) ? props.reduce(
@@ -2554,9 +2653,9 @@ function createPropsRestProxy(props, excludedKeys) {
   return ret;
 }
 function withAsyncContext(getAwaitable) {
-  const ctx = getCurrentInstance();
+  const ctx = getCurrentGenericInstance();
   let awaitable = getAwaitable();
-  unsetCurrentInstance();
+  setCurrentInstance(null, void 0);
   if (shared.isPromise(awaitable)) {
     awaitable = awaitable.catch((e) => {
       setCurrentInstance(ctx);
@@ -2925,7 +3024,7 @@ function createAppContext() {
   };
 }
 let uid$1 = 0;
-function createAppAPI(render, hydrate) {
+function createAppAPI(mount, unmount, getPublicInstance, render) {
   return function createApp(rootComponent, rootProps = null) {
     if (!shared.isFunction(rootComponent)) {
       rootComponent = shared.extend({}, rootComponent);
@@ -2984,22 +3083,11 @@ function createAppAPI(render, hydrate) {
       },
       mount(rootContainer, isHydrate, namespace) {
         if (!isMounted) {
-          const vnode = app._ceVNode || createVNode(rootComponent, rootProps);
-          vnode.appContext = context;
-          if (namespace === true) {
-            namespace = "svg";
-          } else if (namespace === false) {
-            namespace = void 0;
-          }
-          if (isHydrate && hydrate) {
-            hydrate(vnode, rootContainer);
-          } else {
-            render(vnode, rootContainer, namespace);
-          }
+          const instance = mount(app, rootContainer, isHydrate, namespace);
           isMounted = true;
           app._container = rootContainer;
           rootContainer.__vue_app__ = app;
-          return getComponentPublicInstance(vnode.component);
+          return getPublicInstance(instance);
         }
       },
       onUnmount(cleanupFn) {
@@ -3012,7 +3100,7 @@ function createAppAPI(render, hydrate) {
             app._instance,
             16
           );
-          render(null, app._container);
+          unmount(app);
           delete app._container.__vue_app__;
         }
       },
@@ -3036,6 +3124,7 @@ function createAppAPI(render, hydrate) {
 let currentApp = null;
 
 function provide(key, value) {
+  const currentInstance = getCurrentGenericInstance();
   if (!currentInstance) ; else {
     let provides = currentInstance.provides;
     const parentProvides = currentInstance.parent && currentInstance.parent.provides;
@@ -3046,9 +3135,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) {
@@ -3057,7 +3146,7 @@ function inject(key, defaultValue, treatDefaultAsFactory = false) {
   }
 }
 function hasInjectionContext() {
-  return !!(currentInstance || currentRenderingInstance || currentApp);
+  return !!(getCurrentGenericInstance() || currentApp);
 }
 
 const internalObjectProto = {};
@@ -3065,7 +3154,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);
@@ -3118,11 +3207,10 @@ function updateProps(instance, rawProps, rawPrevProps, optimized) {
             const camelizedKey = shared.camelize(key);
             props[camelizedKey] = resolvePropValue(
               options,
-              rawCurrentProps,
               camelizedKey,
               value,
               instance,
-              false
+              baseResolveDefault
             );
           }
         } else {
@@ -3149,10 +3237,10 @@ function updateProps(instance, rawProps, rawPrevProps, optimized) {
           rawPrevProps[kebabKey] !== void 0)) {
             props[key] = resolvePropValue(
               options,
-              rawCurrentProps,
               key,
               void 0,
               instance,
+              baseResolveDefault,
               true
             );
           }
@@ -3200,39 +3288,37 @@ function setFullProps(instance, rawProps, props, attrs) {
     }
   }
   if (needCastKeys) {
-    const rawCurrentProps = reactivity.toRaw(props);
     const castValues = rawCastValues || shared.EMPTY_OBJ;
     for (let i = 0; i < needCastKeys.length; i++) {
       const key = needCastKeys[i];
       props[key] = resolvePropValue(
         options,
-        rawCurrentProps,
         key,
         castValues[key],
         instance,
+        baseResolveDefault,
         !shared.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 = shared.hasOwn(opt, "default");
     if (hasDefault && value === void 0) {
       const defaultValue = opt.default;
       if (opt.type !== Function && !opt.skipFactory && shared.isFunction(defaultValue)) {
-        const { propsDefaults } = instance;
-        if (key in propsDefaults) {
-          value = propsDefaults[key];
+        const cachedDefaults = instance.propsDefaults || (instance.propsDefaults = {});
+        if (shared.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;
@@ -3251,6 +3337,17 @@ function resolvePropValue(options, props, key, value, instance, isAbsent) {
   }
   return value;
 }
+function baseResolveDefault(factory, instance, key) {
+  let value;
+  const prev = setCurrentInstance(instance);
+  const props = reactivity.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 = asMixin ? mixinPropsCache : appContext.propsCache;
@@ -3285,6 +3382,14 @@ function normalizePropsOptions(comp, appContext, asMixin = false) {
     }
     return shared.EMPTY_ARR;
   }
+  baseNormalizePropsOptions(raw, normalized, needCastKeys);
+  const res = [normalized, needCastKeys];
+  if (shared.isObject(comp)) {
+    cache.set(comp, res);
+  }
+  return res;
+}
+function baseNormalizePropsOptions(raw, normalized, needCastKeys) {
   if (shared.isArray(raw)) {
     for (let i = 0; i < raw.length; i++) {
       const normalizedKey = shared.camelize(raw[i]);
@@ -3323,11 +3428,6 @@ function normalizePropsOptions(comp, appContext, asMixin = false) {
       }
     }
   }
-  const res = [normalized, needCastKeys];
-  if (shared.isObject(comp)) {
-    cache.set(comp, res);
-  }
-  return res;
 }
 function validatePropName(key) {
   if (key[0] !== "$" && !shared.isReservedProp(key)) {
@@ -3376,6 +3476,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) shared.def(slots, "__", cacheIndexes, true);
     const type = children._;
     if (type) {
       assignSlots(slots, children, optimized);
@@ -3482,6 +3584,9 @@ function baseCreateRenderer(options, createHydrationFns) {
           optimized
         );
         break;
+      case VaporSlot:
+        getVaporInterface(parentComponent, n2).slot(n1, n2, container, anchor);
+        break;
       default:
         if (shapeFlag & 1) {
           processElement(
@@ -3537,6 +3642,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) => {
@@ -3671,11 +3778,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) => {
@@ -3687,8 +3798,8 @@ function baseCreateRenderer(options, createHydrationFns) {
         hostSetScopeId(el, slotScopeIds[i]);
       }
     }
-    if (parentComponent) {
-      let subTree = parentComponent.subTree;
+    let subTree = parentComponent && parentComponent.subTree;
+    if (subTree) {
       if (vnode === subTree || isSuspense(subTree.type) && (subTree.ssContent === vnode || subTree.ssFallback === vnode)) {
         const parentVNode = parentComponent.vnode;
         setScopeId(
@@ -3791,10 +3902,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) => {
@@ -3925,7 +4040,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,
@@ -3987,15 +4117,48 @@ 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 reactivity.ReactiveEffect {
+    constructor(instance, initialVNode, container, anchor, parentSuspense, namespace, optimized) {
+      const prevScope = reactivity.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;
+      reactivity.setCurrentScope(prevScope);
+      this.job = instance.job = () => {
+        if (this.dirty) {
+          this.run();
+        }
+      };
+      this.job.i = instance;
+    }
+    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;
@@ -4030,7 +4193,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);
           }
           const subTree = instance.subTree = renderComponentRoot(instance);
@@ -4046,20 +4210,21 @@ 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;
-        initialVNode = container = anchor = null;
+        this.initialVNode = this.container = this.anchor = null;
       } else {
         let { next, bu, u, parent, vnode } = instance;
         {
@@ -4071,7 +4236,7 @@ function baseCreateRenderer(options, createHydrationFns) {
             }
             nonHydratedAsyncRoot.asyncDep.then(() => {
               if (!instance.isUnmounted) {
-                componentUpdateFn();
+                this.fn();
               }
             });
             return;
@@ -4112,26 +4277,31 @@ 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
           );
         }
       }
-    };
-    instance.scope.on();
-    const effect = instance.effect = new reactivity.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);
+    }
+  }
+  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);
-    update();
+    effect.run();
   };
   const updateComponentPreRender = (instance, nextVNode, optimized) => {
     nextVNode.component = instance;
@@ -4140,9 +4310,9 @@ function baseCreateRenderer(options, createHydrationFns) {
     instance.next = null;
     updateProps(instance, nextVNode.props, prevProps, optimized);
     updateSlots(instance, nextVNode.children, optimized);
-    reactivity.pauseTracking();
+    const prevSub = reactivity.setActiveSub();
     flushPreFlushCbs(instance);
-    reactivity.resetTracking();
+    reactivity.setActiveSub(prevSub);
   };
   const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized = false) => {
     const c1 = n1 && n1.children;
@@ -4392,7 +4562,7 @@ function baseCreateRenderer(options, createHydrationFns) {
           patched++;
         }
       }
-      const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : shared.EMPTY_ARR;
+      const increasingNewIndexSequence = moved ? shared.getSequence(newIndexToOldIndexMap) : shared.EMPTY_ARR;
       j = increasingNewIndexSequence.length - 1;
       for (i = toBePatched - 1; i >= 0; i--) {
         const nextIndex = s2 + i;
@@ -4412,7 +4582,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--;
           }
@@ -4420,10 +4596,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) {
@@ -4431,13 +4617,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;
@@ -4451,7 +4649,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 = () => {
@@ -4493,9 +4695,9 @@ function baseCreateRenderer(options, createHydrationFns) {
       optimized = false;
     }
     if (ref != null) {
-      reactivity.pauseTracking();
+      const prevSub = reactivity.setActiveSub();
       setRef(ref, null, parentSuspense, vnode, true);
-      reactivity.resetTracking();
+      reactivity.setActiveSub(prevSub);
     }
     if (cacheIndex != null) {
       parentComponent.renderCache[cacheIndex] = void 0;
@@ -4511,7 +4713,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);
@@ -4545,15 +4752,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) => {
@@ -4599,7 +4814,7 @@ function baseCreateRenderer(options, createHydrationFns) {
     const {
       bum,
       scope,
-      job,
+      effect,
       subTree,
       um,
       m,
@@ -4618,16 +4833,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) {
@@ -4642,6 +4859,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) {
@@ -4651,7 +4871,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) {
@@ -4669,12 +4888,7 @@ function baseCreateRenderer(options, createHydrationFns) {
       );
     }
     container._vnode = vnode;
-    if (!isFlushing) {
-      isFlushing = true;
-      flushPreFlushCbs();
-      flushPostFlushCbs();
-      isFlushing = false;
-    }
+    flushOnAppMount();
   };
   const internals = {
     p: patch,
@@ -4682,6 +4896,7 @@ function baseCreateRenderer(options, createHydrationFns) {
     m: move,
     r: remove,
     mt: mountComponent,
+    umt: unmountComponent,
     mc: mountChildren,
     pc: patchChildren,
     pbc: patchBlockChildren,
@@ -4695,22 +4910,46 @@ 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 (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) {
@@ -4740,46 +4979,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) {
@@ -4793,9 +4992,14 @@ 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;
+  return res;
+}
 
 const ssrContextKey = Symbol.for("v-scx");
 const useSSRContext = () => {
@@ -4825,8 +5029,41 @@ function watchSyncEffect(effect, options) {
 function watch(source, cb, options) {
   return doWatch(source, cb, options);
 }
+class RenderWatcherEffect extends reactivity.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 = shared.EMPTY_OBJ) {
-  const { immediate, deep, flush, once } = options;
+  const { immediate, deep, flush = "pre", once } = options;
   const baseWatchOptions = shared.extend({}, options);
   const runsImmediately = cb && immediate || !cb && flush !== "post";
   let ssrCleanup;
@@ -4845,42 +5082,32 @@ function doWatch(source, cb, options = shared.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 = reactivity.watch(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;
@@ -4892,9 +5119,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) {
@@ -4909,10 +5136,10 @@ function createPathGetter(ctx, path) {
 }
 
 function useModel(props, name, options = shared.EMPTY_OBJ) {
-  const i = getCurrentInstance();
+  const i = getCurrentGenericInstance();
   const camelizedName = shared.camelize(name);
   const hyphenatedName = shared.hyphenate(name);
-  const modifiers = getModelModifiers(props, camelizedName);
+  const modifiers = getModelModifiers(props, camelizedName, defaultPropGetter);
   const res = reactivity.customRef((track, trigger) => {
     let localValue;
     let prevSetValue = shared.EMPTY_OBJ;
@@ -4934,9 +5161,25 @@ function useModel(props, name, options = shared.EMPTY_OBJ) {
         if (!shared.hasChanged(emittedValue, localValue) && !(prevSetValue !== shared.EMPTY_OBJ && shared.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();
         }
@@ -4963,16 +5206,24 @@ function useModel(props, name, options = shared.EMPTY_OBJ) {
   };
   return res;
 }
-const getModelModifiers = (props, modelName) => {
-  return modelName === "modelValue" || modelName === "model-value" ? props.modelModifiers : props[`${modelName}Modifiers`] || props[`${shared.camelize(modelName)}Modifiers`] || props[`${shared.hyphenate(modelName)}Modifiers`];
+const getModelModifiers = (props, modelName, getter) => {
+  return modelName === "modelValue" || modelName === "model-value" ? getter(props, "modelModifiers") : getter(props, `${modelName}Modifiers`) || getter(props, `${shared.camelize(modelName)}Modifiers`) || getter(props, `${shared.hyphenate(modelName)}Modifiers`);
 };
 
 function emit(instance, event, ...rawArgs) {
+  return baseEmit(
+    instance,
+    instance.vnode.props || shared.EMPTY_OBJ,
+    defaultPropGetter,
+    event,
+    ...rawArgs
+  );
+}
+function baseEmit(instance, props, getter, event, ...rawArgs) {
   if (instance.isUnmounted) return;
-  const props = instance.vnode.props || shared.EMPTY_OBJ;
   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) => shared.isString(a) ? a.trim() : a);
@@ -4982,10 +5233,10 @@ function emit(instance, event, ...rawArgs) {
     }
   }
   let handlerName;
-  let handler = props[handlerName = shared.toHandlerKey(event)] || // also try camelCase event handler (#2249)
-  props[handlerName = shared.toHandlerKey(shared.camelize(event))];
+  let handler = getter(props, handlerName = shared.toHandlerKey(event)) || // also try camelCase event handler (#2249)
+  getter(props, handlerName = shared.toHandlerKey(shared.camelize(event)));
   if (!handler && isModelListener) {
-    handler = props[handlerName = shared.toHandlerKey(shared.hyphenate(event))];
+    handler = getter(props, handlerName = shared.toHandlerKey(shared.hyphenate(event)));
   }
   if (handler) {
     callWithAsyncErrorHandling(
@@ -4995,7 +5246,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 = {};
@@ -5011,6 +5262,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);
@@ -5259,7 +5513,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;
@@ -5588,7 +5842,8 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
                 pendingBranch,
                 container2,
                 anchor === initialAnchor ? next(activeBranch) : anchor,
-                0
+                0,
+                parentComponent2
               );
               queuePostFlushCb(effects);
             }
@@ -5601,7 +5856,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);
@@ -5674,7 +5935,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() {
@@ -5805,7 +6066,7 @@ function normalizeSuspenseSlot(s) {
   }
   return s;
 }
-function queueEffectWithSuspense(fn, suspense) {
+function queueEffectWithSuspense(fn, id, suspense) {
   if (suspense && suspense.pendingBranch) {
     if (shared.isArray(fn)) {
       suspense.effects.push(...fn);
@@ -5813,7 +6074,7 @@ function queueEffectWithSuspense(fn, suspense) {
       suspense.effects.push(fn);
     }
   } else {
-    queuePostFlushCb(fn);
+    queuePostFlushCb(fn, id);
   }
 }
 function setActiveBranch(suspense, branch) {
@@ -5839,6 +6100,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) {
@@ -6175,6 +6437,40 @@ 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 = shared.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, reactivity.setCurrentScope(scope)];
+  } finally {
+    simpleSetCurrentInstance(instance);
+  }
+};
+
 const emptyAppContext = createAppContext();
 let uid = 0;
 function createComponentInstance(vnode, parent, suspense) {
@@ -6219,7 +6515,7 @@ function createComponentInstance(vnode, parent, suspense) {
     // to be set immediately
     emitted: null,
     // props default value
-    propsDefaults: shared.EMPTY_OBJ,
+    propsDefaults: null,
     // inheritAttrs
     inheritAttrs: type.inheritAttrs,
     // state
@@ -6266,53 +6562,19 @@ function createComponentInstance(vnode, parent, suspense) {
   }
   return instance;
 }
-let currentInstance = null;
-const getCurrentInstance = () => currentInstance || currentRenderingInstance;
-let internalSetCurrentInstance;
-let setInSSRSetupState;
-{
-  const g = shared.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);
-};
 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;
@@ -6323,9 +6585,9 @@ function setupStatefulComponent(instance, isSSR) {
   instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers);
   const { setup } = Component;
   if (setup) {
-    reactivity.pauseTracking();
+    const prevSub = reactivity.setActiveSub();
     const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null;
-    const reset = setCurrentInstance(instance);
+    const prev = setCurrentInstance(instance);
     const setupResult = callWithErrorHandling(
       setup,
       instance,
@@ -6336,12 +6598,15 @@ function setupStatefulComponent(instance, isSSR) {
       ]
     );
     const isAsyncSetup = shared.isPromise(setupResult);
-    reactivity.resetTracking();
-    reset();
+    reactivity.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) => {
@@ -6409,13 +6674,13 @@ function finishComponentSetup(instance, isSSR, skipOptions) {
     }
   }
   {
-    const reset = setCurrentInstance(instance);
-    reactivity.pauseTracking();
+    const prevInstance = setCurrentInstance(instance);
+    const prevSub = reactivity.setActiveSub();
     try {
       applyOptions(instance);
     } finally {
-      reactivity.resetTracking();
-      reset();
+      reactivity.setActiveSub(prevSub);
+      setCurrentInstance(...prevInstance);
     }
   }
 }
@@ -6426,18 +6691,18 @@ const attrsProxyHandlers = {
   }
 };
 function createSetupContext(instance) {
-  const expose = (exposed) => {
-    instance.exposed = exposed || {};
-  };
   {
     return {
       attrs: new Proxy(instance.attrs, attrsProxyHandlers),
       slots: instance.slots,
       emit: instance.emit,
-      expose
+      expose: (exposed) => expose(instance, exposed)
     };
   }
 }
+function expose(instance, exposed) {
+  instance.exposed = exposed || {};
+}
 function getComponentPublicInstance(instance) {
   if (instance.exposed) {
     return instance.exposeProxy || (instance.exposeProxy = new Proxy(reactivity.proxyRefs(reactivity.markRaw(instance.exposed)), {
@@ -6445,7 +6710,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) {
@@ -6464,8 +6731,7 @@ function isClassComponent(value) {
 }
 
 const computed = (getterOrOptions, debugOptions) => {
-  const c = reactivity.computed(getterOrOptions, debugOptions, isInSSRComponentSetup);
-  return c;
+  return reactivity.computed(getterOrOptions, debugOptions, isInSSRComponentSetup);
 };
 
 function h(type, propsOrChildren, children) {
@@ -6521,7 +6787,7 @@ function isMemoSame(cached, memo) {
   return true;
 }
 
-const version = "3.5.16";
+const version = "3.6.0-alpha.1";
 const warn$1 = shared.NOOP;
 const ErrorTypeStrings = ErrorTypeStrings$1 ;
 const devtools = void 0;