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

package/dist/vue.cjs.js

@@ -1,5 +1,5 @@
 /**
-  * @vue/compat v3.6.0-rc.14
+  * @vue/compat v3.6.0-rc.15
   * (c) 2018-present Yuxi (Evan) You and Vue contributors
   * @license MIT
   **/
@@ -73,10 +73,18 @@ const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" &
 const isReservedProp = /*@__PURE__*/ makeMap(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted");
 const isBuiltInTag = /*#__PURE__*/ makeMap("slot,component");
 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;
@@ -84,22 +92,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)}` : ``;
 });
 /**
@@ -307,26 +315,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: '' }`
@@ -575,40 +568,16 @@ function isVaporBranchStart(data) {
 	}
 	return true;
 }
-//#endregion
-//#region packages/reactivity/src/debug.ts
-const triggerEventInfos = [];
-function onTrack(sub, debugInfo) {
-	if (sub.onTrack) sub.onTrack(extend({ effect: sub }, debugInfo));
-}
-function onTrigger(sub) {
-	if (sub.onTrigger) {
-		const debugInfo = triggerEventInfos[triggerEventInfos.length - 1];
-		sub.onTrigger(extend({ effect: sub }, debugInfo));
-	}
+/**
+* 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);
 }
-function setupOnTrigger(target) {
-	Object.defineProperty(target.prototype, "onTrigger", {
-		get() {
-			return this._onTrigger;
-		},
-		set(val) {
-			if (val && !this._onTrigger) setupFlagsHandler(this);
-			this._onTrigger = val;
-		}
-	});
-}
-function setupFlagsHandler(target) {
-	target._flags = target.flags;
-	Object.defineProperty(target, "flags", {
-		get() {
-			return target._flags;
-		},
-		set(value) {
-			if (!(target._flags & 48) && !!(value & 48)) onTrigger(this);
-			target._flags = value;
-		}
-	});
+/** The data of the comment closing the range `open` opens. */
+function rangeCloseOf(open) {
+	return open === "(" ? ")" : open === "{" ? "}" : "]";
 }
 //#endregion
 //#region packages/reactivity/src/warning.ts
@@ -620,13 +589,7 @@ function warn$2(msg, ...args) {
 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;
@@ -675,6 +638,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;
@@ -682,7 +646,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
@@ -700,14 +664,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) {
@@ -743,7 +705,7 @@ 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) {
@@ -751,8 +713,11 @@ 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;
@@ -774,45 +739,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;
@@ -820,9 +807,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;
@@ -840,6 +839,71 @@ 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/debug.ts
+const triggered = [];
+function onTrack(sub, debugInfo) {
+	if (sub.onTrack) sub.onTrack(extend({ effect: sub }, debugInfo));
+}
+function onTrigger(sub, debugInfo) {
+	if (sub.onTrigger) sub.onTrigger(extend({ effect: sub }, debugInfo));
+}
+function startTrigger() {
+	triggered.push([]);
+}
+function endTrigger(debugInfo) {
+	const subs = triggered.pop();
+	if (subs.length) {
+		startBatch();
+		try {
+			for (let i = 0; i < subs.length; i++) {
+				const sub = subs[i];
+				if (sub.flags & 3) onTrigger(sub, debugInfo);
+			}
+		} finally {
+			endBatch();
+		}
+	}
+}
+function setupOnTrigger(target) {
+	Object.defineProperty(target.prototype, "onTrigger", {
+		get() {
+			return this._onTrigger;
+		},
+		set(val) {
+			if (val && !this._onTrigger) setupFlagsHandler(this);
+			this._onTrigger = val;
+		}
+	});
+}
+function setupFlagsHandler(target) {
+	target._flags = target.flags;
+	Object.defineProperty(target, "flags", {
+		get() {
+			return target._flags;
+		},
+		set(value) {
+			if (!(target._flags & 48) && !!(value & 48)) {
+				if (triggered.length) triggered[triggered.length - 1].push(this);
+				else onTrigger(this);
+			}
+			target._flags = value;
+		}
+	});
+}
 //#endregion
 //#region packages/reactivity/src/dep.ts
 var Dep = class {
@@ -899,20 +963,12 @@ function trigger(target, type, key, newValue, oldValue, oldTarget) {
 	if (!depsMap) return;
 	const run = (dep) => {
 		if (dep !== void 0 && dep.subs !== void 0) {
-			triggerEventInfos.push({
-				target,
-				type,
-				key,
-				newValue,
-				oldValue,
-				oldTarget
-			});
 			propagate(dep.subs);
 			shallowPropagate(dep.subs);
-			triggerEventInfos.pop();
 		}
 	};
 	startBatch();
+	startTrigger();
 	if (type === "clear") depsMap.forEach(run);
 	else {
 		const targetIsArray = isArray(target);
@@ -942,6 +998,14 @@ function trigger(target, type, key, newValue, oldValue, oldTarget) {
 			}
 		}
 	}
+	endTrigger({
+		target,
+		type,
+		key,
+		newValue,
+		oldValue,
+		oldTarget
+	});
 	endBatch();
 }
 function getDepFromReactive(object, key) {
@@ -1156,7 +1220,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);
@@ -1740,16 +1804,16 @@ var RefImpl = class {
 			this._value = !useDirectValue && this._wrap ? this._wrap(newValue) : newValue;
 			const subs = this.subs;
 			if (subs !== void 0) {
-				triggerEventInfos.push({
+				startTrigger();
+				propagate(subs);
+				endTrigger({
 					target: this,
 					type: "set",
 					key: "value",
 					newValue,
 					oldValue
 				});
-				propagate(subs);
 				if (!batchDepth) flush();
-				triggerEventInfos.pop();
 			}
 		}
 	}
@@ -1786,8 +1850,10 @@ var RefImpl = class {
 function triggerRef(ref) {
 	const dep = ref.dep;
 	if (dep !== void 0 && dep.subs !== void 0) {
+		startTrigger();
 		propagate(dep.subs);
 		shallowPropagate(dep.subs);
+		endTrigger();
 		if (!batchDepth) flush();
 	}
 }
@@ -1978,6 +2044,10 @@ var ReactiveEffect = class {
 	get active() {
 		return !(this.flags & 1024);
 	}
+	/** @internal */
+	get running() {
+		return !!(this.flags & 4);
+	}
 	pause() {
 		this.flags |= 256;
 	}
@@ -1991,11 +2061,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) {
@@ -2018,9 +2086,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;
 	}
@@ -2032,20 +2100,17 @@ 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();
+		};
+		e.onTrack = options.onTrack;
+		e.onTrigger = options.onTrigger;
 	}
 	try {
 		e.run();
@@ -2105,8 +2170,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();
 			}
 		}
@@ -2135,8 +2202,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);
@@ -2177,11 +2246,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;
-	else if (!failSilently) warn$2("onScopeDispose() is called when there is no active effect scope to be associated with.");
+	if (activeEffectScope !== void 0) {
+		if (activeEffectScope.active) activeEffectScope.cleanups[activeEffectScope.cleanupsLength++] = fn;
+		else fn();
+	} else if (!failSilently) warn$2("onScopeDispose() is called when there is no active effect scope to be associated with.");
 }
 //#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
@@ -2230,12 +2302,24 @@ 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) {
+				onTrack(activeSub, {
+					target: this,
+					type: "get",
+					key: "value"
+				});
+				link(this, activeSub);
+			} else if (activeEffectScope !== void 0) link(this, activeEffectScope);
+			throw err;
+		}
 		if (activeSub !== void 0) {
 			onTrack(activeSub, {
 				target: this,
@@ -2243,7 +2327,18 @@ var ComputedRefImpl = class {
 				key: "value"
 			});
 			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) {
@@ -2255,11 +2350,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);
 		}
@@ -2280,6 +2379,7 @@ function computed$1(getterOrOptions, debugOptions, isSSR = false) {
 		cRef.onTrack = debugOptions.onTrack;
 		cRef.onTrigger = debugOptions.onTrigger;
 	}
+	if (isSSR && activeEffectScope !== void 0) link(cRef, activeEffectScope);
 	return cRef;
 }
 //#endregion
@@ -2650,7 +2750,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;
 	}
@@ -2660,7 +2760,7 @@ function callWithAsyncErrorHandling(fn, instance, type, args) {
 		return values;
 	} else warn$1(`Invalid value type passed to callWithAsyncErrorHandling(): ${typeof fn}`);
 }
-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;
@@ -2668,7 +2768,7 @@ function handleError(err, instance, type, throwInDev = true) {
 		const errorInfo = ErrorTypeStrings$1[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;
@@ -2973,7 +3073,11 @@ function reload(id, newComp) {
 	updateComponentDef(record.initialDef, newComp);
 	const instances = [...record.instances];
 	if (isVapor && newComp.__vapor && !instances.some((instance) => instance.parent && !instance.parent.vapor) && !instances.some((i) => i.ceReload)) {
-		for (const instance of instances) if (instance.root && instance.root.ce && instance !== instance.root) instance.root.ce._removeChildStyle(instance.type);
+		for (const instance of instances) {
+			if (instance.root && instance.root.ce && instance !== instance.root) instance.root.ce._removeChildStyle(instance.type);
+			const oldComp = normalizeClassComponent(instance.type);
+			if (oldComp !== record.initialDef) updateComponentDef(oldComp, newComp);
+		}
 		const dirtyInstances = new Set(instances);
 		const rerenderedParents = /* @__PURE__ */ new Set();
 		runWithHmrUpdating(() => {
@@ -3014,7 +3118,25 @@ function reload(id, newComp) {
 			if (instance.root.ce && instance !== instance.root) instance.root.ce._removeChildStyle(oldComp);
 		}
 		parents.forEach((parent) => {
-			queueJob(() => {
+			const children = instances.filter((instance) => instance.parent === parent);
+			const update = () => {
+				if (!parent.scope.active) return;
+				const activeChildren = children.filter((instance) => instance.scope.active);
+				if (!activeChildren.length) return;
+				const pending = activeChildren.find((instance) => instance.asyncDep && !instance.asyncResolved) || locateUnresolvedAsyncRoot(parent);
+				if (pending) {
+					pending.asyncDep.catch(NOOP).then(() => {
+						if (parent.scope.active && (pending.asyncResolved || !pending.scope.active)) queueJob(update);
+					});
+					return;
+				}
+				for (const instance of activeChildren) {
+					const oldComp = normalizeClassComponent(instance.type);
+					let dirtyInstances = hmrDirtyComponents.get(oldComp);
+					if (!dirtyInstances) hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set());
+					dirtyInstances.add(instance);
+					hmrDirtyComponentsMode.set(oldComp, !!isVapor);
+				}
 				runWithHmrUpdating(() => {
 					if (parent.vapor) parent.hmrRerender();
 					else {
@@ -3025,7 +3147,12 @@ function reload(id, newComp) {
 						}
 					}
 				});
-			});
+				queuePostFlushCb(() => {
+					hmrDirtyComponents.clear();
+					hmrDirtyComponentsMode.clear();
+				});
+			};
+			queueJob(update);
 		});
 	}
 	queuePostFlushCb(() => {
@@ -3574,11 +3701,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) {
@@ -3586,7 +3730,7 @@ function invokeDirectiveHook(vnode, prevVNode, instance, name) {
 			callWithAsyncErrorHandling(hook, instance, 8, [
 				vnode.el,
 				binding,
-				vnode,
+				hookVNode,
 				prevVNode
 			]);
 			setActiveSub(prevSub);
@@ -4029,7 +4173,15 @@ const BaseTransitionImpl = {
 			const { mode } = rawProps;
 			checkTransitionMode(mode);
 			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);
 		};
 	}
@@ -4060,7 +4212,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({
@@ -4083,9 +4235,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, {
@@ -4123,7 +4273,7 @@ function baseResolveTransitionHooks(context, props, state, instance) {
 			callHook(hook, [el]);
 		},
 		enter(el) {
-			if (!isHmrUpdating && isLeaving()) return;
+			if (!isHmrUpdating && isLeaving(el)) return;
 			let hook = onEnter;
 			let afterHook = onAfterEnter;
 			let cancelHook = onEnterCancelled;
@@ -4167,7 +4317,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;
@@ -4202,10 +4364,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;
@@ -4271,9 +4430,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)) {
@@ -4492,7 +4656,7 @@ const getContainerType = (container) => {
 };
 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 === "(" || isVaporBranchStart(data);
+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) => {
@@ -4510,7 +4674,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 === "(" || isVaporInteropEnabled && isVaporBranchStart(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;
@@ -4699,10 +4863,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;
 		}
 	};
@@ -4724,13 +4889,13 @@ 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);
@@ -4993,7 +5158,7 @@ const hydrateOnInteraction = (interactions = []) => (hydrate, forEach) => {
 function forEachElement(node, cb) {
 	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) {
@@ -5030,7 +5195,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);
@@ -5111,10 +5276,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;
@@ -5149,7 +5316,12 @@ function performAsyncHydrate(el, instance, hydrate, getResolvedComp, load, hydra
 			}
 			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 ? () => {
@@ -5207,7 +5379,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);
@@ -5239,11 +5415,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);
@@ -5353,9 +5533,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;
@@ -5794,6 +5973,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;
 	}
@@ -6774,7 +6958,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.14`;
+	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);
@@ -8234,8 +8418,10 @@ function baseCreateRenderer(options, createHydrationFns) {
 		def(el, "__vnode", vnode, true);
 		def(el, "__vueParentComponent", parentComponent, true);
 		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) {
 			const isHmr = isHmrUpdating;
 			queuePostRenderEffect(() => {
@@ -8500,16 +8686,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;
 					}
@@ -8533,7 +8723,7 @@ function baseCreateRenderer(options, createHydrationFns) {
 				const prevTree = instance.subTree;
 				instance.subTree = nextTree;
 				startMeasure(instance, `patch`);
-				patch(prevTree, nextTree, hostParentNode(prevTree.el), getNextHostNode(prevTree), instance, parentSuspense, namespace);
+				patch(prevTree, nextTree, hostParentNode(prevTree.el || resolveAsyncComponentPlaceholder(prevTree)), getNextHostNode(prevTree), instance, parentSuspense, namespace);
 				endMeasure(instance, `patch`);
 				next.el = nextTree.el;
 				if (originNext === null) updateHOCHostEl(instance, nextTree.el);
@@ -8737,9 +8927,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);
@@ -8820,13 +9008,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);
 		devtoolsComponentRemoved(instance);
 	};
 	const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {
@@ -8940,11 +9130,11 @@ function traverseStaticChildren(n1, n2, shallow = false) {
 		c2.el && (c2.el.__vnode = c2);
 	}
 }
-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) {
@@ -9014,7 +9204,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
@@ -9026,17 +9218,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);
 		}
@@ -9048,6 +9245,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");
@@ -9087,11 +9314,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);
@@ -9114,14 +9337,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);
 		}
@@ -9157,6 +9380,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,
@@ -9174,26 +9398,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) {
@@ -9216,13 +9453,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);
@@ -9246,24 +9483,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;
@@ -9304,6 +9569,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);
@@ -9571,7 +9844,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;
@@ -9685,6 +9959,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;
@@ -9693,6 +9978,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());
@@ -9967,7 +10257,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;
@@ -10042,11 +10333,16 @@ function finishComponentSetup(instance, isSSR, skipOptions) {
 		else warn$1(`Component is missing template or render function: `, Component);
 	}
 }
+/**
+* Read through the setup context `attrs` proxy to get the raw attrs object.
+* @internal
+*/
+const rawAttrsKey = Symbol();
 const attrsProxyHandlers = {
 	get(target, key) {
 		markAttrsAccessed();
 		track(target, "get", "");
-		return target[key];
+		return key === rawAttrsKey ? target : target[key];
 	},
 	set() {
 		warn$1(`setupContext.attrs is readonly.`);
@@ -10344,7 +10640,7 @@ function isMemoSame(cached, memo) {
 }
 //#endregion
 //#region packages/runtime-core/src/index.ts
-const version = "3.6.0-rc.14";
+const version = "3.6.0-rc.15";
 const warn = warn$1;
 /**
 * Runtime error messages. Only exposed in dev or esm builds.
@@ -10370,7 +10666,8 @@ const ssrUtils = {
 	popWarningContext,
 	VaporSlot,
 	rawVaporSlotKey,
-	invokeSlotFallback
+	invokeSlotFallback,
+	setDeferElementSlots
 };
 /**
 * @internal only exposed in compat builds
@@ -11159,7 +11456,7 @@ var VueElementBase = class VueElementBase extends BaseClass {
 			}
 			this._styleAnchors.delete(this._def);
 			this._applyStyles(newStyles);
-			if (!this._instance.vapor) this._instance = null;
+			this._instance = null;
 			this._update();
 		};
 		const dispatch = (event, args) => {
@@ -11774,15 +12071,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);
 	}
 };
 /**
@@ -11817,14 +12114,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)) {
@@ -11839,7 +12136,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;
@@ -14807,7 +15104,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);
@@ -17634,7 +17935,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];
@@ -17664,7 +17965,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];
@@ -17683,6 +17984,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();
 			}
 		}
@@ -17727,11 +18029,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)}"`;