@vue/compat 3.6.0-rc.13 → 3.6.0-rc.15

package/dist/vue.cjs.prod.js

@@ -1,5 +1,5 @@
 /**
-  * @vue/compat v3.6.0-rc.13
+  * @vue/compat v3.6.0-rc.15
   * (c) 2018-present Yuxi (Evan) You and Vue contributors
   * @license MIT
   **/
@@ -72,10 +72,18 @@ const isPlainObject = (val) => toTypeString(val) === "[object Object]";
 const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
 const isReservedProp = /*@__PURE__*/ makeMap(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted");
 const isBuiltInDirective = /*@__PURE__*/ makeMap("bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo");
+const STRING_CACHE_MAX_SIZE = 1e4;
 const cacheStringFunction = (fn) => {
-	const cache = Object.create(null);
+	let cache = Object.create(null);
+	let size = 0;
 	return ((str) => {
-		return cache[str] || (cache[str] = fn(str));
+		const hit = cache[str];
+		if (hit !== void 0) return hit;
+		if (++size > STRING_CACHE_MAX_SIZE) {
+			cache = Object.create(null);
+			size = 1;
+		}
+		return cache[str] = fn(str);
 	});
 };
 const camelizeRE = /-(\w)/g;
@@ -83,22 +91,22 @@ const camelizeReplacer = (_, c) => c ? c.toUpperCase() : "";
 /**
 * @private
 */
-const camelize = cacheStringFunction((str) => str.replace(camelizeRE, camelizeReplacer));
+const camelize = /*@__PURE__*/ cacheStringFunction((str) => str.replace(camelizeRE, camelizeReplacer));
 const hyphenateRE = /\B([A-Z])/g;
 /**
 * @private
 */
-const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
+const hyphenate = /*@__PURE__*/ cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
 /**
 * @private
 */
-const capitalize = cacheStringFunction((str) => {
+const capitalize = /*@__PURE__*/ cacheStringFunction((str) => {
 	return str.charAt(0).toUpperCase() + str.slice(1);
 });
 /**
 * @private
 */
-const toHandlerKey = cacheStringFunction((str) => {
+const toHandlerKey = /*@__PURE__*/ cacheStringFunction((str) => {
 	return str ? `on${capitalize(str)}` : ``;
 });
 /**
@@ -237,26 +245,11 @@ const isMathMLTag = /*@__PURE__*/ makeMap(MATH_TAGS);
 * Do NOT use in runtime code paths unless behind `__DEV__` flag.
 */
 const isVoidTag = /*@__PURE__*/ makeMap(VOID_TAGS);
-//#endregion
-//#region packages/shared/src/domAttrConfig.ts
-/**
-* On the client we only need to offer special cases for boolean attributes that
-* have different names from their corresponding dom properties:
-* - itemscope -> N/A
-* - allowfullscreen -> allowFullscreen
-* - formnovalidate -> formNoValidate
-* - ismap -> isMap
-* - nomodule -> noModule
-* - novalidate -> noValidate
-* - playsinline -> playsInline
-* - readonly -> readOnly
-*/
-const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,playsinline,readonly`;
-const isSpecialBooleanAttr = /*@__PURE__*/ makeMap(specialBooleanAttrs);
+const isSpecialBooleanAttr = /*@__PURE__*/ makeMap("itemscope,allowfullscreen,disablepictureinpicture,disableremoteplayback,formnovalidate,ismap,nomodule,novalidate,playsinline,readonly");
 /**
 * The full list is needed during SSR to produce the correct initial markup.
 */
-const isBooleanAttr = /*@__PURE__*/ makeMap(specialBooleanAttrs + ",async,autofocus,autoplay,controls,default,defer,disabled,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected");
+const isBooleanAttr = /*@__PURE__*/ makeMap("itemscope,allowfullscreen,disablepictureinpicture,disableremoteplayback,formnovalidate,ismap,nomodule,novalidate,playsinline,readonly,async,autofocus,autoplay,controls,default,defer,disabled,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected");
 /**
 * Boolean attributes should be included if the value is truthy or ''.
 * e.g. `<select multiple>` compiles to `{ multiple: '' }`
@@ -467,17 +460,37 @@ function getSequence(arr) {
 	return result;
 }
 //#endregion
+//#region packages/shared/src/vaporFlags.ts
+/**
+* The data of the comment a vapor server render opens the branch of a `v-if`
+* chain with, `<!--[1-->`: the digits are the branch's position in the chain,
+* and `<!--]-->` closes it like a fragment.
+*/
+function isVaporBranchStart(data) {
+	if (data.length < 2 || data.charCodeAt(0) !== 91) return false;
+	for (let i = 1; i < data.length; i++) {
+		const c = data.charCodeAt(i);
+		if (c < 48 || c > 57) return false;
+	}
+	return true;
+}
+/**
+* The data of a comment opening a range only a vapor server render emits:
+* `<!--{-->` around the render of a component, or a v-if branch's.
+*/
+function isVaporRangeStart(data) {
+	return data === "{" || isVaporBranchStart(data);
+}
+/** The data of the comment closing the range `open` opens. */
+function rangeCloseOf(open) {
+	return open === "(" ? ")" : open === "{" ? "}" : "]";
+}
+//#endregion
 //#region packages/reactivity/src/system.ts
 const notifyBuffer = [];
 let batchDepth = 0;
 let activeSub = void 0;
-let runDepth = 0;
-function incRunDepth() {
-	++runDepth;
-}
-function decRunDepth() {
-	--runDepth;
-}
+const CHECKING = 512;
 let globalVersion = 0;
 let notifyIndex = 0;
 let notifyBufferLength = 0;
@@ -526,6 +539,7 @@ function unlink(link, sub = link.sub) {
 	const nextDep = link.nextDep;
 	const nextSub = link.nextSub;
 	const prevSub = link.prevSub;
+	link.prevDep = link.nextDep = link.prevSub = link.nextSub = void 0;
 	if (nextDep !== void 0) nextDep.prevDep = prevDep;
 	else sub.depsTail = prevDep;
 	if (prevDep !== void 0) prevDep.nextDep = nextDep;
@@ -533,7 +547,7 @@ function unlink(link, sub = link.sub) {
 	if (nextSub !== void 0) nextSub.prevSub = prevSub;
 	else dep.subsTail = prevSub;
 	if (prevSub !== void 0) prevSub.nextSub = nextSub;
-	else if ((dep.subs = nextSub) === void 0) {
+	else if ((dep.subs = nextSub) === void 0 && dep.flags & 1) {
 		let toRemove = dep.deps;
 		if (toRemove !== void 0) {
 			do
@@ -551,14 +565,12 @@ function propagate(link) {
 		const sub = link.sub;
 		let flags = sub.flags;
 		if (flags & 3) {
-			if (!(flags & 60)) {
-				sub.flags = flags | 32;
-				if (runDepth) sub.flags |= 8;
-			} else if (!(flags & 12)) flags = 0;
+			if (!(flags & 44)) sub.flags = flags | 32;
+			else if (!(flags & 12)) flags = 0;
 			else if (!(flags & 4)) sub.flags = flags & -9 | 32;
 			else if (!(flags & 48) && isValidLink(link, sub)) {
 				sub.flags = flags | 40;
-				flags &= 1;
+				flags = sub === activeSub || activeSub === void 0 ? 0 : flags & 1;
 			} else flags = 0;
 			if (flags & 2) notifyBuffer[notifyBufferLength++] = sub;
 			if (flags & 1) {
@@ -594,15 +606,18 @@ function propagate(link) {
 function startTracking(sub) {
 	++globalVersion;
 	sub.depsTail = void 0;
-	sub.flags = sub.flags & -57 | 4;
+	sub.flags = sub.flags & -569 | 4;
 	return setActiveSub(sub);
 }
 function endTracking(sub, prevSub) {
 	activeSub = prevSub;
 	const depsTail = sub.depsTail;
 	let toRemove = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
-	while (toRemove !== void 0) toRemove = unlink(toRemove, sub);
-	sub.flags &= -5;
+	while (toRemove !== void 0) {
+		unlink(toRemove, sub);
+		toRemove = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
+	}
+	if ((sub.flags &= -5) & 8) markRecursed(sub);
 }
 function flush() {
 	let hasError = false;
@@ -624,45 +639,67 @@ function flush() {
 	if (hasError) throw error;
 }
 function checkDirty(link, sub) {
+	try {
+		return walkDirty(link, sub);
+	} catch (err) {
+		markStale(sub);
+		throw err;
+	}
+}
+function walkDirty(link, sub) {
+	const root = sub;
 	let stack;
 	let checkDepth = 0;
+	let staleDepth = 0;
+	let staleFloor = 0;
 	top: do {
 		const dep = link.dep;
 		const depFlags = dep.flags;
 		let dirty = false;
 		if (sub.flags & 16) dirty = true;
 		else if ((depFlags & 17) === 17) {
-			const subs = dep.subs;
 			if (dep.update()) {
-				if (subs.nextSub !== void 0) shallowPropagate(subs);
+				const subs = dep.subs;
+				if (subs !== void 0 && (subs !== link || subs.nextSub !== void 0)) shallowPropagate(subs);
 				dirty = true;
 			}
 		} else if ((depFlags & 33) === 33) {
-			stack = {
-				value: link,
-				prev: stack
-			};
-			link = dep.deps;
-			sub = dep;
-			++checkDepth;
-			continue;
+			const depth = dep === root ? 0 : depFlags & CHECKING ? checkingDepth(dep, stack, checkDepth) : -1;
+			if (depth < 0) {
+				if (link.nextSub !== void 0 || link.prevSub !== void 0) dep.flags = depFlags | CHECKING;
+				stack = {
+					value: link,
+					prev: stack
+				};
+				link = dep.deps;
+				sub = dep;
+				++checkDepth;
+				continue;
+			}
+			if (depth < checkDepth) {
+				staleFloor = staleDepth && staleFloor < depth ? staleFloor : depth;
+				staleDepth = checkDepth;
+			}
 		}
 		if (!dirty && link.nextDep !== void 0) {
 			link = link.nextDep;
 			continue;
 		}
 		while (checkDepth) {
+			const stale = checkDepth === staleDepth;
+			if (stale && --staleDepth === staleFloor) staleDepth = 0;
 			--checkDepth;
 			link = stack.value;
 			stack = stack.prev;
 			if (dirty) {
-				const subs = sub.subs;
 				if (sub.update()) {
-					if (subs.nextSub !== void 0) shallowPropagate(subs);
+					const subs = sub.subs;
+					if (subs !== void 0 && (subs !== link || subs.nextSub !== void 0)) shallowPropagate(subs);
 					sub = link.sub;
 					continue;
 				}
-			} else sub.flags &= -33;
+			} else if (stale) sub.flags = sub.flags & -545 | 16;
+			else sub.flags &= -545;
 			sub = link.sub;
 			if (link.nextDep !== void 0) {
 				link = link.nextDep;
@@ -670,9 +707,21 @@ function checkDirty(link, sub) {
 			}
 			dirty = false;
 		}
-		return dirty && !!sub.flags;
+		return (dirty || !!(sub.flags & 16)) && !!sub.flags;
 	} while (true);
 }
+function checkingDepth(dep, stack, depth) {
+	for (; stack !== void 0; stack = stack.prev, --depth) if (stack.value.dep === dep) return depth;
+	return -1;
+}
+function markStale(sub) {
+	const nodes = [sub];
+	do {
+		sub = nodes.pop();
+		sub.flags = sub.flags & -33 | 16;
+		for (let link = sub.deps; link !== void 0; link = link.nextDep) if (link.dep.flags & 32) nodes.push(link.dep);
+	} while (nodes.length);
+}
 function shallowPropagate(link) {
 	do {
 		const sub = link.sub;
@@ -690,6 +739,19 @@ function isValidLink(checkLink, sub) {
 	}
 	return false;
 }
+function markRecursed(sub) {
+	const nodes = [sub];
+	do {
+		sub = nodes.pop();
+		for (let link = sub.deps; link !== void 0; link = link.nextDep) {
+			const dep = link.dep;
+			if ((dep.flags & 40) === 32) {
+				dep.flags |= 8;
+				nodes.push(dep);
+			}
+		}
+	} while (nodes.length);
+}
 //#endregion
 //#region packages/reactivity/src/dep.ts
 var Dep = class {
@@ -992,7 +1054,7 @@ function noTracking(self, method, args = []) {
 //#endregion
 //#region packages/reactivity/src/baseHandlers.ts
 const isNonTrackableKeys = /*@__PURE__*/ makeMap(`__proto__,__v_isRef,__isVue`);
-const builtInSymbols = new Set(/*@__PURE__*/ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol));
+const builtInSymbols = /*@__PURE__*/ new Set(/*@__PURE__*/ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol));
 function hasOwnProperty(key) {
 	if (!isSymbol(key)) key = String(key);
 	const obj = /* @__PURE__ */ toRaw(this);
@@ -1781,6 +1843,10 @@ var ReactiveEffect = class {
 	get active() {
 		return !(this.flags & 1024);
 	}
+	/** @internal */
+	get running() {
+		return !!(this.flags & 4);
+	}
 	pause() {
 		this.flags |= 256;
 	}
@@ -1794,11 +1860,9 @@ var ReactiveEffect = class {
 		if (!this.active) return this.fn();
 		cleanup(this);
 		const prevSub = startTracking(this);
-		incRunDepth();
 		try {
 			return this.fn();
 		} finally {
-			decRunDepth();
 			endTracking(this, prevSub);
 			const flags = this.flags;
 			if ((flags & 136) === 136) {
@@ -1821,9 +1885,9 @@ var ReactiveEffect = class {
 		if (flags & 16) return true;
 		if (flags & 32) {
 			if (checkDirty(this.deps, this)) {
-				this.flags = flags | 16;
+				if (this.active) this.flags |= 16;
 				return true;
-			} else this.flags = flags & -33;
+			} else this.flags &= -33;
 		}
 		return false;
 	}
@@ -1834,20 +1898,15 @@ function effect(fn, options) {
 	if (options) {
 		const { onStop, scheduler } = options;
 		if (onStop) {
-			options.onStop = void 0;
 			const stop = e.stop.bind(e);
 			e.stop = () => {
 				stop();
 				onStop();
 			};
 		}
-		if (scheduler) {
-			options.scheduler = void 0;
-			e.notify = () => {
-				if (!(e.flags & 256)) scheduler();
-			};
-		}
-		extend(e, options);
+		if (scheduler) e.notify = () => {
+			if (!(e.flags & 1280)) scheduler();
+		};
 	}
 	try {
 		e.run();
@@ -1907,8 +1966,10 @@ var EffectScope = class {
 		const flags = this.flags;
 		if (flags & 256) {
 			this.flags = flags & -257;
-			for (let link = this.deps; link !== void 0; link = link.nextDep) {
-				const dep = link.dep;
+			const deps = [];
+			for (let link = this.deps; link !== void 0; link = link.nextDep) deps.push(link.dep);
+			for (let i = 0; i < deps.length; i++) {
+				const dep = deps[i];
 				if ("resume" in dep) dep.resume();
 			}
 		}
@@ -1937,8 +1998,10 @@ var EffectScope = class {
 		while (dep !== void 0) {
 			const node = dep.dep;
 			if ("stop" in node) {
-				dep = dep.nextDep;
+				const prev = dep.prevDep;
 				node.stop();
+				const next = prev !== void 0 ? prev.nextDep : this.deps;
+				dep = next === dep ? dep.nextDep : next;
 			} else dep = unlink(dep, this);
 		}
 		cleanup(this);
@@ -1979,10 +2042,14 @@ function setCurrentScope(scope) {
 * @see {@link https://vuejs.org/api/reactivity-advanced.html#onscopedispose}
 */
 function onScopeDispose(fn, failSilently = false) {
-	if (activeEffectScope !== void 0) activeEffectScope.cleanups[activeEffectScope.cleanupsLength++] = fn;
+	if (activeEffectScope !== void 0) {
+		if (activeEffectScope.active) activeEffectScope.cleanups[activeEffectScope.cleanupsLength++] = fn;
+		else fn();
+	}
 }
 //#endregion
 //#region packages/reactivity/src/computed.ts
+const FAILED = 64;
 /**
 * @private exported by @vue/reactivity for Vue core use, but not exported from
 * the main vue package
@@ -2031,14 +2098,31 @@ var ComputedRefImpl = class {
 	}
 	get value() {
 		const flags = this.flags;
-		if (flags & 16 || flags & 32 && checkDirty(this.deps, this)) {
-			if (this.update()) {
-				const subs = this.subs;
-				if (subs !== void 0) shallowPropagate(subs);
-			}
-		} else if (flags & 32) this.flags = flags & -33;
+		try {
+			if (flags & 16 || flags & 32 && checkDirty(this.deps, this)) {
+				if (this.update()) {
+					const subs = this.subs;
+					if (subs !== void 0) shallowPropagate(subs);
+				}
+			} else if (flags & 32) this.flags = flags & -33;
+		} catch (err) {
+			if (activeSub !== void 0) link(this, activeSub);
+			else if (activeEffectScope !== void 0) link(this, activeEffectScope);
+			throw err;
+		}
 		if (activeSub !== void 0) link(this, activeSub);
-		else if (activeEffectScope !== void 0) link(this, activeEffectScope);
+		else if (activeEffectScope !== void 0) {
+			if (activeEffectScope.active) link(this, activeEffectScope);
+			else if (this.subs === void 0) {
+				let dep = this.deps;
+				if (dep !== void 0) {
+					do
+						dep = unlink(dep, this);
+					while (dep !== void 0);
+					this.flags |= 16;
+				}
+			}
+		}
 		return this._value;
 	}
 	set value(newValue) {
@@ -2049,11 +2133,15 @@ var ComputedRefImpl = class {
 		try {
 			const oldValue = this._value;
 			const newValue = this.fn(oldValue);
-			if (hasChanged(oldValue, newValue)) {
+			if (hasChanged(oldValue, newValue) || this.flags & FAILED) {
 				this._value = newValue;
+				this.flags &= -65;
 				return true;
 			}
 			return false;
+		} catch (err) {
+			this.flags |= FAILED;
+			throw err;
 		} finally {
 			endTracking(this, prevSub);
 		}
@@ -2068,7 +2156,9 @@ function computed$1(getterOrOptions, debugOptions, isSSR = false) {
 		getter = getterOrOptions.get;
 		setter = getterOrOptions.set;
 	}
-	return new ComputedRefImpl(getter, setter);
+	const cRef = new ComputedRefImpl(getter, setter);
+	if (isSSR && activeEffectScope !== void 0) link(cRef, activeEffectScope);
+	return cRef;
 }
 //#endregion
 //#region packages/reactivity/src/constants.ts
@@ -2332,7 +2422,7 @@ function callWithAsyncErrorHandling(fn, instance, type, args) {
 	if (isFunction(fn)) {
 		const res = callWithErrorHandling(fn, instance, type, args);
 		if (res && isPromise(res)) res.catch((err) => {
-			handleError(err, instance, type);
+			handleError(err, instance, type, void 0, true);
 		});
 		return res;
 	}
@@ -2342,7 +2432,7 @@ function callWithAsyncErrorHandling(fn, instance, type, args) {
 		return values;
 	}
 }
-function handleError(err, instance, type, throwInDev = true) {
+function handleError(err, instance, type, throwInDev = true, isAsyncError = false) {
 	const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
 	if (instance) {
 		let cur = instance.parent;
@@ -2350,7 +2440,7 @@ function handleError(err, instance, type, throwInDev = true) {
 		const errorInfo = `https://vuejs.org/error-reference/#runtime-${type}`;
 		while (cur) {
 			const errorCapturedHooks = cur.ec;
-			if (errorCapturedHooks) {
+			if (errorCapturedHooks && !cur.isUnmounted && (!isAsyncError || cur.scope.active)) {
 				for (let i = 0; i < errorCapturedHooks.length; i++) if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) return;
 			}
 			cur = cur.parent;
@@ -2805,11 +2895,28 @@ function withDirectives(vnode, directives) {
 	return vnode;
 }
 function invokeDirectiveHook(vnode, prevVNode, instance, name) {
-	const bindings = vnode.dirs;
+	let hookVNode = vnode;
+	if (name === "beforeMount") vnode._mount = vnode;
+	else if (name === "beforeUpdate") {
+		const mount = prevVNode && prevVNode._mount;
+		if (mount) {
+			mount._latest = vnode;
+			vnode._mount = mount;
+		}
+	} else if (name === "mounted") {
+		const latest = vnode._latest;
+		vnode._mount = vnode._latest = void 0;
+		if (latest) {
+			hookVNode = latest;
+			latest._mount = void 0;
+		}
+	}
+	const bindings = hookVNode.dirs;
 	const oldBindings = prevVNode && prevVNode.dirs;
 	for (let i = 0; i < bindings.length; i++) {
-		const binding = bindings[i];
+		let binding = bindings[i];
 		if (oldBindings) binding.oldValue = oldBindings[i].value;
+		else if (name === "mounted" && binding.oldValue !== void 0) binding = extend({}, binding, { oldValue: void 0 });
 		let hook = binding.dir[name];
 		if (!hook) hook = mapCompatDirectiveHook(name, binding.dir, instance);
 		if (hook) {
@@ -2817,7 +2924,7 @@ function invokeDirectiveHook(vnode, prevVNode, instance, name) {
 			callWithAsyncErrorHandling(hook, instance, 8, [
 				vnode.el,
 				binding,
-				vnode,
+				hookVNode,
 				prevVNode
 			]);
 			setActiveSub(prevSub);
@@ -3237,7 +3344,15 @@ const BaseTransitionImpl = {
 			const rawProps = /* @__PURE__ */ toRaw(props);
 			const { mode } = rawProps;
 			return prepareTransitionSwitch(instance.subTree, child, rawProps, state, instance, mode === "out-in" ? resumeAfterLeave || (resumeAfterLeave = () => {
-				if (!(instance.effect.flags & 1024)) instance.update();
+				if (!(instance.effect.flags & 1024)) {
+					if (instance.effect.running) {
+						const job = () => {
+							if (!(instance.effect.flags & 1024)) instance.update();
+						};
+						job.i = instance;
+						queueJob(job);
+					} else instance.update();
+				}
 			}) : NOOP);
 		};
 	}
@@ -3263,7 +3378,7 @@ function getLeavingNodesForType(state, vnode) {
 	}
 	return leavingVNodesCache;
 }
-function resolveTransitionHooks(vnode, props, state, instance, postClone) {
+function resolveTransitionHooks(vnode, props, state, instance) {
 	const key = String(vnode.key);
 	const leavingVNodesCache = getLeavingNodesForType(state, vnode);
 	const hooks = baseResolveTransitionHooks({
@@ -3286,9 +3401,7 @@ function resolveTransitionHooks(vnode, props, state, instance, postClone) {
 			}
 		},
 		cloneHooks: (vnode) => {
-			const hooks = resolveTransitionHooks(vnode, props, state, instance, postClone);
-			if (postClone) postClone(hooks);
-			return hooks;
+			return resolveTransitionHooks(vnode, props, state, instance);
 		}
 	}, props, state, instance);
 	if (isVaporInteropEnabled && vnode.type === VaporSlot) extend(hooks, {
@@ -3326,7 +3439,7 @@ function baseResolveTransitionHooks(context, props, state, instance) {
 			callHook(hook, [el]);
 		},
 		enter(el) {
-			if (isLeaving()) return;
+			if (isLeaving(el)) return;
 			let hook = onEnter;
 			let afterHook = onAfterEnter;
 			let cancelHook = onEnterCancelled;
@@ -3370,7 +3483,19 @@ function baseResolveTransitionHooks(context, props, state, instance) {
 			else done();
 		},
 		clone(node) {
-			return cloneHooks ? cloneHooks(node) : hooks;
+			if (!cloneHooks) return hooks;
+			const cloned = cloneHooks(node);
+			cloned.afterLeave = () => {
+				if (hooks.afterLeave) hooks.afterLeave();
+			};
+			cloned.delayLeave = (el, earlyRemove, delayedLeave) => {
+				if (hooks.delayLeave) hooks.delayLeave(el, earlyRemove, delayedLeave);
+				else delayedLeave();
+			};
+			cloned.delayedLeave = () => {
+				if (hooks.delayedLeave) hooks.delayedLeave();
+			};
+			return cloned;
 		}
 	};
 	return hooks;
@@ -3405,10 +3530,7 @@ function prepareTransitionSwitch(previous, next, props, state, instance, resumeA
 	if (state.isLeaving) return emptyPlaceholder(next);
 	const nextInner = getInnerChild$1(next);
 	if (!nextInner) return emptyPlaceholder(next);
-	let enterHooks = resolveTransitionHooks(nextInner, props, state, instance, (hooks) => {
-		if (delayedLeaveSource) forwardDelayedLeave(hooks, delayedLeaveSource);
-		enterHooks = hooks;
-	});
+	const enterHooks = resolveTransitionHooks(nextInner, props, state, instance);
 	if (delayedLeaveSource) forwardDelayedLeave(enterHooks, delayedLeaveSource);
 	if (nextInner.type !== Comment) setTransitionHooks(nextInner, enterHooks);
 	const mode = props.mode;
@@ -3474,9 +3596,14 @@ function setTransitionHooks(vnode, hooks) {
 			return setTransitionHooks(isTeleport(subTree.type) ? getInnerChild$1(subTree) || subTree : subTree, hooks);
 		}
 	} else if (vnode.shapeFlag & 128) {
-		const contentHooks = vnode.ssContent.transition = hooks.clone(vnode.ssContent);
-		const fallbackHooks = vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
-		return vnode.suspense && vnode.suspense.activeBranch === vnode.ssFallback ? fallbackHooks : contentHooks;
+		const suspense = vnode.suspense;
+		if (suspense) {
+			const branch = suspense.isHydrating ? suspense.pendingBranch : suspense.activeBranch;
+			if (branch) return setTransitionHooks(branch, hooks.clone(branch));
+		} else {
+			vnode.ssContent.transition = hooks.clone(vnode.ssContent);
+			vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
+		}
 	} else {
 		vnode.transition = hooks;
 		if (vnode.type === Fragment && isArray(vnode.children)) {
@@ -3676,6 +3803,8 @@ const getContainerType = (container) => {
 	if (isMathMLContainer(container)) return "mathml";
 };
 const isComment = (node) => node.nodeType === 8;
+/** The data of a comment opening a range a hydration steps over as one. */
+const isRangeStart = (data) => data === "[" || data === "(" || isVaporRangeStart(data);
 function createHydrationFunctions(rendererInternals) {
 	const { mt: mountComponent, p: patch, o: { patchProp, createText, nextSibling, parentNode, remove, insert, createComment } } = rendererInternals;
 	const hydrate = (vnode, container) => {
@@ -3692,7 +3821,7 @@ function createHydrationFunctions(rendererInternals) {
 	};
 	const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => {
 		optimized = optimized || !!vnode.dynamicChildren;
-		const isFragmentStart = isComment(node) && (node.data === "[" || node.data === "(");
+		const isFragmentStart = isComment(node) && (node.data === "[" || node.data === "(" || isVaporInteropEnabled && isVaporRangeStart(node.data));
 		const onMismatch = () => handleMismatch(node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragmentStart);
 		const { type, ref, shapeFlag, patchFlag } = vnode;
 		let domType = node.nodeType;
@@ -3869,10 +3998,11 @@ function createHydrationFunctions(rendererInternals) {
 		const container = parentNode(node);
 		const first = nextSibling(node);
 		const next = isVaporInteropEnabled && vnode.vo && node.data === "(" ? getVaporInterface(parentComponent, vnode).hydrateSlotOutlet(vnode, node, parentComponent, parentSuspense, slotScopeIds) : hydrateChildren(first, vnode, container, parentComponent, parentSuspense, slotScopeIds, optimized);
-		if (next && isComment(next) && next.data === (node.data === "(" ? ")" : "]")) return nextSibling(vnode.anchor = next);
+		const close = isVaporInteropEnabled ? rangeCloseOf(node.data) : node.data === "(" ? ")" : "]";
+		if (next && isComment(next) && next.data === close) return nextSibling(vnode.anchor = next);
 		else {
 			logMismatchError();
-			insert(vnode.anchor = createComment(`]`), container, next);
+			insert(vnode.anchor = createComment(close), container, next);
 			return next;
 		}
 	};
@@ -3891,18 +4021,18 @@ function createHydrationFunctions(rendererInternals) {
 		const container = parentNode(node);
 		remove(node);
 		patch(null, vnode, container, next, parentComponent, parentSuspense, getContainerType(container), slotScopeIds);
-		if (parentComponent && parentComponent.vnode) {
+		if (parentComponent && parentComponent.vnode && parentComponent.vnode.el === node) {
 			parentComponent.vnode.el = vnode.el;
 			updateHOCHostEl(parentComponent, vnode.el);
 		}
 		return next;
 	};
-	const locateClosingAnchor = (node, open = node && isComment(node) && node.data === "(" ? "(" : "[", close = open === "(" ? ")" : "]") => {
+	const locateClosingAnchor = (node, open = node && isComment(node) && (node.data === "(" || isVaporInteropEnabled && node.data === "{") ? node.data : "[", close = isVaporInteropEnabled ? rangeCloseOf(open) : open === "(" ? ")" : "]") => {
 		let match = 0;
 		while (node) {
 			node = nextSibling(node);
 			if (node && isComment(node)) {
-				if (node.data === open) match++;
+				if (node.data === open || isVaporInteropEnabled && open === "[" && isVaporBranchStart(node.data)) match++;
 				if (node.data === close) {
 					if (match === 0) return nextSibling(node);
 					else match--;
@@ -4045,9 +4175,9 @@ const hydrateOnInteraction = (interactions = []) => (hydrate, forEach) => {
 	return teardown;
 };
 function forEachElement(node, cb) {
-	if (isComment(node) && (node.data === "[" || node.data === "(")) {
+	if (isComment(node) && isRangeStart(node.data)) {
 		const open = node.data;
-		const close = open === "[" ? "]" : ")";
+		const close = rangeCloseOf(open);
 		let depth = 1;
 		let next = node.nextSibling;
 		while (next) {
@@ -4056,7 +4186,7 @@ function forEachElement(node, cb) {
 			} else if (isComment(next)) {
 				if (next.data === close) {
 					if (--depth === 0) break;
-				} else if (next.data === open) depth++;
+				} else if (close === "]" ? next.data === "[" || isVaporBranchStart(next.data) : next.data === open) depth++;
 			}
 			next = next.nextSibling;
 		}
@@ -4084,7 +4214,7 @@ function defineAsyncComponent(source) {
 			if (resolvedComp) return () => createInnerComp(resolvedComp, instance);
 			const onError = (err) => {
 				setPendingRequest(null);
-				handleError(err, instance, 13, !errorComponent);
+				handleError(err, instance, 13, !errorComponent, true);
 			};
 			if (suspensible && instance.suspense || isInSSRComponentSetup) return load().then((comp) => {
 				return () => createInnerComp(comp, instance);
@@ -4163,10 +4293,12 @@ const useAsyncComponentState = (delay = 200, timeout, onError, instance = curren
 	const delayed = /* @__PURE__ */ ref(!!delay);
 	let timeoutTimer;
 	let delayTimer;
-	if (instance) onUnmounted(() => {
-		if (timeoutTimer != null) clearTimeout(timeoutTimer);
-		if (delayTimer != null) clearTimeout(delayTimer);
-	}, instance);
+	if (instance) instance.scope.run(() => {
+		onScopeDispose(() => {
+			if (timeoutTimer != null) clearTimeout(timeoutTimer);
+			if (delayTimer != null) clearTimeout(delayTimer);
+		});
+	});
 	if (delay) delayTimer = setTimeout(() => {
 		if (instance && instance.isUnmounted) return;
 		delayed.value = false;
@@ -4195,7 +4327,12 @@ function performAsyncHydrate(el, instance, hydrate, getResolvedComp, load, hydra
 	if (skipIfUpdated) (instance.bu || (instance.bu = [])).push(() => patched = true);
 	const performHydrate = () => {
 		if (patched) return;
-		if (!el.parentNode || wasConnected && !el.isConnected) return;
+		if (!el.parentNode) return;
+		if (wasConnected && !el.isConnected) {
+			let current = instance;
+			while (current && !current.isDeactivated) current = current.parent;
+			if (!current) return;
+		}
 		hydrate();
 	};
 	const doHydrate = hydrateStrategy ? () => {
@@ -4252,7 +4389,11 @@ const KeepAliveImpl = {
 			activate(vnode, container, anchor, renderer, keepAliveInstance, parentSuspense, namespace, optimized);
 		};
 		sharedContext.deactivate = (vnode) => {
-			deactivate(vnode, storageContainer, renderer, keepAliveInstance, parentSuspense);
+			const cached = sharedContext.getCachedComponent(vnode);
+			if (!cached || cached.component !== vnode.component) return false;
+			if (isVaporInteropEnabled && isVaporComponent(vnode.type)) getVaporInterface(keepAliveInstance, vnode).deactivate(vnode, storageContainer, parentSuspense);
+			else deactivate(vnode, storageContainer, renderer, keepAliveInstance, parentSuspense);
+			return true;
 		};
 		function unmount(vnode) {
 			resetShapeFlag(vnode);
@@ -4284,11 +4425,15 @@ const KeepAliveImpl = {
 		let pendingCacheKey = null;
 		const cacheSubtree = () => {
 			if (pendingCacheKey != null) {
-				if (isSuspense(keepAliveInstance.subTree.type)) queuePostRenderEffect(() => {
-					const vnode = getInnerChild(keepAliveInstance.subTree);
-					if (vnode.component) cache.set(pendingCacheKey, vnode);
-				}, void 0, keepAliveInstance.subTree.suspense);
-				else cache.set(pendingCacheKey, getInnerChild(keepAliveInstance.subTree));
+				if (isSuspense(keepAliveInstance.subTree.type)) {
+					const cacheInnerChild = () => {
+						const vnode = getInnerChild(keepAliveInstance.subTree);
+						if (vnode.component) cache.set(pendingCacheKey, vnode);
+					};
+					const suspense = keepAliveInstance.subTree.suspense;
+					if (suspense.pendingBranch) queuePostRenderEffect(cacheInnerChild, void 0, suspense);
+					else cacheInnerChild();
+				} else cache.set(pendingCacheKey, getInnerChild(keepAliveInstance.subTree));
 			}
 		};
 		onMounted(cacheSubtree);
@@ -4397,9 +4542,8 @@ function registerKeepAliveHook(hook, type, target = getCurrentGenericInstance())
 }
 function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
 	const injected = injectHook(type, hook, keepAliveRoot, true);
-	onUnmounted(() => {
-		remove(keepAliveRoot[type], injected);
-	}, target);
+	const removal = injectHook("um", () => remove(keepAliveRoot[type], injected), target);
+	removal.flags = 8;
 }
 function resetShapeFlag(vnode) {
 	vnode.shapeFlag &= -257;
@@ -4830,6 +4974,11 @@ function renderSlot(slots, name, props, fallback, noSlotted, branchKey) {
 			ret.props = extend({}, ret.props, { key: branchKey });
 			ret.key = branchKey;
 		}
+		if (isBlockTreeEnabled <= 0) {
+			if (!ret.vs.props) ret.vs.props = ret.props;
+			ret.props = ret.key != null ? { key: ret.key } : null;
+			ret.vs.attrs = EMPTY_OBJ;
+		}
 		if (!noSlotted && ret.scopeId) ret.slotScopeIds = [ret.scopeId + "-s"];
 		return ret;
 	}
@@ -5619,7 +5768,7 @@ function createCompatVue$1(createApp, createSingletonApp) {
 		if (options.el) return vm.$mount(options.el);
 		else return vm;
 	}
-	Vue.version = `2.6.14-compat:3.6.0-rc.13`;
+	Vue.version = `2.6.14-compat:3.6.0-rc.15`;
 	Vue.config = singletonApp.config;
 	Vue.use = (plugin, ...options) => {
 		if (plugin && isFunction(plugin.install)) plugin.install(Vue, ...options);
@@ -6735,8 +6884,10 @@ function baseCreateRenderer(options, createHydrationFns) {
 			if (vnodeHook = props.onVnodeBeforeMount) invokeVNodeHook(vnodeHook, parentComponent, vnode);
 		}
 		if (dirs) invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
-		if (transition) performTransitionEnter(el, transition, () => hostInsert(el, container, anchor), parentSuspense);
-		else hostInsert(el, container, anchor);
+		if (transition) {
+			if (!needTransition(parentSuspense, transition) && !transition.persisted) el[deferredEnterKey] = true;
+			performTransitionEnter(el, transition, () => hostInsert(el, container, anchor), parentSuspense);
+		} else hostInsert(el, container, anchor);
 		if ((vnodeHook = props && props.onVnodeMounted) || dirs) queuePostRenderEffect(() => {
 			try {
 				vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
@@ -6961,16 +7112,20 @@ function baseCreateRenderer(options, createHydrationFns) {
 			} else {
 				let { next, bu, u, parent, vnode } = instance;
 				{
-					const nonHydratedAsyncRoot = locateNonHydratedAsyncRoot(instance);
-					if (nonHydratedAsyncRoot) {
+					const unresolvedAsyncRoot = locateUnresolvedAsyncRoot(instance);
+					if (unresolvedAsyncRoot) {
 						if (next) {
 							next.el = vnode.el;
 							updateComponentPreRender(instance, next, optimized);
 						}
-						nonHydratedAsyncRoot.asyncDep.then(() => {
-							queuePostRenderEffect(() => {
-								if (!instance.isUnmounted) instance.update();
-							}, void 0, parentSuspense);
+						unresolvedAsyncRoot.asyncDep.then(() => {
+							const retry = () => {
+								if (instance.effect.flags & 1024) return;
+								if (parentSuspense && parentSuspense.pendingBranch) queuePostRenderEffect(retry, void 0, parentSuspense);
+								else instance.update();
+							};
+							retry.flags = 24;
+							queuePostRenderEffect(retry, void 0, parentSuspense);
 						});
 						return;
 					}
@@ -6990,7 +7145,7 @@ function baseCreateRenderer(options, createHydrationFns) {
 				const nextTree = renderComponentRoot(instance);
 				const prevTree = instance.subTree;
 				instance.subTree = nextTree;
-				patch(prevTree, nextTree, hostParentNode(prevTree.el), getNextHostNode(prevTree), instance, parentSuspense, namespace);
+				patch(prevTree, nextTree, hostParentNode(prevTree.el || resolveAsyncComponentPlaceholder(prevTree)), getNextHostNode(prevTree), instance, parentSuspense, namespace);
 				next.el = nextTree.el;
 				if (originNext === null) updateHOCHostEl(instance, nextTree.el);
 				if (u) queuePostRenderEffect(u, void 0, parentSuspense);
@@ -7188,9 +7343,7 @@ function baseCreateRenderer(options, createHydrationFns) {
 		}
 		if (cacheIndex != null && (!vnode.ctx || vnode.ctx === parentComponent)) parentComponent.renderCache[cacheIndex] = void 0;
 		if (shapeFlag & 256) {
-			if (isVaporInteropEnabled && isVaporComponent(vnode.type)) getVaporInterface(parentComponent, vnode).deactivate(vnode, parentComponent.ctx.getStorageContainer(), parentSuspense);
-			else parentComponent.ctx.deactivate(vnode);
-			return;
+			if (parentComponent.ctx.deactivate(vnode)) return;
 		}
 		if (isVaporInteropEnabled && shapeFlag & 6 && isVaporComponent(type)) {
 			getVaporInterface(parentComponent, vnode).unmount(vnode, doRemove, parentSuspense);
@@ -7270,13 +7423,15 @@ function baseCreateRenderer(options, createHydrationFns) {
 		if (effect) {
 			effect.stop();
 			unmount(subTree, instance, parentSuspense, doRemove);
-		} else if (instance.vnode.el && subTree) {
+		} else if (subTree) {
 			subTree.transition = instance.vnode.transition;
 			unmount(subTree, instance, parentSuspense, doRemove);
 		}
 		if (um) queuePostRenderEffect(um, void 0, parentSuspense);
 		if (isCompatEnabled$1("INSTANCE_EVENT_HOOKS", instance)) queuePostRenderEffect(() => instance.emit("hook:destroyed"), void 0, parentSuspense);
-		queuePostRenderEffect(() => instance.isUnmounted = true, void 0, parentSuspense);
+		const markUnmounted = () => instance.isUnmounted = true;
+		markUnmounted.flags = 8;
+		queuePostRenderEffect(markUnmounted, void 0, parentSuspense);
 	};
 	const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {
 		for (let i = start; i < children.length; i++) unmount(children[i], parentComponent, parentSuspense, doRemove, optimized);
@@ -7383,11 +7538,11 @@ function traverseStaticChildren(n1, n2, shallow = false) {
 		if (c2.type === Comment && !c2.el) c2.el = c1.el;
 	}
 }
-function locateNonHydratedAsyncRoot(instance) {
+function locateUnresolvedAsyncRoot(instance) {
 	const subComponent = instance.subTree && instance.subTree.component;
 	if (subComponent) {
 		if (subComponent.asyncDep && !subComponent.asyncResolved) return subComponent;
-		else return locateNonHydratedAsyncRoot(subComponent);
+		else return locateUnresolvedAsyncRoot(subComponent);
 	}
 }
 function invalidateMount(hooks) {
@@ -7453,7 +7608,9 @@ function getInheritedScopeIds(vnode, parentComponent, includeVaporRootIds = true
 function resolveAsyncComponentPlaceholder(anchorVnode) {
 	if (anchorVnode.placeholder) return anchorVnode.placeholder;
 	const instance = anchorVnode.component;
-	if (instance) return resolveAsyncComponentPlaceholder(instance.subTree);
+	if (instance && instance.subTree) return resolveAsyncComponentPlaceholder(instance.subTree);
+	const suspense = anchorVnode.suspense;
+	if (suspense && suspense.activeBranch) return resolveAsyncComponentPlaceholder(suspense.activeBranch);
 	return null;
 }
 //#endregion
@@ -7465,17 +7622,22 @@ function withSuspenseEnabled(value) {
 	return value;
 }
 let suspenseId = 0;
+const deferredEnterKey = Symbol("_deferredEnter");
 const Suspense = /*@__PURE__*/ withSuspenseEnabled({
 	name: "Suspense",
 	__isSuspense: true,
 	process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
 		if (n1 == null) mountSuspense(n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals);
 		else {
-			if (parentSuspense && parentSuspense.deps > 0 && !n1.suspense.isInFallback && !parentSuspense.isHydrating) {
-				n2.suspense = n1.suspense;
-				n2.suspense.vnode = n2;
-				n2.el = n1.el;
-				return;
+			const suspense = n1.suspense;
+			if (parentSuspense && parentSuspense.deps > 0 && !parentSuspense.isHydrating) {
+				const owner = suspense.parentComponent;
+				if (!!owner && owner.suspense === parentSuspense && owner.suspenseId !== parentSuspense.pendingId ? parentSuspense.pendingBranch && !isSameVNodeType(n2.ssContent, suspense.pendingBranch || suspense.activeBranch) : !suspense.isInFallback) {
+					n2.suspense = suspense;
+					suspense.vnode = n2;
+					n2.el = n1.el;
+					return;
+				}
 			}
 			patchSuspense(n1, n2, container, anchor, parentComponent, namespace, slotScopeIds, optimized, rendererInternals);
 		}
@@ -7487,6 +7649,36 @@ function triggerEvent(vnode, name) {
 	const eventListener = vnode.props && vnode.props[name];
 	if (isFunction(eventListener)) eventListener();
 }
+function enterDeferred(suspense, branch) {
+	const enters = [];
+	collectDeferredEnters(branch, enters, true);
+	if (isVaporInteropEnabled) {
+		const { parentComponent } = suspense;
+		const vapor = parentComponent && parentComponent.appContext.vapor;
+		if (vapor) vapor.enterDeferred(suspense, enters);
+	}
+	if (enters.length) queuePostFlushCb(enters);
+}
+function collectDeferredEnters(vnode, enters, isRoot) {
+	const { el, transition, children, shapeFlag } = vnode;
+	if (shapeFlag & 6) {
+		const subTree = vnode.component.subTree;
+		if (subTree) collectDeferredEnters(subTree, enters, isRoot);
+		return;
+	}
+	if (shapeFlag & 192) return;
+	if (shapeFlag & 1) {
+		if (!isRoot && el && el[deferredEnterKey]) {
+			el[deferredEnterKey] = void 0;
+			if (transition && !transition.persisted) {
+				transition.beforeEnter(el);
+				enters.push(() => transition.enter(el));
+			}
+		}
+		isRoot = false;
+	}
+	if (shapeFlag & 16) for (let i = 0; i < children.length; i++) collectDeferredEnters(children[i], enters, isRoot);
+}
 function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
 	const { p: patch, o: { createElement } } = rendererInternals;
 	const hiddenContainer = createElement("div");
@@ -7526,11 +7718,7 @@ function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, sl
 				suspense.activeBranch = pendingBranch;
 			} else unmount(pendingBranch, parentComponent, suspense);
 			suspense.deps = 0;
-			for (let i = 0; i < suspense.effects.length; i++) {
-				const effect = suspense.effects[i];
-				if (effect.flags & 8) queuePostFlushCb(effect);
-			}
-			suspense.effects.length = 0;
+			discardEffects(suspense);
 			suspense.hiddenContainer = createElement("div");
 			if (isInFallback) {
 				patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, namespace, slotScopeIds, optimized);
@@ -7553,14 +7741,14 @@ function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, sl
 	} else {
 		triggerEvent(n2, "onPending");
 		suspense.pendingBranch = newBranch;
-		if (newBranch.shapeFlag & 512) suspense.pendingId = newBranch.component.suspenseId;
-		else suspense.pendingId = suspenseId++;
+		suspense.pendingId = suspenseId++;
 		patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, namespace, slotScopeIds, optimized);
 		if (suspense.deps <= 0) suspense.resolve();
 		else {
-			const { timeout, pendingId } = suspense;
-			if (timeout > 0) setTimeout(() => {
-				if (suspense.pendingId === pendingId) suspense.fallback(newFallback);
+			const { timeout } = suspense;
+			if (timeout > 0) suspense.timeoutTimer = setTimeout(() => {
+				suspense.timeoutTimer = void 0;
+				suspense.fallback(suspense.vnode.ssFallback);
 			}, timeout);
 			else if (timeout === 0) suspense.fallback(newFallback);
 		}
@@ -7589,6 +7777,7 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
 		deps: 0,
 		pendingId: suspenseId++,
 		timeout: typeof timeout === "number" ? timeout : -1,
+		timeoutTimer: void 0,
 		activeBranch: null,
 		isFallbackMountPending: false,
 		pendingBranch: null,
@@ -7604,26 +7793,39 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
 				delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === "out-in";
 				let hasUpdatedAnchor = false;
 				if (delayEnter) activeBranch.transition.afterLeave = () => {
-					if (pendingId === suspense.pendingId) {
+					if (pendingId === suspense.pendingId && !suspense.isUnmounted) {
+						enterDeferred(suspense, pendingBranch);
 						move(pendingBranch, container, anchor === initialAnchor && !hasUpdatedAnchor ? next(activeBranch) : anchor, 0, parentComponent);
 						queuePostFlushCb(effects);
 						if (isInFallback && vnode.ssFallback) vnode.ssFallback.el = null;
 					}
 				};
 				if (activeBranch && !suspense.isFallbackMountPending) {
-					if (parentNode(activeBranch.el) === container) {
+					if (parentNode(activeBranch.el || resolveAsyncComponentPlaceholder(activeBranch)) === container) {
 						anchor = next(activeBranch);
 						hasUpdatedAnchor = true;
 					}
 					unmount(activeBranch, parentComponent, suspense, true);
 					if (!delayEnter && isInFallback && vnode.ssFallback) queuePostRenderEffect(() => vnode.ssFallback.el = null, void 0, suspense);
 				}
-				if (!delayEnter) move(pendingBranch, container, anchor, 0, parentComponent);
+				if (!delayEnter) {
+					enterDeferred(suspense, pendingBranch);
+					move(pendingBranch, container, anchor, 0, parentComponent);
+				}
 			}
+			clearTimeout(suspense.timeoutTimer);
+			suspense.timeoutTimer = void 0;
 			suspense.isFallbackMountPending = false;
 			setActiveBranch(suspense, pendingBranch);
 			suspense.pendingBranch = null;
 			suspense.isInFallback = false;
+			let kept = 0;
+			for (let i = 0; i < effects.length; i++) {
+				const effect = effects[i];
+				if (effect.flags & 16) queuePostFlushCb(effect);
+				else effects[kept++] = effect;
+			}
+			effects.length = kept;
 			let parent = suspense.parent;
 			let hasUnresolvedAncestor = false;
 			while (parent) {
@@ -7646,13 +7848,13 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
 			triggerEvent(vnode, "onResolve");
 		},
 		fallback(fallbackVNode) {
-			if (!suspense.pendingBranch) return;
+			if (suspense.isUnmounted || !suspense.pendingBranch) return;
 			const { vnode, activeBranch, parentComponent, container, namespace } = suspense;
 			triggerEvent(vnode, "onFallback");
 			const anchor = next(activeBranch);
 			const mountFallback = () => {
 				suspense.isFallbackMountPending = false;
-				if (!suspense.isInFallback) return;
+				if (suspense.isUnmounted || !suspense.isInFallback) return;
 				const latestFallback = suspense.vnode.ssFallback;
 				patch(null, latestFallback, container, anchor, parentComponent, null, namespace, slotScopeIds, optimized);
 				setActiveBranch(suspense, latestFallback);
@@ -7676,24 +7878,52 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
 		registerDep(instance, onResolve) {
 			const isInPendingSuspense = !!suspense.pendingBranch;
 			if (isInPendingSuspense) suspense.deps++;
+			const render = (setupResult) => {
+				instance.asyncResolved = true;
+				onResolve(setupResult);
+			};
 			instance.asyncDep.catch((err) => {
-				handleError(err, instance, 0);
+				handleError(err, instance, 0, false, true);
+				return () => null;
 			}).then((asyncSetupResult) => {
-				if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) return;
+				if (instance.isUnmounted || suspense.isUnmounted) return;
+				const isPendingDep = isInPendingSuspense && suspense.pendingId === instance.suspenseId;
 				setCurrentInstance(null, void 0);
 				if (!instance.scope.active) {
-					if (isInPendingSuspense && --suspense.deps === 0) suspense.resolve();
+					if (isPendingDep && --suspense.deps === 0) suspense.resolve();
 					return;
 				}
-				instance.asyncResolved = true;
-				onResolve(asyncSetupResult);
-				if (isInPendingSuspense && --suspense.deps === 0) suspense.resolve();
+				if (!isPendingDep && suspense.pendingBranch) {
+					const job = () => {
+						if (instance.isUnmounted || suspense.isUnmounted || !instance.scope.active) return;
+						if (suspense.pendingBranch) queueEffectWithSuspense(job, void 0, suspense);
+						else render(asyncSetupResult);
+					};
+					job.flags = 24;
+					queueEffectWithSuspense(job, void 0, suspense);
+					return;
+				}
+				render(asyncSetupResult);
+				if (isPendingDep && --suspense.deps === 0) suspense.resolve();
 			});
 		},
 		unmount(parentSuspense, doRemove) {
 			suspense.isUnmounted = true;
+			clearTimeout(suspense.timeoutTimer);
+			suspense.timeoutTimer = void 0;
+			if (parentSuspenseId !== void 0) {
+				const parent = suspense.parent;
+				const pendingId = parentSuspenseId;
+				parentSuspenseId = void 0;
+				queuePostFlushCb(() => {
+					if (parent.pendingId === pendingId && !parent.isUnmounted && --parent.deps === 0) parent.resolve();
+				});
+			}
 			if (suspense.activeBranch) unmount(suspense.activeBranch, parentComponent, parentSuspense, doRemove);
-			if (suspense.pendingBranch) unmount(suspense.pendingBranch, parentComponent, parentSuspense, doRemove);
+			if (suspense.pendingBranch) {
+				unmount(suspense.pendingBranch, parentComponent, suspense, doRemove);
+				discardEffects(suspense);
+			}
 		}
 	};
 	return suspense;
@@ -7730,6 +7960,14 @@ function normalizeSuspenseSlot(s) {
 	if (block && !s.dynamicChildren) s.dynamicChildren = block.filter((c) => c !== s);
 	return s;
 }
+function discardEffects(suspense) {
+	const { effects } = suspense;
+	for (let i = 0; i < effects.length; i++) {
+		const effect = effects[i];
+		if (effect.flags & 8) queuePostFlushCb(effect);
+	}
+	effects.length = 0;
+}
 function queueEffectWithSuspense(fn, id, suspense) {
 	if (suspense && suspense.pendingBranch) {
 		if (isArray(fn)) suspense.effects.push(...fn);
@@ -7960,7 +8198,8 @@ function _createVNode(type, props = null, children = null, patchFlag = 0, dynami
 }
 function guardReactiveProps(props) {
 	if (!props) return null;
-	return /* @__PURE__ */ isProxy(props) || isInternalObject(props) ? extend({}, props) : props;
+	if (/* @__PURE__ */ isProxy(props)) return extend({}, props);
+	return isInternalObject(props) ? extend({}, props[rawAttrsKey] || props) : props;
 }
 function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false) {
 	const { props, ref, patchFlag, children, transition } = vnode;
@@ -8065,6 +8304,17 @@ function normalizeVNode(child) {
 function cloneIfMounted(child) {
 	return child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child);
 }
+let deferElementSlots = false;
+/**
+* While enabled, compiled default slots passed as children of plain elements
+* are kept on the vnode so the server renderer can render them in push mode.
+* @internal
+*/
+function setDeferElementSlots(value) {
+	const prev = deferElementSlots;
+	deferElementSlots = value;
+	return prev;
+}
 function normalizeChildren(vnode, children) {
 	let type = 0;
 	const { shapeFlag } = vnode;
@@ -8073,6 +8323,11 @@ function normalizeChildren(vnode, children) {
 	else if (typeof children === "object") {
 		if (shapeFlag & 65) {
 			const slot = children.default;
+			if (deferElementSlots && slot && slot._c && shapeFlag & 1) {
+				vnode.children = children;
+				vnode.shapeFlag |= 32;
+				return;
+			}
 			if (slot) {
 				slot._c && (slot._d = false);
 				normalizeChildren(vnode, slot());
@@ -8324,7 +8579,8 @@ function setupStatefulComponent(instance, isSSR) {
 					setInSSRSetupState(false);
 				}
 			}).catch((e) => {
-				handleError(e, instance, 0);
+				handleError(e, instance, 0, void 0, true);
+				instance.ssrRender = (_, push) => push("<!---->");
 			});
 			else instance.asyncDep = setupResult;
 		} else handleSetupResult(instance, setupResult, isSSR);
@@ -8382,9 +8638,14 @@ function finishComponentSetup(instance, isSSR, skipOptions) {
 		}
 	}
 }
+/**
+* Read through the setup context `attrs` proxy to get the raw attrs object.
+* @internal
+*/
+const rawAttrsKey = Symbol();
 const attrsProxyHandlers = { get(target, key) {
 	track(target, "get", "");
-	return target[key];
+	return key === rawAttrsKey ? target : target[key];
 } };
 function createSetupContext(instance) {
 	return {
@@ -8468,7 +8729,7 @@ function isMemoSame(cached, memo) {
 }
 //#endregion
 //#region packages/runtime-core/src/index.ts
-const version = "3.6.0-rc.13";
+const version = "3.6.0-rc.15";
 const warn = NOOP;
 /**
 * Runtime error messages. Only exposed in dev or esm builds.
@@ -8493,7 +8754,8 @@ const ssrUtils = {
 	popWarningContext,
 	VaporSlot,
 	rawVaporSlotKey,
-	invokeSlotFallback
+	invokeSlotFallback,
+	setDeferElementSlots
 };
 /**
 * @internal only exposed in compat builds
@@ -9836,15 +10098,15 @@ const vModelSelect = {
 		vModelSelectInit(el, value, number);
 		el[assignKey] = getModelAssigner(vnode);
 	},
-	mounted(el, { value }) {
-		vModelSetSelected(el, value);
+	mounted(el, { value, modifiers: { number } }) {
+		vModelSetSelected(el, value, number);
 	},
 	beforeUpdate(el, { value }, vnode) {
 		el._modelValue = value;
 		el[assignKey] = getModelAssigner(vnode);
 	},
-	updated(el, { value }) {
-		vModelSetSelected(el, value);
+	updated(el, { value, modifiers: { number } }) {
+		vModelSetSelected(el, value, number);
 	}
 };
 /**
@@ -9879,14 +10141,14 @@ function isSameSelectValue(value, assignedValue, multiple) {
 /**
 * @internal
 */
-const vModelSetSelected = (el, value) => {
+const vModelSetSelected = (el, value, number = false) => {
 	el._modelValue = value;
 	const pending = el._pendingValue;
 	el._pendingValue = void 0;
 	if (pending && pending[0] === el.multiple && isSameSelectValue(value, pending[1], pending[0])) return;
-	setSelected(el, value);
+	setSelected(el, value, number);
 };
-function setSelected(el, value) {
+function setSelected(el, value, number) {
 	const isMultiple = el.multiple;
 	const isArrayValue = isArray(value);
 	if (isMultiple && !isArrayValue && !isSet(value)) return;
@@ -9898,7 +10160,7 @@ function setSelected(el, value) {
 				const optionType = typeof optionValue;
 				if (optionType === "string" || optionType === "number") option.selected = value.some((v) => String(v) === String(optionValue));
 				else option.selected = looseIndexOf(value, optionValue) > -1;
-			} else option.selected = value.has(optionValue);
+			} else option.selected = value.has(optionValue) || number && typeof optionValue === "string" && value.has(looseToNumber(optionValue));
 		} else if (looseEqual(getValue(option), value)) {
 			if (el.selectedIndex !== i) el.selectedIndex = i;
 			return;
@@ -12101,7 +12363,15 @@ const nonIdentifierRE = /^$|^\d|[^\$\w\xA0-\uFFFF]/;
 const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
 const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
 const getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source;
+const asciiIdentifierRE = /^[A-Za-z_$][\w$]*$/;
+const isReservedWord = /*@__PURE__*/ makeMap("await,break,case,catch,class,const,continue,debugger,default,delete,do,else,enum,export,extends,false,finally,for,function,if,implements,import,in,instanceof,interface,let,new,null,package,private,protected,public,return,static,super,switch,this,throw,true,try,typeof,undefined,var,void,while,with,yield");
+const isUnparsedIdentifier = (exp) => {
+	if (exp.ast !== null) return false;
+	const content = getExpSource(exp);
+	return asciiIdentifierRE.test(content) && !isReservedWord(content);
+};
 const isMemberExpressionNode = (exp, context) => {
+	if (isUnparsedIdentifier(exp)) return true;
 	try {
 		let ret = exp.ast || (0, _babel_parser.parseExpression)(getExpSource(exp), { plugins: context.expressionPlugins ? [...context.expressionPlugins, "typescript"] : ["typescript"] });
 		ret = unwrapTSNode(ret);
@@ -12112,6 +12382,7 @@ const isMemberExpressionNode = (exp, context) => {
 };
 const isMemberExpression = isMemberExpressionNode;
 const isFnExpressionNode = (exp, context) => {
+	if (isUnparsedIdentifier(exp)) return false;
 	try {
 		let ret = exp.ast || (0, _babel_parser.parseExpression)(getExpSource(exp), { plugins: context.expressionPlugins ? [...context.expressionPlugins, "typescript"] : ["typescript"] });
 		if (ret.type === "Program") {
@@ -12744,7 +13015,11 @@ function getLoc(start, end) {
 	};
 }
 function cloneLoc(loc) {
-	return getLoc(loc.start.offset, loc.end.offset);
+	return {
+		start: extend({}, loc.start),
+		end: extend({}, loc.end),
+		source: loc.source
+	};
 }
 function setLocEnd(loc, end) {
 	loc.end = tokenizer.getPos(end);
@@ -15516,7 +15791,7 @@ const stringifyStatic = (children, context, parent) => {
 	for (; i < children.length; i++) {
 		const child = children[i];
 		if (isParentCached || getCachedNode(child)) {
-			const result = analyzeNode(child);
+			const result = analyzeNode(child, context);
 			if (result) {
 				nc += result[0];
 				ec += result[1];
@@ -15546,7 +15821,7 @@ const isNonStringifiable = /*@__PURE__*/ makeMap(`caption,thead,tr,th,tbody,td,t
 *   - nc is the number of nodes inside
 *   - ec is the number of element with bindings inside
 */
-function analyzeNode(node) {
+function analyzeNode(node, context) {
 	if (node.type === 1 && isNonStringifiable(node.tag)) return false;
 	if (node.type === 1 && findDir(node, "once", true)) return false;
 	if (node.type === 12) return [1, 0];
@@ -15565,6 +15840,7 @@ function analyzeNode(node) {
 			if (p.type === 7 && p.name === "bind") {
 				if (p.arg && (p.arg.type === 8 || p.arg.isStatic && !isStringifiableAttr(p.arg.content, node.ns))) return bail();
 				if (p.exp && (p.exp.type === 8 || p.exp.constType < 3)) return bail();
+				if (p.arg && p.arg.isStatic && (isBooleanAttr(p.arg.content) || p.arg.content === "hidden") && context.isCustomElement(node.tag)) return bail();
 				if (isOptionTag && isStaticArgOf(p.arg, "value") && p.exp && !p.exp.isStatic) return bail();
 			}
 		}
@@ -15609,11 +15885,10 @@ function stringifyElement(node, context) {
 					res += ` ${p.arg.content}="__VUE_EXP_START__${exp.content}__VUE_EXP_END__"`;
 					continue;
 				}
-				if ((isBooleanAttr(p.arg.content) || p.arg.content === "hidden") && exp.content === "false") continue;
 				let evaluated = evaluateConstant(exp);
 				if (evaluated != null) {
-					const arg = p.arg && p.arg.content;
-					if (arg === "hidden" && typeof evaluated === "number" && !includeBooleanAttr(evaluated)) continue;
+					const arg = p.arg.content;
+					if ((isBooleanAttr(arg) || arg === "hidden") && !includeBooleanAttr(evaluated)) continue;
 					if (arg === "class") evaluated = normalizeClass(evaluated);
 					else if (arg === "style") evaluated = stringifyStyle(normalizeStyle(evaluated));
 					res += ` ${p.arg.content}="${escapeHtml(evaluated)}"`;