@vue/runtime-dom 3.6.0-rc.14 → 3.6.0-rc.15

package/dist/runtime-dom.global.js

@@ -1,5 +1,5 @@
 /**
-  * @vue/runtime-dom v3.6.0-rc.14
+  * @vue/runtime-dom v3.6.0-rc.15
   * (c) 2018-present Yuxi (Evan) You and Vue contributors
   * @license MIT
   **/
@@ -60,10 +60,18 @@ var VueRuntimeDOM = (function(exports) {
 	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;
@@ -71,22 +79,22 @@ var VueRuntimeDOM = (function(exports) {
 	/**
 	* @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)}` : ``;
 	});
 	/**
@@ -212,26 +220,11 @@ var VueRuntimeDOM = (function(exports) {
 	* Do NOT use in runtime code paths unless behind `__DEV__` flag.
 	*/
 	const isMathMLTag = /*@__PURE__*/ makeMap(MATH_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: '' }`
@@ -442,40 +435,16 @@ var VueRuntimeDOM = (function(exports) {
 		}
 		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
@@ -487,13 +456,7 @@ var VueRuntimeDOM = (function(exports) {
 	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;
@@ -542,6 +505,7 @@ var VueRuntimeDOM = (function(exports) {
 		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;
@@ -549,7 +513,7 @@ var VueRuntimeDOM = (function(exports) {
 		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
@@ -567,14 +531,12 @@ var VueRuntimeDOM = (function(exports) {
 			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) {
@@ -610,7 +572,7 @@ var VueRuntimeDOM = (function(exports) {
 	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) {
@@ -618,8 +580,11 @@ var VueRuntimeDOM = (function(exports) {
 		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;
@@ -641,45 +606,67 @@ var VueRuntimeDOM = (function(exports) {
 		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;
@@ -687,9 +674,21 @@ var VueRuntimeDOM = (function(exports) {
 				}
 				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;
@@ -707,6 +706,71 @@ var VueRuntimeDOM = (function(exports) {
 		}
 		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 {
@@ -766,20 +830,12 @@ var VueRuntimeDOM = (function(exports) {
 		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);
@@ -809,6 +865,14 @@ var VueRuntimeDOM = (function(exports) {
 				}
 			}
 		}
+		endTrigger({
+			target,
+			type,
+			key,
+			newValue,
+			oldValue,
+			oldTarget
+		});
 		endBatch();
 	}
 	function getDepFromReactive(object, key) {
@@ -1023,7 +1087,7 @@ var VueRuntimeDOM = (function(exports) {
 	//#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);
@@ -1607,16 +1671,16 @@ var VueRuntimeDOM = (function(exports) {
 				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();
 				}
 			}
 		}
@@ -1653,8 +1717,10 @@ var VueRuntimeDOM = (function(exports) {
 	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();
 		}
 	}
@@ -1845,6 +1911,10 @@ var VueRuntimeDOM = (function(exports) {
 		get active() {
 			return !(this.flags & 1024);
 		}
+		/** @internal */
+		get running() {
+			return !!(this.flags & 4);
+		}
 		pause() {
 			this.flags |= 256;
 		}
@@ -1858,11 +1928,9 @@ var VueRuntimeDOM = (function(exports) {
 			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) {
@@ -1885,9 +1953,9 @@ var VueRuntimeDOM = (function(exports) {
 			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;
 		}
@@ -1899,20 +1967,17 @@ var VueRuntimeDOM = (function(exports) {
 		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();
@@ -1972,8 +2037,10 @@ var VueRuntimeDOM = (function(exports) {
 			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();
 				}
 			}
@@ -2002,8 +2069,10 @@ var VueRuntimeDOM = (function(exports) {
 			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);
@@ -2044,11 +2113,14 @@ var VueRuntimeDOM = (function(exports) {
 	* @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
@@ -2097,12 +2169,24 @@ var VueRuntimeDOM = (function(exports) {
 		}
 		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,
@@ -2110,7 +2194,18 @@ var VueRuntimeDOM = (function(exports) {
 					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) {
@@ -2122,11 +2217,15 @@ var VueRuntimeDOM = (function(exports) {
 			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);
 			}
@@ -2147,6 +2246,7 @@ var VueRuntimeDOM = (function(exports) {
 			cRef.onTrack = debugOptions.onTrack;
 			cRef.onTrigger = debugOptions.onTrigger;
 		}
+		if (isSSR && activeEffectScope !== void 0) link(cRef, activeEffectScope);
 		return cRef;
 	}
 	//#endregion
@@ -2517,7 +2617,7 @@ var VueRuntimeDOM = (function(exports) {
 		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;
 		}
@@ -2527,7 +2627,7 @@ var VueRuntimeDOM = (function(exports) {
 			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;
@@ -2535,7 +2635,7 @@ var VueRuntimeDOM = (function(exports) {
 			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;
@@ -2840,7 +2940,11 @@ var VueRuntimeDOM = (function(exports) {
 		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(() => {
@@ -2881,7 +2985,25 @@ var VueRuntimeDOM = (function(exports) {
 				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 {
@@ -2892,7 +3014,12 @@ var VueRuntimeDOM = (function(exports) {
 							}
 						}
 					});
-				});
+					queuePostFlushCb(() => {
+						hmrDirtyComponents.clear();
+						hmrDirtyComponentsMode.clear();
+					});
+				};
+				queueJob(update);
 			});
 		}
 		queuePostFlushCb(() => {
@@ -3089,18 +3216,35 @@ var VueRuntimeDOM = (function(exports) {
 		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) {
 				const prevSub = setActiveSub();
 				callWithAsyncErrorHandling(hook, instance, 8, [
 					vnode.el,
 					binding,
-					vnode,
+					hookVNode,
 					prevVNode
 				]);
 				setActiveSub(prevSub);
@@ -3521,7 +3665,15 @@ var VueRuntimeDOM = (function(exports) {
 				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);
 			};
 		}
@@ -3551,7 +3703,7 @@ var VueRuntimeDOM = (function(exports) {
 		}
 		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({
@@ -3574,9 +3726,7 @@ var VueRuntimeDOM = (function(exports) {
 				}
 			},
 			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, {
@@ -3614,7 +3764,7 @@ var VueRuntimeDOM = (function(exports) {
 				callHook(hook, [el]);
 			},
 			enter(el) {
-				if (!isHmrUpdating && isLeaving()) return;
+				if (!isHmrUpdating && isLeaving(el)) return;
 				let hook = onEnter;
 				let afterHook = onAfterEnter;
 				let cancelHook = onEnterCancelled;
@@ -3658,7 +3808,19 @@ var VueRuntimeDOM = (function(exports) {
 				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;
@@ -3693,10 +3855,7 @@ var VueRuntimeDOM = (function(exports) {
 		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;
@@ -3762,9 +3921,14 @@ var VueRuntimeDOM = (function(exports) {
 				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)) {
@@ -3983,7 +4147,7 @@ var VueRuntimeDOM = (function(exports) {
 	};
 	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) => {
@@ -4001,7 +4165,7 @@ var VueRuntimeDOM = (function(exports) {
 		};
 		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;
@@ -4190,10 +4354,11 @@ var VueRuntimeDOM = (function(exports) {
 			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;
 			}
 		};
@@ -4215,13 +4380,13 @@ var VueRuntimeDOM = (function(exports) {
 			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);
@@ -4484,7 +4649,7 @@ var VueRuntimeDOM = (function(exports) {
 	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) {
@@ -4521,7 +4686,7 @@ var VueRuntimeDOM = (function(exports) {
 				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 || false) return load().then((comp) => {
 					return () => createInnerComp(comp, instance);
@@ -4602,10 +4767,12 @@ var VueRuntimeDOM = (function(exports) {
 		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;
@@ -4640,7 +4807,12 @@ var VueRuntimeDOM = (function(exports) {
 				}
 				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 ? () => {
@@ -4694,7 +4866,11 @@ var VueRuntimeDOM = (function(exports) {
 				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);
@@ -4726,11 +4902,15 @@ var VueRuntimeDOM = (function(exports) {
 			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);
@@ -4835,9 +5015,8 @@ var VueRuntimeDOM = (function(exports) {
 	}
 	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;
@@ -5045,6 +5224,11 @@ var VueRuntimeDOM = (function(exports) {
 				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;
 		}
@@ -6845,8 +7029,10 @@ var VueRuntimeDOM = (function(exports) {
 			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(() => {
@@ -7103,16 +7289,20 @@ var VueRuntimeDOM = (function(exports) {
 				} 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;
 						}
@@ -7135,7 +7325,7 @@ var VueRuntimeDOM = (function(exports) {
 					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);
@@ -7338,9 +7528,7 @@ var VueRuntimeDOM = (function(exports) {
 			}
 			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);
@@ -7420,12 +7608,14 @@ var VueRuntimeDOM = (function(exports) {
 			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);
-			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) => {
@@ -7539,11 +7729,11 @@ var VueRuntimeDOM = (function(exports) {
 			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) {
@@ -7613,7 +7803,9 @@ var VueRuntimeDOM = (function(exports) {
 	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
@@ -7625,17 +7817,22 @@ var VueRuntimeDOM = (function(exports) {
 		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);
 			}
@@ -7647,6 +7844,36 @@ var VueRuntimeDOM = (function(exports) {
 		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");
@@ -7686,11 +7913,7 @@ var VueRuntimeDOM = (function(exports) {
 					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);
@@ -7713,14 +7936,14 @@ var VueRuntimeDOM = (function(exports) {
 		} 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);
 			}
@@ -7756,6 +7979,7 @@ var VueRuntimeDOM = (function(exports) {
 			deps: 0,
 			pendingId: suspenseId++,
 			timeout: typeof timeout === "number" ? timeout : -1,
+			timeoutTimer: void 0,
 			activeBranch: null,
 			isFallbackMountPending: false,
 			pendingBranch: null,
@@ -7773,26 +7997,39 @@ var VueRuntimeDOM = (function(exports) {
 					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) {
@@ -7815,13 +8052,13 @@ var VueRuntimeDOM = (function(exports) {
 				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);
@@ -7845,24 +8082,52 @@ var VueRuntimeDOM = (function(exports) {
 			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;
@@ -7903,6 +8168,14 @@ var VueRuntimeDOM = (function(exports) {
 		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);
@@ -8127,7 +8400,8 @@ var VueRuntimeDOM = (function(exports) {
 	}
 	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;
@@ -8513,7 +8787,8 @@ var VueRuntimeDOM = (function(exports) {
 						setInSSRSetupState(false);
 					}
 				}).catch((e) => {
-					handleError(e, instance, 0);
+					handleError(e, instance, 0, void 0, true);
+					instance.ssrRender = (_, push) => push("<!---->");
 				});
 				else {
 					instance.asyncDep = setupResult;
@@ -8582,11 +8857,16 @@ var VueRuntimeDOM = (function(exports) {
 			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.`);
@@ -8884,7 +9164,7 @@ var VueRuntimeDOM = (function(exports) {
 	}
 	//#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.
@@ -9705,7 +9985,7 @@ var VueRuntimeDOM = (function(exports) {
 				}
 				this._styleAnchors.delete(this._def);
 				this._applyStyles(newStyles);
-				if (!this._instance.vapor) this._instance = null;
+				this._instance = null;
 				this._update();
 			};
 			const dispatch = (event, args) => {
@@ -10302,15 +10582,15 @@ var VueRuntimeDOM = (function(exports) {
 			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);
 		}
 	};
 	/**
@@ -10345,14 +10625,14 @@ var VueRuntimeDOM = (function(exports) {
 	/**
 	* @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)) {
@@ -10367,7 +10647,7 @@ var VueRuntimeDOM = (function(exports) {
 					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;