vue 3.6.0-beta.1 → 3.6.0-beta.2

package/dist/vue.runtime-with-vapor.esm-browser.js

@@ -1,5 +1,5 @@
 /**
-* vue v3.6.0-beta.1
+* vue v3.6.0-beta.2
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -2422,7 +2422,6 @@ function warn$1(msg, ...args) {
       instance,
       11,
       [
-        // eslint-disable-next-line no-restricted-syntax
         msg + args.map((a) => {
           var _a, _b;
           return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
@@ -3047,7 +3046,6 @@ function setDevtoolsHook$1(hook, target) {
     // (#4815)
     typeof window !== "undefined" && // some envs mock window but not fully
     window.HTMLElement && // also exclude jsdom
-    // eslint-disable-next-line no-restricted-syntax
     !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))
   ) {
     const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
@@ -5054,9 +5052,17 @@ function isMismatchAllowed(el, allowedType) {
   }
 }
 
-const requestIdleCallback = getGlobalThis().requestIdleCallback || ((cb) => setTimeout(cb, 1));
-const cancelIdleCallback = getGlobalThis().cancelIdleCallback || ((id) => clearTimeout(id));
+let requestIdleCallback;
+let cancelIdleCallback;
+function ensureIdleCallbacks() {
+  if (!requestIdleCallback) {
+    const g = getGlobalThis();
+    requestIdleCallback = g.requestIdleCallback || ((cb) => setTimeout(cb, 1));
+    cancelIdleCallback = g.cancelIdleCallback || ((id) => clearTimeout(id));
+  }
+}
 const hydrateOnIdle = (timeout = 1e4) => (hydrate) => {
+  ensureIdleCallbacks();
   const id = requestIdleCallback(hydrate, { timeout });
   return () => cancelIdleCallback(id);
 };
@@ -5349,7 +5355,7 @@ function performAsyncHydrate(el, instance, hydrate, getResolvedComp, load, hydra
 }
 
 const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
-const KeepAliveImpl = {
+const KeepAliveImpl$1 = {
   name: `KeepAlive`,
   // Marker for special handling inside the renderer. We are not using a ===
   // check directly on KeepAlive in the renderer, because importing it directly
@@ -5537,7 +5543,7 @@ const KeepAliveImpl = {
     };
   }
 };
-const KeepAlive = KeepAliveImpl;
+const KeepAlive = KeepAliveImpl$1;
 function matches(pattern, name) {
   if (isArray(pattern)) {
     return pattern.some((p) => matches(p, name));
@@ -10258,7 +10264,7 @@ function hydrateSuspense(node, vnode, parentComponent, parentSuspense, namespace
     parentSuspense,
     parentComponent,
     node.parentNode,
-    // eslint-disable-next-line no-restricted-globals
+    // oxlint-disable-next-line no-restricted-globals
     document.createElement("div"),
     null,
     namespace,
@@ -10754,7 +10760,7 @@ const setCurrentInstance = (instance, scope = instance !== null ? instance.scope
     simpleSetCurrentInstance(instance);
   }
 };
-const internalOptions = ["ce", "type"];
+const internalOptions = ["ce", "type", "uid"];
 const useInstanceOption = (key, silent = false) => {
   const instance = getCurrentGenericInstance();
   if (!instance) {
@@ -10774,7 +10780,7 @@ const useInstanceOption = (key, silent = false) => {
   return { hasInstance: true, value: instance[key] };
 };
 
-const emptyAppContext = createAppContext();
+const emptyAppContext = /* @__PURE__ */ createAppContext();
 let uid = 0;
 function nextUid() {
   return uid++;
@@ -11409,7 +11415,7 @@ function isMemoSame(cached, memo) {
   return true;
 }
 
-const version = "3.6.0-beta.1";
+const version = "3.6.0-beta.2";
 const warn = warn$1 ;
 const ErrorTypeStrings = ErrorTypeStrings$1 ;
 const devtools = devtools$1 ;
@@ -13468,22 +13474,22 @@ function resetInsertionState() {
   insertionParent = insertionAnchor = isLastInsertion = void 0;
 }
 
-const isHydratingStack = [];
-let isHydrating = false;
 let currentHydrationNode = null;
-function pushIsHydrating(value) {
-  isHydratingStack.push(isHydrating = value);
-}
-function popIsHydrating() {
-  isHydratingStack.pop();
-  isHydrating = isHydratingStack[isHydratingStack.length - 1] || false;
+let _hydrateDynamicFragment;
+let isHydrating = false;
+function setIsHydrating(value) {
+  try {
+    return isHydrating;
+  } finally {
+    isHydrating = value;
+  }
 }
 function runWithoutHydration(fn) {
+  const prev = setIsHydrating(false);
   try {
-    pushIsHydrating(false);
     return fn();
   } finally {
-    popIsHydrating();
+    setIsHydrating(prev);
   }
 }
 let isOptimized$1 = false;
@@ -13491,6 +13497,7 @@ function performHydration(fn, setup, cleanup) {
   if (!isOptimized$1) {
     adoptTemplate = adoptTemplateImpl;
     locateHydrationNode = locateHydrationNodeImpl;
+    _hydrateDynamicFragment = hydrateDynamicFragmentImpl;
     Comment.prototype.$fe = void 0;
     Node.prototype.$pns = void 0;
     Node.prototype.$idx = void 0;
@@ -13502,12 +13509,12 @@ function performHydration(fn, setup, cleanup) {
     isOptimized$1 = true;
   }
   enableHydrationNodeLookup();
-  pushIsHydrating(true);
+  const prev = setIsHydrating(true);
   setup();
   const res = fn();
   cleanup();
   currentHydrationNode = null;
-  popIsHydrating();
+  setIsHydrating(prev);
   if (!isHydrating) disableHydrationNodeLookup();
   return res;
 }
@@ -13667,6 +13674,50 @@ function removeFragmentNodes(node, endAnchor) {
     }
   }
 }
+function hydrateDynamicFragment(frag, isEmpty) {
+  _hydrateDynamicFragment && _hydrateDynamicFragment(frag, isEmpty);
+}
+function hydrateDynamicFragmentImpl(frag, isEmpty) {
+  if (frag.anchor) return;
+  if (frag.anchorLabel === "if") {
+    if (isEmpty) {
+      frag.anchor = locateFragmentEndAnchor("");
+      if (!frag.anchor) {
+        throw new Error(
+          "Failed to locate if anchor. this is likely a Vue internal bug."
+        );
+      } else {
+        {
+          frag.anchor.data = frag.anchorLabel;
+        }
+        return;
+      }
+    }
+  } else if (frag.anchorLabel === "slot") {
+    if (isEmpty && isComment(currentHydrationNode, "")) {
+      frag.anchor = currentHydrationNode;
+      {
+        frag.anchor.data = frag.anchorLabel;
+      }
+      return;
+    }
+    frag.anchor = locateFragmentEndAnchor();
+    if (!frag.anchor) {
+      throw new Error(
+        "Failed to locate slot anchor. this is likely a Vue internal bug."
+      );
+    } else {
+      return;
+    }
+  }
+  const { parentNode: pn, nextNode } = findBlockNode(frag.nodes);
+  queuePostFlushCb(() => {
+    pn.insertBefore(
+      frag.anchor = createComment(frag.anchorLabel) ,
+      nextNode
+    );
+  });
+}
 
 // @__NO_SIDE_EFFECTS__
 function createElement(tagName) {
@@ -14285,7 +14336,241 @@ function shouldForceHydrate(el, key) {
   tagName.includes("-");
 }
 
-/*! #__NO_SIDE_EFFECTS__ */
+const displayName = "VaporTransition";
+let registered = false;
+const ensureTransitionHooksRegistered = () => {
+  if (!registered) {
+    registered = true;
+    registerTransitionHooks(
+      applyTransitionHooksImpl,
+      applyTransitionLeaveHooksImpl
+    );
+  }
+};
+const decorate$1 = (t) => {
+  t.displayName = displayName;
+  t.props = TransitionPropsValidators;
+  t.__vapor = true;
+  return t;
+};
+const VaporTransition = /* @__PURE__ */ decorate$1((props, { slots }) => {
+  ensureTransitionHooksRegistered();
+  let resetDisplay;
+  if (isHydrating && currentHydrationNode && isTemplateNode(currentHydrationNode)) {
+    const {
+      content: { firstChild },
+      parentNode
+    } = currentHydrationNode;
+    if (firstChild) {
+      if (firstChild instanceof HTMLElement || firstChild instanceof SVGElement) {
+        const originalDisplay = firstChild.style.display;
+        firstChild.style.display = "none";
+        resetDisplay = () => firstChild.style.display = originalDisplay;
+      }
+      parentNode.replaceChild(firstChild, currentHydrationNode);
+      setCurrentHydrationNode(firstChild);
+    }
+  }
+  const children = slots.default && slots.default();
+  if (!children) return [];
+  const instance = currentInstance;
+  const { mode } = props;
+  checkTransitionMode(mode);
+  let resolvedProps;
+  renderEffect(() => resolvedProps = resolveTransitionProps(props));
+  const hooks = applyTransitionHooksImpl(children, {
+    state: useTransitionState(),
+    // use proxy to keep props reference stable
+    props: new Proxy({}, {
+      get(_, key) {
+        return resolvedProps[key];
+      }
+    }),
+    instance
+  });
+  if (resetDisplay && resolvedProps.appear) {
+    const child = findTransitionBlock(children);
+    hooks.beforeEnter(child);
+    resetDisplay();
+    queuePostFlushCb(() => hooks.enter(child));
+  }
+  return children;
+});
+const getTransitionHooksContext = (key, props, state, instance, postClone) => {
+  const { leavingNodes } = state;
+  const context = {
+    setLeavingNodeCache: (el) => {
+      leavingNodes.set(key, el);
+    },
+    unsetLeavingNodeCache: (el) => {
+      const leavingNode = leavingNodes.get(key);
+      if (leavingNode === el) {
+        leavingNodes.delete(key);
+      }
+    },
+    earlyRemove: () => {
+      const leavingNode = leavingNodes.get(key);
+      if (leavingNode && leavingNode[leaveCbKey]) {
+        leavingNode[leaveCbKey]();
+      }
+    },
+    cloneHooks: (block) => {
+      const hooks = resolveTransitionHooks(
+        block,
+        props,
+        state,
+        instance,
+        postClone
+      );
+      if (postClone) postClone(hooks);
+      return hooks;
+    }
+  };
+  return context;
+};
+function resolveTransitionHooks(block, props, state, instance, postClone) {
+  const context = getTransitionHooksContext(
+    String(block.$key),
+    props,
+    state,
+    instance,
+    postClone
+  );
+  const hooks = baseResolveTransitionHooks(
+    context,
+    props,
+    state,
+    instance
+  );
+  hooks.state = state;
+  hooks.props = props;
+  hooks.instance = instance;
+  return hooks;
+}
+function applyTransitionHooksImpl(block, hooks) {
+  if (isArray(block)) {
+    block = block.filter((b) => !(b instanceof Comment));
+    if (block.length === 1) {
+      block = block[0];
+    } else if (block.length === 0) {
+      return hooks;
+    }
+  }
+  const fragments = [];
+  const child = findTransitionBlock(block, (frag) => fragments.push(frag));
+  if (!child) {
+    fragments.forEach((f) => f.$transition = hooks);
+    if (fragments.length === 0) {
+      warn("Transition component has no valid child element");
+    }
+    return hooks;
+  }
+  const { props, instance, state, delayedLeave } = hooks;
+  let resolvedHooks = resolveTransitionHooks(
+    child,
+    props,
+    state,
+    instance,
+    (hooks2) => resolvedHooks = hooks2
+  );
+  resolvedHooks.delayedLeave = delayedLeave;
+  child.$transition = resolvedHooks;
+  fragments.forEach((f) => f.$transition = resolvedHooks);
+  return resolvedHooks;
+}
+function applyTransitionLeaveHooksImpl(block, enterHooks, afterLeaveCb) {
+  const leavingBlock = findTransitionBlock(block);
+  if (!leavingBlock) return void 0;
+  const { props, state, instance } = enterHooks;
+  const leavingHooks = resolveTransitionHooks(
+    leavingBlock,
+    props,
+    state,
+    instance
+  );
+  leavingBlock.$transition = leavingHooks;
+  const { mode } = props;
+  if (mode === "out-in") {
+    state.isLeaving = true;
+    leavingHooks.afterLeave = () => {
+      state.isLeaving = false;
+      afterLeaveCb();
+      leavingBlock.$transition = void 0;
+      delete leavingHooks.afterLeave;
+    };
+  } else if (mode === "in-out") {
+    leavingHooks.delayLeave = (block2, earlyRemove, delayedLeave) => {
+      state.leavingNodes.set(String(leavingBlock.$key), leavingBlock);
+      block2[leaveCbKey] = () => {
+        earlyRemove();
+        block2[leaveCbKey] = void 0;
+        leavingBlock.$transition = void 0;
+        delete enterHooks.delayedLeave;
+      };
+      enterHooks.delayedLeave = () => {
+        delayedLeave();
+        leavingBlock.$transition = void 0;
+        delete enterHooks.delayedLeave;
+      };
+    };
+  }
+}
+function findTransitionBlock(block, onFragment) {
+  let child;
+  if (block instanceof Node) {
+    if (block instanceof Element) child = block;
+  } else if (isVaporComponent(block)) {
+    if (isAsyncWrapper(block) && !block.type.__asyncResolved) {
+      child = block;
+    } else {
+      if (getComponentName(block.type) === displayName) return void 0;
+      child = findTransitionBlock(block.block, onFragment);
+      if (child && child.$key === void 0) child.$key = block.uid;
+    }
+  } else if (isArray(block)) {
+    let hasFound = false;
+    for (const c of block) {
+      if (c instanceof Comment) continue;
+      const item = findTransitionBlock(c, onFragment);
+      if (hasFound) {
+        warn(
+          "<transition> can only be used on a single element or component. Use <transition-group> for lists."
+        );
+        break;
+      }
+      child = item;
+      hasFound = true;
+    }
+  } else if (isFragment(block)) {
+    if (block.insert) {
+      child = block;
+    } else {
+      if (onFragment) onFragment(block);
+      child = findTransitionBlock(block.nodes, onFragment);
+    }
+  }
+  return child;
+}
+function setTransitionHooksOnFragment(block, hooks) {
+  if (isFragment(block)) {
+    block.$transition = hooks;
+    if (block.nodes && isFragment(block.nodes)) {
+      setTransitionHooksOnFragment(block.nodes, hooks);
+    }
+  } else if (isArray(block)) {
+    for (let i = 0; i < block.length; i++) {
+      setTransitionHooksOnFragment(block[i], hooks);
+    }
+  }
+}
+function setTransitionHooks(block, hooks) {
+  if (isVaporComponent(block)) {
+    block = findTransitionBlock(block.block);
+    if (!block) return;
+  }
+  block.$transition = hooks;
+}
+
 // @__NO_SIDE_EFFECTS__
 function defineVaporComponent(comp, extraOptions) {
   if (isFunction(comp)) {
@@ -14298,7 +14583,7 @@ function defineVaporComponent(comp, extraOptions) {
   return comp;
 }
 
-const VaporKeepAliveImpl = defineVaporComponent({
+const KeepAliveImpl = defineVaporComponent({
   name: "VaporKeepAlive",
   __isKeepAlive: true,
   props: {
@@ -14478,6 +14763,7 @@ const VaporKeepAliveImpl = defineVaporComponent({
     return children;
   }
 });
+const VaporKeepAliveImpl = KeepAliveImpl;
 const shouldCache = (block, props, interop = false) => {
   const isAsync = !interop && isAsyncWrapper(block);
   const type = interop ? block.vnode.type : block.type;
@@ -14822,6 +15108,9 @@ function createVDOMComponent(internals, component, parentComponent, rawProps, ra
       },
       instance
     );
+    if (isMounted && rawRef) {
+      setRef$1(rawRef, null, null, vnode);
+    }
   };
   return frag;
 }
@@ -15361,10 +15650,12 @@ const dynamicSlotsProxyHandlers = {
       for (const source of dynamicSources) {
         if (isFunction(source)) {
           const slot = resolveFunctionSource(source);
-          if (isArray(slot)) {
-            for (const s of slot) keys.push(String(s.name));
-          } else {
-            keys.push(String(slot.name));
+          if (slot) {
+            if (isArray(slot)) {
+              for (const s of slot) keys.push(String(s.name));
+            } else {
+              keys.push(String(slot.name));
+            }
           }
         } else {
           keys.push(...Object.keys(source));
@@ -15582,230 +15873,6 @@ function renderEffect(fn, noLifecycle = false) {
   effect.run();
 }
 
-const displayName = "VaporTransition";
-const decorate$1 = (t) => {
-  t.displayName = displayName;
-  t.props = TransitionPropsValidators;
-  t.__vapor = true;
-  return t;
-};
-const VaporTransition = /* @__PURE__ */ decorate$1((props, { slots }) => {
-  let resetDisplay;
-  if (isHydrating && currentHydrationNode && isTemplateNode(currentHydrationNode)) {
-    const {
-      content: { firstChild },
-      parentNode
-    } = currentHydrationNode;
-    if (firstChild) {
-      if (firstChild instanceof HTMLElement || firstChild instanceof SVGElement) {
-        const originalDisplay = firstChild.style.display;
-        firstChild.style.display = "none";
-        resetDisplay = () => firstChild.style.display = originalDisplay;
-      }
-      parentNode.replaceChild(firstChild, currentHydrationNode);
-      setCurrentHydrationNode(firstChild);
-    }
-  }
-  const children = slots.default && slots.default();
-  if (!children) return [];
-  const instance = currentInstance;
-  const { mode } = props;
-  checkTransitionMode(mode);
-  let resolvedProps;
-  renderEffect(() => resolvedProps = resolveTransitionProps(props));
-  const hooks = applyTransitionHooks(children, {
-    state: useTransitionState(),
-    // use proxy to keep props reference stable
-    props: new Proxy({}, {
-      get(_, key) {
-        return resolvedProps[key];
-      }
-    }),
-    instance
-  });
-  if (resetDisplay && resolvedProps.appear) {
-    const child = findTransitionBlock(children);
-    hooks.beforeEnter(child);
-    resetDisplay();
-    queuePostFlushCb(() => hooks.enter(child));
-  }
-  return children;
-});
-const getTransitionHooksContext = (key, props, state, instance, postClone) => {
-  const { leavingNodes } = state;
-  const context = {
-    setLeavingNodeCache: (el) => {
-      leavingNodes.set(key, el);
-    },
-    unsetLeavingNodeCache: (el) => {
-      const leavingNode = leavingNodes.get(key);
-      if (leavingNode === el) {
-        leavingNodes.delete(key);
-      }
-    },
-    earlyRemove: () => {
-      const leavingNode = leavingNodes.get(key);
-      if (leavingNode && leavingNode[leaveCbKey]) {
-        leavingNode[leaveCbKey]();
-      }
-    },
-    cloneHooks: (block) => {
-      const hooks = resolveTransitionHooks(
-        block,
-        props,
-        state,
-        instance,
-        postClone
-      );
-      if (postClone) postClone(hooks);
-      return hooks;
-    }
-  };
-  return context;
-};
-function resolveTransitionHooks(block, props, state, instance, postClone) {
-  const context = getTransitionHooksContext(
-    String(block.$key),
-    props,
-    state,
-    instance,
-    postClone
-  );
-  const hooks = baseResolveTransitionHooks(
-    context,
-    props,
-    state,
-    instance
-  );
-  hooks.state = state;
-  hooks.props = props;
-  hooks.instance = instance;
-  return hooks;
-}
-function applyTransitionHooks(block, hooks) {
-  if (isArray(block)) {
-    block = block.filter((b) => !(b instanceof Comment));
-    if (block.length === 1) {
-      block = block[0];
-    } else if (block.length === 0) {
-      return hooks;
-    }
-  }
-  const fragments = [];
-  const child = findTransitionBlock(block, (frag) => fragments.push(frag));
-  if (!child) {
-    fragments.forEach((f) => f.$transition = hooks);
-    if (fragments.length === 0) {
-      warn("Transition component has no valid child element");
-    }
-    return hooks;
-  }
-  const { props, instance, state, delayedLeave } = hooks;
-  let resolvedHooks = resolveTransitionHooks(
-    child,
-    props,
-    state,
-    instance,
-    (hooks2) => resolvedHooks = hooks2
-  );
-  resolvedHooks.delayedLeave = delayedLeave;
-  child.$transition = resolvedHooks;
-  fragments.forEach((f) => f.$transition = resolvedHooks);
-  return resolvedHooks;
-}
-function applyTransitionLeaveHooks(block, enterHooks, afterLeaveCb) {
-  const leavingBlock = findTransitionBlock(block);
-  if (!leavingBlock) return void 0;
-  const { props, state, instance } = enterHooks;
-  const leavingHooks = resolveTransitionHooks(
-    leavingBlock,
-    props,
-    state,
-    instance
-  );
-  leavingBlock.$transition = leavingHooks;
-  const { mode } = props;
-  if (mode === "out-in") {
-    state.isLeaving = true;
-    leavingHooks.afterLeave = () => {
-      state.isLeaving = false;
-      afterLeaveCb();
-      leavingBlock.$transition = void 0;
-      delete leavingHooks.afterLeave;
-    };
-  } else if (mode === "in-out") {
-    leavingHooks.delayLeave = (block2, earlyRemove, delayedLeave) => {
-      state.leavingNodes.set(String(leavingBlock.$key), leavingBlock);
-      block2[leaveCbKey] = () => {
-        earlyRemove();
-        block2[leaveCbKey] = void 0;
-        leavingBlock.$transition = void 0;
-        delete enterHooks.delayedLeave;
-      };
-      enterHooks.delayedLeave = () => {
-        delayedLeave();
-        leavingBlock.$transition = void 0;
-        delete enterHooks.delayedLeave;
-      };
-    };
-  }
-}
-function findTransitionBlock(block, onFragment) {
-  let child;
-  if (block instanceof Node) {
-    if (block instanceof Element) child = block;
-  } else if (isVaporComponent(block)) {
-    if (isAsyncWrapper(block) && !block.type.__asyncResolved) {
-      child = block;
-    } else {
-      if (getComponentName(block.type) === displayName) return void 0;
-      child = findTransitionBlock(block.block, onFragment);
-      if (child && child.$key === void 0) child.$key = block.uid;
-    }
-  } else if (isArray(block)) {
-    let hasFound = false;
-    for (const c of block) {
-      if (c instanceof Comment) continue;
-      const item = findTransitionBlock(c, onFragment);
-      if (hasFound) {
-        warn(
-          "<transition> can only be used on a single element or component. Use <transition-group> for lists."
-        );
-        break;
-      }
-      child = item;
-      hasFound = true;
-    }
-  } else if (isFragment(block)) {
-    if (block.insert) {
-      child = block;
-    } else {
-      if (onFragment) onFragment(block);
-      child = findTransitionBlock(block.nodes, onFragment);
-    }
-  }
-  return child;
-}
-function setTransitionHooksOnFragment(block, hooks) {
-  if (isFragment(block)) {
-    block.$transition = hooks;
-    if (block.nodes && isFragment(block.nodes)) {
-      setTransitionHooksOnFragment(block.nodes, hooks);
-    }
-  } else if (isArray(block)) {
-    for (let i = 0; i < block.length; i++) {
-      setTransitionHooksOnFragment(block[i], hooks);
-    }
-  }
-}
-function setTransitionHooks(block, hooks) {
-  if (isVaporComponent(block)) {
-    block = findTransitionBlock(block.block);
-    if (!block) return;
-  }
-  block.$transition = hooks;
-}
-
 class VaporFragment {
   constructor(nodes) {
     this.vnode = null;
@@ -15821,45 +15888,7 @@ class DynamicFragment extends VaporFragment {
   constructor(anchorLabel) {
     super([]);
     this.hydrate = (isEmpty = false) => {
-      if (this.anchor) return;
-      if (this.anchorLabel === "if") {
-        if (isEmpty) {
-          this.anchor = locateFragmentEndAnchor("");
-          if (!this.anchor) {
-            throw new Error(
-              "Failed to locate if anchor. this is likely a Vue internal bug."
-            );
-          } else {
-            {
-              this.anchor.data = this.anchorLabel;
-            }
-            return;
-          }
-        }
-      } else if (this.anchorLabel === "slot") {
-        if (isEmpty && isComment(currentHydrationNode, "")) {
-          this.anchor = currentHydrationNode;
-          {
-            this.anchor.data = this.anchorLabel;
-          }
-          return;
-        }
-        this.anchor = locateFragmentEndAnchor();
-        if (!this.anchor) {
-          throw new Error(
-            "Failed to locate slot anchor. this is likely a Vue internal bug."
-          );
-        } else {
-          return;
-        }
-      }
-      const { parentNode, nextNode } = findBlockNode(this.nodes);
-      queuePostFlushCb(() => {
-        parentNode.insertBefore(
-          this.anchor = createComment(this.anchorLabel) ,
-          nextNode
-        );
-      });
+      hydrateDynamicFragment(this, isEmpty);
     };
     this.slotOwner = currentSlotOwner;
     if (isHydrating) {
@@ -16043,6 +16072,11 @@ const VaporTeleportImpl = {
 class TeleportFragment extends VaporFragment {
   constructor(props, slots) {
     super([]);
+    /**
+     * @internal marker for duck typing to avoid direct instanceof check
+     * which prevents tree-shaking of TeleportFragment
+     */
+    this.__isTeleportFragment = true;
     this.insert = (container, anchor) => {
       if (isHydrating) return;
       this.placeholder = createComment("teleport start") ;
@@ -16256,7 +16290,10 @@ Server rendered element contains fewer child nodes than client nodes.`
   }
 }
 function isVaporTeleport(value) {
-  return value === VaporTeleportImpl;
+  return !!(value && value.__isTeleport && value.__vapor);
+}
+function isTeleportFragment(value) {
+  return !!(value && value.__isTeleportFragment);
 }
 function locateTeleportEndAnchor(node = currentHydrationNode) {
   while (node) {
@@ -16453,7 +16490,7 @@ function normalizeBlock(block) {
   } else if (isVaporComponent(block)) {
     nodes.push(...normalizeBlock(block.block));
   } else {
-    if (block instanceof TeleportFragment) {
+    if (isTeleportFragment(block)) {
       nodes.push(block.placeholder, block.anchor);
     } else {
       nodes.push(...normalizeBlock(block.nodes));
@@ -16529,6 +16566,18 @@ function setComponentScopeId(instance) {
     setScopeId(instance.block, scopeIds);
   }
 }
+let _applyTransitionHooks;
+let _applyTransitionLeaveHooks;
+function registerTransitionHooks(applyHooks, applyLeaveHooks) {
+  _applyTransitionHooks = applyHooks;
+  _applyTransitionLeaveHooks = applyLeaveHooks;
+}
+function applyTransitionHooks(block, hooks) {
+  return _applyTransitionHooks ? _applyTransitionHooks(block, hooks) : hooks;
+}
+function applyTransitionLeaveHooks(block, enterHooks, afterLeaveCb) {
+  _applyTransitionLeaveHooks && _applyTransitionLeaveHooks(block, enterHooks, afterLeaveCb);
+}
 
 function hmrRerender(instance) {
   const normalized = normalizeBlock(instance.block);
@@ -17010,7 +17059,7 @@ function getRootElement(block, onDynamicFragment, recurse = true) {
   if (recurse && isVaporComponent(block)) {
     return getRootElement(block.block, onDynamicFragment, recurse);
   }
-  if (isFragment(block) && !(block instanceof TeleportFragment)) {
+  if (isFragment(block) && !isTeleportFragment(block)) {
     if (block instanceof DynamicFragment && onDynamicFragment) {
       onDynamicFragment(block);
     }
@@ -17088,7 +17137,7 @@ function handleSetupResult(setupResult, component, instance) {
       });
     } else if (!instance.accessedAttrs && isArray(instance.block) && instance.block.length || // preventing attrs fallthrough on Teleport
     // consistent with VDOM Teleport behavior
-    instance.block instanceof TeleportFragment) {
+    isTeleportFragment(instance.block)) {
       warnExtraneousAttributes(instance.attrs);
     }
   }
@@ -17422,7 +17471,6 @@ class VaporElement extends VueElementBase {
 }
 
 let t;
-/*! #__NO_SIDE_EFFECTS__ */
 // @__NO_SIDE_EFFECTS__
 function template(html, root, ns) {
   let node;
@@ -17459,7 +17507,7 @@ function createIf(condition, b1, b2, once) {
   if (!isHydrating) resetInsertionState();
   let frag;
   if (once) {
-    frag = condition() ? b1() : b2 ? b2() : [];
+    frag = condition() ? b1() : b2 ? b2() : [createComment("if") ];
   } else {
     frag = isHydrating || true ? new DynamicFragment("if") : new DynamicFragment();
     renderEffect(() => frag.update(condition() ? b1 : b2));
@@ -18090,11 +18138,11 @@ function resolveParentNode(block) {
   if (block instanceof Node) {
     return block.parentNode;
   } else if (isArray(block)) {
-    return resolveParentNode(block[0]);
+    return resolveParentNode(block[block.length - 1]);
   } else if (isVaporComponent(block)) {
     return resolveParentNode(block.block);
   } else {
-    return resolveParentNode(block.nodes);
+    return resolveParentNode(block.anchor || block.nodes);
   }
 }
 function setVars(instance, vars) {
@@ -18317,13 +18365,14 @@ const decorate = (t) => {
   t.__vapor = true;
   return t;
 };
-const VaporTransitionGroup = decorate({
+const VaporTransitionGroupImpl = {
   name: "VaporTransitionGroup",
   props: /* @__PURE__ */ extend({}, TransitionPropsValidators, {
     tag: String,
     moveClass: String
   }),
   setup(props, { slots }) {
+    ensureTransitionHooksRegistered();
     const instance = currentInstance;
     const state = useTransitionState();
     let cssTransitionProps = resolveTransitionProps(props);
@@ -18415,7 +18464,8 @@ const VaporTransitionGroup = decorate({
       return slottedBlock;
     }
   }
-});
+};
+const VaporTransitionGroup = /* @__PURE__ */ decorate(VaporTransitionGroupImpl);
 function getTransitionBlocks(block) {
   let children = [];
   if (block instanceof Node) {